PHP: полный мануал с примерами, функциями и ООП

Начало: название отдела перед названием элемента

На сайте есть каталог и доставка. Оба модуля хотят назвать свой заголовок TITLE. Пространство имён добавляет к такому имени адрес отдела: Workshop\Catalog\TITLE и Workshop\Delivery\TITLE. Поэтому модули могут существовать в одной программе и не спорить за одно полное имя.

Сначала достаточно понимать вывод echo и строку в кавычках. const TITLE = 'Каталог'; задаёт именованное значение: const объявляет константу, TITLE — её имя без знака $, = связывает имя со значением, кавычки ограничивают текст, ; заканчивает инструкцию. Изменять такую константу повторным присваиванием нельзя. Подробности — в главе о константах.

<?php
namespace Workshop\Catalog;

const TITLE = 'Каталог';
echo TITLE, "\n";

Каталог

Два TITLE рядом: что именно перестаёт конфликтовать

В следующем примере фигурные скобки после namespace ограничивают его часть файла. Пустое имя в namespace { ... } обозначает глобальную часть — пространство без префикса. Начальная \ в обращении означает: взять полное имя от корня, не дописывать текущий namespace.

<?php
namespace Workshop\Catalog {
    const TITLE = 'Каталог: товары';
}
namespace Workshop\Delivery {
    const TITLE = 'Доставка: пункты выдачи';
}
namespace {
    echo \Workshop\Catalog\TITLE, "\n";
    echo \Workshop\Delivery\TITLE, "\n";
}

Каталог: товары
Доставка: пункты выдачи

До namespace похожую задачу решают длинными именами вроде workshop_catalog_title. Это допустимо. С ростом библиотек и классов namespace даёт единое правило адресации, а use — короткие записи в конкретном файле. Сам алгоритм расчёта стоимости от этого быстрее не становится.

Где писать namespace и какие имена допустимы

Первое объявление namespace должно предшествовать исполняемым инструкциям файла. Перед ним допускается declare; комментарии и пробелы внутри открытого PHP-блока не мешают. Текст, пробел или UTF-8 BOM до <?php — уже данные вне PHP. Из-за них файл с namespace не пройдёт разбор.

<?php
// Заголовок модуля. Пробелы находятся внутри PHP.

namespace Workshop\Welcome;

echo "Модуль загружен\n";

Модуль загружен

<?php
echo 'Сначала вывод';
namespace Workshop\Catalog;

declare(strict_types=1); можно поставить после открывающего тега перед namespace: директива задаёт правила типов для файла, а не создаёт namespace. Она разобрана в правилах типов. Сами namespaces существуют с PHP 5.3; все рабочие примеры этой главы рассчитаны на PHP 8.2+.

Составное имя: Catalog\Export не наследует Catalog

Допустим, в каталоге появился экспорт. Имя Workshop\Catalog\Export удобно человеку, но PHP не поднимается автоматически к Workshop\Catalog, если чего-то не нашёл. Каждое объявление namespace задаёт полный префикс; отдельное namespace Export; не дописывает его к предыдущему.

<?php
namespace Workshop\Catalog {
    const TITLE = 'Каталог';
}
namespace Workshop\Catalog\Export {
    const TITLE = 'CSV';
    echo TITLE, "\n";
    echo \Workshop\Catalog\TITLE, "\n";
}

CSV
Каталог

Нельзя вложить один блок namespace {...} внутрь другого. Записывайте длинное имя одним объявлением. Кроме того, две части namespace не требуют двух папок на диске: это соглашение может задать Composer/PSR-4, а не сам синтаксис namespace.

Какие объявления получают префикс, а какие — нет

Namespace участвует в именах классов, интерфейсов, трейтов, перечислений, функций и констант уровня пространства. Методы и свойства принадлежат своему классу. Переменные $title не становятся Workshop\Catalog\$title.

<?php
namespace Workshop\Catalog {
    $title = 'Товары';
}
namespace Workshop\Delivery {
    echo $title, "\n";
    $title = 'Получение';
}
namespace Workshop\Catalog {
    echo $title, "\n";
}

Товары
Получение

Для состояния товара используйте свойства объекта; для входных данных операции — параметры функции. Сравнение namespace с областями видимости переменных помогает избежать ложного ощущения изоляции.

Четыре формы имени: короткое, составное, полное, относительное

