javascript面向对象技术基础(六)

作用域、闭包、模拟私有属性
先来简单说一下变量作用域，这些东西我们都很熟悉了，所以也不详细介绍。

var sco = "global";  //全局变量
function t() { 
    var sco = "local";  //函数内部的局部变量
    alert(sco);         //local 优先调用局部变量
}
t();             //local
alert(sco);       //global  不能使用函数内的局部变量

 

注意一点，在javascript中没有块级别的作用域，也就是说在java或c/c++中我们可以用"{}"来包围一个块，从而在其中定义块内的局部变量，在"{}"块外部,这些变量不再起作用,同时,也可以在for循环等控制语句中定义局部的变量,但在javascript中没有此项特性:

function f(props) {
    for(var i=0; i<10; i++) {}
    alert(i);         //10  虽然i定义在for循环的控制语句中,但在函数
                      //的其他位置仍旧可以访问该变量.
    if(props == "local") {
        var sco = "local";
	alert(sco); 
    }
    alert(sco);       //同样,函数仍可引用if语句内定义的变量
}
f("local");      //10  local   local

 

 在函数内部定义局部变量时要格外小心:

var sco = "global";
function print1() {
    alert(sco);   //global
}
function print2() {
    var sco = "local";
    alert(sco);   //local
}
function print3() {
    alert(sco);   //undefined
    var sco = "local"; 
    alert(sco);   local
}

print1();  //global
print2();  //local
print3();  //undefined  local

 前面两个函数都很容易理解，关键是第三个:第一个alert语句并没有把全局变量"global"显示出来，而是undefined，这是因为在print3函数中，我们定义了sco局部变量(不管位置在何处),那么全局的sco属性在函数内部将不起作用，所以第一个alert中sco其实是局部sco变量，相当于：

function print3() {
    var sco;
    alert(sco);
    sco = "local";
    alert(sco);
}

 从这个例子我们得出，在函数内部定义局部变量时，最好是在开头就把所需的变量定义好，以免出错。

函数的作用域在定义函数的时候已经确定了，例如：

var scope = "global"   //定义全局变量
function print() {
    alert(scope);
}
function change() {
    var scope = "local";  //定义局部变量
    print();              //虽然是在change函数的作用域内调用print函数，
                          //但是print函数执行时仍旧按照它定义时的作用域起作用
}
change();    //golbal

 

闭包
闭包是拥有变量、代码和作用域的表达式.在javascript中,函数就是变量、代码和函数的作用域的组合体,因此所有的函数都是闭包(JavaScript functions are a combination of code to be executed and the scope in which to execute them. This combination of code and scope is known as a closure in the computer science literature.All JavaScript functions are closures).好像挺简单.但是闭包到底有什么作用呢?看一个例子。
我们想写一个方法，每次都得到一个整数，这个整数是每次加1的，没有思索，马上下笔：

var i = 0;
function getNext() {
    i++;
    return i;
}
alert(getNext()); //1
alert(getNext()); //2
alert(getNext()); //3

 

一直用getNext函数得到下一个整数,而后不小心或者故意的将全局变量i的值设为0,然后再次调用getNext,你会发现又从1开始了........这时你会想到,要是把i设置成一个私有变量该多好,这样只有在方法内部才可能改变它，在函数之外就没有办法修改了.下面的代码就是按照这个要求来做得，后面我们详细讨论。
为了解释方便，我们就把下面的代码称为demo1.

function temp() {
    var i = 0;
    function b() {
        return ++i;
    }
    return b;
}
var getNext = temp();
alert(getNext());    //1
alert(getNext());    //2
alert(getNext());    //3
alert(getNext());    //4

因为我们平时所说的javascript绝大多数都是指的在客户端(浏览器)下，所以这里也不例外。在javascript解释器启动时,会首先创建一个全局的对象(global object),也就是"window"所引用的对象.然后我们定义的所有全局属性和方法等都会成为这个对象的属性.不同的函数和变量的作用域是不同的,因而构成了一个作用域链(scope chain).很显然，在javascript解释器启动时,这个作用域链只有一个对象:window(Window Object，即global object).

在demo1中,temp函数是一个全局函数，因此temp()函数的作用域(scopr)对应的作用域链就是js解释器启动时的作用域链，只有一个window对象。当temp执行时，首先创建一个call对象(活动对象)，然后把这个call对象添加到temp函数对应的作用域链的最前头,这是，temp()函数对应的作用域链就包含了两个对象：window对象和temp函数对应的call object(活动对象).然后呢，因为我们在temp函数里定义了变量i，定义了函数b(),这些都会成为call object的属性。当然，在这之前会首先给call object对象添加arguments属性，保存了temp()函数执行时传递过来的参数。此时，整个的作用域链如下图所示:

同理可以得出函数b()执行时的整个作用域链:

注意在b()的作用域链中，b()函数对应的call object只有一个arguemnts属性，并没有i属性，这是因为在b()的定义中，并没有用var关键字来
声明i属性，只有用var 关键字声明的属性才会添加到对应的call object上.在函数执行时，首先查找对应的call object有没有需要的属性，如果没有，再往上一级查找，直到找到为止，如果找不到，那就是undefined了.

这样我们再来看demo1的执行情况。我们用getNext引用了temp函数，而temp函数返回了函数b，这样getNext函数其实就是b函数的引用。执行一次getNext，就执行一次b()函数。因为函数b()的作用域依赖于函数temp，因此temp函数在内存中会一直存在。函数b执行时，首先查找i，在b对应的call object中没有，于是往上一级找，在temp函数对应的call object中找到了，于是将其值加1，然后返回这个值。这样，只要getNext函数有效，那么b()函数就一直有效，同时，b()函数依赖的temp函数也不会消失，变量i也不会消失，而且这个变量在temp函数外部根本就访问不到，只能在temp()函数内部访问(b当然可以了).

来看一个利用闭包来模拟私有属性的例子:

function Person(name, age) {  
    this.getName = function() { return name; };  
    this.setName = function(newName) { name = newName; };  
    this.getAge = function() { return age; };  
    this.setAge = function(newAge) { age = newAge; };  
}  
  
var p1 = new Person("sdcyst",3);  
alert(p1.getName());  //sdcyst  
alert(p1.name);       //undefined   因为Person('类')没有name属性  
p1.name = "mypara"    //显示的给p1添加name属性  
alert(p1.getName());  //sdcyst     但是并不会改变getName方法的返回值  
alert(p1.name);       //mypara     显示出p1对象的name属性  
p1.setName("sss");    //改变私有的"name"属性
alert(p1.getName());  //sss  
alert(p1.name);       //仍旧为mypara  

 

定义了一个Person类，有两个私有属性name，age，分别定义对应的get/set方法。
虽然可以显示的设置p1的name、age属性，但是这种显示的设置，并不会改变我们
最初设计时模拟出来的"name/age"私有属性。

解释闭包的确不是一件容易的事，在网上很多人也是利用例子来说明闭包。如果有地方说的不对，还请指正。
下面是另一篇解释javascript闭包的文章，一块儿参考吧。
http://softbbs.pconline.com.cn/9497825.html

评论

20 楼 szcjlssx 2009-10-01  

kimmking 写道

szcjlssx 写道

sdcyst 写道

olaola 写道

我想说明一下，楼主漏掉了原书中很重要的一段话

贴中所说的:
“闭包是拥有变量、代码和作用域的表达式.在javascript中,函数就是变量、代码和函数的作用域的组合体,因此所有
的函数都是闭包(JavaScript functions are a combination of code to be executed and the scope in which to
execute them. This combination of code and scope is known as a closure in the computer science literature.
All JavaScript functions are closures).”

这个只是之计算机术语上的闭包概念，而不是我们希望理解"闭包"概念。二者是有区别的，本书中作者想让我们知道的特定的”闭包“是指
漏掉的一段：
"when a nested function is exported outside the scope in which it is defined. When a nested function is used in this way, it is often explicitly called a closure."
就是当一个内部函数暴露在它本身被定义的作用域之外的时候，这个特定的情况下我们称为"闭包"。所以这里有2个不同的包概念。

第一段那种泛指的，什么所有函数都是闭包，其实实际使用上毫无意义。有用的是第2中闭包。所以大家要加以区分。

在这里我得道歉了.这句话我是故意漏掉的，因为我没有能力解释其中的原因。我解释不了原书中的意思：既然任何一个函数都是一个闭包，那为什么在js中只有当一个方法暴露在它定义域之外时才称为闭包？如果仅仅用js语言的特殊性来解释的话，我自己觉得是很没有说服力的，所以在这个地方我忽略了过去，只好用例子来说明。既然olaola提出来了了，那请哪位再继续深入的解释一下如何？

小辈来简单解释下,

function DemoOut() {
    var outVar=123;
    DemoInner();
    function DemoInner() {
        alert(outVar);//在这个函数里面,闭包产生了,简单讲就是它能访问到了它的外面的变量(相对全局变量)
        //但这样其实很好理解,当把这个函数送出去之后,就是我们所期望的"闭包"了
    }
    return DemoInner;//送出了闭包
}
var closure=DemoOut();
closure();//其实在任何地方,最终执行的DemoInner都是原处的函数
//我的理解就是,从函数声明的位置,从里向外看,能看到的变量 ,它的"最终值"都能访问到,这就是closure

完全不对头

我这样解释好理解些嘛,对啊,我只是对闭包现象的描述,人家看了肯定比讲其内部实现好些吧

19 楼 kimmking 2009-10-01  

szcjlssx 写道

sdcyst 写道

olaola 写道

我想说明一下，楼主漏掉了原书中很重要的一段话

贴中所说的:
“闭包是拥有变量、代码和作用域的表达式.在javascript中,函数就是变量、代码和函数的作用域的组合体,因此所有
的函数都是闭包(JavaScript functions are a combination of code to be executed and the scope in which to
execute them. This combination of code and scope is known as a closure in the computer science literature.
All JavaScript functions are closures).”

这个只是之计算机术语上的闭包概念，而不是我们希望理解"闭包"概念。二者是有区别的，本书中作者想让我们知道的特定的”闭包“是指
漏掉的一段：
"when a nested function is exported outside the scope in which it is defined. When a nested function is used in this way, it is often explicitly called a closure."
就是当一个内部函数暴露在它本身被定义的作用域之外的时候，这个特定的情况下我们称为"闭包"。所以这里有2个不同的包概念。

第一段那种泛指的，什么所有函数都是闭包，其实实际使用上毫无意义。有用的是第2中闭包。所以大家要加以区分。

在这里我得道歉了.这句话我是故意漏掉的，因为我没有能力解释其中的原因。我解释不了原书中的意思：既然任何一个函数都是一个闭包，那为什么在js中只有当一个方法暴露在它定义域之外时才称为闭包？如果仅仅用js语言的特殊性来解释的话，我自己觉得是很没有说服力的，所以在这个地方我忽略了过去，只好用例子来说明。既然olaola提出来了了，那请哪位再继续深入的解释一下如何？

小辈来简单解释下,

function DemoOut() {
    var outVar=123;
    DemoInner();
    function DemoInner() {
        alert(outVar);//在这个函数里面,闭包产生了,简单讲就是它能访问到了它的外面的变量(相对全局变量)
        //但这样其实很好理解,当把这个函数送出去之后,就是我们所期望的"闭包"了
    }
    return DemoInner;//送出了闭包
}
var closure=DemoOut();
closure();//其实在任何地方,最终执行的DemoInner都是原处的函数
//我的理解就是,从函数声明的位置,从里向外看,能看到的变量 ,它的"最终值"都能访问到,这就是closure

完全不对头

18 楼 szcjlssx 2009-10-01  

sdcyst 写道

olaola 写道

我想说明一下，楼主漏掉了原书中很重要的一段话

贴中所说的:
“闭包是拥有变量、代码和作用域的表达式.在javascript中,函数就是变量、代码和函数的作用域的组合体,因此所有
的函数都是闭包(JavaScript functions are a combination of code to be executed and the scope in which to
execute them. This combination of code and scope is known as a closure in the computer science literature.
All JavaScript functions are closures).”

这个只是之计算机术语上的闭包概念，而不是我们希望理解"闭包"概念。二者是有区别的，本书中作者想让我们知道的特定的”闭包“是指
漏掉的一段：
"when a nested function is exported outside the scope in which it is defined. When a nested function is used in this way, it is often explicitly called a closure."
就是当一个内部函数暴露在它本身被定义的作用域之外的时候，这个特定的情况下我们称为"闭包"。所以这里有2个不同的包概念。

第一段那种泛指的，什么所有函数都是闭包，其实实际使用上毫无意义。有用的是第2中闭包。所以大家要加以区分。

