學習筆記（一）—— 函數(shù)式編程

最近開始對前端知識體系進行一個系統(tǒng)的擴展跟學習怒允，通過每天定期的學習，對一些不常使用的知識點進行了解和補充锈遥，同時對已經(jīng)使用過的知識點溫故而知新
在此記錄學習筆記纫事，并根據(jù)學習進度定時跟新

函數(shù)一等公民 (First-class Function)

函數(shù)可以存儲在變量中
函數(shù)可以作為參數(shù)
函數(shù)可以作為返回值

高階函數(shù)（Higher-order Function）

可以把函數(shù)作為參數(shù)傳遞給另一個函數(shù)
可以把函數(shù)作為另一個函數(shù)的返回結(jié)果

常用的高階函數(shù)及模擬實現(xiàn)

forEach

// forEach
const forEach = (array, fn) => {
    for (let t of array) {
        fn(t)
    }
}

filter

// filter
const filter = (array, fn) => {
    let result = []
    for (let t of array) {
        fn(t) && result.push(t)
    }
    return result;
}

// map
const map = (array, fn) => {
    let result = []
    for (let t of array) {
        result.push(fn(t))
    }
    return result
}

some

// some
const some = (array, fn) => {
    for (let t of array) {
        if(fn(t)) {
            return true
        }
    }
    return false
}

every

// every
const every = (array, fn) => {
    for (let t of array) {
        if(!fn(t)) {
            return false
        }
    }
    return true
}

once

// once
const once = (fn) => {
    let done = false
    return (...args) => {
        if (!done) {
            done = true
            return fn.apply(this, args)
        }
    }
}

閉包（Closure）

函數(shù)及其周圍的狀態(tài)的引用捆綁在一起勘畔，組成閉包
* 可以在另一個作用域中調(diào)用一個函數(shù)的內(nèi)部函數(shù)，并訪問到該函數(shù)的作用域中的成員
閉包的本質(zhì)：函數(shù)在執(zhí)行時會放到一個執(zhí)行棧上丽惶，當執(zhí)行完成后會從執(zhí)行棧上移除炫七，但是堆上的作用域成員因為被外部引用而不能被釋放，因此內(nèi)部函數(shù)依然可以訪問外部函數(shù)的成員
箭頭函數(shù)蚊夫，閉包中this指向undefined诉字，因為外層函數(shù)調(diào)用棧被釋放?

純函數(shù)

相同的輸入永遠得到相同的輸出，且沒有任何可觀察的副作用
數(shù)組的slice和splice分別是純函數(shù)和不純函數(shù)
* slice返回數(shù)組指定部分知纷，不會改變原數(shù)組
* splice從原數(shù)組中移除的元素壤圃，并返回移除元素集合，會改變原數(shù)組
函數(shù)式編程不會保留計算中間的結(jié)果琅轧，所以變量是不可變的（無狀態(tài)的）

Lodash

具體參見Lodash官網(wǎng)

純函數(shù)的好處

可緩存

模擬實現(xiàn)lodash memoize

function memoize (fn) {
    let cache = {}
    return function () {
        const key = JSON.stringify(arguments)
        cache[key] = cache[key] || fn(...arguments)
        return cache[key]        
    }
}

可測試
并行處理
純函數(shù)不需要訪問共享內(nèi)存數(shù)據(jù)

副作用

使純函數(shù)變得不純
副作用來源：外部數(shù)據(jù)依賴（接口伍绳、數(shù)據(jù)庫、配置文件乍桂、全局變量等）
副作用不可能完全禁止冲杀，盡可能控制在可控范圍內(nèi)

柯里化（Currying）

當一個函數(shù)包含多個參數(shù)的時候先傳遞部分參數(shù)去調(diào)用他（這部分參數(shù)以后永遠不變）
然后返回一個新的函數(shù)接收剩余參數(shù)，并返回結(jié)果
柯里化模擬實現(xiàn)

// curry
function curry (fn) {
    return function (...args) {
        if (args.length < fn.length) {
            return function() {
                return fn(...args, ...arguments)
            }
        }
        return fn(...args)
    }
}

柯里化總結(jié)
- 柯里化可以使我們給一個函數(shù)傳遞較少的參數(shù)睹酌，生成一個記住了某些參數(shù)的新函數(shù)
- 是一種對函數(shù)的緩存
- 使函數(shù)的粒度更小
- 可以將多元（多參數(shù)）函數(shù)轉(zhuǎn)化為一元（單參數(shù)）函數(shù)