Пока в файле нет импортов use, мысленно подставляйте текущий namespace перед составным именем без начальной черты. Слово namespace\ означает «именно из текущего пространства». Формы ниже используются для констант, функций и классов; резервный поиск коротких функций и констант разберём отдельно.

<?php
namespace Workshop\Catalog\Export {
    const TITLE = 'Выгрузка';
}
namespace Workshop\Catalog {
    const TITLE = 'Товары';
    echo TITLE, "\n";
    echo Export\TITLE, "\n";
    echo \Workshop\Catalog\TITLE, "\n";
    echo namespace\TITLE, "\n";
}

Товары
Выгрузка
Товары
Товары

Тот же namespace вокруг небольшой функции

Теперь отделу нужен не готовый заголовок, а подпись конкретного заказа. function title($number) объявляет функцию с одним параметром. Её тело в {...} выполняется при вызове title(41); return отдаёт строку обратно, а точка соединяет текст и число. Эти действия разложены в начале главы о функциях. Namespace меняет полное имя функции, но не способ передачи данных.

<?php
namespace Workshop\Orders {
    function title($number)
    {
        return 'Заказ №' . $number;
    }
}
namespace {
    echo \Workshop\Orders\title(41), "\n";
    echo \Workshop\Orders\title(52), "\n";
}

Заказ №41
Заказ №52

Несколько пространств в файле: две формы записи

Вариант с точкой с запятой можно повторять; новый namespace переключает контекст дальнейшего исходного кода. Вариант с фигурными скобками делает границы заметнее и позволяет выделить глобальный блок без имени. Эти два стиля нельзя смешивать в одном файле.

<?php
namespace Workshop\Shop;
const TITLE = 'Магазин';
echo TITLE, "\n";

namespace Workshop\Support;
const TITLE = 'Поддержка';
echo TITLE, "\n";
echo \Workshop\Shop\TITLE, "\n";

Магазин
Поддержка
Магазин

При скобочной форме весь PHP-код файла, кроме разрешённого начального declare, должен быть внутри блоков namespace. Глобальный исполняемый код помещают в namespace { ... }. Не пытайтесь переключиться в глобальное пространство записью namespace;.

<?php
namespace Workshop\Catalog;
const TITLE = 'Товары';
namespace Workshop\Delivery {
    const TITLE = 'Получение';
}

Для обычного исходника проекта проще один namespace на файл. Несколько блоков удобны в коротком учебном примере или сгенерированном файле; возможность языка сама по себе не требует так организовывать весь проект.

use и as: короткие имена двух классов Receipt

Когда один файл работает с чеком магазина и квитанцией доставки, полные имена нужны для различения, но мешают чтению каждой строки. use Workshop\Shop\Receipt as ShopReceipt; вводит в этом файле короткое имя ShopReceipt. Без as псевдонимом станет последняя часть, здесь Receipt.

Для примера класс — описание объекта с методом label(). public разрешает вызывать метод снаружи; new ShopReceipt() создаёт объект, $receipt->label() вызывает его метод. Обе реализации просто возвращают подпись. Механика объектов подробно разобрана в базовой главе ООП.

<?php
namespace Workshop\Shop {
    class Receipt {
        public function label() { return 'Чек магазина'; }
    }
}
namespace Workshop\Delivery {
    class Receipt {
        public function label() { return 'Квитанция доставки'; }
    }
}
namespace Workshop\Page {
    use Workshop\Shop\Receipt as ShopReceipt;
    use Workshop\Delivery\Receipt as DeliveryReceipt;

    $purchase = new ShopReceipt();
    $delivery = new DeliveryReceipt();
    echo $purchase->label(), "\n";
    echo $delivery->label(), "\n";
}

Чек магазина
Квитанция доставки

Имя справа после use уже задаётся от корня; текущий Workshop\Page к нему не добавляется. Начальная \ там допустима для полного имени, но лишняя. Выбирайте понятные псевдонимы по роли, а не A и B.

Функция, константа и префикс импортируются по-разному

Есть отдельные таблицы коротких имён для классов/пространств, функций и констант. Поэтому use Workshop\Money\format; не превращает вызов format() в вызов той функции. Для неё нужен use function; для константы — use const.

<?php
namespace Workshop\Money {
    const CURRENCY = 'руб.';
    function format($amount) {
        return $amount . ' ' . CURRENCY;
    }
}
namespace Workshop\Checkout {
    use function Workshop\Money\format as money;
    use const Workshop\Money\CURRENCY as UNIT;
    use Workshop\Money as Money;

