浅析函数柯里化与反柯里化

最新推荐文章于 2026-08-04 14:29:48 发布
原创 最新推荐文章于 2026-08-04 14:29:48 发布 · 1.1k 阅读 · 7 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
收录于
JS基础

当前文章被收录于：

JS基础
4 篇文章 0 人学习
订阅专栏 查看详情

浅析函数柯里化与反柯里化

1. 柯里化

柯里化（Currying），又称部分求值（Partial Evaluation），可以理解为提前接收部分参数，延迟执行，不立即输出结果，而是返回一个接受剩余参数的函数。因为这样的特性，也被称为部分计算函数。柯里化，是一个逐步接收参数的过程。

1.1 作用

柯里化有3个常见作用：

  1. 参数复用
  2. 提前返回
  3. 延迟计算/运行

先看一个简单示例，实现 add(1)(2, 3)(4)() = 10 的效果：

let currying = (fn) =>  {
    let arr = [];
    // 相当于参数 fn 及 return 语句之前定义的变量都被保存下来了
    let next = (...args) => {
        if (args.length > 0) {
            arr.push(...args);
            // 实现链式调用
            return next;
        } else {
            return fn(...arr);
        }
    }
    return next;
    // ES5 写法
    // return function() {
    //     if (arguments.length === 0) {
    //         return fn.call(null, arr);
    //     } else {
    //         arr = arr.concat([].slice.call(arguments));
    //     }
    // }

}

let add = currying((...args) => {
    let sum = 0;
    for (let item of args) {
        sum += item;
    }
    return sum;
})

add(1);
add(2, 3);
add(4);
let sum = add(5)();
console.log(sum); // 15

从上例可以看出，柯里化有延迟计算/运行的作用，而且可以保存变量，因此，我们可以通过柯里化实现参数复用：

// 监听事件
function nodeListen(node, eventName){
    return function(fn){
        node.addEventListener(eventName, function(){
            fn.apply(this, Array.prototype.slice.call(arguments));
        }, false);
    }
}

var bodyClickListen = nodeListen(document.body, 'click');
bodyClickListen(function(){
    console.log('first listen');
});

bodyClickListen(function(){
    console.log('second listen');
});

// 有点懒，就不搞成 ES6 的写法了

提前返回，很常见的一个例子，兼容现代浏览器以及IE浏览器的事件添加方法，可以减少判断次数（参考张鑫旭的JS中的柯里化(currying)）：

// 原先的写法
var addEvent = function(el, type, fn, capture) {
    if (window.addEventListener) {
        el.addEventListener(type, function(e) {
            fn.call(el, e);
        }, capture);
    } else if (window.attachEvent) {
        el.attachEvent("on" + type, function(e) {
            fn.call(el, e);
        });
    } 
};

// 柯里化，只走一次判断
var addEvent = (function(){
    if (window.addEventListener) {
        return function(el, sType, fn, capture) {
            el.addEventListener(sType, function(e) {
                fn.call(el, e);
            }, (capture));
        };
    } else if (window.attachEvent) {
        return function(el, sType, fn, capture) {
            el.attachEvent("on" + sType, function(e) {
                fn.call(el, e);
            });
        };
    }
})();

1.2 函数的执行时机

以 add(1)(2, 3)(4)(5) = 15 为例，如何知道柯里化函数的执行时机？

总结了3种方法：

  • 判断最后一次调用时传入的参数特征

    以上文中的将 add 函数柯里化的例子 ，判断传入参数的个数以结束函数调用，但这种方法不够优雅

  • 隐式类型转化：valueOf和toString

    修改上文 add 函数柯里化的例子

    let currying = (fn) => {
    let arr = [];
    let next = (...args) => {
        arr.push(...args);
        return next;
    }

    // 字符类型
    next.toString = () => {
        console.log('toString')
        return fn(...arr);
    };

    // 数值类型
    next.valueOf = () => {
        console.log('valueOf')
        return fn(...arr);
    };

    return next;
}

let add = currying((...args) => {
    let sum = 0;
    for (let item of args) {
        sum += item;
    }
    return sum;
})
// 注意 ‘+’，这里进行了隐式类型转化
let sum = +add(1)(2, 3)(4);
console.log(sum);
//valueOf
//10

    如果我们没有重新定义 valueOf 和 toString，其**隐式转换会调用默认的toString()**方法，将函数本身内容作为字符串返回；如果我们自己重新定义toString/valueOf方法，其中 valueOf 比 toString 优先级更高

    可以参考 有趣的JavaScript隐式类型转换，简单了解一下隐式类型转换

  • 判断原函数（被柯里化函数的参数数量）

    主要用到了函数的 length 属性，示例参照下一节通用柯里化函数

