第 84 题：请实现一个 add 函数，满足以下功能。

[yygmind]

add(1); 	// 1
add(1)(2);  	// 3
add(1)(2)(3)；  // 6
add(1)(2, 3);   // 6
add(1, 2)(3);   // 6
add(1, 2, 3);   // 6

[yygmind]

之前写过 2 篇文章，可以参考一二。
1、【进阶 6-1 期】JavaScript 高阶函数浅析
2、【进阶 6-2 期】深入高阶函数应用之柯里化

其中第一篇文章给出了前三个功能的实现，并没有覆盖到后面三种。
第二篇文章实现了一个通用的柯里化函数，覆盖实现了所有功能。

[yygmind]

实现 1：

function currying(fn, length) {
  length = length || fn.length; 	// 注释 1
  return function (...args) {			// 注释 2
    return args.length >= length	// 注释 3
    	? fn.apply(this, args)			// 注释 4
      : currying(fn.bind(this, ...args), length - args.length) // 注释 5
  }
}

实现 2：

const currying = fn =>
    judge = (...args) =>
        args.length >= fn.length
            ? fn(...args)
            : (...arg) => judge(...args, ...arg)

其中注释部分

• 注释 1：第一次调用获取函数 fn 参数的长度，后续调用获取 fn 剩余参数的长度

• 注释 2：currying 包裹之后返回一个新函数，接收参数为 ...args

• 注释 3：新函数接收的参数长度是否大于等于 fn 剩余参数需要接收的长度

• 注释 4：满足要求，执行 fn 函数，传入新函数的参数

• 注释 5：不满足要求，递归 currying 函数，新的 fn 为 bind 返回的新函数（bind 绑定了 ...args 参数，未执行），新的 length 为 fn 剩余参数的长度

[ZodiacSyndicate]

const curry = (fn, arity = fn.length, ...args) =>
  arity <= args.length ? fn(...args) : curry.bind(void 0, fn, arity, ...args);

[zhouyangit]

function add() {
  let args = [].slice.call(arguments);
  let fn = function(){
   let fn_args = [].slice.call(arguments)
   return add.apply(null,args.concat(fn_args))
 }
fn.toString = function(){
  return args.reduce((a,b)=>a+b)
}
return fn
}

[ablikim915]

function add(){
	let args = [...arguments];
	let addfun = function(){
		args.push(...arguments);
		return addfun;
	}
	addfun.toString = function(){
		return args.reduce((a,b)=>{
			return a + b;
		});
	}
	return addfun;
}

[ablikim915]

还有一种方法

function add(){
	if(arguments.length === 0){
		let num = 0;
		add.args.forEach(v=>{
			num += v;
		});
		add.args = null;
		return num;
	}else{
		add.args = add.args ? add.args : [];
		add.args = add.args.concat([...arguments]);
		return add;
	}
}
add(1)(2)(3)();
add(1, 2)(3)(8)();

[GitHdu]

function curry (fn) {
  const finalLen = fn.length
  let args = [].slice.call(this,1)
  return function currying () {
    args = args.concat(Array.from(arguments))
    const len = args.length
    return len >= fn.length ? fn.apply(this, args) : currying
  }
}
function add (a,b,c) {
  return a+b+c
}
const add1 = curry(add)
console.log(add1(1, 2)(3))

[CoffeeWorm]

function add(...args) {
  let sum = 0;
  const innerAdd = (...args) => {
    args.forEach(i => (sum += i));
    return innerAdd;
  };
  innerAdd.toString = () => sum;
  return innerAdd(...args);
}

[seognil]

如果要做成高阶函数以便支持任意迭代器，累加器的初始值设定要麻烦一点
尤其是考虑到任意长度输入和空输入，要多一些判断逻辑。

写了一个支持以上所有特性的

const curryReducer = (fn) => {
  return (...args) => {
    let runned = false;
    const chain = (...args) => {
      if (!args.length) return chain;
      chain.acc = (runned ? [chain.acc] : []).concat(args).reduce(fn);
      !runned && (runned = true);
      return chain;
    };
    chain.acc = undefined;
    chain.toString = () => chain.acc;
    return chain(...args);
  };
};

// * ---------------- simple add function