    echo money(900), "\n";
    echo UNIT, "\n";
    echo Money\format(1200), "\n";
    echo Money\CURRENCY, "\n";
}

900 руб.
руб.
1200 руб.
руб.

use function и use const доступны с PHP 5.6. Для встроенной функции можно явно написать use function strlen; внутри namespace: это закрепит глобальную функцию за коротким вызовом strlen(). Сам импорт не добавляет определение функции и не вызывает её.

Групповой импорт: сократить повторяющийся префикс

Несколько импортов можно разделить запятыми в одной инструкции или собрать под общим префиксом в {...}. В смешанной группе перед функцией ставится function, перед константой — const; перед классом ничего не добавляют. Закрывающая скобка группы заканчивается ;. Групповой use доступен с PHP 7.0.

<?php
namespace Workshop\Packaging {
    class Box {}
    function label($count) { return 'Коробок: ' . $count; }
    const UNIT = 'шт.';
}
namespace Workshop\Shipment {
    use Workshop\Packaging\{Box, function label as boxLabel, const UNIT};

    echo Box::class, "\n";
    echo boxLabel(3), ' ', UNIT, "\n";
}

Workshop\Packaging\Box
Коробок: 3 шт.

Также допустимы группы только функций use function Workshop\Packaging\{label, total}; и только констант use const Workshop\Packaging\{UNIT, LIMIT};, если такие имена существуют при обращении к ним. Группа не означает «подключить всё пространство»: use Workshop\Packaging\*; не поддерживается. Несколько отдельных строк часто легче читать и менять.

Когда действует псевдоним: текст файла, а не условие выполнения

PHP разбирает импорты при компиляции исходника. В переменную нельзя положить имя, а затем написать use $name;. Нельзя поместить импорт namespace внутрь функции, метода или if. Размещайте импорты сразу после namespace, до мест их использования.

<?php
namespace Workshop\Page;

echo Card::class, "\n";
use Workshop\Catalog\Card;
echo Card::class, "\n";

Workshop\Page\Card
Workshop\Catalog\Card

<?php
namespace Workshop\Page;
function render() {
    use Workshop\Catalog\Card;
}

<?php
namespace Workshop\Page {
    use Workshop\Catalog\Card;
    echo Card::class, "\n";
}
namespace Workshop\Page {
    echo Card::class, "\n";
}

Workshop\Catalog\Card
Workshop\Page\Card

Импорт действует в текущем файле и блоке namespace; при новом блоке его пишут заново. У ключевого слова use ещё две роли: захват переменных замыканием и подключение трейта внутри класса. Окружение записи определяет её смысл.

require подключает файл, но не передаёт ему namespace и use

Чтобы запустить следующий пример вручную, создайте рядом с основным PHP-файлом три приложенных файла. require __DIR__ . '/vendor.php'; выполняет файл по пути: __DIR__ — папка текущего исходника, точка соединяет части строки. Namespace и импорты в каждом файле разбираются самостоятельно.

<?php
namespace Workshop\Page;
use Workshop\Vendor\Card as CallerCard;

require __DIR__ . '/vendor.php';
require __DIR__ . '/page-helper.php';
require __DIR__ . '/global-helper.php';

echo CallerCard::class, "\n";
echo helperName(), "\n";
echo \outsideName(), "\n";

Workshop\Vendor\Card
Workshop\Page\CallerCard
Глобальная функция

В одном namespace можно объявлять разные элементы в разных файлах. Подключение файла повторно не должно повторно объявлять те же классы и функции; для файлов определений применяют require_once или управляют загрузкой через Composer. При этом переменные подключаемого файла подчиняются области выполнения include/require, а не этим правилам имён.

Глобальное пространство и резервный поиск: функция найдётся, класс — нет

Если короткая функция или константа не импортирована, PHP сначала проверяет текущее пространство, затем глобальное. В родительские составные пространства он не заходит. У классов такого резервного перехода к глобальному имени нет.

<?php
namespace {
    const SHOP_NAME = 'Магазин';
    function label() { return 'Общая подпись'; }
}
namespace Workshop\Checkout {
    function label() { return 'Оформление'; }

    echo label(), "\n";
    echo \label(), "\n";
    echo SHOP_NAME, "\n";
    echo strlen('order'), "\n";
}

