严厉的讲，闭包常常表现为一个函数内部的函数，它运用了非本身定义的、本身地点作用域内的变量，而且使这些变量打破了作用域的限定。
函数内部的函数：私有函数
起首，我们从这个内部函数去说开，因为这个是情势上的，假如一最先讲作用域，有点有意。闭包在情势上就是函数内部的函数，比方：
jQuery(function($){
function message(msg) {
alert(msg);
}
if($(window).width() > 1000) message('window宽度大于1000');
});
假如你用jquery，这段代码应当常常运用吧。假如你细致去视察，就会发明，第一个function被作为参数，传给了jQuery()这个函数，而在function内，又有一个message()函数。一切的jQuery代码被放在第一个function中去处置惩罚。第二个函数就是函数体内部的函数，这个函数在函数体内声明，一旦外层函数实行终了，那末这个函数就失去了作用，在jQuery()外没法运用message()，因而，message()是第一个函数内部的私有函数。
变量的作用域
函数内部的变量有两种，一种是局部变量，一种是全局变量。局部变量只在当前函数体内有用，出了函数体，就上一级的局限，局部变量无效。
var age = 10;
function a(age) {
return age + 1;
}
function b(_age) {
return age + _age;
}
function c(_age) {
var age = 11;
function add() {
return age + _age;
}
return add();
}
alert(a(9)); // 10 : 9 + 1
alert(b(2)); // 12 : 10 + 2
alert(c(5)); // 16 : 11 + 5
在上面的代码中，我们看b和c函数。b函数中的age直接援用了全局变量age（10），而c函数中从新声明下场部变量age，因而，全局变量age在c函数中无效。
然则在c中，函数内部有一个函数add()，它的函数体内的age是指c中声明的局部变量，而非全局变量age。从这个例子里，反应出了变量的作用域，函数内的函数体里，假如没有声明局部变量，就会认可其父级以至先人级函数的变量，以及全局变量。
闭包
怎样才算是一个闭包呢？我们来看下面的代码：
function a() {
var age = 10;
return function(){
return age;
}
}
var age = a();
alert(age()); // 10
根据我们前面说的作用域，在上面这段代码中age是a()的局部变量，按道理，出了函数，就不能被接见了。然则，a()返回了一个私有函数，个这个函数返回了age，这致使我们可以在a()外部，依然可以接见到本来是局部变量的age，这个时刻，我们就把这个内部函数称为闭包。它的道理就是，函数内部的函数，可以接见父函数的局部变量。
综合上面的论述，我们要如许去明白闭包：
闭包是一个函数，它运用了本身以外的变量。
闭包是一个作用域。
闭包是“由函数和与其相干的援用环境组合而成的实体”。
严厉的讲，闭包常常表现为一个函数内部的函数，它运用了非本身定义的、本身地点作用域内的变量，而且使这些变量打破了作用域的限定。
一个典范的闭包：
函数内的函数
这个内部函数援用了父函数的局部变量
这个内部函数使援用的变量打破了作用域限定
var a = 1;
function fun() {return a + 1;}
alert(fun());
这也可以算作一个闭包，a()援用了它以外定义的变量。然则这不算严厉的闭包，因为它没有在打破作用域的这个点上表现出来。
var a = 1;
function fun() {
var b = 2;
return function(){
return a + ++b;
};
}
var c = fun();
alert(c()); // 4
alert(c()); // 5
这就是一个异常典范的闭包了。而且为何alert(c())两次的值差别，我们还会在下面诠释到。
为了让你越发明了的和你曾开发过的案例联络在一起，我们来看我们曾做过的如许的事：
define(function(){
var age = 10;
function getAge() {
return age;
}
function grow() {
age ++;
}
return {
age : getAge,
grow : grow
};
});
这是我们在require.js中的一种写法，把它还原为我们熟习的闭包情势：
function Cat(){
var age = 10;
function getAge() {
return age;
}
function grow() {
age ++;
}
return {
ageAge : getAge,
grow : grow
};
};
var cat = Cat();
var age = cat.getAge();
alert(age); // 10
cat.grow();
age = cat.getAge();
alert(age); // 11
从内存看闭包
如今，我们就要来诠释为何上面的alert()两次的效果差别的缘由了。
起首，我们来看下一般的函数声明和运用过程中内存的变化：
function fun(a,b) {
return a+b;
}
alert(fun(1,2));
alert(fun(3,4));
上面是我们没有碰到闭包的状况，内存我们如许来画（注重，我这里只是笼统的画出内存变化，而不是实在的javascript内存机制。）
【图片缺失，请检察文末的原文链接，原文中图片一般】
在每一次实行完fun()今后，fun()函数的实行环境被开释（接纳机制）。
接下来我们来看一个闭包：
function fun(a) {
return function(b){return a + b;}
}
var add = fun(2);
alert(add(2));
alert(add(4));
上面就涌现闭包了，注重，我们这里涌现了一个add变量。
【图片缺失，请检察文末的原文链接，原文中图片一般】
在后两步中，实际上fun(2)部份没有任何变化，所变的，则是在内部函数所对应的内存地区中有变化。仔细的你，可能会发明这内里的题目地点，当实行完add(2)今后，fun对应的内存没有被开释掉，而它的内部函数，也就是function(2)被开释掉了，在实行add(4)的时刻，仅仅从新运转了内部函数。假如连fun()对应的内存涌现了变化怎么办？我们来看下面的例子：
function fun() {
var b = 2;
return function(a){
return a + ++b;
};
}
var c = fun();
alert(c(1)); // 4
alert(c(1)); // 5
注重，这但是个异常典范的闭包的例子，它有一个局部变量b，我们来看它的内存图。
【图片缺失，请检察文末的原文链接，原文中图片一般】
注重第2、3、4步中内存的变化。第2步时，我们仅仅将fun()赋给变量c，这个时刻，内部函数function(a)并没有被实行，所以++b也没有被实行，b的值照样2。然则第3步最先，++b被先实行，++b的意义是先自加，再进行运算，和b++是差别的，假如是b++，虽然c(1)的终究效果照样为4，然则在c(1)实行最先时，b应当为2，实行完今后才是3。
巧妙的事变发生了，在内部函数中，++b致使下场部变量值发生了变化，b从2变成了3，而且，内存并没有被开释，fun()的实行环境没有被烧毁，b还被保留在内存中。到第4步时，b的初始值是3，经由++b 今后，变成了4。
这个内存剖析异常抽象的把闭包观点中，关于“打破作用域限定”这个点形貌的异常清晰，底本根据作用域的限定，函数的局部变量不能被外部环境接见，更不能被修正，然则闭包却使得外部环境不仅可以读取到局部变量的内容，以至可以修正它，深切一点就是：闭包会致使闭包函数所涉及到的非本身定义的变量一向保留在内存中，包含其父函数在内的相干环境都不会被烧毁。
闭包到底有什么用？
说了这么多，那闭包到底有什么用，我们为何要运用闭包呢？从上面的论述中，你应当已知道了闭包的唯一作用：打破作用域限定。那怎样运用这个作用为顺序效劳呢？
常驻内存，意味着读取速率快（，固然，内存花消也大，致使内存溢出）。常驻内存，意味着一旦初始化今后，就可以重复运用同一个内存中的某个对象，而无需再次运转顺序。而这一点，是许多插件、模块的设想头脑。
最好的例子就是上文我举得谁人define()的例子，背面用我们本日所相识的情势去实践今后，你就会发明本来可以把function当作一个其他语言中的class来看待，cat.getAge(), cat.grow()如许的操纵是不是是很相符我们在编程中的运用习气呢？一旦一个发生今后，这个cat就一向在内存中，随时可以拿出来就用，它就是一个实例化对象。
为了更抽象，我们来建立一个简朴的代码块：
function Animal() {
this.age = 1;
this.weight = 10;
return {
getAge : function(){
return this.age;
},
getWeight : function(){
return this.weight;
},
grow : function(){
this.age ++;
this.weight = this.age * 10 * 0.8;
}
};
}
function Cat() {
var cat = new Animal(); // 继承
cat.grow = function(){
cat.age ++;
cat.weight = cat.age * 10 * 0.6;
}
return cat;
}
var cat1 = new Cat();
alert(cat1.getAge());
cat1.grow();
alert(cat1.getAge());
为何要举这个例子呢，因为我想让你想象如许一种场景，假如没有闭包怎么办？
没有闭包是如许的一种状况：函数没法接见本身父级（先人，全局）对象的变量。比方：
var a = 1;
function add() {
return ++a; // 假如没有闭包机制，会undefined报错
}
这类状况怎么办？必需以参数的情势传入到函数中：
var a = 1;
function add(a) {
return ++a;
}
alert(add(a)); // 2
假如是如许，就很贫苦了，你需要在每个函数中传入变量。而更贫苦的是，没有了作用域的打破，比方：
function Cat() {
age = 1;
function getAge(age) {
return age;
}
function grow(age) {
age ++;
}
return {
getAge : getAge,
grow : grow
}
}
var cat = new Cat();
cat.grow();
alert(cat.getAge()); // 1，没有被修正
这类状况下，我们无论怎样都没法运用这类要领来完成我们的目标。唯一可以完成的，就是根据下面这类要领：
var cat = {
age : 1,
weight : 10,
grow : function(){
this.age ++;
this.weight += 3;
}
};
var cat1 = cat;
alert(cat1.age);
cat1.grow();
alert(cat1.age);
我们智慧的运用到了this关键字，然则如许一个害处是，age, weight这些属性直接暴露给外部，我们只需要实行 cat1.age = 12; 就可以立时让cat长到12岁，而体重却没任何变化。
总结而言，闭包可以带来这么几个方面的运用上风：
常驻内存，加速运转速率
封装
闭包运用中的注重点
除了上面提到的内存开支题目外，另有一个需要被注重的处所，就是闭包所援用的外部变量，在一些特别状况下会存在与期望值差别的偏差。
function init() {
var pAry = document.getElementsByTagName("p");
for( var i=0; i<pAry.length; i++ ) {
pAry[i].i = i;
pAry[i].onclick = function() {
alert(this.i);
}
}
}
在上面这段代码中，你愿望经由过程一个轮回，来为每个p标签绑定一个click事宜，但是不幸的是，for轮回中运用的闭包函数没有让你如愿以偿，在闭包函数中，i被认作pAry.length，也就是轮回到最后i的终究值。为何会如许呢？ 本来，闭包援用变量，而非直接运用变量，“援用”的意义是将指针指向变量的内容。因为这个缘由，当i=0的时刻，闭包内里的i确实是0，然则当跟着i的值变大的时刻，闭包内的i并没有保留当前值，而是继承把指针指向i的内容，当你点击某个p标签的时刻，i的内容实际上是for到最后i的值。
一样，这个题目会出如今setTimeout，setInterval，$.ajax等这类操纵中，你只需记着，当你绑定操纵时，和实行操纵时，对应的变量是不是已变化就OK了。
原文链接：http://www.tangshuang.net/2368.html