1.3 通用柯里化函数

三行代码实现柯里化函数：

const curry = (fn) => {
    if (fn.length <= 1) return fn;

    const generator = (args) => (args.length === fn.length ? fn(...args) : arg => generator([...args, arg]));

    // 上述函数拆分后
    // const generator = (args) => {
    //     if (args.length === fn.length) {
    //         return fn(...args);
    //     } else {
    //         return arg => generator([...args, arg])
    //     }
    // }

    return generator([], fn.length);
};

const sum = (a, b, c) => a + b + c;
const curriedSum = curry(sum);
const res = curriedSum(1)(2)(3)
console.log(res); // 6

还有一个一行实现的：

const curry = (fn, arr = []) => (...args) => (
  arg => arg.length === fn.length
    ? fn(...arg)
    : curry(fn, arg)
)([...arr, ...args])

emmmmm，我的小脑筋不适合这个…

1.4 Function.prototype.bind 方法也是柯里化应用

与 call/apply 方法直接执行不同，bind 方法将第一个参数设置为函数执行的上下文，其他参数依次传递给调用方法（函数的主体本身不执行，可以看成是延迟执行），并动态创建返回一个新的函数（绑定函数）， 这符合柯里化特点。

function addArguments(arg1, arg2) {
    return arg1 + arg2
}

// 创建一个函数，它拥有预设的第一个参数
var addThirtySeven = addArguments.bind(null, 37);

var result1 = addThirtySeven(5);
// 37 + 5 = 42 

var result2 = addThirtySeven(6, 10);
// 37 + 6 = 42 ，第二个参数被忽略

2. 反柯里化

反柯里化，是一个泛型化的过程。它使得被反柯里化的函数，可以接收更多参数。使本来只有特定对象才适用的方法，扩展到更多的对象。

即把如下给定的函数签名，

obj.func(arg1, arg2)

转化成一个函数形式，签名如下：

func(obj, arg1, arg2)

2.1 简单实现

Function.prototype.uncurrying = function() {
    var that = this;
    return function() {
        return Function.prototype.call.apply(that, arguments);
    }
};

function sayHi () {
    return "Hello " + this.value +" "+[].slice.call(arguments);
}
var sayHiuncurrying=sayHi.uncurrying();
console.log(sayHiuncurrying({value:'world'},"hahaha"));
  • uncurrying是定义在Function的prototype上的方法，因此对所有的函数都可以使用此方法。调用时候：sayHiuncurrying=sayHi.uncurrying()，所以uncurrying中的 this 指向的是 sayHi 函数; （一般原型方法中的 this 不是指向原型对象prototype，而是指向调用对象，在这里调用对象是另一个函数，在javascript中函数也是对象）
  • call.apply(that, arguments) 把 that 设置为 call 方法的上下文，然后将 arguments 传给 call方法。上例中，that 实际指向 sayHi，所以调用 sayHiuncurrying(arg1, arg2, ...) 相当于 sayHi.call(arg1, arg2, ...)（apply的作用）;
  • sayHi.call（arg1, arg2, ...), call 函数把 arg1 当做 sayHi的上下文，然后把 arg2,... 等剩下的参数传给 sayHi，因此最后相当于 arg1.sayHi(arg2,...)（call的作用）;
  • 因此，这相当于 sayHiuncurrying(obj,args) 等于 obj.sayHi(args)。

2.2 通用反柯里化函数

var uncurrying= function (fn) {
    return function () {        
        return Function.prototype.call.apply(fn,arguments);
    }
};

举例：

var $ = {};
console.log($.push);                          // undefined
var pushUncurrying = uncurrying(Array.prototype.push);
$.push = function (obj) {
    pushUncurrying(this,obj);
};
$.push('first');
console.log($.length);                        // 1
console.log($[0]);                            // first
console.log($.hasOwnProperty('length'));      // true

这里模仿了一个“类似jquery库” 实现时借用 Array 的 push 方法。 我们知道对象是没有 push 方法的，所以 console.log(obj.push) 返回 undefined，可以借用Array 来处理 push，由原生的数组方法（js引擎）来维护 伪数组对象的 length 属性和数组成员。