Оформление
Общая подпись
Магазин
5

Во втором примере try запускает проверяемый код; catch (\Error $error) перехватывает ошибку языка, чтобы показать понятный результат. Это контролируемая учебная ошибка. Механизм try/catch разобран отдельно.

<?php
namespace Workshop\Calendar;
use DateTimeImmutable as Date;

try {
    new DateTimeImmutable('2026-10-01');
} catch (\Error $error) {
    echo "Нет класса Workshop\\Calendar\\DateTimeImmutable\n";
}

$date = new Date('2026-10-01', new \DateTimeZone('UTC'));
echo $date->format('Y-m-d'), "\n";

Нет класса Workshop\Calendar\DateTimeImmutable
2026-10-01

То же правило класса применяется в extends, implements, типах параметров/результатов и catch. Например, catch (Exception $e) без импорта внутри вашего namespace не обозначает встроенный \Exception. Импортируйте его или используйте полное имя.

__NAMESPACE__ и namespace\: название текущего контекста

__NAMESPACE__ — специальная константа с именем текущего пространства без начальной обратной черты; в глобальной части это пустая строка. А namespace\ внутри имени принудительно начинает поиск от текущего namespace, минуя псевдоним первого сегмента.

<?php
namespace Workshop\Vendor\Tools {
    const LABEL = 'Инструменты библиотеки';
}
namespace Workshop\Page\Tools {
    const LABEL = 'Инструменты страницы';
}
namespace Workshop\Page {
    use Workshop\Vendor\Tools as Tools;

    echo __NAMESPACE__, "\n";
    echo Tools\LABEL, "\n";
    echo namespace\Tools\LABEL, "\n";
}
namespace {
    echo '[', __NAMESPACE__, "]\n";
}

Workshop\Page
Инструменты библиотеки
Инструменты страницы
[]

На практике __NAMESPACE__ полезен в диагностике и при сборке полного строкового имени. Он не возвращает путь к папке: для папки нужен __DIR__. В глобальном пространстве namespace\strlen означает глобальную strlen.

Имя из переменной: строка не проходит через таблицу use

Если имя класса лежит в строке, new $className() использует содержимое строки. PHP не дописывает текущий namespace и не заменяет псевдоним внутри текста. Card::class, напротив, разбирается как запись имени в исходнике и возвращает уже полное имя.

<?php
namespace Workshop\Catalog {
    class Card {}
}
namespace Workshop\Page {
    use Workshop\Catalog\Card as Item;

    $className = Item::class;
    $card = new $className();
    echo $card::class, "\n";

    $shortName = 'Item';
    try {
        new $shortName();
    } catch (\Error $error) {
        echo "Строка Item не является псевдонимом use\n";
    }
}

Workshop\Catalog\Card
Строка Item не является псевдонимом use

В двойных кавычках \n означает перевод строки, а не две буквы имени. Для вручную записанного полного имени используйте корректное экранирование 'Workshop\\Catalog\\Card'; ещё надёжнее взять его через Card::class. Короткое строковое имя в class_exists() или callable также не получает импорт автоматически.

<?php
namespace Workshop\Text {
    const LABEL = 'Заказ';
    function title($number) { return LABEL . ' №' . $number; }

    $functionName = __NAMESPACE__ . '\\title';
    $constantName = __NAMESPACE__ . '\\LABEL';
    echo $functionName(41), "\n";
    echo constant($constantName), "\n";
}

Заказ №41
Заказ

Не собирайте произвольный класс, путь require или callable прямо из HTTP-параметра. Если посетитель выбирает формат отчёта, сопоставьте допустимые короткие значения с заранее известными ClassName::class или функциями. Такой явный выбор обработчика ограничивает действие запроса и делает код проверяемым.

Алгоритм выбора имени: разберите запись до поиска файла

Для диагностики сначала определите полное имя, которое PHP пытается использовать. Только потом проверяйте существование определения и автозагрузку. Иначе можно долго искать верный файл для неверного имени.

Имена в строках относятся к отдельному случаю, описанному выше. Не применяйте к ним эту подстановку исходника. Часть решений делается при компиляции; резервный поиск короткой функции/константы относится к выполнению. Поэтому 'namespace' не равен универсальному поиску по папкам.

Ошибки FAQ: конфликт псевдонима, неизвестная константа, регистр

