JS进阶篇--JS中的反柯里化( uncurrying)

LdhAndroid 发布于2019-08-22 10:54 / 749人阅读

摘要：最后，我们反过来看，其实反柯里化相当于把原来的形式，转换成了，使得的使用范围泛化了。更抽象地表达，反柯里化，使得原来调用，可以转成形式的调用。

反柯里化

相反，反柯里化的作用在与扩大函数的适用性，使本来作为特定对象所拥有的功能的函数可以被任意对象所用.
即把如下给定的函数签名，

obj.func(arg1, arg2)

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

func(obj, arg1, arg2)

这就是反柯里化的形式化描述。

例如，下面的一个简单实现：

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, ...);

sayHi.call（arg1, arg2, ...), call 函数把 arg1 当做 sayHi的上下文，然后把 arg2,... 等剩下的参数传给sayHi，因此最后相当于 arg1.sayHi(arg2,...);

因此，这相当于 sayHiuncurrying(obj,args) 等于 obj.sayHi(args)。

最后，我们反过来看，其实反柯里化相当于把原来 sayHi(args) 的形式，转换成了 sayHiuncurrying(obj,args)，使得sayHi的使用范围泛化了。更抽象地表达， uncurryinging反柯里化，使得原来 x.y(z) 调用，可以转成 y(x",z) 形式的调用。假设x" 为x或者其他对象，这就扩大了函数的使用范围。

通用反柯里化函数

上面例子中把uncurrying写进了prototype，这不太好，我们其实可以把 uncurrying 多带带封装成一个函数;

var uncurrying= function (fn) {
    return function () {
        var args=[].slice.call(arguments,1);
        return fn.apply(arguments[0],args);        
    }    
};

上面这个函数很清晰直接。
使用时调用 uncurrying 并传入一个现有函数 fn，反柯里化函数会返回一个新函数，该新函数接受的第一个实参将绑定为 fn 中 this的上下文，其他参数将传递给 fn 作为参数。

所以，对反柯里化更通俗的解释可以是函数的借用，是函数能够接受处理其他对象，通过借用泛化、扩大了函数的使用范围。

所以 uncurrying更常见的用法是对 Javascript 内置的其他方法的借调而不用自己都去实现一遍。

文字描述比较绕，还是继续看代码：

var test="a,b,c";
console.log(test.split(","));

var split=uncurrying(String.prototype.split);   //[ "a", "b", "c" ]
console.log(split(test,","));                   //[ "a", "b", "c" ]

split=uncurrying(String.prototype.split) 给 uncurrying 传入一个具体的fn，即String.prototype.split ，split 函数就具有了 String.prototype.split 的功能，函数调用 split(test,",") 时，传入的第一个参数为 split 执行的上下文，剩下的参数相当于传给原 String.prototype.split 函数。

再看一个例子:

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 属性和数组成员。

同样的道理，我们还可以继续有：

var indexof=uncurrying(Array.prototype.indexOf);
$.indexOf = function (obj) {
    return indexof(this,obj);
};
$.push("second");
console.log($.indexOf("first"));              // 0
console.log($.indexOf("second"));             // 1
console.log($.indexOf("third"));              // -1

例如我们在实现自己的类库时，有些方法如果有些方法和原生的类似，那么可以通过 uncurrying 借用原生方法。

我们还可以把 Function.prototype.call/apply 方法 uncurring，例如：

var call= uncurrying(Function.prototype.call);
var fn= function (str) {
    console.log(this.value+str);
};
var obj={value:"Foo "};
call(fn, obj,"Bar!");                       // Foo Bar!

这样可以非常灵活地把函数也当做一个普通“数据”来使用，有函数式编程的赶脚，在一些类库中经常能看到这样的用法。

通用 uncurrying 函数的进击

上面的 uncurrying 函数是比较符合思维习惯容易理解的版本，接下来一路进击，看几个其他版本：

首先，如果B格高一点，uncurrying 也可能写成这样：

var uncurrying= function (fn) {
    return function () {
        var context=[].shift.call(arguments);
        return fn.apply(context,arguments);
    }
};

当然如果还需要再提升B格，那么还可以是这样：

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

参考地址

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

云服务器 GPU云服务器柯里化反柯里化 python 柯里化进阶篇

文章版权归作者所有，未经允许请勿转载,若此文章存在违规行为，您可以联系管理员删除。

转载请注明本文地址：https://www.ucloud.cn/yun/91436.html

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

摘要：作为函数式编程语言，带来了很多语言上的有趣特性，比如柯里化和反柯里化。而反柯里化，从字面讲，意义和用法跟函数柯里化相比正好相反，扩大适用范围，创建一个应用范围更广的函数。作为函数式编程语言，JS带来了很多语言上的有趣特性，比如柯里化和反柯里化。可以对照另外一篇介绍 JS 柯里化的文章一起看~ 1. 简介柯里化，是固定部分参数，返回一个接受剩余参数的函数，也称为部分计算函数，目的是为了缩...

zhjx922 2019-05-22 15:17 评论0 收藏0
关于js中的柯里化（Currying）与反柯里化（Uncurrying）

摘要：今天了解到一个新名词柯里化，研究一番后总结如下一柯里化定义把接受多个参数的函数变换成接受一个单一参数最初函数的第一个参数的函数，并且返回接受余下的参数且返回结果的新函数的技术。如果使用反柯里化，则可以这样写震惊某前端只会，竟月入百万。。。今天了解到一个新名词：柯里化，研究一番后总结如下：一· 柯里化定义把接受多个参数的函数变换成接受一个单一参数(最初函数的第一个参数)的函数，并...

Rocko 2019-08-22 13:53 评论0 收藏0
翻译连载 | JavaScript 轻量级函数式编程-第3章:管理函数的输入 |《你不知道的JS》姊

摘要：但是，对函数式编程而言，这个行为的重要性是毋庸置疑的。关于该模式更正式的说法是偏函数严格来讲是一个减少函数参数个数的过程这里的参数个数指的是希望传入的形参的数量。原文地址：Functional-Light-JS 原文作者：Kyle Simpson－《You-Dont-Know-JS》作者关于译者：这是一个流淌着沪江血液的纯粹工程：认真，是 HTML 最坚实的梁柱；分享，是...

xiaowugui666 2019-08-20 19:08 评论0 收藏0
JS进阶篇--JS中的柯里化(currying)

摘要：何为化柯里化化来源与数学家的名字编程语言也是以他的名字命名。因此柯里化的过程是逐步传参，逐步缩小函数的适用范围，逐步求解的过程。当在多次调用同一个函数，并且传递的参数绝大多数是相同的，那么该函数可能是一个很好的柯里化候选。何为Curry化/柯里化？ curry化来源与数学家 Haskell Curry的名字（编程语言 Haskell也是以他的名字命名）。柯里化通常也称部分求值，其...

young.li 2019-08-22 10:54 评论0 收藏0
JavaScript函数柯里化

摘要：函数柯里化的对偶是，一种使用匿名单参数函数来实现多参数函数的方法。这是基于的富应用开发的方法实现反柯里化可能遇到这种情况拿到一个柯里化后的函数，却想要它柯里化之前的版本，这本质上就是想将类似的函数变回类似的函数。什么是柯里化？官方的说法在计算机科学中，柯里化（英语：Currying），又译为卡瑞化或加里化，是把接受多个参数的函数变换成接受一个单一参数（最初函数的第一个参数）的函数...

tommego 2019-08-21 17:46 评论0 收藏0