函数柯里化简析

2022-06-14

字数： 1.7k字 | 阅读时长： 7min | 阅读量：次

定义

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

属于 函数式编程（Functional programming）范式中的, 函数式编程是与 面向对象编程 和 过程式编程 并列的编程范式。由于是与运筹学有关，其中多与数学相关，不考虑性能。

举例：计算 (a+b)*c 实现函数可以是调用 f(a, b, c)，柯里化方式就是 f(a)(b)(c) 或者 f(a)(b)(c)() 这种方法调用

使用场景

有利于阅读源码，也比较便于数学计算方面的代码阅读

特点

参数复用：利用闭包实现了参数的暂存
提前确认：确定好了每一步输入走的逻辑
延迟运行：利用闭包将函数的定义与执行环境分开

实现

原理

闭包来保存参数
高阶函数实现运算

call 和 apply

call 和 apply 都是改变函数体内部 this 的指向，this 是函数在运行的时候才确定的值，即函数运行时的上下文 context
call 和 apply 作用完全相同，区别是接受参数的方式上。call 是 apply 的一种语法糖。
格式：apply(context, [arguments]) , call(context, param1, param2, ...)

简单函数柯里化

利用函数实现两数相加 a + b 运算：

// 两数相加
function add(x, y) {
    return x + y;
}
add(1, 1)

将函数进行柯里化：

function add(x, y){
    var len = arguments.length;
    if (len < 2 && len > 0) {
        return function (y) {
            console.log(x)
            return x + y
        } // 如果传参是一个的话，返回一个函数，等待第二个参数
    }
    return x + y
}

运行如下：

公共的柯里化函数

// 定义一个createCurry的函数
function createCurry(fn){
    var slice = Array.prototype.slice,  // 从 Array.prototype 中借用 slice 方法帮我们把 arguments 转为一个真正的数组，方便我们更好的操作
    stored_args = slice.call(arguments,1);  // 保存除了第一个参数外的其他参数，因为第一个参数是 需要柯里化的函数，闭包保存
    return function () {
        let new_args = slice.call(arguments), // 将柯里化后传入的新的变量转为数组
        args = stored_args.concat(new_args); // 将 先前传入的保存的变量{第一次调用传的变量} 与 柯里化函数后新传入的{之后传的} 进行 数组的拼接
        return fn.apply(null,args); // 执行 需要被柯里化的函数
    } // 返回柯里化后的函数
}

函数的 arguments 是一个类数组，是有 length 属性的对象。
运行如下：

function add(x, y) {
    return x + y
}
var afterCurryingAdd = createCurry(add, 1); // function () { let new_args = slice.call(arguments), args = stored_args.concat(new_args); return fn.apply(null,args); }
console.log(afterCurryingAdd(2)) // 3

console.log(createCurry(add, 3)(4)) // 7
console.log(createCurry(add)(3, 4)) // 7
console.log(createCurry(add, 3, 4)()) // 7

可以看出，无论参数传入几个，这里只能进行一次函数的柯里化，所以调用的时候，第一步传参调用是得到柯里化的函数，第二步传参调用才是真正的执行函数。

灵活的柯里化函数

希望函数分为多步执行：

// 创建一个可以多步执行的柯里化函数，当参数满足数量时就去执行它：
// 函数公式：fn(x,y,z,w) ==> fn(x)(y)(z)(w);
var createCurry = (fn,...params)=> {
    let args = params || [];
    let fnLen = fn.length; // 指定柯里化函数的参数长度
    return (...res)=> {
        // 通过作用域链获取上一次的所有参数
        let allArgs = args.slice(0);
        // 深度拷贝闭包共用的args参数，避免后续操作影响（引用类型）
        allArgs.push(...res);
        if(allArgs.length < fnLen){
           // 当参数数量小于原函数的参数长度时，递归调用 createCurry 函数
           return createCurry.call(this,fn,...allArgs);  
        }else{
          // 当参数数量满足时，触发函数执行
          return fn.apply(this,allArgs);
        }
    }
}

运行如下：

// 多个参数的普通函数
function add(a,b,c,d){
    return a + b + c + d;
}
// 测试柯里化函数
var afterCurryingAdd = createCurry(add,1); // (...res)=> { let allArgs = args.slice(0); allArgs.push(...res); if(allArgs.length < fnLen){ return createCurry.call(this,fn,...allArgs); } else { return fn.apply(this,allArgs); } }
console.log(afterCurryingAdd(2)(3)(4)); // 10
console.log(createCurry(add,1,2,3,4)()); // 10

当参数符合该函数时，我们需要直接调用函数即可，不要再次调用执行，修改如下：

var createCurry = (fn,...params)=> {
    let args = params || [];
    let fnLen = fn.length; // 指定柯里化函数的参数长度
    if(length === _args.length){
       // 加入判断，如果第一次参数数量以经足够时就直接调用函数获取结果
           return fn.apply(this,args);
        }
    return (...res)=> {
        let allArgs = args.slice(0);
        allArgs.push(...res);
        if(allArgs.length < fnLen){
           return createCurry.call(this,fn,...allArgs);
        }else{
          return fn.apply(this,allArgs);
        }
    }
}

可以控制执行时间的柯里化函数

控制执行时间就是一直返回的是柯里化之后的函数，直到传参足够，并且再次调用一次柯里化的函数才执行，否则不执行，即修改如下：

// 当参数满足，再次执行时调用函数
var createCurry = (fn,...params)=> {
    let args = params || [];
    let fnLen = fn.length; // 指定柯里化函数的参数长度
    //当然这里的判断需要注释掉，不然当它第一次参数数量足够时就直接执行结果了
    //if(length === _args.length){
       // 加入判断，如果第一次参数数量以经足够时就直接调用函数获取结果
           //return fn.apply(this,args);
        //}
    return (...res)=> {
        let allArgs = args.slice(0);
        allArgs.push(...res);
        // 在这里判断输入的参数是否大于0，如果大于0在判断参数数量是否足够，
        // 这里不能用 && ，如果用&& 也是参数数量足够时就执行结果了。
        if(res.length > 0 || allArgs.length < fnLen){ // 这个判断需要自己想想好，看看要什么效果
           return createCurry.call(this,fn,...allArgs);
        }else{
          return fn.apply(this,allArgs);
        }
    }
}
 
// 多个参数的普通函数
function add(a,b,c,d){
    return a + b + c + d;
}
// 测试可控制的柯里化函数
var afterCurryingAdd = createCurry(add,1); // (...res)=> { let allArgs = args.slice(0); allArgs.push(...res); if(res.length > 0 || allArgs.length < fnLen){ return createCurry.call(this,fn,...allArgs); }else{ return fn.apply(this,allArgs); } }
console.log(afterCurryingAdd(2)(3)(4)()); // 10
console.log(afterCurryingAdd(2)(3)()); // (...res)=> { let allArgs = args.slice(0); allArgs.push(...res); if(res.length > 0 || allArgs.length < fnLen){ return createCurry.call(this,fn,...allArgs); }else{ return fn.apply(this,allArgs); } }
console.log(afterCurryingAdd(2)(3)(4)(5)(6)) // 同上，是柯里化的函数
console.log(afterCurryingAdd(2)(3)(4)(5)(6)()) // 10

参数不够时就执行那么就在执行函数柯里化，如果参数够了执行就是在执行了，所以自己在调用 createCurry 的时候，需要对需要柯里化的函数的参数长度有所了解。

参考链接如下：

脚本之家

csdn

阮一峰的博客