函数式编程

为什么要学习函数式编程

• 函数式编程是随着 React (Hooks) 的风行受到越来越多的关注
• Vue 3 也开始拥抱函数式编程
• 函数式编程能够摈弃 this
• 打包过程中能够更好的利用 tree shaking 过滤无用代码
• 不便测试、不便并行处理
• 有很多库能够帮忙咱们进行函数式开发：lodash、underscore、ramda

什么是函数式编程

函数式编程(Functional Programming, FP)，FP 是编程范式之一，咱们常据说的编程范式还有面向过程编程、面向对象编程。

• 面向对象编程的思维形式：把事实世界中的事物形象成程序世界中的类和对象，通过封装、继承和多态来演示事物事件的分割

• 函数式编程的思维形式：把事实世界的事物和事物之间的分割形象到程序世界（对运算过程进行形象）

  • 程序的实质：依据输出通过某种运算取得相应的输入，程序开发过程中会波及很多有输出和输入的函数
  • x -> f(分割、映射) -> y，y=f(x)
    函数式编程中的函数指的不是程序中的函数(办法)，而是数学中的函数即映射关系，例如：y= sin(x)，x 和 y 的关系
  • 雷同的输出始终要失去雷同的输入(纯函数)
  • 函数式编程用来形容数据 (函数) 之间的映射

// 非函数式
let num1 = 2
let num2 = 3
let sum = num1 + num2
console.log(sum)

// 函数式
function add (n1, n2) {return n1 + n2}
let sum = add(2, 3)
console.log(sum)

函数是一等公民

函数能够存储在变量中

函数能够做参数

函数能够做返回值

高阶函数

• 函数做参数

   function foreach(arr, fn) {for(let i = 0; i < arr.length; i++){fn(arr[i]);
   }
   }

• 函数做返回值

  function makeFn () {
  let msg = 'Hello function'
  return function () {console.log(msg)
  }
  }
  const fn = makeFn()
  fn() // => 'Hello function'

  React 高阶组件 实质上就是 高阶函数

罕用的高阶函数，Array 的办法

• forEach
• map
• find/findIndex
• includes
• some
• every
• reduce
  …

闭包

• 闭包 (Closure)：函数和其四周的状态 (词法环境) 的援用捆绑在一起造成闭包。

  • 能够在另一个作用域中调用一个函数的外部函数并拜访到该函数的作用域中的成员
• 闭包的实质：函数在执行的时候会放到一个执行栈受骗函数执行结束之后会从执行栈上移除，然而
  堆上的作用域成员因为被内部援用不能开释，因而外部函数仍然能够拜访内部函数的成员

纯函数

• 雷同的输出永远会失去雷同的输入，而且没有任何可察看的副作用

  • 纯函数就相似数学中的函数(用来形容输出和输入之间的关系)，y = f(x)
• lodash 是一个纯函数的性能库，提供了对数组、数字、对象、字符串、函数等操作的一些办法

• 数组的 slice 和 splice

  • slice 返回数组中的指定局部，不会扭转原数组
  • splice 对数组进行操作返回该数组，会扭转原数组

let numbers = [1, 2, 3, 4, 5]
// 纯函数
numbers.slice(0, 3)
// => [1, 2, 3]
numbers.slice(0, 3)
// => [1, 2, 3]
numbers.slice(0, 3)
// => [1, 2, 3]
// 不纯的函数 扭转了原数组
numbers.splice(0, 3)
// => [1, 2, 3]
numbers.splice(0, 3)
// => [4, 5]
numbers.splice(0, 3)
// => []

• 函数式编程不会 保留计算的两头后果，所以变量是不可变的
• 能够把一个函数的执行后果给另一个函数去解决

纯函数益处

• 可缓存

  • 因为纯函数对雷同的输出永远会失去雷同的输入，所以能够把后果缓存起来

    const _ = require('lodash')
    function getArea (r) {return Math.PI * r * r}
    let getAreaWithMemory = _.memoize(getArea)
    console.log(getAreaWithMemory(4))
    

  • 本人实现一个 memoize

    function memoize(f) {let cache = {};
      return function () {let argStr = JSON.stringify(arguments);
        cache[argStr] = cache[argStr] || f.apply(f, arguments);
        return cache[argStr]
      }
    }

