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

<?php
function orderLabel($number) { return 'Заказ №' . $number; }
$text = call_user_func('orderLabel', 41);
echo $text;

Заказ №41

Имя передаётся строкой; значение 41 относится к параметру orderLabel, а не к самому посреднику. Присваивание сохраняет результат, echo показывает его. Без return у callback обычный результат будет null.

<?php
class ShopLabel
{
    public $prefix;
    public function __construct($prefix) { $this->prefix = $prefix; }
    public function format($number) { return $this->prefix . ' #' . $number; }
}
$retail = new ShopLabel('Розница');
$wholesale = new ShopLabel('Опт');
echo call_user_func([$retail, 'format'], 41), "\n";
echo call_user_func([$wholesale, 'format'], 41);

Розница #41
Опт #41

Оба callback вызывают одинаковый метод, но объекты несут разные настройки. new запускает конструктор; call_user_func запускает format. Передавать [ShopLabel::class, 'format'] нельзя: этот метод требует объект, он не static.

<?php
try {
    call_user_func('missing_manual_formatter');
} catch (TypeError $error) {
    echo "Действие недоступно\n";
}
$format = function ($number) { throw new RuntimeException('Формат временно недоступен'); };
try {
    call_user_func($format, 41);
} catch (RuntimeException $error) {
    echo "Ошибка обработчика\n";
}

Действие недоступно
Ошибка обработчика

TypeError относится к непригодному callback. RuntimeException выброшен его телом и прошёл через посредника. Последующие строки не выполнятся автоматически, если исключение не перехватить на выбранной границе.

<?php
function makeLabel($number, $prefix) { return $prefix . ' №' . $number; }
$arguments = [41, 'Заказ'];
echo call_user_func_array('makeLabel', $arguments);

Заказ №41

Числовые ключи списка не являются именами параметров. Передача [8 => 41, 2 => 'Заказ'] тоже использует порядок элементов 41, затем Заказ, а не сортировку ключей.

<?php
function makeLabel($number, $prefix = 'Заказ') { return $prefix . ' №' . $number; }
echo call_user_func_array('makeLabel', ['prefix' => 'Возврат', 'number' => 41]), "\n";
try {
    call_user_func_array('makeLabel', ['id' => 41]);
} catch (Error $error) {
    echo "Имя параметра не совпало\n";
}

Возврат №41
Имя параметра не совпало

PHP 8 связывает prefix и number по именам независимо от порядка этих двух ключей. id не объявлен и не собирается в variadic: вызов не состоялся. Это причина поломки старых маршрутизаторов, передававших произвольные ассоциативные поля.

<?php
$weights = [300, 100, 200];
$arguments = [&$weights, SORT_NUMERIC];
$ok = call_user_func_array('sort', $arguments);
var_dump($ok);
echo implode(',', $weights);

bool(true)
100,200,300

Первый элемент args связан с weights. Возврат sort — true, сами отсортированные значения находятся в weights. Для callback без ссылочных параметров дополнительные & не нужны и могут неожиданно объединить данные.

<?php
function finishReport($name) { echo 'Завершён: ', $name, "\n"; }
register_shutdown_function('finishReport', 'каталог');
echo "Основная работа\n";

Основная работа
Завершён: каталог

Скобки регистрации передают имя callback и аргумент каталог. Если написать finishReport('каталог') вместо строки, функция выполнится сразу, а регистрировать придётся её результат null — это ошибка. Результат callback не становится результатом register_shutdown_function.

<?php
$results = [];
register_shutdown_function(function () use (&$results) {
    echo "Сводка проверки:\n";
    foreach ($results as $line) { echo $line, "\n"; }
});
$rows = [
    ['sku' => 'TEA', 'quantity' => 2],
    ['sku' => 'CUP', 'quantity' => 0],
    ['sku' => 'COFFEE', 'quantity' => 3],
];
foreach ($rows as $row) {
    if (!is_int($row['quantity']) || $row['quantity'] < 1) {
        $results[] = $row['sku'] . ': отказ, количество должно быть положительным целым';
        continue;
    }
    $results[] = $row['sku'] . ': принято ' . $row['quantity'] . ' шт.';
}
echo "Основной код закончил проверку\n";

Основной код закончил проверку
Сводка проверки:
TEA: принято 2 шт.
CUP: отказ, количество должно быть положительным целым
COFFEE: принято 3 шт.

При регистрации results ещё пуст, но use(&$results) сохраняет связь. Основной foreach добавляет три готовые строки: два принятия и отказ для нуля. Continue пропускает добавление успешной строки у CUP. После последнего echo заканчивается основной файл, PHP вызывает зарегистрированное замыкание, и оно видит заполненный results. Ни склад, ни база не меняются: «принято» означает пройдена именно эта проверка фиксированных учебных данных. Для реального импорта отдельно нужны сохранение результата и правила обработки сбоев.

<?php
register_shutdown_function(function () {
    echo "Первая очистка\n";
    register_shutdown_function(function () { echo "Добавленная очистка\n"; });
});
register_shutdown_function(function () { echo "Вторая очистка\n"; });
echo "Основной код\n";
exit;

Основной код
Первая очистка
Вторая очистка
Добавленная очистка

exit в основном коде запускает завершение. Новая регистрация из callback добавляется в конец. Если exit вызвать внутри первого callback, последующие callbacks не выполнятся. В рабочей очистке не нужно управлять всей очередью через exit.

<?php
$processed = 0;
$lastObserved = null;
$observer = function () use (&$processed, &$lastObserved) {
    $lastObserved = $processed;
};
$registered = register_tick_function($observer);
try {
    declare(ticks=1) {
        $processed = 1;
        $processed += 1;
    }
} finally {
    unregister_tick_function($observer);
}
if ($registered) { echo "Наблюдатель был зарегистрирован\n"; }
echo 'Обработано документов: ', $processed, "\n";
echo 'Последнее наблюдение: ', $lastObserved, "\n";

Наблюдатель был зарегистрирован
Обработано документов: 2
Последнее наблюдение: 2

Register_tick_function получает сам Closure и возвращает true в registered. Declare создаёт tick-точки для тела, где processed становится 1, затем 2. Callback читает processed и сохраняет в lastObserved; его собственный return не используется. После finally наблюдение снято; вывод показывает реальное последнее значение 2. Это учебные отметки документов, а не чтение их файлов. Количество событий может отличаться от количества присваиваний; пример не превращает ticks в бизнес-счётчик.

<?php
$result = [];
$seen = [];
$observer = function ($stage) use (&$result, &$seen) {
    $seen[$stage] = $result;
};
register_tick_function($observer, 'Подготовка названий');
try {
    declare(ticks=1) {
        foreach ([' Tea ', ' Cup '] as $name) {
            $result[] = trim($name);
        }
    }
} finally {
    unregister_tick_function($observer);
}
foreach ($seen as $stage => $names) {
    echo $stage, ': ', implode(', ', $names), "\n";
}

Подготовка названий: Tea, Cup

Второй аргумент регистрации — строка, которую PHP подставляет в местный stage каждого вызова observer. Use передаёт связи с result и seen отдельно от этого параметра. Trim возвращает Tea/Cup без крайних пробелов, тело добавляет их в result. Callback обновляет снимок списка для подписи участка; после последней точки он содержит оба названия. Foreach читает этот сохранённый массив и печатает его. В примере сохраняется только последнее наблюдение, поэтому не обещается запись каждого промежуточного состояния или наблюдение всего приложения.

