We read every piece of feedback, and take your input very seriously.
To see all available qualifiers, see our documentation.
Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.
By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.
Already on GitHub? Sign in to your account
原文地址,译文如下
我最近使用Ramda实现函数式组合的文章涉及到一个重要的主题。为了使用Ramda的方式做某种组合,我们需要这些方法被柯里化。
柯里化是啥,能吃吗?
实际上,柯里化 是从 Haskell 来的。Haskell是第一个研究这种技术的。(是的,他们用自己的名字命名了一个函数式编程语言。不仅如此,Curry的中间初始是B,或者当然代表的是Brainf*ck)
柯里化
B
柯里化是这么一个过程,它一个本来需要多个参数的方法转化为这样一种方法,这个方法在传递更少参数之后,返回一个新方法,返回的这个新方法会等待获取余下的参数。
基本的例子看起来像这样,这是一个普通的函数:
// 没有柯里化的版本 var formatName1 = function(first, middle, last) { return first + middle + ' ' + last; } formatName1('John', 'Paul', 'Jones'); // => 'John Paul Jones' // (呃, 是音乐家或者海军上将?) formatName1('John', 'Paul') // => 'John Paul undefined'
但是一个柯里化的版本就更加有用了
// 柯里化的版本 var formatName2 = R.curry(function(first, middle, last) { return first + ' ' + middel + ' ' + last; }); formatName2('John', 'Paul', 'Jones'); // => 'John Paul Jones' (肯定是个音乐家) var jp = formatName2('John', 'Paul'); // => 返回一个方法 jp('Jones'); // => 'John Paul Jones' (maybe this one's the admiral) jp('Stevens'); //=> 'John Paul Stevens' (the Supreme Court Justice) jp('Pontiff'); //=> 'John Paul Pontiff' (ok, so I cheated.) jp('Ziller'); //=> 'John Paul Ziller' (magician, a wee bit fictional) jp('Georgeandringo'); //=> 'John Paul Georgeandringo' (rockers)
或者
['Jones', 'Stevens', 'Eiller'].map(jp); //=> ['John Paul Jones', 'John Paul Stevens', 'John Paul Ziller']
你也可以在多次这样传递
var james = formatName2('James'); // => return a function james('Byron', 'Dean'); // => 'James Byron Dean'(rebel) var je = james('Earl'); // 也会返回一个方法 je('Carter'); // => 'James Earl Carter'(president) je('Jones'); // => 'James Earl Jones' (actor, Vader)
有些人会认为我们在做的应该叫"部分应用"更加合适,并且"柯里化"应该只是用在这种情况:返回的方法只接收一个参数,其他每个参数都使用一个独立的新方法处理直到所有必须的参数都被提供。这些人可以继续这样迷信(意译)。
补充: 其实这里就是使用闭包给方法绑定了数据,通过返回的函数在之后的调用中复用之前绑定的数据。这里使用的例子是一个经典的场景,叫做 惰性求值。
惰性求值
下面是个更有意义的例子。如果你想求一个数字集合的和,你可以这么做:
// 普通JS var add = function(a, b) {return a + b;}; var numbers = [1, 2, 3, 4, 5]; var sum = numbers.reduce(add, 0); // => 15
如果你想写一个通用的函数来计算数字列表的总数,你可能会这么写:
var total = function(list) { return list.reduce(add, 0); } var sum = total(numbers); // => 15
在 Ramda里面, total 和 sum 非常相似。亦可以这样定义 sum:
total
sum
var sum = R.reduce(add, 0, numbers); // => 15
但是因为 reduce 是一个柯里化过的方法,但你不传最后一个参数的时候,就像在上面你自己定义的 total 函数一样:
reduce
// 在 Ramda 里 var total = R.reduce(add, 0); // 返回一个柯里化之后的方法
你仅仅拿到一个方法你可以这样调用:
var sum = total(numbers); // => 15
再次注意方法的定义和方法应用于数据上是多么相似
var total = R.reduce(add, 0); // => function var sum = R.reduce(add, 0, numbers); // => 15
所以你是一个web开发,是吧?你需要发一个AJAX请求到服务器?你需要使用 Promise?(起码我希望是这样)你需要操作返回的数据,过滤它,取得子集?或者你做服务器端开发?你异步查询SQL数据库,并且操作这些结果?
我能建议你做的最好的事情是你可以看看前端开发专家Jackson的精彩文章 为什么柯里化有帮助?。这是我看过最精彩的文章。如果你是个通过视频学习者,花半个小时看下Dr. Boolean的视频 Underscore,你做错了(不要在意标题,他没有花费他多时间实际吐槽工具库)。
真的去做。看看这些,它们解释得比我好,你已经看出来我多啰嗦了,巴拉巴拉。如果你已经看过这些,你可以跳过余下的章节。他们已经比我说得更好了。
该说的我都说了。
想象我们要获取像下面这样的数据
var data = { result: "SUCCESS", interfaceVersion: "1.0.3", requested: "10/17/2013 15:31:20", lastUpdated: "10/16/2013 10:52:39", tasks: [ {id: 104, complete: false, priority: "high", dueDate: "2013-11-29", username: "Scott", title: "Do something", created: "9/22/2013"}, {id: 105, complete: false, priority: "medium", dueDate: "2013-11-22", username: "Lena", title: "Do something else", created: "9/22/2013"}, {id: 107, complete: true, priority: "high", dueDate: "2013-11-22", username: "Mike", title: "Fix the foo", created: "9/22/2013"}, {id: 108, complete: false, priority: "low", dueDate: "2013-11-15", username: "Punam", title: "Adjust the bar", created: "9/25/2013"}, {id: 110, complete: false, priority: "medium", dueDate: "2013-11-15", username: "Scott", title: "Rename everything", created: "10/2/2013"}, {id: 112, complete: true, priority: "high", dueDate: "2013-11-27", username: "Lena", title: "Alter all quuxes", created: "10/5/2013"} // , ... ] };
并且我们需要一个方法 getIncompleteTaskSummaries 接收一个 membername 参数,然后从服务器(后者其他地方)获取数据,选择没有完成的会员,返回他们的ids,priorities, titles和due dates,根据due date排序。实际上,它返回一个应该在排序列表里面resolve的Promise。
getIncompleteTaskSummaries
membername
如果你传递 "Scott" 给 getIncompleteTaskSummaries,它可能会返回
[ {id: 110, title: "Rename everything", dueDate: "2013-11-15", priority: "medium"}, {id: 104, title: "Do something", dueDate: "2013-11-29", priority: "high"} ]
好啦,我们开始,下面的code看起来熟悉吗?
getIncompleteTaskSummaries = function(membername) { return fetchData() .then(function(data) { return data.tasks; }) .then(function(tasks) { var results = []; for (var i = 0, len = tasks.length; i < len; i++) { if (tasks[i].username == membername) { results.push(tasks[i]); } } return results; }) .then(function(tasks) { var results = []; for (var i = 0, len = tasks.length; i < len; i++) { if (!tasks[i].complete) { results.push(tasks[i]); } } return results; }) .then(function(tasks) { var results = [], task; for (var i = 0, len = tasks.length; i < len; i++) { task = tasks[i]; results.push({ id: task.id, dueDate: task.dueDate, title: task.title, priority: task.priority }) } return results; }) .then(function(tasks) { tasks.sort(function(first, second) { var a = first.dueDate, b = second.dueDate; return a < b ? -1 : a > b ? 1 : 0; }); return tasks; }); };
如果代码看起来像下面这样是不是更美妙?
var getIncompleteTaskSummaries = function(membername) { return fetchData() .then(R.get('tasks')) .then(R.filter(R.propEq('username', membername))) .then(R.reject(R.propEq('complete', true))) .then(R.map(R.pick(['id', 'dueDate', 'title', 'priority']))) .then(R.sortBy(R.get('dueDate'))); };
如果这样,那么柯里化会很适合你 。所有在这个代码块中提到的Ramda方法都被柯里化了。(实际上,所有超过一个参数的Ramda方法都被柯里化了,只有一些必要的例外。)在所有的情况下,柯里化让组合这些方法到一个优雅的块中变得简单。
让我们看看发生了什么。
get (也用 prop)是这样定义的:
get
prop
ramda.get = curry(function(name, obj) { return obj[name]; })
但是当我们像上面一样调用它,我们只是给了第一个参数 name,正如我们讨论的,这意味着我们会得到一个等待通过第一个then方法传递obj参数的方法,就是下面这样
name
.then(R.get('tasks'))
可以认为是下面的简化写法
.then(function(data) { return data.tasks; })
下面是 propEq,被定义为
propEq
ramda.propEq = curry(function(name, val, obj) { return obj[name] === val; });
所以当我们通过 username 和 membername 调用它的时候(后面的参数被作为参数传递给我们的方法),柯里化给我们返回了一个新方法,等价于
username
funciton(obj) { return obj['username'] === membername; }
membername的值被绑定为传给我们的值。
这个方法之后被传给 filter。
filter
Ramda的 filter 方法就像在 Array.prototype 上的原生filter方法,但是函数签名是
Array.prototype
ramda.filter = curry(function(predicate, list) { });
所以我们已经柯里化过了,只需要传递 predicate 参数,并且前一步的tasks列表不需要。(我告诉过你所有的东西已经被柯里化了,没有吗?)
predicate
我们对于 propEq('complete', true) -> reject 跟 propEq('username', membername) -> 做了同样的事情。filter.Reject 跟 filter 是一样的,除了它会反转语义。它只保留哪些 predicate 返回 false的值。
propEq('complete', true) -> reject
propEq('username', membername) ->
filter.Reject
false
好了,你还在读吗?我们手指都累了。(真的要学学touch-type了)你真的不需要我来解释最后两行了,对吧?真的?你确定?好吧,好吧!是的!...是的,我说过我会的!
所以接下来我们看
R.pick(['id', 'dueDate', 'title', 'priority'])
pick 接收一个属性名数组和一个对象,并且返回一个新的对象,这个对象会把原来的属性拷贝过来。因为我们只传递了属性名,我们只要给它传递一个对象,就能得到一个会返回新对象的方法。这个方法被传递给 R.map 函数。跟 filter 一样,跟原生方法的版本工作方式相同,但是函数签名不同:
pick
R.map
ramda.map = curry(function(fn, list) { /* ... */ });
这里再多嘴一下 -- 我已经说过我很乏味 -- 这个方法已经柯里化过了,因为我们只是传递了 pick 函数(柯里化后)的输出,而不是列表,then 会调用使用tasks列表调用这个方法。
then
好啦,记得坐在学校教室等待下课?钟表上的分针卡住了,秒针像是被糖蜜粘住了吗?老师成天唠叨一遍又一遍同样的事情。还记得吗?然后也许就是两分钟要结束前那一刻,结束尽在眼前:哈利路亚!我想这个例子完了之后我们就到了,就剩这个了:
.then(R.sortBy(R.get('dueDate')));
我们已经说过 get 方法了.就像这样柯里化之后,它返回一个方法,这个方法接受一个对象并且返回 dueDate 属性.我们把它传递给 sortBy 方法,这个方法接收一个列表并且基于方法返回值对这个列表元素排序.但是,等等,我们没有列表,对吧?当然没有,我们又柯里化了.但是当我们被 .then() 方法调用的时候,它会接收这个列表,把每个对象传递给 get 方法并且基于结果排序.
dueDate
sortBy
.then()
这个例子展示了 Ramda 的工具方法跟 Ramda 柯里化版本.也许柯里化并没有那么重要.让我们来在没有柯里化的情况下重写:
Ramda
var getIncompleteTaskSummaries = function(membername) { return fetchData() .then(function(data) { return R.get('tasks', data) }) .then(function(tasks) { return R.filter(function(task) { return R.propEq('username', membername, task) }, tasks) }) .then(function(tasks) { return R.reject(function(task) { return R.propEq('complete', true, task); }, tasks) }) .then(function(tasks) { return R.map(function(task) { return R.pick(['id', 'dueDate', 'title', 'priority'], task); }, tasks); }) .then(function(abbreviatedTasks) { return R.sortBy(function(abbrTask) { return R.get('dueDate', abbrTask); }, abbreviatedTasks); }); };
我想其实是等价的.它也比原始的代码要好.Ramda 的工具方法有些,额,功用,甚至在柯里化的版本中.但是我不认为它比下面的版本可读性更好:
所以这就是我们柯里化的原因.
到这里课程结束了.
我确实警告过你.
下次,当我告诉你读其他人的文章而不是我的的时候,你要注意了,对吧?跟我写的比这些都有些过时了,但是他们仍然写得很好,并且你可以看看:
有个新的,我今天才看到.我们会看到它是否能够经受起时间的检验,但是当下它值得一读:
柯里化的确很强大,但是不足以让你的代码优雅.
有三个重要的元素:
Ramda 其中一个目标就是要通过方便的包装来提供所有这些.
The text was updated successfully, but these errors were encountered:
No branches or pull requests
原文地址,译文如下
有帮助的curry
我最近使用Ramda实现函数式组合的文章涉及到一个重要的主题。为了使用Ramda的方式做某种组合,我们需要这些方法被柯里化。
柯里化是啥,能吃吗?
实际上,
柯里化
是从 Haskell 来的。Haskell是第一个研究这种技术的。(是的,他们用自己的名字命名了一个函数式编程语言。不仅如此,Curry的中间初始是B
,或者当然代表的是Brainf*ck)柯里化是这么一个过程,它一个本来需要多个参数的方法转化为这样一种方法,这个方法在传递更少参数之后,返回一个新方法,返回的这个新方法会等待获取余下的参数。
基本的例子看起来像这样,这是一个普通的函数:
但是一个柯里化的版本就更加有用了
或者
你也可以在多次这样传递
有些人会认为我们在做的应该叫"部分应用"更加合适,并且"柯里化"应该只是用在这种情况:返回的方法只接收一个参数,其他每个参数都使用一个独立的新方法处理直到所有必须的参数都被提供。这些人可以继续这样迷信(意译)。
补充: 其实这里就是使用闭包给方法绑定了数据,通过返回的函数在之后的调用中复用之前绑定的数据。这里使用的例子是一个经典的场景,叫做
惰性求值
。无聊!对我有什么帮助吗?
下面是个更有意义的例子。如果你想求一个数字集合的和,你可以这么做:
如果你想写一个通用的函数来计算数字列表的总数,你可能会这么写:
在 Ramda里面,
total
和sum
非常相似。亦可以这样定义sum
:但是因为
reduce
是一个柯里化过的方法,但你不传最后一个参数的时候,就像在上面你自己定义的total
函数一样:你仅仅拿到一个方法你可以这样调用:
再次注意方法的定义和方法应用于数据上是多么相似
不在乎:我又不是个数学极客
所以你是一个web开发,是吧?你需要发一个AJAX请求到服务器?你需要使用 Promise?(起码我希望是这样)你需要操作返回的数据,过滤它,取得子集?或者你做服务器端开发?你异步查询SQL数据库,并且操作这些结果?
我能建议你做的最好的事情是你可以看看前端开发专家Jackson的精彩文章 为什么柯里化有帮助?。这是我看过最精彩的文章。如果你是个通过视频学习者,花半个小时看下Dr. Boolean的视频 Underscore,你做错了(不要在意标题,他没有花费他多时间实际吐槽工具库)。
真的去做。看看这些,它们解释得比我好,你已经看出来我多啰嗦了,巴拉巴拉。如果你已经看过这些,你可以跳过余下的章节。他们已经比我说得更好了。
该说的我都说了。
想象我们要获取像下面这样的数据
并且我们需要一个方法
getIncompleteTaskSummaries
接收一个membername
参数,然后从服务器(后者其他地方)获取数据,选择没有完成的会员,返回他们的ids,priorities, titles和due dates,根据due date排序。实际上,它返回一个应该在排序列表里面resolve的Promise。如果你传递 "Scott" 给
getIncompleteTaskSummaries
,它可能会返回好啦,我们开始,下面的code看起来熟悉吗?
如果代码看起来像下面这样是不是更美妙?
如果这样,那么柯里化会很适合你 。所有在这个代码块中提到的Ramda方法都被柯里化了。(实际上,所有超过一个参数的Ramda方法都被柯里化了,只有一些必要的例外。)在所有的情况下,柯里化让组合这些方法到一个优雅的块中变得简单。
让我们看看发生了什么。
get
(也用prop
)是这样定义的:但是当我们像上面一样调用它,我们只是给了第一个参数
name
,正如我们讨论的,这意味着我们会得到一个等待通过第一个then方法传递obj参数的方法,就是下面这样可以认为是下面的简化写法
下面是
propEq
,被定义为所以当我们通过
username
和membername
调用它的时候(后面的参数被作为参数传递给我们的方法),柯里化给我们返回了一个新方法,等价于membername
的值被绑定为传给我们的值。这个方法之后被传给
filter
。Ramda的
filter
方法就像在Array.prototype
上的原生filter方法,但是函数签名是所以我们已经柯里化过了,只需要传递
predicate
参数,并且前一步的tasks列表不需要。(我告诉过你所有的东西已经被柯里化了,没有吗?)我们对于
propEq('complete', true) -> reject
跟propEq('username', membername) ->
做了同样的事情。filter.Reject
跟filter
是一样的,除了它会反转语义。它只保留哪些predicate
返回false
的值。好了,你还在读吗?我们手指都累了。(真的要学学touch-type了)你真的不需要我来解释最后两行了,对吧?真的?你确定?好吧,好吧!是的!...是的,我说过我会的!
所以接下来我们看
pick
接收一个属性名数组和一个对象,并且返回一个新的对象,这个对象会把原来的属性拷贝过来。因为我们只传递了属性名,我们只要给它传递一个对象,就能得到一个会返回新对象的方法。这个方法被传递给R.map
函数。跟filter
一样,跟原生方法的版本工作方式相同,但是函数签名不同:这里再多嘴一下 -- 我已经说过我很乏味 -- 这个方法已经柯里化过了,因为我们只是传递了
pick
函数(柯里化后)的输出,而不是列表,then
会调用使用tasks列表调用这个方法。好啦,记得坐在学校教室等待下课?钟表上的分针卡住了,秒针像是被糖蜜粘住了吗?老师成天唠叨一遍又一遍同样的事情。还记得吗?然后也许就是两分钟要结束前那一刻,结束尽在眼前:哈利路亚!我想这个例子完了之后我们就到了,就剩这个了:
我们已经说过
get
方法了.就像这样柯里化之后,它返回一个方法,这个方法接受一个对象并且返回dueDate
属性.我们把它传递给sortBy
方法,这个方法接收一个列表并且基于方法返回值对这个列表元素排序.但是,等等,我们没有列表,对吧?当然没有,我们又柯里化了.但是当我们被.then()
方法调用的时候,它会接收这个列表,把每个对象传递给get
方法并且基于结果排序.所以柯里化有多重要?
这个例子展示了
Ramda
的工具方法跟Ramda
柯里化版本.也许柯里化并没有那么重要.让我们来在没有柯里化的情况下重写:我想其实是等价的.它也比原始的代码要好.
Ramda
的工具方法有些,额,功用,甚至在柯里化的版本中.但是我不认为它比下面的版本可读性更好:所以这就是我们柯里化的原因.
到这里课程结束了.
我确实警告过你.
下次,当我告诉你读其他人的文章而不是我的的时候,你要注意了,对吧?跟我写的比这些都有些过时了,但是他们仍然写得很好,并且你可以看看:
有个新的,我今天才看到.我们会看到它是否能够经受起时间的检验,但是当下它值得一读:
一个小秘密
柯里化的确很强大,但是不足以让你的代码优雅.
有三个重要的元素:
Ramda 其中一个目标就是要通过方便的包装来提供所有这些.
The text was updated successfully, but these errors were encountered: