大家发点自己用闭包写的功能(简洁有用的)

最近没事，想进一步研究下javascript，所以在看闭包的内容，网上找的要么太简单，要么太深，不能对其完全理解，但是总归它的原理我是懂了的，希望大家有写过闭包，而且觉得写得不错的，容易理解的发上来分享下

解决方案 »

免费领取超大流量手机卡，每月29元包185G流量+100分钟通话, 中国电信官方发货

其实就作用域的问题
比如<!DOCTYPE HTML>
<html>
<head>
<meta charset="gb2312" />
<title></title>
</head>
<body>
<script>
;(function(){
var test = 123;
})();
alert(test) // 获取不鸟闭包中的变量
</script>
<script>
;(function(){
var test = 123;
window.test = test;  //赋予全局变量
})();
alert(test) // 可以获取
</script>
</body>
</html>
再如
页面有
<div>111</div>
<div>222</div>
<div>333</div>
现在想点击他们显示出 0、1、2（暂且理解为现实索引）
通常会这样写<!DOCTYPE HTML>
<html>
<head>
<meta charset="gb2312" />
<title></title>
<style type="text/css">
div {
border: 1px solid red;
}
</style>
</head>
<body>
<div>111</div>
<div>222</div>
<div>333</div>
<script>
var objs = document.getElementsByTagName('div');
for(var i = 0, len = objs.length; i < len; i++){
objs[i].onclick = function(){
alert( i );
}
}
</script>
</body>
</html>
可事与愿违，点击弹出的全是 3.
是因为点击时，i作为全局变量，已经递加为3了。此时就要使用闭包了，相当于把i作为局部变量保护起来，参见 var objs = document.getElementsByTagName('div');
for(var i = 0, len = objs.length; i < len; i++){
;(function(i){
objs[i].onclick = function(){
alert( i );
}
})(i);
}
这样就能显示正确了。
其实看w3school里说的ECMAScript 最易让人误解的一点是，它支持闭包（closure）。

闭包，指的是词法表示包括不被计算的变量的函数，也就是说，函数可以使用函数之外定义的变量。
“函数可以使用函数之外定义的变量” 看到这句话就应该什么是闭包了  并不是什么很高深的东西哦
比方说用户向后台提交一个请求,后台如果报错会返回一个错误代码,那么前台js就要根据这个错误代码做相应的处理,普通方法就是用if..else..来处,万一错误代码很多的话if else多了就不好维护了,这里有个例子.
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE> New Document </TITLE>
<script type="text/javascript">
// 后台总共有这些错误代码
var errorCodeArr = ['1000','1001','1002']; var errorHandler = (function(){
var handlerMap = {};
handlerMap['1000'] = function(){
alert('处理1000错误');
}
handlerMap['1001'] = function(){
alert('处理1001错误');
}
handlerMap['1002'] = function(){
alert('处理1002错误');
}
// 如果以后添加其他错误代码可以以此类推
// ... return function(errorCode){
handlerMap[errorCode]();
}
})(); // 后台抛出1001错误
errorHandler('1001');
</script>
</HEAD>
<BODY>
</BODY>
</HTML>
受教，顺便我问下jquery的事件绑定等功能是否用的闭包的感念
还可以用来创建单列程序
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE> New Document </TITLE>
<script type="text/javascript">
var DateUtil = (function(){
// 私有变量
var ymdFmt = 'yyyy-MM-dd';
var ymdhmsFmt = 'yyyy-MM-dd HH:mm:ss'; return {
ymdFormat:function(date) {
// ymdFmt
alert(ymdFmt + '格式处理日期:'+ date)
}
,ymdhmsFormat:function(date){
// ymdhmsFmt
alert(ymdhmsFmt + '格式处理日期:' + date)
}
};

})()
DateUtil.ymdhmsFormat(new Date());
</script>
</HEAD>
<BODY>
</BODY>
</HTML>
简单说，一个function 就是一个闭包。内部变量，只是在这个函数内部有效。
先来个简单的
var getGuid = (function(){
  var guid = 0;
  return function(){
    return guid++;
  };
})();console.log(getGuid());
console.log(getGuid());
console.log(getGuid());
随手敲了一个简单的用到了闭包的demo，这里的闭包的作用主要是避免了频繁进行DOM查找，提高了效率<!DOCTYPE HTML>
<html>
    <head>
        <meta charset="utf-8" />
        <title>test</title>
    </head>
    <body>
     <form>
     <label>
     <span>Text:</span>
     <input type="text" id="text-box" />
     </label>
     <input id="verify" type="button" value="Verify" />
     </form>
<script>
document.getElementById("verify").onclick = (function(){
var text_box = document.getElementById("text-box"),
reg = /^\d+$/;
return function(){
alert(reg.test(text_box.value));
}
})();
</script>
    </body>
</html>
一、变量的作用域
要理解闭包，首先必须理解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），子对象会一级一级地向上寻找所有父对象的变量。所以，父对象的所有变量，对子对象都是可见的，反之则不成立。既然f2可以读取f1中的局部变量，那么只要把f2作为返回值，我们不就可以在f1外部读取它的内部变量了吗！
Js代码
　　function f1(){
　　　　n=999;
　　　　function f2(){　　　　　　alert(n);　　　　}
　　　　return f2;
　　}
　　var result=f1();
　　result(); // 999
--------------------------------------------------------------------------------------------------------
三、闭包的概念
上一节代码中的f2函数，就是闭包。各种专业文献上的“闭包”（closure）定义非常抽象，很难看懂。我的理解是，闭包就是能够读取其他函数内部变量的函数。由于在Javascript语言中，只有函数内部的子函数才能读取局部变量，因此可以把闭包简单理解成“定义在一个函数内部的函数”。所以，在本质上，闭包就是将函数内部和函数外部连接起来的一座桥梁。
--------------------------------------------------------------------------------------------------------b
四、闭包的用途
闭包可以用在许多地方。它的最大用处有两个，一个是前面提到的可以读取函数内部的变量，另一个就是让这些变量的值始终保持在内存中。
怎么来理解这句话呢？请看下面的代码。
Js代码
　　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），这时一定要小心，不要随便
改变父函数内部变量的值。
--------------------------------------------------------------------------------------------------------
六、思考题
如果你能理解下面代码的运行结果，应该就算理解闭包的运行机制了。
Js代码　　var name = "The Window"; 　　var object = { 　　　　name : "My Object", 　　　　getNameFunc : function(){ 　　　　　　return function(){ 　　　　　　　　return this.name; 　　　　　}; 　　　　} }; alert(object.getNameFunc()()); //The Window
--------------------------------------------------------------------------------------------------------JavaScript闭包例子
function outerFun(){var a=0;function innerFun(){a++;alert(a);} }innerFun()
上面的代码是错误的.innerFun()的作用域在outerFun()内部,所在outerFun()外部调用它是错误的.改成如下,也就是闭包:
Js代码
function outerFun(){var a=0;function innerFun(){a++;alert(a);}return innerFun; //注意这里}var obj=outerFun();obj(); //结果为1obj(); //结果为2var obj2=outerFun();obj2(); //结果为1obj2(); //结果为2
什么是闭包:
当内部函数在定义它的作用域的外部被引用时,就创建了该内部函数的闭包 ,如果内部函数引用了位于外部函数的变量,当外部函数调用完毕后,这些变量在内存不会被释放,因为闭包需要它们.
一、变量的作用域
要理解闭包，首先必须理解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），子对象会一级一级地向上寻找所有父对象的变量。所以，父对象的所有变量，对子对象都是可见的，反之则不成立。既然f2可以读取f1中的局部变量，那么只要把f2作为返回值，我们不就可以在f1外部读取它的内部变量了吗！
Js代码
　　function f1(){
　　　　n=999;
　　　　function f2(){　　　　　　alert(n);　　　　}
　　　　return f2;
　　}
　　var result=f1();
　　result(); // 999
--------------------------------------------------------------------------------------------------------
三、闭包的概念
上一节代码中的f2函数，就是闭包。各种专业文献上的“闭包”（closure）定义非常抽象，很难看懂。我的理解是，闭包就是能够读取其他函数内部变量的函数。由于在Javascript语言中，只有函数内部的子函数才能读取局部变量，因此可以把闭包简单理解成“定义在一个函数内部的函数”。所以，在本质上，闭包就是将函数内部和函数外部连接起来的一座桥梁。
--------------------------------------------------------------------------------------------------------b
四、闭包的用途
闭包可以用在许多地方。它的最大用处有两个，一个是前面提到的可以读取函数内部的变量，另一个就是让这些变量的值始终保持在内存中。
怎么来理解这句话呢？请看下面的代码。
Js代码
　　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），这时一定要小心，不要随便
改变父函数内部变量的值。
--------------------------------------------------------------------------------------------------------
六、思考题
如果你能理解下面代码的运行结果，应该就算理解闭包的运行机制了。
Js代码　　var name = "The Window"; 　　var object = { 　　　　name : "My Object", 　　　　getNameFunc : function(){ 　　　　　　return function(){ 　　　　　　　　return this.name; 　　　　　}; 　　　　} }; alert(object.getNameFunc()()); //The Window
--------------------------------------------------------------------------------------------------------JavaScript闭包例子
function outerFun(){var a=0;function innerFun(){a++;alert(a);} }innerFun()
上面的代码是错误的.innerFun()的作用域在outerFun()内部,所在outerFun()外部调用它是错误的.改成如下,也就是闭包:
Js代码
function outerFun(){var a=0;function innerFun(){a++;alert(a);}return innerFun; //注意这里}var obj=outerFun();obj(); //结果为1obj(); //结果为2var obj2=outerFun();obj2(); //结果为1obj2(); //结果为2
什么是闭包:
当内部函数在定义它的作用域的外部被引用时,就创建了该内部函数的闭包 ,如果内部函数引用了位于外部函数的变量,当外部函数调用完毕后,这些变量在内存不会被释放,因为闭包需要它们.
一、变量的作用域
要理解闭包，首先必须理解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），子对象会一级一级地向上寻找所有父对象的变量。所以，父对象的所有变量，对子对象都是可见的，反之则不成立。既然f2可以读取f1中的局部变量，那么只要把f2作为返回值，我们不就可以在f1外部读取它的内部变量了吗！
Js代码
　　function f1(){
　　　　n=999;
　　　　function f2(){　　　　　　alert(n);　　　　}
　　　　return f2;
　　}
　　var result=f1();
　　result(); // 999
--------------------------------------------------------------------------------------------------------
三、闭包的概念
上一节代码中的f2函数，就是闭包。各种专业文献上的“闭包”（closure）定义非常抽象，很难看懂。我的理解是，闭包就是能够读取其他函数内部变量的函数。由于在Javascript语言中，只有函数内部的子函数才能读取局部变量，因此可以把闭包简单理解成“定义在一个函数内部的函数”。所以，在本质上，闭包就是将函数内部和函数外部连接起来的一座桥梁。
--------------------------------------------------------------------------------------------------------b
四、闭包的用途
闭包可以用在许多地方。它的最大用处有两个，一个是前面提到的可以读取函数内部的变量，另一个就是让这些变量的值始终保持在内存中。
怎么来理解这句话呢？请看下面的代码。
Js代码
　　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），这时一定要小心，不要随便
改变父函数内部变量的值。
--------------------------------------------------------------------------------------------------------
六、思考题
如果你能理解下面代码的运行结果，应该就算理解闭包的运行机制了。
Js代码　　var name = "The Window"; 　　var object = { 　　　　name : "My Object", 　　　　getNameFunc : function(){ 　　　　　　return function(){ 　　　　　　　　return this.name; 　　　　　}; 　　　　} }; alert(object.getNameFunc()()); //The Window
--------------------------------------------------------------------------------------------------------JavaScript闭包例子
function outerFun(){var a=0;function innerFun(){a++;alert(a);} }innerFun()
上面的代码是错误的.innerFun()的作用域在outerFun()内部,所在outerFun()外部调用它是错误的.改成如下,也就是闭包:
Js代码
function outerFun(){var a=0;function innerFun(){a++;alert(a);}return innerFun; //注意这里}var obj=outerFun();obj(); //结果为1obj(); //结果为2var obj2=outerFun();obj2(); //结果为1obj2(); //结果为2
什么是闭包:
当内部函数在定义它的作用域的外部被引用时,就创建了该内部函数的闭包 ,如果内部函数引用了位于外部函数的变量,当外部函数调用完毕后,这些变量在内存不会被释放,因为闭包需要它们.