一分钟理解js闭包_javascript技巧
作者：用户
本文讲的是一分钟理解js闭包_javascript技巧，
什么是闭包？先看一段代码：
function a(){
var n = 0;
function inc() {
console.log(n);
什么是闭包？先看一段代码：
function a(){
var n = 0;
function inc() {
console.log(n);
a(); //控制台输出1，再输出2
简单吧。再来看一段代码：
function a(){
var n = 0;
this.inc = function () {
console.log(n);
var c = new a();
//控制台输出1
//控制台输出2
什么是闭包？这就是闭包！
有权访问另一个函数作用域内变量的函数都是闭包。这里 inc 函数访问了构造函数 a 里面的变量 n，所以形成了一个闭包。
再来看一段代码：
function a(){
var n = 0;
function inc(){
console.log(n);
var c = a();
//控制台输出1
//控制台输出2
看看是怎么执行的：
var c = couter()，这一句 couter()返回的是函数 inc，那这句等同于 var c =
c()，这一句等同于 inc();
注意，函数名只是一个标识（指向函数的指针），而()才是执行函数。
后面三句翻译过来就是：
inc();，跟第一段代码有区别吗？ 没有。
什么是闭包？这就是闭包！
所有的教科书上都喜欢用最后一段来说明闭包，但我觉得这将问题复杂化了。这里面返回的是函数名，没看过谭浩强C/C++程序设计的同学可能一下子没反应出带不带()的区别，也就是说这种写法自带一个陷阱。虽然这种写法更显高大上，但我还是喜欢将问题单一化，看看代码 1 和代码 2，你还会纠结函数的调用，你会纠结 n 的值吗？
为啥要这样写？
我们知道，js的每个函数都是一个个小黑屋，它可以获取外界信息，但是外界却无法直接看到里面的内容。将变量 n 放进小黑屋里，除了 inc 函数之外，没有其他办法能接触到变量 n，而且在函数 a 外定义同名的变量 n 也是互不影响的，这就是所谓的增强“封装性”。
而之所以要用 return 返回函数标识 inc，是因为在 a 函数外部无法直接调用 inc 函数，所以 return inc 与外部联系起来，代码 2 中的 this 也是将 inc 与外部联系起来而已。
常见的陷阱看看这个：
function createFunctions(){
var result = new Array();
for (var i=0; i & 10; i++){
result[i] = function(){
var funcs = createFunctions();
for (var i=0; i & funcs. i++){
console.log(funcs[i]());
乍一看，以为输出 0~9 ，万万没想到输出10个10？
这里的陷阱就是：函数带()才是执行函数！ 单纯的一句 var f = function() { alert('Hi'); }; 是不会弹窗的，后面接一句 f(); 才会执行函数内部的代码。上面代码翻译一下就是：
var result = new Array(),
result[0] = function(){ }; //没执行函数，函数内部不变，不能将函数内的i替换！
result[1] = function(){ }; //没执行函数，函数内部不变，不能将函数内的i替换！
result[9] = function(){ }; //没执行函数，函数内部不变，不能将函数内的i替换！
console.log(i); // funcs[0]()就是执行 return i 语句，就是返回10
console.log(i); // funcs[1]()就是执行 return i 语句，就是返回10
console.log(i); // funcs[9]()就是执行 return i 语句，就是返回10
为什么只垃圾回收了 result，但却不收了 i 呢？ 因为 i 还在被 function 引用着啊。好比一个餐厅，盘子总是有限的，所以服务员会去巡台回收空盘子，但还装着菜的盘子他怎么敢收？ 当然，你自己手动倒掉了盘子里面的菜（=null），那盘子就会被收走了，这就是所谓的内存回收机制。
至于 i 的值怎么还能保留，其实从开头一路读下来，这应该没有什么可以纠结的地方。盘子里面的菜，吃了一块不就应该少一块吗？
闭包就是一个函数引用另外一个函数的变量，因为变量被引用着所以不会被回收，因此可以用来封装一个私有变量。这是优点也是缺点，不必要的闭包只会徒增内存消耗！另外使用闭包也要注意变量的值是否符合你的要求，因为他就像一个静态私有变量一样。闭包通常会跟很多东西混搭起来，接触多了才能加深理解，这里只是开个头说说基础性的东西。
本文链接：http://www.cnblogs.com/qieguo/p/5457040.
以上就是本文的全部内容，希望对大家的学习有所帮助。
以上是云栖社区小编为您精心准备的的内容，在云栖社区的博客、问答、公众号、人物、课程等栏目也有的相关内容，欢迎继续使用右上角搜索按钮进行搜索js
javascript 闭包理解、javascript 闭包、javascript闭包详解、javascript闭包面试题、javascript闭包的作用，以便于您获取更多的相关知识。
弹性可伸缩的计算服务，助您降低 IT 成本，提升运维效率
40+云计算产品，6个月免费体验
稳定可靠、可弹性伸缩的在线数据库服务，全球最受欢迎的开源数据库之一
云服务器9.9元/月，大学必备
云栖社区(yq.aliyun.com)为您免费提供相关信息，包括
，所有相关内容均不代表云栖社区的意见！&>&js闭包理解之倒计时
js闭包理解之倒计时
上传大小：587B
网上大多只是讲解js闭包的大概意思和小例子，但真实用于项目中又该怎么用呢。这个例子真实的告诉大家在项目中的用法
综合评分：5
下载个数：
{%username%}回复{%com_username%}{%time%}\
/*点击出现回复框*/
$(".respond_btn").on("click", function (e) {
$(this).parents(".rightLi").children(".respond_box").show();
e.stopPropagation();
$(".cancel_res").on("click", function (e) {
$(this).parents(".res_b").siblings(".res_area").val("");
$(this).parents(".respond_box").hide();
e.stopPropagation();
/*删除评论*/
$(".del_comment_c").on("click", function (e) {
var id = $(e.target).attr("id");
$.getJSON('/index.php/comment/do_invalid/' + id,
function (data) {
if (data.succ == 1) {
$(e.target).parents(".conLi").remove();
alert(data.msg);
$(".res_btn").click(function (e) {
var parentWrap = $(this).parents(".respond_box"),
q = parentWrap.find(".form1").serializeArray(),
resStr = $.trim(parentWrap.find(".res_area_r").val());
console.log(q);
//var res_area_r = $.trim($(".res_area_r").val());
if (resStr == '') {
$(".res_text").css({color: "red"});
$.post("/index.php/comment/do_comment_reply/", q,
function (data) {
if (data.succ == 1) {
var $target,
evt = e || window.
$target = $(evt.target || evt.srcElement);
var $dd = $target.parents('dd');
var $wrapReply = $dd.find('.respond_box');
console.log($wrapReply);
//var mess = $(".res_area_r").val();
var mess = resS
var str = str.replace(/{%header%}/g, data.header)
.replace(/{%href%}/g, 'http://' + window.location.host + '/user/' + data.username)
.replace(/{%username%}/g, data.username)
.replace(/{%com_username%}/g, data.com_username)
.replace(/{%time%}/g, data.time)
.replace(/{%id%}/g, data.id)
.replace(/{%mess%}/g, mess);
$dd.after(str);
$(".respond_box").hide();
$(".res_area_r").val("");
$(".res_area").val("");
$wrapReply.hide();
alert(data.msg);
}, "json");
/*删除回复*/
$(".rightLi").on("click", '.del_comment_r', function (e) {
var id = $(e.target).attr("id");
$.getJSON('/index.php/comment/do_comment_del/' + id,
function (data) {
if (data.succ == 1) {
$(e.target).parent().parent().parent().parent().parent().remove();
$(e.target).parents('.res_list').remove()
alert(data.msg);
//填充回复
function KeyP(v) {
var parentWrap = $(v).parents(".respond_box");
parentWrap.find(".res_area_r").val($.trim(parentWrap.find(".res_area").val()));
评论共有3条
很好，受到了启发
没有很懂,留着以后再看
不错。有用到。可以参考
VIP会员动态
CSDN下载频道资源及相关规则调整公告V11.10
下载频道用户反馈专区
下载频道积分规则调整V1710.18
spring mvc+mybatis+mysql+maven+bootstrap 整合实现增删查改简单实例.zip
资源所需积分/C币
当前拥有积分
当前拥有C币
输入下载码
为了良好体验，不建议使用迅雷下载
js闭包理解之倒计时
会员到期时间：
剩余下载个数：
剩余积分：0
为了良好体验，不建议使用迅雷下载
积分不足！
资源所需积分/C币
当前拥有积分
您可以选择
程序员的必选
绿色安全资源
资源所需积分/C币
当前拥有积分
当前拥有C币
为了良好体验，不建议使用迅雷下载
资源所需积分/C币
当前拥有积分
当前拥有C币
为了良好体验，不建议使用迅雷下载
资源所需积分/C币
当前拥有积分
当前拥有C币
您的积分不足，将扣除 10 C币
为了良好体验，不建议使用迅雷下载
无法举报自己的资源
你当前的下载分为234。
你还不是VIP会员
开通VIP会员权限，免积分下载
你下载资源过于频繁，请输入验证码
您因违反CSDN下载频道规则而被锁定帐户，如有疑问，请联络:!
若举报审核通过，可返还被扣除的积分
被举报人：
xingyu_qie
举报的资源分：
请选择类型
资源无法下载 （ 404页面、下载失败、资源本身问题）
资源无法使用 （文件损坏、内容缺失、题文不符）
侵犯版权资源 （侵犯公司或个人版权）
虚假资源 （恶意欺诈、刷分资源）
含色情、危害国家安全内容
含广告、木马病毒资源
*详细原因：
js闭包理解之倒计时Access denied | www.ruanyifeng.com used Cloudflare to restrict access
Please enable cookies.
What happened?
The owner of this website (www.ruanyifeng.com) has banned your access based on your browser's signature (420ed-ua98).js闭包真是十分十分重要的，再怎么强调也不过分，因为他是js能力提升中无法绕过的一 环,几乎每次面试必问的问题,因为在回答的时候.你的答案的深度,对术语的理解以及js内部解释器的运作方式的描述,都是可以看出你js实际水平的.即使 你没答对,也能让考官对你的水平有个评估。所以一定要掌握吃透，理解！！
要理解闭包，首先你要理解js几个很基本的特性：执行环境、作用域链、垃圾回收机制、函数嵌套。
每调用一个函数时（执行函数时），系统会为该函数创建一个封闭的局部的运行环境，即该函数的执行环境。函数总是在自己的执行环境中执行，如读写局部变量、
函数参数、运行内部逻辑。创建执行环境的过程包含了创建函数的作用域，函数也是在自己的作用域下执行的。从另一个角度说，每个函数执行环境都有一个作用域
链，子函数的作用域链包括它的父函数的作用域链。
简单来说,作用域链就是函数在定义的时候创建的,用于寻找使用到的变量的值的一个索引,而他内部的规则是,把函数自身的本地变量放在最前面,把自身的父级
函数中的变量放在其次,把再高一级函数中的变量放在更后面,以此类推直至全局对象为止.当函数中需要查询一个变量的值的时候,js解释器会去作用域链去查
找,从最前面的本地变量中先找,如果没有找到对应的变量,则到下一级的链上找,一旦找到了变量,则不再继续.如果找到最后也没找到需要的变量,则解释器返
回undefined。
垃圾回收机制
一般来说,一个函数在执行开始的时候,会给其中定义的变量划分内存空间保存,以备后面的语句所用,等到函数执行完毕返回了,这些变量就被认为是无用的了.
对应的内存空间也就被回收了.下次再执行此函数的时候,所有的变量又回到最初的状态,重新赋值使用.但是如果这个函数内部又嵌套了另一个函数,而这个函数
是有可能在外部被调用到的.并且这个内部函数又使用了外部函数的某些变量的话.这种内存回收机制就会出现问题.如果在外部函数返回后,又直接调用了内部函
数,那么内部函数就无法读取到他所需要的外部函数中变量的值了.所以js解释器在遇到函数定义的时候,会自动把函数和他可能使用的变量(包括本地变量和父
级和祖先级函数的变量(自由变量))一起保存起来.也就是构建一个闭包,这些变量将不会被内存回收器所回收,只有当内部的函数不可能被调用以后(例如被删
除了,或者没有了指针),才会销毁这个闭包,而没有任何一个闭包引用的变量才会被下一次内存回收启动时所回收.
各种专业文献上的&闭包&定义非常抽象，很难看懂。我的理解是，闭包就是能够读取其他函数内部变量的函数（欢迎指正）。
由于在js语言中，只有函数内部的子函数才能读取局部变量，因此可以把闭包简单理解成&定义在一个函数内部的函数&。
所以，在本质上，闭包就是将函数内部和函数外部连接起来的一座桥梁。
闭包可以用在许多地方。它的最大用处有两个，一个是可以读取函数内部的变量，另一个就是让这些变量的值始终保持在内存中。
举个栗子：
　function f1(){
　　　　var n=999;
　　　　nAdd=function(){n+=1}
　　　　function f2(){
　　　　　　alert(n);
　　　　return f2;
　　var result=f1();
　　result();
在这段代码中，result实际上就是闭包f2函数。它一共运行了两次，第一次的值是999，第二次的值是1000。这证明了，函数f1中的局部变量n一直保存在内存中，并没有在f1调用后被自动清除。
为什么会这样呢？原因就在于f1是f2的父函数，而f2被赋给了一个全局变量，这导致f2始终在内存中，而f2的存在依赖于f1，因此f1也始终在内存中，不会在调用结束后，被垃圾回收机制回收。
然而，由于闭包会使得函数中的变量都被保存在内存中，内存消耗很大，所以不能滥用闭包，否则会造成网页的性能问题，在IE中可能导致内存泄露。解决方法是，在退出函数之前，将不使用的局部变量全部删除。
闭包会在父函数外部，改变父函数内部变量的值。所以，如果你把父函数当作对象（object）使用，把闭包当作它的公用方法（Public Method），把内部变量当作它的私有属性（private value），这时一定要小心，不要随便改变父函数内部变量的值。
如果看到这里还是不是很懂的话，转载了一篇很好的文章，&&这里写链接内容
一、什么是闭包？
官方&的解释是：闭包是一个拥有许多变量和绑定了这些变量的环境的表达式（通常是一个函数），因而这些变量也是该表达式的一部分。
相信很少有人能直接看懂这句话，因为他描述的太学术。其实这句话通俗的来说就是：JavaScript中所有的function都是一个闭包。不过一般来说，嵌套的function所产生的闭包更为强大，也是大部分时候我们所谓的&闭包&。看下面这段代码：
function a() {
var i = 0;
function b() { alert(++i); }
var c = a();
这段代码有两个特点：
1、函数b嵌套在函数a内部；
2、函数a返回函数b。
引用关系如图：
　　这样在执行完var c=a()后，变量c实际上是指向了函数b，再执行c()后就会弹出一个窗口显示i的值(第一次为1)。这段代码其实就创建了一个闭包，为什么？因为函数a外的变量c引用了函数a内的函数b，就是说：
　　当函数a的内部函数b被函数a外的一个变量引用的时候，就创建了一个闭包。
　　让我们说的更透彻一些。所谓&闭包&，就是在构造函数体内定义另外的函数作为目标对象的方法函数，而这个对象的方法函数反过来引用外层函数体中的临时
变量。这使得只要目标
对象在生存期内始终能保持其方法，就能间接保持原构造函数体当时用到的临时变量值。尽管最开始的构造函数调用已经结束，临时变量的名称也都消失了，但在目
标对象的方法内却始终能引用到该变量的值，而且该值只能通这种方法来访问。即使再次调用相同的构造函数，但只会生成新对象和方法，新的临时变量只是对应新
的值，和上次那次调用的是各自独立的。
二、闭包有什么作用？
　　简而言之，闭包的作用就是在a执行完并返回后，闭包使得Javascript的垃圾回收机制GC不会收回a所占用的资源，因为a的内部函数b的执行需
要依赖a中的变量。这是对闭包作用的非常直白的描述，不专业也不严谨，但大概意思就是这样，理解闭包需要循序渐进的过程。
在上面的例子中，由于闭包的存在使得函数a返回后，a中的i始终存在，这样每次执行c()，i都是自加1后alert出i的值。
三、闭包内的微观世界
　　如果要更加深入的了解闭包以及函数a和嵌套函数b的关系，我们需要引入另外几个概念：函数的执行环境(excution
context)、活动对象(call object)、作用域(scope)、作用域链(scope
chain)。以函数a从定义到执行的过程为例阐述这几个概念。
当定义函数a的时候，js解释器会将函数a的作用域链(scope chain)设置为定义a时a所在的&环境&，如果a是一个全局函数，则scope chain中只有window对象。
当执行函数a的时候，a会进入相应的执行环境(excution context)。
在创建执行环境的过程中，首先会为a添加一个scope属性，即a的作用域，其值就为第1步中的scope chain。即a.scope=a的作用域链。
然后执行环境会创建一个活动对象(call
object)。活动对象也是一个拥有属性的对象，但它不具有原型而且不能通过JavaScript代码直接访问。创建完活动对象后，把活动对象添加到a
的作用域链的最顶端。此时a的作用域链包含了两个对象：a的活动对象和window对象。
下一步是在活动对象上添加一个arguments属性，它保存着调用函数a时所传递的参数。
最后把所有函数a的形参和内部的函数b的引用也添加到a的活动对象上。在这一步中，完成了函数b的的定义，因此如同第3步，函数b的作用域链被设置为b所被定义的环境，即a的作用域。
到此，整个函数a从定义到执行的步骤就完成了。此时a返回函数b的引用给c，又函数b的作用域链包含了对函数a的活动对象的引用，也就是说b可以访问到a中定义的所有变量和函数。函数b被c引用，函数b又依赖函数a，因此函数a在返回后不会被GC回收。
当函数b执行的时候亦会像以上步骤一样。因此，执行时b的作用域链包含了3个对象：b的活动对象、a的活动对象和window对象，如下图所示：
如图所示，当在函数b中访问一个变量的时候，搜索顺序是：
先搜索自身的活动对象，如果存在则返回，如果不存在将继续搜索函数a的活动对象，依次查找，直到找到为止。
如果函数b存在prototype原型对象，则在查找完自身的活动对象后先查找自身的原型对象，再继续查找。这就是Javascript中的变量查找机制。
如果整个作用域链上都无法找到，则返回undefined。
小结，本段中提到了两个重要的词语：函数的定义与执行。文中提到函数的作用域是在定义函数时候就已经确定，而不是在执行的时候确定（参看步骤1和3）。用一段代码来说明这个问题：
function f(x) {
var g = function () {
var h = f(1);
alert(h());
这段代码中变量h指向了f中的那个匿名函数(由g返回)。
假设函数h的作用域是在执行alert(h())确定的，那么此时h的作用域链是：h的活动对象-&alert的活动对象-&window对象。
假设函数h的作用域是在定义时确定的，就是说h指向的那个匿名函数在定义的时候就已经确定了作用域。那么在执行的时候，h的作用域链为：h的活动对象-&f的活动对象-&window对象。
如果第一种假设成立，那输出值就是undefined；如果第二种假设成立，输出值则为1。
运行结果证明了第2个假设是正确的，说明函数的作用域确实是在定义这个函数的时候就已经确定了。
四、闭包的应用场景
保护函数内的变量安全。以最开始的例子为例，函数a中i只有函数b才能访问，而无法通过其他途径访问到，因此保护了i的安全性。
在内存中维持一个变量。依然如前例，由于闭包，函数a中i的一直存在于内存中，因此每次执行c()，都会给i自加1。
通过保护变量的安全实现JS私有属性和私有方法（不能被外部访问）
私有属性和方法在Constructor外是无法被访问的
function Constructor(...) {
var that =
var membername =
function membername(...) {...}
以上3点是闭包最基本的应用场景，很多经典案例都源于此。
五、Javascript的垃圾回收机制
在Javascript中，如果一个对象不再被引用，那么这个对象就会被GC回收。如果两个对象互相引用，而不再被第3者所引用，那么这两个互相引用的对象也会被回收。因为函数a被b引用，b又被a外的c引用，这就是为什么函数a执行后不会被回收的原因。
阅读(...) 评论() &闭包这个东西确实好用，理解他对学习JavaScript确实很有帮助。
闭包的内部细节，依赖于函数被调用过程所发生的一系列事件为基础，所以有必要先弄清楚以下几个概念：1. 执行环境和活动对象、2. 作用域链。
在javascript中，执行环境可以抽象的理解为一个object，它由以下几个属性构成：
executionContext：{
variable object：vars,functions,arguments,
scope chain: variable object + all parents scopes
thisValue: context object
作用域链，它在解释器进入到一个执行环境时初始化完成并将其分配给当前执行环境。每个执行环境的作用域链由当前环境的变量对象及父级环境的作用域链构成。
详情可查看
什么是闭包？
&官方&的解释是：所谓&闭包&，指的是一个拥有许多变量和绑定了这些变量的环境的表达式（通常是一个函数），因而这些变量也是该表达式的一部分。通俗一点的讲就是闭包是指有权访问另一个函数作用域变量的函数，创建闭包的通常方式，是在一个函数内部创建另一个函数。
理解JavaScript的作用域机制对理解闭包有很大的帮助。
上文我们提到了，由于作用域链的结构，外围函数是无法访问内部变量的，为了能够访问内部变量，我们就可以使用闭包，闭包的本质还是函数
一个简单的例子：
function A(){
var x = 25;
return function(){
console.log(x);
var n = A();
闭包实现原理
当某个函数调用时会创建一个执行环境以及作用域链，然后根据arguments和其它命名参数初始化形成活动对象。 在外部函数调用结束后，其执行环境与作用域链被销毁，但是其活动对象保存在了闭包之中，最后在闭包函数调用结束后才销毁
普通函数：在outer()执行完，局部变量local被销毁，内存仅仅保存全局作用域。
function outer() {
var localVal = 30;
return localV
outer(); // 30
闭包：在outer()执行后，func()仍然可以访问outer()内部的localVal，因为func()将outer()的内的活动对象（localVal）添加到了func()的作用域链。在outer()执行后，由于localVal被func()的作用域链所引用，所以localVal不会被销毁，而是存在内存中，直到func()被销毁，才会随之销毁。
function outer() {
var localVal = 30;
return function() {
return localV
var func = outer();
func(); // 30
闭包的实现
在函数中定义函数，并且内部函数引用了外部函数的变量，最后内部函数被返回
闭包的作用
我们的函数可产生类似于块级作用域的东西，内部的变量外部不可访问，但是我们需要提供访问的接口，这个接口的实现便依赖于我们的闭包
闭包的问题
闭包的使用上需要注意，因为他会增大内存的负担，对性能有一点影响，另外闭包有可能会有一些容易出错的场景。
再看一道题目:
var str1 = str2 = "web";
(function () {
var str1 = str2 = "前端";
console.log(str2);
当然这里输出的是结果是: 前端
如果现在将console.log(str2)变成consloe.log(str1),那么输出的结果就会变成 web
其实这题并不是很难，第一句 var str1 = str2 = "web"; 其实是定义了两个全局的变量，在利用function的闭包内用 var 重新定义了 str1 而没有重新定义 str2
我们知道在默认情况下 如果不用 var 定义的变量都会变成全局变量，所以此时在function闭包内的str2就是引用了全局变量，所以赋值操作当然也就能赋予全局变量 str2 所以输出 str2 结果是 "前端"
而 str1 用了 var 定义，就是在function闭包内的变量，闭包外自然不可以改变，所以输出的结果是 "web"
其实每一次看到这种形式的代码
(function(){
都觉得非常的新鲜，觉得这里有很多东西可以专研，所以在这里也总结一下这种形式的闭包。
解释前先看看
首先这种形式的闭包是人为的加上去，并不是说可以有什么神奇的 duangduang 的特效，而是可以避免很多本来是局部变量可以搞定的比较 low 的变量去污染全局的变量
其次在js中，是没有块作用域 这种说法
首先我们回到C++,如果有一段代码是这样
int number1=10;
int number1 = 5;
cout&&number1;
这里的结果还是 10
而在js代码之中
var str1= "web";
var str1="前端";
console.log(str1);
这里的结果就是 前端
因为 if{} 没有块作用域，所以内部的str1直接就重定义了外部全局的str1，所以输出的结果就只是"前端"了，而且这也污染了全局变量（那个等于"web"的str1已经不见了踪影）
而大 js 只有 函数作用域
所以我们要利用函数闭包
利用函数闭包能有效的封装局部的变量，而不污染全局作用域
str1 = "web";
(function () {
var str1 = "前端";
//str1剩下的功能
console.log(str1);
此时输出的还是 web
所以我们利用了一个匿名函数 function(){} 并且让他自己调用自己执行函数内部的操作 并且 str1 也没有污染到外部的全局作用域
接下来用一些题来加深理解：
　　例1：判断作用域指向的变量对象是否相同
function A(){
var x = 1;
return function(){
console.log(x);
var m1 = A();//第一次执行A函数
var m2 = A();//第二次执行A函数
　　每次执行 A 函数时，都会生成一个A的活动变量和执行环境，执行完毕以后，A 的执行环境销毁，但是活动对象由于被闭包函数引用，所以仍然保留，所以，最终剩下两个A的变量对象，因此 m1 和 m2 在操作x时，指向的是不同的数据，
　　注意：执行环境和变量对象在运行函数时生成；执行环境中的所有代码执行完以后，执行环境被销毁，保存在其中的变量和函数也随之销毁；(全局执行环境到应用退出时销毁)
function A(){
var x = 1;
m[0] = function(){
console.log(x);
m[1] = function(){
console.log(x);
var m = A();//第一次运行A,而且只运行这一次
m[0]();//2
m[1]();//3
m[0]();//4
m[1]();//5
　　这个例子和刚刚十分类似，不同的是，在A内部就先定义了两个函数，可以看出 ，最后的结果与上面的例子有些不同:变量x仍然能保持递增，但是m[0]和m1定义的函数，对于x的改变不再是相互独立的，其实大家估计猜到了，这里的m[0]和m1的作用域指向的A的变量对象，其实是同一个，为什么呢?很简单，看看刚刚这段代码，其实是只调用了一次A函数，再看上文那句话:执行环境和变量对象在运行函数时生成
　　既然A只执行一次，那么A的活动变量当然也就生成了一个，所以这里m[0]和m1的作用域指向同一个A的变量对象
　　例3：判断变量对象中变量的值
function A(){
var funs=[];
for(var i=0;i&10;i++){
funs[i]=function(){
var funs = A();//定义funs[0]-funs[9]，10个函数
console.log(funs[0]());//10
console.log(funs[1]());//10
console.log(funs[6]());//10
　　这个例子其实算是一个经典案例，在很多地方都有提到，执行完毕后 funs 数组中，funs[0]-funs[9]存的其实都是一样的,都是一个返回i值的函数，这个例子容易错误的地方其实在于，弄错了产生执行环境的时机，还是看这句话：执行环境和变量对象在运行函数时生成　　所以，当执行var funs = A();时，只是定义函数，而没有执行，真正产生环境变量的时间是在console.log(funs[0]());这三句的时候，此时A的变量对象中i值是什么呢？很简单，看它return的时候，i的值，显然，i的值是10，所以，最后三句输出的都是10
　　如果想让 fun[i] 能够返回 i：
function A(){
var funs=[];
for(var i=0;i&10;i++){
funs[i] = function anonymous1(num){
return function anonymous2(){
var funs = A();//定义funs[0]-funs[9]，10个函数
console.log(funs[0]());//0
console.log(funs[1]());//1
console.log(funs[6]());//6&
　　是不是一看头就大了？没关系，接下来我们慢慢分析，当然，上述代码中 anonymous1 和 anonymous2 两个名字是我自己添加上的，为了后面能够更好的说明。
　　首先，先来看看 function anonymous1(num){}(i)，这是一个立即执行函数，效果和名字一样，定义完之后马上运行结果，那这里运行的结果是什么呢？就是把i的值立即传递给 num 这个局部变量，然后再返回 anonymous2，请注意这个立即执行函数被执行的次数，10次，[即使创建一个函数让它执行的时候创建自己的活动对象]再来看看这句话：执行环境和变量对象在运行函数时生成。　　这里面生成了几个 anonymous1 的活动变量？当然也是10个。　　那每个 anonymous1 活动变量中存贮的 num 值是多少？看anonymous函数return的时候可以知道，存贮的num值就是每次传入的i值，也就是0-9。　　好了，那现在很明了了，这样的写法其实相当于，把每次的 i 值都保存在一个 anonymous1 活动变量钟，给最内层的 anonymous2 函数使用
* 闭包原理
* @version 1
//理解作用域、作用域链
//内部作用域可以通过作用域链引用外部作用域的变量
// function(){}() functionName() 立即执行函数
function exp1() {
var a = 1;
var b = function() {
//console.log(0); //exp1函数被调用的时候，0不会输出；b函数被调用时，0才输出。
console.log(a);
}; //b是函数，被调用的时候输出才执行，通过作用域链找到a值。
a = a + 3;
var res1 = exp1(); //[function]
res1(); //调用函数执行输出，a值已经被修改为4
console.log('------------------------');
//本质：exp1函数已执行完， b函数才被调用 。
function exp2() {
var a = 1;
var b = function() {
console.log(a);
}(); //b是数值，匿名函数立即执行输出a值为1
a = a + 3;
var res2 = exp2(); //1
console.log('------------------------');
function exp3() {
var a = 1;
var b = function() {
return function(){
console.log(a);
}(); //再加一层闭包保持b是函数。外层匿名函数立即执行返回函数，b是函数，被调用的时候输出才执行，通过作用域链找到a值。
a = a + 3;
var res3 = exp3(); //[function]
res3();//调用函数执行输出,a值已经被修改为4
console.log('------------------------');
function exp4() {
var a = 1;
var b = function(num) {//参数num被赋值为1
return function(){
console.log(num);
}(a);//再加一层闭包保持b是函数，外层匿名函数传参立即执行。立即执行外层匿名函数返回函数，b是函数，被调用的时候输出才执行，通过作用域链找到num值。
a = a + 3;
var res4 = exp4(); //[function]
res4();//调用函数执行输出,num值为1
console.log('------------------------');
function exp5() {
var b = [];
for (var i = 0; i & 4; i++) {
b[i] = function() {
console.log(i);
var res5 = exp5(); //[[function],[function],[function],[function]]
res5[1](); //4
console.log('------------------------');
function exp6() {
var b = [];
for (var i = 0; i & 4; i++) {
b[i] = function(num) {
return function(){
console.log(num);
var res6 = exp6(); //[[function],[function],[function],[function]]
res6[1](); //1
《JavaScript高级程序设计》
阅读(...) 评论()