我们经常说在Javascript语言中,函数是“一等公民”,它们本质上是十分简单和过程化的。可以利用函数,进行一些简单的数据处理,return 结果,或者有一些额外的功能,需要通过使用闭包来实现,最后经常会return 匿名函数。
如果你对函数式编程有一定了解,函数柯里化(function currying)是不可或缺的,利用函数柯里化,可以在开发中非常优雅的处理复杂逻辑。
柯里化(Currying),维基百科上的解释是,把接受多个参数的函数转换成接受一个单一参数的函数
先看一个简单例子
// 柯里化
var foo = function(x) {
return function(y) {
return x + y
}
}
foo(3)(4) // 7
// 普通方法
var add = function(x, y) {
return x + y;
}
add(3, 4) //7
本来应该一次传入两个参数的add函数,柯里化方法,变成每次调用都只用传入一个参数,调用两次后,得到最后的结果。
再看看,一道经典的面试题。
编写一个sum函数,实现如下功能:
console.log(sum(1)(2)(3)) // 6.
直接套用上面柯里化函数,多加一层return
function sum(a) {
return function(b) {
return function(c) {
return a + b + c;
}
}
}
当然,柯里化不是为了解决面试题,它是应函数式编程而生
还是看看上面的经典面试题。
如果想实现 sum(1)(2)(3)(4)(5)...(n)就得嵌套n-1个匿名函数,
function sum(a) {
return function(b) {
...
return function(n) {
}
}
}
看起来并不优雅,如果我们预先知道有多少个参数要传入,可以利用递归方法解决
var add = function(num1, num2) {
return num1 + num2;
}
// 假设 sum 函数调用时,传入参数都是标准的数字
function curry(add, n) {
var count = 0,
arr = [];
return function reply(arg) {
arr.push(arg);
if ( ++count >= n) {
//这里也可以在外面定义变量,保存每次计算后结果
return arr.reduce(function(p, c) {
return p = add(p, c);
}, 0)
} else {
return reply;
}
}
}
var sum = curry(add, 4);
sum(4)(3)(2)(1) // 10
如果调用次数多于约定数量,sum 就会报错,我们就可以设计成类似这样
sum(1)(2)(3)(4)(); // 最后传入空参数,标识调用结束,
只需要简单修改下curry 函数
function curry(add) {
var arr = [];
return function reply() {
var arg = Array.prototype.slice.call(arguments);
arr = arr.concat(arg);
if (arg.length === 0) { // 递归结束条件,修改为 传入空参数
return arr.reduce(function(p, c) {
return p = add(p, c);
}, 0)
} else {
return reply;
}
}
}
console.log(sum(4)(3)(2)(1)(5)()) // 15
上面针对具体问题,引入柯里化方法解答,回到如何实现创建柯里化函数的通用方法。
同样先看简单版本的方法,以add方法为例,代码来自《JavaScript高级程序设计》
function curry(fn) {
var args = Array.prototype.slice.call(arguments, 1);
return function() {
var innerArgs = Array.prototype.slice.call(arguments);
var finalArgs = args.concat(innerArgs);
return fn.apply(null, finalArgs);
};
}
function add(num1, num2) {
return num1 + num2;
}
var curriedAdd = curry(add, 5);
var curriedAdd2 = curry(add, 5, 12);
alert(curriedAdd(3)) // 8
alert(curriedAdd2()) // 17
上面add函数,可以换成任何其他函数,经过curry函数处理,都可以转成柯里化函数。
这里在调用curry初始化时,就传入了一个参数,而且返回的函数 curriedAdd , curriedAdd2也没有被柯里化。要想实现更加通用的方法,在柯里化函数真正调用时,再传参数,
function curry(fn) {
...
}
function add(num1, num2) {
return num1 + num2;
}
var curriedAdd = curry(add);
curriedAdd(3)(4) // 7
每次调用curry返回的函数,也被柯里化,可以继续传入一个或多个参数进行调用,
跟上面sum(1)(2)(3)(4) 非常类似,利用递归就可以实现。 关键是递归的出口,这里不能是传入一个空参数的调用, 而是原函数定义时,参数的总个数,柯里化函数调用时,满足了原函数的总个数,就返回计算结果,否则,继续返回柯里化函数。
原函数的入参总个数,可以利用length 属性获得
function add(num1, num2) {
return num1 + num2;
}
add.length // 2
结合上面的代码,
var curry = function(f) {
var len = f.length;
return function t() {
var innerLength = arguments.length,
args = Array.prototype.slice.call(arguments);
if (innerLength >= len) { // 递归出口,f.length
return f.apply(undefined, args)
} else {
return function() {
var innerArgs = Array.prototype.slice.call(arguments),
allArgs = args.concat(innerArgs);
return t.apply(undefined, allArgs)
}
}
}
}
// 测试一下
function add(num1, num2) {
return num1 + num2;
}
var curriedAdd = curry(add);
add(2)(3); //5
// 一个参数
function identity(value) {
return value;
}
var curriedIdentify = curry(identify);
curriedIdentify(4) // 4
到此,柯里化通用函数可以满足大部分需求了。
在使用 apply 递归调用的时候,默认传入 undefined, 在其它场景下,可能需要传入 context, 绑定指定环境
实际开发,推荐使用 lodash.curry , 具体实现,可以参考下curry源码
讲了这么多curry函数的不同实现方法,那么实现了通用方法后,在那些场景下可以使用,或者说使用柯里化函数是否可以真实的提高代码质量,下面总结一下使用场景
参数复用
在《JavaScript高级程序设计》中简单版的curry函数中
var curriedAdd = curry(add, 5)
在后面,使用curriedAdd函数时,默认都复用了5,不需要重新传入两个参数
延迟执行
上面传入多个参数的sum(1)(2)(3),就是延迟执行的最后例子,传入参数个数没有满足原函数入参个数,都不会立即返回结果。
类似的场景,还有绑定事件回调,更使用bind()方法绑定上下文,传入参数类似,
addEventListener('click', hander.bind(this, arg1,arg2...))
addEventListener('click', curry(hander))
延迟执行的特性,可以避免在执行函数外面,包裹一层匿名函数,curry函数作为回调函数就有很大优势。
函数式编程中,作为compose, functor, monad 等实现的基础
有人说柯里化是应函数式编程而生,它在里面出现的概率就非常大了,在JS 函数式编程指南中,开篇就介绍了柯里化的重要性。
函数柯里化可以用来构建复杂的算法 和 功能, 但是滥用也会带来额外的开销。
从上面实现部分的代码中,可以看到,使用柯里化函数,离不开闭包, arguments, 递归。
闭包,函数中的变量都保存在内存中,内存消耗大,有可能导致内存泄漏。
递归,效率非常差。
arguments, 变量存取慢,访问性很差。
理论计算机科学中,柯里化提供了在简单的理论模型中,比如:只接受一个单一参数的lambda演算中,研究带有多个参数的函数的方式。 函数柯里化的对偶是Uncurrying,一种使用匿名单参数函数来实现多参数函数的方法。
很多刚刚了解函数式编程的人会对偏函数应用(partial application)和柯里化(currying)之间的区别感到困惑。实际上,直到现在也很少在 JavaScript 中看到柯里化的实际使用,许多叫curry()的工具函数并不是柯里化函数。它们其实是偏函数!
柯里化,是一个逐步接收参数的过程。在接下来的剖析中,你会深刻体会到这一点。 反柯里化,是一个泛型化的过程。它使得被反柯里化的函数,可以接收更多参数。目的是创建一个更普适性的函数,可以被不同的对象使用。
如果我们需要设计一个函数来计算每个月的开销,在每天结束之前,我们需要记录当天花费了多少。在月底的时候计算出这个月一共开销了多少? 可以看出在性能上和方式二差不多,但是这样做更加通俗易懂了,当然在实际开发中,我们一般会封装为对象。
柯里化(Currying),又称部分求值(Partial Evaluation),是把接收多个参数的函数变成接受一个单一参数(最初函数的第一个参数)的函数,并且返回接受剩余的参数而且返回结果的新函数的技术。
把接收多个参数的函数变换成接收一个单一参数(最初函数的第一个参数)的函数,并返回接受剩余的参数而且返回结果的新函数的技术。其由数学家Haskell Brooks Curry提出,并以curry命名。
最近在社区阅读技术博客的时候偶然间看到了函数柯里化几个字,还有要求手写js函数柯里化,心想是柯里化是什么高级的东西?没听说过啊?就带着问题出发,专门去学习了一下,做了一些整理。
函数式编程是一种如今比较流行的编程范式,它主张将函数作为参数进行传递,然后返回一个没有副作用的函数,说白了,就是希望一个函数只做一件事情。这种编程思想涵盖了三个重要的概念:
在计算机科学中,柯里化(Currying)是把接受多个参数的函数变换成接受一个单一参数(最初函数的第一个参数)的函数,并且返回接受余下的参数且返回结果的新函数的技术。这个技术由 Christopher Strachey 以逻辑学家 Haskell Curry 命名的
很多同学都能看出来,这些写是非常傻的,因为函数f1和f是等效的,我们直接令var f1 = f;就行了,完全没有必要包裹那么一层。但是,下面一段代码就未必能够看得出问题来了:
内容以共享、参考、研究为目的,不存在任何商业目的。其版权属原作者所有,如有侵权或违规,请与小编联系!情况属实本人将予以删除!