JavaScript嵌套數字加法器函式，具有未知數量的鏈式函式呼叫

我有一個嵌套函式，應該能夠處理鏈式函式呼叫，但呼叫次數未知。該函式必須將數字相加，直到我們在沒有引數的情況下呼叫它，在這種情況下，它應該回傳在鏈呼叫中作為引數傳遞的所有數字的結果。

描述：

撰寫makeAdder函式，它將回傳該 adder函式。該adder功能應在以下模式下作業：adder(2)(3)(4)(1)(2)(3)(4)() === 19. 它將所有傳入引數的數字相加，直到遇到不帶引數的呼叫。不帶引數呼叫時，會回傳結果并清除金額。

例子：

const adder = makeAdder();
adder() === 0
adder(4)(5)() === 9
adder() === 0
adder(5)(5)(5)
adder(4)
adder() === 19
adder() === 0

在事先不知道需要多少嵌套函式的情況下，如何撰寫此函式？

function makeInfinityAdder() {

  return function adder(a = 0) {
    return (b) => {
      if (b) {
        adder(a   b)
      } else {
        return a   b;
      }
    };
  }
}

我試過這個，但我得到'加法器（...）（...）不是一個函式'。

uj5u.com熱心網友回復：

工廠函式：回傳值回傳一個新的 Function 實體（本身）或基于（有效數字）引數的可用性的當前值。

也可以看看

const addAll = (a = 0) => b =>  b >= 0 ? addAll(a   b) : a;

let add = addAll();
console.log(`add(8)(9)(10)(15)() => ${add(8)(9)(10)(15)()}`);
console.log(`add(0)(8)(9)(10)(15)('stop') => ${add(0)(8)(9)(10)(15)('stop')}`);

// reassign if you want to continue later (see comments):
add = add(5)(5)(5);
add = add(4);
console.log(`reassignment (add = add(...)) => ${add()}`);

// if you don't want to reassign
const addAll2 = (a = 0) => {
  const fn = b =>  b >= 0 ? (a  = b, fn) : a;
  return fn;
};

let add2 = addAll2();
add2(5)(5)(5);
add2(4);
console.log(`add2 (multiple add2(...)) => ${add2()}`);

uj5u.com熱心網友回復：

這就是我想出的。

const makeAdder = () => {
    // Store the results across calls
    let result = 0;
    // The adder function
    const adder = (a = null) => {
        if (a == null) {
            const retval = result;
            result = 0;
            return retval;
        }
        else {
            result  = a;
            return adder;
        }
    };
    return adder;
};

const adder = makeAdder();
console.log(adder());
console.log(adder(4)(5)());
console.log(adder());
adder(5)(5)(5);
adder(4);
console.log(adder());
console.log(adder());

uj5u.com熱心網友回復：

雖然你可以這樣做：

const makeAdder = () => ((t = 0, tmp = t, fn = (n) => (
  (t  = n || 0),
  (n == undefined) ? ((tmp = t), (t = 0), tmp) : fn
)) => fn) ()

const adder = makeAdder();
console .log (adder ())           //=> 0
console .log (adder (4) (5) ())   //=> 9 
console .log (adder ())           //=> 0
console .log (adder (5) (5) (5))  //=> <function>
console .log (adder (4))          //=> <function>
console .log (adder ())           //=> 19

.as-console-wrapper {max-height: 100% !important; top: 0}

這種函式的固有狀態讓我感到困擾，尤其是當我們可能試圖將其視為工廠函式時。

我寧愿創建一個adder總是回傳包含當前總和的無狀態函式的函式。這為我們提供了一個更清晰的界面：

const adder = (n, t = 0) => 
  n == undefined ? t : (x) => adder (x, t   n)

console .log (adder ())           //=> 0
console .log (adder (4) (5) ())   //=> 9 
console .log (adder ())           //=> 0
const foo = adder (5) (5) (5)     //=> <function> (15)
const bar = foo (4)               //=> <function> (19)
console .log (bar ())             //=> 19

console .log (bar (1) ())         //=> 20
console .log (foo (20) ())        //=> 35
console .log (foo (12) ())        //=> 27

.as-console-wrapper {max-height: 100% !important; top: 0}

我覺得這更干凈。但請注意，我們使用adder. 首先，它不是工廠函式。它是一個普通函式，回傳一個數字或另一個函式。其次，它在你不斷呼叫它時生成的函式是新函式，它們是無狀態的。具有不同值的單獨呼叫foo不會在它們之間累積總和。

標籤：javascript功能递归嵌套的方法调用

上一篇：將多個專案添加到字典

下一篇：如何在Python中操作類中的值？