百度百科關於閉包的理解

目錄

閉包是能夠包含自由（未綁定到特定對象）變量的代碼塊；這些變量不是在這個代碼塊內或者任何全局上下文中定義的，而是在定義代碼塊的環境中定義。「閉包」 一詞來源於如下二者的結合：要執行的代碼塊（因爲自由變量被包含在代碼塊中，這些自由變量以及它們引用的對象沒有被釋放）和爲自由變量提供綁定的計算環境（做用域）。在 Scala、Scheme、Common Lisp、Smalltalk、Groovy、JavaScript、Ruby 和 Python，objective c 等語言中都能找到對閉包不一樣程度的支持。

價值

閉包的價值在於能夠做爲函數對象 或者匿名函數，對於類型系統而言這就意味着不只要表示數據還要表示代碼。支持閉包的多數語言都將函數做爲第一級對象，就是說這些函數能夠存儲到變量中、做爲參數傳遞給其餘函數，最重要的是可以被函數動態地建立和返回。

數學意義

若在一個集合上進行某種運算，其運算結果仍爲集合中的元素，則稱該集合爲此運算上的閉包。

本質

集合 S 是閉集當且僅當 Cl(S)=S（這裏的cl即closure，閉包）。特別的， 空集的閉包是空集，X 的閉包是 X。集合的交集的閉包老是集合的閉包的交集的子集（不必定是真子集）。有限多個集合的並集的閉包和這些集合的閉包的並集相等；零個集合的並集爲空集，因此這個命題包含了前面的空集的閉包的特殊狀況。無限多個集合的並集的閉包不必定等於這些集合的閉包的並集，但前者必定是後者的父集

