Callback functions and anonymous functions in PHP

Pillow Book

Always be in awe.

Callback functions and anonymous functions in PHP

Foreword

I was so busy at the company some time ago that my head felt heavy when I came home from get off work every day. There are various things going on on Saturdays and Sundays, and I don’t want to start typing, so I have put off blogging. I have a feeling that I won’t be too busy in the near future, so I will start to have time to write, summarize and share my harvest, welcome to follow.

Callback functions and anonymous functions

Callback functions and closures are no strangers to JS. JS can use them to complete the event mechanism and perform many complex operations. It is not commonly used in PHP. Today, let’s talk about callback functions and anonymous functions in PHP.

Callback function

Callback function: Callback (that is, call then back will return to the main function after being called by the main function) refers to a reference to a certain block of executable code that is passed to other codes through function parameters.

The popular explanation is to pass the function as a parameter into another function for use; there are many functions in PHP that "require parameters as functions", such as array_map, usort, call_user_func_array, etc. They execute the passed in function and then directly Return the result to the main function. The advantage is that functions are convenient to use as values, and the code is concise and readable.

Anonymous function:

Anonymous function, as the name suggests, is a function without a determined function name. PHP treats anonymous functions and closures as the same concept (anonymous functions are also called closure functions in PHP). Its usage, of course, can only be used as a variable.

There are four ways to assign a function to a variable in PHP:

We often use: the function is defined externally/or built-in in PHP, and the function name is directly passed in as a string parameter. Note: If it is a class static function, it is passed in as CLASS::FUNC_NAME.

Use create_function($args, $func_code); to create a function, which will return a function name. $func_code is the code body, $args is the parameter string, separated by ',';

Direct assignment: $func_name = function($arg){statement};

Use the anonymous function directly and define the function directly at the parameter. Do not assign specific variable values;

The first method is not mentioned anymore because it is commonly used; the second method, similar to the eval() method, is also officially listed as a deprecated method by PHP, and its definition The method is too unintuitive. I have never used it in other places except for testing, so I will not mention it. Here we focus on the third and fourth usages;

The functions created by the latter two are called anonymous functions, that is, closure functions. The functions created by the third assignment method are very flexible and can be passed through variables. Quote. You can use is_callable($func_name) to test whether this function can be called, or you can call it directly through $func_name($var); the function created in the fourth way is more similar to the callback function in JS and does not require variable assignment. , used directly;

Another special introduction is the use keyword, which can be used to reference variables in the parent scope when defining a function; the usage is function($arg) use($outside_arg) {function_statement}. Among them, $outside_arg is a variable in the parent scope and can be used in function_statement.

This usage is used in the callback function "the number of parameter values ​​is determined". For example, usort requires that the parameter value of $callback be two items, but what if we need to introduce other parameters to affect the sorting? Using the use() keyword, it is very convenient to introduce a new variable into $callback for internal use.

array_map/array_filter/array_walk:

Put these three functions together because the execution logic of these three functions is relatively similar, similar to the following code:

$result = [];
foreach($vars as $key=>$val){
    $item = callback();
    $result[] = $item;
}
return $result;

array_walk($vars, $callback)

The callback should be as follows:

$callback = function(&$val, $key[, $arg]){    
            doSomething($val);
        }

array_walk returns whether the execution is successful, which is a Boolean value. Adding a reference symbol to $value can change the $value value within the function to achieve the effect of changing the $vars array. Since its $callback requires two parameters, array_walk cannot pass in $callbacks such as strtolower/array_filter. If you want to achieve similar functions, you can use array_map() to be discussed next.

array_walk_recursive($arr, $callback);

The return value and execution mechanism are similar to array_walk;

The callback is the same as array_walk, the difference is that if $val is an array, the function will recursively process $val downwards ; It should be noted that in this case, $val is the $key of the array and will be ignored.

array_filter($vars, $callback, $flag);

its $callback is similar to:

$callback = function($var){
            　　return true or false;         
            }

array_filter will filter out items that return false when $callback is executed, and array_filter returns the array after filtering is completed.

The third parameter $flag determines the value of its callback parameter $var, but this may be a feature of higher versions of PHP. My PHP5.5.3 does not support it. You can test it yourself. By default, the value of each item in the array is passed in. When the flag is ARRAY_FILTER_USE_KEY, the key of each item in the array is passed in, and ARRAY_FILTER_USE_BOTH is passed in the key and value;

array_map($callback, &$var_as [,$var_bs...]) ;

its $callback is similar to:

$callback = function($var_a[, $var_b...]){
            doSomething($var_a, $var_b);
        }

返回$var_as经过callback处理后的数组（会改变原数组）；如果有多个数组的时候将两个数组同样顺序的项目传入处理，执行次数为参数数组中项目最多的个数；

usort/array_reduce

把这两个函数放在一块，因为他们的执行机制都有些特殊。

usort(&$vars, $callback)

$callback应该如下：

    callback = function($left, $right){
        $res = compare($left, $right);
        return $res;
    }

usort返回执行成功与否，bool值。用户自定义方法 比较$left 和 $right，其中$left和$right是$vars中的任意两项；

$left > $right时返回 正整数， $left < $right时返回 负整数， $left = $right时返回0；

$vars中的元素会被取出会被由小到大升序排序。 想实现降序排列，将$callback的返回值反一下就行了。

array_reduce($vars ,$callable [, mixed $initial = NULL])

$callback应该如下：

    $callback = function($initial, $var){
        $initial = calculate($initail, $var);
        return $initial;
    }

初始值$initial默认为null，返回经过迭代后的initial；一定要将$initial返回，这样才能不停地改变$initial的值，实现迭代的效果。

这里顺便说一下map和reduce的不同：

map：将数组中的成员遍历处理，每次返回处理后的一个值，最后结果值为所有处理后值组成的多项数组；

reduce：遍历数组成员，每次使用数组成员结合初始值处理，并将初始值返回，即使用上一次执行的结果，配合下一次的输入继续产生结果，结果值为一项；

call_user_func/call_user_func_array

call_user_func[_array]($callback, $param)

$callback形如：

    $callback = function($param){
        $result = statement(); 
        return $result;
    }

返回值多种，具体看$callback。

可用此函数实现PHP的事件机制，其实并不高深，在判断条件达成，或程序执行到某一步后 call_user_func()就OK了。这个我在之前的博客中也有介绍到：搭建自己的PHP框架心得（二）

总结

其实以上$callback不用单独定义并使用变量引用，使用上面说过的第四种函数定义方式，直接在函数内定义，使用‘完全’匿名函数就行了。 如：

usort($records, function mySortFunc($arg) use ($order){
    func_statement;
});

是不是逼格满满呢？

OK，介绍了几个用法~希望对大家有帮助，如果有问题，欢迎指出，如果您喜欢，可以点下推荐~