闭包的定义
学术来说，闭包是指在 JavaScript 中，内部函数总是可以访问其所在的外部函数中声明的参数和变量，即使在其外部函数被返回（寿命终结）了之后。
就我个人而言的理解，从形式来看，闭包就是在函数里面定义一个函数，从特点来说，子函数能够读写父函数的局部变量。
function parent() {
var count = 0;
return function children(){
count++;
console.log(count);
}
}
var children = parent();
children(); // 1
children(); // 2
如何辨别闭包
虽然生产中，我们一直极力回避复杂的闭包，闭包容易降低代码的阅读性，但是大家却非常喜欢考闭包，知乎也有相关讨论：
https://www.zhihu.com/question/30861304
就让我们来看看那些面试中的闭包。
案例1:
function f1() {
var n = 999;
nAdd = function () { n += 1;}
function f2() {
console.log(n);
}
}
var result = f1();
result(); // 999
nAdd(); //
result(); // 1000
- 执行f1返回得是一个f2的function。
- 执行f2 打印999，其中n是f1的局部变量，作为闭包的f2能访问父函数的局部变量。
- 执行nAdd方法，实际上，nAdd是一个匿名函数，n作为引用传入到匿名函数中，将匿名函数传给nAdd，因为nAdd方法没有做
var声明，nAdd是一个全局函数，执行全局函数。调用nAdd的时候将会打印1000
案例2
var tasks = [];
for (var i=0; i<3; i++) {
tasks.push(function() {
console.log('>>> ' + i);
});
}
相信大多数人都会回答，打印陆续打印1，2，3，而实际情况打印的是3，3，3 因为匿名函数保存的是i的引用，当for循环结束的时候，i已经变成3了，所以打印的时候变成3，相对其他题目的考察方向，这个例子的考察的方向是如何利用闭包解决问题
for (var i=0; i<3; i++) {
(function(n) {
tasks.push(function() {
console.log('>>> ' + n);
});
})(i);
}
闭包里的匿名函数，读取变量的顺序是，先读取本地变量，再读取父函数的局部变量，如果找不到到全局里面搜索，i作为局部变量存到闭包里面，所以调整后的代码可以能正常打印。
案例3:
是不是觉得有点感觉了，看看以下案例？
function fun(n,o){
console.log(o);
return {
fun:function(m){//[2]
return fun(m,n);//[1]
}
}
}
var a=fun(0);
a.fun(1);
a.fun(2);
a.fun(3);
var b=fun(0).fun(1).fun(2).fun(3);
var c=fun(0).fun(1);
c.fun(2);
c.fun(3);
鉴于分析篇幅过大，就不做分析了，可以参考:
http://segmentfault.com/a/1190000004187681
闭包与内存泄漏
javascript的主要通过计数器的方式方式回收内存，假设有A,B,C三个对象，当a引用b的时候，那么b的引用计数器增加1，同时b引用c的时候，c计数器增加1，当a被释放的时候，b的计数器减少1，变成0被释放，c计数器变成0，被释放，然而，当遇到b和c之间存在相互引用的时候，就无法通过计数器方式释放内存，而必包恰好是导致这种情况发生的温床。闭包不代表一定会带来内存泄漏，良好的闭包设计是正常内存使用。
function parent() {
var childrenVar = {a: 1};
return function() {
console.log(childrenVar);
}
}
var children = parent();
children(); // {a: 1}
当parent函数结束时发现childrenVar 变量被匿名函数占用，所以parent无法释放，导致内存泄漏。
翻阅了不少资料，有人已经对js的闭包做过不少测试，具体可以参考
http://justjavac.iteye.com/blog/1465169
闭包的应用
说了那么多闭包的坏处，难道闭包就一无是处么？实际上，只要保证使用闭包的适合，不要重复创建，不断创建，无休止创建，使用闭包并没有想象中那么严重，例如，当我们需要利用闭包来实现统计，那是内存使用，不叫内存泄漏。
这里列举两个例子
案例1
var middleware = function (s) {
return function (req, res, next) {
console.log(s); // hello world
return next();
}
}
app.use(middleware('hello world'));
使用闭包能够为 express中间件，传递参数到中间件当中。
案例2
var request = require('request');
var _ = require('underscore');
var middleware = function (req, res, next) {
req.request = function (options, callback) {
_.extend(options, {headers: req.headers});
request(options, callback);
}
}
app.use(middleware);
app.get(function (req, res, next) {
req.request('/api', function () {
res.send('ok');
})
})
现在有这么一个业务需求，做一个api代理，代理需要把原来api请求的header也带上，如果直接使用request模块做转发，时间久了，很容易会导致忘记带上原来请求的header，所以写了一个request方法绑定到req上。
最后
闭包，并不是什么坏东西，不要每次提到闭包都与内存泄漏挂钩，正常使用闭包，是使用内存，不是内存泄漏，请充分利用好闭包的特性。
