前端閉包演算法

① javaScript 中的閉包好處是什麼為什麼用到閉包

js中的局部變數出了作用於就會被垃圾回收機制回收，這時候如果想長久保存這個變數不被回收就要用到閉包。

真心想學習JS、以後想朝著這個方向發展，那麼你一定要來這個企鵝裙，前面前面是二

九六，中間是五九1，最後面就是二九0，連起來就是完整的噢，來這里可以這里學習經驗，得到專人解答，這樣你可以成長的更快，期待你的加入！！！閉包的規則是：1，函數嵌套函數。2，內部函數使用了外部函數的變數或者參數。

下面有個二級菜單的小案例就是使用了閉包的特性：

<div><li>0</li><li>1</li><li>2</li></div>

<script>

varlis=document.getElementsByTagName("li");

for(vari=0;i<lis.length;i++){

(function(i){//外部函數

lis[i].onclick=function(){alert(i)}//內部函數使用外部函數的參數

})(i);

}

</script>

這就是閉包的一個應用。

② JavaScript 里的閉包是什麼應用場景有哪些

閉包是：指有有訪問另一個函數作用域中的變數的函數。

創建閉包的常用方式：在一個函數內部創建一個函數。例子：

functioncreateFunction(name){
returnfunction(obj1,obj2){
varvalue1=obj1[name];
varvalue2=obj2[name];

returnvalue1+","+value2;
}
}

了解創建作用域以及作用域有什麼作用的細節，對徹底理解閉包到頭重要。當某個函數被調用時，會創建一個執行環境及相應的作用域鏈。然後，使用arguments和其他參數的值來初始化函數的活動對象。

一、閉包

1、createFunction()創建時，它(compare)的作用域包含createFunction()函數的活動對象和全局對象。

//創建函數
varcompare=createFunction("name");
console.log(typeofcompare);//function

2、匿名函數被執行時，創建自己的活動對象和可以訪問createFunction()的執行環境。

//調用函數
varresult=compare({name:"jjaiy"},{name:"ascy"});//jjaiyy,ascy

3、createFunction()函數執行完後，其執行環境的作用域不會被銷毀。原因在於它的活動對象還在內存中，直到匿名函數被銷毀。

//解除對匿名函數的引用（以便釋放內存）
compare=null;

原因在於：

瀏覽器的垃圾收集方式有：

• 標記清除（主要針對變數）

• 引用計數（跟蹤記錄每個值被引用的次數）

二、實例運行

封裝功能

varroute={
routes:{},
for:function(path,handler){//閉包
this.routes[path]=handler;//引用回調函數
}
};

//執行二個匿名函數
route.for("/start",function(request,response){
response.writeHead(200,{"Content-Type":"text/plain"});
response.write("Hello");
response.end();
});

route.for("/finish",function(request,response){
response.writeHead(200,{"Content-Type":"text/plain"});
response.write("Goodbye");
response.end();
});

//先判斷argument中的path變數是否一致，能否調用其函數中的回調函數。
if(typeofroute.routes["/finish"]==='function'){
route.routes["/finish"](request,response);
}

③ javascript 閉包

1、何謂閉包

JavaScript例子：

function GISMapPanel() {
this.mapPanel = document.getElementById("mapDiv");
this.width;
this.height;

this.showMap = function() {
alert(this.mapPanel); //tip:[object]
this.mapPanel.onmousedown = this.mouseDownEventProcess();
}

this.mouseDownEventProcess = function( ){
var _this = this;
return function() {
alert(this.mapPanel); //tip:undefined,why;
_this.width = 400;
_this.height = 300;
//other codes
}
}
}

閉包簡單的解釋是，ECMAScript允許inner functions(嵌套函數)：函數可以定義在另外一個函數裡面。這些內部的函數可以訪問outer function（父函數）的local變數，參數，其它內部函數。當內部函數被構造，並可以在函數外被獲得（函數當成返回值），這個內部函數在 outer function返回後被執行（在outer函數外執行），那一個閉包形成了。

閉包特徵：A、作為一個函數變數的一個引用，當函數返回時，其處於激活狀態；B、一個閉包就是當一個函數返回時，一個沒有釋放資源的棧區。

2、 閉包隱喻

function就像房子內的居室(也是房子)，可以租給給甲居住，甲就是居室(function)的主人(this)，也可以租給乙住，乙就成為居室(function)的主人(this)，甲原來的一切則被甲帶走，乙用不到任何甲的東西。如果甲是房子(外層function)的主人，並把某居室(內層function)租給乙，乙具有居室內的一切，而乙也可以使用甲的衛生間、客廳(外層函數變數，如_this)。閉包變數就是外層房子內變數，包括居室(function)、衛生間、客廳(外層函數變數)。同JavaScript閉包，居室可以是一局、兩局、多局，當然一局一般比較好租，JavaScript閉包一般也是一局。

3、閉包作用

面向對象編程的成功和流行，使不支持面向的對象編程的語言也盡量往這個方向靠，如C語言可以通過struct及function指針，模擬面向對象編程，以期達到面向對象的封裝、多態；JavaScript則通過基於對象編制以期達到封裝性。如上例所示，把地圖(div)相關的事件處理代碼、相關屬性、相關方法集中到GISMapPanel對象中。但由於事件發生的實體是地圖對應的div對象，事件函數調用時房子是由div對象居住的，也就是說this是div元素，因此，會出現alert(this.mapPanel); //tip:undefined，div元素沒有屬性mapPanel；如果想要訪問原GISMapPanel對象中的屬性，就要象例子所示，把GISMapPanel對象當作一個客廳來處理，從而可以使用客廳內的東西，而不是別人居室內的東西(也是訪問不到的，正如alert(this.mapPanel); //tip:undefined，該this就不是外層居室的this了，本來想直接訪問外層居室的this)。通過閉包、基於對象，取代了全局變數、函數方式的JavaScript處理事件、業務邏輯處理手段，增加了模塊性、封裝性、問題局部化等特性。

④ JavaScript 里的閉包是什麼應用場景有哪些

閉包（closure）是Javascript語言的一個難點，也是它的特色，很多高級應用都要依靠閉包實現。
下面就是我的學習筆記，對於Javascript初學者應該是很有用的。
一、變數的作用域
要理解閉包，首先必須理解Javascript特殊的變數作用域。
變數的作用域無非就是兩種：全局變數和局部變數。
Javascript語言的特殊之處，就在於函數內部可以直接讀取全局變數。
var n=999;
function f1(){
alert(n);
}
f1(); // 999
另一方面，在函數外部自然無法讀取函數內的局部變數。
function f1(){
var n=999;
}
alert(n); // error
這里有一個地方需要注意，函數內部聲明變數的時候，一定要使用var命令。如果不用的話，你實際上聲明了一個全局變數！
function f1(){
n=999;
}
f1();
alert(n); // 999
二、如何從外部讀取局部變數？
出於種種原因，我們有時候需要得到函數內的局部變數。但是，前面已經說過了，正常情況下，這是辦不到的，只有通過變通方法才能實現。
那就是在函數的內部，再定義一個函數。
function f1(){
var n=999;
function f2(){
alert(n); // 999
}
}
在上面的代碼中，函數f2就被包括在函數f1內部，這時f1內部的所有局部變數，對f2都是可見的。但是反過來就不行，f2內部的局部變數，
對f1就是不可見的。這就是Javascript語言特有的"鏈式作用域"結構（chain scope），子對象會 "一級一級" 地向上尋找所有父對象的變數。
所以，父對象的所有變數，對子對象都是可見的，反之則不成立。
既然f2可以讀取f1中的局部變數，那麼只要把f2作為返回值，我們不就可以在f1外部讀取它的內部變數了嗎！
function f1(){
var n=999;
function f2(){
alert(n);
}
return f2;
}
var result=f1();
result(); // 999
三、閉包的概念
上一節代碼中的f2函數，就是閉包。
各種專業文獻上的"閉包"（closure）定義非常抽象，很難看懂。我的理解是，閉包就是能夠讀取其他函數內部變數的函數。
由於在Javascript語言中，只有函數內部的子函數才能讀取局部變數，因此可以把閉包簡單理解成"定義在一個函數內部的函數"。
所以，在本質上，閉包就是將函數內部和函數外部連接起來的一座橋梁。
四、閉包的用途
閉包可以用在許多地方。它的最大用處有兩個，一個是前面提到的可以讀取函數內部的變數，另一個就是讓這些變數的值始終保持在內存中。
怎麼來理解這句話呢？請看下面的代碼。
function f1(){
var n=999;
nAdd=function(){n+=1}
function f2(){
alert(n);
}
return f2;
}
var result=f1();
result(); // 999
nAdd();
result(); // 1000
在這段代碼中，result實際上就是閉包f2函數。它一共運行了兩次，第一次的值是999，第二次的值是1000。
這證明了，函數f1中的局部變數n一直保存在內存中，並沒有在f1調用後被自動清除。
為什麼會這樣呢？原因就在於f1是f2的父函數，而f2被賦給了一個全局變數，這導致f2始終在內存中，而f2的存在依賴於f1，
因此f1也始終在內存中，不會在調用結束後，被垃圾回收機制（garbage collection）回收。
這段代碼中另一個值得注意的地方，就是"nAdd=function(){n+=1}"這一行，首先在nAdd前面沒有使用var關鍵字，因此nAdd是一個全局變數，而不是局部變數。
其次，nAdd的值是一個匿名函數（anonymous function），而這個匿名函數本身也是一個閉包，
所以nAdd相當於是一個setter，可以在函數外部對函數內部的局部變數進行操作。
五、使用閉包的注意點
1）由於閉包會使得函數中的變數都被保存在內存中，內存消耗很大，所以不能濫用閉包，否則會造成網頁的性能問題，在IE中可能導致內存泄露。
解決方法是，在退出函數之前，將不使用的局部變數全部刪除。
2）閉包會在父函數外部，改變父函數內部變數的值。所以，如果你把父函數當作對象（object）使用，把閉包當作它的公用方法（Public Method），
把內部變數當作它的私有屬性（private value），這時一定要小心，不要隨便改變父函數內部變數的值。
六、思考題
如果你能理解下面兩段代碼的運行結果，應該就算理解閉包的運行機制了。
代碼片段一。
var name = "The Window";
var object = {
name : "My Object",
getNameFunc : function(){//alert(this.name);//My Object
return function(){
return this.name;// 空
};
}
};
alert(this.name);// The Window
alert(object.getNameFunc()()); // 空

