PHP Closures and Anonymous Functions (Detailed Tutorial)

亚连
Release: 2023-03-30 20:04:02
Original
1661 people have browsed it

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);
Copy after login

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 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);
Copy after login

Additional state

PHP closures do not automatically encapsulate the application's state like real javascrypt closures do, we must call it manually Attach state to a PHP closure using the closure object's bindTo() method or using the use keyword.

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");
Copy after login

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 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
*/
Copy after login

The above is what I compiled for everyone. I hope it will be helpful to everyone in the future.

Related articles:

Custom events in Vue components (detailed tutorial)

How to implement the ball following the mouse using JS Mobile

Detailed introduction to the basic use of NW.js

The above is the detailed content of PHP Closures and Anonymous Functions (Detailed Tutorial). For more information, please follow other related articles on the PHP Chinese website!

Related labels:
source:php.cn
Statement of this Website
The content of this article is voluntarily contributed by netizens, and the copyright belongs to the original author. This site does not assume corresponding legal responsibility. If you find any content suspected of plagiarism or infringement, please contact admin@php.cn
Popular Tutorials
More>
Latest Downloads
More>
Web Effects
Website Source Code
Website Materials
Front End Template