其它参考14

dlaliberte的第一点示例:

  不仅在返回内部函数时创建闭包。实际上，封闭功能根本不需要返回。您可以将内部函数分配给外部作用域中的变量，或者将其作为参数传递给另一个可以立即使用的函数。因此，封闭函数的闭包可能在调用封闭函数时已经存在，因为任何内部函数在调用它时都可以访问它。

var i;
function foo(x) {
    var tmp = 3;
    i = function (y) {
        console.log(x + y + (++tmp));
    }
}
foo(2);
i(3);

其它参考15

我知道已经有很多解决方案，但我想这个小而简单的脚本可以用来演示这个概念:

// makeSequencer will return a "sequencer" function
var makeSequencer = function() {
    var _count = 0; // not accessible outside this function
    var sequencer = function () {
        return _count++;
    }
    return sequencer;
}

var fnext = makeSequencer();
var v0 = fnext();     // v0 = 0;
var v1 = fnext();     // v1 = 1;
var vz = fnext._count // vz = undefined

其它参考16

闭包是内部函数所具有的访问其外部函数中的变量。这可能是关闭时可以获得的最简单的一行解释。

其它参考17

你正在睡觉，你邀请丹。
你告诉Dan带一个XBox控制器。


丹邀请保罗。
丹要求保罗带一个控制器。有多少控制器被带到聚会上?

function sleepOver(howManyControllersToBring) {

    var numberOfDansControllers = howManyControllersToBring;

    return function danInvitedPaul(numberOfPaulsControllers) {
        var totalControllers = numberOfDansControllers + numberOfPaulsControllers;
        return totalControllers;
    }
}

var howManyControllersToBring = 1;

var inviteDan = sleepOver(howManyControllersToBring);

// The only reason Paul was invited is because Dan was invited. 
// So we set Paul's invitation = Dan's invitation.

var danInvitedPaul = inviteDan(howManyControllersToBring);

alert("There were " + danInvitedPaul + " controllers brought to the party.");

其它参考18

JavaScript函数可以访问它们:

1. 参数


2. 本地人(即他们的本地变量和本地函数)


3. 环境，包括:
   
   
   
   
   • globals，包括DOM
   
   
   • 外部职能中的任何内容
   
   

如果函数访问其环境，则该函数是闭包。


请注意，外部函数不是必需的，尽管它们确实提供了我在此不讨论的好处。通过访问其环境中的数据，闭包使数据保持Activity。在外部/内部函数的子例外，外部函数可以创建本地数据并且最终退出，但是，如果在外部函数退出之后存在任何内部函数，则内部函数使外部函数的本地数据保持Activity状态。


使用全局环境的闭包示例:


想象一下，Stack Overflow Vote-Up和Vote-Down按钮事件实现为闭包，voteUp_click和voteDown_click，它们可以访问外部变量isVotedUp和isVotedDown，它们是全局定义的。 (为简单起见，我指的是StackOverflow的问题投票按钮，而不是答案投票按钮的数组。)


当用户单击VoteUp按钮时，voteUp_click函数检查isVotedDown ==是否确定是否投票或仅取消向下投票。函数voteUp_click是一个闭包，因为它正在访问它的环境。

var isVotedUp = false;
var isVotedDown = false;

function voteUp_click() {
  if (isVotedUp)
    return;
  else if (isVotedDown)
    SetDownVote(false);
  else
    SetUpVote(true);
}

function voteDown_click() {
  if (isVotedDown)
    return;
  else if (isVotedUp)
    SetUpVote(false);
  else
    SetDownVote(true);
}

function SetUpVote(status) {
  isVotedUp = status;
  // Do some CSS stuff to Vote-Up button
}

function SetDownVote(status) {
  isVotedDown = status;
  // Do some CSS stuff to Vote-Down button
}

所有这四个函数都是闭包，因为它们都访问它们的环境。

其它参考19

Closures 的作者已经很好地解释了闭包，解释了我们需要它们的原因，并解释了理解闭包所必需的LexicalEnvironment。

以下是摘要:[111]


如果访问变量，但它不是本地的，该怎么办?像这儿:


[112]


在这种情况下，解释器在中找到变量
外LexicalEnvironment对象。[113]


该过程包括两个步骤:

1. 首先，当创建函数f时，它不会创建为空
   空间。有一个当前的LexicalEnvironment对象。在这种情况下
   上面，它是窗口(a在功能时是未定义的
   创建)。

[114]


创建函数时，它会获得一个名为[[Scope]]的隐藏属性，该属性引用当前的LexicalEnvironment。


[115]


如果读取变量但在任何地方都找不到，则会生成错误。


嵌套函数


函数可以嵌套在另一个函数中，形成一个LexicalEnvironments链，也可以称为范围链。


[116]


因此，函数g可以访问g，a和f。


闭包


