Вызов функции вида func(x)(x)(x)(x)

#javascript

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

func(1)(2)(3)(4)(5);


Код самой функции мне недоступен.

В чем смысл подобного вызова функции?

Пытался искать в интернете, но ничего подобного не нашел.
    

Ответы

Ответ 1

Приведу пример такой функции:  



const sum = function(a) {
  var result = a;                              // Первый вызов, инициализация
  const innersum = a => (result+=a, innersum); // Функция возвращает себя же
  innersum.toString = () => result;            // сериализация значения для вывода
  return innersum;
};

console.log(sum(1)(2)(3)(4)); // 10
console.log(sum(1)(2)(3));    // 6

let tmp = sum(2)(3);
console.log(tmp);     // 5
console.log(tmp(5));  //10
console.log(tmp(10)); //20




Перевод функции(без "новых стандартов языка"):  

function sum(a) {
  var result = a;

  function innerSum(a) {
    result += a;
    return innerSum;
  }

  innerSum.toString = function() {
    return result;
  };

  return innerSum;
}


Ответ 2

function func(a) {
  return function (b) {
    return function (c) {
      return function (d) {
        return function (e) {
          console.log('Ну вот ты и вызвал все 5 функций')
          console.log([a, b, c, d, e].join(' '))
        }
      }
    }
  }
}

func(1)(2)(3)(4)(5);


Ответ 3

О, я вспомнил ES6 :)

Некоторые детали.



class Summator extends Function {
  constructor() {
    super('return arguments.callee.apply(this, arguments)');
    this.value = 0;
  }

  apply(me, [x]) {
    this.value += x;
    return this;
  }

  toString() {
    return this.value;
  }
}

var func = new Summator(); // Инстанс хранит значение
console.log(func(1)(2)(3)(4)(5)); // 15
// Если использовать существующий инстанс вместо создания нового
console.log(func(1)(2)(3)); // то будет 15+1+2+3 = 21




И вариант с неизменяемыми функциями:



class Summator extends Function {
  constructor(x) {
    super('return arguments.callee.apply(this, arguments)');
    this.value = x || 0;
  }

  apply(me, [x]) {
    return new Summator(this.value + x);
  }

  toString() {
    return this.value;
  }
}

function func(x) { // Просто обёртка, чтобы выкинуть new
  return new Summator(x);
}

console.log(func(1)(2)(3)(4)(5)); // 15
console.log(func(1)(2)(3)); // 6


Ответ 4

Если без углубления в код JS, то схема такая:

func(1)(2)(3)(4)(5) эквивалентно поочередному вызову цепочки функций, где каждой
новой задаются по очереди аргументы 1, 2, 3, 4 и 5 соответственно. важно(!) чтобы каждый
вызов функции возвращал (давал в результате) какую-то функцию, чтобы к ней применялся
следующий аргумент, кроме последнего вызова с аргументом 5, тут необязательно, чтобы
результатом была функция.

func(1) дает функцию func_2, к которой применяем аргумент 2, т.е. func_2(2), это
дает в свою очередь func_3 и она вызывается как func_3(3), затем func_4 с вызовом func_4(4)
и наконец func_5 с вызовом func_5(5).


Ответ 5

Скорее всего, функция func возвращает функцию, которая возвращает функцию, которая
возвращает функцию и т.д. Нужно это для каррирования.