对函数式编程的认识、理解笔记

函数式编程（Function Programing）是一种编程范式.

函数式编程的思维：把现实的事物与事物间的联系抽象到程序中，也就是：对运算过程的抽象.

程序的本质就是：根据输入通过运算得到输出.      相同的输入始终要得到相同的输出（纯函数）

函数不是方法，而是数学中的函数，如y=f(x),一种映射关系.

如下代码函数式和非函数式

// 非函数式
let b1 = 2;
let b2 = 4;
let sum = b1 + b2;
console.log(sum)

//函数式
function add(a,b) {
    return a + b
}
let sum =add(2,4)
console.log(sum)

---

函数是一等公民，可以作参数、返回值以及存储在变量中。

在JavaScript中函数就是一个普通的对象（通过new Function（））

//函数赋值给变量
let fn = function() {
    console('我存储在变量中')
}


//函数作为参数
function forEach(array,fn) {
    for(let i=0; i<array,length; i++) {
        fn(array[i])
    }
}

let arr =[1, 2, 3, 4, 5]
forEach(arr, function(item) {
        console.log(item)
    })


//函数作返回值

function FnVa() {
    let ss = 'Return Value'
    return function() {
        console.log(ss)
    }
}
const fn = FnVa();
fn() //Return Value

上面代码中，函数有作为参数和返回值，此时的函数属于高阶函数。

高阶函数是用来抽象通用的问题，抽象可以让我们不关注实现细节，只需知道如何使用，关注结果。

常用的高阶函数有：map、forEach、filter、every、find、reduce 等 ......

下面模拟一下map：

const map =(array,fn) => {
    let results = [];
    for(let value of array) {
        results.push(fn(value))
    }
    return results
}

let arr = [1, 2, 3, 4];
arr = map(arr, v => v*v)
console.log(arr)  // [1, 4, 9, 16]

---

闭包(closure):函数和其周围的状态（词法环境）的引用捆绑在一起形成的闭包。

可以在另一个作用域中调用一个函数的内部函数并访问到函数的作用域中的成员。

闭包的本质：函数在执行的时候会放到一个执行栈上，当函数执行完毕后会从执行栈上移除，但是堆上的作用域成员因为被外部引用不能释放，因此内部函数依然可以访问外部的函数成员。

纯函数：上面有提到。相同的输入永远会得到相同的输出，而且无任何可观察的副作用。类似数学中的函数关系。

lodash是一个纯函数的功能库，提供了一些对数组、数字、对象、字符串、函数等的操作方法。

在数组中的slice和splice分别是纯函数和不纯的函数，因为后者改变了原数组。

纯函数的优点：

可缓存：因为纯函数对相同的输入始终有相同的输出，所有可以把纯函数的结果缓存起来

并行处理：在多线程环境下并行操作共享的内存数据很可能出现意外情况。纯函数不需要访问共享的内存数据，所以在并行执行的环境下可以任意运行纯函数（Web Worker）

const _ = require('lodash')
function getArea(r) {
    return Math.PI * r * r
}

let getAreaMemory = _.memoize(getArea) //用lodash提供的memoize进行缓存


//对应相同的输入，第一次进行计算，其余直接取缓存数据
console.log(getAreaMemory(4))

console.log(getAreaMemory(4))
console.log(getAreaMemory(4))
console.log(getAreaMemory(4))

纯函数的副作用：副作用让一个函数变得不纯，纯函数根据相同的输入返回相同的输出，如果函数依赖于外部状态就无法保证输出相同，就会带来副作用。如下：

//不纯，因为mini从外部获取，对于相同的输入，当外部的mini改变时，就得不到相同的输出
let mini =18
function checkAge(age) {
    return age >= mini
}


//纯的,mini不受外部影响(存在硬编码，后续可以通过柯里化解决)

function checkAge(age) {
    let mini =18
    return age >= mini
}

所有的外部交互都用可能带来副作用，副作用会让方法的通用性下降，不适合扩展和可重用性。同时，副作用会给程序带来安全隐患，给程序带来不确定性，但是副作用不可能完全禁止，只能尽可能的控制它们在可控的范围内发生。

柯里化：当一个函数有多个参数的时候新传递一部分参数去调用它（这部分参数以后永不变化），然后返回一个新的函数接收剩余的参数，返回结果

