Javascript函数质询add(1,2）和add(1）(2）都应该返回3

我写了一个curried函数，无论每次传递多少个参数，它的valueOf()方法和函数上下文(this(都和sum绑定。

/* add function */
let add = function add(...args) {
  const sum = args.reduce((acc, val) => acc + val, this);
  const chain = add.bind(sum);
  chain.valueOf = () => sum;
  return chain;
}.bind(0);
/* tests */
console.log('add(1, 2) = ' + add(1, 2));
console.log('add(1)(2) = ' + add(1)(2));
/* even cooler stuff */
console.log('add(1, 2)(3) = ' + add(1, 2)(3));
console.log('add(1, 2, 3)(4, 5)(6) = ' + add(1, 2, 3)(4, 5)(6));
/* retains expected state */
let add7 = add(7);
console.log('let add7 = add(7)');
console.log('add7(3) = ' + add7(3));
console.log('add7(8) = ' + add7(8));

之所以需要这两种机制，是因为add()的主体必须使用被调用函数的绑定上下文才能访问中间部分应用程序的和，而调用站点必须使用valueOf()成员(隐式或显式(才能访问最终和。

多布斯博士期刊上有一篇关于"JavaScript中的Currying和偏函数"的文章，正是描述了这个问题。

本文中的一个解决方案是：

// a curried add
// accepts partial list of arguments
function add(x, y) {
     if (typeof y === "undefined") { // partial
        return function (y) {
              return x + y;
        };
     }
   // full application
   return x + y;
}

function add(num1, num2){
    if (num1 && num2) {
        return num1 + num2;
    } else if (num1) {
        return function(num2){return num1 + num2;};
    }
    return 0;
}

您正在寻找的概念被称为currying，它与函数转换和部分函数应用有关。当您发现自己用几乎相同的参数反复调用同一个函数时，这很有用。

通过currying实现add(2)(6)的示例如下。。。

function add(x,y) { 
  if (typeof y === 'undefined') {
    return function(y) {
      return x + y;
    }
  }
}
add(2)(4); // => 6

此外，你可以做这样的事情。。。

var add6 = add(6);
typeof add6; // => 'function'
add6(4);     // => 10

var add = function(){
  // the function was called with 2 arguments
  if(arguments.length > 1)
    arguments.callee.first_argument = arguments[0];
  // if the first argument was initialized
  if(arguments.callee.first_argument){
    var result = arguments.callee.first_argument + arguments[arguments.length - 1];
    arguments.callee.first_argument = 0;
    return result;
  }else{// if the function was called with one argument only then we need to memorize it and return the same function handler 
    arguments.callee.first_argument = arguments.callee.first_argument || arguments[0];
    return arguments.callee;
  }
}
console.log(add(2)(4));
console.log(add(2, 4));

取决于环境的扩展解决方案：

function add(){
  add.toString = function(){
    var answer = 0;
    for(i = 0; i < add.params.length; i++)
      answer += add.params[i];
    return answer;
  };
  add.params = add.params || [];
  for(var i = 0; i < arguments.length; i++)
    add.params.push(arguments[i])
  return add;
}
console.log(add(2)(4)(6)(8))
console.log(add(2, 4, 6, 8));

我们可以使用Javascript提供的闭包概念。

代码片段：

function add(a,b){
    if(b !== undefined){
        console.log(a + b);
        return;
    }
    return function(b){
        console.log(a + b);
    }
}
add(2,3);
add(2)(3);

通常，您需要就函数是否应返回函数(用于使用更多参数进行调用(或最终结果达成一致。想象一下add函数也必须这样工作：

add(1, 2, 3)(4, 5)  // -> 15

然后它变得模棱两可，因为你可能想再次调用：

add(1, 2, 3)(4, 5)(6)  // -> 21

因此add(1, 2, 3)(4, 5)应该返回一个函数，而不是15。

例如，您可以同意必须再次调用函数，但不带参数，以获得数字结果：

function add(...args) {
    if (args.length === 0) return 0;
    let sum = args.reduce((a, b) => a+b, 0);
    return (...args) => args.length ? add(sum, ...args) : sum; 
}
console.log(add()); // 0
console.log(add(1,2,3)()); // 6
console.log(add(1,2,3)(4,5)()); // 15
console.log(add(1,2,3)(4,5)(6)()); // 21

人们可能认为他/她必须调用同一个函数两次，但如果你深入思考，你会意识到问题很直接，你必须调用一次add函数，然后你需要调用add函数返回的内容。

function add(a){
    return function(b){
        return a+b;
    }
}
console.log(add(20)(20));
//output: 40

您可以随时返回函数。假设y=mx+c

const y= function (m){
    return function(x){
        return function (c){
            return m*x+c
        }
    }
}
console.log(y(10)(5)(10)); 
//out put: 60