函数式编程

参考

• JS 函数式编程指南

高阶函数

高阶函数接受一个函数作为参数，也可以传入其他参数， 最后返回另一个函数。返回的函数通常会添加一些增强的特殊行为。

const add = (x, y) => x + y;
const log = func => (...args) => {
    console.log(...args);
    return func(...args);
};
const logAdd = log(add);

logAdd(1,2)

纯函数

纯函数是指函数不产生副作用，它不会修改自身作用域以外的任何东西，同样的参数可以获得相同的结果。

// 纯函数
const add = (x, y) => x + y;

// 非纯函数，因为他修改了外部作用域的变量值，相同参数每次返回的结果无法保证一致
let x = 0;
const add2 = y => (x = x + y);

不可变性

不可变性是指一种操作变量的方式：函数不会修改变量的值，而是创建新的变量，赋新值然后再返回变量。

// 影响了参数的值
const add3 = arr => arr.push(3) 
const myArr = [1, 2] 
add3(myArr) // [1, 2, 3] 
add3(myArr) // [1, 2, 3, 3]

// 返回的是一个新的数组，不会影响入参的值
const add3 = arr => arr.concat(3)

Immutable（持久化数据结构）本身就是函数式编程中的概念，因为只要输入一致，输出必然一致，这样开发的组件更易于调试和组装。

参考：Immutable.js

柯里化

柯里化过程就是将多参数函数转换成单参数函数，这些单参数函数的返回值也是函数。

const add = x => y => x + y;

const add10 = add(10) // 通过科里化，可以将某个步骤之前的参数都缓存起来，返回的函数可以复用
add10(100) // 110
add10(20) // 30

const add100 = add(100)
add100(1) // 101

实现柯里化

function currying(fn, ...args) {
    // fn.length表示函数接收的形参个数
    if (args.length >= fn.length) {
        return fn(...args);
    } else {
        return (...args2) => currying(fn, ...args, ...args2);
    }
}
function fun(a, b, c) {
    console.log(a, b, c)
}

const curryingFun = currying(fun);
curryingFun(1)(2)(3); // 1 2 3
curryingFun(1, 2)(3); // 1 2 3
curryingFun(1, 2, 3); // 1 2 3

组合

组合就是结合两个或多个函数，从而产生一个新函数或进行某些计算的过程。

var compose = function(f, g){
    return function(x){
        return f(g(x))
    }
}