闭包是什么？

闭包（英语：Closure），又称词法闭包（Lexical Closure）或函数闭包（Function Closures），是引用了自由变量的函数。这个被引用的自由变量将和这个函数一同存在，即使已经离开了创造它的环境也不例外。所以，有另一种说法认为闭包是函数和声明该函数的词法环境的组合。你也可以理解为闭包就是一个带状态（状态即引用的自由变量）的函数。

1、函数作为返回值

在高阶函数中函数不仅可以作为参数进行传递，还可以作为返回值返回。

?我们先来实现一个两个数字相加的例子

function add(x, y) {return x + y;
}
add(1, 2) // 3

但是如果我们不想立马计算，在后面根据需求在进行计算应该怎么办？答案是返回求和的方法，而不是返回求和的结果。

function lazy_add(x, y) {var add = function(x, y) {return x + y;}return add;
}

当我们调用lazy_add() 时返回的并不是求和的结果，而是返回的求和函数

var fun = lazy_add(1, 2)  // function add(){}

当真正需要进行计算的时候我们可以调用fun()

var sum = fun();    //3 

那么我们调用的是fun方法，也并没有将他怎么就知道是1和2相加了呢？原因就是fun方法是通过lazy_add方法传递两个参数1和2生成的，lazy_add方法在返回add方法的同时将变量x和y也一并保存返回了。这就形成了自由变量x，y和函数add组成的闭包。

需要注意的是，当我们调用lazy_add()时，每次调用都会返回一个新的函数，即使传入相同的参数：

var f1 = lazy_add(1, 2);
var f2 = lazy_sum(1, 2);
f1 === f2; // false

2、循环中的闭包

?我们再看一个例子

function count() {var arr = [];for (var i=1; i<=3; i++) {arr.push(function () {return i * i;});}return arr;
}var results = count();
var f1 = results[0];
var f2 = results[1];
var f3 = results[2];

在上面的代码中在每次循环中生成了一个函数放到了数组中。你可能认为调用f1()，f2()和f3()结果应该是1，4，9，但实际结果是：三个都是 16

为什么会这样呢？原因就在于返回的函数引用了变量i，但它并非立刻执行。等到3个函数都返回时，它们所引用的变量i已经变成了4，因此最终结果为16。

所以返回闭包时牢记的一点就是：返回函数不要引用任何循环变量，或者后续会发生变化的变量

如果非要引用循环变量应该怎么办？那就是在循环变量的外层包一层立即执行函数，将循环变量绑定到立即执行函数的入参，如下：

function count() {var arr = [];for (var i=1; i<=3; i++) {arr.push((function (n) {return function () {return n * n;}})(i));}return arr;
}var results = count();
var f1 = results[0];
var f2 = results[1];
var f3 = results[2];f1(); // 1
f2(); // 4
f3(); // 9

另外可以通过ES6中的语法更轻松地解决这个问题，那就是通过let声明循环变量，该方法可以避免使用过多的闭包（过多的闭包影响性能）代码如下：

function count() {var arr = [];for (let i=1; i<=3; i++) {arr.push(function () {return i * i;});}return arr;
}var results = count();
var f1 = results[0];
var f2 = results[1];
var f3 = results[2];

这个例子使用let而不是var，因此每个闭包都绑定了块作用域的变量，这意味着不再需要额外的闭包。

说了这么多，难道闭包就是为了返回一个函数然后延迟执行吗？当然不是！让我们接着往下看。

3、函数柯里化(curry)

柯里化（Currying）是把接受多个参数的函数变换成接受一个单一参数(最初函数的第一个参数)的函数，并且返回接受余下的参数且返回结果的新函数的技术。读起来可能优点绕，看了下面的例子你就会明白。

想必大家应该都用过 Math.pow(x, y)方法，是的这个就是计算x的y次方的方法，但是由于我们通常都是计算2次方和3次方，所以我们要通过闭包基数对该方法进行柯里化。

function make_pow(n) {return function (x) {return Math.pow(x, n);}
}//创建两个新的方法
var pow2 = make_pow(2);
var pow3 = make_pow(3);pow2(5); // 25
pow3(5); // 125

4、对象封装

在面向对象的程序设计语言里，比如Java和C++，要在对象内部封装一个私有变量，可以用private修饰一个成员变量。

在没有class机制，只有函数的语言里，借助闭包，同样可以封装一个私有变量。下面我们就用javascript创建一个包含私有变量的计数器。

function create_counter(initial) {var x = initial || 0;return {inc: function () {x += 1;return x;}}
}var c1 = create_counter(1);
c1.inc(); // 2
c1.inc(); // 3
c1.inc(); // 4

在返回的对象中，实现了一个闭包，该闭包携带了局部变量x，并且，从外部代码根本无法访问到变量x 

5、闭包性能考量

如果不是某些特定任务需要使用闭包，在其它函数中创建函数是不明智的，因为闭包在处理速度和内存消耗方面对脚本性能具有负面影响。

例如，在创建新的对象或者类时，方法通常应该关联于对象的原型，而不是定义到对象的构造器中。原因是这将导致每次构造器被调用时，方法都会被重新赋值一次（也就是，每个对象的创建）。

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;
};var obj1 = new MyObject('name1', 'message1');
var obj2 = new MyObject('name2', 'message2');
obj1.getName == obj2.getName; // true

上面的代码中构造的每个实例中的方法都指向同一个

但是如果是用闭包封装的对象会怎么样，接着用之前的计数器例子做一下测试

var count1 = create_counter(1);
var count2 = create_counter(2);count1.inc == count2.int; //false

从测试结果可以看出每个对象中的方法都是独立的方法，这样违背了对象方法公用原则

万物皆有利弊，所以具体要怎么使用还是要仔细考量。