Analysis of closures and anonymous functions in PHP

A closure refers to a function that encapsulates surrounding state when created. Even if the environment in which the closure is located no longer exists, the state encapsulated in the closure still exists. 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. I hope it can help everyone.

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 assigns 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 look for 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 do not automatically encapsulate the application state like real javascrypt closures. 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 multiple parameters like the parameters of a PHP function or method.

Use the bindTo() method to attach the closure's state

Similar to other PHP objects, each closure instance can use the $this keyword to obtain the closure's internal state. 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
*/

Related recommendations:

How to use closures to obtain external variables in PHP

In-depth understanding of javascript closures

What are anonymous functions, nested functions, and closures?

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