<?php
$currentDocument = 'Заказ №41';
$lastObserved = null;
$observer = function () use (&$currentDocument, &$lastObserved) {
    $lastObserved = $currentDocument;
};
register_tick_function($observer);
declare(ticks=1) { $currentDocument = 'Заказ №42'; }
unregister_tick_function($observer);
declare(ticks=1) { $currentDocument = 'Заказ №43'; }
echo 'Последнее наблюдение: ', $lastObserved, "\n";
echo 'Текущий документ: ', $currentDocument, "\n";

Последнее наблюдение: Заказ №42
Текущий документ: Заказ №43

Первый участок даёт callback возможность сохранить №42. Unregister_tick_function получает тот же объект observer и снимает регистрацию. Второй участок меняет currentDocument на №43, но lastObserved остаётся №42. Возврат unregister — void: результат действия читается в состоянии программы, а не как bool. Новый Closure с таким же текстом был бы другим объектом и не обозначал бы прежнюю регистрацию.

<?php
$stage = 'Ожидание';
$lastObserved = null;
$observer = function () use (&$stage, &$lastObserved) { $lastObserved = $stage; };
register_tick_function($observer);
try {
    declare(ticks=1) {
        $stage = 'Пакет получен';
        throw new RuntimeException('Нет правила доставки');
    }
} catch (RuntimeException) {
    echo "Пакет отклонён: нет правила доставки\n";
} finally {
    unregister_tick_function($observer);
}
declare(ticks=1) { $stage = 'Следующее задание'; }
echo 'Последнее наблюдение старого задания: ', $lastObserved, "\n";
echo 'Текущий этап: ', $stage, "\n";

Пакет отклонён: нет правила доставки
Последнее наблюдение старого задания: Пакет получен
Текущий этап: Следующее задание

Первое присваивание даёт наблюдение «Пакет получен». Throw передаёт управление обработчику отказа; finally снимает observer даже на этом пути. Затем stage меняется, но старый lastObserved не получает «Следующее задание». Удобство finally в том, что снятие не нужно дублировать в каждой успешной и ошибочной ветке. Это обычный обработанный сценарий исключения; убийство процесса или exit не дают такой же гарантии исполнения finally.

<?php
// Исторический фрагмент для чтения; НЕ запускать в PHP 8.
$format = create_function('$number', 'return "Заказ №" . $number;');

Первой строкой описывались параметры, второй — исполняемое тело. В современном PHP такого имени функции нет: вызов даст Error. Не заменяйте отсутствие функции собственным eval-полифиллом. Этот исторический фрагмент не исполняется.

<?php
$format = function ($number) {
    return 'Заказ №' . $number;
};
echo $format(41);

Заказ №41

Внешние скобки function описывают параметры, фигурные — тело. Строка Заказ № является обычным текстом результата. Для вызова используется переменная и скобки; никакой дополнительный компилятор строк не нужен.

<?php
function makeOrderFormatter($prefix)
{
    return function ($number) use ($prefix) {
        return $prefix . ' #' . $number;
    };
}
$retail = makeOrderFormatter('Розница');
$wholesale = makeOrderFormatter('Опт');
echo $retail(41), "\n";
echo $wholesale(41);

Розница #41
Опт #41

use сохраняет значение для будущего вызова; return внешней функции отдаёт действие, а return внутренней — текст. Тело Closure не обязано быть static или методом класса. Объекты-клиенты нужны позже, когда настройки сопровождаются несколькими связанными операциями.

<?php
class Document
{
    public const PREFIX = 'Документ';
    public static function label($number) { return static::PREFIX . ' #' . $number; }
}
class Invoice extends Document
{
    public const PREFIX = 'Счёт';
    public static function compare($number)
    {
        echo call_user_func([Document::class, 'label'], $number), "\n";
        echo forward_static_call([Document::class, 'label'], $number);
    }
}
Invoice::compare(41);

Документ #41
Счёт #41

extends задаёт наследование, static объявляет метод без экземпляра, :: выбирает член класса, ::class даёт строку его имени. static::PREFIX внутри унаследованного тела использует called class. Этот опыт нужен для понимания механизма; обычному форматтеру достаточно функции с явным префиксом.

