柯里化是 函数式编程 中的一个思想。

    分析curry函数：

    1. curry返回的是一个函数 fn；
    2. 执行fn，中间状态返回的是函数，如：add(1) / add(1)(2)；
    3. 最后返回执行结果，如：add(1)(2)(3)。
    1. function currying(fn, ...args) {
    2.     const len = fn.length; // Function.length 属性指明函数的形参个数
    3.     let allArgs = [...args]
    4.     const res = (...newArgs) => {
    5.         allArgs = [...allArgs, ...newArgs]
    6.         if (allArgs.length === len) {
    7.             // console.log('最后执行吗？')
    8.             return fn(...allArgs)
    9.         } else {
    10.             // console.log('啥时执行？')
    11.             return res
    12.         }
    13.     }
    14.     return res
    15. }
    17. var add = (a, b, c) => a + b + c;
    18. var a = currying(add, 1)
    19. a(2)(3) // 或 a(2, 3)，保证形参和 add 函数所需形参个数相同
    1. function curry(...fn) {
    2.   const fnLen = fn.length; // 传入函数的参数长度，也就是 add 函数的参数长度：3
    3.   const cacheArgs = []; // 收集参数
    5.   // 返回的函数
    6.   function calc(...args) {
    7.     // 积累参数
    8.     cacheArgs = [...cacheArgs, ...args];
    10.     // 判断参数长度
    11.     if (cacheArgs.length < fnLen) {
    12.       // 若参数长度不够 add 函数所需参数长度，则返回函数
    13.       return calc;
    14.     } else {
    15.       // 若参数长度够了，返回计算结果
    16.       return fn.apply(this, cacheArgs.slice(0, fnLen)); // slice 避免传入超长参数，超长参数无用
    17.     }
    18.   }
    19.   return calc;
    20. }
    22. var add = (a, b, c) => a + b + c;
    23. var a = currying(add)
    24. a(1)(2)(3) // 或 a(1, 2, 3)，保证形参和 add 函数所需形参个数相同