JavaScript函数柯里化

1.什么是柯里化

柯里化是把接受多个参数的函数变换成接受一个单一参数的函数，并且返回接受余下参数的新函数的技术。函数柯里化的主要作用和特点就是参数复用、提前返回和延迟执行。

2. 温习简单实现

2.1. 基础实现

// 普通的sum函数
function sum(x, y) {
    return x + y;
}

//Currying之后
function curryingSum(x) {
    return function (y) {
        return x + y;
    }
}

sum(1, 2); // 3
curryingSum(1, 2); //3

2.2. 参数复用

// 正常正则验证字符串 reg.test(txt)
function checkString(reg, txt) {
    return reg.test(txt);
}
console.log('普通---', checkString(/\d+/g, 'test')); // false
console.log('普通---', checkString(/[a-z]+/g, 'test')); // true

// Currying后
function curryingCheckString(reg) {
    return function (txt) {
        return reg.test(txt)
    }
}
var hasNum = curryingCheckString(/\d+/g);
var hasLetter = curryingCheckString(/[a-z]+/g);
console.log(hasNum('test001')); // true
console.log(hasNum('test me')); // false
console.log(hasLetter('343')); // false

3. 通用的柯里化原生实现

// // 支持多参数传递的函数柯里化
function progressCurrying(fn, args) {
    var that = this;
    var newArgs = args || [];
    return function () {
        var _args = Array.prototype.slice.call(arguments);
        _args = Array.prototype.concat.call(newArgs, _args)
        // 如果参数个数小于最初的该函数本身期待的参数fn.length，则递归调用，继续收集参数
        if (_args.length < fn.length) {
            return progressCurrying.call(that, fn, _args)
        }
        // 参数收集完毕，则执行fn
        return fn.apply(that, _args)
    }
}



function multiFn(a, b, c) {
    return a * b * c;
}
let fn = progressCurrying(function (a, b, c, d, e) {
    console.log(a + b + c + d + e)
})
fn(1, 2, 3, 4, 5)  // 15
fn(1, 2)(3, 4, 5)
fn(1, 2)(3)(4)(5)
fn(1)(2)(3)(4)(5)
var multi = progressCurrying(multiFn);

console.log(multi(2)(3)(4)); //24
console.log(multi(2,3,4)); //24
console.log(multi(2)(3,4)); //24
console.log(multi(2,3)(4)); //24

add面试题

function adds(...args) {
       let nums = args.reduce((pre, cur) => pre + cur, 0)
       return function fn(...ar) {
           nums = nums + ar.reduce((pre, cur) => pre + cur, 0)
           adds = nums
           return fn
       }
   };

   adds(1, 2)(3);
   console.log(adds); // 6