做过一段时间的 Web 开发，咱们都晓得或者理解 JavaScript 中有个十分弱小的语法，那就是闭包。其实，在 PHP 中也早就有了闭包函数的性能。早在 5.3 版本的 PHP 中，闭包函数就曾经呈现了。到了 7 以及起初的古代框架中，闭包函数的应用更是无处不在。在这里，咱们就先从根底来理解 PHP 中闭包的应用吧！

闭包函数（closures）在 PHP 中都会转换为 Closure 类的实例。在定义时如果是赋值给变量，在结尾的花括号须要增加; 分号。闭包函数从父作用域中继承变量，任何此类变量都应该用 use 语言构造传递进去。PHP 7.1 起，不能传入此类变量：superglobals、$this 或者和参数重名。

根底语法

闭包的应用非常简单，和 JavaScript 也十分类似。因为他们都有另外一个别名，叫做匿名函数。

$a = function () {echo "this is testA";};
$a(); // this is testA


function testA ($a) {var_dump($a); 
}
testA($a); // class Closure#1 (0) {}

$b = function ($name) {echo 'this is' . $name;};

$b('Bob'); // this is Bob

咱们将 $a 和 $b 两个变量间接赋值为两个函数。这样咱们就能够应用变量 () 的模式调用这两个函数了。通过 testA()办法，咱们能够看出闭包函数是能够当做一般参数传递的，因为它主动转换成为了 Closure 类的实例。

$age = 16;
$c = function ($name) {echo 'this is' . $name . ', Age is' . $age;};

$c('Charles'); // this is Charles, Age is

$c = function ($name) use ($age) {echo 'this is' . $name . ', Age is' . $age;};

$c('Charles'); // this is Charles, Age is 16

如果咱们须要调用内部的变量，须要应用 use 关键字来援用内部的变量。这一点和一般函数不一样，因为闭包有着严格的作用域问题。对于全局变量来说，咱们能够应用 use，也能够应用 global。然而对于局部变量（函数中的变量）时，只能应用 use。这一点咱们前面再说。

作用域

function testD(){
    global $testOutVar;
    echo $testOutVar;
}
$d = function () use ($testOutVar) {echo $testOutVar;};
$dd = function () {
    global $testOutVar;
    echo $testOutVar;
};
$testOutVar = 'this is d';
$d(); // NULL
testD(); // this is d
$dd(); // this is d

$testOutVar = 'this is e';
$e = function () use ($testOutVar) {echo $testOutVar;};
$e(); // this is e

$testOutVar = 'this is ee';
$e(); // this is e

$testOutVar = 'this is f';
$f = function () use (&$testOutVar) {echo $testOutVar;};
$f(); // this is f

$testOutVar = 'this is ff';
$f(); // this is ff

在作用域中，use 传递的变量必须是在函数定义前定义好的，从上述例子中能够看出。如果闭包（$d）是在变量（$testOutVar）之前定义的，那么 $d 中 use 传递进来的变量是空的。同样，咱们应用 global 来测试，不论是一般函数（testD()）或者是闭包函数（$dd），都是能够失常应用 $testOutVar 的。

在 $e 函数中的变量，在函数定义之后进行批改也不会对 $e 闭包内的变量产生影响。这时候，必须要应用援用传递（$f）进行批改才能够让闭包外面的变量产生变动。这里和一般函数的援用传递与值传递的概念是雷同的。

除了变量的 use 问题，其余方面闭包函数和一般函数根本没什么区别，比方进行类的实例化：

class G
{}
$g = function () {
    global $age;
    echo $age; // 16
    $gClass = new G();
    var_dump($gClass); // G info
};
$g();

类中作用域

对于全局作用域，闭包函数和一般函数的区别不大，次要的区别体现在 use 作为桥梁进行变量传递时的状态。在类办法中，有没有什么不一样的中央呢？

$age = 18;
class A
{
    private $name = 'A Class';
    public function testA()
    {
        $insName = 'test A function';
        $instrinsic = function () {var_dump($this); // this info
            echo $this->name; // A Class
            echo $age; // NULL
            echo $insName; // null
        };
        $instrinsic();

        $instrinsic1 = function () {
            global $age, $insName;
            echo $age; // 18
            echo $insName; // NULL
        };
        $instrinsic1();

        global $age;
        $instrinsic2 = function () use ($age, $insName) {
            echo $age; // 18
            echo $insName; // test A function
        };
        $instrinsic2();}
}

$aClass = new A();
$aClass->testA();

