17370845950

惰性求值延迟计算直到需要时才执行，如通过函数封装或生成器实现；记忆化缓存函数结果避免重复计算，适用于纯函数；两者可结合用于高效初始化。

惰性求值和记忆化是JavaScript中两种优化计算的策略，它们能提升性能，尤其是在处理高开销运算时。虽然目的相似，但实现方式和适用场景有所不同。

惰性求值（Lazy Evaluation）

惰性求值指的是推迟表达式的计算，直到真正需要结果时才执行。这种机制避免了不必要的计算，尤其适用于可能不会被使用的值或无限数据结构。

JavaScript本身是急切求值的语言，但可以通过函数封装模拟惰性行为。

示例：用函数包装延迟执行

function lazyAdd(a, b) {
  return () => a + b; // 只有调用返回函数时才计算
}
const computation = lazyAdd(5, 10);
// 此时并未计算
console.log(computation()); // 输出 15，此时才执行
  

更复杂的惰性结构可以用生成器（Generator）实现：

function* infiniteRange() {
  let i = 0;
  while (true) yield i++;
}
const sequence = infiniteRange();
console.log(sequence.next().value); // 0
console.log(sequence.next().value); // 1
  

生成器只在调用 next() 时产生下一个值，实现了惰性遍历。

记忆化（Memoization）

记忆化是一种缓存技术，将函数上次的输入和输出保存下来，当下次用相同参数调用时直接返回缓存结果，避免重复计算。

适合用于纯函数——即相同输入始终返回相同输出，且无副作用。

手动实现一个记忆化函数

function memoize(fn) {
  const cache = new Map();
  return function(...args) {
    const key = JSON.stringify(args);
    if (cache.has(key)) {
      return cache.get(key);
    }
    const result = fn.apply(this, args);
    cache.set(key, result);
    return result;
  };
}
const expensiveFib = memoize(function fib(n) {
if (n <= 1) return n;
return fib(n - 1) + fib(n - 2);
});
console.log(expensiveFib(30)); // 第一次较慢，后续相同调用极快

注意：key 的生成要能准确代表参数组合，JSON.stringify 是简单方案，但对对象顺序敏感；更健壮的做法可使用自定义序列化或 WeakMap 配合原始类型限制。

结合使用惰性与记忆化

在某些场景下，可以将两者结合。比如创建一个惰性初始化且带缓存的值：

function lazyMemoized(fn) {
  let cachedValue;
  let computed = false;
  return () => {
    if (!computed) {
      cachedValue = fn();
      computed = true;
    }
    return cachedValue;
  };
}
const heavyInit = lazyMemoized(() => {
console.log("执行一次昂贵初始化");
return Array.from({ length: 10000 }, (_, i) => i * i);
});
heavyInit(); // 打印并计算
heavyInit(); // 不再打印，直接返回缓存

这个模式常用于模块级单次初始化、配置加载等场景。

基本上就这些。惰性求值控制“何时算”，记忆化解决“要不要重算”，合理使用能让代码更高效。实际项目中，Lodash 的 _.memoize 或自定义 Hook（如 React 中的 useMemo）都是这类思想的应用。不复杂但容易忽略细节，比如缓存清理和内存占用。