閉包就是能夠讀取其他函數內部變量的函數。例如在javascript中，只有函數內部的子函數才能讀取局部變量，所以閉包可以理解成“定義在一個函數內部的函數“。在本質上，閉包是將函數內部和函數外部連接起來的橋梁。 在php中,閉包函數一般就是匿名函數.

Closure

面向對象變成語言代碼的復用主要采用繼承來實現，而函數的復用，就是通過閉包來實現。這就是閉包的設計初衷。

注：PHP里面閉包函數是為了復用函數而設計的語言特性，如果在閉包函數里面訪問指定域的變量，使用use關鍵字來實現。

PHP具有面向函數的編程特性，但是也是面向對象編程語言，PHP 會自動把閉包函數轉換成內置類 Closure 的對象實例，依賴Closure 的對象實例又給閉包函數添加了更多的能力。

閉包不能被實例(私有構造函數)，也不能被繼承(finally 類)。可以通過反射來判斷閉包實例是否能被實例，繼承。

匿名函數

匿名函數，是php5.3的時候引入的,又稱為Anonymous functions。字面意思也就是沒有定義名字的函數。

提到閉包就不得不想起匿名函數，也叫閉包函數(closures)，貌似PHP閉包實現主要就是靠它。聲明一個匿名函數是這樣：

$say =function() {return '我是匿名函數';

};//帶結束符

echo $say();//這是最直接調用匿名函數方式

function test(Closure $callback)

{ return $callback();}

echo test($say);//這是間接調用匿名函數方式

當然也可以這樣寫 :

echo test( function() {

return '我是匿名函數';

});

//例一

//在函數里定義一個匿名函數，并且調用它

function printStr() {

$func = function( $str ) {

echo $str;

};

$func( 'some string' );

}

printStr();

//例二

//在函數中把匿名函數返回，并且調用它

function getPrintStrFunc() {

$func = function( $str ) {

echo $str;

};

return $func;

}

$printStrFunc = getPrintStrFunc();

$printStrFunc( 'some string' );

//例三

//把匿名函數當做參數傳遞，并且調用它

function callFunc( $func ) {

$func( 'some string' );

}

$printStrFunc = function( $str ) {

echo $str;

};

callFunc( $printStrFunc );

//也可以直接將匿名函數進行傳遞。如果你了解js，這種寫法可能會很熟悉

callFunc( function( $str ) {

echo $str;

} );

可以看到，匿名函數因為沒有名字，如果要使用它，需要將其返回給一個變量。匿名函數也像普通函數一樣可以聲明參數，調用方法也相同：

$func =function( $param ) {

echo $param;

};

$func('some string');//輸出：//some string

順便提一下，PHP在引入閉包之前，也有一個可以創建匿名函數的函數：create function，但是代碼邏輯只能寫成字符串，這樣看起來很晦澀并且不好維護，所以很少有人用。

實現閉包

將匿名函數在普通函數中當做參數傳入，也可以在函數中被返回。這就實現了一個簡單的閉包。

連接閉包和外界變量的關鍵字：USE

PHP在默認情況下，匿名函數不能調用所在代碼塊的上下文變量，而需要通過使用use關鍵字。

function getMoney() {

$rmb= 1;

$func=function() use ( $rmb ) {

echo $rmb;//把$rmb的值加1

$rmb++;

};

$func();

echo $rmb;//閉包內的變量改變了，但是閉包外沒有改變。

}

getMoney();//輸出：//1//1

在上面我們看見匿名函數不能改變上下文的變量，是因為use所引用的也只不過是變量的一個副本clone而已(非完全引用變量本身)。

如果我們想在匿名函數中改變上下文的變量呢？想要完全引用變量，而不是復制呢?要達到這種效果，在變量前加一個 & 符號即可。

function getMoney() {

$rmb= 1;

$func= function() use ( &$rmb ) {

echo $rmb;//把$rmb的值加1

$rmb++;

};

$func();

echo $rmb;

}

