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

Обычные функции

Начнем с самого простого способа создания функций, который существует с момента появления языка. Зарегистрируем константную функцию с помощью ключевого слова function:

function hello(){
	return 'Hello World!';
}

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

function createMessage($verb, $subject){
	return "$verb $subject!";
}

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

function createMessage(string $verb, string $subject): string {
	return "$verb $subject!";
}

И получаем функцию, в которую нельзя передать параметры неправильного типа или получить результат неправильного типа не получится. Получаем вот такие результаты вызова:

createMessage('Hello', 'World'); // 'Hello World!'
createMessage(123, false) //InvalidArgumentException

Это все база, от которой будем далее отталкиваться. Но если хочется проверить свои знания функций в PHP, то можно обратиться к разделу в официальной документации (EN/RU)

Вызываемый класс

Хотя в этой статье мы больше говорим о процедурном подходе, стоит упомянуть, что и сущности классов можно вызывать как обычные функции. Для этого в классе должен быть реализован метод __invoke:

class Message
{
    public function __invoke(string $verb, string $subject): string {
		return "$verb $subject!";
	}
}

$message = new Message();

$message('Hello', 'World'); // Hello World!

Использование этого метода встречается редко, так как он сильно усложняет чтение кода, в котором экземпляр класса становится функцией. Но все таки встречается

Анонимные функции (Замыкания/Closures)

У функций описанных в предыдущем разделе есть важный общий момент – у них всех есть имя. Но мы можем создать и вариант функции без имени:

function(string $verb, string $subject): string {
	return "$verb $subject!";
};

Такая функция называется анонимной ведь у нее нет имени. Еще в PHP такие функции называют замыканиями или closure. Это может сбить с толку людей, знакомых с JS, где замыкание – это про получение доступа к переменной вне функции. Но разработчики PHP не решили нас запутать, а просто взяли концепцию из C подобных языков, в которых замыкания – синтаксический сахар для создания анонимных функций. И в PHP тоже есть класс Closure, и анонимная функция под капотом создает экземпляр этого класса, но о нем позднее, а пока вернемся к нашему примеру.

Хотя в нем синтаксически все верно, есть проблема – анонимную функцию никак не вызвать поэтому давайте запишем ее в переменную:

$createMessage = function(string $verb, string $subject): string {
	return "$verb $subject!";
};

И теперь, хотя функция анонимна и не может быть вызвана самостоятельно, у нас есть переменная, которая указывает на функцию и дает возможность с ней работать:

$createMessage('Hello', 'World'); // 'Hello World!'

И самый частый способ использования анонимных функций – это их передача в качестве параметра других функций.

Callback функции

В PHP есть специальный тип callable, который обозначает что-то, что можно вызвать как функцию. Он объединяет в себя различные типы, не все из которых выглядят очевидно:

Обычные функции / Строки

Функции созданные обычным способом можно вызвать, а значит они соответствуют типу callable. Давайте создадим такую:

function add(int $a, int $b): int {
	return $a+$b;
}

И передадим их в функцию array_reduce, которая преобразует массив данных в соответствии с правилами, описанными в переданной callback функции:

array_reduce([3,2,1], add, 0);

Иииии получим ошибку Undefined constant "add", а все, потому что в PHP строка вне кавычек и без доллара в начале считается за константу. Но есть решение этой проблемы – нужно всего лишь обернуть имя функции в кавычки и она заработает:

array_reduce([3,2,1], 'add', 0); //6

В целом любую функцию в PHP можно вызывать используя кавычки: 'add'(1,2), но это только для тех, кому платят за каждый символ в коде.

Кстати таким образом можно использовать и встроенные в язык функции, например здесь функция trim применилась ко всем

array_map('trim', [' foo ', 'bar ', ' baz']); //['foo', 'bar', 'baz']

Анонимные функции

В примере выше имя функции использовалось для указания на нее, но гораздо удобнее использовать анонимные функции, как callback функции. Доработаем предыдущий пример:

$add = function (int $a, int $b): int {
	return $a+$b;
};

И теперь воспользуемся ей при вызове функции array_reduce:

array_reduce([3,2,1], $add, 0); //6

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

array_reduce([3,2,1], function($a, $b) {
	return $a+$b;
}, 0); //6

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

Массивы

Точнее один вид массива, состоящий из двух элементов, где первый элемент – это экземпляр класса, а второй – публичный метод класса:

class Math {
	public function add (int $a, int $b): int {
		return $a+$b;
	}
}

В примере все та же функция add, только теперь это уже метод класса Math. Создадим экземпляр класса Math и воспользуемся методом add как callback функцией:

array_reduce([3,2,1], [new Math, 'add'], 0); //6

Проблема такой записи в том, что на ней может ломаться статический анализ кода текстового редактора и вместе с ним быстрый поиск метода. Хотя такое сейчас встречаю уже редко

Таким же способом можно вызывать и статические методы, только вместо сущности класса, нужно указать сам класс:

class Math {
	public static function add (int $a, int $b): int {
		return $a+$b;
	}
}

array_reduce([3,2,1], [Math::class, 'add'], 0); //6

First class callable syntax

"Зачем нам вызывать функции из строк, если мы можем явно создавать ссылки на функции?" подумали разработчики PHP, готовя релиз версии 8.1 и добавили фичу со странным названием из заголовка, но оно имеет смысл. В программировании "Первоклассными сущностями" называются те элементы программы, которые могут быть присвоены переменной, переданы как параметр, возвращены из функции. То есть First class callable - это ничто иное как уже известная нам анонимная функция (Closure/Замыкание).

Сам синтаксис же состоит из конструкции (...), которую нужно использовать после callable сущности для создания анонимной функции на ее основе:

class Math {  
	public function add(int $a, int $b): int {}  
	public static function addStatic(int $a, int $b): int {}  
	public function __invoke(int $a, int $b): int {}  
}  
  
$math = new Math();  
  
//Встроенные функция
strlen(...);
'strlen'(...);  

//Массивы
[$math, 'add'](...);  
[Math::class, 'addStatic'](...);
  
//Invokable объекты
$math(...);

//Методы объекта и класса
$math->add(...);  
Math::addStatic(...);

В итоге если вы работаете с версией PHP 8.1+, то вместо оборачивания функций в кавычки и создания массивов для передачи метода, можно использовать единый синтаксис (...)

Use - получение данных из родительского контекста

Попробуем умножить массив чисел на переменную определенную вне анонимной функции. По умолчанию анонимные функции в PHP не имеют доступа к внешним переменным, поэтому следующий пример работать не будет:

$multiplier = 2;  
  
array_map(function ($num) use ($multiplier) {  
    return $num * $multiplier; // Warning: Undefined variable $multiplier
}, [1, 2, 3]); // [0,0,0]

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

$multiplier = 2;  
  
array_map(function ($num) use ($multiplier) {  
    return $num * $multiplier;
}, [1, 2, 3]); // [2,4,6]

Но на самом деле неверно про такой код говорить, что он захватывает переменную. Нет, он захватывает лишь значение переменной, что демонстрирует следующий пример:

  
$multiplier = 2;  
  
$func = function ($num) use ($multiplier) {  
    return $num * $multiplier;  
};  
  
array_map($func, [1, 2, 3]); // Ожидаемые [2,4,6]  
  
$multiplier = 4;  
  
array_map($func, [1, 2, 3]); // Все еще [2,4,6]

Здесь работают такие же правила, как и с передачей аргументов в функцию. По умолчанию примитивные типы и массивы передаются по значению (опустим детали оптимизации), и только экземпляры классов передаются по ссылке. Это легко продемонстрировать, заменим значение $multiplier на класс:

final class Multiplier {  
    public function __construct(  
        private int $multiplier  
    ) {}  
  
    public function getMultiplier(): int {  
        return $this->multiplier;  
    }  
  
    public function setMultiplier(int $multiplier): void {  
        $this->multiplier = $multiplier;  
    }  
}  
  
$multiplier = new Multiplier(2);  
  
$func = function ($num) use ($multiplier) {  
    return $num * $multiplier->getMultiplier();  
};  
  
array_map($func, [1, 2, 3]); // Умножаем на 2 - [2,4,6]  
  
$multiplier->setMultiplier(4);  
  
array_map($func, [1, 2, 3]); // А теперь на 4 [4,8,12]

Для того чтобы в функцию передавать аргументы по ссылке, требуется чтобы перед именем параметра в теле функции стоял знак &. То же самое работает и с use, вернемся к последнему примеру с неверной логикой и починим его:

$multiplier = 2;  
  
$func = function ($num) use (&$multiplier) {  
    return $num * $multiplier;  
};  
  
array_map($func, [1, 2, 3]); // Ожидаемые [2,4,6]  
  
$multiplier = 4;  
  
array_map($func, [1, 2, 3]); // Тоже ожидаемые [4,8,12]

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

Но все таки автоматический захват внешних переменных для анонимных функций существует. Точнее только одной переменной - $this. Следующий пример будет работать даже без применения use:

class Multiplier {  
    public function __construct(  
        private int $multiplier  
    ) {  
    }  
    public function getMultipliedArray(array $array): array  
    {  
        return array_map(  
            function ($num) {  
                return $num * $this->multiplier; // Используем $this без use  
            },  
            $array  
        );  
    }  
}  
  
(new Multiplier(2))->getMultipliedArray([1,2,3]); // Результат - уже знакомый массив [2,4,6]

Если же внутри анонимной функции не предполагается использование переменной $this, то функцию стоит объявить статической. Тогда автоматический захват $this будет отключен. Это предотвращает потенциальную утечку памяти, в случае если указатель на экземпляр класса останется существовать внутри замыкания. Объявляется статическая анонимная функция следующим образом:

$f = static function() {}; // Больше никакого $this

Стрелочные функции

В PHP 7.4 появился способ автоматически захватывать внешние переменные в анонимных функциях. Для этого вместо привычного синтаксиса создания функции, нужно применить "стрелочный" или "сокращенный" вариант: fn (argument_list) => expr. Вот так выглядит применение стрелочной функции в примере с умножением массива:

$multiplier = 2;  
  
array_map(  
    fn($num) => $num * $multiplier,  
    [1, 2, 3]  
); // [2,4,6]

Конструкция use в данном случае не нужна. Захват происходит автоматически и только по значению. А также пропал оператор return, значение вычисленное в функции автоматически возвращается из нее.

А что делать если нужно выполнить несколько действий в одной стрелочной функции? Не использовать стрелочную функцию! В стрелочной может быть только одно выражение, И хотя это является ограничением, оно становится менее серьезным если уметь в функциональный подход, использовать тернарный оператор, использовать функции для преобразования данных (array_map вместо foreach цикла, например)

Попытка снятия ограничения была в 2022 году. Тогда было создано RFC Short Closures 2.0 по внедрению многострочных стрелочных функций в PHP 8.2, но ему не хватило перевеса в 1-2 голоса из 43 полученных для принятия в стандарт языка. Первая же версия этого RFC от 2015 года провалилась полностью. Возможно в будущем будет и третья уже удачная попытка.

Closure - как создается анонимная функция

Как я уже упоминал, анонимные функции – это синтаксический сахар для создания экземпляра класса Closure. Вот только создать экземпляр этого класса напрямую с помощью оператора new не получится, ведь у него приватный конструктор и сам класс финальный. Это подтверждает структура класса из официальной документации:

final class Closure {
	private __construct()
	
	public static bind(Closure $closure, ?object $newThis, object|string|null $newScope = "static"): ?Closure
	
	public bindTo(?object $newThis, object|string|null $newScope = "static"): ?Closure
	
	public call(object $newThis, mixed ...$args): mixed
	
	public static fromCallable(callable $callback): Closure
}

Но есть фабричный метод fromCallable, который из callable типа создает замыкание, например вот так:

function greet($name) { 
	return "Hello, " . $name; 
} 

$closure = Closure::fromCallable('greet'); 

$closure instanceof Closure; // true

