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

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

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

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

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

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

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

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

其实简单说来还是核心概念的问题。闭包的概念与“约束”密不可分。
（本来要是用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开始也支持完整的闭包了……

  广告确实多。。。

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

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

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

小辈来简单解释下,

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

完全不对头

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