在这里我得道歉了.这句话我是故意漏掉的，因为我没有能力解释其中的原因。我解释不了原书中的意思：既然任何一个函数都是一个闭包，那为什么在js中只有当一个方法暴露在它定义域之外时才称为闭包？如果仅仅用js语言的特殊性来解释的话，我自己觉得是很没有说服力的，所以在这个地方我忽略了过去，只好用例子来说明。既然olaola提出来了了，那请哪位再继续深入的解释一下如何？

小辈来简单解释下,

function DemoOut() {
    var outVar=123;
    DemoInner();
    function DemoInner() {
        alert(outVar);//在这个函数里面,闭包产生了,简单讲就是它能访问到了它的外面的变量(相对全局变量)
        //但这样其实很好理解,当把这个函数送出去之后,就是我们所期望的"闭包"了
    }
    return DemoInner;//送出了闭包
}
var closure=DemoOut();
closure();//其实在任何地方,最终执行的DemoInner都是原处的函数
//我的理解就是,从函数声明的位置,从里向外看,能看到的变量 ,它的"最终值"都能访问到,这就是closure

17 楼 szcjlssx 2009-10-01  

我对于闭包的理解很简单,就是在"相对更小"的作用域中能访问其"外面"的变量的"最终值",这里的重要的概念就是变量作用域始终是相对的,遵循"在函数声明的位置从里往外看"的原则,变量的"最终"值就可以访问到,嗯,最后不忘再打个广告,AjaxLife 565247577 欢迎大家到群里讨论

16 楼 royoan 2009-09-28  

一口气看完楼主该系列的文章，收获颇丰！
但是那个闭包的概念确实很难理解！

15 楼 77tt77 2009-08-19  

  楼主写的不错啊，辛苦了，整个系列终于看完了。
对JS面向对象的部分，作用域，原型，闭包有了初步的了解。

14 楼 天空不空 2009-01-17  

hite 写道

zhaoweisgz 写道

http://softbbs.pconline.com.cn/9497825.html这文章还是不错的

里面给出的来源网址：
http://www.knowsky.com/442121.html

广告多的？就像个广告牌。

  广告确实多。。。

13 楼 千秋霸业 2009-01-12  

看过大家的留言有了新的深刻的理解，我收藏了。谢谢

12 楼 RednaxelaFX 2009-01-06  

sdcyst 写道

在这里我得道歉了.这句话我是故意漏掉的，因为我没有能力解释其中的原因。我解释不了原书中的意思：既然任何一个函数都是一个闭包，那为什么在js中只有当一个方法暴露在它定义域之外时才称为闭包？如果仅仅用js语言的特殊性来解释的话，我自己觉得是很没有说服力的，所以在这个地方我忽略了过去，只好用例子来说明。既然olaola提出来了了，那请哪位再继续深入的解释一下如何？

其实简单说来还是核心概念的问题。闭包的概念与“约束”密不可分。
（本来要是用lambda演算很容易解释……但解释lambda演算说不定更麻烦了，算，还是不要太正式了。）

数学上，函数的本质是值到值的映射：（f: A -> B）
1、从一个定义域的集合A中取出任一元素x，在值域B中都必须有一个对应的值y；
2、如果f(x) = y且f(x) = z，则y = z。

假设有一个函数，succ(x) = x + 1。
这种纯粹的函数，在用一个具体的值（例如2）作为实际参数来调用的时候，其形式参数（这里只有一个，就是x）就与值相绑定了，或者在正式文献中一般翻译为“约束”（bind）。把函数调用时就与值绑定的变量成为“约束变量”（bound variable）。值只受约束变量而变化的函数可以叫做纯函数。变量获得绑定的地方成为它所在的“环境”（environment）。succ函数的局部环境里，只有一个变量x与它的值的绑定。

那么如果函数里包含有在调用时不一定已经与值绑定在一起的变量会怎样呢？
假设有这样一个“函数”（不是纯数学意义上的函数了），addY(x) = x + y。
它的结果不但受到约束变量x的影响，也受到一个需要从别的地方获得值的变量y的影响。addY函数要能正确执行，必须先让y从addY函数以外的别的环境与一个值相绑定才行；这也意味着addY对相同的输入x不一定会产生一样的结果，而受外部环境中的y的值影响。这个时候，y被称为“自由变量”（free variable）。

