为什么 ES6 中的这个函数组合（带有尾递归）返回未定义但累加器 returns 是正确的结果？

Question

我正在尝试编写一个组合函数，它可以接受任意数量的函数，将它们存储在一个闭包中，并将这些函数中的每一个应用到一个初始值。函数组合的实际应用在尾调用递归 _lCompose() 中执行。我运行遇到的问题是基本情况 console.log('acc', acc) 正确的值但是 'return acc' returns 未定义

function addOne (a ) {
    console.log('addone', a, a + 1)
    return a + 1
}
function double (a) {
    console.log('double', a, a * 2)
    return a * 2;
}
function square (a) {
    console.log('square', a, a * a)
    return a * a;
}

const lCompose = (...args) => {

    function _lCompose ( initialValue, acc, ...args ) {
        //base case when no args remain, return acc
        if ( !args.length ) {
            console.log('acc', acc)
            return acc;
        } else {
            // recurse, shift ...args and call head(acc)
            const [head, ...tail] = args;
            console.log('head', head)
            const _acc = head(acc);
            _lCompose (initialValue, _acc, ...tail )
        }
    }
    // use _v twice to set as initial value and initial accumulator
    return (initV, initAcc) =>  _lCompose(initV, initAcc, ...args)
}

const trans = lCompose(addOne, double, square);
trans(5, 5) // should return 144

Answer 1

因为你忘了return递归调用的结果。

<b>return</b> _lCompose (initialValue, _acc, ...tail )

const addOne = a => a + 1;
const double = a => a * 2;
const square = a => a * a;
const lCompose = (...args) => {
  function _lCompose ( initialValue, acc, ...args ) {
    if ( !args.length ) {
      return acc;
    } else {
      const [head, ...tail] = args;
      const _acc = head(acc);
      return _lCompose (initialValue, _acc, ...tail )
    }
  }
  return (initV, initAcc) =>  _lCompose(initV, initAcc, ...args)
}
const trans = lCompose(addOne, double, square);
console.log(trans(5, 5)); // 144

为什么 ES6 中的这个函数组合（带有尾递归）返回未定义但累加器 returns 是正确的结果？

Why does this function composition ( with tail recursion ) in ES6 returned undefined but the accumulator returns the correct result?

javascript

recursion

function-composition

ecmascript-6