getMoney();//輸出：//1//2

好，這樣匿名函數就可以引用上下文的變量了。如果將匿名函數返回給外界，匿名函數會保存use所引用的變量，而外界則不能得到這些變量，這樣形成‘閉包’這個概念可能會更清晰一些。

根據描述我們再改變一下上面的例子：

function getMoneyFunc() {

$rmb= 1;

$func= function() use ( &$rmb ) {

echo $rmb.'
';//把$rmb的值加1

$rmb++;

};return$func;

}

$getMoney= getMoneyFunc(); //匿名函數返回給外界,保存了$rmb的變量

$getMoney();

$getMoney();

$getMoney();//輸出：//1//2//3從例子中理解“將匿名函數返回給外界，匿名函數會保存use所引用的變量，而外界則不能得到這些變量”，將匿名函數返回給外界后，$rmb這個引用變量就被保存了，提升成了全局變量(全局變量，類似靜態變量)，而后面每次再調用匿名函數，傳入的都是這個保存后的值

總結：

閉包函數不能直接訪問閉包外的變量，而是通過use 關鍵字來調用上下文變量(閉包外的變量)，也就是說通過use來引用上下文的變量；

閉包內所引用的變量不能被外部所訪問(即，內部對變量的修改，外部不受影響)，若想要在閉包內對變量的改變從而影響到上下文變量的值，需要使用&的引用傳參。

use所引用的是變量的復制(副本而)，并不是完全引用變量。如果要達到引用的效果，就需要使用 & 符號，進行引用傳遞參數；

如果我們要調用一個類里面的匿名函數呢？直接上demo

return $i+100;

};

}

}

function B(Closure $callback)

{return $callback(200);

}

$a=B(A::testA());

print_r($a);//輸出 300

其中的A::testA()返回的就是一個無名funciton。

綁定的概念

上面的例子的Closure只是全局的的匿名函數，好了，那我們現在想指定一個類有一個匿名函數。也可以理解說，這個匿名函數的訪問范圍不再是全局的了，而是一個類的訪問范圍。

那么我們就需要將“一個匿名函數綁定到一個類中”。

PHP?Closure 類是用于代表匿名函數的類，匿名函數(在 PHP 5.3 中被引入)會產生這個類型的對象，Closure類摘要如下：

Closure {

__construct (void)public static Closure bind (Closure $closure , object $newthis [, mixed $newscope = 'static'])public Closure bindTo (object $newthis [, mixed $newscope = 'static'])

}

參數說明：

closure

需要綁定的匿名函數。

newthis

需要綁定到匿名函數的對象，或者 NULL 創建未綁定的閉包。

newscope

想要綁定給閉包的類作用域，或者 'static' 表示不改變。如果傳入一個對象，則使用這個對象的類型名。 類作用域用來決定在閉包中 $this 對象的 私有、保護方法 的可見性。(備注：可以傳入類名或類的實例，默認值是 'static'， 表示不改變。)

返回值：

返回一個新的 Closure 對象 或者在失敗時返回 FALSE

方法說明：

Closure::__construct — 用于禁止實例化的構造函數

Closure::bind — 復制一個閉包，綁定指定的$this對象和類作用域。

Closure::bindTo — 復制當前閉包對象，綁定指定的$this對象和類作用域。

除了此處列出的方法，還有一個 __invoke 方法。這是為了與其他實現了 __invoke()魔術方法 的對象保持一致性，但調用閉包對象的過程與它無關。

Closure::bind是Closure::bindTo的靜態版本

深入理解bind參數：

要理解bing參數，先要理解類屬性的可訪問權限 public,private(子類不可訪問),protect(子類可訪問，類外不可以訪問)。

php的public、protected、private三種訪問控制模式的區別

public: 公有類型 在子類中可以通過self::var調用public方法或屬性,parent::method調用父類方法

在實例中可以能過$obj->var 來調用 public類型的方法或屬性

protected: 受保護類型在子類中可以通過self::var調用protected方法或屬性,parent::method調用父類方法

在實例中不能通過$obj->var 來調用 protected類型的方法或屬性

private: 私有類型該類型的屬性或方法只能在該類中使用，在該類的實例、子類中、子類的實例中都不能調用私有類型的屬性和方法

不能通過 $this 訪問靜態變量，靜態方法里面也不可用 $this (原因：靜態屬性屬于類本身而不屬于類的任何實例。靜態屬性可以被看做是存儲在類當中的全局變量，可以在任何地方通過類來訪問它們)

在類外不能通過 類名::私有靜態變量，只能在類里面通過self,或者static 訪問私有靜態變量：

第一個參數：需要綁定的匿名函數。

第二個參數：關于bind的第二個參數為object還是null，取決于第一個參數閉包中是否用到了`$this`的上下文環境。(綁定的對象決定了函數中的$this的取值)

若閉包中用到了`$this`,則第2個參數不可為null，只能為object實例對象；若閉包中用到了靜態訪問(::操作符)，第2個參數就可以為null,也可以為object

第三個參數(作用域)：是控制閉包的作用域的，如果閉包中訪問的是 private 屬性，就需要第3個參數提升閉包的訪問權限，若閉包中訪問的是public屬性，第三個參數可以不用。只有需要改變訪問權限時才要，傳對象，類名都可以。

[bind的第三個參數：mixed類型的類作用域，決定了這個匿名函數中能夠調用哪些私有和保護的方法。也就是說this可以調用的方法，即這個this可以調用的方法，即這個this可以調用的方法與屬性，與這個scope一致。

第三個參數如果是類實例對象與類的名稱都代表著這個閉包有類作用域，如果是static則表示這個閉包與外部變量作用域一樣，不能訪問類的私有以及保護方法。

mixed類型在PHP中也就是沒有類型限定的意思，缺省情況下第三個參數是個字符串，值是‘static’]

第2個參數是給閉包綁定`$this`對象的，第3個參數是給閉包綁定作用域的。

通過成員的可訪問行來舉例子理解：

classA{private $name = '王力宏';protected $age = '30';private static $weight = '70kg';public $address = '中國';public static $height = '180cm';

}

$obj = newA();//echo $obj->name;//報錯 Cannot access private property A::$name//echo $obj->age;//報錯 Cannot access protected property A::$age//echo A::$weight;//報錯 Cannot access private property A::$weight

echo $obj->address;//正常 輸出 中國

echo A::$height;//正常 輸出 180cm

$fun =function(){

$obj= newA();return $obj->address;//實例對象可以獲得公有屬性, $obj->name等私有屬性肯定不行 上面例子已列出報錯

}

echo $fun();//正常 輸出 中國

$fun2 =function(){return A::$height;//類可以直接訪問公有靜態屬性，但A::$weight肯定不行，因為weight為私有屬性

}

echo $fun2();//正常 輸出 180cm

以上都理解的情況下 我們來看看這樣的情況，有如下匿名函數:

$fun =function(){return $this->name;

}

或者

$fun=function(){returnA::$height;

}

echo $fun();//會報錯的

其實單獨這段代碼是肯定不能運行 調用的，因為里面有個$this,程序壓根不知道你這個$this是代表那個對象 或 那個類(并且就算知道那個對象或類，該對象是否擁有name屬性，如果沒有照樣會有問題)

因此想讓其正常運行肯定有前提條件啊(就好比你想遍歷某個數組一樣，如果這個數組壓根你就沒提前定義 聲明 肯定會報錯的)

如果這樣:

$fun =function(){//name是私有屬性，需要第3個參數

return $this->name;

} ;

$name= Closure::bind($fun,new A() ,'A');

echo $name();//輸出 王力宏

該函數返回一個全新的 Closure匿名的函數，和原來匿名函數$fun一模一樣，只是其中$this被指向了A實例對象,這樣就能訪問address屬性了。

