函数式编程学习记录

函数式编程主要概念
1.将函数进行科里化使函数可以进行任意函数组合生成新的函数
2.通过不同函数的重复组合提高开发效率，进行少代码重复，使代码更清晰

1.函数科里化

作用：把函数中的参数暂时保存起来，返回一个新的函数
目标：
addCurry(1,2) // 3
addCurry(1)(2) // 3

/**
* 用递归函数 创建柯里化函数
*/ 
const curry = (fn: Function, ...args: any[]) => {
    if (args.length >= fn.length) {
        return fn.apply(this, args);
    } else {
        return (...arg: any[]) => curry(fn, ...args, ...arg,)
    }
}

//基本用法
const add = (a,b) => a + b
const addCurry = addCurry(add)

addCurry(1,2) // 3
addCurry(1)(2)// 3
 //常用示例
const add10 = addCurry(10) //返回新的函数但是不执行 add
	add10(12)// 22
	add10(3)// 13

2.函数组合

函数柯里化常用的场景是为了，通过函数组合生成新的函数。
目标：解决以下包洋葱的问题
reduceCurry(addCurry(10))

 /** 
 * @name 组合函数
 * @param args 数组函数 
 * @returns  从左到右执行函数并返回结果
 */ 
const compose = (...args: Function[]) => value => {
    return args.reduce(
        (total, currentValue) => currentValue(total),
        value
    )
}

const reduce = (a,b) => a - b  
const add = (a,b) => a + b
//先把函数进行科里化
const addCurry = addCurry(add)
const reduceCurry  = curry(reduce)

/**
* 使用函数组合 addCurry 和 reduceCurry 函数生成新的results函数
* 有一点需要注意的是compose函数是从右到左执行的 也就是说
* 先执行 reduceCurry  在执行  addCurry 
* 据说这么设计是为了更复合数学计算  
* */
let results =   compose(addCurry(5),reduceCurry(2))
results(10) // results函数 执行 10 + 5 - 2 
results(2) // results函数 执行 2 + 5 - 2

3.普通函子的调用

函子通俗定义有of 和map方法
目标：

// 普通函子
class Functor {
    constructor(value) {
        this.__value = value
    }

    static of(value) {
        return new Functor(value)
    }

    map(f) {
        return new Functor(f(this.val));
    }
}

const getValue = (value) => {
    return Functor.of(value)
}
const reduce = (a,b) => a - b  
const add = (a,b) => a + b
//先把函数进行科里化
const addCurry = addCurry(add)
const reduceCurry  = curry(reduce)

let res = getValue(2)
.map(add(5))
.map(val=>{
//在里面你可以对值进行各种修改
return val
})
.map(reduce(2))
// 2 + 5 -2  

4.Maybe函数

Maybe 函子主要用来处理空值

//Maybe 函子 处理空值
class Maybe {
    static of(value) {
        return new Maybe(value)
    }

    map(fn) {
        return this.isNothing() ? Maybe.of(null) : Maybe.of(fn(this.__value))
    }
    //Maybe 函子 验证空值
    isNothing() {
        return (this.__value === null || this.__value === undefined)
    }
}

总结

1.在小型简单应用中命令式编程更方便快捷。
2.在大型复杂应用中函数式编程语义更加的清晰，可维护性远大于命令式编程。
最后上干货
这是我这网上找的最全的函数式编程书籍了