我的一个朋友要求我编写一个适用于这两种情况的函数
add(2,4) // 6
add(2)(4) // 6
我的直觉是编写一个返回自身的 add() 函数，但我不确定我是否朝着正确的方向前进。这失败了。
function add(num1, num2){
if (num1 && num2){
return num1 + num2;
} else {
return this;
}
}
alert(add(1)(2));
所以我开始阅读返回其他函数或返回自身的函数。
我会继续尝试，但如果有人有一个巧妙的解决方案，我很乐意看到它！
我写了一个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()成员（隐式或显式）才能访问最终总和。
Dr.Dobs Journal 上有一篇关于“ Currying and Partial Functions in JavaScript ”的文章准确描述了这个问题。
本文中找到的一种解决方案是：
// 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;
}
您正在寻找的概念称为柯里化，它与函数转换和部分函数应用有关。当您发现自己一遍又一遍地使用几乎相同的参数调用相同的函数时，这很有用。
通过柯里化实现的一个例子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