参考文献

JS中的柯里化(currying)

JavaScript 函数式编程技巧 - 柯里化

柯里化与反柯里化

三行代码实现 JS 柯里化

浅析 JavaScript 中的 函数 uncurrying 反柯里化

标签
#函数 #柯里化 #反柯里化
理解函数柯里化
dorabighead的博客
02-02 1133
在数学和计算机科学中，柯里化是一种将使用多个参数的一个函数转换成一系列使用一个参数的函数的技术。有没有一种感觉读完和没读一样哈哈咱们来看一个案例吧，不看案例还真理解不了// 6这个是一个累加函数，接收三个参数，但是假设我有这样一种需求就是前两个参数不变，然后最后一个参数可以随意。很多人，第一想法就是传入前两个不改不就行了。其实这个也能说是一个解决方案，但是代码得优雅，经常一调用就得穿前面那俩个固定的参数是不是很繁琐而且容易出错，出错之后还不好排查，对吧。
前端进阶｜一文理解柯里化的逆操作，什么是反柯里化
前端梦工厂
09-04 1478
反柯里化（Uncurrying）是指将柯里化函数转换为接受多个参数的普通函数的过程。在函数柯里化中，一个多参数的函数被转换为接受一个参数并返回一个新函数的一系列嵌套函数。而反柯里化则是将这些嵌套函数重新组合成一个多参数的函数。具体来说，反柯里化是将一系列通过柯里化得到的函数，重新组合成一个函数，使得这个函数能够接受与原来多参数函数相同数量的参数，并且处理这些参数。简而言之，反柯里化是将柯里化函数还原成普通函数。
函数柯里化
gaotlantis的博客
01-03 932
函数柯里化（Currying）是将一个接受多个参数的函数转换为一系列接受单一参数的函数的过程。换句话说，柯里化是通过固定一个参数，返回一个新函数，该函数继续接受下一个参数，直到所有参数都被提供，从而最终得到结果。函数柯里化是一种将多参数函数转换为接受单一参数的函数的技术，它使得函数更加灵活、可组合和易于复用。应用场景部分应用：提前填充函数的一部分参数。事件处理：为特定的事件创建定制化的回调函数。函数组合：将多个小函数组合成一个更大的函数。动态配置：逐步提供函数的参数，灵活地生成配置。
函数 tostring_什么是函数的柯里化与反柯里化？看了这篇，你就懂了
weixin_39915721的博客
12-05 523
前言首先，柯里化这种东西，可以理解为高阶函数的一种特殊用法(为啥一种特殊用法也要新取个名字呢？)，高阶函数大家都知道是在传递参数的时候可以传递一个函数。柯里化可以理解为提前接收部分参数，延迟执行，不立即输出结果，而是返回一个接受剩余参数的函数。因为这样的特性，也被称为部分计算函数。柯里化，是一个逐步接收参数的过程。在接下来的剖析中，你会深刻体会到这一点。 反柯里化，是一个泛型化的过程。它使得被反柯...
柯里化与反柯里化详解
油墨香^-^的博客
02-09 453
柯里化（Currying）和反柯里化（Uncurrying）是函数式编程中的两种重要技术。柯里化将多参数函数转换为链式调用的单参数函数，支持参数复用、函数组合和延迟执行，适用于API构建、配置函数等场景。反柯里化是其逆向过程，将柯里化函数还原为普通函数，便于方法借用和接口适配。两者各有优势：柯里化增强灵活性和复用性，反柯里化简化调用并兼容面向对象代码。实际开发中需根据需求选择，平衡性能与可读性，遵循团队规范。示例展示了如何混合使用这两种技术优化数据处理流程。
浅析 JavaScript 中的 函数 uncurrying 反柯里化
12-09 137
柯里化 　　柯里化又称部分求值，其含义是给函数分步传递参数，每次传递参数后部分应用参数，并返回一个更具体的函数接受剩下的参数，这中间可嵌套多层这样的接受部分参数函数，直至返回最后结果。 　　因此柯里化的过程是逐步传参，逐步缩小函数的适用范围，逐步求解的过程。 　　请见我的另一篇博客· 浅析 JavaScript 中的 函数 currying 柯里化 　　反柯里化 　　相反，反柯里化的作用
柯里化概念浅析
两只鱼，鱼鱼鱼鱼鱼
07-16 991
柯里化的核心：函数分解和延迟执行。通过闭包等方式逐步传递参数，直到所有参数收集完毕后再执行原函数
浅析 JavaScript 中的 函数 currying 柯里化
weixin_30505485的博客
08-04 147
何为Curry化/柯里化？ curry化来源与数学家 Haskell Curry的名字 （编程语言 Haskell也是以他的名字命名）。 柯里化通常也称部分求值，其含义是给函数分步传递参数，每次传递参数后部分应用参数，并返回一个更具体的函数接受剩下的参数，这中间可嵌套多层这样的接受部分参数函数，直至返回最后结果。 因此柯里化的过程是逐步传参，逐步缩小函数的适用范围，逐步求解的过程。 柯里化一个求和...
闭包、偏函数(偏应用函数)、函数柯里化 浅析
weixin_45207388的博客
11-13 576
闭包 概念：在函数的作用域外可以引用函数内部的变量 或调用方法内部的匿名函数时，函数内可引用外部函数的变量 scala 代码 ```scala object MyClosure{ def closure(): Int => Unit = { val a = 10 (x: Int) => println(a + x) // 返回一个函数 } def main(args...
JavaScript 反柯里化
weixin_30709635的博客
12-09 151
浅析 JavaScript 中的 函数 uncurrying 反柯里化 柯里化 柯里化又称部分求值，其含义是给函数分步传递参数，每次传递参数后部分应用参数，并返回一个更具体的函数接受剩下的参数，这中间可嵌套多层这样的接受部分参数函数，直至返回最后结果。因此柯里化的过程是逐步传参，逐步缩小函数的适用范围，逐步求解的过程。请见我的另一篇博客· 浅析 JavaScript 中的 函数 curry...
Javaslang柯里化原理浅析
low_125的博客
07-11 335
Lambda柯里化函数，按流程走一遍，解决一些疑惑。
Python函数浅析（三）——柯里化装饰器
欢迎来到小木虫1314的博客
06-19 1620
装饰器是学Python的必须路程，是非常重要的一点！那什么是柯里化装饰器，什么又是柯里化呢! 柯里化就是将原来接收两个参数的函数变成接收一个参数的函数的过程，新的函数返回一个以原来第二个参数为参数的函数！似乎与返回函数有点类似(⊙o⊙)… 在学装饰器之前最好先学完返回函数和高阶函数！ 装饰器顾名思义就是具有包装的作用，在Python中装饰器就是对一个既定的函数功能进行包装，增添新的功能，但是...
C#委托与函数式编程：从Action/Func到柯里化实战
最新发布
weixin_33910759的博客
08-04 354
在C#编程中，委托是实现回调、事件处理和异步操作的核心机制，它允许将方法作为参数传递，极大地提升了代码的灵活性和模块化。其原理是通过类型安全的函数指针封装方法调用，支持同步与异步执行模式。这一技术价值在于解耦调用者与被调用者，促进代码复用和可测试性，广泛应用于事件驱动架构、LINQ查询以及任务调度等场景。匿名方法和Lambda表达式作为委托的简洁语法糖，进一步简化了代码书写，而泛型委托Action和Func则提供了标准化的契约，成为现代C#开发的基础构件。在此基础上，函数式编程思想如柯里化（Currying
arg是什么函数_浅析函数式编程与前端
weixin_39574928的博客
11-27 460
毕业三年，市面上听说过的互联网公司几乎都面试了一遍，函数式编程似乎是一个面试官很感兴趣的话题，几乎有一半的面试官都会问到对函数式编程的理解，尤其是这次回成都的几场面试。每每遇到这个问题，我总是简单的说几句自己的看法，然后快速转移话题企图掩盖自己对函数式编程的无知。本周的“思考沉淀”就回忆和总结一下对函数式编程的理解。什么是函数式编程我们常见的编程范式有两种：命令式和声明式，比如我们熟悉的面向对象思...
浅析JavaScript函数式编程
大转转FE
03-17 1000
前言随着React的流行，函数式编程在前端领域备受关注。尤其近几年，越来越多的类库偏向于函数式开发：lodash/fp，Rx.js、Redux的纯函数，React16.8推出的hooks，...
浅析函数式编程
VFrank
12-03 267
浅析函数式编程 以函数抽象为单元 function parseAge(age) { if (!_.isString(agr)) { throw new Error('Expecting is String'); } console.log('告警：接收到参数，准备类型转化'); var tem...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值