JavaScript函数式编程之函子

  • JavaScript函数式编程之函子已关闭评论
  • 19 次浏览
  • A+
所属分类:Web前端
摘要

函子是一个特殊的容器,通过一个普通对象来实现,该对象具有map方法,map方法可以运行一个函数对值进行处理(变形关系),容器包含值和值变形关系(这个变形关系就是函数)。函数式编程中解决副作用的存在


函子(Functor)

函子是一个特殊的容器,通过一个普通对象来实现,该对象具有map方法,map方法可以运行一个函数对值进行处理(变形关系),容器包含值和值变形关系(这个变形关系就是函数)。函数式编程中解决副作用的存在

  • 函数式编程的运算不直接操作值,,而是由函子完成
  • 函子就是一个实现了map契约的对象
  • 我们可以把函子想象成一个盒子,盒子里面封装了一个值
  • 想要处理盒子中的值,我们需要给盒子的map方法传递一个处理值的函数(纯函数),由这个函数来对值进行处理
  • 最终map方法返回一个包含新值所在的盒子(函子)

根据函子的定义我们创建一个函子

// functor 函子 class Container {   constructor (value) {     // 函子内部保存这个值。下划线是不想外部访问     this._value = value   }    // map 方法接收一个处理值的函数   map (fn) {     return new Container(fn(this._value))   } } 

此时就已经创建了一个函子但是这是面向对象的方式来创建的,换成用函数式编程来写一个函子

class Container {   constructor (value) {     this._value = value   }    map (fn) {     return Container.of(fn(this._value))   }    static of (value) {     return new Container(value)   } }  let x = Container.of(5).map(x => x + 1).map(x => x - 1) 

但是这个函子还是存在一些问题,比如空值的时候就会报错, 会让我们的函子变的不纯,我们需要去拦截空值错误,我们创建一个方法去判断是否为空值,如果是控制我们直接返回一个空值的函子,如果有值再去处理,这个时候就需要使用MayBe函子

let x = Container.of(null).map(x => x + 1).map(x => x - 1) 

MayBe 函子

我们在编程的过程中可能会遇到很多错误,需要对这些错误做相应的处理,MayBe函子的作用就是可以对外部的空值情况做处理(控制副作用在允许的范围)

// MayBe 函子 class MayBe {   constructor (value) {     this._value = value   }    map (fn) {     return this.isNothing() ? MayBe.of(null) : MayBe.of(fn(this._value))   }    isNothing () {     return this._value === undefined || this._value === null   }    static of (value) {     return new MayBe(value)   } }  let x = MayBe.of(null)   .map(x => x + 1)   .map(x => x - 1) console.log(x) 

这个时候我们已经能正常执行了,但是现在出现了空值的函子,但是我们不知道那个地方出现了空值,所以我们创建两个函子一个是正常的处理一个是出现错误情况处理,正常的就按照正常的方式创建,错误的是是否我们把map方法改造一下让她不再处理回调函数,直接返回一个空值的MayBe函子,这样就记录下了错误信息Eitcher 函子就是来处理这种情况的

Either函子

Eitcher 类似于 if else 的处理,两者中的任何一个,异常会让函数变的不纯,Eitcher函子可以用来做异常处理

// 因为是二选一,所以定义两个类 Left 和 Right  // 记录错误信息的 class Left {   constructor (value) {     this._value = value   }    map (fn) {     return this   }    static of (value) {     return new Left(value)   } }  // 正常处理 class Rgiht {   constructor (value) {     this._value = value   }    map (fn) {     return Rgiht.of(fn(this._value))   }    static of (value) {     return new Rgiht(value)   } }  function parseJson (str) {   try {     return Rgiht.of(JSON.parse(str))   } catch (err) {     return Left.of({ message: err.message })   } }  // 故意传入错误的数据 let r = parseJson('{ name: "2" }') r.map(x => x.name.toUpperCase()) console.log(r) 

IO 函子

IO 函子中的 _value 是一个函数, 这里把函数作为值来处理, IO 函子可以吧不纯的动作储存到_value中,延迟这个不纯的操作(惰性执行),保证当前的操作是纯的,延迟把不纯的操作到调用者来处理

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

IO 函子内部帮我们包装了一些函数,当我们传递函数的时候有可能这个函数是一个不纯的操作,不管这个函数纯与不纯,IO这个函子在执行的过程中它返回的这个结果始终是一个纯的操作,我们调用map的时候始终返回的是一个函子,但是IO函子这个_value属性他里面要去合并很多函数,所以他里面可能是不纯的,把这些不纯的操作延迟到了调用的时候,也就是我们通过IO函子控制了副作用的在可控的范围内发生

实现 liunx 下 cat 命令

const fp = require('lodash/fp')  // IO 函子 class IO {   constructor (fn) {     this._value = fn   }   static of (value) {     return new IO(function () {       return value     })   }   map (fn) {     // 把当前的value 和传入的fn 函数组合成一个新的函数     return new IO(fp.flowRight(fn, this._value))   } }  let r = IO.of(process).map(x => x.execPath)  function readFile (fileName) {   return new IO(() => fs.readFileSync(fileName, 'utf-8')) }  function print (x) {   return new IO(() => {     console.log(x)     return x   }) }  let cat = fp.flowRight(print, readFile)  console.log(cat('package.json')._value()._value()) 

此时IO函子出现了嵌套的问题,导致调用嵌套函子中的方法就必须要要._value()._value() 这样来执了,嵌套了几层就需要几层调用

Folktale

Folktale 是一个标准的函数式编程库,和lodash不同的是,他没有提供很多功能函数,只提供了一些函数式处理的操作,例如:compose、curry等,一些函子 Task、Either、MayBe等,

Folktale 中的currycompose的简单使用

const { compose, curry } = require('folktale/core/lambda') const { toUpper, first } = require('lodash/fp')  // 与lodash区别,第一个参数指明后面参数的个数 let f = curry(2, (n1, n2) => n1 + n2)  console.log(f(1, 2))  // compose 就是函数组合 lodash 中的函数组合是 flowRight let f2 = compose(toUpper, first)  console.log(f2(['one', 'two'])) 

Folktale 中的 task 函子

函子可以处理异步任务,在异步任务中会通往地狱之门的回调,而使用task 函子可以避免回调的嵌套,详细请看官方文档

// Task 异步任务 const { task } = require('folktale/concurrency/task') const { split, find } = require('lodash/fp') const fs = require('fs')  function readFile (filename) {   return task(resolver => {     fs.readFile(filename, 'utf-8', (err, data) => {       if (err) {         resolver.reject(err)       }       resolver.resolve(data)     })   }) }  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 来处理值)

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

Monad函子

解决函子嵌套的问题,Monad 函子是可以变扁的 Pointed 函子 IO(IO),一个函子如果具有joinof两个方法并遵循一些定律就是一个Monad

class IO {   constructor (fn) {     this._value = fn   }   static of (value) {     return new IO(function () {       return value     })   }   map (fn) {     return new IO(fp.flowRight(fn, this._value))   }    join () {     return this._value()   }    // 同时调用 join 和 map   flatMap (fn) {     return this.map(fn).join()   } }  function readFile (fileName) {   return new IO(() => fs.readFileSync(fileName, 'utf-8')) }  function print (x) {   return new IO(() => {     return x   }) }  let r = readFile('package.json').flatMap(print).join()  console.log(r) 

当我们想要去调用一个方法,这个方法返回一值的时候我们去调用map方法,当我们想要去调用一个方法,这个方法返回一个函子的时候我们去调用flatMap方法

原文地址:https://kspf.xyz/archives/17
更多内容微信