• 可测试 纯函数让测试更不便

• 并行处理

  • 在多线程环境下并行操作共享的内存数据很可能会出现意外状况
  • 纯函数不须要访问共享的内存数据，所以在并行环境下能够任意运行纯函数 (Web Worker)

副作用

// 不纯的
let mini = 18
function checkAge (age) {return age >= mini}
// 纯的(有硬编码，后续能够通过柯里化解决)
function checkAge (age) {
  let mini = 18
  return age >= mini
}

副作用让一个函数变的不纯 (如上例)，纯函数的依据雷同的输出返回雷同的输入，如果函数依赖于内部
的状态就无奈保障输入雷同，就会带来副作用。

副作用起源：

• 配置文件
• 数据库
• 获取用户的输出
• …

所有的内部交互都有可能带来副作用，副作用也使得办法通用性降落不适宜扩大和可重用性，同时副作用会给程序中带来安全隐患给程序带来不确定性，然而副作用不可能齐全禁止，尽可能管制它们在可控范畴内产生。

函数柯里化

• 应用柯里化解决硬编码

  function checkAge (age) {
  let min = 18
  return age >= min
  }
  // 一般纯函数
  function checkAge (min, age) {return age >= min}
  
  checkAge(18, 24)
  checkAge(18, 20)
  checkAge(20, 30)
  
  // 柯里化
  function checkAge (min) {return function (age) {return age >= min}
  }
  // ES6 写法
  let checkAge = min => (age => age >= min)
  let checkAge18 = checkAge(18)
  let checkAge20 = checkAge(20)
  checkAge18(24)
  checkAge18(20)

• 柯里化 (Currying)：

  • 当一个函数有多个参数的时候先传递一部分参数调用它（这部分参数当前永远不变）
  • 而后返回一个新的函数接管残余的参数，返回后果

lodash 中的柯里化办法

• _.curry(func) 创立一个函数，该函数接管一个或多个 func 的参数，如果 func 所须要的参数都被提供则执行 func 并返回执行的后果。否则持续返回该函数并期待接管残余的参数。

  const _ = require('lodash')
  // 要柯里化的函数
  function getSum (a, b, c) {return a + b + c}
  // 柯里化后的函数
  let curried = _.curry(getSum)
  // 测试
  curried(1, 2, 3) // => 6
  curried(1)(2)(3) // => 6
  curried(1, 2)(3) // => 6

• 模仿柯里化函数

  function curry(func){return function curriedFn(...args) {if (args.length < func.length) {return curriedFn(...args.concat(Array.from(arguments)));
    } else {return func(...args);
    }
  }
  }

  柯里化总结

• 柯里化能够让咱们给一个函数传递较少的参数失去一个曾经记住了某些固定参数的新函数
• 这是一种对函数参数的‘缓存’（其实是闭包）
• 让函数变得灵便，让函数颗粒度更小
• 能够把多元函数变为一元函数，能够组合成更弱小的函数

函数组合

• 纯函数和柯里化很容易写出洋葱代码 h(g(f(x)))
• 获取数组的最初一个元素再转换成大写字母，_.toUpper(_.first(_.reverse(array)))
• 函数组合能够让咱们把细粒度的函数重新组合生成一个新的函数

• 函数组合 (compose)：如果一个函数要通过多个函数解决能力失去最终值，这个时候能够把两头
  过程的函数合并成一个函数

  • 函数就像是数据的管道，函数组合就是把这些管道连接起来，让数据穿过多个管道造成最终
    后果

  • 函数组合默认是从右到左执行

    // 简略组合函数
    function compose (f, g) {return function (x) {return f(g(x))
    }
    }
    function first (arr) {return arr[0]
    }
    function reverse (arr) {return arr.reverse()
    }
    // 从右到左运行
    let last = compose(first, reverse)
    console.log(last([1, 2, 3, 4]))

• lodash 中的组合函数
• lodash 中组合函数 flow() 或者 flowRight()，他们都能够组合多个函数
• flow 从左往右执行