那么谁来提供这个环境呢？可以由全局环境来提供，也可以由别的函数的局部环境来提供。
假如我们预先定义了y就等于2，那么addY(x) = x + y也就能够从全局定义的y = 2中获得绑定，addY函数就能够完成执行了。全局环境被认为是一种特殊的环境，所以单独分开来讨论。
假如是从别的局部环境来获取自由变量的绑定又如何呢？看看这样的一个函数：add(y) = addY(x) = x + y。
这要怎么看呢？用JavaScript的语法来写的话这里的大家应该都能看懂了：

function add(y) {
    function addY(x) {
        return x + y
    }
    return addY
}

var addToThree = add(3)   //=> function(x) { return x + 3 }
var seven = addToThree(4) //=> 7

add函数的局部环境中含有对变量y的绑定，addY函数的局部环境中含有对变量x的绑定；addY函数嵌套于add函数内，并依赖于x与y的值，所以在依赖自身的环境的同时，还依赖于其外围的add函数的环境。这样，外围的add函数的环境就“包围”（close over）住了内部的addY函数；外围add函数的环境也就形成了内部函数addY的“闭包”（closure）。

函数的调用-返回一般符合先进后出（LIFO，last in first out）的顺序，而其依赖的局部环境通常可以在调用时创建而在返回时撤销，所以也符合LIFO顺序。例如说如果函数f中调用了函数g，那么f被调用时其局部环境会被创建，控制流进入f；然后调用了g，则g的局部环境也会被创建，控制流进入g；在g完成计算后，g的环境被撤销，控制流返回到f；接下来f也完成了计算，其局部环境也被撤销，控制流返回到调用f的地方。这样的性质与“栈”（stack）所支持的操作正好吻合。在编程语言与计算机硬件的发展中相互影响，使得许多硬件对运行时调用栈（runtime call stack）有直接的支持，而一般的编程语言也会充分利用这点，使用运行时调用栈来存放函数的局部环境。

但如果环境创建-撤销的顺序需函数调用的顺序不吻合，也就是说不再满足LIFO顺序了，那么这些不满足LIFO顺序的局部环境就无法在运行时调用栈上存放。这时就要另外找地方放了，现代带有GC的语言一般是将闭包环境存放在堆（heap）上，等到使用这个闭包的函数已经没有再被引用的时候再释放掉它。JavaScript也是这样的。

很多时候会看到英语文章里说某个函数“是一个”（is a）闭包，实际上要说的就是这个函数不但拥有计算的逻辑（代码/code）和自身的局部环境，同时还可以访问到其外部的别的局部环境，而这个外部环境对这个函数形成了闭包。
显然，不含有自由变量的函数是不依赖于其局部环境以外的环境的，也就不需要闭包。全局环境虽然包围着所有函数，但它比较特殊，通常就不把只依赖于它和自身的局部环境的函数称为闭包。
如果函数内部嵌套定义了函数，但内部函数没有返回到外围函数的外面，则这里的内部函数的局部环境仍然满足LIFO的创建-撤销顺序。看一例子：

function ternaryAdd(x, y, z) {
    function addToXY(n) {
        return x + y + n
    }
    return addToXY(z)
}

ternaryAdd(4, 5, 6)

内部的addToXY使用了两个自由变量，其值都是在外围的ternaryAdd获得绑定的，因而ternaryAdd的环境对addToXY形成了闭包。但观察局部环境的创建顺序：
1、调用ternaryAdd，其局部环境被创建，x、y、z的值被绑定到4、5、6；
2、ternaryAdd的内部调用了addToXY，其局部环境被创建，n的值被绑定到外围的z的值，6；
3、addToXY使用自身局部环境中的n与外围环境中的x、y计算出结果并返回，其局部环境可以被撤销；
4、ternaryAdd通过将addToXY的返回值与自身局部环境中的z相加计算出返回值，结束计算并返回；
5、由于ternaryAdd返回前addToXY已经完成调用并返回了，此时已经没有别的函数引用着ternaryAdd的局部环境，所以ternaryAdd返回的时候其局部环境也可以被撤销。
可以观察到，这个例子里局部环境的创建-撤销顺序满足LIFO顺序，所以局部环境仍然可以存放在运行时调用栈上，只不过内部函数的局部环境里需要增加一个到外围函数的局部环境的引用而已。因为这样，很多时候大家也不把虽然嵌套定义但没有被返回到外围函数以外的函数称为闭包。叫不叫闭包是一回事，概念上外围函数还是对内部函数形成了闭包的。

