简介
闭包closure是javascript中一个十分弱小的性能。所谓闭包就是函数中的函数，外部函数能够拜访内部函数的作用域范畴，从而能够应用闭包来做一些比拟弱小的工作。
明天将会给大家具体介绍一下闭包。
函数中的函数
咱们提到了函数中的函数能够拜访父函数作用域范畴的变量，咱们看一个例子：
function parentFunction() { var address = 'flydean.com'; function alertAddress() { alert(address); } alertAddress();}parentFunction();下面的例子中，咱们在parentFunction中定义了一个变量address，在parentFunction外部定义了一个alertAddress办法，在该办法外部拜访内部函数中定义的address变量。
下面代码运行是没问题的，能够正确的拜访到数据。
Closure闭包
函数中的函数有了，那么什么是闭包呢？
咱们看上面的例子：
function parentFunction() { var address = 'flydean.com'; function alertAddress() { alert(address); } return alertAddress;}var myFunc = parentFunction();myFunc();这个例子和第一个例子很相似，不同之处就是咱们将外部函数返回了，并且赋值给了myFunc。
接下来咱们间接调用了myFunc。
myFunc中拜访了parentFunction中的address变量，尽管parentFunction曾经执行结束返回。
然而咱们在调用myFunc的时候，任然能够拜访到address变量。这就是闭包。
闭包的这个个性十分领有，咱们能够应用闭包来生成function factory,如下所示：
function makeAdder(x) { return function(y) { return x + y; };}var add5 = makeAdder(5);var add10 = makeAdder(10);console.log(add5(2)); // 7console.log(add10(2)); // 12其中add5和add10都是闭包，他们是由makeAdder这个function factory创立进去的。通过传递不同的x参数，咱们失去了不同的基数的add办法。
最终生成了两个不同的add办法。
应用function factory的概念，咱们能够思考一个闭包的理论利用，比方咱们在页面上有三个button，通过点击这些button可实现批改字体的性能。
咱们能够先通过function factory来生成三个办法：
function makeSizer(size) { return function() { document.body.style.fontSize = size + 'px'; };}var size12 = makeSizer(12);var size14 = makeSizer(14);var size16 = makeSizer(16);有了这三个办法，咱们把DOM元素和callback办法绑定起来：
document.getElementById('size-12').onclick = size12;document.getElementById('size-14').onclick = size14;document.getElementById('size-16').onclick = size16;应用闭包实现private办法
比照java来说，java中有private拜访描述符，通过private，咱们能够指定办法只在class外部拜访。
当然，在JS中并没有这个货色，然而咱们能够应用闭包来达到同样的成果。
var counter = (function() { var privateCounter = 0; function changeBy(val) { privateCounter += val; } return { increment: function() { changeBy(1); }, decrement: function() { changeBy(-1); }, value: function() { return privateCounter; } };})();console.log(counter.value()); // 0.counter.increment();counter.increment();console.log(counter.value()); // 2.counter.decrement();console.log(counter.value()); // 1.咱们在父function中定义了privateCounter属性和changeBy办法，然而这些办法只可能在外部function中拜访。
咱们通过闭包的概念，将这些属性和办法封装起来，裸露给内部应用，最终达到了公有变量和办法封装的成果。
闭包的Scope Chain
对于每个闭包来说，都有一个作用域范畴，包含函数自身的作用域，父函数的作用域和全局的作用域。
如果咱们在函数外部嵌入了新的函数，那么就会造成一个作用域链，咱们叫做scope chain。
看上面的一个例子：
// global scopevar e = 10;function sum(a){ return function(b){ return function(c){ // outer functions scope return function(d){ // local scope return a + b + c + d + e; } } }}console.log(sum(1)(2)(3)(4)); // log 20闭包常见的问题
第一个常见的问题就是在循环遍历中应用闭包，咱们看一个例子：
function showHelp(help) { document.getElementById('help').innerHTML = help;}function setupHelp() { var helpText = [ {'id': 'email', 'help': 'Your e-mail address'}, {'id': 'name', 'help': 'Your full name'}, {'id': 'age', 'help': 'Your age (you must be over 16)'} ]; for (var i = 0; i < helpText.length; i++) { var item = helpText[i]; document.getElementById(item.id).onfocus = function() { showHelp(item.help); } }}setupHelp();下面的例子中，咱们创立了一个setupHelp函数，setupHelp中，onfocus办法被赋予了一个闭包，所以闭包中的item能够拜访到内部function中定义的item变量。
因为在循环外面赋值，所以咱们实际上创立了3个闭包，然而这3个闭包共享的是同一个内部函数的作用域范畴。
咱们的本意是，不同的id触发不同的help音讯。然而如果咱们真正执行就会发现，不论是哪一个id，最终的音讯都是最初一个。
因为onfocus是在闭包创立结束之后才会触发，这个时候item的值实际上是变动的，在循环完结之后，item的值曾经指向了最初一个元素，所以全副显示的是最初一条数据的help音讯。
怎么解决这个问题呢？
最简略的方法应用ES6中引入的let描述符，从而将item定义为block的作用域范畴，每次循环都会创立一个新的item，从而放弃闭包中的item的值不变。
for (let i = 0; i < helpText.length; i++) { let item = helpText[i]; document.getElementById(item.id).onfocus = function() { showHelp(item.help); } }还有一种办法，就是再创立一个闭包：
function makeHelpCallback(help) { return function() { showHelp(help); };} for (var i = 0; i < helpText.length; i++) { var item = helpText[i]; document.getElementById(item.id).onfocus = makeHelpCallback(item.help); }这里用到了之前咱们提到的function factory的概念，咱们为不同的闭包创立了不同的作用域环境。
还有一种办法就是将item蕴含在一个新的function作用域范畴之内，从而每次创立都是新的item，这个和let的原理是类似的：
for (var i = 0; i < helpText.length; i++) { (function() { var item = helpText[i]; document.getElementById(item.id).onfocus = function() { showHelp(item.help); } })(); }第二个常见的问题就是内存泄露。
function parentFunction(paramA) { var a = paramA; function childFunction() { return a + 2; } return childFunction(); }下面的例子中，childFunction援用了parentFunction的变量a。只有childFunction还在被应用，a就无奈被开释，从而导致parentFunction无奈被垃圾回收。
闭包性能的问题
咱们定义了一个对象，并且通过闭包来拜访其公有属性：
function MyObject(name, message) { this.name = name.toString(); this.message = message.toString(); this.getName = function() { return this.name; }; this.getMessage = function() { return this.message; };}下面的对象会有什么问题呢？
下面对象的问题就在于，对于每一个new进去的对象，getName和getMessage办法都会被复制一份，一方面是内容的冗余，另一方面是性能的影响。
通常来说，咱们将对象的办法定义在prototype下面：
function MyObject(name, message) { this.name = name.toString(); this.message = message.toString();}MyObject.prototype.getName = function() { return this.name;};MyObject.prototype.getMessage = function() { return this.message;};留神，咱们不要间接重写整个prototype，这样会导致未知的谬误，咱们只须要依据须要重写特定的办法即可。
总结
闭包是JS中十分弱小和有用的概念，心愿大家可能喜爱。
本文作者：flydean程序那些事本文链接：http://www.flydean.com/js-closure/
本文起源：flydean的博客
欢送关注我的公众号:「程序那些事」最艰深的解读，最粗浅的干货，最简洁的教程，泛滥你不晓得的小技巧等你来发现！