Фасад Cot в Cotonti 1.0: полное справочное руководство

Введение

Cotonti — это гибкая и расширяемая система управления контентом (CMF), которая предоставляет разработчикам множество инструментов для создания плагинов и модулей. Одним из ключевых классов, активно используемых в Cotonti 1.0, является фасад — класс Cot, который предоставляет унифицированный статический интерфейс для доступа к основным глобальным переменным системы. Это позволяет разработчикам обращаться к важным данным (конфигурации, базе данных, текущему пользователю и т.д.) без необходимости использовать ключевое слово global или суперглобальный массив $GLOBALS, что особенно удобно в объектно-ориентированном коде.

Данное руководство представляет собой подробный справочник по классу Cot, его свойствам, инициализации и особенностям использования. Оно основано на анализе исходного кода Cotonti (файлы system/Cot.php, system/common.php, system/router/Router.php) и официальной документации. Информация изложена максимально точно, без предположений и домыслов.

Мы детально рассмотрим:

• Понятие фасада в контексте Cotonti.
• Архитектуру класса Cot и его связь с глобальными переменными.
• Процесс инициализации фасада.
• Каждое статическое свойство фасада: назначение, тип данных, способы использования.
• Практические примеры применения в плагинах, модулях и контроллерах.
• Сравнение с традиционным подходом через global.
• Ограничения и лучшие практики.

Это руководство предназначено для разработчиков расширений, которые хотят эффективно использовать современные возможности Cotonti.

Что такое фасад в контексте Cotonti?

Фасад (от англ. Facade) — это структурный шаблон проектирования, который предоставляет простой интерфейс к сложной подсистеме, скрывая её внутреннюю структуру и упрощая взаимодействие с ней. В объектно-ориентированном программировании фасад обычно реализуется в виде класса с высокоуровневыми методами, которые делегируют вызовы к нижележащим компонентам.

В Cotonti класс Cot выполняет роль статического фасада для доступа к глобальным переменным системы. Исторически Cotonti (как и многие другие PHP-приложения того времени) широко использовала глобальные переменные для хранения состояния: $cfg — конфигурация, $db — соединение с базой данных, $usr — данные текущего пользователя и т.д. Такой подход прост, но имеет недостатки:

• В функциях и методах требуется явно объявлять global для доступа к этим переменным, что загромождает код.
• В объектно-ориентированных компонентах (контроллерах, сервисах) использование глобальных переменных нарушает принципы инкапсуляции и усложняет тестирование.
• Нет единой точки доступа, что затрудняет рефакторинг.

Разработчики Cotonti ввели класс Cot, который аккумулирует ссылки на все ключевые глобальные переменные в виде публичных статических свойств. Это даёт следующие преимущества:

• Простота доступа: вместо global $cfg; $cfg['mainurl'] можно написать Cot::$cfg['mainurl'].
• Единообразие: все важные переменные собраны в одном месте, что упрощает изучение API.
• Совместимость с ООП: статические свойства доступны из любого класса без необходимости внедрения зависимостей или глобальных объявлений.
• Обратная совместимость: поскольку свойства хранят ссылки на оригинальные глобальные переменные, все изменения через фасад немедленно отражаются на них и наоборот.

Важно понимать, что фасад Cot — это не копия данных, а именно ссылки на глобальные переменные. Это означает, что работа через Cot::$cfg эквивалентна работе с $GLOBALS['cfg'] или с $cfg внутри области видимости, где она объявлена как global.

В документации Cotonti прямо указано:

Обратите внимание, что все наиболее востребованные глобальные переменные ($cfg, $usr, $db, $id, $strucutre и пр.) доступны через специальный «фасад»-класс Cot. Таким образом нет необходимости использовать явное указание переменных в списке global, а можно обратиться к ним напрямую через свойство объекта: Cot::$cfg (например). Полный список переменных доступных через «фасад» следующий: $cache, $cfg, $cot_extrafields, $db, $db_x, $env, $L, $out, $R, $structure, $sys, $usr.

Это подтверждает, что фасад охватывает все наиболее часто используемые глобальные данные.

Архитектура фасада Cot

Класс Cot определён в файле system/Cot.php. Он состоит из:

• Набора публичных статических свойств, каждое из которых соответствует одной глобальной переменной.
• Статического метода init(), который привязывает эти свойства к глобальным переменным посредством ссылок.

Рассмотрим объявление класса (сокращённо, без docblock-комментариев для краткости):

class Cot
{
    public static $cache;
    public static $cfg;
    public static $db;
    public static $db_x;
    public static $env;
    public static $extrafields;
    public static $L;
    public static $out;
    public static $R;
    public static $structure;
    public static $sys;
    public static $usr;
    public static $currentRoute = null;

    public static function init()
    {
        global $cache, $cfg, $cot_extrafields, $db, $db_x, $env, $L, $out, $R, $structure, $sys, $usr;

        self::$cache       =& $cache;
        self::$cfg         =& $cfg;
        self::$db          =& $db;
        self::$db_x        =& $db_x;
        self::$env         =& $env;
        self::$extrafields =& $cot_extrafields;
        self::$L           =& $L;
        self::$out         =& $out;
        self::$R           =& $R;
        self::$structure   =& $structure;
        self::$sys         =& $sys;
        self::$usr         =& $usr;

        // ... дополнительная инициализация (регистрация таблиц и т.д.)
    }
}

Ключевые моменты:

1. Все свойства объявлены как public static, что делает их доступными из любого места через Cot::$имя_свойства.
2. Cot::$currentRoute инициализируется значением null и не участвует в init(). Оно предназначено для хранения текущего маршрута (объекта класса Route) и устанавливается в процессе маршрутизации.
3. Метод init() объявляет глобальные переменные с теми же именами, что и в традиционном коде Cotonti, и затем присваивает статическим свойствам ссылки (=&) на эти переменные. Благодаря ссылкам любые изменения глобальных переменных автоматически видны через фасад, и наоборот.
4. После вызова init() глобальные переменные и соответствующие статические свойства становятся синонимами одной и той же области памяти.

Обратите внимание на расхождение имён: глобальная переменная $cot_extrafields доступна через свойство Cot::$extrafields (без префикса cot_). Это сделано для краткости, но следует помнить о соответствии.

Архитектура фасада максимально проста: он не содержит бизнес-логики, только статические ссылки. Это позволяет использовать его как тонкий слой доступа к данным, не нарушая обратную совместимость.

Инициализация фасада

Фасад Cot должен быть инициализирован до того, как разработчики начнут обращаться к его свойствам. Инициализация выполняется однократно в файле system/common.php сразу после установки соединения с базой данных. В коде common.php это выглядит так:

// После создания $db (объект CotDB) и выполнения других подготовительных шагов
Cot::init();

Комментарий в коде гласит: // Here we can init our globals facade, что подчёркивает назначение метода.

Порядок инициализации

Для корректной работы фасада необходимо, чтобы соответствующие глобальные переменные существовали на момент вызова Cot::init(). В common.php к этому моменту уже определены:

• $cfg — конфигурация (загружается из файла datas/config.php и, возможно, из базы данных).
• $db — объект подключения к БД (создан ранее).
• $db_x — префикс таблиц (определён в конфигурационном файле).
• $env — массив окружения (обычно инициализируется в начале скрипта).
• $L, $R, $out, $structure, $sys, $usr — могут быть ещё не полностью заполнены, но переменные уже доступны (возможно, как null или пустые массивы). Благодаря ссылкам фасад будет автоматически видеть все последующие изменения этих переменных.

$cache также определён: если кэширование включено, он содержит объект Cache, иначе null. $cot_extrafields на момент вызова может быть ещё не загружен, но ссылка всё равно будет установлена на переменную (даже если она null), и когда позже она будет заполнена, фасад увидит изменения (при условии, что переменная не будет пересоздана заново, а именно изменена).

После вызова Cot::init() фасад готов к использованию в любом месте приложения: в хуках, в контроллерах, в подключаемых файлах расширений и т.д.

Важность своевременной инициализации

Не рекомендуется обращаться к Cot::$... до вызова Cot::init(), так как свойства будут содержать null или неопределённые значения. В стандартном жизненном цикле Cotonti инициализация происходит очень рано (до обработки запроса и загрузки расширений), поэтому разработчики расширений могут смело использовать фасад в своих обработчиках, не заботясь о порядке.

Список доступных свойств фасада

Ниже приведён подробный разбор каждого статического свойства класса Cot. Для каждого свойства указано:

• Имя глобальной переменной, на которую оно ссылается.
• Тип данных (в рабочем состоянии).
• Назначение.
• Особенности использования.
• Пример кода.

Cot::$cache

Глобальная переменная: $cache
Тип: Cache или null
Описание: Предоставляет доступ к объекту кэширования Cotonti, если кэш включён в конфигурации ($cfg['cache'] == true и не режим отладки). Если кэш отключён, значение будет null.

Объект Cache предоставляет методы для работы с различными типами кэша (база данных, статические файлы, memcache и др.). Через фасад вы можете, например, сохранить или получить произвольные данные из кэша:

// Сохранить значение в кэше
if (Cot::$cache) {
    Cot::$cache->db->store('my_key', $myData, 'my_extension');
}

// Получить значение из кэша
if (Cot::$cache) {
    $myData = Cot::$cache->db->get('my_key', 'my_extension');
}

Примечание: Всегда проверяйте, что Cot::$cache не null, прежде чем вызывать его методы, чтобы избежать ошибок при отключённом кэшировании.

Cot::$cfg

Глобальная переменная: $cfg
Тип: array
Описание: Основной массив конфигурации Cotonti. Содержит все настройки ядра, модулей и плагинов. Загружается из файла datas/config.php и затем дополняется значениями из таблицы конфигурации в базе данных.

Массив $cfg имеет вложенную структуру:

• $cfg['mainurl'] — основной URL сайта.
• $cfg['defaulttheme'] — тема по умолчанию.
• $cfg['plugin']['название_плагина']['настройка'] — настройки конкретного плагина.
• И множество других параметров.

Доступ через фасад тривиален:

$siteUrl = Cot::$cfg['mainurl'];
$myPluginSetting = Cot::$cfg['plugin']['myplug']['some_setting'];

Вы также можете изменять значения конфигурации, и эти изменения будут действовать в течение текущего запроса:

Cot::$cfg['debug_mode'] = true; // временно включить отладку

Важно: Изменения конфигурации через фасад не сохраняются автоматически в базу данных или файл. Для постоянного изменения необходимо использовать соответствующие механизмы Cotonti (например, cot_config_set()).

Cot::$db

Глобальная переменная: $db
Тип: CotDB (наследник PDO)
Описание: Объект подключения к базе данных. Предоставляет методы для выполнения запросов, экранирования значений, работы с транзакциями и т.д. Это основной способ взаимодействия с БД в Cotonti.

Через фасад вы можете выполнять любые запросы:

// Выборка данных
$result = Cot::$db->query("SELECT * FROM " . Cot::$db->users . " WHERE user_id = 1");
$row = $result->fetch();

// Экранирование строки
$safeName = Cot::$db->quote($unsafeName);

// Выполнение подготовленного запроса
$stmt = Cot::$db->prepare("UPDATE " . Cot::$db->users . " SET user_name = ? WHERE user_id = ?");
$stmt->execute([$newName, $userId]);

Класс CotDB также регистрирует таблицы ядра через registerTable(), что позволяет обращаться к ним как Cot::$db->users, Cot::$db->pages и т.д.

Cot::$db_x

Глобальная переменная: $db_x
Тип: string
Описание: Префикс таблиц базы данных. Обычно задаётся в конфигурации и используется для динамического формирования имён таблиц в запросах, если вы не пользуетесь зарегистрированными именами.

Пример использования:

$tableName = Cot::$db_x . 'my_custom_table';
$result = Cot::$db->query("SELECT * FROM $tableName");

Хотя предпочтительнее использовать зарегистрированные имена таблиц (Cot::$db->users), префикс может понадобиться для нестандартных таблиц.

Cot::$env

Глобальная переменная: $env
Тип: array
Описание: Массив переменных окружения, содержащий информацию о текущем запросе: какой модуль/плагин выполняется, тип расширения, местоположение и т.д. Это свойство особенно полезно в маршрутизации и определении контекста.

Типичные ключи:

• $env['ext'] — код текущего расширения (например, page, forums, имя плагина).
• $env['type'] — тип расширения: module или plugin.
• $env['location'] — область выполнения (например, plugins или admin).

Пример использования:

if (Cot::$env['ext'] == 'page') {
    // выполняется модуль страниц
}

Этот массив активно используется в Router.php для установки значений после определения маршрута.

Cot::$extrafields

Глобальная переменная: $cot_extrafields
Тип: array
Описание: Содержит определения дополнительных полей (extra fields), которые используются для расширения базовых сущностей (пользователи, страницы, категории и т.д.). Массив имеет вложенную структуру: $extrafields['module']['field_name'] = [...].

Пример структуры:

Cot::$extrafields['users']['company'] = [
    'field_name' => 'company',
    'field_type' => 'input',
    'field_required' => 0,
    // ...
];

Доступ к дополнительному полю текущего пользователя:

$company = $usr['profile']['user_company'];

Примечание: Глобальная переменная называется $cot_extrafields, но в фасаде используется имя extrafields (без префикса). Убедитесь, что вы обращаетесь именно к Cot::$extrafields.

Cot::$L

Глобальная переменная: $L
Тип: array
Описание: Массив языковых строк (локализация). Содержит переводы всех загруженных языковых файлов для текущего языка пользователя. Ключи обычно имеют вид 'domain_key', например 'users_prof_title'.

Пример использования:

$errorMessage = Cot::$L['users_error_notfound'];

Вывод локализованной строки в шаблоне обычно осуществляется через теги {PHP.L...}, но в PHP-коде удобно обращаться именно через Cot::$L.

Cot::$out

Глобальная переменная: $out
Тип: array
Описание: Массив выходных данных, используемый для накопления контента перед выводом. Чаще всего содержит такие ключи, как $out['head'], $out['subtitle'], $out['desc'] и т.д. Плагины могут добавлять сюда свои данные для последующего вывода в шаблоне.

Пример добавления собственного блока в заголовок:

Cot::$out['head'] .= '<meta name="my-meta" content="value">';

Cot::$R

Глобальная переменная: $R
Тип: array
Описание: Массив "ресурсных строк" (resource strings) — это предопределённые строки, используемые в шаблонах и коде для унификации (например, $R['link_png']). Они загружаются из resources.rc.php и файлов темы.

Пример:

$icon = Cot::$R['icon_delete'];

Ресурсные строки могут быть переопределены темой, поэтому обращение через фасад гарантирует получение актуальных значений.

Cot::$structure

Глобальная переменная: $structure
Тип: array
Описание: Содержит структуру категорий (разделов) сайта для всех модулей, которые поддерживают иерархию (например, page, forums). Массив вложенный: $structure['page'][$categoryCode] = ['title' => ..., 'path' => ..., ...].

Доступ к названию категории:

$categoryTitle = Cot::$structure['page']['news']['title'];

Это свойство особенно полезно при построении навигации или проверке существования категории.

Cot::$sys

Глобальная переменная: $sys
Тип: array
Описание: Массив системных переменных, содержащий временные данные запроса: текущее время, URI, информацию о хосте, уникальные идентификаторы и т.д. Например, Cot::$sys['now'] — текущее время в Unix timestamp, Cot::$sys['uri'] — текущий URI.

Пример:

$currentTime = Cot::$sys['now'];
$requestUri = Cot::$sys['uri'];