<?php
class ExportDocument
{
    public const KIND = 'document';
    public static function row($number, $amount)
    {
        return static::KIND . ':' . $number . ':' . $amount;
    }
    public static function export($number, $amount)
    {
        $formatter = [self::class, 'row'];
        return forward_static_call($formatter, $number, $amount);
    }
}
class InvoiceExport extends ExportDocument { public const KIND = 'invoice'; }
class RefundExport extends ExportDocument { public const KIND = 'refund'; }
echo InvoiceExport::export(41, 1200), "\n";
echo RefundExport::export(41, 300);

invoice:41:1200
refund:41:300

export объявлен один раз. В каждом вызове выбирается тело row предка, но static::KIND остаётся связан с нужным видом документа. В этом фиксированном примере self::row($number, $amount) проще; посредник имеет смысл, когда callback действительно выбирается обёрткой. Он не выполняет поиск переопределённого тела вместо явно указанного row.

<?php
function lineLabel($number, $quantity) { return '#' . $number . ': ' . $quantity; }
$arguments = [41, 3];
echo forward_static_call_array('lineLabel', $arguments);

#41: 3

Элемент 41 попадает в number, элемент 3 — в quantity. Функция lineLabel не использует static-контекст. Здесь call_user_func_array либо прямой lineLabel(...$arguments) понятнее; опыт показывает точную границу допустимого вызова, а не обязательную рекомендацию.

<?php
class ExportTemplate
{
    public const LABEL = 'Документ';
    public static function render($number, $quantity)
    {
        return static::LABEL . ' #' . $number . ': ' . $quantity;
    }
    public static function fromRow($row)
    {
        $arguments = [$row['number'], $row['quantity']];
        return forward_static_call_array([self::class, 'render'], $arguments);
    }
}
class InvoiceTemplate extends ExportTemplate { public const LABEL = 'Счёт'; }
echo InvoiceTemplate::fromRow(['number' => 41, 'quantity' => 3]);

Счёт #41: 3

Входная запись остаётся данными, а fromRow выбирает явный порядок аргументов. Выбрано тело render из ExportTemplate, static::LABEL читает значение InvoiceTemplate. Вход в реальном приложении должен быть проверен до fromRow; отсутствие ключа не заменяется автоматическим значением.

<?php
function normalizeLabels(&$labels)
{
    foreach ($labels as $key => $label) { $labels[$key] = trim($label); }
    return count($labels);
}
$labels = [' Tea ', ' Cup '];
$arguments = [&$labels];
echo forward_static_call_array('normalizeLabels', $arguments), "\n";
echo implode(',', $labels);

2
Tea,Cup

Внешний args содержит один ссылочный элемент: он соответствует одному параметру labels. Передача массива labels без внешней оболочки превратила бы его строки в отдельные аргументы. В обычном коде прямой normalizeLabels($labels) лучше показывает изменение.

<?php
function orderLine($number, $quantity) {
    $readNumber = func_get_arg(0);
    $readQuantity = func_get_arg(1);
    return 'Заказ №' . $readNumber . ': ' . $readQuantity . ' шт.';
}
$label = orderLine(41, 3);
echo $label, "\n";

Заказ №41: 3 шт.

Func_get_arg(0) возвращает 41 в readNumber, func_get_arg(1) — 3 в readQuantity. Внешний return соединяет значения со строками и отдаёт готовую подпись в label. Echo вызывающего показывает результат. Func_get_arg не получает номер заказа напрямую и не читает аргументы CLI. В этом простом объявлении прямые number и quantity яснее; чтение по позициям нужно прежде всего при сопровождении старого универсального интерфейса.

<?php
function legacyLabel($number)
{
    $prefix = func_num_args() >= 2 ? func_get_arg(1) : 'Заказ';
    return $prefix . ' #' . $number;
}
echo legacyLabel(41), "\n";
echo legacyLabel(41, 'Возврат');

Заказ #41
Возврат #41

Пользовательская функция может получить лишний позиционный аргумент, даже если он не указан в объявлении. Проверка защищает чтение второй позиции. Это пример поддержки legacy-договора, а не рекомендация скрывать новые параметры: function label($number, $prefix = 'Заказ') понятнее читателю и анализатору.

<?php
function inspectLine($number)
{
    foreach ([-1, 1] as $position) {
        try {
            func_get_arg($position);
        } catch (ValueError $error) {
            echo 'Недоступная позиция: ', $position, "\n";
        }
    }
}
inspectLine(41);

Недоступная позиция: -1
Недоступная позиция: 1

inspectLine вызван с единственным аргументом: доступна только позиция 0. На PHP 8.5.11 отрицательная и выходящая за список позиции дают ValueError. Пример ловит конкретную ожидаемую ошибку, не скрывая остальные отказы.

<?php
function showArguments($number, $quantity)
{
    $arguments = func_get_args();
    foreach ($arguments as $position => $value) {
        echo $position, ': ', $value, "\n";
    }
}
showArguments(41, 3);

0: 41
1: 3

Параметров у func_get_args нет. foreach получает индекс и значение массива. Имена переменных вызывающего кода здесь не восстанавливаются; если нужен именованный договор данных, передайте явный массив с разрешёнными полями.

<?php
function joinLabelParts(...$parts) { return implode(' / ', $parts); }
function oldReportLabel()
{
    return call_user_func_array('joinLabelParts', func_get_args());
}
function reportLabel(...$parts)
{
    return joinLabelParts(...$parts);
}
echo oldReportLabel('Заказ', '41', 'Готов'), "\n";
echo reportLabel('Заказ', '41', 'Готов');

Заказ / 41 / Готов
Заказ / 41 / Готов

В объявлении ...$parts собирает аргументы; в вызове ...$parts распаковывает их. Первый способ помогает прочитать старый код, второй показывает договор сразу. Этот опыт содержит только скалярные строки; нельзя бездумно переслать так параметры по ссылке и обещать сохранение их ссылочного договора.

<?php
function normalizeLabel($label)
{
    $before = func_get_args();
    $label = trim($label);
    $after = func_get_args();
    echo '[', $before[0], ']', "\n";
    echo '[', $after[0], ']';
}
normalizeLabel(' Tea ');

[ Tea ]
[Tea]

Снимок скалярного значения before сделан до изменения. После trim у текущего параметра уже Tea, и func_get_args показывает Tea. Для объектов такая копия массива не создаёт независимую глубокую копию их состояния; не называйте её универсальным журналом исходного ввода.

<?php
function exportOptions($format = 'csv', $language = 'ru', ...$extra) {
    echo 'Настройки: ', $format, '/', $language, "\n";
    $arguments = func_get_args();
    if ($arguments === []) { echo "Обычных переданных позиций нет\n"; }
    foreach ($arguments as $position => $value) {
        echo 'Позиция ', $position, ': ', $value, "\n";
    }
    foreach ($extra as $name => $enabled) {
        echo 'Дополнительно ', $name, ': ', $enabled ? 'включено' : 'выключено', "\n";
    }
}
exportOptions(language: 'en', trace: true);
exportOptions(trace: true);

Настройки: csv/en
Позиция 0: csv
Позиция 1: en
Дополнительно trace: включено
Настройки: csv/ru
Обычных переданных позиций нет
Дополнительно trace: включено

Первый вызов задаёт language во второй объявленной позиции: func_get_args возвращает [csv,en], включая предыдущий default. Неизвестное имя trace собрано в extra и в этот список не входит. Во втором вызове нет обычных переданных позиций, массив пуст, хотя тело использует оба defaults csv/ru. Дополнительные поля этого примера — только булевы флаги; для произвольных внешних значений нужна отдельная схема. Позиции массива не восстанавливают исходную запись вызова.