使用了bind函數后 ，

其實是匿名函數里的$this被指定到了或綁定到了A實例對象上了

Closure::bind($fun,newA() );

這個使用 你可以理解成對匿名函數做了如下過程:

$fun=function(){

$this = newA();return $this->name;

} ;

你可以想象認為,$this就成了A類的實例對象了，然后在去訪問name屬性，就和我們正常實例化類訪問成員屬性一樣，上面2中的例子$obj = new A()就是這樣，(因為$this是關鍵字，在這里我們其實不能直接$this = new A();這么寫，為了好理解我寫成$this，但是原理還是這個意思)，但是我們都知道因為name屬性是私有的，上面2中我已說過，實例對象不能訪問私有屬性，那該怎么辦呢，于是添加第三個參數就很重要了，一般傳入傳入一個對應對象，或對應類名(對應的意思是:匿名函數中$this-name想獲取name屬性值，你這個$this想和那個類和對象綁定在一起呢，就是第二個參數，這時你第三個參數寫和第二個參數寫一樣的對象或類就行了，就是作用域為這個對象或類，這就會讓原理的name私有屬性變為公有屬性)

$fun =function(){//address為公開，第3個參數可以不需要

return $this->name;

} ;

$address= Closure::bind($fun,newA());

echo $address();

這里數一下bind這次為什么沒添加第三個參數，因為我們要訪問的address屬性是公有的，一個對象實例是可以直接訪問公有屬性的，這個例子中只要匿名函數中$this被指向了A對象實例(或者叫綁定也可以)，就能訪問到公有屬性，所以可以不用添加第三個參數，當然你加上了第三個參數 如這樣Closure::bind($fun2, new A(), ‘A’ );或Closure::bind($fun2, new A(), nwe A() );不影響 照樣運行，就好比把原來公有屬性 變為公有屬性 不影響的(一般當我們訪問的屬性為私有屬性時，才使用第三個參數改變作用域 ，使其變為公有屬性)

$fun =function() {//訪問私有靜態屬性，訪問靜態屬性，第2個參數可以為null，訪問私有屬性，需要第3個參數提高作用域//return A::$weight; 這樣寫，會報錯，提示不能通過類名訪問私有靜態變量//weight 為類的私有屬性，只可在類中訪問　　return self::$weight;

};

//echo $fun(); 運行會報錯 因為weight為私有屬性 。

$weight = Closure::bind($fun,null,'A');//通過bind函數作用，返回一個和$fun匿名函數一模一樣的匿名函數，只是該匿名函數中A::$weight, weight屬性由私有變成公有屬性了。

echo $weight();

為什么第二個參數又成null了呢，因為在該匿名函數中A::$weight 這屬于正常類使用啊(php中 類名::公有靜態屬性，這是正常訪問方法，上面2中例子已經說的很清楚了)，所以不用綁定到某個對象上去了，于是第二個參數可以省略，唯一遺憾的是weight屬性雖是靜態屬性，但是其權限是private私有屬性，于是我們要把私有屬性變公有屬性就可以了，這時把第三個參數加上去就可以了，第三個參數可以是A類(Closure::bind($fun,null,'A'))，也可以是A類的對象實例(Closure::bind($fun,null, new A() ))，兩種寫法都可以，最終第三個參數的添加使私有屬性變成了公有屬性，(這個例子中當然你非得添加第二個參數肯定也沒問題，只要第二個參數是A的實例對象就行Closure::bind($fun,new A(),'A')，不影響，只是說 A::$weight 這種使用方法本身就是正常使用，程序本身就知道你用的是A類，你在去把它指向到A類自己的對象實例上，屬于多此一舉，因此第二個參數加不加都行，不加寫null就行)

綜上大家應該理解其用法了吧，有時第二個參數為null，有時第三個參數可以不要，這些都跟你匿名函數里 代碼中訪問的方式緊密相關