Импорт не может спорить с объявлением того же короткого имени класса в том же файле/контексте. Возьмите другой псевдоним. Если класс текущего namespace объявлен в другом файле, такой псевдоним технически допустим: он меняет короткую запись только здесь, а не удаляет тот класс. Но назвать их явно по роли обычно понятнее.

<?php
namespace Workshop\Page;
use Workshop\Catalog\Card;
class Card {}

<?php
namespace Workshop\Page;
use Workshop\Catalog\Card;

require __DIR__ . '/local-card.php';
require __DIR__ . '/external-card.php';

$imported = new Card();
$local = new namespace\Card();
echo $imported->label(), "\n";
echo $local->label(), "\n";

Карточка каталога
Карточка страницы

<?php
namespace Workshop {
    namespace Catalog {
        const TITLE = 'Товары';
    }
}

В PHP 8+ неизвестная константа даёт Error и при короткой, и при полной записи. Исторический пункт FAQ PHP.net о превращении голого неизвестного имени в строку описывает старое поведение до PHP 8.0; повторять его как правило для современного кода нельзя.

<?php
namespace Workshop\Catalog;

try {
    echo UNKNOWN_TITLE;
} catch (\Error $error) {
    echo "Короткая константа не определена\n";
}
try {
    echo \Workshop\Catalog\UNKNOWN_TITLE;
} catch (\Error $error) {
    echo "Полная константа не определена\n";
}

Короткая константа не определена
Полная константа не определена

<?php
namespace Workshop\Catalog;
const true = 'Да';

Конечная часть имени пользовательской константы чувствительна к регистру; namespace в строковом квалифицированном имени регистронезависим. С уже объявленными классами и функциями PHP обычно разрешает обращения без учёта регистра, но это не причина менять написание: автозагрузка и файловая система могут требовать точного совпадения. Сохраняйте регистр namespace, класса и имени файла согласно принятому соглашению.

Импорт, подключение, автозагрузка: три разных шага

В этом примере class_exists($name, false) проверяет, объявлен ли класс уже сейчас. Второй аргумент false отключает попытку автозагрузки при самой проверке. Тернарная запись условие ? 'Да' : 'Нет' выбирает подпись результата. Ни use, ни Card::class файл не выполняют.

<?php
namespace Workshop\Page;
use Workshop\Catalog\Card;

echo class_exists(Card::class, false) ? "До: есть\n" : "До: нет\n";
require __DIR__ . '/catalog-card.php';
echo class_exists(Card::class, false) ? "После: есть\n" : "После: нет\n";
$card = new Card();
echo $card->label(), "\n";

До: нет
После: есть
Карточка товара

Сам namespace не знает, где лежит файл. Composer и PSR-4 задают соответствие префикса и папки. require 'vendor/autoload.php'; регистрирует загрузчик; это не создание всех объектов. Классовая автозагрузка не запускается от отсутствующей обычной функции или константы: их файл подключают явно или через Composer autoload.files.

Полезно сначала проверить полное имя через SomeAlias::class, затем наличие класса и подключение загрузчика, затем регистр/путь в настройках. Не добавляйте случайные require в каждый метод: это скрывает причину и усложняет зависимости.

Namespace в типе параметра, extends, интерфейсе и трейте

После знакомства с интерфейсами, трейтами и наследованием правило имени остаётся тем же. В следующем примере interface задаёт обещанный метод, trait даёт его реализацию, extends выбирает родителя, implements — интерфейс. Параметр Labelled $item разрешает передать объект, выполняющий этот договор.

<?php
namespace Workshop\Contracts {
    interface Labelled {
        public function label(): string;
    }
}
namespace Workshop\Shared {
    trait LabelText {
        public function label(): string { return 'Заказ готов'; }
    }
    class BaseMessage {}
}
namespace Workshop\Orders {
    use Workshop\Contracts\Labelled;
    use Workshop\Shared\LabelText;
    use Workshop\Shared\BaseMessage;

    class ReadyMessage extends BaseMessage implements Labelled {
        use LabelText;
    }
    function render(Labelled $item): string {
        return $item->label();
    }
    echo render(new ReadyMessage()), "\n";
}

Заказ готов

<?php
namespace Workshop\Orders {
    enum Status: string {
        case Paid = 'Оплачен';
    }
}
namespace Workshop\Page {
    use Workshop\Orders\Status as OrderStatus;
    echo OrderStatus::Paid->value, "\n";
}