На самом деле мы уже обсудили все варианты создание Closure из callable, когда говорили про First class callable syntax, ведь конструкция (...) – это тоже синтаксический сахар, только уже для метода Closure::fromCallable.

BindTo, Bind и Call - указание контекста

В структуре класса Closure еще осталось еще три метода. Все они нужны для изменения контекста вызова анонимной функции. Все три функции используются для подмены $this на требуемый объект, а bindTo и bind еще могут менять статическую область видимости.

bindTo

Начнем с метода bindTo. Так как Closure – это класс с методами, а анонимная функция – это экземпляр класса Closure, то у этой функции можно вызывать методы, как у обычного объекта. И метод bind мы как раз можем вызвать для изменения контекста:

class Num5 {  
    public int $num = 5;  
}  
  
class Num10 {  
    public int $num = 10;  
}  
  
$func = function (int $a): int {
    return $a * $this->num;  
};  
  
$func5  = $func->bindTo(new Num5());  
$func10 = $func->bindTo(new Num10());  
  
$func5(5); // 25  
$func10(5); // 50

Функция $func внутри себя обращается к объекту через $this, но сразу этот объект не определен. Требуется с помощью метода bindTo указать на требуемый $this. В примере выше на место $this становятся экземпляры классов Num5 и Num10.

То же самое можно провернуть и со статическими свойствами и методами. Только теперь вместо передачи экземпляра класса в первый параметр, нужно передать сам класс во второй параметр:

class Num5 {  
    static int $num = 5;  
}  
  
class Num10 {  
    static int $num = 10;  
}  
  
$func = function (int $a): int {
    return $a * static::$num;  
};  
  
$func5  = $func->bindTo(null, Num5::class);  
$func10 = $func->bindTo(null, Num10::class);  
  
$func5(5); // 25  
$func10(5); // 50

Но что самое интересное, таким образом можно получить доступ и к приватным свойствам класса. Для этого нужно использовать сразу оба параметра. Первый укажет на конкретный экземпляр класса, а второй изменит видимость private и protected методов:

class Num5 {  
    private int $num = 5;  
}  
  
class Num10 {  
    protected int $num = 10;  
}  
  
$func = function (int $a): int {  
    return $a * $this->num;  
};  
  
$func5  = $func->bindTo(new Num5(), Num5::class);  
$func10 = $func->bindTo(new Num10(), Num10::class);  
  
$func5(5); // 25  
$func10(5); // 50

Злоупотреблять таким подходом я крайне не рекомендую. Слишком сильно можно запутать код свободными обращениями к защищенным данным. Но как хак на крайний случай имеет место быть.

bind

Все что было рассказано про метод bindTo верно и для bind. Только вызывается он статически на классе Closure и callable переменная передается в него первым параметром, а $this и контекст – вторым и третьим:

class Num5 {  
    private int $num = 5;  
}  
  
class Num10 {  
    protected int $num = 10;  
}  
  
$func = function (int $a): int {  
    return $a * $this->num;  
};  
  
$func5  = Closure::bind($func, new Num5(), Num5::class);  
$func10 = Closure::bind($func, new Num10(), Num10::class);  
  
$func5(5); // 25  
$func10(5); // 50

call

Метод call тоже во многом поход на bind, но только он не возвращает обновленное замыкание, а сразу его вызывает и возвращает результат вызова. Первым аргументом call принимает $this, который требуется установить, а далее через запятую параметры функции:

class Num5 {  
    private int $num = 5;  
}  
  
class Num10 {  
    protected int $num = 10;  
}  
  
$func = function (int $a): int {  
    return $a * $this->num;  
};  
  
$func->call(new Num5(), 2); //10  
$func->call(new Num10(), 2); //20

Также защищенные данные сразу станут доступны внутри функции вызванной с помощью call

Подводя итоги

В PHP уже с 7 версии есть множество способов работы с функциями. С версии 8 этих способов стало еще больше. Работая с современным PHP, не стоит везде использовать обычные (глобальные) функции. Нужно использовать еще анонимные и стрелочные, работать с областями видимости.

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

А как у вас с функциями в PHP? Какие подходы используете для работы в процедурном и функциональном стилях?