1.函数式编程是什么 为什么要函数式编程
2.什么是函数组合
3.柯里化实现
严格意义上的柯里化是将多参函数变为单参函数，每个函数可以看成处理数据的管道，函数组合就是将各个管道串联起来，因为函数的返回值只有一个，所以如果想串联函数，就需要被串联的函数是单参的，这就需要柯里化。函数组合后返回一个函数，这时候传递最后的数据，执行函数就得到最后想要的结果。简明 JavaScript 函数式编程——入门篇 说的比较清楚
怎样去debug组合的函数
var dasherize = compose(join('-'), toLower, trace("after split"), split(' '), replace(/\s{2,}/ig, ' '));
// after split [ 'The', 'world', 'is', 'a', 'vampire' ]
需要个trace函数,本以为复杂，其实很简单，采自函数式编程指北
var trace = curry(function(tag, x){
console.log(tag, x);
return x;
});
看到trace，自然会联想到console.trace,做出改进
const trace = curry(function(tag, x) {
console.log(tag, x);
console.trace("trace");
return x;
});
F12打开控制台就看到函数的调用栈了
一个例子
- 获取所有年龄小于 18 岁的对象，并返回他们的名称和年龄。
还是上篇文章中的例子：
具体的代码在functional demo使用jest测试
import * as R from "ramda";
/*
* ex1
*/
// :: String -> Number -> Object -> Boolean
const propLt = R.curry((p, c) =>
R.pipe(
R.prop(p),
R.lt(R.__, c)
)
);
// :: Object -> Boolean
const ageUnder18 = propLt("age", 18);
// :: [a] -> b
const getAgeUnder18 = R.pipe(
R.filter(ageUnder18),
R.map(R.pickAll(["name", "age"]))
);
describe("Test", function() {
it("1. 获取所有年龄小于18岁的对象，并返回他们的名称和年龄", function() {
const result = getAgeUnder18(data);
expect(result).toEqual(ageLt18);
});
});
pipe更compose执行顺序相反，pipe从左到右执行，R.filter R.map跟数组的filter map类似,都需要传递函数，R.prop，R.lt，R.pickAll源码都很简单
ramda@0.27.0
- R.prop
/**
* Returns a function that when supplied an object returns the indicated
* property of that object, if it exists.
*
* @func
* @memberOf R
* @since v0.1.0
* @category Object
* @typedefn Idx = String | Int
* @sig Idx -> {s: a} -> a | Undefined
* @param {String|Number} p The property name or array index 对象的名字或者数组的下标
* @param {Object} obj The object to query 对象或者数组
* @return {*} The value at `obj.p`. 返回对象的值或者数组的值
* @see R.path, R.props, R.pluck, R.project, R.nth
* @example
*
* R.prop('x', {x: 100}); //=> 100
* R.prop('x', {}); //=> undefined
* R.prop(0, [100]); //=> 100
* R.compose(R.inc, R.prop('x'))({ x: 3 }) //=> 4
*/
var prop = _curry2(function prop(p, obj) {
if (obj == null) {
return;
}
return _isInteger(p) ? nth(p, obj) : obj[p];
});
export default prop;
- R.lt
import _curry2 from './internal/_curry2';
/**
* Returns `true` if the first argument is less than the second; `false`
* otherwise.
*
* @func
* @memberOf R
* @since v0.1.0
* @category Relation
* @sig Ord a => a -> a -> Boolean
* @param {*} a
* @param {*} b
* @return {Boolean}
* @see R.gt
* @example
*
* R.lt(2, 1); //=> false
* R.lt(2, 2); //=> false
* R.lt(2, 3); //=> true
* R.lt('a', 'z'); //=> true
* R.lt('z', 'a'); //=> false
*/
var lt = _curry2(function lt(a, b) { return a < b; });
export default lt;
- R.pickAll 攫取对象中指定keys的子对象
import _curry2 from './internal/_curry2';
/**
* Similar to `pick` except that this one includes a `key: undefined` pair for
* properties that don't exist.
*
* @func
* @memberOf R
* @since v0.1.0
* @category Object
* @sig [k] -> {k: v} -> {k: v}
* @param {Array} names an array of String property names to copy onto a new object
* @param {Object} obj The object to copy from
* @return {Object} A new object with only properties from `names` on it.
* @see R.pick
* @example
*
* R.pickAll(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, d: 4}
* R.pickAll(['a', 'e', 'f'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, e: undefined, f: undefined}
*/
var pickAll = _curry2(function pickAll(names, obj) {
var result = {};
var idx = 0;
var len = names.length;
while (idx < len) {
var name = names[idx];
result[name] = obj[name];
idx += 1;
}
return result;
});
export default pickAll;
源码在写的时候并没有使用单参函数，都是用了curry函数进行柯里化，但是所有的函数都有一个规律，第二个参数是管道中流动的数据，第一个参数是一开始传递进去的。所以流动的数据应该放在需要被柯里化的函数参数的最后面。这样我们可以自我实现R.filter R.map
const filter = R.curry((func, arr) => arr.filter(func));
const map = R.curry((func, arr) => arr.map(func));
哇 好简单。但是这么写是不是有点复杂，最原始直接的办法：
arr.filter((x) => x.age < 18).map((x) => ({ name: x.name, age: x.age }));
对于数组的操作感觉这么写直观，简单。从复用的角度说ageUnder18函数并不简单，R.pickAll相对简单点，返回了函数。
4. lodash/fp 模块
在 ES6 大行其道的今天，还有必要使用 lodash 之类的库吗？讨论指出：
- lodash/fp 下面的所有方法，都是 Immutable 的。
- lodash/fp 下面的所有方法，都是 Auto-curried Iteratee-first Data-last 处理过的。
- 通过 flow 创建的函数是 lazy evaluation 的。
在我们安装lodash的时候已经安装了lodash/fp模块，可以随性的使用。函数式风格跟lodash 链式调用也有争议，其中提到flow 已经自带做了这种性能优化，而原生的链式调用是不会有这种性能优化的。看了《JavaScript函数式编程指南》导读与总结发现lodash@4.17.15链式调用也做了惰性求值。