總結：

1、一般匿名函數中有$this->name類似這樣用 $this訪問屬性方式時，你在使用bind綁定時 ，第二個參數肯定要寫，寫出你綁定那個對象實例，第三個參數要不要呢，要看你訪問的這個屬性，在綁定對象中的權限屬性，如果是private，protected 你要使用第三個參數 使其變為公有屬性, 如果本來就是公有，你可以省略，也可以不省略

2、一般匿名函數中是 類名::靜態屬性 類似這樣的訪問方式(比如例子中A::$weight)，你在使用bind綁定時，第二個參數可以寫null,也可以寫出具體的對象實例，一般寫null就行(寫了具體對象實例多此一舉)，第三個參數寫不寫還是得看你訪問的這個靜態屬性的權限是 private 還是 public,如果是私有private或受保護protected的，你就得第三個參數必須寫，才能使其權限變為公有屬性 正常訪問，如果本來就是公有public可以不用寫，可以省略

3、需要提升屬性作用域時，第3個參數需要傳，傳對象或者類名都可以。

例子：

classAnimal {public $cat = 'cat';public static $dog = 'dog';private $pig = 'pig';private static $duck = 'duck';

}//不能通過 $this 訪問靜態變量//不能通過 類名::私有靜態變量，只能通過self,或者static,在類里面訪問私有靜態變量

$cat=function() {return $this->cat;

};

$dog= staticfunction () {returnAnimal::$dog;

};

$pig=function() {return $this->pig;

};

$duck= staticfunction() {//return Animal::$duck; 這樣寫，會報錯，提示不能通過類名訪問私有靜態變量

return self::$duck; //return static::$duck

};

$bindCat= Closure::bind($cat, new Animal(), 'Animal');

$bindCat2= Closure::bind($cat, new Animal(), newAnimal());

echo $bindCat() . PHP_EOL;

echo $bindCat2() . PHP_EOL;

$bindDog= Closure::bind($dog, null, 'Animal');

$bindDog2= Closure::bind($dog, null, newAnimal());

echo $bindDog() . PHP_EOL;

echo $bindDog2() . PHP_EOL;

$bindPig= Closure::bind($pig, new Animal(), 'Animal');

$bindPig2= Closure::bind($pig, new Animal(), newAnimal());

echo $bindPig() . PHP_EOL;

echo $bindPig2() . PHP_EOL;

$bindDuck= Closure::bind($duck, null, 'Animal');

$bindDuck2= Closure::bind($duck, null, newAnimal());

echo $bindDuck() . PHP_EOL;

echo $bindDuck2() . PHP_EOL;

通過上面的例子，可以看出函數復用得，可以把函數掛在不同的類上，或者對象上。

閉包函數的應用：

/**

* 一個基本的購物車，包括一些已經添加的商品和每種商品的數量

**/

classCart {//定義商品價格

const PRICE_BUTTER = 10.00;const PRICE_MILK = 30.33;const PRICE_EGGS = 80.88;protected $products =array();/**

* 添加商品和數量

*

* @access public

* @param string 商品名稱

* @param string 商品數量*/

publicfunction add($item, $quantity) {

$this->products[$item] =$quantity;

}/**

* 獲取單項商品數量

*

* @access public

* @param string 商品名稱*/

publicfunction getQuantity($item) {return isset($this->products[$item]) ? $this->products[$item] : FALSE;

}/**

* 獲取總價

*

* @access public

* @param string 稅率*/

publicfunction getTotal($tax) {

$total= 0.00;

$callback= function ($quantity, $item) use ($tax, &$total) {

$pricePerItem= constant(__CLASS__ . "::PRICE_" . strtoupper($item)); //調用以上對應的常量

$total += ($pricePerItem * $quantity) * ($tax + 1.0);

};

array_walk($this->products, $callback);return round($total, 2);

}

}

$my_cart= newCart;//往購物車里添加商品及對應數量

$my_cart->add('butter', 10);

$my_cart->add('milk', 3);

$my_cart->add('eggs', 12);//打出出總價格，其中有 3% 的銷售稅.

echo $my_cart->getTotal(0.03);//輸出 1196.4

給類的私有屬性賦值：

classA {private $attr =array();

}classB {public staticfunction bind (A $a) {return\Closure::bind(function () use ($a) {//給私有屬性賦值

$a->attr =['color' => 'red','weight' => '1.0',

];

},null, A::class);

}

}//我們在對象外部給私有對象賦值時，需要通過\Closure::bind ,來提高閉包作用域進行賦值

$a = newA();//不能對私有屬性直接進行$a->attr = ['color' => 'red','weight' => '1.0'];

call_user_func(B::bind($a));

print_r($a);

通過上面的幾個例子，其實匿名綁定的理解就不難了....我們在看一個擴展的demo(引入trait特性)

給類動態的添加方法

/**

* 給類動態添加新方法

*

* @author fantasy*/trait DynamicTrait {/**

* 自動調用類中存在的方法*/

publicfunction __call($name, $args) {if(is_callable($this->$name)){ //getdog函數在__set已經定義和綁定了return call_user_func($this->$name, $args); //把第一個參數作為回調函數調用

}else{throw new \RuntimeException("Method {$name} does not exist");

}

}/**

* 添加方法*/

publicfunction __set($name, $value) {

$this->$name = is_callable($value)?$value->bindTo($this, $this):$value;

//相當于 $getdog = function(){ return $this->dog; } Closure::bindto($getdog, new Animal,'Animal');

}

}/** * 只帶屬性不帶方法動物類 * * @author fantasy*/

classAnimal {

use DynamicTrait;private $dog = '汪汪隊';

}

$animal= newAnimal;//往動物類實例中添加一個方法獲取實例的私有屬性$dog

$animal->getdog =function() {return $this->dog; };

echo $animal->getdog();//輸出 汪汪隊

獲取類屬性:第3個參數 score 范圍 設置為null 時，只能獲取到 public 屬性。

如果希望完全取消綁定，則需要將閉包和范圍都設置為null

classMyClass

{public $foo = 'a';protected $bar = 'b';private $baz = 'c';/**

* @param bool $all 是否獲取全部的屬性

*

* @return array*/

public function toArray($all = false)

{//Only public variables

$callback =(function ($obj) {//get_object_vars — 返回由對象屬性組成的關聯數組 ,在類內調用時，會返回所有的屬性(private,protect,public), 在類外使用只返回public

returnget_object_vars($obj);

});//指定作用域 為 null 則會返回 public 屬性； 指定作用域默認 ‘static’，則會返回所有屬性

if($all) {

$callback= $callback->bindTo(null); //只能在類里面通過self,或者static 訪問私有靜態變量

}else{//類內獲取public屬性

$callback = $callback->bindTo(null, null);

}return $callback($this);

}

}

$obj = new MyClass;

$vars = get_object_vars($obj); // get_object_vars 類外使用，獲取到的是 public 屬性

print_r($vars);

echo '
';

$vars = $obj->toArray();

print_r($vars);

echo '
';

$vars = $obj->toArray(1);

print_r($vars);

結果：

Array ( [foo] =>a )

Array ( [foo]=>a )

Array ( [foo]=> a [bar] => b [baz] => c )

總結：

1. 閉包內如果用 $this, 則 $this 只能調用非靜態的屬性，這和實際類中調用原則是一致的，且 Closure::bind() 方法的第2個參數不能為null，必須是一個實例 (因為$this,必須在實例中使用)，第三個參數可以是實例，可以是類字符串，或 static；

2. 閉包內調用靜態屬性時，閉包必須聲明為 static,同時Closure::bind()方法的第2個參數需要為null,因為 靜態屬性不需要實例，第3個參數可以是類字符串，實例，static.