javascript 闭包 柯里化函数

什么是闭包

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

通俗来讲满足以下三点的函数就叫做闭包：

1. 函数内声明了一个函数，并且将内部函数返回到全局；
2. 将函数内的函数返回并且存储在全局变量中；
3. 内部的函数调用了外部函数中的局部变量；

闭包的写法：

function fn1(){
    // 默认情况，函数执行完成后，局部变量会被销毁
    var a=1;
    function fn2(){
        // 但是因为函数中函数使用到了函数外的变量，变量就不会销毁
        // 在函数内的函数，调用外函数中的局部变量时，是可以直接调用
        a++;
        console.log(a);
    }
    //将内部函数返回到全局
    return fn2;
}
//将函数内的函数返回并且存储在全局变量fns中
var fns=fn1();
fns();//打印a=2
fns();//打印a=3
fns=null;//闭包在不使用时，要及时释放，避免内容泄露

返回的可以直接是函数，也可以是对象内的函数。

var Utils=(function(){
    var s=5;
    return {
        a:1,
        s:10,
        b:function(){
            s++;
            console.log(s);
        }
    }
})();
console.log(Utils);//{a: 1, s: 10, b: ƒ()}，打印返回的对象
Utils.b();//打印s=6

闭包的作用域

要理解闭包，首先必须理解Javascript特殊的变量作用域。变量的作用域无非就是两种：全局变量和局部变量。 Javascript语言的特殊之处，就在于函数内部可以直接读取全局变量。

//变量a是全局变量
var a=6
function fun1(){
	console.log(a);//6
}
fun1();

//变量b是私有变量
//注意：如果b=6前面不写var，b就被升级为全局变量了,此时会打印出b=6
function fun2(){
	var b=6;
}
fun2();
console.log(b);//报错，b is undefined

闭包内的作用域：

//fun1是返回的对象
var fun1=(function(){
	//a是自执行函数的私有变量,在外部是无法调用变量a的
    var a=3;
    return {
    	//调用b的时候this.b可以在对象内调用
    	//也可以在外部使用this.b调用
        b:7,
        sum:function(){
            return this.b+a;
        }
    }
})();
console.log(fun1.sum());//10

闭包的特点

闭包的特点：

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

闭包的优点：

1. 可以有私有变量的存在；
2. 避免全局变量的污染；
3. 希望一个变量长期驻扎在内存中，防止私有变量被垃圾回收机制所清除；

闭包的缺点：

• 闭包比普通函数占用更多的内存，会造成内存泄漏；

解决：闭包在不使用时，要及时释放，将引用内层函数对象的变量赋值为null。

柯里化

什么是柯里化：
在计算机科学中，柯里化（Currying）是把接受多个参数的函数变换成接受一个单一参数（最初函数的第一个参数）的函数，并且返回接受余下的参数且返回结果的新函数的技术。通俗来讲就是将一个函数拆分成多个函数，是固定部分的参数，返回一个接受剩余参数的函数，也称为部分计算函数，目的是为了缩小适用范围，创建一个针对性更强的函数。

来看一个求和的例子，我们普通的写法是这样的：

function getSum(){
    var s=0;
    for(var i=0;i<arguments.length;i++){
        s+=arguments[i];
    }
    return s;
}
var sum=getSum(1,3,5,7,9,10);
console.log(sum);//35

如果这个时候，我们想实现当调用的时候，参数是这样传进去的，
getSum(1,3);
getSum(5,7);
getSum(9);
getSum(10);
var sum=getSum();
当参数为空时，返回最后的求和结果，我们可以这样写：

function currying(fn){
    var arr=[];
    return function(){
        if(arguments.length>0){
        	//将每次传进来的参数累加存储在arr中
            var a=Array.from(arguments);
            a.forEach(item=>arr.push(item));
        }else{
        	//当参数为空时，返回fn(),并将arr作为参数传进去
        	//因为arr是个数组，这里使用apply进行传参
            return fn.apply(null,arr);
        }
    }
}

function getSums(){
	//进行求和
  return Array.from(arguments).reduce(function(value,item){
        return value+item;
    }) 
}

var fns=currying(getSums);
fns(1,3,5);
fns(2,4,6);
fns(10,15);
fns(20);
var sum=fns();
console.log(sum);//66

如果说，参数是这样传进去的，
var s=fns(1,3,5)(2,4,6)(10,15)(20)();
当最后一个参数为空，返回求和结果，只需要当arguments的长度大于0时，返回自身函数即可，写法如下：

function currying(fn){
	var arr=[];
    return function(){
        if(arguments.length>0){
        	//使用concat将每次传进来的参数累加存储在arr中
            arr=arr.concat.apply(arr,arguments);
            //或者也可以这样写
            //arr=arr.concat(Array.from(arguments));
            //arr=Array.prototype.concat.apply(arr,arguments);
            //返回自身函数
            return arguments.callee;
        }
        //当arguments的长度=0时，返回fn()
        return fn.apply(null,arr);
    }
}

var fns=currying(function(){
    return Array.from(arguments).reduce((value,item)=>value+item);
})

var sum=fns(1,3,5)(2,4,6)(10,15)(20)();
console.log(sum);//66