閉包裏的自由變量

閉包(closure)，是一種編程語言特性，它指的是代碼塊和做用域環境的結合，早期由scheme語言引入這一特性，隨後幾乎全部語言都帶有這一特性，典型的閉包以下：

(define (func a)
  (lambda (b) 
     (lambda (c) (+ a b c))))
(((func 1) 2) 3)複製代碼

閉包裏的自由變量會綁定在代碼塊上，在離開創造它的環境下依舊生效，而這一點使用代碼塊的人可能沒法察覺。

閉包裏的自由變量的形式有不少，先舉個簡單例子。

function add(one){
    return function(two){
        return one+two;
    }
}
const a = add(1);
const b = add(2);複製代碼

在上面的例子裏，a和b這兩個函數，代碼塊是相同的，但如果執行a(1)和b(1)的結果倒是不一樣的，緣由在於這二者所綁定的自由變量是不一樣的，這裏的自由變量其實就是函數體裏的one。

add這個函數嵌套返回一個新的函數，而新的函數也帶來了新的做用域，在JS裏，自由變量的查找會從本級做用域依次向外部做用域，直到查到最近的一個，而自由變量的綁定也會在函數定義的時候就已經肯定，這也是詞法做用域（或稱靜態做用域）的具體表現。

自由變量的引入，能夠起到和OOP裏的封裝一樣做用，咱們能夠在一層函數裏封裝一些不被外界知曉的自由變量，從而達到相同的效果，舉例說這麼一個簡單的java類。

class Demo{
    private int r;
    private int k = 1;
    public Demo(int r){
       this.r = r;
    }
    public int getSquare(){
        return this.r*this.r*this.k;
    }
    public void incr(){
       this.k++;
    }
}複製代碼

這裏的變量r被封裝了，咱們能夠new Demo(1)或者new Demo(2)返回不一樣的實例，而後調用相同的方法來獲得不一樣的結果，這一點若是用自由變量也能夠作到。

func demo(r int) (func() int,func()){
    k := 1
    getSqueare := func() int{
        return r*r*k
    }
    incr := func (){
        k++
    }
    return getSqueare,incr
}
getSqueare,incr := demo(1)複製代碼

在執行demo(1)或者demo(2)的時候，獲得的對象均可以用來執行相同的方法，然而他們的自由變量(r和k)都是相互隔離的，這就是封裝的表現。

自由變量的肯定在其餘語言有着不同的表現，好比說php裏，函數與函數之間的做用域是徹底隔離的，除非你用傳參或者global來拿到外部做用域的變量，這會致使咱們作封裝的時候極爲麻煩，因此php5.3里加了use語法，它容許在函數做用域裏引用上一層的自由變量。

好比上面的JS代碼能夠改爲這樣的php代碼。

function demo($r){
   $k = 1;
   return array(
      "getSquare"=>function() use ($r,&$k){
         return $r*$r*$k;
      },
      "incr"=>function() use (&$k){
         $k++;
      }
   );
}複製代碼

這裏還有一個要注意的地方就是在use $k的時候，用了&表示按引用傳遞，由於若是不這麼作的話，內部函數裏的這個$k實際上只是一份值拷貝，沒法改變其值，也沒法應用改變以後的新值。

有人比較偏心php 的use語法，由於這樣能夠明確的肯定須要使用的外部自由變量，而有的人偏心js這種隱式寫法，緣由是寫起來簡潔不累贅，只能說語言設計都有不一樣的取捨。

剛纔說到的這些，其實函數都是一等公民的狀況下，然而在其餘形式的語言裏，其實也都有閉包，好比說在java裏，雖然沒法定義一個脫離於class的函數，可是咱們能夠在method裏的內部定義一個class，這個class也就是local class，它實際上就是一種閉包，舉例來講。

class Demo {
  private volatile int a;
  public void test(final int b) {
    new Thread(
      new Runnable() {
        void run() {
          a++;
          System.out.print(b);
        }
      }
    ).start();
  }
}複製代碼

上面test方法裏的local class，能夠直接引用或者更改定義在類裏的private variable，也能夠讀取方法裏的參數，而且它的自由變量綁定也是在定義的時候就已經肯定好的。
然而因爲java自己的限制，因此上面的參數b必須是final的，這一點在java8的lambda也不例外，就算在java8裏你不使用final肯定，它仍是隱式的認爲其是final，因此沒法在local class裏的方法更改這個參數。

再說說C++，C++裏最開始是使用運算符重載來達到定義函數類型，可是它有一個缺點就是沒法捕獲外部的自由變量，爲了達到相同的效果，你須要使用一個重載了()操做符的類對象來做爲僞函數，好比這樣：

class Func{
Func(int one){ this->one = one; }  
public:
    int operator ()(int two) {  
        return this.one+two;  
    }
private: 
    int one;
};
Func f = Func(3); 
f(10);複製代碼

C++11加入了lambda語法糖，能夠很容易的捕獲自由變量：

int one = 3;
auto f = [=](int two){
    return one+two;
};
f(10);複製代碼

在上面的[=](int two) {}語句裏，咱們可使用外部的自由變量one，C++裏能夠選擇=、&來指示是不是引用仍是捕獲值，或者指定任意要捕獲的變量名，這一點能夠極大方便咱們在C++裏使用函數。
然而在C語言裏，咱們想要作一樣的事情就很困難了，C語言並不支持高階函數，咱們想要讓函數能做爲參數代入，或者讓函數可以返回函數，咱們須要使用函數指針，典型的函數指針是這樣子的：

int (*funcP) (int,int);
(*funcP)(1,2);複製代碼

這裏的funcP本質上是一個指針，因此它能夠在C語言裏被函數當作參數或者當作返回值，然而它沒法代入自由變量，也就是說它根本無法作到捕獲做用域變量，咱們若是想要使用外層變量，必須手動加入一個參數的指針，而後再和函數指針一塊兒代出去，這樣才能使用到外層的變量。

何其麻煩！因此不少廠商爲c語言定製了閉包特性，其中比較有名的就是蘋果家的block，它的定義形式和函數指針極爲類似，只不過把*換成了^，然而它卻有閉包的特性，能夠捕獲自由變量，舉例來講：

int a =10;
int main(void){
  int (^op) (int);
  int b = 20;
  static c = 30;
  op = ^(int one){ return one+a+b+c;};
  op(1);
}複製代碼

咱們上面的op是一個block，在它的內部，能夠捕獲到全局變量a，以及局部變量b，靜態變量c，對於全局變量a以及局部靜態變量c，它是能夠直接訪問而且能夠修改的，然而對於局部變量b，它卻只能訪問，而沒法作修改，而且當b的值發生變化的時候，它也沒法感知，其實是由於捕獲的時候就已經把b的值代入進棧的block object裏了。

爲了可以更好的捕獲自由變量，因此block還引入了一個特殊的修飾符，也就是__block，用於修飾局部非靜態變量，被__block修飾的變量是能夠在block裏讀取並修改的，它的值是動態生成的，實質上是每次執行的時候都會去獲取被修飾變量的內存區域，從而達到共享變量值的效果。

block object還有一個比較重要的地方就是它和其餘變量同樣，生命週期在定義的函數執行結束以後也就結束了，這樣咱們須要考慮的就是如何脫離創造它的環境下依舊有效，block引入了Block_copy這一工具函數，用於將棧上的block複製到堆上，這樣新的block就能夠脫離原有的創造環境了。

總之，閉包在各類語言上有着不一樣的語法語義，其核心要素就是在於自由變量如何捕獲，咱們在使用閉包的時候須要注意到語言的做用域方式，以及自由變量捕獲方式這些特色。