函数柯里化

function rawMethod(a) {
    return a + 1;
}
function middleware1(next) {
    return function(a) {
        return next(a) + 1;
    };
}
function middleware2(next) {
    return function(a) {
        return next(a) + 1;
    };
}
function middleware3(next) {
    return function(a) {
        return next(a) + 1;
    };
}

// 请实现该方法
const applyMiddleWare = (originalMethod, ...args) => {
    // 请实现该方法
    const applyMiddleWare = (originalMethod, ...args) => {
        // 根据题目，需要如下处理函数：middleware3(middleware2(middleware1(rawMethod)))(n)
        // 这个函数层层嵌套，那么可以使用数组的reduce方法
        // 查看执行顺序，和reduce的顺序，这里除了第一个函数外，需要取相反方向，不能用sort，会改变原数组

        /*
        let funs = [].concat(originalMethod,args);
        let initFn = funs[0]
        let otherFn = []
        for(let i=funs.length-1;i>0;i--){
            otherFn.push(funs[i])
        }

        return otherFn.reduce((result, current) => {
            return current(result)
        },initFn)
        */

        // 上过面的方法只要执行 applyMiddleWare 就已经执行了他的参数方法
        // 所以 applyMiddleWare(newMethod, middleware1) 这里的23先于1执行
        // 那么就考虑将参数方法在包一层，在函数调用里执行
        let funs = [].concat(originalMethod,args)
        const len = funs.length
        if(len === 0){
            return arg => arg;
        }else if(len === 1){
            return funs[0]
        }else{
            return funs.reduce((a, b) => {
                return (n)=> {
                    return b(a)(n)
                }
            })
        }
    }
}

// 上面函数实际上返回如下
let z1 = n => middleware1(n => middleware2(n => middleware3(rawMethod)(n))(n))(n)
// 1. n => 里面函数结果 + 1
// 2. 里面函数结构 = 里面函数结构 + 1
// 3. 里面函数结构 = 里面函数结构 + 1 ...
// 4. 到了 rawMethod， rawMethod(n) + 1 + 1 + 1 

console.log(z1(1))

var newMethod = applyMiddleWare(rawMethod, middleware3, middleware2)
// 调用顺序：middleware2 -> middleware3 -> rawMethod，结果：x=3
var x = newMethod(1)
console.log(x)

var newMethod2 = applyMiddleWare(newMethod, middleware1);
// 调用顺序：middleware1 -> middleware2 -> middleware3 -> rawMethod，结果：y=13
var y = newMethod2(10)
console.log(y)