<?php
function packingLabel($quantity = 1): string {
    if (func_num_args() === 0) {
        return 'Количество не указано: используем ' . $quantity . ' упаковку';
    }
    return 'Выбрано упаковок: ' . $quantity;
}
echo packingLabel(), "\n";
echo packingLabel(1), "\n";
echo packingLabel(3), "\n";

Количество не указано: используем 1 упаковку
Выбрано упаковок: 1
Выбрано упаковок: 3

Первый вызов не передал аргумент: quantity получает default 1, func_num_args возвращает 0 и выбирает специальную подпись. Второй явно передал 1: количество аргументов равно 1, хотя quantity совпадает с default. Третий тоже передал один аргумент — число 3, поэтому счётчик равен 1, а текст количества равен 3. Return каждого вызова попадает в соответствующий echo. Это уже проверенные положительные целые; пример разбирает происхождение настройки, не валидацию формы.

<?php
function requestLabel($newLabel = null) {
    static $label = 'Общий';
    if (func_num_args() > 0) { $label = $newLabel; }
    return $label;
}
echo 'До изменения: ', requestLabel(), "\n";
echo 'После записи: ', requestLabel('Импорт'), "\n";
$cleared = requestLabel(null);
echo 'После очистки: ', $cleared ?? 'подпись отключена', "\n";
echo 'Повторное чтение: ', requestLabel() ?? 'подпись отключена', "\n";

До изменения: Общий
После записи: Импорт
После очистки: подпись отключена
Повторное чтение: подпись отключена

Вызов без аргумента получает 0 из func_num_args и читает сохранённый label. Вызов с Импорт получает 1 и записывает строку. Явный null — тоже один аргумент: label очищается, return отдаёт null в cleared, и ?? выбирает пояснение отключения. Последний вызов снова читает сохранённое null. Static сохраняет значение между вызовами только внутри текущего выполнения. В новом API отдельные операции чтения и записи обычно проще; здесь показан договор старого интерфейса.

<?php
function showOptions($format = 'csv', $language = 'ru', ...$extra) {
    echo 'Формат/язык: ', $format, '/', $language, "\n";
    echo 'Позиции func_num_args: ', func_num_args(), "\n";
    foreach ($extra as $key => $value) {
        echo 'Extra[', $key, ']: ', is_bool($value) ? ($value ? 'true' : 'false') : $value, "\n";
    }
}
showOptions(language: 'en');
showOptions(debug: true);
showOptions('csv', 'ru', 'Дополнительная подпись');

Формат/язык: csv/en
Позиции func_num_args: 2
Формат/язык: csv/ru
Позиции func_num_args: 0
Extra[debug]: true
Формат/язык: csv/ru
Позиции func_num_args: 3
Extra[0]: Дополнительная подпись

Language заполняет вторую объявленную позицию, поэтому список нормализуется до двух значений csv/en. Debug не объявлен и попадает только в extra: func_num_args даёт 0, хотя тело использует defaults. Третий позиционный аргумент входит и в общее число 3, и в extra[0]. Эти числа нельзя складывать для подсчёта уникальных входов. Is_bool в выводе отделяет флаг от текста; скобки у вложенного выбора показывают две разные ветки форматирования.

<?php
function localOrderLabel($number) { return 'Заказ №' . $number; }
$name = 'LOCALORDERLABEL';
if (function_exists($name)) {
    $text = $name(41);
    echo $text, "\n";
}
foreach (['echo', 'missing_manual_helper'] as $candidate) {
    if (!function_exists($candidate)) {
        echo $candidate, ': не найдено имя функции', "\n";
    }
}

Заказ №41
echo: не найдено имя функции
missing_manual_helper: не найдено имя функции

