Question

如何编写add函数，以便我们可以将其称为

add(3,5);
// and 
add(3)(5);

在JavaScript中

？

Answer 1

这是一种通用方法来定义任何函数，只要它定义了所有形式参数（即它不适用于可变参数函数）。

function curry(f) {
    return function() {
        if (arguments.length >= f.length) {
            return f.apply(null, arguments);
        }
        var args = Array.prototype.slice.call(arguments, 0);
        return curry(f.bind.apply(f,[null].concat(args)));
    }
}

它的工作原理是将函数接受的参数数量（通过.length property公开）与传递给函数的参数数量进行比较。如果向函数传递的参数少于它接受的参数，则返回带有绑定参数的新函数。

用法：

function add(a, b, c) {
    return a + b + c;
}

add = curry(add);

console.log(add(1,1,1));   // 3
console.log(add(1,1));     // function
console.log(add(1,1)(2));  // 4
console.log(add(1)(2,2));  // 5
console.log(add(1)(2)(3)); // 6

演示：http://jsfiddle.net/90zs4n92/

可以找到避免绑定参数的替代实现here。

Answer 2

也许这就是你想要的？

function addFactory(a) {
  return function(b) {
    return a + b;
  };
}

//Make an addingFunction
var addThree = addFactory(3);

addThree(5);  // returns 8

//Or, in short
addFactory(3)(5);  // returns 8

您可以通过检查add(3,5)和参数类型，使函数同时处理add(3)(5) case和arguments.length case。但是，我认为只有2个函数和if语句才会更简单，更易读。不确定你用的是什么。

Answer 3

这将适用于任何一种方式：

add = function(a, b) {
    if(b === undefined) {
        return function(b) {
            return add(a, b);
        }
    }
    return a + b;
}
alert(add(3)(5));
alert(add(3, 5));

Answer 4

你想写一个curryable函数 - 一个接收 n 数量参数的函数，但是如果你在没有所有参数的情况下调用它，它会返回一个部分应用的函数。

var add = function(a, b) {
    if(arguments.length === 2) {
        return a + b;
    }
    else {
        return function(x) { return x + a }
    }
}

var addFour = add(4); 

add(4, 3); // => 7
add(4)(3); // => 7
addFour(3); // => 7

Answer 5

试试这个

function add() {
   //Check the number of arguments
   var argLength = arguments.length;

   //No arguments
   if(argLength == 0) {
      return null;
   }

   //Only one argument, then return another function. 
   if(argLength == 1) {
      var first = arguments[0];
      return function(second) {
         return first + second;
      }
   }

   //More than one argument, then add them all.
   var output = 0;
   for(var i = 0; i < argLength; i++) {
      output += arguments[i];
   }
   return output;
}

Answer 6

这是基于我原始评论的解决方案。顺便说一句，我看到每个人都有相同的想法（返回一个function对象。）。

var add = (function(x, z) {
    return (typeof(z) !== "undefined") ? x + z : function(y) { return x + y; }
});

var value = add(3)(5);
alert(value); // 8

value = add(3, 5);
alert(value); // 8

如果您的问题的原始目标是关于 currying ，我使用JavaScript找到了一个有趣的文档：https://medium.com/@kbrainwave/currying-in-javascript-ce6da2d324fe

Answer 7

你可以这样做：

   function add(a, b) {
    if(b === undefined || arguments.length !== 2) {
        return function(b) {
            return add(a, b);
        }
    }
    return a + b;
}
alert(add(3)(5));
alert(add(3, 5));

Answer 8

Currying是指将一个函数分解为一系列函数的函数，这些函数将参与一部分参数。这是Scheme

中的一个例子

(define (add a b)
(+ a b))

(add 3 4) returns 7

这是一个带有两个参数a和b的函数，并返回它们的总和。我们现在将讨论这个功能：

(define (add a)
    (lambda (b)
        (+ a b)))`

这是一个函数，它接受一个参数a，并返回一个带有另一个参数b的函数，该函数返回它们的总和。

((add 3) 4)

(define add3 (add 3))

(add3 4)

第一个语句返回7，就像（add 3 4）语句一样。第二个语句定义了一个名为add3的新函数，它将为其参数添加3。这是有些人可能称之为封闭的。第三个语句使用add3操作添加3到4，结果再次产生7。

无法在JavaScript中编写add方法

8 个答案: