基本介紹
- 中文名：閉包
- 外文名：closure
- 相關學科：離散數學
- 用途：編程邏輯
- 特點：未綁定到特定對象
- 本質：將函式內部和外部連線起來的橋樑
簡單介紹,本質,性質,舉例說明,語法結構,Groovy,Lua,Scheme,創建,代碼,特點,作用,例子,例1,例2,微觀世界,套用場景,回收機制,匿名內部,度量空間,離散數學,使用注意點,
簡單介紹
閉包包含自由（未綁定到特定對象）變數，這些變數不是在這個代碼塊內或者任何全局上下文中定義的，而是在定義代碼塊的環境中定義（局部變數）。“閉包” 一詞來源於以下兩者的結合：要執行的代碼塊（由於自由變數被包含在代碼塊中，這些自由變數以及它們引用的對象沒有被釋放）和為自由變數提供綁定的計算環境（作用域）。在PHP、Scala、Scheme、Common Lisp、Smalltalk、Groovy、JavaScript、Ruby、 Python、Go、Lua、objective c、swift 以及Java（Java8及以上）等語言中都能找到對閉包不同程度的支持。
本質
集合 S 是閉集若且唯若 Cl(S)=S（這裡的cl即closure，閉包）。特別的，空集的閉包是空集，X 的閉包是 X。集合的交集的閉包總是集合的閉包的交集的子集（不一定是真子集）。有限多個集合的並集的閉包和這些集合的閉包的並集相等；零個集合的並集為空集，所以這個命題包含了前面的空集的閉包的特殊情況。無限多個集合的並集的閉包不一定等於這些集合的閉包的並集，但前者一定是後者的父集。
若 A 為包含 S 的 X 的子空間，則 S 在 A 中計算得到的閉包等於 A 和 S 在 X 中計算得到的閉包（Cl_A(S) = A ∩ Cl_X(S））的交集。特別的，S在 A 中是稠密的，若且唯若 A 是 Cl_X(S) 的子集。
性質
cl(S) 是 S 的閉父集。
cl(S) 是所有包含 S 的閉集的交集。
cl(S) 是包含 S 的最小的閉集。
集合 S 是閉集，若且唯若 S = cl(S）。
若 S 是 T 的子集，則 cl(S) 是 cl(T) 的子集。
若 A 是閉集，則 A 包含 S 若且唯若 A 包含 cl(S）。
有時候，上述第二或第三條性質會被作為拓撲閉包的定義。
舉例說明
閉包 (closure）是個精確但又很難解釋的電腦名詞。在 Perl 裡面，閉包是以 匿名函式的形式來實現，具有持續參照位於該函式範圍之外的文字式變數值的能力。這些外部的文字變數會神奇地保留它們在閉包函式最初定義時的值 （深連結）。
如果一個程式語言容許函式遞迴另一個函式的話 （像 Perl 就是），閉包便具有意義。要注意的是，有些語言雖提供匿名函式的功能，但卻無法正確處理閉包； Python 這個語言便是一例。如果要想多了解閉包的話，建議你去找本功能性程式 設計的教科書來看。Scheme這個語言不僅支持閉包，更鼓勵多加使用。
以下是個典型的產生函式的函式：
sub add_function_generator {
return sub { shift + shift };
}
$add_sub = add_function_generator();
$sum = &$add_sub(4,5)； # $sum是 9了
閉包用起來就像是個函式樣板，其中保留了一些可以在稍後再填入的空格。add_function_generator() 所遞迴的匿名函式在技術上來講並不能算是一個閉包， 因為它沒有用到任何位在這個函式範圍之外的文字變數。
把上面這個例子和下面這個make_adder()函式對照一下，下面這個函式所遞迴的匿名函式中使用了一個外部的文字變數。這種指明外部函式的作法需要由 Perl遞迴一個適當的閉包，因此那個文字變數在匿名函式產生之時的值便永久地被鎖進閉包里。
sub make_adder {
my $addpiece = shift;
return sub { shift + $addpiece };
}
$f1 = make_adder(20)；
$f2 = make_adder(555)；
這樣一來&$f1($n) 永遠會是 20加上你傳進去的值$n ，而&$f2($n) 將 永遠會是 555加上你傳進去的值$n。$addpiece的值會在閉包中保留下來。
閉包在比較實際的場合中也常用得到，譬如當你想把一些程式碼傳入一個函式時：
my $line;
timeout（30,sub { $line = <STDIN> });
如果要執行的程式碼當初是以字串的形式傳入的話，即'$line = <STDIN>' ，那么timeout() 這個假想的函式在回到該函式被呼叫時所在的範圍後便無法再截取$line這個文字變數的值了。
語法結構
Groovy
閉包（Closure）是Java所不具備的語法結構(JAVA8增加了對閉包的支持)。閉包就是一個代碼塊，用“{ }”包起來。此時，程式代碼也就成了數據，可以被一個變數所引用（與C語言的函式指針比較類似）。閉包的最典型的套用是實現回調函式（callback）。Groovy的API大量使用閉包，以實現對外開放。閉包的創建過程很簡單，例如：
{ 參數 ->
代碼...
}
參考下面的例子代碼，定義了c1和c2兩個閉包，並對它們進行調用：
def c1 = { println it }
def c2 = { text -> println text }
c1.call("content1") //用call方法調用閉包
c2("content2") //直接調用閉包
“->；”之前的部分為閉包的參數，如果有多個參數，之間可用逗號分割；“->；”之後的部分為閉包內的程式代碼。如果省略了“->；”和它之前的部分，此時閉包中代碼，可以用名為“it”的變數訪問參數。
閉包的返回值和函式的返回值定義方式是一樣的：如果有return語句，則返回值是return語句後面的內容；如果沒有return語句，則閉包內的最後一行代碼就是它的返回值。
Lua
當一個函式內部嵌套另一個函式定義時，內部的函式體可以訪問外部的函式的局部變數，這種特徵在lua中我們稱作詞法定界。雖然這看起來很清楚，事實並非如此，詞法定界加上第一類函式在程式語言里是一個功能強大的概念，很少語言提供這種支持。
下面看一個簡單的例子，假定有一個學生姓名的列表和一個學生名和成績對應的表；想根據學生的成績從高到低對學生進行排序，可以這樣做：
names = {"Peter","Paul","Mary"}
grades = {Mary = 10,Paul = 7,Peter = 8}
table.sort(names,function (n1,n2）
return grades[n1] > grades[n2] -- compare the grades
end)
假定創建一個函式實現此功能：
function sortbygrade (names,grades)
table.sort(names,function (n1,n2）
return grades[n1] > grades[n2] --compare the grades
end)
Scheme
其他編程的語言主要採用的是閉包的第二種意義（一個與閉包毫不相干的概念）：閉包也算一種為表示帶有自由變數的過程而用的實現技術。但Scheme的術語“閉包”來自抽象代數。在抽象代數裡，一集元素稱為在某個運算（操作）之下封閉，如果將該運算套用於這一集合中的元素，產生出的仍然是該集合里的元素。
用Scheme的序對舉例，為了實現數據抽象，Scheme提供了一種稱為序對的複合結構。這種結構可以通過基本過程cons構造出來。過程cons取兩個參數，返回一個包含這兩個參數作為其成分的複合數據對象。請注意，一個序對也算一個數據對象。進一步說，還可以用cons去構造那種其元素本身就是序對的序對，並繼續這樣做下去。
(define x (cons 1 2)) //構造一個x序對，由1，2組成
(define y (cons 3 4))
(define z (cons x y))
Scheme可以建立元素本身也算序對的序對，這就是表結構得以作為一種表示工具的根本基礎。我們將這種能力稱為cons的閉包性質。一般說，某種組合數據對象的操作滿足閉包性質，那就是說，通過它組合起數據對象得到的結果本身還可以通過同樣的操作再進行組合。閉包性質是任何一種組合功能的威力的關鍵要素，因為它使我們能夠建立起層次性結構，這種結構由一些部分構成，而其中的各個部分又是由它們的部分構成，並且可以如此繼續下去。
創建
在Javascript中閉包的創建過程，如以下程式所示。
代碼
function a(){
var i=0;
function b(){
alert(++i);
}
return b;
}var c=a();
c();
特點
這段代碼有兩個特點：
1、函式b嵌套在函式a內部；
2、函式a返回函式b。
這樣在執行完var c=a( )後，變數c實際上是指向了函式b，再執行c( )後就會彈出一個視窗顯示i的值（第一次為1）。這段代碼其實就創建了一個閉包，這是因為函式a外的變數c引用了函式a內的函式b。也就是說，當函式a的內部函式b被函式a外的一個變數引用的時候，就創建了一個閉包。
作用
簡而言之，閉包的作用就是在a執行完並返回後，閉包使得Javascript的垃圾回收機制不會收回a所占用的資源，因為a的內部函式b的執行需要依賴a中的變數。
在上面的例子中，由於閉包的存在使得函式a返回後，a中的i始終存在，這樣每次執行c()，i都是自加1後alert出i的值。
那 么我們來想像另一種情況，如果a返回的不是函式b，情況就完全不同了。因為a執行完後，b沒有被返回給a的外界，只是被a所引用，而此時a也只會被b引 用，因此函式a和b互相引用但又不被外界打擾（被外界引用），函式a和b就會被回收。
例子
例1
模擬私有變數：
function Counter(start){
var count = start;
return{
increment:function(){
count++;
},
get:function(){
return count;
}
}
}
var foo =Counter(4);
foo.increment();
foo.get();// 5
return{
increment:function(){
count++;
},
get:function(){
return count;
}
}
}
var foo =Counter(4);
foo.increment();
foo.get();// 5
這裡，Counter 函式返回兩個閉包，函式 increment 和函式 get。 這兩個函式都維持著對外部作用域 Counter 的引用，因此總可以訪問此作用域內定義的變數count。
objective c的閉包（block）
objective c 中的的閉包，是通過block實現的。Apple在C，Objective-C和C++中擴充了Block這種文法的，並且在GCC4.2中進行了支持。你可以把它理解為函式指針，匿名函式，閉包，lambda表達式，這裡暫且用塊對象來表述，因為它們之間還是有些許不同的。
如果以內聯方式使用塊對象，則無需聲明。塊對象聲明語法與函式指針聲明語法相似，但是塊對象應使用脫字元(^)而非星號指針 (*)。下面的代碼聲明一個aBlock變數，它標識一個需傳入三個參數並具有float返回值的塊。
float (^aBlock)(const int*, int, float);
例2
下面是一個使用閉包簡單的例子，模擬一個計數器，通過將整型包裹為一個列表的單一元素來模擬使看起來更易變：
函式counter()所作的唯一一件事就是接受一個初始化的值來計數，並將該值賦給列表count成員，然後定義一個內部函式incr()。通過內部函式使用變數count，就創建了一個閉包。最魔法的地方是counter()函式返回一個incr()，一個可以調用的函式對象。
運行：
>>> c = counter⑸
>>> type(c)
<type 'function'>
>>> print c()6
>>> print c()
7
>>> c2 = counter（99）
100
>>> print c()
8
微觀世界
如 果要更加深入的了解閉包以及函式a和嵌套函式b的關係，我們需要引入另外幾個概念：函式的執行環境（execution context）、活動對象（call object）、作用域（scope）、作用域鏈（scope chain）。以函式a從定義到執行的過程為例闡述這幾個概念。
1、當定義函式a的時候，js解釋器會將函式a的作用域鏈（scope chain）設定為定義a時a所在的“環境”，如果a是一個全局函式，則scope chain中只有window對象。
2、當函式a執行的時候，a會進入相應的執行環境（execution context）。
3、在創建執行環境的過程中，首先會為a添加一個scope屬性，即a的作用域，其值就為第1步中的scope chain。即a.scope=a的作用域鏈。
4、然後執行環境會創建一個活動對象（call object）。活動對象也是一個擁有屬性的對象，但它不具有原型而且不能通過JavaScript代碼直接訪問。創建完活動對象後，把活動對象添加到a的作用域鏈的最頂端。此時a的作用域鏈包含了兩個對象：a的活動對象和window對象。
5、下一步是在活動對象上添加一個arguments屬性，它保存著調用函式a時所傳遞的參數。
6、最後把所有函式a的形參和內部的函式b的引用也添加到a的活動對象上。在這一步中，完成了函式b的的定義，因此如同第3步，函式b的作用域鏈被設定為b所被定義的環境，即a的作用域。
到此，整個函式a從定義到執行的步驟就完成了。此時a返回函式b的引用給c，又函式b的作用域鏈包含了對函式a的活動對象的引用，也就是說b可以訪問到a中定義的所有變數和函式。函式b被c引用，函式b又依賴函式a，因此函式a在返回後不會被GC回收。
當函式b執行的時候亦會像以上步驟一樣。因此，執行時b的作用域鏈包含了3個對象：b的活動對象、a的活動對象和window對象，如下圖所示：
當在函式b中訪問一個變數的時候，搜尋順序是先搜尋自身的活動對象，如果存在則返回，如果不存在將繼續搜尋函式a的活動對象，依次查找，直到找到為止。如果整個作用域鏈上都無法找到，則返回undefined。如果函式b存在prototype原型對象，則在查找完自身的活動對象 後先查找自身的原型對象，再繼續查找。這就是Javascript中的變數查找機制。
套用場景
1、保護函式內的變數安全。以最開始的例子為例，函式a中i只有函式b才能訪問，而無法通過其他途徑訪問到，因此保護了i的安全性。
2、在記憶體中維持一個變數。依然如前例，由於閉包，函式a中i的一直存在於記憶體中，因此每次執行c（），都會給i自加1。
以上兩點是閉包最基本的套用場景，很多經典案例都源於此。
回收機制
在Javascript中，如果一個對象不再被引用，那么這個對象就會被GC回收。如果兩個對象互相引用，而不再被第3者所引用，那么這兩個互相引用的對象也會被回收。因為函式a被b引用，b又被a外的c引用，這就是為什麼函式a執行後不會被回收的原因。
匿名內部
在Python中的閉包（Closure)
學過Java GUI編程的人都知道定義匿名內部類是註冊監聽等處理的簡潔有效手段，閉包的定義方式有點類似於這種匿名內部類，
但是閉包的作用威力遠遠超過匿名內部類，這也是很多流行動態語言選擇閉包的原因，相信你在JavaScript中已經了解它的神奇功效了。
度量空間
對歐幾里德空間的子集 S，x 是 S 的閉包點，若所有以 x 為中心的開球都包含 S 的點（這個點也可以是 x）。
這個定義可以推廣到度量空間 X 的任意子集 S。具體地說，對具有度量 d 的度量空間 X，x 是 S 的閉包點，若對所有 r > 0，存在 y 屬於 S，使得距離 d(x,y) < r（同樣的，可以是 x = y）。另一種說法可以是，x 是 S 的閉包點，若距離 d(x,S) := inf{d(x,s) : s 屬於 S} = 0（這裡 inf 表示下確界）。
這個定義也可以推廣到拓撲空間，只需要用鄰域替代“開球”。設 S 是拓撲空間 X 的子集，則 x 是 S 的閉包點，若所有 x 鄰域都包含 S 的點。注意，這個定義並不要求鄰域是開的。
離散數學
設R是集合A上的二元關係，R的自反（對稱、傳遞）閉包是滿足以下條件的關係R'：
（i）R'是自反的（對稱的、傳遞的）；
（ii）R'⊇R；
（iii）對於A上的任何自反（對稱、傳遞）關係R"，若R"⊇R，則有R"⊇R'。
R的自反、對稱、傳遞閉包分別記為r(R）、s(R) 和t(R）。
性質1
集合A上的二元關係R的閉包運算可以複合，例如：
ts(R)=t(s(R))
表示R的對稱閉包的傳遞閉包，通常簡稱為R的對稱傳遞閉包。而tsr(R)則表示R的自反對稱傳遞閉包。
性質2
設R是集合A上的二元關係，則有
（a）如果R是自反的，那么s(R）和t(R）也是自反的；
（b）如果R是對稱的，那么r(R）和t(R）也是對稱的；
（c）如果R是傳遞的，那么r(R）也是傳遞的。
性質3
設R是集合A上的二元關係，則有
（a）rs(R)=sr(R）；
（b）rt(R)=tr(R）；
（c）ts(R)⊇ st(R）。
使用注意點
（2）閉包會在父函式外部，改變父函式內部變數的值。所以，如果把父函式當作對象（object）使用，把閉包當作它的公用方法（Public Method），把內部變數當作它的私有屬性（private value），這時一定要小心，不要隨便改變父函式內部變數的值。