Системные переменные широко используются в ядре и расширениях.

Cot::$usr

Глобальная переменная: $usr
Тип: array
Описание: Данные текущего пользователя (или гостя). Массив содержит информацию об ID, имени, группах, правах, теме оформления и т.д. Структура массива подробно описана в документации Cotonti.

Основные ключи:

• $usr['id'] — ID пользователя (0 для гостя).
• $usr['name'] — имя пользователя.
• $usr['maingrp'] — основная группа.
• $usr['groups'] — массив всех групп, к которым принадлежит пользователь.
• $usr['profile'] — полный профиль из таблицы users.

Пример проверки, авторизован ли пользователь:

if (Cot::$usr['id'] > 0) {
    // пользователь авторизован
}

Доступ к кастомному полю пользователя:

$city = Cot::$usr['profile']['user_city'];

Cot::$currentRoute

Глобальная переменная: отсутствует, только статическое свойство класса.
Тип: ?Route (null или объект класса cot\router\Route)
Описание: Хранит объект текущего маршрута после его определения. Маршрут содержит информацию о контроллере, действии, подключаемых файлах и т.д. Это свойство используется преимущественно внутри системы маршрутизации, но может быть полезно и разработчикам для анализа текущего запроса.

Объект Route имеет публичные свойства:

• $controller — экземпляр контроллера или null.
• $action — строка с именем действия.
• $includeFiles — массив файлов, которые должны быть подключены.
• $extensionType — тип расширения (module, plugin или null).
• $extensionCode — код расширения (например, page).

Пример использования (скорее для отладки):

if (Cot::$currentRoute) {
    $controllerClass = get_class(Cot::$currentRoute->controller);
    $action = Cot::$currentRoute->action;
    // ...
}

Как использовать фасад в расширениях

Фасад Cot может быть использован в любом PHP-коде Cotonti: в плагинах, модулях, контроллерах, обработчиках хуков, подключаемых файлах. Он не требует импорта или дополнительной настройки — класс Cot загружается автоматически (через автозагрузчик Composer или явное подключение).

В обработчиках хуков

Типичный плагин Cotonti состоит из файлов-обработчиков хуков. Раньше для доступа к глобальным переменным в таких файлах требовалось писать:

global $cfg, $usr, $db;
$someSetting = $cfg['plugin']['myplug']['setting'];

Теперь можно обойтись без global:

$someSetting = Cot::$cfg['plugin']['myplug']['setting'];

Это делает код чище и устраняет риск забыть объявить какую-либо переменную.

В контроллерах

Начиная с Cotonti 1.0, система использует контроллеры (классы, наследующие BaseController) для обработки запросов. Внутри методов контроллера глобальные переменные не доступны напрямую, поэтому фасад — основной способ получения данных:

namespace cot\modules\mymodule\controllers;

use Cot;
use cot\controllers\BaseController;

class MyController extends BaseController
{
    public function actionIndex()
    {
        $userId = Cot::$usr['id'];
        $cfgValue = Cot::$cfg['plugin']['mymodule']['some_param'];
        // ...
    }
}

В любых других классах

Фасад отлично подходит для использования в сервисах, репозиториях, хелперах — любых классах, где нежелательно протягивать глобальные переменные через параметры.

Примеры практического использования

Рассмотрим несколько конкретных сценариев, иллюстрирующих применение фасада.

Получение текущего пользователя

// Проверка, авторизован ли пользователь
if (Cot::$usr['id'] > 0) {
    $userName = Cot::$usr['name'];
    $userEmail = Cot::$usr['profile']['user_email'];
} else {
    $userName = 'Гость';
}

Доступ к конфигурации

// Получить основной URL сайта
$siteUrl = Cot::$cfg['mainurl'];

// Получить настройку своего плагина
$mySetting = Cot::$cfg['plugin']['myplug']['api_key'] ?? null;

// Изменить значение на время выполнения
Cot::$cfg['display_errors'] = true;

Работа с базой данных