const add = curryReducer((a, e) => a + e);

console.log('' + add(1, 2, 3)()(4, 5)(6)(7)(8, 9, 10));

const method = {
  add: (a, e) => a + e,
  minus: (a, e) => a - e,
  times: (a, e) => a * e,
  devide: (a, e) => a / e,
};
Object.values(method).forEach((e) => {
  console.log('batch test -------------- method is: ', e);
  const chainFn = curryReducer(e);
  console.log('' + chainFn());
  console.log('' + chainFn(6));
  console.log('' + chainFn(6, 2));
  console.log('' + chainFn(6)(2));
  console.log('' + chainFn()(6)(2));
  console.log('' + chainFn(6, 2, 3));
  console.log('' + chainFn(6, 2)(3));
  console.log('' + chainFn(6)(2)(3));
});

[linchengzzz]

function add(...a) {
    let sum = a.reduce((p, n) => p + n);

    function next(...b) {
        let _sum = b.reduce((p, n) => p + n);
        sum = sum + _sum;
        return next;
    }

    next.toString = function () {
        return sum;
    };

    return next;
}

[wjryours]

function currying(fn, length) {
  length = length || fn.length; 	// 注释 1
  return function (...args) {			// 注释 2
    return args.length >= length	// 注释 3
    	? fn.apply(this, args)			// 注释 4
      : currying(fn.bind(this, ...args), length - args.length) // 注释 5
  }
}
const sum = function(t,y,u){
    let args = [].slice.call(arguments)
    return args.reduce((a, b) => a + b)
} ;
    const add = currying(sum);
    console.log(add(1,2)(2)(9)) ;  	// Uncaught TypeError: add(...)(...) is not a function

请问这个调用这个柯里化函数sum中的形参还要自己手动补吗？
我看这个形参少于实际调用add函数时就会报错，还是我调用的方式错了呢？
@yygmind

[yygmind]

@wjryours sum 函数定义的参数长度为 3，调用时参数为 4，所以问题出在这里

[ryanZiegler]

@wjryours sum 函数定义的参数长度为 3，调用时参数为 4，所以问题出在这里

柯里化生成的 add 函数若是存储的形参个数达不到定义的参数长度, 则是返回 [Function]

那么如题 add(1) ==>1 , add(1)(2) ==> 3 则不是没有实现吗

[wjryours]

@wjryours sum 函数定义的参数长度为 3，调用时参数为 4，所以问题出在这里

柯里化生成的 add 函数若是存储的形参个数达不到定义的参数长度, 则是返回 [Function]

那么如题 add(1) ==>1 , add(1)(2) ==> 3 则不是没有实现吗

我想表达的就是这个意思，按照你这个写法那些基本的功能都通过不了，可以解答一下吗@yygmind

[seognil]

@wjryours sum 函数定义的参数长度为 3，调用时参数为 4，所以问题出在这里

柯里化生成的 add 函数若是存储的形参个数达不到定义的参数长度, 则是返回 [Function]
那么如题 add(1) ==>1 , add(1)(2) ==> 3 则不是没有实现吗

我想表达的就是这个意思，按照你这个写法那些基本的功能都通过不了，可以解答一下吗@yygmind

我觉得题目出的不好(描述有歧义)。
我的理解里，题目本身和柯里化是有差异的，
题目更像是迭代器而不是柯里化。

如果是柯里化，那么缺少参数的时候是等待所有参数到齐则再开始进行运算，并返回计算结果。
（因为不是所有方法都像 add 一样简单，能支持部分参数计算，不然因为缺少参数，计算逻辑报错了怎么办？）
参数不足的时候返回一个中间 function，以便继续调用。

至于直接能读到（toString），这是一个 trick。
对于柯里化这个高阶方法来说，我觉得不应该一起实现。
就像我说的，是应该等参数到齐再计算（固定参数 function 的 length），
可以参考一下 lodash 或者 ramda 里的 curry

至于如何实现题目本身
（任意长度也能返回计算结果，也就是说，调用一次执行一次）
（像我上面说的，更像是实现一个迭代器，add 只是一个算子）
可以参考一下我的答案
#134 (comment)
Inspired by @CoffeeWorm
#134 (comment)