代碼片段二。
var name = "The Window";
var object = {
name : "My Object",
getNameFunc : function(){
var that = this;
return function(){
return that.name;
};
}
};
alert(object.getNameFunc()()); // My Object

⑤ JavaScript閉包，什麼是閉包，對閉包的理解

提問



該問題可能描述不清，建議你重新提問

javascript的閉包是什麼意思 有什麼用

我有更好回答



PHP交流者之家

電腦網路認證團隊  推薦於 2017-09-06

一、什麼是閉包？
「官方」的解釋是：所謂「閉包」，指的是一個擁有許多變數和綁定了這些變數的環境的表達式（通常是一個函數），因而這些變數也是該表達式的一部分。
相信很少有人能直接看懂這句話，因為他描述的太學術。我想用如何在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外的一個變數引用的時候，就創建了一個閉包。
我猜想你一定還是不理解閉包，因為你不知道閉包有什麼作用，下面讓我們繼續探索。

⑥ js中閉包是什麼意思，有什麼作用，最好舉例說明啊。

函數對象可以通過作用域鏈相互關聯起來，函數體內部的變數都可以保存在函數作用域內，這種特性在計算機科學文獻中稱之為「閉包」。
從技術角度講，所有的JavaScript函數都是閉包： 它們都是對象，它們都關聯到作用域鏈。
實現計數器
介紹利用閉包實現計數器，請看以下代碼：

var counter = (function() {

var count = 0;

return function() {

return count ++;

}

})();

以上代碼定義了一個立即執行的函數，count遍歷只能在這個匿名函數中可以使用。

⑦ JavaScript 里的閉包是什麼應用場景有哪些

