web-dev-qa-db-fra.com

Comment faire var a = add (2) (3); // 5 travail?

Je veux rendre cette syntaxe possible: 

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

basé sur ce que j'ai lu à http://dmitry.baranovskiy.com/post/31797647

Je ne sais pas comment rendre cela possible.

javascriptcurrying
34
rajakvk

Add doit être une fonction qui prend un argument et retourne une fonction qui prend un argument qui ajoute l'argument à ajouter et lui-même.

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

Ah, la beauté de JavaScript

Cette syntaxe est très soignée aussi

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

Fonctions de première classe et fermetures font le travail.

14
NVI

essayez ceci vous aidera de deux manières: ajoutez (2) (3) et ajoutez (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
9
vasudev
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
}

Fonctionne pour tout et n'a pas besoin de final () à la fin de la fonction, contrairement à d'autres solutions.

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

La syntaxe ES6 rend cela simple et agréable:

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
satyrsynth

C'est à propos de JS et un peu strict avec 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

Cela fonctionne comme un charme avec une chaîne d'addition illimitée !!

5
hien

en plus de ce qui a déjà été dit, voici une solution générique de currying (basée sur 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))
3
user187291

Ceci est une solution généralisée qui résoudra add (2,3) (), add (2) (3) () ou toute combinaison analogue à add (2,1,3) (1) (1) (1) (2,3) ( 4) (4,1,1) (). Veuillez noter que peu de contrôles de sécurité ne sont pas effectués et que cela peut être optimisé davantage.

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

2
Debajit Majumder

Le concept de FERMETURE peut être utilisé dans ce cas.
La fonction "add" renvoie une autre fonction. La fonction en cours de retour peut accéder à la variable dans la portée du parent (dans ce cas, la variable a).

function add(a){

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

}


add(2)(3);

Voici un lien pour comprendre les fermetures http://www.w3schools.com/js/js_function_closures.asp

2
Rahul Arora

Cela va gérer à la fois

add(2,3) // 5

ou

add(2)(3) // 5

Ceci est un exemple de curry ES6 ...

const add = (a, b) => (b || b === 0) ? a + b : (b) => a + b;
2
Joshua Michael Calafell
function add(a, b){
 return a && b ? a+b : function(c){return a+c;}
}

console.log(add(2, 3));
console.log(add(2)(3));
1
manoj shukla

Avec ES6, répartissez l'opérateur ... et la fonction .reduce. Avec cette variante, vous obtiendrez la syntaxe d'enchaînement mais le dernier appel () est requis ici car la fonction est toujours renvoyée: 

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)()}
`;
<div id='output'></div>

1
Alendorff
function A(a){
  return function B(b){
      return a+b;
  }
}

J'ai trouvé une bonne explication pour ce type de méthode. Il est connu sous le nom de Syntax of Closures

veuillez vous référer à ce lien Syntaxe des fermetures

0
Nithin Mohan

Nous pouvons simplement écrire une fonction comme celle-ci

    function sum(x){
      return function(y){
        return function(z){
          return x+y+z;
        }
      }
    }

    sum(2)(3)(4)//Output->9
0
AshwiniB

fonction 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
0
Vishesh Mishra

Les fonctions de flèche facilitent sans aucun doute l'obtention du résultat souhaité:

const Sum = a => b => b ? Sum( a + b ) : a;

console.log(Sum(3)(4)(2)(5)()); //19

console.log(Sum(3)(4)(1)()); //8
0
Amir Danish
const add = a => b => b ? add(a+b) : a;

console.log(add(1)(2)(3)());

Ou (`${a} ${b}`) pour les chaînes.

0
LBoyle