搞懂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

### JavaScript 函数柯里化的概念 函数柯里化(Currying)是一种将接受多个参数函数转换为一系列接受单一参数函数的技术。换句话说,柯里化将一个多参数函数转化为一系列嵌套的单参数函数[^4]。这种技术通过部分应用参数的方式,使得函数可以逐步接收输入并返回新的函数,直到所有参数都被提供为止。 ### JavaScript 函数柯里化的实现方法 #### 方法 1:使用闭包实现柯里化 以下是一个简单的加法函数及其柯里化版本: ```javascript // 普通的加法函数 function add(x, y) { return x + y; } // 使用柯里化转换的加法函数 function curryAdd(x) { return function(y) { return x + y; } } const newAdd = curryAdd(2); console.log(newAdd(3)); // 输出 5 ``` 此示例展示了如何通过闭包实现柯里化,其中 `curryAdd` 返回一个新函数,该函数等待第二个参数 `y` 的输入[^3]。 #### 方法 2:通用柯里化函数 为了使柯里化适用于任意参数函数,可以创建一个通用的柯里化函数: ```javascript function curry(fn) { return function curried(...args) { if (args.length >= fn.length) { return fn.apply(this, args); } else { return function (...nextArgs) { return curried.apply(this, args.concat(nextArgs)); }; } }; } // 示例函数 function multiply(a, b, c) { return a * b * c; } const curriedMultiply = curry(multiply); console.log(curriedMultiply(2)(3)(4)); // 输出 24 ``` 上述代码中,`curry` 函数检查传入的参数数量是否满足原函数的要求。如果参数不足,则返回一个新的函数以接收更多参数[^5]。 #### 方法 3:使用 `bind` 方法实现柯里化 JavaScript 的 `bind` 方法也可以用来实现柯里化,尽管它通常用于绑定 `this` 值,但也可以固定某些参数: ```javascript function subtract(a, b) { return a - b; } const curriedSubtract = subtract.bind(null, 10); console.log(curriedSubtract(5)); // 输出 5 ``` 这里,`bind` 方法将第一个参数固定为 `10`,从而实现部分应用的效果[^2]。 ### 总结 函数柯里化在实际开发中具有广泛的应用,可以提高代码的复用性和灵活性。通过闭包、递归或 `bind` 方法,我们可以自定义 `curry` 函数来实现函数柯里化[^2]。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值