// Выборка всех страниц из определённой категории
$category = 'news';
$query = Cot::$db->query(
    "SELECT page_id, page_title FROM " . Cot::$db->pages . 
    " WHERE page_cat = " . Cot::$db->quote($category) . 
    " ORDER BY page_date DESC LIMIT 10"
);

while ($row = $query->fetch()) {
    echo $row['page_title'] . '<br>';
}

Доступ к языковым строкам

// Получить перевод строки
$errorText = Cot::$L['users_error_email_taken'];

Доступ к структуре сайта

// Проверить, существует ли категория
if (isset(Cot::$structure['page']['downloads'])) {
    // категория есть
}

Работа с системными переменными

// Получить текущий URI
$currentUri = Cot::$sys['uri'];

// Получить уникальный идентификатор запроса
$uniqueId = Cot::$sys['unique'];

Использование в контроллерах

namespace cot\modules\myext\controllers;

use Cot;
use cot\controllers\BaseController;

class SettingsController extends BaseController
{
    public function actionSave()
    {
        // Проверка прав доступа
        if (!cot_auth('admin', 'any', 'R')) {
            cot_die_message(403);
        }

        // Получение параметра из POST
        $value = cot_import('value', 'P', 'TXT');

        // Сохранение в конфиг через фасад (временное)
        Cot::$cfg['plugin']['myext']['saved_value'] = $value;

        // Здесь можно выполнить запись в БД и т.д.
    }
}

Сравнение с традиционным доступом через global

До появления фасада стандартным способом доступа к глобальным переменным было использование ключевого слова global внутри функций или включение файлов с хуками в глобальной области видимости. Оба подхода имеют свои плюсы и минусы.

Традиционный подход

Преимущества:

• Простота: переменные напрямую доступны в области видимости, где они объявлены как global.
• Не требуется дополнительного класса.

Недостатки:

• В каждой функции, методе или include-файле, который не находится в глобальной области видимости, необходимо явно перечислять все нужные глобальные переменные. Это утомительно и повышает риск ошибок.
• В объектно-ориентированном коде использование global считается плохой практикой, так как создаёт скрытые зависимости.
• Код становится менее читаемым из-за обилия global $var1, $var2, ...;.

Подход через фасад

Преимущества:

• Единая точка доступа: Cot::$... всегда доступен, независимо от области видимости.
• Отсутствие необходимости в global.
• Более чистый и понятный код, особенно в классах.
• Возможность использовать автодополнение в IDE (если описаны типы).
• Легче рефакторить: можно изменить способ хранения данных, не меняя внешний интерфейс (теоретически).

Недостатки:

• Некоторое увеличение длины имени (например, Cot::$cfg вместо $cfg).
• Статические свойства могут быть неудобны при модульном тестировании (но это общая проблема статики).
• Требуется привыкание.

Сравнение на примере:

Без фасада:

function my_function() {
    global $cfg, $usr;
    if ($cfg['debug_mode']) {
        echo $usr['name'];
    }
}

С фасадом:

function my_function() {
    if (Cot::$cfg['debug_mode']) {
        echo Cot::$usr['name'];
    }
}

Очевидно, что второй вариант короче и не требует перечисления глобальных переменных.

Особенности и ограничения

Ссылочная природа

Фасад хранит ссылки на глобальные переменные, а не их копии. Это означает:

• Изменение значения через фасад изменяет глобальную переменную и наоборот.
• Если глобальная переменная будет перезаписана новым значением (например, $cfg = []), ссылка в фасаде продолжит указывать на старое значение, потому что ссылка была привязана к конкретной области памяти, а не к имени переменной. В Cotonti такие перезаписи крайне редки и обычно не выполняются после инициализации, поэтому на практике это не создаёт проблем.

Время инициализации

Фасад инициализируется один раз в common.php после создания соединения с БД. До этого момента обращение к Cot::$... может вернуть null или вызвать ошибку (если свойство не инициализировано). В обычном расширении вам не нужно об этом беспокоиться, так как ваши обработчики выполняются после инициализации.