• A::testA()办法中的 $insName 变量，咱们只能通过 use 来拿到。
• 闭包函数中的 $this 是调用它的环境的上下文，在这里就是 A 类自身。闭包的父作用域是定义该闭包的函数（不肯定是调用它的函数）。动态闭包函数无奈取得 $this。
• 全局变量仍然能够应用 global 取得。

小技巧

理解了闭包的这些个性后，咱们能够来看几个小技巧：

$arr1 = [['name' => 'Asia'],
    ['name' => 'Europe'],
    ['name' => 'America'],
];

$arr1Params = 'is good!';
// foreach($arr1 as $k=>$a){//     $arr1[$k] = $a . $arr1Params;
// }
// print_r($arr1);

array_walk($arr1, function (&$v) use ($arr1Params) {$v .= 'is good!';});
print_r($arr1);

干掉 foreach：很多数组类函数，比方 array_map、array_walk 等，都须要应用闭包函数来解决。上例中咱们就是应用 array_walk 来对数组中的内容进行解决。是不是很有函数式编程的感觉，而且十分清晰明了。

function testH()
{return function ($name) {echo "this is" . $name;};
}
testH()("testH's closure!"); // this is testH's closure!

看到这样的代码也不要懵圈了。PHP7 反对立刻执行语法，也就是 JavaScript 中的 IIFE(Immediately-invoked function expression)。

咱们再来一个计算斐波那契数列的：

$fib = function ($n) use (&$fib) {if ($n == 0 || $n == 1) {return 1;}

    return $fib($n - 1) + $fib($n - 2);
};

echo $fib(10);

同样的还是应用递归来实现。这里间接换成了闭包递归来实现。最初有一点要留神的是，use 中传递的变量名不能是带下标的数组项：

$fruits = ['apples', 'oranges'];
$example = function () use ($fruits[0]) {// Parse error: syntax error, unexpected '[', expecting ',' or ')'
    echo $fruits[0]; 
};
$example();

这样写间接就是语法错误，无奈胜利运行的。

彩蛋

Laravel 中的 IoC 服务容器中，大量应用了闭包能力，咱们模仿一个便于大家了解。当然，更好的计划是本人去翻翻 Laravel 的源码。

class B
{}
class C
{}
class D
{}
class Ioc
{public $objs = [];
    public $containers = [];

    public function __construct()
    {$this->objs['b'] = function () {return new B();
        };
        $this->objs['c'] = function () {return new C();
        };
        $this->objs['d'] = function () {return new D();
        };
    }
    public function bind($name)
    {if (!isset($this->containers[$name])) {if (isset($this->objs[$name])) {$this->containers[$name] = $this->objs[$name]();} else {return null;}
        }
        return $this->containers[$name];
    }
}

$ioc = new Ioc();
$bClass = $ioc->bind('b');
$cClass = $ioc->bind('c');
$dClass = $ioc->bind('d');
$eClass = $ioc->bind('e');

var_dump($bClass); // B
var_dump($cClass); // C
var_dump($dClass); // D
var_dump($eClass); // NULL

总结

闭包个性经常出现的中央是事件回调类的性能中，另外就是像彩蛋中的 IoC 的实现。因为闭包有一个很弱小的能力就是能够提早加载。IoC 的例子咱们的闭包中返回的是新 new 进去的对象。当咱们的程序运行的时候，如果没有调用 $ioc->bind(‘b’)，那么这个 B 对象是不会创立的，也就是说这时它还不会占用资源占用内存。而当咱们须要的时候，从服务容器中拿进去的时候才利用闭包真正的去创建对象。同理，事件的回调也是一样的概念。事件产生时在咱们须要解决的时候才去执行回调外面的代码。如果没有闭包的概念，那么 $objs 容器就这么写了：

$this->objs['b'] = new B();
$this->objs['c'] = new C();
$this->objs['d'] = new D();

容器在实例化的时候就把所有的类都必须实例化了。这样对于程序来说很多用不上的对象就都被创立了，带来十分大的资源节约。

基于闭包的这种弱小能力，当初闭包函数曾经在 Laravel、TP6 等框架中无处不在了。学习无止尽，把握原理再去学习框架往往更能事倍功半。

测试代码：
https://github.com/zhangyue0503/dev-blog/blob/master/php/201911/source/%E8%BF%98%E4%B8%8D%E7%9F%A5%E9%81%93PHP%E6%9C%89%E9%97%AD%E5%8C%85%EF%BC%9F%E9%82%A3%E4%BD%A0%E7%9C%9FOUT%E4%BA%86.php

参考文档：
https://www.php.net/manual/zh/functions.anonymous.php
https://www.php.net/manual/zh/functions.anonymous.php#100545

https://www.php.net/manual/zh/functions.anonymous.php#119388

各自媒体平台均可搜寻【硬核项目经理】