JavaScript数学递归函数栈溢出优化及线性转换方案咨询

你的判断完全准确：JavaScript 引擎的调用栈存在固定深度上限（不同引擎阈值在数千到一万余层不等，例如 V8 引擎默认栈深度约为1万层左右）。你当前实现的递归属于普通非尾递归，每一次函数调用都会在调用栈中留存独立的执行上下文，当递归次数超过栈深度阈值时，就会抛出Maximum call stack size exceeded错误。
另外你当前的代码还存在依赖全局变量维护递归状态的问题，会产生函数副作用，多实例调用时会出现状态污染。

方案1：改写为循环迭代实现（优先推荐，兼容性、性能最优） #

你的递归逻辑本质是固定次数的复利数值迭代，完全不需要递归实现，直接用普通循环做线性迭代即可，全程不会占用额外调用栈空间，哪怕迭代次数达到千万、亿级也不会出现栈溢出问题。
重构后代码如下，同时移除了全局状态依赖：

const basePrincipal = 10000
const yearlySeconds = 31557600
const apy = 0.09
const iterateCount = 10000000 // 可替换为任意大的数值，无栈溢出风险

function calcCompound(initial, times) {
    let current = initial
    const periodRate = 1 + apy / yearlySeconds
    for (let i = 0; i < times; i++) {
        current *= periodRate
    }
    return current
}

const result = calcCompound(basePrincipal, iterateCount)
console.log(result)

该方案无任何环境兼容问题，执行效率远高于递归实现，是此类线性迭代场景的标准实现方式。

方案2：直接使用数学公式计算（性能天花板） #

你实现的是固定周期利率的复利计算，完全符合复利数学公式，不需要做逐次循环迭代，直接用内置幂运算Math.pow即可一步得到结果，时间复杂度为O(1)，无论期数多大都可以瞬间完成计算：

const basePrincipal = 10000
const yearlySeconds = 31557600
const apy = 0.09
const totalPeriods = 10000000 // 任意期数都支持
const result = basePrincipal * Math.pow(1 + apy / yearlySeconds, totalPeriods)
console.log(result)

注意：浮点数计算存在精度边界，当期数过大时结果会超出JS可精确表示的数值范围，这属于浮点数本身的特性，和栈溢出无关。

方案3：尾递归改造（不推荐生产环境使用） #

ES6 规范中定义了尾调用优化（PTC）：如果函数的最后一步操作是纯函数调用、不需要留存当前栈帧的上下文，引擎可以复用当前栈帧执行下一次调用，不会产生栈深度叠加。你当前的代码不是严格尾递归（且依赖全局状态），改造后的纯尾递归版本如下：

const yearlySeconds = 31557600
const apy = 0.09

function calcRecursive(current, timesLeft, periodRate) {
    if (timesLeft <= 0) return current
    return calcRecursive(current * periodRate, timesLeft - 1, periodRate)
}

const result = calcRecursive(10000, 1000000, 1 + apy/yearlySeconds)
console.log(result)

重要提示：目前仅 Safari 等极少数JavaScript引擎实现了标准尾调用优化，Chrome/V8、Node.js、绝大多数主流移动端浏览器均未支持该特性，该方案无法解决大部分环境下的栈溢出问题，生产环境不要依赖。

方案4：蹦床（trampoline）函数改造（通用递归兼容方案） #

如果你需要保留递归的代码写法，同时要兼容所有JS环境，可以通过蹦床函数将递归执行转换为循环执行：将递归函数的每一步返回值改为待执行的函数包装，由蹦床函数循环逐次执行，全程不会产生调用栈叠加。实现代码如下：

// 蹦床工具函数
function trampoline(fn) {
    return function(...args) {
        let res = fn(...args)
        while (typeof res === 'function') {
            res = res()
        }
        return res
    }
}

const yearlySeconds = 31557600
const apy = 0.09
const calcWithTrampoline = trampoline(function recurse(current, timesLeft, periodRate) {
    if (timesLeft <= 0) return current
    return () => recurse(current * periodRate, timesLeft - 1, periodRate)
})

const result = calcWithTrampoline(10000, 1000000, 1 + apy/yearlySeconds)
console.log(result)

该方案兼容所有JS环境，支持任意递归深度，缺点是每一步会产生临时函数包装，性能略低于原生循环实现。

内容的提问来源于stack exchange，提问作者Maxime R