• flowRight 从右往左执行，应用更多

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

• 模仿 lodash flowRight

  // 多函数组合
  function compose (...fns) {return function (value) {return fns.reverse().reduce(function (acc, fn) {return fn(acc)
    }, value)
  }
  }
  // ES6
  const compose = (...fns) => value => fns.reverse().reduce((acc, fn) =>
  fn(acc), value)
  

• 函数的组合要满足 结合律 (associativity)：

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

• 调试函数组合

  const _ = require('lodash')
  // 柯里化一个跟踪函数，记录一个 tag，打印上一步解决失去的值
  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 之后'), map(_.toLower),
  trace('split 之后'), 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 的办法 (主动柯里化 函数优先 数据置后)

    // lodash 模块
    const _ = require('lodash')
    _.map(['a', 'b', 'c'], _.toUpper)
    // => ['A', 'B', 'C']
    _.map(['a', 'b', 'c'])
    // => ['a', 'b', 'c']
    _.split('Hello World', ' ')
    
    // lodash/fp 模块
    const fp = require('lodash/fp')
    fp.map(fp.toUpper, ['a', 'b', 'c'])
    fp.map(fp.toUpper)(['a', 'b', 'c'])
    fp.split('','Hello World')
    fp.split('')('Hello World')
    
    const f = fp.flowRight(fp.join('-'), fp.map(_.toLower), fp.split(' '))
    console.log(f('NEVER SAY DIE'))
    

    Point Free

    咱们能够把数据处理的过程定义成与数据无关的合成运算，不须要用到代表数据的那个参数，只有把简略的运算步骤合成到一起，在应用这种模式之前咱们须要定义一些辅助的根本运算函数。

• 不须要指明解决的数据
• 只须要合成运算过程

• 须要定义一些辅助的根本运算函数

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

