函数curry化

前言

最近的某次面试被问到了两次相关的问题，但是自己居然都没答好，尤其第二次，先来看看面试官给的题目是什么样子的：

   // 实现一个函数add使得下面这段代码返回true
  add(1)(2)(3) === add(0)(2)(4);

这一问给我问懵逼了，add(1)(2)(3)() === add(0)(2)(4)();这样的咱会实现啊，你再多加几个参数咱也能实现啊，但是最后没有()的情况咋整啊，啥时候判断该返回结果而不是返回函数呢？想了半天咱也没写出代码，结果面试官写了这样一段代码：

  function add(num1) {
    return function (num2) {
      return function (num3) {
        return num1 + num2 + num3;
      }
    }
  }

敢情不用判断什么时候该返回结果，题目就是指定了调用三次.......，还是自己想得太多，思维固化了，那既然这样，当然也可以给出这样一个答案：

  function add(num1) {
    return function (num2) {
      return function (num3) {
        return 'anything';
        // 注意这里真的返回anything就行了
      }
    }
  }

关于函数curry化，其实就类似与链式调用的思想，通过不断返回函数，使得可以执行多个'(...args)'，在适当的时候返回结果

函数curry化的实现：

1. 泛化的curry化

    let sum=function () {
        var total = 0;
        for (let i = 0, c; c = arguments[i++];) {
            total += c;
        }
        return total;
    };

    let curry = (fn) => {
        let args = [];

        // 不用callee这个属性，而是直接使用函数名字来调用
        return function next() {
            if(arguments.length === 0) {
                return fn.apply(this, args);
            }
            // curry化之后的函数使用方式是，不断收集参数，认为参数收集完毕之后就进行一次无参调用进行最后的计算。
            // 所以curry化在这里的作用其实就是收集参数，当然不同的curry函数可以达到不同的效果
            args = [...args, ...arguments];
            // return arguments.callee;
            return next;
        }
    }


    let sum_curry1 = curry(sum);
    sum_curry1(1)(2,3);
    sum_curry1(4);
    console.log(sum_curry1());

curry化的作用

1. 提高适用性

【通用函数】解决了兼容性问题，但同时也会再来，使用的不便利性，不同的应用场景往，要传递很多参数，以达到解决特定问题的目的。有时候应用中，同一种规则可能会反复使用，这就可能会造成代码的重复性。
看下面一个例子：

    function square(i) {
        return i * i;
    }

    function dubble(i) {
        return i *= 2;
    }

    function map(handeler, list) {
        return list.map(handeler);
    }

    // 数组的每一项平方
    map(square, [1, 2, 3, 4, 5]);
    map(square, [6, 7, 8, 9, 10]);
    map(square, [10, 20, 30, 40, 50]);
    // ......

    // 数组的每一项加倍
    map(dubble, [1, 2, 3, 4, 5]);
    map(dubble, [6, 7, 8, 9, 10]);
    map(dubble, [10, 20, 30, 40, 50]);

例子中，创建了一个map通用函数，用于适应不同的应用场景。显然，通用性不用怀疑。同时，例子中重复传入了相同的处理函数：square和dubble。
应用中这种可能会更多。当然，通用性的增强必然带来适用性的减弱。

2. 延迟执行。

柯里化的另一个应用场景是延迟执行。不断的柯里化，累积传入的参数，最后执行。
看下面：

    let curry = (fn) => {
        let args = [];

        // 不用callee这个属性，而是直接使用函数名字来调用
        return function next() {
            if(arguments.length === 0) {
                return fn.apply(this, args);
            }
            // curry化之后的函数使用方式是，不断收集参数，认为参数收集完毕之后就进行一次无参调用进行最后的计算。
            // 所以curry化在这里的作用其实就是收集参数，当然不同的curry函数可以达到不同的效果
            args = [...args, ...arguments];
            // return arguments.callee;
            return next;
        }
    }