JavaScript中的函数式编程：惰性求值与无限序列

描述
惰性求值（Lazy Evaluation）是函数式编程的核心特性之一，指表达式或计算在真正需要结果时才执行，而非在定义时立即求值。在JavaScript中，结合生成器（Generator）和迭代器（Iterator）可实现惰性求值，从而构建无限序列（如无限斐波那契数列）或高效处理大规模数据流。

为什么需要惰性求值？

1. 节省计算资源：避免不必要的中间计算，尤其适用于大规模数据。
2. 支持无限序列：可定义无穷数据流（如自然数序列），按需生成值。
3. 解耦数据生成与消费：生产者按需生成数据，消费者控制计算节奏。

循序渐进讲解

步骤1：理解立即求值与惰性求值的区别

• 立即求值：表达式定义后立即计算结果。

  const arr = [1, 2, 3].map(x => x * 2); // 立即生成新数组[2, 4, 6]
  

• 惰性求值：表达式定义时不计算，等到使用时才求值。

  // 通过生成器定义惰性序列
  function* lazyMap(arr, fn) {
    for (let item of arr) {
      yield fn(item); // 每次调用next()时才计算
    }
  }
  

步骤2：利用生成器实现惰性序列

生成器函数（function*）返回一个迭代器，通过yield暂停执行，实现按需计算。

// 无限自然数序列
function* naturalNumbers() {
  let n = 0;
  while (true) {
    yield n++;
  }
}

const numbers = naturalNumbers();
console.log(numbers.next().value); // 0
console.log(numbers.next().value); // 1
// 不会陷入死循环，因为每次只生成一个值

步骤3：构建惰性操作链

通过组合生成器，实现类似数组方法（如map、filter）的惰性版本：

// 惰性map
function* lazyMap(iterable, fn) {
  for (const item of iterable) {
    yield fn(item);
  }
}

// 惰性filter
function* lazyFilter(iterable, predicate) {
  for (const item of iterable) {
    if (predicate(item)) yield item;
  }
}

// 示例：生成平方值且大于10的数
const numbers = naturalNumbers();
const result = lazyFilter(
  lazyMap(numbers, x => x * x),
  x => x > 10
);
console.log(result.next().value); // 16 (4*4)
console.log(result.next().value); // 25 (5*5)

步骤4：实现无限斐波那契数列

斐波那契数列是典型的无限序列，适合用惰性求值实现：

function* fibonacci() {
  let a = 0, b = 1;
  while (true) {
    yield a;
    [a, b] = [b, a + b];
  }
}

const fib = fibonacci();
console.log(Array.from({ length: 5 }, () => fib.next().value)); // [0, 1, 1, 2, 3]

步骤5：惰性求值的性能优化

对比立即求值与惰性求值处理大规模数据的差异：

// 立即求值：需要完整计算所有数据
const bigArray = Array.from({ length: 1000000 }, (_, i) => i);
const immediateResult = bigArray.map(x => x * 2).filter(x => x > 1000).slice(0, 10);

// 惰性求值：只计算必要部分
function* lazyTake(iterable, n) {
  for (let item of iterable) {
    if (n-- <= 0) return;
    yield item;
  }
}

const lazyResult = lazyTake(
  lazyFilter(
    lazyMap(bigArray, x => x * 2),
    x => x > 1000
  ),
  10
);
console.log(Array.from(lazyResult)); // 仅计算前10个满足条件的值

步骤6：实际应用场景

1. 流式数据处理：逐行读取文件时惰性解析，避免内存溢出。
2. 无限状态机：如游戏状态、传感器数据流。
3. 函数式库支持：Lodash的_.chain、Ramda等库内置惰性求值优化。

总结
惰性求值通过延迟计算提升性能并支持无限数据结构，在JavaScript中依赖生成器和迭代器实现。关键点包括：

• 使用function*和yield定义惰性序列。
• 通过组合生成器构建操作链（如lazyMap、lazyFilter）。
• 无限序列需通过条件（如lazyTake）控制计算范围。