//柯里化
function checkAge(min) {
    return function (age) {
        return age >=min
}
//先传递一个参数，保持不变
let checkAge18 = checkAge(18)


checkAge18(23)  //true
checkAge18(13)  //false
checkAge18(22)
checkAge18(33)

在上面提到的lodash库中，有柯里化函数—— _.curry(func)

功能：创建一个函数，该函数接收一个或者多个func参数，如果func所需要的参数都被提供，则执行func并返回执行结果。否则继续返回该函数并等待接收剩余的参数。

其参数为：需要柯里化的函数。   返回值： 柯里化后的函数

//柯里化方法的使用
const _ = require('lodash')
function sum(a, b, c) {
    return a+b+c
}
const curried = _curry(sum)
console.log(curried(1,2,3))
console.log(curried(1)(2,3))
console.log(curried(1,2)(3))

柯里化可以让我们给一个函数传递较少的参数得到一个已经记住了某些固定参数的新函数，这是一种对函数参数的缓存，让函数变得更加灵活，让函数的粒度更小，可以把多元函数转换成一元函数，可以结合使用函数产生强大的功能。

---

函数组合

纯函数和柯里化很容易写出洋葱代码，如h(g(f(x)))

获取数组的最后一个元素再转化为大写字母：_.toUpper(_first(_.reverse(array))

函数组合可以让我们把细粒度的函数重新组成一个新的函数

管道：

fn=compose(f3,f2,f1) //伪代码

b=fn(a)

函数组合（compose）:如果一个函数要经过多个函数处理才能得到最终值，这个时候可以把中间过程的函数合并成一个函数。函数就行数据的管道，函数组合就是把这些组合连接起来，让数据穿过多个管道形成最终结果。函数组合默认从右到左执行。

看一下lodash中的组合函数：flow()或者flowRight(),可以组合多个函数。f

low从左到右执行，flowRight从右到左执行，多用flowRight().

在lodash中有个fp模块

lodashd的fp模块提供了实用的对函数式编程友好的方法，提供了不可变的柯里化、函数优先、数据滞后的方法

const fp =require('lodash/fp')
fp.map(fp.toUpper,['a', 'b', 'c'])

fp.map(fp.toUpper)(['a', 'b', 'c'])

PointFree:我们可以把数据处理的过程定义成与数据无关的合成运算，不需要用到代表数据的那个参数，只要简单的运算步骤聚合到一起，在使用这种模式之前我们需要定义一些辅助的基本运算函数。

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

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

---

函子（Functor）

函子是一个容器，包含值和值的变形关系（函数），函子是一个特殊的容器，通过一个普通的对象来实现，该对象具有map方法，可以运行一个函数对值进行处理（变形关系）

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

 let r = Container.of(5)
        .map(x => x + 2)
        .map(x => x * x)
    
console.log(r) //Container { _value: 49 }

函数式编程的运算不直接操作值，而是由函子完成，想处理函子中的值，需要给map方法传递一个处理值的函数（纯函数），由这个函数来对值进行处理，最终maap方法返回一个包含新值的盒子（函子）。

介绍几种函子

MayBe 函子：对外部的空值情况做处理（控制副作用在允许的范围）

class MayBe {
    static of(value) {
        return new MayBe(value)
    }

    constructor(value) {
        this._value = value
    }

    map(fn) {
        return this.isNothing() ? MayBe.of(null) : MayBe.of(fn(this._value))
    }

    isNothing() {
        return this._value === null || this._value === undefined
    }
}

// let r = MayBe.of('Hello World')
//     .map(x => x.toUpperCase())
// console.log(r)

// let r = MayBe.of(null)
//     .map(x => x.toUpperCase())
// console.log(r)

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

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

// Eithter 函子

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))
    }
}
// 测试
// let r1 = Right.of(12).map(x => x + 2)
// let r2 = Left.of(12).map(x => x + 2)
// console.log(r1)
// console.log(r2)

function parseJSON(str) {
    try {
        return Right.of(JSON.parse(str))
    } catch (e) {
        return Left.of({ error: e.message })
    }
}

// let r = parseJSON('{ name: zs }')
// console.log(r)

let r = parseJSON('{ "name": "zs" }')
    .map(x => x.name.toUpperCase())
console.log(r)  // Right { _value: 'ZS' }

IO函子：IO函子中的_value是一个函数，这里把函数作为值来处理，可以把不纯的动作存储到_value中，延迟执行这个不纯的操作，包装当前的操作纯，把不纯的操作交给调用者来处理。

const fp = require('lodash/fp')
const { map } = require('lodash')

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

// 调用 
let r = IO.of(process).map(p => p.execPath)
console.log(r)  // IO { _value: [Function] }
console.log(r._value())  // F:\node\node.exe