至于嵌套定义而又被返回到外围函数之外、并且使用了自由变量的内部函数的状况，前面的帖子有足够例子了这里就不说了。观察一下就能发现其中的局部环境的创建-撤销顺序不满足LIFO，所以不能把外围函数的局部环境存放在运行时调用栈上。

以前在某个回复里我也写过写闭包相关的简单解释：关于对象与闭包的关系的一个有趣小故事。另外，更早之前也尝试过写篇稍微详细一些的解释，在这里，不过写到一半觉得值得说明的东西太多，结果没写完。凑合看看吧 =v=
说来以前还记过关于C#和Ruby的闭包相关内容，D语言从2.007开始也支持完整的闭包了……

11 楼 xingqiliudehuanghun 2009-01-05  

    前段时间看了下周爱民的书，里面对必包研究的很深入。自己比较愚钝不能完全理解，在此谈一下自己对必包的理解，有不对之处大家指正以。
    必包是多数动态语言里边都存在的一种数据结构。必包有几个特点：
    1.在函数执行时被初始化
    2.再函数推出时保存原有状态
    3.在没有被其他必包引用时被回收
    。。。。。
    还有一些记不得了可以参考下爱民的书

必包有利于动态语言的实现。为什么这么说呢？写过汇编的都知道，我们在写汇编程序的时候我们的程序大部分情况下会包含两个段：数据段和代码段。数据段用来声明变量存储地址，代码端用来描述逻辑。C++、Java这些高级语言需要经过编译装换成类似汇编的低级语言，这些高级语言的函数声明部分会被映射成数据段的声明（个人猜测没有具体研究）。可是我们的动态语言不需要经过编译呀，怎么解决这个问题呢？答案是用必包来模拟。动态语言的执行一般要分为两个步骤：
    1）预编译阶段，在这个阶段解释机会首先初始化一个空必包用来存储函数声明的变量，然后扫描函数脚本，每遇到一个声明语句var xxx;就向必包中写入一条类似name=null这样的数据结构。
    2）经过1）段段以后被执行的函数有了一个自己的必包，而且函数文本被转化成了解释机内部可识别的命令符号。这就好比我们双击一个exe文件，系统把他从硬盘装入内存并且为他分配了进程可访问的内存资源，那么执行也就是顺理成章的事情了。改变变量仅仅改变必包中的值就可以了。

    所以说每一个被执行的函数必定被分配了一个必包，但这个必包只有被其他变量引用的时候才有意义。因为必包所占用的内存是由解释机来分配的，解释机有为了管理内存对每一块分配的内存做引用计数，一旦计数为0，就会被系统回首。我们平常执行函数的时候，函数没有被引用，所以一旦函数执行完毕，就会被当成垃圾回收了；只有把函数必包赋值给变量，也就是对函数必包做一次引用，必包才能保留下来，才能被继续
使用。
    上面就是我对必包的理解，可能有些地方有出入，因为我没有读过JS解释机的实现代码，只是我的一点猜测。请大家拍砖

10 楼 olaola 2009-01-05  

可能你觉得无法解释是因为你没有去区分2段话中的闭包其实是不同的东西，大家想深入研究的是第2中，也就是作者说的“explicitly called a closure”,而第一段的闭包是广义的，不具有实用性。如果你把二个closure都认为是一个意思，显然无法解释了。

举个例子，我们可以叫一个满18岁的男性为男人，但是很多时候我们会认为，满了18岁并且有过性经验的才算真正的男人。显然后面一个男人特指了某一类，并且更具有实际用途。
这个比喻有点低级，不过我一时也想不出其他的。

建议大家可以看看这个文章，他用非常简明的描述解释了什么是闭包，还有简单的可执行的列子展示了闭包的作用，个人感觉比犀牛书写得要浅显易懂。

http://blog.morrisjohns.com/javascript_closures_for_dummies.html

9 楼 sdcyst 2009-01-05  

olaola 写道

我想说明一下，楼主漏掉了原书中很重要的一段话