• 案例演示

  // 非 Point Free 模式
  // Hello World => hello_world
  function f (word) {return 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'))
  

• 应用 Point Free 的模式，把单词中的首字母提取并转换成大写

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

Functor (函子)

函子是是一个非凡的容器，通过一个一般的对象来实现，该对象具备 map 办法，map 办法能够运行一个函数对值进行解决(变形关系)

Functor 函子

// 一个容器，包裹一个值
class Container {
  // of 静态方法，能够省略 new 关键字创建对象
  static of (value) {return new Container(value)
  }
  constructor (value) {this._value = value}
  // map 办法，传入变形关系，将容器里的每一个值映射到另一个容器
  map (fn) {return Container.of(fn(this._value))
  }
}
// 测试
Container.of(3)
.map(x => x + 2)
.map(x => x * x)

• 总结

  • 函数式编程的运算不间接操作值，而是由函子实现
  • 函子就是一个实现了 map 契约的对象
  • 咱们能够把函子设想成一个盒子，这个盒子里封装了一个值
  • 想要解决盒子中的值，咱们须要给盒子的 map 办法传递一个解决值的函数（纯函数），由这个函数来对值进行解决
  • 最终 map 办法返回一个蕴含新值的盒子（函子）

• 在 Functor 中如果咱们传入 null 或 undefined

  // 测试
  Container.of(null)
  .map(x => x.toUperCase()) 
  // => TypeError: Cannot read property 'toUpperCase' of null

MayBe 函子

• 咱们在编程的过程中可能会遇到很多谬误，须要对这些谬误做相应的解决

• MayBe 函子的作用就是能够对外部的空值状况做解决（管制副作用在容许的范畴）

  class MayBe {static of (value) {return new MayBe(value);
  }
  
  constructor(value) {this._value = value;}
  
  isNothing() {return this._value === undefined || this._value === null;}
  
  map(fn) {return this.isNothing() ? this : MayBe.of(fn(this._value));
  }
  }
  
  // 传入具体值
  MayBe.of('Hello World')
  .map(x => x.toUpperCase())
  // 传入 null 的状况
  MayBe.of(null)
  .map(x => x.toUpperCase())
  // => MayBe {_value: null}

• 存在问题：在 MayBe 函子中，咱们很难确认是哪一步产生的空值问题，如下例：

  MayBe.of('hello world')
  .map(x => x.toUpperCase())
  .map(x => null)
  .map(x => x.split(' '))
  // => MayBe {_value: null}

Either 函子

• Either 两者中的任何一个，相似于 if…else… 的解决

• 异样会让函数变的不纯，Either 函子能够用来做异样解决

  class Left {static of (value) {return new Left(value)
  }
  constructor (value) {this._value = value}
  map (fn) {return this}
  }
  
  class Right {static of (value) {return new Right(value)
  }
  constructor (value) {this._value = value}
  map (fn) {return Right.of(fn(this._value))
  }
  }
  

• Either 用来解决异样

  function parseJSON(json) {
  try {return Right(JSON.parse(json))
  } catch(err) {return Left({error: err})
  }
  }
  
  let r = parseJSON('{"name":"zs"}')
  .map(x => x.name.toUpperCase())
  console.log(r) // => Right : {_value: 'ZS'}

  IO 函子

• IO 函子中的 _value 是一个函数，这里是把函数作为值来解决
• IO 函子能够把不纯的动作存储到 _value 中，提早执行这个不纯的操作(惰性执行)，包装以后的纯操作

• 把不纯的操作交给调用者来解决

  const fp = require('lodash/fp')
  class IO {static of (x) {return new IO(function () {return x})
  }
  constructor (fn) {this._value = fn}
  map (fn) {
    // 把以后的 value 和 传入的 fn 组合成一个新的函数
    return new IO(fp.flowRight(fn, this._value))
  }
  }
  
  // 调用
  let io = IO.of(process).map(p => p.execPath)
  console.log(io._value())
  

Task 函子 异步执行

folktale 一个规范的函数式编程库

• 和 lodash、ramda 不同的是，他没有提供很多性能函数
• 只提供了一些函数式解决的操作，例如：compose、curry 等，一些函子 Task、Either、MayBe 等

const {compose, curry} = require('folktale/core/lambda')
const {toUpper, first} = require('lodash/fp')
// 第一个参数是传入函数的参数个数
let f = curry(2, function (x, y) {console.log(x + y)
})
f(3, 4)
f(3)(4)
// 函数组合
let f = compose(toUpper, first)
f(['one', 'two'])

• Task 异步执行

  const {task} = require('folktale/concurrency/task')
  
  function readFile(filename) {
  return task(resolver => {fs.readFile(filename, 'utf-8', (err, data) => {if (err) resolver.reject(err)
      resolver.resolve(data)
    })
  })
  }
  // 调用 run 执行
  readFile('package.json')
  .map(split('\n'))
  .map(find(x => x.includes('version')))
  .run().listen({
  onRejected: err => {console.log(err)
  },
  onResolved: value => {console.log(value)
  }
  })
  

Pointed 函子

• Pointed 函子是实现了 of 静态方法的函子
• of 办法是为了防止应用 new 来创建对象，更深层的含意是 of 办法用来把值放到上下文 Context（把值放到容器中，应用 map 来解决值）

Monad（单子）

在应用 IO 函子的时，会呈现 ._value()屡次调用的问题 如下

const fs = require('fs')
const fp = require('lodash/fp')
let readFile = function (filename) {return new IO(function() {return fs.readFileSync(filename, 'utf-8')
  })
}
let print = function(x) {return new IO(function() {console.log(x)
    return x
  })
}

// IO(IO(x))
let cat = fp.flowRight(print, readFile)
// 调用
let r = cat('package.json')._value()._value()
console.log(r)

• Monad 函子是能够变扁的 Pointed 函子，IO(IO(x))

• 一个函子如果具备 join 和 of 两个办法并恪守一些定律就是一个 Monad

  // IO Monad
  class IO {static of (x) {return new IO(function () {return x})
  }
  constructor (fn) {this._value = fn}
  map (fn) {return new IO(fp.flowRight(fn, this._value))
  }
  join () {return this._value()
  }
  flatMap (fn) {return this.map(fn).join()}
  }
  let r = readFile('package.json')
  .map(fp.toUpper)
  .flatMap(print)
  .join()