Оплачен

Если нужны атрибуты, имя их класса разрешается по тем же правилам. Namespace не меняет public/protected/private, правила наследования или типизацию: он только помогает выбрать, какой именно тип указан.

Практика: страница заказа использует два независимых модуля

Модуль продажи знает сумму заказа; доставка знает свой статус. У обоих есть функция summary(). Страница должна вывести обе подписи. Создайте основной файл и два приложенных файла; основной файл подключит определения, назначит понятные псевдонимы и передаст каждому модулю его данные.

<?php
namespace Workshop\Page;
use function Workshop\Orders\summary as orderSummary;
use function Workshop\Delivery\summary as deliverySummary;

require __DIR__ . '/orders.php';
require __DIR__ . '/delivery.php';

$orderNumber = 41;
echo orderSummary($orderNumber, 1250), "\n";
echo deliverySummary($orderNumber, 'В пункте выдачи'), "\n";

Заказ №41: 1250 руб.
Доставка заказа №41: В пункте выдачи

Когда модуль доставки заменится библиотекой, вы сможете поменять её подключение и импорт, сохранив понятные имена на странице — если контракт вызова совпадает. Разницу аргументов и результата придётся согласовать явно: alias не адаптирует API. См. проверку входных данных и объектные зависимости, когда у клиента появится состояние.

Упражнение: подключить возвраты, не меняя доставку

Добавьте третий модуль Workshop\Returns со своей summary($number). На странице назовите её returnSummary и выведите «Возврат заказа №41 принят». Сначала запишите полное имя функции на бумаге. Затем определите, какой файл объявляет функцию, и только после этого добавьте короткий импорт.

<?php
namespace Workshop\Page;
use function Workshop\Returns\summary as returnSummary;

require __DIR__ . '/returns.php';
echo returnSummary(41), "\n";

Возврат заказа №41 принят

Проверьте себя: почему строка 'returnSummary' не годится для динамического вызова этой функции? Почему use Workshop\Returns; не разрешает короткий summary(41)? Что изменится, если записать Returns\summary(41)? Ответы: строка не проходит импорт; обычный use задаёт префикс, а не таблицу функций; составная запись использует этот префикс.

Для небольшого скрипта с одной функцией дополнительный namespace может быть необязателен. Для повторно используемого пакета собственный префикс предотвращает случайные совпадения с приложением и другими пакетами. Стиль импортов выбирайте единый; влияние на скорость измеряйте на реальной нагрузке, а не выводите из длины имени.

Откуда возникают эти ошибки в реальных проектах

В обсуждениях разработчиков повторяются конкретные затруднения: автор считает use загрузкой, ожидает наследования контекста подключаемым файлом или передаёт строку с псевдонимом вместо полного имени. Примеры выше написаны заново для этих ситуаций; правила языка сверены с PHP Manual, а ответы участников не используются как нормативная спецификация.

• use принимают за загрузку исходного файла: Разделены сокращение имени, require и автозагрузка; собственный пример проверяет существование класса до и после require.
• Ожидание, что включённый файл наследует namespace вызывающего: В fixture каждый файл имеет собственный контекст имён; файл без namespace остаётся глобальным.
• Строка с коротким псевдонимом не находит класс: Собственный пример сравнивает Alias::class и строку 'Alias'; полное имя получают до динамического new.
• Обычный use не импортирует короткое имя функции: Отдельно объяснены use function, use const и импорт префикса пространства имён.
• Импорт пытаются поместить внутрь функции: use размещён на уровне файла/блока namespace; функция пользуется уже разрешённым именем.
• Видимая первая строка namespace, но до PHP-тега может быть вывод/BOM: Различены допустимые пробелы внутри PHP и недопустимые байты до открывающего тега; диагноз проверен отдельными lint-пробами.

Старые ответы могут описывать PHP до появления use function или до Error для неизвестных констант. Сопоставляйте дату совета с версией PHP и точной формой имени. Следующие сохранённые практические блоки этой главы закрепляют выбор имён и связь с автозагрузкой.

Когда два модуля назвали свою функцию одинаково

Каталог и доставка независимо завели функцию title. Обе нужны в одном приложении, но глобальное имя не может обозначать две разные функции. Пространство имён добавляет смысловую часть: Bridge\Catalog\title и Bridge\Delivery\title.

