函数式编程

函数式编程

纯函数

纯函数符合以下特点：

1. 此函数在相同的输入值时，需产生相同的输出。
2. 函数的输出和输入值以外的其他隐藏信息或状态无关，也和由I/O设备产生的外部输出无关。
3. 该函数不能有语义上可观察的函数副作用，诸如“触发事件”，使输出设备输出，或更改输出值以外物件的内容等。

副作用：表示在执行一个函数时，除了返回函数值之外，还对调用函数产生了附加的影响，比如修改了全局变量，修改参数或者改变外部的存储。

柯里化函数

柯里化函数：只传递给函数一部分参数来调用它，让它返回一个函数去处理剩余的参数

柯里化函数的优势

1. 让每一个函数处理的问题尽可能的单一
2. 逻辑复用

//柯里化函数的用途
//1.让每一个函数处理的问题尽可能的单一
function add2(n) {
    n = n + 2;
    return function(x) {
        x = x * 2;
        return function(y) {
            y = y ** 2;
            return n + x + y;
        }
    }
}

var r = add2(10)(5)(20);
console.log(r);

//2.逻辑复用
function foo(m) {
    m = m * 2;
    return function(x) {
        return m + x;
    }
}

var fn = foo(10);
console.log(fn(5));
console.log(fn(10));

普通函数转为柯里化函数

// 柯里化函数的实现hyCurrying
function hyCurrying(fn) {
    function curried(...args) {
        // 判断当前已经接收的参数的个数, 可以参数本身需要接受的参数是否已经一致了
        // 1.当已经传入的参数 大于等于 需要的参数时, 就执行函数
        if (args.length >= fn.length) {
            // fn(...args)
            // fn.call(this, ...args)
            return fn.apply(this, args)
        } else {
            // 没有达到个数时, 需要返回一个新的函数, 继续来接收的参数
            function curried2(...args2) {
                // 接收到参数后, 需要递归调用curried来检查函数的个数是否达到
                return curried.apply(this, args.concat(args2))
            }
            return curried2
        }
    }
    return curried
}

组合函数

当我们对一个数据进行处理时，需要反复按次序调用多个函数时，我们可以封装一个组合函数，来实现多次按次序的调用。

组合函数的封装:

//多个函数执行的组合函数
function hyCompose(...fns) {
    //遍历所有的参数，看看是不是函数
    var length = fns.length;
    for (let i = 0; i < length; i++) {
        var fn = fns[i];
        if (typeof fn !== 'function') {
            throw new TypeError('Expected are function');
        }
    }
    return function(...args) {
        var index = 0;
        //判断是否有函数参数，如果没有返回传入的值
        var result = length ? fns[index].apply(this, args) : args;
        while (++index < length) {
            result = fns[index].call(this, result);
        }
        return result;
    }
}