原文链接：http://www.jianshu.com/p/72a96b6ece5f

闭包的定义

学术来说，闭包是指在 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上。

最后

闭包，并不是什么坏东西，不要每次提到闭包都与内存泄漏挂钩，正常使用闭包，是使用内存，不是内存泄漏，请充分利用好闭包的特性。