Результат: вы вызовете нужное объявление по полному имени, дадите ему короткий псевдоним и увидите разницу между именем и загрузкой файла. Сначала нужны функции; пример с загрузчиком также использует класс, new и свойство объекта.

Каждый пример запускается отдельно. Скачайте его архив, распакуйте целиком, откройте терминал в этом каталоге и выполните php example.php. Сравните вывод с блоком «Ожидаемый результат». Не объединяйте примеры в один файл: некоторые намеренно повторяют имена функций и классов.

namespace, обратный слеш и use

namespace Bridge\Catalog;
use Bridge\Delivery\Calculator as DeliveryCalculator;

namespace должен находиться в начале PHP-кода; перед ним допустим declare. HTML, пробел до <?php или BOM могут нарушить это правило. Обычная переменная $price не получает отдельное пространство имён: переменные по-прежнему следуют правилам области видимости.

Минимальный запуск: два title без конфликта

<?php
declare(strict_types=1);

namespace Bridge\Catalog {
    function title(): string
    {
        return 'Каталог товаров';
    }
}

namespace Bridge\Delivery {
    function title(): string
    {
        return 'Доставка заказов';
    }
}

namespace {
    echo \Bridge\Catalog\title(), "\n";
    echo \Bridge\Delivery\title(), "\n";
}

Каталог товаров
Доставка заказов

Собрать строку отчёта внутри функции

<?php
declare(strict_types=1);

namespace Bridge\Catalog {
    const CURRENCY = 'RUB';

    function wholeRubles(int $amount): string
    {
        if ($amount < 0) {
            throw new \InvalidArgumentException('Сумма меньше нуля');
        }
        return (string) $amount;
    }

    class Product
    {
        public function title(): string
        {
            return 'Чай';
        }
    }
}

namespace Bridge\Report {
    use Bridge\Catalog\Product as CatalogProduct;
    use function Bridge\Catalog\wholeRubles as formatAmount;
    use const Bridge\Catalog\CURRENCY;

    function itemLine(int $rubles): string
    {
        $product = new CatalogProduct();
        return $product->title() . ': ' . formatAmount($rubles) . ' ' . CURRENCY;
    }

    echo itemLine(150), "\n";
}

Чай: 150 RUB

В примере new CatalogProduct() создаёт объект класса, а $product->title() вызывает его метод. Ни namespace, ни use не запускают этот метод сами. Для глобального класса исключения написано \InvalidArgumentException: начальный слеш исключает поиск одноимённого класса внутри Bridge\Catalog.

Почему use не заменяет require и автозагрузку

В имени класса есть обратные слеши, но PHP не обязан автоматически превратить их в путь. Для одного файла можно явно написать require. Для многих классов регистрируют загрузчик. Следующий опыт печатает состояние до и после new, поэтому разница видна без догадок.

<?php
declare(strict_types=1);

use Bridge\Catalog\Product;

echo class_exists(Product::class, false) ? "Уже загружен\n" : "До new класс не загружен\n";

spl_autoload_register(static function (string $class): void {
    $files = [
        Product::class => __DIR__ . '/src/Product.php',
    ];
    if (isset($files[$class])) {
        require $files[$class];
    }
});

$product = new Product('Чай');
echo $product->title, "\n";
echo class_exists(Product::class, false) ? "После new класс загружен\n" : "Класс не найден\n";

До new класс не загружен
Чай
После new класс загружен

В настоящем проекте обычно используют Composer и его загрузчик. Правило PSR-4 связывает префикс пространства имён с каталогом; его нужно настроить, а файл vendor/autoload.php — подключить. Имена и регистр каталогов должны соответствовать правилу. Автозагрузка классов сама по себе не подгружает произвольные функции и константы по первому обращению. Для файлов с ними выбирают явное подключение или отдельное правило Composer files.

Ошибки имён и самостоятельное изменение

• Не вставляйте use внутрь функции. use для импорта отличается от use ($variable) у замыкания и use TraitName внутри класса.
• Не передавайте строку с коротким псевдонимом туда, где ожидается полное динамическое имя класса: строка не получает магический импорт.
• Не делайте предположение «имя совпало с путём — PHP сам найдёт файл»: сначала должен существовать загрузчик.

Попробуйте сами. В отчёте появились два класса Product: Catalog\Product и Supplier\Product. Как различать их в одном файле?