Question

我一直在阅读JavaScript中的递归函数和尾调用优化（TCO）。我的目标是在递归函数中克服堆栈溢出：

function factorial(n) {
    function recur(n, acc) {
        if (n === 0) {
            return acc;
        } else {
            return recur(n - 1, n * acc);
        }
    }
    return recur(n, 1);
}

factorial(5); // 120
console.log(factorial(4585759)); // Maximum call stack size exceeded

我已经找到了如何使用thunk和trampoline来克服递归函数中的堆栈溢出：

let thunk = function (fn) {
    return function() {
        let args = Array.prototype.slice.apply(arguments);
        return function() { return fn.apply(this, args); };
    };
};

function trampoline(f) {
    while (f && f instanceof Function) {
        f = f();
    }
    return f;
}

function factorial(n) {
    let recur = function(x, n) {
        if (n === 0) {
            return x;
        } else {
            return thunk(recur)(n * x, n - 1);
        }
    };
    return trampoline(thunk(recur)(1, n));
}

console.log(factorial(5)); // 120
console.log(factorial(4585759)); // Infinity

然而，我并不喜欢我被迫编写递归函数的方式。我发现了一些名为TCO的函数的实现：

function tco(fn) {
  var active, nextArgs;
  return function() {
    var result;
    nextArgs = arguments;
    if (!active) {
      active = true;
      while (nextArgs) {
        result = fn.apply(this, [nextArgs, nextArgs = null][0]);
      }
      active = false;
    }
    return result;
  };
}

该功能应允许以下内容：

let factorialToc = tco(function(n) {
    function recur(n, acc) {
        if (n === 0) {
            return acc;
        } else {
            return recur(n - 1, n * acc);
        }
    };
    return recur(n, 1);
});

但它不起作用：

factorialToc(5); // 120
console.log(factorialToc(4585759)); // Maximum call stack size exceeded

是否有任何实用功能来封装TCO？

Answer 1

您将tco函数应用于非递归factorialToc函数，而不是导致堆栈溢出的recur。它应该是

function factorialToc(n) {
    const recur = tco(function(n, acc) {
        if (n === 0) {
            return acc;
        } else {
            return recur(n - 1, n * acc);
        }
    });
    return recur(n, 1);
}

用于在JavaScript中封装尾调用优化的实用程序？

1 个答案: