¿Cómo puedo hacer que var a = add (2) (3); // 5 trabajo?

Quiero hacer posible esta syntax:

var a = add(2)(3); //5 

basado en lo que leo en http://dmitry.baranovskiy.com/post/31797647

No tengo ni idea de cómo hacerlo posible.

Necesita agregar para ser una función que toma un argumento y devuelve una función que toma un argumento que agrega el argumento para agregar y sí mismo.

 var add = function(x) { return function(y) { return x + y; }; } 
 function add(x) { return function(y) { return x + y; }; } 

Ah, la belleza de JavaScript

Esta syntax es bastante clara también

 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 
 function add(x){ return function(y){ return x+y } } 

Las funciones de primera clase y los cierres hacen el trabajo.

intente esto le ayudará de dos maneras agregar (2) (3) y agregar (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 
 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 } 

Funciona para todo y no necesita el final () al final de la función como algunas otras soluciones.

 console.log(add(1)(2)(3)(10)); // 16 console.log(add(10)(10)); // 20 

La syntax de ES6 hace que esto sea agradable y simple:

 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 

Además de lo que ya se ha dicho, aquí hay una solución con currying genérico (basado en 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)) 

El concepto de CIERRES se puede usar en este caso.
La función “agregar” devuelve otra función. La función que se devuelve puede acceder a la variable en el ámbito principal (en este caso, la variable a).

 function add(a){ return function(b){ console.log(a + b); } } add(2)(3); 

Aquí hay un enlace para comprender los cierres http://www.w3schools.com/js/js_function_closures.asp

Se trata de JS curring y un poco estricto con 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 

¡Funciona como un encanto con una cadena de adición ilimitada!

Esta es una solución generalizada que resolverá add (2,3) (), add (2) (3) () o cualquier combinación como add (2,1,3) (1) (1) (2,3) ( 4) (4,1,1) (). Tenga en cuenta que pocos controles de seguridad no están hechos y pueden optimizarse aún más.

 function add() { var total = 0; function sum(){ if( arguments.length ){ var arr = Array.prototype.slice.call(arguments).sort(); total = total + arrayAdder(arr); return sum; } else{ return total; } } if(arguments.length) { var arr1 = Array.prototype.slice.call(arguments).sort(); var mytotal = arrayAdder(arr1); return sum(mytotal); }else{ return sum(); } function arrayAdder(arr){ var x = 0; for (var i = 0; i < arr.length; i++) { x = x + arr[i]; }; return x; } } add(2,3)(1)(1)(1,2,3)(); 
 function add(a, b){ return a && b ? a+b : function(c){return a+c;} } console.log(add(2, 3)); console.log(add(2)(3)); 

Esto manejará ambos

 add(2,3) // 5 

o

 add(2)(3) // 5 

Este es un ejemplo de curry ES6 …

 const add = (a, b) => (b || b === 0) ? a + b : (b) => a + b; 

Con el operador ES6 spread ... y la función .reduce . Con esa variante obtendrás syntax de encadenamiento pero se requiere la última llamada () porque la función siempre se devuelve:

 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 = ` 

add() === 0: ${add() === 0 ? 'true' : 'false, res=' + add()}

add(1)(2)() === 3: ${add(1)(2)() === 3 ? 'true' : 'false, res=' + add(1)(2)()}

add(1,2)() === 3: ${add(1,2)() === 3 ? 'true' : 'false, res=' + add(1,2)()}

add(1)(1,1)() === 3: ${add(1)(1,1)() === 3 ? 'true' : 'false, res=' + add(1)(1,1)()}

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)()} `;
 

function add () {var sum = 0;

  function add() { for (var i=0; i 
 function A(a){ return function B(b){ return a+b; } } 

Encontré una buena explicación para este tipo de método. Se conoce como syntax de cierres

por favor, consulte este enlace Sintaxis de cierres

 const add = a => b => b ? add(a+b) : a; console.log(add(1)(2)(3)()); 

O (`${a} ${b}`) para cadenas.

 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));