贴中所说的:
“闭包是拥有变量、代码和作用域的表达式.在javascript中,函数就是变量、代码和函数的作用域的组合体,因此所有
的函数都是闭包(JavaScript functions are a combination of code to be executed and the scope in which to
execute them. This combination of code and scope is known as a closure in the computer science literature.
All JavaScript functions are closures).”

这个只是之计算机术语上的闭包概念，而不是我们希望理解"闭包"概念。二者是有区别的，本书中作者想让我们知道的特定的”闭包“是指
漏掉的一段：
"when a nested function is exported outside the scope in which it is defined. When a nested function is used in this way, it is often explicitly called a closure."
就是当一个内部函数暴露在它本身被定义的作用域之外的时候，这个特定的情况下我们称为"闭包"。所以这里有2个不同的包概念。

第一段那种泛指的，什么所有函数都是闭包，其实实际使用上毫无意义。有用的是第2中闭包。所以大家要加以区分。

在这里我得道歉了.这句话我是故意漏掉的，因为我没有能力解释其中的原因。我解释不了原书中的意思：既然任何一个函数都是一个闭包，那为什么在js中只有当一个方法暴露在它定义域之外时才称为闭包？如果仅仅用js语言的特殊性来解释的话，我自己觉得是很没有说服力的，所以在这个地方我忽略了过去，只好用例子来说明。既然olaola提出来了了，那请哪位再继续深入的解释一下如何？

8 楼 olaola 2009-01-04  

我想说明一下，楼主漏掉了原书中很重要的一段话

贴中所说的:
“闭包是拥有变量、代码和作用域的表达式.在javascript中,函数就是变量、代码和函数的作用域的组合体,因此所有
的函数都是闭包(JavaScript functions are a combination of code to be executed and the scope in which to
execute them. This combination of code and scope is known as a closure in the computer science literature.
All JavaScript functions are closures).”

这个只是之计算机术语上的闭包概念，而不是我们希望理解"闭包"概念。二者是有区别的，本书中作者想让我们知道的特定的”闭包“是指
漏掉的一段：
"when a nested function is exported outside the scope in which it is defined. When a nested function is used in this way, it is often explicitly called a closure."
就是当一个内部函数暴露在它本身被定义的作用域之外的时候，这个特定的情况下我们称为"闭包"。所以这里有2个不同的包概念。

第一段那种泛指的，什么所有函数都是闭包，其实实际使用上毫无意义。有用的是第2中闭包。所以大家要加以区分。

7 楼 qinglangee 2008-12-31  

http://www.felixwoo.com/blog/article.asp?id=294
这个地址更原始一些，带的图也在

6 楼 sdcyst 2008-12-26  

hite 写道

zhaoweisgz 写道http://softbbs.pconline.com.cn/9497825.html这文章还是不错的
里面给出的来源网址：
http://www.knowsky.com/442121.html

广告多的？就像个广告牌。

帅哥你观察挺仔细俄......当时就是因为这个所以我才没把原始地址给弄出来

5 楼 hite 2008-12-26  

zhaoweisgz 写道

http://softbbs.pconline.com.cn/9497825.html这文章还是不错的

里面给出的来源网址：
http://www.knowsky.com/442121.html

广告多的？就像个广告牌。

4 楼 zhaoweisgz 2008-12-25  

http://softbbs.pconline.com.cn/9497825.html这文章还是不错的

3 楼 achun 2008-12-22  

我的认识,
闭包就是用来控制消除局部对象名和全局对象名间的同名访问冲突或访问限制(私有访问)的.
如果在一段代码中,用到的对象担心和全局的对象名冲突,那可以用闭包,
如果在一段代码中,希望某个对象只被特定的代码访问(比如局部函数),那可以用闭包,
不过闭包肯定不只是这两点,
比如动态建立返回的函数其实也闭包,而且每次返回的都是不同的对象.

2 楼 56071925 2008-12-19  

理解了闭包真开心啊，谢谢楼主。严重同意楼上的话，“解释闭包不是一件容易的事“，↖(^ω^)↗加油

1 楼 srdrm 2008-12-19  

感谢楼主，你的系列文章我都好好看过。非常棒。


这篇讲闭包我彻底也明白了。我想对你最后一段说的， “解释闭包不是一件容易的事”，这话说的的确是。

看完后，我个人感觉，像是模式设计里面的，工厂方法。用于创建接口实例的函数。外部只能访问提供的接口。具体实现里用到的东西是不可见的。