搞懂js函数柯里化

       柯里化（Currying）是把接受多个参数的函数变换成接受一个单一参数(最初函数的第一个参数)的函数，并且返回接受余下的参数且返回结果的新函数的技术。

       简单来说，以前写一个sum函数求两数之和，调用时是sum(a,b)，而柯里化之后的调用方式则变成了sum(a)(b)...

       从调用方法可以看出，sum函数返回的一定还是一个可被持续调用的函数,直到调用结束。因此js中函数柯里化的基本方法也是：使用闭包来返回一个函数。

将函数柯里化的通用方式如下：

function curry(fn) {
    var arg = Array.prototype.slice.call(arguments, 1) 
    // 得到除fn以外的后面所有参数
    return function() {
        var innerArg = Array.prototype.slice.call(arguments)
        // 得到调用之后的内部函数的所有参数
        var args = arg.concat(innerArg)
        // 合并后续所有参数
        return fn.apply(null, args)
        // 把合并后的所有参数传入fn中执行
    }
}

// 调用方式
var fnCurry = curry(fn)
fnCurry(1)(2)

如果我们要计算4个数之和，使用普通函数：

function sum(a,b,c,d) {
    return a+b+c+d
}    

// 调用方式
sum(1,2,3,4)  // 10

使用柯里化函数：

function curry(fn,...arg) {
    return function (...nextArg) {
        // 核心思想在于把所有参数合并后再执行相加操作
        var args = [...arg,...nextArg]
        if (args.length >= fn.length) {
            // fn.length表示函数fn的行参个数
            return fn.apply(null,args)
        }
        return curry(fn, ...args)
    }
}

var sumCurry = curry(sum)
sumCurry(1,2,3,4)  // 10
sumCurry(1)(2)(3)(4)  // 10
sumCurry(1,2,3)(4)  // 10
sumCurry(1,2)(3,4)  // 10

把柯里化函数和目标函数合并： 

function sumCurry(...arg) {
    var sum = function (a,b,c,d) {
        return a+b+c+d
    } 
    var _curry = function (...nextArg) {
        // 核心思想在于把所有参数合并后再执行相加操作
        var args = [...arg,...nextArg]
        if (args.length >= sum.length) {
            // sum.length表示函数fn的行参个数
            return sum.apply(null,args)
        }
        return sumCurry(...args)
    }
    if(arg.length >= sum.length) {
    // 这个条件为了sumCurry(1,2,3,4)这种，只调用了一次的情况
        return sum.apply(null,arg)
    } else {
        return _curry
    }
}

sumCurry(1,2,3,4)  // 10
sumCurry(1)(2)(3)(4)  // 10
sumCurry(1,2,3)(4)  // 10
sumCurry(1,2)(3,4)  // 10

上面的做法针对参数已知个数。如果是参数个数不确定呢？

普通函数：

function sum() {
    var arg = Array.prototype.slice.call(arguments)
    return arg.reduce((prve, cur) => {return prve + cur})
}

sum(1) // 1
sum(1,2)  //3
sum(1,2,3)   //6

对于不定参的函数柯里化来说，需要添加一个判断结束的方法调用。如多一层调用、调用valueOf、toString方法等。

几乎所有的数据类型都拥有toString方法和valueOf方法，null除外。

valueOf()会把数据类型转换成原始类型，toString()会把数据类型转换成string类型。这里注意：

正常情况下对象会先调用toString方法，但有运算操作符的情况下会优先调用valueOf方法，无法运算再调用toString方法。

 这里把柯里化函数和目的函数sum合并了：

function sumCurry(...arg) {
    var args = [...arg]
    var _curry = function (...nextArg) {
        if (nextArg.length) {
            args = [...args,...nextArg]
            return _curry
        }    
        return args.reduce((prve, cur) => { return prve + cur})
    }
    _curry.valueOf = function () {
        return args.reduce((prve, cur) => { return prve + cur})
    }
    return _curry
}

sumCurry(1,2)()  // 3
sumCurry(1)(2)(3).valueOf()  // 6
sumCurry(1,2,3)(4)()  // 10
sumCurry(1,2)(3,4)(5).valueOf()  // 15

// 判断返回值
sumCurry(1)(2)(3) == 6 // true