js递归性能优化

JavaScript 递归性能优化

递归是编程中强大的技术，但在 JavaScript 中如果不注意优化可能会导致性能问题甚至栈溢出。以下是几种优化递归性能的方法：

1. 尾调用优化 (Tail Call Optimization, TCO)

ES6 引入了尾调用优化，但只在严格模式下有效：

'use strict';

// 普通递归
function factorial(n) {
  if (n === 1) return 1;
  return n * factorial(n - 1); // 不是尾调用
}

// 尾递归优化版本
function factorial(n, total = 1) {
  if (n === 1) return total;
  return factorial(n - 1, n * total); // 尾调用
}

注意：目前主流浏览器引擎对 TCO 的支持有限，Node.js 中需要开启特定 flag。

2. 使用循环替代递归

// 递归版
function fibonacci(n) {
  if (n <= 1) return n;
  return fibonacci(n - 1) + fibonacci(n - 2);
}

// 循环版（性能更好）
function fibonacci(n) {
  let a = 0, b = 1, temp;
  for (let i = 0; i < n; i++) {
    temp = a;
    a = b;
    b = temp + b;
  }
  return a;
}

3. 记忆化 (Memoization)

缓存已计算的结果避免重复计算：

function memoizedFibonacci() {
  const cache = {};
  
  return function fib(n) {
    if (n in cache) return cache[n];
    if (n <= 1) return n;
    
    cache[n] = fib(n - 1) + fib(n - 2);
    return cache[n];
  };
}

const fib = memoizedFibonacci();

4. 使用 trampoline 技术

将递归转换为循环执行：

function trampoline(fn) {
  return function(...args) {
    let result = fn(...args);
    while (typeof result === 'function') {
      result = result();
    }
    return result;
  };
}

// 使用
const factorial = trampoline(function myself(n, acc = 1) {
  if (n <= 1) return acc;
  return () => myself(n - 1, n * acc);
});

5. 限制递归深度

function limitedRecursion(fn, maxDepth = 1000) {
  return function(...args) {
    if (--maxDepth < 0) throw new Error('Maximum call stack exceeded');
    return fn(...args);
  };
}

6. 使用异步递归

将递归调用拆分为多个事件循环：

function asyncRecursion(n, callback) {
  if (n <= 0) return process.nextTick(() => callback(1));
  
  process.nextTick(() => {
    asyncRecursion(n - 1, (result) => {
      callback(n * result);
    });
  });
}

最佳实践建议

1. 优先考虑尾递归形式
2. 对于深度递归考虑使用循环
3. 对于重复计算使用记忆化
4. 对于非常深的递归考虑 trampoline 或异步方式
5. 始终设置递归终止条件

记住，递归虽然优雅，但在 JavaScript 中并不总是最高效的解决方案。根据具体场景选择最适合的方法。