函數(shù)組合(compose)

函數(shù)組合可以把細粒度的函數(shù)重新組合成新的函數(shù)
如果一個函數(shù)需要多個函數(shù)處理才能得到最終值权谁，我們可以將中間過程的函數(shù)合并成一個函數(shù)
函數(shù)組合默認從右向左執(zhí)行

compose函數(shù)模擬實現(xiàn)

// compose
const compose = (...fns) => (...args) => fns.reduceRight((fn1, fn2) => ()=> fn2(fn1(...args)))()

lodash中的組合函數(shù)
- flow() 從左向右組合執(zhí)行
- flowRight() 從右向左組合執(zhí)行
lodash/fp模塊
- 提供了對函數(shù)式編程友好的方法
- fp模塊中提供的方法（例如：map、filter憋沿、split等）都是被柯里化的
- 多個參數(shù)的方法函數(shù)優(yōu)先旺芽，數(shù)據(jù)滯后（默認為數(shù)據(jù)優(yōu)先、函數(shù)滯后辐啄，例如map(array, func))
lodash-map方法的小問題：parseInt參數(shù)問題
- map(array, func(item, index, array))
- parseInt(string, radix)
  - string 待parse字符串
  - radix 進制
- map傳遞給parseInt 3個參數(shù)采章，將index當成了radix，由此引發(fā)問題
- fp.map柯里化后的func只接收一個參數(shù)壶辜，因此沒有此問題
函數(shù)組合只能組合單參數(shù)函數(shù)悯舟？
PointFree
- 不需要指明處理的數(shù)據(jù)
- 只需要合成運算過程
- 需要定義一些輔助的基本運算函數(shù)

函子（Functor）

容器：包含值和值的變形關(guān)系（變形關(guān)系即函數(shù)）
函子：是一個特殊的容器，通過一個普通對象來實現(xiàn)砸民，該對象具有map方法抵怎，map方法可以運行一個函數(shù)對值進行變形處理
函子用來處理副作用、異步操作岭参、異常處理等

函子對象class實現(xiàn)

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

總結(jié)
- 函數(shù)式編程的運算不直接操作值便贵，而由函子完成
- 函子就是一個實現(xiàn)了map契約的對象
- 函子中封裝了一個值，想要操作值冗荸，就給map傳遞一個處理值的函數(shù)（純函數(shù)）
- 最終返回一個新的函子

函子介紹

MayBe函子
- 用于處理空值（null、undefined）

class MayBe extends Functor {
    isNothing() {
        return this._value === null || this._value === undefined
    }
    map(fn) {
        return this.isNothing() ? MayBe.of(null) : MayBe.of(fn(this._value))
    }
}

Either函子
用于處理異常
類似于if...else
Left函子 + Right函子
IO函子
- IO函子的value是一個函數(shù)利耍，將函數(shù)作為值來處理
- IO函子可以把不純的動作存儲到_value中蚌本，延遲執(zhí)行（惰性執(zhí)行）

class IO extends Functor {
    static of(value) {
        return new IO(function() {
            return value
        })
    }
    map(fn) {
        return new IO(fp.flowRight(fn, this._value))
    }
}

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: e => console.log(e),
        onResolved: d => console.log(d),
    })

Pointed函子
- 實現(xiàn)了of靜態(tài)方法的函子
- of靜態(tài)方法避免了使用new 來創(chuàng)建對象
- 更深層的含義是of方法用來把值放到上下文Context（把值放到容器中盔粹，使用map來處理）
Monad函子
- 一個函子具有join和of兩個方法，并遵守一定規(guī)律程癌，就是Monad函子
- 可以變扁的Pointed函子

folktale 一個標準的函數(shù)式編程庫
- 提供了compose舷嗡、curry等函數(shù)
- 提供了Task、Maybe嵌莉、Either等函子
- 用法自行百度

學習筆記（一）—— 函數(shù)式編程

函數(shù)一等公民 (First-class Function)

高階函數(shù)（Higher-order Function）

常用的高階函數(shù)及模擬實現(xiàn)

閉包 （Closure）

純函數(shù)

Lodash

純函數(shù)的好處

副作用

柯里化（Currying）

函數(shù)組合(compose)

函子（Functor）

閉包（Closure）