Пара слов о программировании

Анонимные функции часто используются в современных языках программирования, они популярны в Ruby, Javascript и Python. А в PHP до версии 5.3 не было истинно анонимных функций. Хотя для начинающих программистов сложно найти им применение, их использование это очень элегантное решение некоторых практических задач.

Переменные-функции в PHP

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

function Hello($name)
{
    echo "Привет, $name";
}

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

$func = "Hello";
$func("Мир!");
 
// результат:
//Привет, Мир!

Другой пример, используя класс и статический метод:

<?php
class CHello
{
    static function Hello($name)
    {
        echo "Привет, $name";
    }
}
$func = "Hello";
CHello::$func("Мир!");
 
// результат:
// Привет, мир!
?>

Анонимные или лямбда функции

Бывает, необходимо создать небольшую локальную функцию, состоящую всего из нескольких строк, например, для обратного вызова. Глупо загрязнять глобальное пространство имен такого рода одноразовыми функциями. Гораздо лучше создать анонимную или лямбда функцию используя create_function. Анонимные функции позволяют создать функции у которых нет имени. Рассмотрим на примере:

<?php
$str = "Привет, Мир!";
$lambda = create_function('$match', 'return "Друг!";');
$str = preg_replace_callback('/Мир/', $lambda, $str);
echo $str ;
?>

Здесь мы создали маленькую безымянную (анонимную) функцию, которая вызывается в функции preg_replace_callback. Хотя create_function позволяет создать анонимные функции, это не часть языка, а "хак". PHP 5.3 поддерживает по настоящему анонимные функции как часть языка. Мы создаем безымянную функцию и присваиваем её переменной и затем просто используем эту переменную как функцию. Пример:

<?php
$func = function($name)
{
    echo "Привет, $name\n";
};
 
$func("Мир!");
$func("Алексей!");
 
// результат:
//Привет, Мир!
//Привет, Алексей!
?>

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

<?php
$str = "Привет, Мир!";
$func = function($match)
{
    return "друг!";
};
 
$str = preg_replace_callback('/Мир/', $func, $str);
echo $str ;
?>

Анонимные и вложенные функции

PHP позволяет вкладывать функции внутрь друг друга. Хотя это выглядит скорее подобно побочному эффекту парсера, чем намеренному решению, но зато очень помогает в некоторых случаях. Рассмотрим на примере. Функция censorString принимает строку как параметр и заменяет нужные слова в строке на "*". Функция censorString определяет вложенную функцию replace, которая используется при вызове preg_replace_callback. Учитывая то, что функция replace используется в нашей программе только в функции censorString, лучше всего определить ее как вложенную, чтобы не загрязнять пространство имен.

<?php
function censorString($string, $censor)
{
    function replace($match)
    {
        return str_repeat("*", strlen($match[0]));
    }
 
    return preg_replace_callback('/'.$censor.'/', 'replace', $string);
 
}
 
echo censorString("Привет, мир!", "мир");
echo censorString("Привет, мир!", "Привет");
 
// результат:
// Привет, ***!
// Fatal error: Cannot redeclare replace() 
?>

При таком определении функции как в примере выше, вложенная функция не существует до тех пор, пока не начнется выполняться родительская функция. Как только выполняется родительская функция (censorString), вложенная функция появляется в глобальном пространстве имен. Теперь мы можем получить доступ к вложенной функции из любого места программы. Проблема состоит в том, что при повторном вызове родительской функции будет сделана попытка передекларировать вложенную функцию, что вызовет ошибку, так как она уже существует. Решение в том, чтобы использовать вложенную функцию, как это показано ниже. (Обратите внимание на точку с запятой в конце вложенной функции.)

<?php
 function censorString($string, $censor)
{
    $func = function($match)
    {
        return str_repeat("*", strlen($match[0]));
    };
 
    return preg_replace_callback('/'.$censor.'/', $func, $string);
 
}
 
echo censorString("Привет, мир!", "мир");
echo censorString("Привет мир!", "Привет");
 
// результат:
// Привет, ***!
// ******, мир!
?>

Теперь вложенная функция появляется только на время выполнения censorString. Итак, мы можем повторно вызывать функцию censorString без того, чтобы вызвать ошибку передекларации.

Другой способ определить вложенную функцию:

<?php
function censorString($string, $censor)
{
 
    return preg_replace_callback('/'.$censor.'/', 
                                function($match) 
                                {
                                    return str_repeat("*", 
                                           strlen($match[0]));
                                },
                                $string);
 
}
 
echo censorString("Привет, мир!", "мир");
echo censorString("Привет, мир!", "Привет");
 
// результат:
// Привет, ***!
// ******, мир!
?>

Замыкания

Замыкание это анонимная функция со своим контекстом. Короче говоря, это функция, которая знает о переменных, не определенных в ней. Рассмотрим на простом примере. Скажем, мы хотим создать анонимную функцию, которая умножает число на 5.

<?php
$mult = function($x)
{
    return $x * 5;
};
 
echo $mult(2);
 
// результат:
// 10
?>

Если мы хотим чтобы число умножалось на 7 вместо 5, нам необходимо создавать другую функцию. Вместо того чтобы создавать несколько почти одинаковых функций, создадим замыкание, используя конструкцию use, которая дает анонимной функции доступ к внешним переменным и "замыкает" их в текущей функции.

<?php
$multiply = function($multiplier)
{
    return function($x) use ($multiplier)
    {
        return $x * $multiplier;
    };
};
 
// $mul5 теперь содержит функцию, которая умножает аргумент на пять
$mult5 = $multiply(5);
 
// $mul7 теперь содержит функцию, которая умножает аргумент на семь
$mult7 = $multiply(7);
 
echo $mult5(5);
echo $mult7(5);
 
// результат:
// 25
// 35
?>

Лямбда функции и замыкания приближают PHP по функциональности к другим современным языкам. И это хорошо :)