Function_exists получает строку LOCALORDERLABEL и возвращает true: регистр обычного имени функции не препятствует нахождению. Проверка сама ничего не вызывает. Следующий отдельный $name(41) передаёт 41 в number, return даёт строку в text, затем echo печатает её. Echo — конструкция языка; missing_manual_helper не объявлена, поэтому обе проверки дают false и выбирают диагностические подписи. Произвольное внешнее имя нельзя считать разрешённой командой только потому, что функция существует.

<?php
$required = ['strtoupper', 'str_pad'];
$missing = [];
foreach ($required as $name) {
    if (!function_exists($name)) { $missing[] = $name; }
}
if ($missing !== []) {
    echo 'Недоступны: ', implode(', ', $missing), "\n";
} else {
    $sku = strtoupper('tea');
    $label = str_pad($sku, 8, '.', STR_PAD_RIGHT);
    echo '|', $label, '|', "\n";
}

|TEA.....|

Две проверки возвращают true в обычной сборке PHP, список missing остаётся пустым. Затем strtoupper возвращает ASCII-строку TEA, str_pad дополняет её справа до восьми байтов пятью точками, и echo показывает итог с границами. Проверка существования разрешила этот путь, но не проверяет правильность всех будущих входов. Если администратор отключил одну из функций, выполняется сообщение о недоступности. Пример намеренно использует ASCII, а не обещает такую же ширину или преобразование регистра для любого языка.

<?php
namespace ManualShop;
$name = __NAMESPACE__ . '\\optional_label';
if (!function_exists($name)) {
    echo "Запасное правило ещё не объявлено: создаём его\n";
    function optional_label($number) { return 'Магазин #' . $number; }
}
$text = optional_label(41);
echo $text, "\n";

Запасное правило ещё не объявлено: создаём его
Магазин #41

Строка name содержит полное ManualShop\optional_label. В начале условное объявление ещё не выполнено; function_exists возвращает false, ! разрешает ветку и функция появляется. Вызов после if передаёт 41, получает Магазин #41 в text и печатает результат. Обычное безусловное объявление верхнего уровня доступно раньше — не переносите этот порядок на него. Строковые имена не получают namespace или use function автоматически. Наличие заранее объявленного совместимого правила позволило бы пропустить fallback.

<?php
function manual_order_label($number) { return '#' . $number; }
$functions = get_defined_functions();
foreach ($functions['internal'] as $name) {
    if ($name === 'strlen') { echo 'Встроенная: ', $name, "\n"; }
}
foreach ($functions['user'] as $name) {
    if ($name === 'manual_order_label') { echo 'Пользовательская: ', $name, "\n"; }
}

Встроенная: strlen
Пользовательская: manual_order_label

Get_defined_functions без аргументов возвращает массив в functions. Ключ internal ведёт к списку встроенных имён, user — к списку пользовательских. Foreach читает реальные строки и выбирает нужные для ограниченного отчёта. Ни strlen, ни manual_order_label не выполняются: это содержимое таблицы, а не callback-вызовы. Для одной проверки существования function_exists проще; ниже применён полный снимок для отчёта о нескольких требуемых helper-именах.

<?php
function manual_export_csv() { return 'CSV'; }
function manual_export_json() { return 'JSON'; }
function unrelated_helper() { return 'Другой модуль'; }
$known = ['manual_export_csv', 'manual_export_json', 'manual_export_xml'];
$defined = get_defined_functions()['user'];
foreach ($known as $name) {
    echo $name, ': ', in_array($name, $defined, true) ? 'есть' : 'нет', "\n";
}

manual_export_csv: есть
manual_export_json: есть
manual_export_xml: нет

Фиксированный known — требования модуля. Отчёт помогает найти забытый include, но не вызывает функции и не доказывает правильность экспорта. В маленькой проверке те же строки проще получить через function_exists; таблица удобна, когда её уже анализируют целиком для ограниченного диагностического отчёта.