函子(Functor) 函子是一個特殊的容器,通過一個普通對象來實現,該對象具有map方法,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 中的curry
與compose
的簡單使用
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)
,一個函子如果具有join
和of
兩個方法並遵循一些定律就是一個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
更多內容微信公眾號搜索充饑的泡飯
小程式搜一搜開水泡飯的博客