Application of closures of anonymous functions and calback in PHP

Lecture

Introduction to PHP 5.3 closures is one of its main innovations, and although several years have passed since the release, there is still no standard practice for using this language feature. In this article, I tried to collect all the most interesting possibilities for applying closures in PHP.

To begin, consider what it is - a closure and what are its features in PHP.

$g = 'test'; $c = function($a, $b) use($g){ echo $a . $b . $g; }; $g = 'test2'; var_dump($c); /* object(Closure)#1 (2) { ["static"]=> array(1) { ["g"]=> string(4) "test" } ["parameter"]=> array(2) { ["$a"] => string(10) "" ["$b"]=> string(10) "" } } */

As you can see, the closure, like the lambda function, is an object of the Closure class, which coordinates the passed parameters. In order to call an object as a function, the magic method __invoke was introduced in PHP5.3.

 function getClosure() { $g = 'test'; $c = function($a, $b) use($g){ echo $a . $b . $g; }; $g = 'test2'; return $c; } $closure = getClosure(); $closure(1, 3); //13test getClosure()->__invoke(1, 3); //13test

Using the use construct, we inherit the variable from the parent scope to the local scope of the Lambda function.
The syntax is simple and straightforward. The use of such functionality in the development of web applications is not entirely clear. I looked at the code of several modern frameworks that use the new features of the language and tried to bring together their various uses.

Callback functions

The most obvious use of anonymous functions is to use them as callbacks. In PHP, there are many standard functions that accept a callback type or its synonym callable as entered in PHP 5.4. The most popular ones are array_filter, array_map, array_reduce. The array_map function is used for iterative processing of array elements. The callback function is applied to each element of the array and the result is the processed array. I immediately had a desire to compare the performance of the usual array processing in a loop using the built-in function. Let's experiment.

 $x = range(1, 100000); $t = microtime(1); $x2 = array_map(function($v){ return $v + 1; }, $x); //Time: 0.4395 //Memory: 22179776 //--------------------------------------- $x2 = array(); foreach($x as $v){ $x2[] = $v + 1; } //Time: 0.0764 //Memory: 22174788 //--------------------------------------- function tr($v){ return $v + 1; } $x2 = array(); foreach($x as $v){ $x2[] = tr($v); } //Time: 0.4451 //Memory: 22180604

As you can see, the overhead of a large number of function calls gives a noticeable drop in performance, which is to be expected. Although the test is synthetic, the task of processing large arrays often arises, and in this case, the use of data processing functions can become the place where your application will significantly slow down. Be careful. However, in modern applications, this approach is used very often. It allows you to make the code more concise, especially if the handler is declared somewhere else, and not when called.

In fact, in this context, the use of anonymous functions is no different from the old way of passing a string name of a function or a callback array, except for one particular feature - now we can use closures, that is, save variables from the scope when creating a function. Consider an example of processing an array of data before adding them to the database.

 //объявляем функцию квотирования. $quoter = function($v) use($pdo){ return $pdo->quote($v);//использовать эту функцию не рекомендуется, тем не менее :-) } $service->register('quoter', $quoter); … //где-то в другом месте //теперь у нас нет доступа к PDO $data = array(...);//массив строк $data = array_map($this->service->getQuoter(), $data); //массив содержит обработанные данные.

It is very convenient to use anonymous functions and to filter

 $x = array_filter($data, function($v){ return $v > 0; }); //vs $x = array(); foreach($data as $v) { if($v > 0){$x[] = $v} }

Developments.

Closures are ideal as event handlers. for example

 //где-то при конфигурации приложения. $this->events->on(User::EVENT_REGISTER, function($user){ //обновить счетчик логинов для пользователя и т.д. }); $this->events->on(User::EVENT_REGISTER', function($user){ //выслать email для подтверждения. }); //в обработчике формы регистрации $this->events->trigger(User::EVENT_REGISTER, $user);

Putting logic into event handlers on the one hand makes the code cleaner, on the other hand complicates the search for errors — sometimes the behavior of the system becomes unexpected for a person who does not know which handlers are hung at the moment.

Validation

