A brief analysis of closures and anonymous functions in PHP

PHP closures and anonymous functions use the same syntax as ordinary functions, but closures and anonymous functions are actually objects (instances of the Closure class) disguised as functions. Let me introduce to you the knowledge of closures and anonymous functions in PHP. Friends who need it can refer to it

Closure refers to a function that encapsulates the surrounding state when it is created. Even if the environment in which the closure is located no longer exists, the state encapsulated in the closure still exists.

Anonymous function is a function without a name. Anonymous functions can be assigned to variables and passed around like any other PHP object. However, anonymous functions are still functions, so they can be called and parameters can be passed in. Anonymous functions are particularly suitable as callbacks for functions or methods.

Note: Theoretically, closures and anonymous functions are different concepts. However, PHP treats it as the same concept. Therefore, when we refer to closures, we are also referring to anonymous functions, and vice versa.

PHP closures and anonymous functions use the same syntax as ordinary functions, but closures and anonymous functions are actually objects (instances of the Closure class) disguised as functions.

Create closure

$closure = function($name){
  return sprintf("Hello %s", $name);
}
echo $closure("jerry");
// 检测$closure变量是否是一个闭包
var_dump($closure instanceof Closure);

The above code creates a closure object, and then Assign it to the $closure variable. Closures are very similar to ordinary PHP functions. They use the same syntax, receive parameters, and can return values.

Explanation: The reason why we can call the $closure variable is because the value of this variable is a closure, and the closure object implements the __invoke() magic method. As long as there is () after the variable name, PHP will find and call the __invoke() method.

Using closures

We usually use PHP closures as callbacks for functions and methods. Many PHP functions use callback functions, such as array_map() and preg_replace_callback(). In the following example, we will use array_map() to process the array and increment each item in the array by 1 :

$nubmers = array_map(function($number){
  return $number++;
}, [1,2,3]);
var_dump($numbers);

Additional status

PHP closures will not behave like real javascrypt closures To automatically encapsulate the application's state like a package, we must manually call the bindTo() method of the closure object or use the use keyword to attach the state to the PHP closure.

Use the use keyword

It is more common to use the use keyword to attach closure state, so we will look at this method first. When you attach a variable to a closure using the use keyword, the attached variable remembers the value assigned to it when attached.

function Car ($name){
  return function($statu)use($name){
    return sprintf("Car %s is %s", $name, $statu); 
  }
}
// 将车名封装在闭包中
$car = Car("bmw");
// 调用车的动作
// 输出--> "bmw is running"
echo $car("running");

Note: Use the use keyword to pass multiple parameters into the closure. In this case, use commas to separate them like the parameters of a PHP function or method. Multiple parameters.

Use the bindTo() method to attach the state of the closure

Similar to other PHP objects, each closure instance can use $this Keyword gets the internal state of the closure. The default state of the closure object is useless, but there is an __invoke() magic method and a bindTo() method.

The bindTo() method adds some interesting potential to closures. We can use this method to bind the internal state of the Closure object to other objects.

The second parameter of the bindTo() method is very important. Its function is to specify the PHP class to which the object of the binding closure belongs. Therefore, a closure can access protected and private member variables in the object to which the closure is bound.

class TestClosure
{
  private $name=[];
  private $age;
  private $sex;
  public function addPerson($name, $personCallback){
    // 将闭包对象绑定当前实例
    $this->name[$name] = $personCallback->bindTo($this, __CLASS__);
  }
  public function display($name){
    foreach ($this->name as $key => $callback){
      if($key == $name){
        // 执行闭包对象，将闭包状态附加到类
        $callback();
      }
    }
    echo "name : {$name}\n";
    echo "age : {$this->age}\n";
    echo "sex : {$this->sex}\n";
  }
}
$person = new TestClosure();
$person->addPerson("jerry", function(){
  $this->age = 19;
  $this->sex = "man";
});
$person->display("jerry");
/** output
name : jerry
age : 19
sex : man
*/

Summary

The above is the PHP that the editor introduces to you Closures and anonymous functions, I hope it will be helpful to everyone. If you have any questions, please leave me a message and the editor will reply to you in time. I would also like to thank you all for your support of the php Chinese website!

Articles you may be interested in:

Source code analysis Laravel explains the reasons for repeatedly executing the same queue task

Detailed explanation of the problem of multiple processes taking queues at the same time in Laravel Redis

Detailed explanation of php-msf source code

The above is the detailed content of A brief analysis of closures and anonymous functions in PHP. For more information, please follow other related articles on the PHP Chinese website!