若 A 爲包含 S 的 X 的子空間，則 S 在 A 中計算獲得的閉包等於 A 和 S 在 X 中計算獲得的閉包（Cl_A(S) = A\cap Cl_X(S））的交集。特別的，S在 A 中是稠密的，當且僅當 A 是 Cl_X(S) 的子集。

閉包點

對歐幾里德空間的子集 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 的點。注意，這個定義並不要求鄰域是開的。

極限點

閉包點的定義很是接近極限點的定義。這兩個定義之間的差異很是微小但很重要——在極限點的定義中，點 x 的鄰域必須包含和 x 不一樣的集合的點。

所以，全部極限點都是閉包點，但不是全部的閉包點都是極限點。不是極限點的閉包點就是孤點。也就是說，點 x 是孤點，若它是 S 的元素，且存在 x 的鄰域，該鄰域中除了 x 沒有其餘的點屬於 S。

對給定的集合 S 和點 x，x 是 S 的閉包點，當且僅當 x 屬於 S，或 x 是 S 的極限點。

集合的閉包

集合 S 的閉包是全部 S 的閉包點組成的集合。S 的閉包寫做 cl(S），Cl(S) 或 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）。

有時候，上述第二或第三條性質會被做爲拓撲閉包的定義。

在第一可數空間（如度量空間）中，cl(S) 是全部點的收斂數列的全部極限。

編輯本段Perl

閉包 (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⒇；

$f2 = make_adder（555）；

這樣一來&$f1($n) 永遠會是 20加上你傳進去的值$n ，而&$f2($n) 將 永遠會是 555加上你傳進去的值$n。$addpiece的值會在閉包中保留下來。

閉包在比較實際的場合中也經常使用獲得，譬如當你想把一些程式碼傳入一個函數時：

my $line;

timeout（30,sub { $line = <STDIN> });

若是要執行的程式碼當初是以字串的形式傳入的話，即'$line = <STDIN>' ，那麼timeout() 這個假想的函數在回到該函數被呼叫時所在的範圍後便沒法再擷取$list這個文字變數的值了。

編輯本段語法結構

Groovy的閉包

閉包（Closure）是Java所不具有的語法結構。閉包就是一個代碼塊，用「{ }」包起來。此時，程序代碼也就成了數據，能夠被一個變量所引用（與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語句，則閉包內的最後一行代碼就是它的返回值。 ^[1]

編輯本段環境表達

在Javascript中閉包（Closure)

1、什麼是閉包？

「官方」的解釋是：所謂「閉包」，指的是一個擁有許多變量和綁定了這些變量的環境的表達式（一般是一個函數），於是這些變量也是該表達式的一部分。

相信不多有人能直接看懂這句話，由於他描述的太學術。我想用如何在Javascript中建立一個閉包來告訴你什麼是閉包，由於跳過閉包的建立過程直接理解閉包的定義是很是困難的。看下面這段代碼：

function a(){

var i=0;

function b(){

alert(++i);

}

return b;

}

var c = a();

c();

這段代碼有兩個特色：

一、函數b嵌套在函數a內部；

二、函數a返回函數b。

這樣在執行完var c=a（）後，變量c其實是指向了函數b，再執行c（）後就會彈出一個窗口顯示i的值（第一次爲1）。這段代碼其實就建立了一個閉包，爲何？由於函數a外的變量c引用了函數a內的函數b，就是說：

當函數a的內部函數b被函數a外的一個變量引用的時候，就建立了一個閉包。

2、另外一個例子

模擬私有變量

functionCounter(start){

var count = start;
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);

l 建立一個塊

塊使用脫字符(^)做爲起始標誌，使用分號做爲結束標誌。下面的例子聲明一個簡單塊，而且將其賦給以前聲明的block變量（oneFrom）。

int (^oneFrom)(int);

oneFrom = ^(int anInt) {

return anInt - 1;

};

2、閉包有什麼做用？

簡而言之，閉包的做用就是在a執行完並返回後，閉包使得Javascript的垃圾回收機制GC不會收回a所佔用的資源，由於a的內部函數b的執行須要依賴a中的變量。這是對閉包做用的很是直白的描述，不專業也不嚴謹，但大概意思就是這樣，理解閉包須要按部就班的過程。

在上面的例子中，因爲閉包的存在使得函數a返回後，a中的i始終存在，這樣每次執行c（），i都是自加1後alert出i的值。

那 麼咱們來想象另外一種狀況，若是a返回的不是函數b，狀況就徹底不一樣了。由於a執行完後，b沒有被返回給a的外界，只是被a所引用，而此時a也只會被b引 用，所以函數a和b互相引用但又不被外界打擾（被外界引用），函數a和b就會被GC回收。（關於Javascript的垃圾回收機制將在後面詳細介紹）

3、閉包內的微觀世界

如 果要更加深刻的瞭解閉包以及函數a和嵌套函數b的關係，咱們須要引入另外幾個概念：函數的執行環境（execution context）、活動對象（call object）、做用域（scope）、做用域鏈（scope chain）。以函數a從定義到執行的過程爲例闡述這幾個概念。

一、當定義函數a的時候，js解釋器會將函數a的做用域鏈（scope chain）設置爲定義a時a所在的「環境」，若是a是一個全局函數，則scope chain中只有window對象。

二、當函數a執行的時候，a會進入相應的執行環境（execution context）。

三、在建立執行環境的過程當中，首先會爲a添加一個scope屬性，即a的做用域，其值就爲第1步中的scope chain。即a.scope=a的做用域鏈。

四、而後執行環境會建立一個活動對象（call object）。活動對象也是一個擁有屬性的對象，但它不具備原型並且不能經過JavaScript代碼直接訪問。建立完活動對象後，把活動對象添加到a的做用域鏈的最頂端。此時a的做用域鏈包含了兩個對象：a的活動對象和window對象。

五、下一步是在活動對象上添加一個arguments屬性，它保存着調用函數a時所傳遞的參數。

六、最後把全部函數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中的變量查找機制。

4、閉包的應用場景

一、保護函數內的變量安全。以最開始的例子爲例，函數a中i只有函數b才能訪問，而沒法經過其餘途徑訪問到，所以保護了i的安全性。

二、在內存中維持一個變量。依然如前例，因爲閉包，函數a中i的一直存在於內存中，所以每次執行c（），都會給i自加1。

以上兩點是閉包最基本的應用場景，不少經典案例都源於此。

5、Javascript的垃圾回收機制

在Javascript中，若是一個對象再也不被引用，那麼這個對象就會被GC回收。若是兩個對象互相引用，而再也不被第3者所引用，那麼這兩個互相引用的對象也會被回收。由於函數a被b引用，b又被a外的c引用，這就是爲何函數a執行後不會被回收的緣由。

編輯本段匿名內部

在Python中的閉包（Closure)

學過Java GUI編程的人都知道定義匿名內部類是註冊監聽等處理的簡潔有效手段，閉包的定義方式有點相似於這種匿名內部類，

可是閉包的做用威力遠遠超過匿名內部類，這也是不少流行動態語言選擇閉包的緣由，相信你在JavaScript中已經瞭解它的神奇功效了。

定義： 若是在一個內部函數裏，對在外部做用域（但不是在全局做用域）的變量進行引用，那麼內部函數就被認爲是閉包（closure）。