Closures essentially save some logic in a variable that can be executed or not executed in the course of the script. This is what you need to implement validators:

 $notEmpty = function($v){ return strlen($v) > 0 ? true : “Значение не может быть пустым”; }; $greaterZero = function($v){ return $v > 0 ? true : “Значение должно быть больше нуля”; }; function getRangeValidator($min, $max){ return function($v) use ($min, $max){ return ($v >= $min && $v <= $max) ? true : “Значение не попадает в промежуток”; }; }

In the latter case, we apply a higher order function that returns another function — a validator with predefined boundaries of values. You can use validators, for example, as follows.

 class UserForm extends BaseForm{ public function __constructor() { $this->addValidator('email', Validators::$notEmpty); $this->addValidator('age', Validators::getRangeValidator(18, 55)); $this->addValidator('custom', function($v){ //some logic }); } /** * Находится в базовом классе. */ public function isValid() { … $validationResult = $validator($value); if($validationResult !== true){ $this->addValidationError($field, $validationResult); } … } }

Using forms is a classic example. Also, validation can be used in setters and getters of ordinary classes, models, etc. It is true that declarative validation is considered to be a good way, when the rules are described not in the form of functions, but in the form of rules in configuration, however, sometimes this approach is very useful.

Expressions

Symfony has a very interesting use for closures. The ExprBuilder class defines an entity that allows you to build expressions like

 ... ->beforeNormalization() ->ifTrue(function($v) { return is_array($v) && is_int(key($v)); }) ->then(function($v) { return array_map(function($v) { return array('name' => $v); }, $v); }) ->end() ...

In symfony, as I understand it, this is an internal class that is used to create processing of nested configuration arrays (correct me if not right). An interesting idea is the implementation of expressions in the form of chains. In principle, it is possible to implement a class that would describe expressions in the following form:

 $expr = new Expression(); $expr ->if(function(){ return $this->v == 4;}) ->then(function(){$this->v = 42;}) ->else(function(){}) ->elseif(function(){}) ->end() ->while(function(){$this->v >=42}) ->do(function(){ $this->v --; }) ->end() ->apply(function(){/*Some code*/}); $expr->v = 4; $expr->exec(); echo $expr->v;

Application, of course, experimentally. In essence, this is a record of some algorithm. The implementation of such a functional is quite complicated - the expression in the ideal case should store a tree of operations. An interesting concept, maybe somewhere such a construction would be useful.

Routing

In many mini frameworks, routing now works on anonymous functions.

 App::router('GET /users', function() use($app){ $app->response->write('Hello, World!'); });

Enough convenient and concise.

Caching

 $someHtml = $this->cashe->get('users.list', function() use($app){ $users = $app->db->table('users)->all(); return $app->template->render('users.list', $isers); }, 1000);

Here, the get method checks the validity of the cache using the 'users.list' key and if it is not valid, then it accesses the function for data. The third parameter determines the duration of data storage.

Initialization On Demand

Suppose we have the Mailer service, which we call in some methods. It must be configured before use. In order not to initialize it every time, we will use lazy object creation.

 //Где-то в конфигурационном файле. $service->register('Mailer', function(){ return new Mailer('user', 'password', 'url'); }); //Где-то в контроллере $this->service('Mailer')->mail(...);

Object initialization will occur only before the very first use.

Change the behavior of objects

Sometimes it is useful to override the behavior of objects during script execution — add a method, override an old one, and so on. The closure will help us here too. In PHP5.3, you had to use different workarounds for this.

 class Base{ public function publicMethod(){echo 'public';} private function privateMethod(){echo 'private';} //будем перехватывать обращение к замыканию и вызывать его. public function __call($name, $arguments) { if($this->$name instanceof Closure){ return call_user_func_array($this->$name, array_merge(array($this), $arguments)); } } } $b = new Base; //создаем новый метод $b->method = function($self){ echo 'I am a new dynamic method'; $self->publicMethod(); //есть доступ только к публичным свойствам и методам }; $b->method->__invoke($b); //вызов через магический метод $b->method(); //вызов через перехват обращения к методу //call_user_func($b->{'method'}, $b); //так не работает

In principle, it is possible to override the old method, but only if it was defined in a similar way. Not quite comfortable. Therefore, in PHP 5.4, it became possible to associate a closure with an object.

 $closure = function(){ return $this->privateMethod(); } $closure->bindTo($b, $b); //второй параметр определяет область видимости $closure();

Of course, the modification of the object failed, however, the closure gains access to private functions and properties.

Passing as default parameters to data access methods

An example of getting a value from a GET array. In case of its absence, the value will be obtained by calling the function.

 $name = Input::get('name', function() {return 'Fred';});

Higher order functions

There was already an example of creating a validator. I will give an example from the lithium framework

 /** * Writes the message to the configured cache adapter. * * @param string $type * @param string $message * @return closure Function returning boolean `true` on successful write, `false` otherwise. */ public function write($type, $message) { $config = $this->_config + $this->_classes; return function($self, $params) use ($config) { $params += array('timestamp' => strtotime('now')); $key = $config['key']; $key = is_callable($key) ? $key($params) : String::insert($key, $params); $cache = $config['cache']; return $cache::write($config['config'], $key, $params['message'], $config['expiry']); }; }

The method returns a closure that can then be used to write the message to the cache.

Transfer to templates

Sometimes it is convenient to transfer not just data to a template, but, for example, a configured function that can be called from the template code to get any values.

 //В контроллере $layout->setLink = function($setId) use ($userLogin) { return '/users/' . $userLogin . '/set/' . $setId; }; //В шаблоне setLink->__invoke($id);?>>Set name

In this case, the template generated several links to the user's entities, and his login appeared in the addresses of these links.

Recursive closure definition

Finally, how to set recursive closures. To do this, pass a reference to the closure in use, and call it in code. Do not forget about the condition of the termination of recursion

 $factorial = function( $n ) use ( &$factorial ) { if( $n == 1 ) return 1; return $factorial( $n - 1 ) * $n; }; print $factorial( 5 );

Many of the examples look stiff. How many years have lived without them - and nothing. However, sometimes using closures is natural enough for PHP. Skillful use of this feature will make the code more readable and increase the efficiency of the programmer. You just need to adjust your thinking a little under the new paradigm and everything will fall into place. In general, I recommend to compare how such things are used in other languages like Python. I hope that someone has found something new here. And of course, if someone else knows any interesting applications of closures, then I’m really looking forward to your comments. Thank!

This small tutorial is designed to cover the topic of closures in PHP. First of all, it is worth explaining what a closure is. One definition of closure:

A closure is an anonymous function, that is, a function that does not have a name .

To some extent this reflects the essence of the closure. It is important to understand that closure is a kind of independent entity from a theoretical point of view and not to confuse the very concept of closure with how it is specifically implemented. Below I will describe what the difference is.

About applicability
In order to better understand the scope of closures, you should recall (or find out if you have not done so already) that there is a so-called data pseudotype in PHP - callback. In essence, variables of this type are, from the point of view of the interpreter, the entities for the call. In other words, data of this type can be used as functions. Strictly speaking, this type is wider than just closures; it can also include string names of functions. I will give a complete list:

0. Actually, the circuit
1. Strings that are the names of custom or standard functions (for example, "trim")
2. Names of methods, including static

It should be remembered that in the latter case, the actual callback data will be an array indicating the object in the element with a zero index and the name of the method in the element with the first index. For example:
PHP:
copy code to clipboard

// Proper callback variable of type 0:
$ fnCallback = function ($ sItem)
{
return trim ($ sItem);
};
// Proper callback variable of type 1:
$ fnCallback = "trim";
// Proper callback variable of type 2 (indicating that the data will be processed as Foo-> bar)
$ fnCallback = array ("Foo", "bar");

- the first time I specify the syntax of closures for the first time, which is probably premature, but if you don’t understand it, skip and return to the example later. Callback data can be used in functions, for example, array_walk or call_user_func .

Little formality
Now it's time to talk about how closures are built. Depending on the PHP version, they can:

0. Not supported at all, PHP version <4.0.1
1. Only supported via create_function, PHP version 4> = 4.0.1 or PHP 5 <5.3
2. To be supported both through create_function and through special syntax.

The option when closures are not supported at all, we are not interested, and therefore I will talk about two ways to create closures (those in paragraphs 1. and 2.).
So, creating closures with create_function :
Of course, the most complete description of this function is on the official site, but I will do some summary.
The function takes two parameters and both are string. The line-list of arguments separated by a comma is indicated by the first parameter, the PHP code is indicated by the second parameter.
I will give an example: