我想使这种语法成为可能：
var a = add(2)(3); //5
基于我在http://dmitry.baranovskiy.com/post/31797647
上阅读的内容我不知道如何使它成为可能。
答案 0 :(得分：82)
你需要添加一个函数来接受一个参数并返回一个函数，该函数接受一个参数，该参数将参数添加到add和它本身。
var add = function(x) {
return function(y) { return x + y; };
}
答案 1 :(得分：33)
function add(x) {
return function(y) {
return x + y;
};
}
啊，JavaScript之美
这个语法非常简洁
function add(x) {
return function(y) {
if (typeof y !== 'undefined') {
x = x + y;
return arguments.callee;
} else {
return x;
}
};
}
add(1)(2)(3)(); //6
add(1)(1)(1)(1)(1)(1)(); //6
答案 2 :(得分：15)
function add(x){
return function(y){
return x+y
}
}
First-class functions和closures完成这项工作。
答案 3 :(得分：9)
试试这会帮助你以两种方式添加（2）（3）和添加（2,3）
1）
function add(a){ return function (b){return a+b;} }
add(2)(3) // 5
2）。
function add(a,b){
var ddd = function (b){return a+b;};
if(typeof b =='undefined'){
return ddd;
}else{
return ddd(b);
}
}
add(2)(3) // 5
add(2,3) // 5
答案 4 :(得分：9)
function add(n) {
sum = n;
const proxy = new Proxy(function a () {}, {
get (obj, key) {
return () => sum;
},
apply (receiver, ...args) {
sum += args[1][0];
return proxy;
},
});
return proxy
}
适用于所有内容，并且不需要函数末尾的final（），就像其他解决方案一样。
console.log(add(1)(2)(3)(10)); // 16
console.log(add(10)(10)); // 20
答案 5 :(得分：6)
ES6语法使这很简单：
const add = (a, b) => a + b;
console.log(add(2, 5));
// output: 7
const add2 = a => b => a + b;
console.log(add2(2)(5));
// output: 7
答案 6 :(得分：5)
这与JS生成有关，并且对valueOf有点严格：
function add(n){
var addNext = function(x) {
return add(n + x);
};
addNext.valueOf = function() {
return n;
};
return addNext;
}
console.log(add(1)(2)(3)==6);//true
console.log(add(1)(2)(3)(4)==10);//true
它就像一个具有无限添加链的护身符！
答案 7 :(得分：3)
这将处理两个
add(2,3) // 5
或
add(2)(3) // 5
这是ES6咖喱的例子......
const add = (a, b) => (b || b === 0) ? a + b : (b) => a + b;
答案 8 :(得分：3)
除了已经说过的内容之外，这里还有一个通用currying的解决方案（基于http://github.com/sstephenson/prototype/blob/master/src/lang/function.js#L180）
Function.prototype.curry = function() {
if (!arguments.length) return this;
var __method = this, args = [].slice.call(arguments, 0);
return function() {
return __method.apply(this, [].concat(
[].slice.call(args, 0),
[].slice.call(arguments, 0)));
}
}
add = function(x) {
return (function (x, y) { return x + y }).curry(x)
}
console.log(add(2)(3))
答案 9 :(得分：2)
在这种情况下可以使用CLOSURES的概念 功能＆＃34;添加＆＃34;返回另一个函数。返回的函数可以访问父作用域中的变量（在本例中为变量a）。
function add(a){
return function(b){
console.log(a + b);
}
}
add(2)(3);
答案 10 :(得分：2)
使用ES6传播for index, label in enumerate(ax.xaxis.get_ticklabels()):
if index % n != 0:
label.set_visible(False)
运算符和...函数。使用该变体，您将获得链接语法，但此处需要最后调用.reduce，因为始终返回函数：
()function add(...args) {
if (!args.length) return 0;
const result = args.reduce((accumulator, value) => accumulator + value, 0);
const sum = (...innerArgs) => {
if (innerArgs.length === 0) return result;
return add(...args, ...innerArgs);
};
return sum;
}
// it's just for fiddle output
document.getElementById('output').innerHTML = `
<br><br>add() === 0: ${add() === 0 ? 'true' : 'false, res=' + add()}
<br><br>add(1)(2)() === 3: ${add(1)(2)() === 3 ? 'true' : 'false, res=' + add(1)(2)()}
<br><br>add(1,2)() === 3: ${add(1,2)() === 3 ? 'true' : 'false, res=' + add(1,2)()}
<br><br>add(1)(1,1)() === 3: ${add(1)(1,1)() === 3 ? 'true' : 'false, res=' + add(1)(1,1)()}
<br><br>add(2,3)(1)(1)(1,2,3)() === 13: ${add(2,3)(1)(1)(1,2,3)() === 13 ? 'true' : 'false, res=' + add(2,3)(1)(1)(1,2,3)()}
`;
答案 11 :(得分：2)
这是一个通用的解决方案，它将解决add（2,3）（），add（2）（3）（）或任何组合，如add（2,1,3）（1）（1）（2， 3）（4）（4,1,1）（）。请注意，很少进行安全检查，可以进一步优化。
ymd_hm("2009-10-01 10:00") - ymd_hm("2009-10-01 9:00")
#Time difference of 1 hours
答案 12 :(得分：2)
这是JS中的currying概念。
您的问题的解决方案是：
function add(a) {
return function(b) {
return a + b;
};
}
这也可以使用箭头功能：
let add = a => b => a + b;
解决方案；使用递归
function add(a) {
return function(b){
return b ? add(a + b) : a;
}
}
使用 ES6箭头功能语法：
let add = a => b => b ? add(a + b) : a;
答案 13 :(得分：1)
function add(a, b){
return a && b ? a+b : function(c){return a+c;}
}
console.log(add(2, 3));
console.log(add(2)(3));
答案 14 :(得分：1)
毫无疑问，箭头功能使获得所需结果变得非常简单：
const Sum = a => b => b ? Sum( a + b ) : a;
console.log(Sum(3)(4)(2)(5)()); //19
console.log(Sum(3)(4)(1)()); //8
答案 15 :(得分：0)
也可以试试这个：
let sum = a => b => b ? sum(a + b) :a
console.log(sum(10)(20)(1)(32)()) //63
答案 16 :(得分：0)
以下用例的简单递归解决方案
添加(); // 0
添加(1)(2)(); //3
添加(1)(2)(3)(); //6
function add(v1, sum = 0) {
if (!v1) return sum;
sum += v1
return (v2) => add(v2, sum);
}
答案 17 :(得分：0)
您应该使用柯里化来调用上述格式的函数。
理想情况下，一个将两个数字相加的函数应该是这样的，
let sum = function(a, b) {
return a + b;
}同样的函数可以转换为，
let sum = function(a) {
return function(b) {
return a+b;
}
}
console.log(sum(2)(3));让我们了解这是如何工作的。
当你调用 sum(2) 时，它返回
function(b) {
return 2 + b;
}
当返回的函数被3进一步调用时，b取值为3。返回结果5。
更详细的解释：
let sum = function(a) {
return function(b) {
return a + b;
}
}
let func1 = sum(2);
console.log(func1);
let func2 = func1(3)
console.log(func2);
//the same result can be obtained in a single line
let func3 = sum(2)(3);
console.log(func3);
//try comparing the three functions and you will get more clarity.答案 18 :(得分：0)
这个问题已经激发了很多答案，以至于我的“两分钱”肯定不会破坏事物。
我为尝试采用“我的最爱”功能而感到惊讶的是，我采用了多种方法和变体。 e。使用某些ES6表示法，我想在这样一个易用的函数中一起找到的对象：
const add=(...n)=>{
const vsum=(a,c)=>a+c;
n=n.reduce(vsum,0);
const fn=(...x)=>add(n+x.reduce(vsum,0));
fn.toString=()=>n;
return fn;
}
let w=add(2,1); // = 3
console.log(w()) // 3
console.log(w); // 3
console.log(w(6)(2,3)(4)); // 18
console.log(w(5,3)); // 11
console.log(add(2)-1); // 1
console.log(add()); // 0
console.log(add(5,7,9)(w)); // 24.as-console-wrapper {max-height:100% !important; top:0%}
基本上，此递归编程函数中的所有内容都不是 new 。但这可以与以上任何答案中提到的所有可能参数组合一起使用，并且最后不需要“空参数列表”。
您可以在所需的任意循环级别中使用尽可能多的参数，结果将是另一个可以出于相同目的重用的函数。我使用了一些“技巧”来也“同时”获得一个数值：我重新定义了内部函数.toString()的{{1}}函数！只要使用不带参数列表且“期望某个值”的函数，Javascript就会调用此方法。从技术上讲，这是一个“ hack”，因为它不会返回字符串而是一个数字，但是在大多数情况下，它将以“所需”的方式工作。旋转一下！
答案 19 :(得分：0)
我们可以使用闭包来完成这项工作。
function add(param1){
return function add1(param2){
return param2 = param1 + param2;
}
}
console.log(add(2)(3));//5
答案 20 :(得分：0)
let multi = (a)=>{
return (b)=>{
return (c)=>{
return a*b*c
}
}
}
multi (2)(3)(4) //24
let multi = (a)=> (b)=> (c)=> a*b*c;
multi (2)(3)(4) //24
答案 21 :(得分：0)
这里我们使用闭包的概念，其中在main函数iter内部调用的所有函数都引用并udpate x ，因为它们具有闭包功能。无论循环走了多久，直到最后一个功能，都可以访问 x 。
function iter(x){
return function innfunc(y){
//if y is not undefined
if(y){
//closure over ancestor's x
x = y+x;
return innfunc;
}
else{
//closure over ancestor's x
return x;
}
}
}
iter（2）（3）（4）（）// 9 iter（1）（3）（4）（5）（）// 13
答案 22 :(得分：0)
不要复杂。
var add = (a)=>(b)=> b ? add(a+b) : a;
console.log(add(2)(3)()); // Output:5
它将在最新的javascript（ES6）中运行，这是一个递归函数。
答案 23 :(得分：0)
make这是错吗？
答案 24 :(得分：0)
我们可以简单地编写一个这样的函数
function sum(x){
return function(y){
return function(z){
return x+y+z;
}
}
}
sum(2)(3)(4)//Output->9
答案 25 :(得分：0)
const add = a => b => b ? add(a+b) : a;
console.log(add(1)(2)(3)());
或(`${a} ${b}`)表示字符串。
答案 26 :(得分：0)
function A(a){
return function B(b){
return a+b;
}
}
我找到了这种方法的一个很好的解释。它被称为闭包语法
请参阅此链接 Syntax of Closures
答案 27 :(得分：0)
function add（）{ var sum = 0;
function add() {
for (var i=0; i<arguments.length; i++) {
sum += Number(arguments[i]);
}
return add;
}
add.valueOf = function valueOf(){
return parseInt(sum);
};
return add.apply(null,arguments);
}
// ...
console.log(add() + 0); // 0
console.log(add(1) + 0);/* // 1
console.log(add(1,2) + 0); // 3
答案 28 :(得分：-1)
我想出了一个带有闭包的不错的解决方案，内部函数可以访问父函数的参数并存储在其词法范围内，无论何时执行，都会得到答案
const Sum = function (a) {
return function (b) {
return b ? Sum(a + b) : a;
}
};
Sum(1)(2)(3)(4)(5)(6)(7)() // result is 28
Sum(3)(4)(5)() // result is 12
Sum(12)(10)(20) // result is 42
答案 29 :(得分：-1)
let add = (a,b)=>b===undefined ?add.bind(null,a):a+b;
console.log( add(10,5) ); //15
console.log( add(10)(5) ); //15
答案 30 :(得分：-1)
function add () {
var args = Array.prototype.slice.call(arguments);
var fn = function () {
var arg_fn = Array.prototype.slice.call(arguments);
return add.apply(null, args.concat(arg_fn));
}
fn.valueOf = function () {
return args.reduce(function(a, b) {
return a + b;
})
}
return fn;
}
console.log(add(1));
console.log(add(1)(2));
console.log(add(1)(2)(5));