JavaScript函数式编程_惰性求值实现

惰性求值是一种延迟计算策略，JavaScript虽为严格求值语言，但可通过生成器实现惰性求值，利用yield暂停执行，按需生成值，适合处理无限序列与性能优化。

惰性求值是一种延迟计算的策略，只有在真正需要结果时才执行计算。JavaScript本身是严格求值（eager evaluation）的语言，但通过一些技巧可以实现惰性求值，尤其在函数式编程中非常有用，比如处理无限序列、提高性能或组合复杂操作。

什么是惰性求值？

惰性求值意味着表达式不会立即求值，而是等到其结果被使用时才计算。与之相对的是严格求值，即表达式一旦定义就立刻执行。

例如，在严格求值中：

const result = [1, 2, 3].map(x => x * 2).filter(x => x > 3);
// 立即执行 map 和 filter

而在惰性求值中，这些操作可以推迟到真正需要数据时才执行，甚至只计算所需的部分。

使用生成器实现惰性求值

JavaScript 的 Generator 函数天然支持惰性求值。它通过 yield 暂停执行，每次调用 next() 才继续计算下一个值。

function* range(start = 0, step = 1) {
  let current = start;
  while (true) {
    yield current;
    current += step;
  }
}
function* map(iterable, fn) {
for (const value of iterable) {
yield fn(value);
}
}
function* filter(iterable, predicate) {
for (const value of iterable) {
if (predicate(value)) {
yield value;
}
}
}

使用示例：

const numbers = range(0, 1);
const doubled = map(numbers, x => x * 2);
const evens = filter(doubled, x => x % 4 === 0);
// 只有在取值时才计算
console.log(evens.next().value); // 0
console.log(evens.next().value); // 4
console.log(evens.next().value); // 8

这种链式操作不会预先计算所有值，而是按需生成，非常适合处理大量或无限数据。

构建惰性链式操作库

我们可以封装一个更接近函数式风格的惰性结构：

class Lazy {
  constructor(iterator) {
    this.iterator = iterator;
  }
map(fn) {
const iter = map(this.iterator, fn);
return new Lazy(iter);
}
filter(predicate) {
const iter = filter(this.iterator, predicate);
return new Lazy(iter);
}
take(n) {
function* take(iter, count) {
let index = 0;
for (const value of iter) {
if (index >= count) break;
yield value;
index++;
}
}
return new Lazy(take(this.iterator, n));
}
value() {
return [...this.iterator];
}
}
// 工厂函数
Lazy.from = function*(start, step) {
let current = start;
while (true) {
yield current;
current += step;
}
};
// 使用
const result = new Lazy(Lazy.from(1, 1))
.map(x => x ** 2)
.filter(x => x % 2 === 0)
.take(5)
.value();
console.log(result); // [4, 16, 36, 64, 100]

这个 Lazy 类封装了迭代器，并提供链式方法。每个操作都不立即执行，直到调用 value() 展开时才触发计算。