javascript 函数式编程

1.函数式编程是什么 为什么要函数式编程

我眼中的 JavaScript 函数式编程

2.什么是函数组合

征服 JavaScript 面试:什么是函数组合

3.柯里化实现

JS中的柯里化 及 精巧的自动柯里化实现

严格意义上的柯里化是将多参函数变为单参函数,每个函数可以看成处理数据的管道,函数组合就是将各个管道串联起来,因为函数的返回值只有一个,所以如果想串联函数,就需要被串联的函数是单参的,这就需要柯里化。函数组合后返回一个函数,这时候传递最后的数据,执行函数就得到最后想要的结果。简明 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打开控制台就看到函数的调用栈了

一个例子

  1. 获取所有年龄小于 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链式调用也做了惰性求值。

推荐阅读更多精彩内容