高阶函数和函数柯里化 持续更新中...

 1 函数柯里化定义

      把接受多个参数的函数变换成接受一个单一参数（最初函数的第一个参数）的函数，并且返回接受余下的参数而且返回结果的新函数

   2 柯里化函数实例

       function curry (fn) {
    return function curriedFn(...args) {
       console.log(1111,args)
        // 判断实参和形参的个数
        // 如果传递参数个数小于形参的个数，返回一个函数
        if (args.length < fn.length) {
            return function () {
                // 这个函数中的参数可以通过arguments来获取
                // 将多次传入的参数合并成一个数组，然后展开传递
                // arguments是一个类数组，需要使用Array.from来转换成一个数组
                console.log(22222,arguments)
                return curriedFn(...args.concat(Array.from(arguments)))
            }
        }
        // 如果传递的参数个数大于等于形参个数，直接返回执行结果
        return fn.apply(fn, args)
    }
}
  

  不管传几个参数，调用方式不同，结果都一样

  例如2：

柯里化函数通过比较函数的长度和传参的长度来判断是否递归
function curry(func, args) {
  // 表示所需要参数的个数
  let funcLen = func.length;
  let argsTemp = args || [];
 
  return function() {
    // 由于参数是一个类数组不是真正的数组，这里需要转换一下
    let _args = [].slice.call(arguments);
    _args = [...argsTemp, ..._args]

    // 如果参数的数量还不足，则还需要递归收集参数
    if (_args.length < funcLen) {
      return curry.call(this, func, _args);
    }
    // 收集完毕则执行func函数
    return func.apply(this, _args);
  }
}
//调用curry 
var add = curry(function(a,b,c){
    return a+b+c
})
add(2)(2)(3) // 7
add(2,2)(3) // 7

3 总结 

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

1  compose函数，要求结果从右往左依次执行

      引用txm

function compose (...args) {
    return function (value) {
        // 因为是从右开始执行，所以需要将传入的多个函数先进行反转
        return args.reverse().reduce((res, fn) => {
            return fn(res)
        }, value)
    }
}
// 使用箭头函数来书写
const compose = (...args) => value => args.reverse().reduce((res, fn) => fn(res), value)

// test
const reverse = arr => arr.reverse()
const first = arr => arr[0]
const toUpper = s => s.toUpperCase()
const f = compose(toUpper, first, reverse)
console.log(f(['one', 'two', 'three']))