閉包（closure）是Javascript語言的一個難點，也是它的特色，很多高級應用都要依靠閉包實現。
下面就是我的學習筆記，對於Javascript初學者應該是很有用的。
一、變數的作用域
要理解閉包，首先必須理解Javascript特殊的變數作用域。
變數的作用域無非就是兩種：全局變數和局部變數。
Javascript語言的特殊之處，就在於函數內部可以直接讀取全局變數。
varn=999;
functionf1(){
alert(n);
}
f1();//999
另一方面，在函數外部自然無法讀取函數內的局部變數。
functionf1(){
varn=999;
}
alert(n);//error
這里有一個地方需要注意，函數內部聲明變數的時候，一定要使用var命令。如果不用的話，你實際上聲明了一個全局變數！
functionf1(){
n=999;
}
f1();
alert(n);//999
二、如何從外部讀取局部變數？
出於種種原因，我們有時候需要得到函數內的局部變數。但是，前面已經說過了，正常情況下，這是辦不到的，只有通過變通方法才能實現。
那就是在函數的內部，再定義一個函數。
functionf1(){
varn=999;
functionf2(){
alert(n);//999
}
}
在上面的代碼中，函數f2就被包括在函數f1內部，這時f1內部的所有局部變數，對f2都是可見的。但是反過來就不行，f2內部的局部變數，
對f1就是不可見的。這就是Javascript語言特有的"鏈式作用域"結構（chainscope），子對象會"一級一級"地向上尋找所有父對象的變數。
所以，父對象的所有變數，對子對象都是可見的，反之則不成立。
既然f2可以讀取f1中的局部變數，那麼只要把f2作為返回值，我們不就可以在f1外部讀取它的內部變數了嗎！
functionf1(){
varn=999;
functionf2(){
alert(n);
}
returnf2;
}
varresult=f1();
result();//999
三、閉包的概念
上一節代碼中的f2函數，就是閉包。
各種專業文獻上的"閉包"（closure）定義非常抽象，很難看懂。我的理解是，閉包就是能夠讀取其他函數內部變數的函數。
由於在Javascript語言中，只有函數內部的子函數才能讀取局部變數，因此可以把閉包簡單理解成"定義在一個函數內部的函數"。
所以，在本質上，閉包就是將函數內部和函數外部連接起來的一座橋梁。
四、閉包的用途
閉包可以用在許多地方。它的最大用處有兩個，一個是前面提到的可以讀取函數內部的變數，另一個就是讓這些變數的值始終保持在內存中。
怎麼來理解這句話呢？請看下面的代碼。
functionf1(){
varn=999;
nAdd=function(){n+=1}
functionf2(){
alert(n);
}
returnf2;
}
varresult=f1();
result();//999
nAdd();
result();//1000
在這段代碼中，result實際上就是閉包f2函數。它一共運行了兩次，第一次的值是999，第二次的值是1000。
這證明了，函數f1中的局部變數n一直保存在內存中，並沒有在f1調用後被自動清除。
為什麼會這樣呢？原因就在於f1是f2的父函數，而f2被賦給了一個全局變數，這導致f2始終在內存中，而f2的存在依賴於f1，
因此f1也始終在內存中，不會在調用結束後，被垃圾回收機制（garbagecollection）回收。
這段代碼中另一個值得注意的地方，就是"nAdd=function(){n+=1}"這一行，首先在nAdd前面沒有使用var關鍵字，因此nAdd是一個全局變數，而不是局部變數。
其次，nAdd的值是一個匿名函數（anonymousfunction），而這個匿名函數本身也是一個閉包，
所以nAdd相當於是一個setter，可以在函數外部對函數內部的局部變數進行操作。
五、使用閉包的注意點
1）由於閉包會使得函數中的變數都被保存在內存中，內存消耗很大，所以不能濫用閉包，否則會造成網頁的性能問題，在IE中可能導致內存泄露。
解決方法是，在退出函數之前，將不使用的局部變數全部刪除。
2）閉包會在父函數外部，改變父函數內部變數的值。所以，如果你把父函數當作對象（object）使用，把閉包當作它的公用方法（PublicMethod），
把內部變數當作它的私有屬性（privatevalue），這時一定要小心，不要隨便改變父函數內部變數的值。
六、思考題
如果你能理解下面兩段代碼的運行結果，應該就算理解閉包的運行機制了。
代碼片段一。
varname="TheWindow";
varobject={
name:"MyObject",
getNameFunc:function(){//alert(this.name);//MyObject
returnfunction(){
returnthis.name;//空
};
}
};
		alert(this.name);//TheWindow
alert(object.getNameFunc()());//空

代碼片段二。
varname="TheWindow";
varobject={
name:"MyObject",
getNameFunc:function(){
varthat=this;
returnfunction(){
returnthat.name;
};
}
};
alert(object.getNameFunc()());//MyObject

一層訪問一層，不能跨層訪問

⑧ javascript怎麼實現閉包

不需要實現，只需要學會使用
閉包（closure）是Javascript語言的一個難點，也是它的特色，很多高級應用都要依靠閉包實現。

一、變數的作用域

要理解閉包，首先必須理解Javascript特殊的變數作用域。

變數的作用域無非就是兩種：全局變數和局部變數。

Javascript語言的特殊之處，就在於函數內部可以直接讀取全局變數。

Js代碼

var n=999;

function f1(){
alert(n);
}

f1(); // 999

另一方面，在函數外部自然無法讀取函數內的局部變數。

Js代碼

function f1(){
var n=999;
}

alert(n); // error

這里有一個地方需要注意，函數內部聲明變數的時候，一定要使用var命令。如果不用的話，你實際上聲明了一個全局變數！

Js代碼

function f1(){
n=999;
}

f1();

alert(n); // 999

--------------------------------------------------------------------------------------------------------

二、如何從外部讀取局部變數？

出於種種原因，我們有時候需要得到函數內的局部變數。但是，前面已經說過了，正常情況下，這是辦不到的，只有通過變通方法才能實現。

那就是在函數的內部，再定義一個函數。

Js代碼

function f1(){

n=999;

function f2(){
alert(n); // 999
}

}

在上面的代碼中，函數f2就被包括在函數f1內部，這時f1內部的所有局部變數，對f2都是可見的。但是反過來就不行，f2內部的局部變數，對f1 就是不可見的。這就是Javascript語言特有的「鏈式作用域」結構（chain scope），

子對象會一級一級地向上尋找所有父對象的變數。所以，父對象的所有變數，對子對象都是可見的，反之