Не все глобальные переменные доступны через фасад

Класс Cot содержит только наиболее востребованные переменные. Некоторые редко используемые глобальные переменные (например, $cot_yesno, $cot_groups и др.) могут быть не представлены. Для доступа к ним по-прежнему можно использовать global или $GLOBALS.

Потенциальная проблема с $extrafields

Глобальная переменная $cot_extrafields может быть загружена после вызова Cot::init(). В текущем коде common.php загрузка extrafields происходит только при необходимости (например, внутри cot_load_structure()), которая вызывается после Cot::init(). Однако поскольку init() устанавливает ссылку на переменную $cot_extrafields (которая на тот момент может быть null), то после заполнения массива эта ссылка должна автоматически обновиться, так как переменная изменяется, а не пересоздаётся. В PHP присвоение значения переменной, на которую есть ссылка, изменяет содержимое этой переменной, и ссылка продолжает указывать на то же место. Поэтому проблем быть не должно.

Статический контекст

Фасад использует статические свойства, что делает его глобальным по своей сути. Это удобно, но может усложнить изоляцию в тестах. Однако для Cotonti, где глобальное состояние является нормой, это приемлемо.

Лучшие практики

1. Используйте фасад вместо global везде, где это возможно. Это улучшает читаемость и снижает вероятность ошибок.
2. Не изменяйте глобальные переменные без необходимости. Если вы изменяете Cot::$cfg, помните, что это влияет на весь последующий код.
3. Проверяйте наличие Cot::$cache перед использованием, так как при отключённом кэше он равен null.
4. Изучите структуру каждого массива перед обращением к вложенным элементам, чтобы избежать ошибок доступа к несуществующим ключам.
5. Используйте зарегистрированные имена таблиц через Cot::$db->table_name, а не собирайте имена вручную с Cot::$db_x.
6. В контроллерах всегда обращайтесь к данным только через фасад, не объявляйте global.
7. Помните, что Cot::$currentRoute устанавливается после маршрутизации и может быть null на ранних этапах.
8. Документируйте свой код, особенно если вы полагаетесь на определённые ключи массивов.

Взаимодействие с хуками

Обработчики хуков — это PHP-файлы, которые подключаются через include в местах вызова хуков. Эти файлы выполняются в той области видимости, где был вызван хук. Если хук вызывается в глобальной области (что чаще всего), то внутри обработчика глобальные переменные доступны напрямую. Однако для единообразия и упрощения переносимости кода рекомендуется использовать фасад даже в таких файлах.

Пример обработчика хука header.tags:

<?php
// Файл myplug.header.tags.php
defined('COT_CODE') or die('Wrong URL');

// Добавление мета-тега в заголовок
Cot::$out['head'] .= '<meta name="myplug-version" content="1.0">';

// Использование конфигурации
$myParam = Cot::$cfg['plugin']['myplug']['param'];

// И т.д.

Таким образом, фасад делает код обработчиков более предсказуемым и менее зависимым от контекста вызова.

Заключение

Фасад Cot — это мощный и удобный инструмент, который упрощает доступ к основным глобальным данным Cotonti. Он предоставляет единый статический интерфейс, избавляя разработчиков от необходимости использовать global и делая код чище, особенно в объектно-ориентированной среде. Все ключевые переменные системы доступны через свойства класса Cot, что ускоряет разработку и снижает вероятность ошибок.

В Cotonti 1.0 фасад стал неотъемлемой частью архитектуры, особенно с введением контроллеров и маршрутизации. Понимание его работы и правильное использование — обязательное условие для создания качественных расширений.

Мы рассмотрели все доступные свойства, их назначение и примеры использования, а также сравнили фасад с традиционным подходом. Надеемся, что данное руководство поможет вам в разработке для Cotonti.

Данная статья основана на анализе исходного кода Cotonti 1.0 (файлы system/Cot.php, system/common.php, system/router/Router.php) и официальной документации. Вся информация представлена без домыслов и предположений.