函数柯里化与不定参数处理

题目一：函数式编程当中有个非常重要的概念就是 函数柯里化，一个接受 任意多个参数 的函数，如果执行的时候传入的参数不足，那么它会返回新的函数，新的函数会接受剩余的参数，直到所有参数都传入才执行操作。这种技术就叫柯里化，请你完成 curry 函数，它可以把任意的函数进行柯里化，效果如下：
const f = (a, b, c d) => { ... }
const curried = curry(f)
curried(a, b, c, d)
curried(a, b, c)(d)
curried(a)(b, c, d)
curried(a, b)(c, d)
curried(a)(b, c)(d)
curried(a)(b)(c, d)
curried(a, b)(c)(d)
// 这些函数执行结果都一样
例如：
const add = curry((a, b ,c ,d) => a + b + c +d)
add (1,2,3,4)=10
add(1)(2,3)(4)=10
add(1,2,3)(4)=10
add(1)(2)(3)(4)=10

题目二：不定参数处理
实现一个add方法，使计算结果能够满足如下预期：
add(1)(2)(3) = 6;
add(1, 2, 3)(4) = 10;
add(1)(2)(3)(4)(5) = 15;

答案
首先函数柯里化因为参数固定，使用vars数组保存每次传进来的参数，然后判断fn的参数个数，如果fn参数个数正好等于vars数组中保存的个数，那么执行fn，否则递归一次，返回curried函数，继续等待输入。这里外层curry 函数只会执行一次便会被剥离，之后add会变成curried的一个引用，同时curried可以闭包引用外层的vars，使得每次传入的参数可以长久保存。

      我的答案一：函数柯里化
        const curry = (fn,vars=[]) =>{
            const curried=(...args)=>{
                for(let i of [...args]){
                    vars.push(i)
                }
                if(vars.length==fn.length){
                    return fn(...vars)
                }else{
                    return curry(fn,vars)
                }
            }
            return curried
        }

网上更为优秀的答案：用延展符将push做了简化
const curry = (f, args1 = []) => (...args2) => {
  const args = [ ...args1, ...args2 ]
  return f.length === args.length
  ? f(...args)
  : curry(f, args)
}

参考上面网上优秀答案的思路，写出这个不定参数处理add函数，...args可以接受不定参数，由于题目二中并没有题目一中const add = curry((a, b ,c ,d) => a + b + c +d)函数劫持的过程，所以不能直接返回函数定义，而是要返回一个执行完的函数curried(...args)，同时在curried中再返回一个函数定义curried，这样就可以把函数连接起来了。由于参数不定，这里对每次传入的参数都要进行执行处理，执行方法是利用函数的隐式转换，当函数执行结束时会有一个toString的操作，来使函数能参与其他的运算，这里我们将toString从新定义，返回vars中的累加值，从而实现add运算。

      我的答案二：不定参数处理
      const add=(...args)=>{
            let vars=[]
            const curried=(...c)=>{
                vars=[...vars,...c]
                return curried
            }
            curried.toString=()=>{
                 return vars.reduce((a,b)=>a+b,0)
            }
            return curried(...args)
        }