函数组合

纯函数和柯里化很容易写出层层包含的洋葱代码(h(g(f(x))))

函数组合可以让我们把细粒度的函数重新组合成一个新函数，完成更复杂的逻辑

管道(pipe)

从左至右执行代码

const pipe = (...fns) => val => fns.reduce((acc, fn) => fn(acc), val)

当fn函数比较复杂时，可以把函数fn拆分成多个小函数，此时多了中间运算过程产生的m和n

image-20210104100629890.png

const pipe = (...fns) => val => fns.reduce((acc, fn) => fn(acc), val)
const f1 = value => value.split(',')
const f2 = value => value.slice(0, 1)
const f3 = value => value.map(val => val.toUpperCase())
const str = 'asdf,dfgfd,wer'
const fn = pipe(f1, f2, f3)
fn(str) // ["ASDF"]

函数组合

函数自右向左执行

const compose = (...fns)=>val=>fns.reverse().reduce((acc,fn)=>fn(acc),val); // lodash中的flowRoght实现

• 2个函数组合

  const a = value => value * 2
  const b = value => value * 3
  const componse = (a, b) => c => a(b(c))
  let fn = componse(a, b)
  console.log(fn(2)) // 12
  

• 多个函数组合

  const componse = (...fns) => val => fns.reverse().reduce((acc, fn) => fn(acc), val)
  const sentenceNum = str => str.match(/。/g)
  const countFn = arr => arr.length
  const addOrEven = num => num % 2 === 0 ? '偶数' : '奇数'
  let str = '大家好，我是中国人。我爱中国。我们同住地球村。'
  const myfn = componse(addOrEven, countFn, sentenceNum)
  myfn(str) // 奇数
  

lodash中的组合函数

• flow()从左向右执行

• flowRight()从右向左执行

  const _ = require('lodash')
  
  const reverse = (arr) => arr.reverse()
  const first = (arr) => arr[0]
  const toUpper = (s) => s.toUpperCase()
  const f = _.flowRight(toUpper, first, reverse)
  console.log(f(['one', 'two', 'three']))
  
  // test
  const firstStr = (str) => str.charAt(0)
  const fn = _.flowRight(toUpper, firstStr, first)
  console.log(fn(['one', 'two', 'three']))
  

• 函数组合要满足结合律（associativity）

  可以把g和h结合，也可以把f和g结合，结果都一样

  // 结合律（associativity）
  let f = componse(f, g, h)
  let associative = componse(componse(f, g), h) == componse(f, componse(g, h))
  

  上面的例子可以更改为

  // const fn = _.flowRight(toUpper, _.flowRight(firstStr, first))
  const fn = _.flowRight(_.flowRight(toUpper, firstStr), first)
  console.log(fn(['one', 'two', 'three']))
  

• 调试

  函数组合只能一次性返回所有结果，如果返回结果不对，不知道哪一步出问题，所以就需要调试

  const _ = require('lodash')
  const trace = _.curry((tag, v) => {
    console.log(tag, v)
    return v // 需要将上一步生成的结果返回出去
  })
  
  const split = _.curry((sep, str) => _.split(str, sep))
  const join = _.curry((sep, array) => _.join(array, sep))
  const map = _.curry((fn, array) => _.map(array, fn))
  const f = _.flowRight(join('-'), trace, map(_.toLower), trace, split(' '))
  
  console.log(f('NEVER SAY DIE')) // split 之后 [ 'NEVER', 'SAY', 'DIE' ] map 之后 [ 'never', 'say', 'die' ] never-say-die
  

lodash/fp模块

• lodash 的 fp 模块提供了实用的对函数式编程友好的方法
• 提供了不可变 auto-curried iteratee-first, data-last 的方法

const fp = require('lodash/fp') // 方法优先，数据在后
const f = fp.flowRight(fp.join('-'), fp.map(fp.toLower), fp.split(' '))
console.log(f('NEVER SAY DIE')) // never-say-die

// lodash 和 lodash/fp 模块中 map 方法的区别
const _ = require('lodash')
/**
 * lodash 数据优先 函数之后
 *  _.map参数 value - index|key - collection
 * 数组 第二个参数为index索引 对象传递key
 * 最后一个参数collection
 * 所以此时相当于向parseInt传递以下三个参数
 * parseInt('23', 0, array) 0代表10进制
 * parseInt('8', 1, array)
 * parseInt('10', 2, array)
 */
console.log(_.map(['23', '8', '10'], parseInt)) // [ 23, NaN, 2 ]

// 所以此时需要fp模块 函数优先
const fp = require('lodash/fp')

console.log(fp.map(parseInt, ['23', '8', '10'])) // [23, 8, 10]

Point Free

我们可以把数据处理的过程定义成与数据无关的合成运算，不需要用到代表数据的那个参数，只要把简单的运算步骤合成到一起；本质是使用一些通用的函数，组合成各种负责运算，这就需要将一些常用的操作封装成函数

• 不需要指定处理的数据
• 只需要合成运算过程
• 需要定义一些辅助的基本运算函数

const f = fp.flowRight(fp.join('-'), fp.map(_.toLower), fp.split(' '))

// 非point free
// const f = (word) => word.toLowerCase().replace(/\s+/g, '_')
// point free
const fp = require('lodash/fp')

const f = fp.flowRight(fp.replace(/\s+/g, '_'), fp.toLower)

console.log(f('Hello     World')) // hello_world

// 把一个字符串中的首字母提取并转换成大写, 使用. 作为分隔符
// world wild web ==>  // W. W. W
const fp = require('lodash/fp')

const firstLetterToUpper = fp.flowRight(
  fp.join('. '),
  fp.map(fp.flowRight(fp.toUpper, fp.first)),
  fp.split(' ')
)
console.log(firstLetterToUpper('world wild web')) // W. W. W