关于闭包:JS-总结之闭包

从《JS 总结之函数、作用域链》一文中晓得作用域链的作用，保障了对所有变量对象的有序拜访。

???? 问题

函数外的是无法访问函数外部的变量，有时候要用到怎么办？咱们的配角，闭包就是能够解决这个问题。

???? 什么是闭包

援用 MDN 上的解释：

闭包是函数和申明该函数的词法环境的组合。

援用《JavaScript 高级程序设计（第 3 版）》上的解释：

闭包是指有权拜访另一个函数作用域中的变量的函数。

???? 相同点

这两个解释都在说着同一件事，闭包能拜访 申明时函数所在的环境中的变量和函数。

那具体是因为什么才会让闭包拜访到环境中的变量和函数，这得靠两兄弟：变量对象 和作用域链。

变量对象

当执行函数的时候，会创立和初始化一个函数执行环境，在函数执行环境中，全局执行环境的变量对象（Variable Object，缩写为 VO）不能间接拜访，此时由激活对象（Activation Object, 缩写为 AO）表演 VO 的角色。

变量对象专门用来梳理和记住这些变量和函数，是作用域链造成的前置条件。但咱们无奈间接应用这个变量对象，该对象次要是给 JS 引擎应用的。具体能够查看《JS 总结之变量对象》。

变量对象就相当于一个寄存的仓库，获取到外面的货色，还得须要 去获取这些的门路，这就是作用域链的事件了。

作用域链

然而，光有变量对象可实现不了闭包的造成，怎样才能让函数拜访到，这得靠作用域链，作用域链的作用就是让函数找到变量对象外面的变量和函数。具体能够查看《JS 总结之函数、作用域链》

???? 不同点

尽管都是讲闭包，但 MDN 下面讲的是 申明该函数的词法环境 ，而 JS 高程讲的是 拜访另一个函数作用域中 ，从解释上的不同，闭包便有了 实践中的闭包 （MDN）和 实际中的闭包（JS 高程）之分。

???? 实践中的闭包

依据 MDN 的解释写个例子：

var a = 1
function fn() {console.log(a)
}
fn()

函数 fn 和函数 fn 的词法作用域形成了一个闭包。然而这不是一般的函数吗？

在《JavaScript 权威指南》中也失去证实:

从技术的角度讲，所有 JavaScript 函数都是闭包

????‍????‍ 实际中的闭包

汤姆大叔翻译的文章中讲，实际中的闭包须要满足以下两个条件：

1. 即便创立它的上下文曾经销毁，它依然存在（比方，外部函数从父函数中返回）
2. 在代码中援用了自在变量

什么是上下文？即函数的执行环境。

什么是自在变量？即函数的词法作用域中的变量和函数，而不是函数自身的参数或者局部变量，或者说是所在函数的变量对象中的变量和函数。

这两点和 JS 高程中讲的闭包的解释不约而同。

当初写个合乎的例子：

function fn() {
  var a = 1
  function fn1() {console.log(a)
  }
  return fn1
}

var b = fn()
b()

当执行 b 的时候，创立它的执行环境 fn 早曾经捣毁，但函数 b 还能拜访到变量 a。

好吧，我有点乱！

要彻底明确这个是咋回事，要联合 执行环境 、 流动变量 和作用域链 来看，让咱们来看看这个例子的执行过程：

???? 执行过程

1. 执行全局代码，创立全局执行环境 globalContext，将全局执行环境推入 环境栈

环境栈 = [globalContext]

1. 初始化全局执行环境

globalContext = {VO: [global],
  Scope: [globalContext.VO],
  this: globalContext.VO
}

1. 初始化的同时，创立 fn 函数，复制 全局执行环境的作用域链 到 fn 的 [[scope]] 属性

fn.[[scope]] = [globalContext.VO]

1. 执行 fn 函数，创立 fn 的执行环境 fnContext，并推入环境栈

环境栈 = [fnContext, globalContext]

1. 初始化 fnContext：

• 复制 fn 的 [[scope]] 创立 fn 作用域链
• 创立变量对象，初始化变量对象，退出形参，函数，变量等，因为是函数，变量对象为流动对象
• 将流动对象推入 fnContext 的 Scope 顶端

fnContext = {
  AO: {arguments: {},
    scope: undefined,
    fn1: reference to function fn1(){}
  },
  Scope: [AO, globalContext.VO],
  this: undefined
}

• 初始化同时，创立 fn1 函数，复制 fnContext 的作用域链 到 fn1 的 [[scope]] 属性

fn1.[[scope]] = [fnContext.AO, globalContext.VO]

1. 执行结束，推出 fnContext

环境栈 = [globalContext]

1. 执行函数 b，也就是被返回的 fn1，创立 fn1 的执行环境 fn1Context，并推入环境栈

环境栈 = [
  fn1Context，globalContext
]

1. 初始化 fn1Context：

• 复制 fn1 的 [[scope]] 创立 fn1 作用域链
• 创立变量对象，初始化变量对象，退出形参，函数，变量等，因为是函数，变量对象为流动对象
• 将流动对象推入 fn1Context 的 Scope 顶端

fn1Context = {
  AO: {arguments: {}
  },
  Scope: [AO, fnContext.AO, globalContext.VO],
  this: undefined
}

1. 执行结束，推出 fn1Context

环境栈 = [globalContext]

???? 柳暗花明

当执行函数 b 的时候，创立它的执行环境 fn 早已捣毁（步骤 6），只留下了它的流动变量 fnContext.AO 于内存中（步骤 5）：

fn1Context = {Scope: [AO, fnContext.AO, globalContext.VO]
}

fnContext.AO 存在 fn1 的作用域链中，所以能拜访到fn1 的词法环境，这便造成了闭包。因而，闭包是变量对象和作用域链独特作用的后果。