Как сделать var a = add (2) (3); // 5 работа?

Question

Я хочу сделать этот синтаксис возможным:

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

на основании того, что я прочитал в http://dmitry.baranovskiy.com/post/31797647

Понятия не имею, как это сделать.

Answer 1

Вам нужно добавить, чтобы быть функцией, которая принимает аргумент и возвращает функцию, которая принимает аргумент, который добавляет аргумент для добавления и себя.

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

Answer 2

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

Answer 3

function add(x){
  return function(y){
    return x+y
  }
}

Первоклассные функции и замыкания выполняют работу.

Answer 4

попробуйте это поможет вам двумя способами добавить (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

Answer 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
}

Работает для всего и не требует final () в конце функции, как некоторые другие решения.

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

Answer 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

Answer 7

Это о JS curring и немного строгий с 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

Он работает как шарм с неограниченной цепочкой добавления !!

Answer 8

Это будет обрабатывать оба

add(2,3) // 5

или

add(2)(3) // 5

Это пример карри ES6 ...

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

Answer 9

в дополнение к тому, что уже сказано, вот решение с универсальным карри

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

Answer 10

С ES6, оператор ... и функция .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)()}
`;

<div id='output'></div>