簡單閉包的例子：

下面是一個使用閉包簡單的例子，模擬一個計數器，經過將整型包裹爲一個列表的單一元素來模擬使看起來更易變：

  代碼格式較重要

函數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

編輯本段在離散中

「關係」的閉包（Closure)

離散數學中，一個關係R的閉包，是指加上最小數目的有序偶爾造成的具備自反性，對稱性或傳遞性的新的有序偶集，此集就是關係R的閉包。

設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）。

編輯本段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)

end

外部的局部變量

例子中包含在sortbygrade函數內部的sort中的匿名函數能夠訪問sortbygrade的參數grades，在匿名函數內部grades不是全局變量也不是局部變量，咱們稱做 外部的局部變量（external local variable）或者upvalue。（upvalue意思有些誤導，然而在Lua中他的存在有歷史的根源，還有他比起external local variable簡短）。

看下面的代碼：

function newCounter()

local i = 0

return function() -- anonymous function

i = i + 1

return i

end

end

c1 = newCounter()

print(c1()) --> 1

print(c1()) --> 2

匿名函數使用upvalue i保存他的計數，當咱們調用匿名函數的時候i已經超出了做用範圍，由於建立i的函數newCounter已經返回了。然而Lua用閉包的思想正確處理了這種狀況。簡單的說，閉包是一個函數以及它的upvalues。若是咱們再次調用newCounter，將建立一個新的局部變量i，所以咱們獲得了一個做用在新的變量i上的新閉包。

c2 = newCounter()

print(c2()) --> 1

print(c1()) --> 3

print(c2()) --> 2

c一、c2是創建在同一個函數上，但做用在同一個局部變量的不一樣實例上的兩個不一樣的閉包。

技術上來說，閉包指值而不是指函數，函數僅僅是閉包的一個原型聲明；儘管如此，在不會致使混淆的狀況下咱們繼續使用術語函數代指閉包。

閉包在上下文環境中提供頗有用的功能，如前面咱們見到的能夠做爲高級函數（sort）的參數；做爲函數嵌套的函數（newCounter）。這一機制使得咱們能夠在Lua的函數世界裏組合出奇幻的編程技術。閉包也可用在回調函數中， 好比在GUI環境中你須要建立一系列button，但用戶按下button時回調函數被調用，可能不一樣的按鈕被按下時須要處理的任務有點區別。具體來說，一個十進制計算器須要10個類似的按鈕，每一個按鈕對應一個數字，可使用下面的函數建立他們：

function digitButton (digit)

return Button{ label = digit,

action = function ()

add_to_display(digit)

end

}

end

這個例子中咱們假定Button是一個用來建立新按鈕的工具，label是按鈕的標籤，action是按鈕被按下時調用的回調函數。（其實是一個閉包，由於他訪問upvalue digit）。digitButton完成任務返回後，局部變量digit超出範圍，回調函數仍然能夠被調用而且能夠訪問局部變量digit。

閉包在徹底不一樣的上下文中也是頗有用途的。由於函數被存儲在普通的變量內咱們能夠很方便的重定義或者預約義函數。一般當你須要原始函數有一個新的實現時能夠重定義函數。例如你能夠重定義sin使其接受一個度數而不是弧度做爲參數：

oldSin = math.sin

math.sin = function (x)

return oldSin(x*math.pi/180）

end

更清楚的方式：

do

local oldSin = math.sin

local k = math.pi/180

math.sin = function (x)

return oldSin(x*k)

end

end

這樣咱們把原始版本放在一個局部變量內，訪問sin的惟一方式是經過新版本的函數。

利用一樣的特徵咱們能夠建立一個安全的環境（也稱做沙箱，和java裏的沙箱同樣），當咱們運行一段不信任的代碼（好比咱們運行 網絡服務器上獲取的代碼）時安全的環境是須要的，好比咱們可使用閉包重定義io庫的open函數來限制程序打開的文件。

do

local oldOpen = io.open

io.open = function (filename,mode)

if access_OK(filename,mode) then

return oldOpen(filename,mode)

else

return nil,"access denied"

end

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的 閉包性質。通常說，某種組合數據對象的操做知足閉包性質，那就是說，經過它組合起數據對象獲得的結果自己還能夠經過一樣的操做再進行組合。閉包性質是任何一種組合功能的威力的關鍵要素，由於它使咱們可以創建起層次性結構，這種結構由一些部分構成，而其中的各個部分又是由它們的部分構成，而且能夠如此繼續下去。