闭包

• 函数当执行完成后，函数中的局部变量将会被销毁
• 当函数作用域还有内部函数调用到了外部的这个局部变量，这个局部变量就会被保存下来，并且会造成内存泄漏
• 闭包特征是创建了私有成员
• 私有成员的特点时，可以像全局变量一样保存数据，累积数据不会因为函数执行完成而被销毁
• 同时也具备独立的运行环境，除此环境外，其他地方无法调用
• 闭包就是 函数执行返回另一个内部的函数，并且这个内部的函数有权访问外部函数中的局部变量

闭包是指有权访问另一个函数作用域中的变量的函数，
创建闭包的最常见的方式就是在一个函数内创建另一个函数，通过另一个函数访问这个函数的局部变量

闭包的特点和优点

• 闭包的特点:

  • 1.函数嵌套函数
  • 2.函数内部可以引用外部的参数和变量
  • 3.参数和变量不会被垃圾回收机制回收

• 闭包的优点

  • 1.希望一个变量长期驻扎在内存中
  • 2.避免全局变量的污染
  • 3.私有成员的存在

function fun(){
    var m=2;
    var n=3;
    function f1() {
        n++;
        m++;
        console.log(m,n);    
    }
    return f1;
}
var fn = fun();
fn();//3 4
fn();//5 6 
1
2
3
4
5
6
7
8
9
10
11
12
13

当代码中出现全局变量，全局函数名重名的现象，这种情况将会下边覆盖上面的，我们把这个叫做变量污染

var fun1 = (function () {
    var a = 3;
    return {
        b: 7,
        sum: function () {
            return this.b + a;
        }
    }
})()

console.log(fun1.sum());
1
2
3
4
5
6
7
8
9
10
11

fun1是作为一个自执行函数返回定义的，因此fun1实际上是返回的对象，而对象下有一个方法sum，因此fun1，sum就是调用该对象下的sum方法，注意，a是自执行函数的
私有变量，b是对象的共有属性，因此，调用b的时候this.b可以在对象内调用，也可以在外部使用this.b调用，但是在外部是无法调用变量a的，因为他是局部变量。

---

柯里化

currying：咖喱：有所有的调料给放在一起成大料的这样的意思
分批次向函数中传入不同的参数，当再次执行不再传参的时候，统一执行最终结果。

function currying(callbcak){
    var arr = [];
    return function(){
        if(arguments.length>0){
            arr.push(...arguments);
            return arguments.callee;
        }else{
            return callbcak(...arr)
        }
    }
}
var f = currying(function(){
    return Array.from(arguments).reduce((v,t)=>v+t)
})
f(1,2,3);
f(1,2,3);
var s=f();
console.log(s)//12
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

柯力化描述二

Function.prototype.currying = function(){
    var arg = Array.from(arguments);
    var self = this;
    return function(){
        if(arguments.length===0){
            return self.apply(null,arg);
        }
        arg = arg.concat(Array.from(arguments));
    }
}
function fs(){
    console.log(Array.from(arguments));
}
var f1 = fs.currying();
f1(1,2);
f1(3,4);
f1();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17