外部函数完成后，嵌套函数可能会继续存在:


[117]


标记LexicalEnvironments:


[118]


如我们所见，this.say是用户对象中的属性，因此在用户完成后它将继续存在。


如果你还记得，当创建this.say时，它(作为每个函数)都会获得当前LexicalEnvironment的内部引用this.say.[**Scope**]。因此，当前用户执行的LexicalEnvironment保留在内存中。 User的所有变量也都是它的属性，因此它们也被仔细保存，而不是通常的垃圾。


重点是确保如果内部函数将来想要访问外部变量，它就能够这样做。


总结一下:

1. 内部函数保留对外部的引用
   LexicalEnvironment。


2. 内部函数可以从中访问变量
   任何时候即使外部功能完成。


3. 浏览器将LexicalEnvironment及其所有属性(变量)保留在内存中，直到有一个引用它的内部函数。

这称为闭包。

其它参考20

作为一个6岁的子的父亲，目前正在教育幼儿(以及没有接受过正规教育的相对新手，因此需要更正)，我认为通过实际操作可以最好地吸取教训。如果这个6岁的子已经准备好了解关闭是什么，那么他们已经足够大了，可以自己去做。我建议将代码粘贴到jsfiddle.net中，解释一下，然后让他们独自制作一首独特的歌曲。下面的解释性文字可能更适合10岁的人。

function sing(person) {

    var firstPart = "There was " + person + " who swallowed ";

    var fly = function() {
        var creature = "a fly";
        var result = "Perhaps she'll die";
        alert(firstPart + creature + "\n" + result);
    };

    var spider = function() {
        var creature = "a spider";
        var result = "that wiggled and jiggled and tickled inside her";
        alert(firstPart + creature + "\n" + result);
    };

    var bird = function() {
        var creature = "a bird";
        var result = "How absurd!";
        alert(firstPart + creature + "\n" + result);
    };

    var cat = function() {
        var creature = "a cat";
        var result = "Imagine That!";
        alert(firstPart + creature + "\n" + result);
    };

    fly();
    spider();
    bird();
    cat();
}

var person="an old lady";

sing(person);

说明


数据:数据是事实的集合。它可以是数字，单词，测量，观察甚至只是对事物的描述。你不能触摸它，闻它或品尝它。你可以把它写下来，说出来并听到它。你可以用它来创造使用电脑触摸气味和味道。它可以制作使用代码的计算机很有用。


代码:以上所有内容都称为代码。它是用JavaScript编写的。


JAVASCRIPT:JavaScript是一种语言。像英语或法语或中文是语言。计算机和其他电子处理器可以理解许多语言。要使计算机能够理解JavaScript，它需要一个解释器。想象一下，如果只会说俄语的老师来到学校教你的课。当老师说всесадятся时，班级不明白。但幸运的是，你班上有一名俄罗斯学生告诉大家这意味着每个人都坐下来 - 所以你们都这样做。这个班级就像一台电脑，俄罗斯学生就是翻译。对于JavaScript，最常见的解释器称为浏览器。


浏览器:当您通过计算机，平板电脑或手机连接到Internet访问网站时，您可以使用浏览器。您可能知道的示例包括Internet Explorer，Chrome，Firefox和Safari。浏览器可以理解JavaScript并告诉计算机它需要做什么。 JavaScript指令称为函数。


功能:JavaScript中的函数就像一个工厂。它可能是一个只有一台机器的小工厂。或者它可能包含许多其他小工厂，每个工厂都有许多机器从事不同的工作。在现实生活中的衣服工厂里，你可能会看到大量的布料和线轴，以及T恤和牛仔裤的出现。我们的JavaScript工厂只处理数据，它不能缝制，钻孔或熔化金属。在我们的JavaScript工厂数据进入并且数据出来。


所有这些数据听起来都有点无聊，但它真的很酷;我们可能有一个功能，告诉机器人晚餐吃什么。让我们说我邀请你和你的朋友来我家。你最喜欢鸡腿，我喜欢香肠，你的朋友总是想要你想要的东西而我的朋友不吃肉。


我没有时间去购物，所以功能需要知道我们在冰箱里有什么来做决定。每种食材都有不同的烹饪时间，我们希望机器人能同时为所有食物提供热量。我们需要提供有关我们喜欢的数据的功能，该功能可以与冰箱对话，并且该功能可以控制机器人。


函数通常具有名称，括号和大括号。喜欢这个:

function cookMeal() {  /*  STUFF INSIDE THE FUNCTION  */  }

请注意，/*...*/和//会停止浏览器读取的代码。


姓名:您可以根据自己想要的任何字词调用函数。示例cookMeal通常是将两个单词连接在一起并在第二个单词的开头给出大写字母 - 但这不是必需的。它不能有空间，它本身不能是一个数字。


父:圆括号或()是JavaScript功能工厂门上的信箱或街道上的邮箱，用于向工厂发送信息包。有时邮箱可能标有，例如 cookMeal(you, me, yourFriend, myFriend, fridge, dinnerTime)，在这种情况下，您知道您必须提供哪些数据。


支架:看起来像{}的大括号是我们工厂的有色窗户。从工厂内部你可以看到，但从外面你不能看到。


上面的长代码示例


我们的代码以 function 这个词开头，所以我们知道它是一个!然后是函数的名称​​唱 - 这是我自己对函数的描述。然后是括号()。括号总是存在于函数中。有时候它们是空的，有时它们有东西。这个有一个单词:(person)。之后有一个像这样的大括号{。这标志着函数唱的开始( )。它有一个伙伴，标志着 sing()的结束，就像这样}

function sing(person) {  /* STUFF INSIDE THE FUNCTION */  }

所以这个功能可能与唱歌有关，可能需要一些人的数据。它内部有指令来处理该数据。


现在，在函数 sing()之后，接近代码的末尾就是该行

var person="an old lady";

VARIABLE:字母 var 代表变量。变量就像一个信封。在外面，这个信封被标记为人。在里面它包含一张纸，上面有我们的功能需要的信息，一些字母和空格连在一起就像一根字符串(它被称为一个字符串)，使一个短语读作一位老太太。我们的信封可能包含其他类似的东西，如数字(称为整数)，指令(称为函数)，列表(称为数组)。因为这个变量写在所有大括号之外{}，因为你可以当你在括号内时透过有色窗口看，这个变量可以从代码中的任何地方看到。我们称之为全局变量。


GLOBAL VARIABLE: person 是一个全局变量，这意味着如果你将其价值从老太太改为年轻人，那么人将继续保持年轻直到您决定再次更改它并且代码中的任何其他功能都可以看到它是年轻人。按 F12 按钮或查看选项设置以打开浏览器的开发人员控制台并输入person以查看此值是什么。键入person="a young man"进行更改，然后再次键入person以查看其已更改。


在此之后我们有了这行

sing(person);

这一行正在调用该函数，就好像它正在调用一只狗一样

  来吧唱歌，来吧人!

当浏览器加载到达此行的JavaScript代码时，它将启动该功能。我把这行放在最后，以确保浏览器具有运行它所需的所有信息。


功能定义动作 - 主要功能是唱歌。它包含一个名为 firstPart 的变量，它适用于歌曲中关于适用于歌曲每节经文的人的歌唱:有+人+吞下。如果你在控制台中输入 firstPart ，你就不会得到答案，因为变量被锁定在一个函数中 - 浏览器无法看到大括号的有色窗口内部。


闭包:闭包是大型 sing()函数中较小的函数。大工厂里面的小工厂。它们各自都有自己的大括号，这意味着它们内部的变量不能从外部看到。这就是为什么变量的名称(生物和结果)可以在闭包中重复但具有不同的值。如果在控制台窗口中键入这些变量名称，则无法获得其值，因为它被两层有色窗口隐藏。


闭包都知道 sing()函数的变量名为 firstPart 是什么，因为他们可以从他们的有色窗口中看到。


关闭之后就行了

fly();
spider();
bird();
cat();

sing()函数将按照给定的顺序调用这些函数。然后将完成sing()函数的工作。

其它参考21

好的，和一个6岁的子交谈，我可能会使用以下关联。

  想象一下 - 你在整个房子里和你的小兄弟姐妹一起玩，你带着你的玩具四处走动，把它们带进你哥哥的房间。过了一会儿，你的哥哥从学校回来，然后去了他的房间，他锁在里面，所以现在你无法直接进入那里留下的玩具。但你可以敲门，问你的兄弟那些玩具。这就是玩具的封闭;你兄弟为你做了，他现在进入外部范围。

与一个门被草稿锁定而内部没人(一般功能执行)的情况相比，然后发生一些局部火灾并烧毁房间(垃圾收集器:D)，然后建造一个新房间，现在你可以离开那里有另一个玩具(新功能实例)，但从来没有得到第一个房间实例中留下的相同玩具。


对于一个高级子，我会提出如下的内容。它并不完美，但它让你感觉它是什么:

function playingInBrothersRoom (withToys) {
  // We closure toys which we played in the brother's room. When he come back and lock the door
  // your brother is supposed to be into the outer [**scope**] object now. Thanks god you could communicate with him.
  var closureToys = withToys || [],
      returnToy, countIt, toy; // Just another closure helpers, for brother's inner use.

  var brotherGivesToyBack = function (toy) {
    // New request. There is not yet closureToys on brother's hand yet. Give him a time.
    returnToy = null;
    if (toy && closureToys.length > 0) { // If we ask for a specific toy, the brother is going to search for it.

      for ( countIt = closureToys.length; countIt; countIt--) {
        if (closureToys[countIt - 1] == toy) {
          returnToy = 'Take your ' + closureToys.splice(countIt - 1, 1) + ', little boy!';
          break;
        }
      }
      returnToy = returnToy || 'Hey, I could not find any ' + toy + ' here. Look for it in another room.';
    }
    else if (closureToys.length > 0) { // Otherwise, just give back everything he has in the room.
      returnToy = 'Behold! ' + closureToys.join(', ') + '.';
      closureToys = [];
    }
    else {
      returnToy = 'Hey, lil shrimp, I gave you everything!';
    }
    console.log(returnToy);
  }
  return brotherGivesToyBack;
}
// You are playing in the house, including the brother's room.
var toys = ['teddybear', 'car', 'jumpingrope'],
    askBrotherForClosuredToy = playingInBrothersRoom(toys);

// The door is locked, and the brother came from the school. You could not cheat and take it out directly.
console.log(askBrotherForClosuredToy.closureToys); // Undefined

// But you could ask your brother politely, to give it back.
askBrotherForClosuredToy('teddybear'); // Hooray, here it is, teddybear
askBrotherForClosuredToy('ball'); // The brother would not be able to find it.
askBrotherForClosuredToy(); // The brother gives you all the rest
askBrotherForClosuredToy(); // Nothing left in there

如您所见，无论房间是否锁定，房间内的玩具仍可通过兄弟进入。这是一个玩它的jsbin。[119]

其它参考22

一个六岁子的答案(假设他知道一个函数是什么，变量是什么，以及是什么数据):


函数可以返回数据。您可以从函数返回的一种数据是另一种功能。当返回该新函数时，创建它的函数中使用的所有变量和参数都不会消失。相反，该父函数关闭。换句话说，没有什么可以看到它的内部并看到它使用的变量除了它返回的函数。这个新函数有一个特殊的能力，可以回顾创建它的函数并查看其中的数据。

function the_closure() {
  var x = 4;
  return function () {
    return x; // Here, we look back inside the_closure for the value of x
  }
}

var myFn = the_closure();
myFn(); //=> 4

解释它的另一个非常简单的方法是在范围方面:


无论何时在较大范围内创建较小的范围，较小的范围始终都能够查看较大范围内的范围。

其它参考23

JavaScript中的函数不仅仅是对一组指令的引用(如在C语言中)，而且它还包括一个隐藏的数据结构，该结构由对它使用的所有非局部变量(捕获的变量)的引用组成。这种两件式函数称为闭包。 JavaScript中的每个函数都可以被视为闭包。


闭包是具有状态的功能。它有点类似于this，意思是this也为函数提供状态但函数和this是单独的对象(t​​his只是一个奇特的参数，并且是将它永久绑定到a的唯一方法函数是创建一个闭包)。虽然this和函数总是分开存在，但函数不能与其闭包分离，并且语言无法访问捕获的变量。


因为词法嵌套函数引用的所有这些外部变量实际上是其词法封闭函数链中的局部变量(全局变量可以假定为某些根函数的局部变量)，并且函数的每次执行都会创建新的实例它的局部变量，它遵循一个函数的每次执行返回(或以其他方式将其转移出来，例如将其注册为回调)嵌套函数创建一个新的闭包(具有其自己的可能唯一的一组引用的非局部变量，表示其执行上下文)。


此外，必须要理解的是，JavaScript中的局部变量不是在堆栈帧上创建的，而是在堆上创建的，只有在没有人引用它们时才会被销毁。当函数返回时，对其局部变量的引用会递减，但如果在当前执行期间它们成为闭包的一部分并且仍然由其词法嵌套函数引用(它们仅在引用时才会发生)，它们仍然可以为非null。这些嵌套函数被返回或以其他方式传递给某些外部代码)。


一个例子:

function foo (initValue) {
   //This variable is not destroyed when the foo function exits.
   //It is 'captured' by the two nested functions returned below.
   var value = initValue;

   //Note that the two returned functions are created right now.
   //If the foo function is called again, it will return
   //new functions referencing a different 'value' variable.
   return {
       getValue: function () { return value; },
       setValue: function (newValue) { value = newValue; }
   }
}

function bar () {
    //foo sets its local variable 'value' to 5 and returns an object with
    //two functions still referencing that local variable
    var obj = foo(5);

    //Extracting functions just to show that no 'this' is involved here
    var getValue = obj.getValue;
    var setValue = obj.setValue;

    alert(getValue()); //Displays 5
    setValue(10);
    alert(getValue()); //Displays 10

    //At this point getValue and setValue functions are destroyed
    //(in reality they are destroyed at the next iteration of the garbage collector).
    //The local variable 'value' in the foo is no longer referenced by
    //anything and is destroyed too.
}

bar();