javascript的iterator接口是一种统一的遍历协议，其核心是通过实现symbol.iterator方法使对象可迭代，具体步骤为：1. 对象需实现symbol.iterator方法，返回一个迭代器；2. 迭代器必须有next()方法，每次调用返回{value, done}对象；3. done为true时遍历结束，value通常为undefined。例如自定义createrangeiterator函数生成指定范围数字，通过[symbol.iterator]() { return this; }让迭代器自身可遍历，从而支持for…of循环。generator函数则是iterator的语法糖，通过function*和yield简化迭代器实现，自动处理状态管理和next()返回值格式，如rangegenerator通过yield产出值并自动完成遍历逻辑，使代码更简洁高效。iterator接口解决了不同数据结构遍历方式不统一的问题，使自定义结构也能无缝融入javascript生态，提升代码通用性与可维护性。
JavaScript的Iterator接口，核心上讲，它就是一套统一的遍历协议。它定义了任何对象如何被for…of循环消费，或者说，如何按需、逐个地吐出它的元素。这套机制的关键在于一个next()方法，每次调用都会返回一个包含value（当前元素）和done（是否遍历结束）的对象。它让各种数据结构，无论是数组、字符串、Map、Set，还是我们自己定义的复杂对象，都能以一种统一且可预测的方式被迭代，而不必关心它们内部的具体实现细节。
解决方案
要让一个对象变得可迭代（iterable），它必须实现Symbol.iterator方法。这个方法不带任何参数，并且必须返回一个迭代器（iterator）对象。而这个迭代器对象，它就必须拥有一个next()方法。每次调用next()，它都应该返回一个形如{ value: any, done: boolean }的对象。当done为true时，表示遍历已经结束，value通常会是undefined，或者最后一个有意义的值（取决于具体实现）。
我们来构建一个简单的自定义迭代器，比如一个能生成指定范围数字的迭代器：
立即学习“Java免费学习笔记（深入）”；
function createRangeIterator(start, end) {
let current = start;
return {
[Symbol.iterator]() { // 这个方法让迭代器自身也成为可迭代的，方便for...of直接使用
return this;
},
next() {
if (current <= end) {
return { value: current++, done: false };
} else {
return { value: undefined, done: true };
}
}
};
}
const myRange = createRangeIterator(1, 3);
console.log(myRange.next()); // { value: 1, done: false }
console.log(myRange.next()); // { value: 2, done: false }
console.log(myRange.next()); // { value: 3, done: false }
console.log(myRange.next()); // { value: undefined, done: true }
// 甚至可以直接用for...of遍历，因为我们加了[Symbol.iterator]
for (const num of createRangeIterator(5, 7)) {
console.log(num); // 输出 5, 6, 7
}
这里值得一提的是，[Symbol.iterator]() { return this; }这一小段代码，它让我们的迭代器对象本身也成了可迭代的。这在很多场景下是推荐的做法，因为for…of循环期望的是一个可迭代对象，而你返回的迭代器本身通常就是那个可迭代的对象。
为什么我们需要JavaScript的Iterator接口？
在Iterator接口出现之前，JavaScript中遍历不同类型的数据结构，其实是有点“各说各话”的。数组有for循环、forEach；对象有for…in（但它还会遍历原型链上的属性，并且顺序不保证）；字符串可以直接用索引访问。这些方法在各自的领域里可能够用，但当你的代码需要处理一个“可能是一个数组，也可能是一个Set，还可能是一个自定义集合”的场景时，你就得写一堆if/else来判断类型，然后选择不同的遍历逻辑。这显然不是什么优雅的解决方案，代码会变得又臭又长，维护起来也头疼。
Iterator接口的出现，就像给所有可遍历的数据结构颁发了一张统一的“通行证”。无论你是什么类型的数据，只要你实现了这个接口，for…of循环就能无脑地去遍历你。它把遍历的逻辑从数据结构的消费者那里抽象出来，交给了数据结构本身去实现。这不仅让我们的代码更简洁、更具通用性，也让自定义的数据结构能够无缝地融入到JavaScript的生态系统中，享受for…of带来的便利。对我来说，这是一种代码组织上的胜利，它让“遍历”这个行为变得可预测和标准化。
如何为自定义对象实现Iterator接口？
为自定义对象实现Iterator接口，通常意味着你要决定你的对象在被for…of遍历时，应该“吐出”哪些数据，以及按什么顺序吐出。这不像数组那样直观，因为它没有默认的索引或顺序。你需要手动定义[Symbol.iterator]方法，并确保它返回一个符合迭代器协议的对象。
假设我们有一个简单的Collection类，它内部存储了一些项，我们希望能够按照它们被添加的顺序进行遍历：
class MyCollection {
constructor() {
this.items = [];
}
add(item) {
this.items.push(item);
}
// 核心部分：实现Symbol.iterator方法
[Symbol.iterator]() {
let index = 0;
const items = this.items; // 捕获当前集合的items数组
return {
next() {
if (index < items.length) {
return { value: items[index++], done: false };
} else {
return { value: undefined, done: true };
}
}
};
}
}
const collection = new MyCollection();
collection.add('Apple');
collection.add('Banana');
collection.add('Cherry');
for (const fruit of collection) {
console.log(fruit); // 依次输出 Apple, Banana, Cherry
}
// 甚至可以展开为数组
const fruitsArray = [...collection];
console.log(fruitsArray); // ['Apple', 'Banana', 'Cherry']
在这个例子里，MyCollection类通过实现[Symbol.iterator]方法，明确地告诉了for…of循环，它应该如何遍历自己的items数组。这个方法返回了一个匿名对象，这个对象就是迭代器，它维护了一个内部的index状态，确保每次调用next()都能返回下一个元素，直到所有元素都被遍历完。关键在于，这个[Symbol.iterator]方法是在每次需要迭代时被调用的，所以你可以为每次迭代创建一个新的、独立的状态，避免不同迭代器之间的状态干扰。
Iterator与Generator函数有什么关系？
Generator函数（生成器函数）是JavaScript中一个非常强大的特性，它在语法层面为我们创建迭代器提供了一种极其简洁优雅的方式。你可以把Generator函数看作是Iterator接口的“语法糖”或者“高级封装”。当你定义一个function*函数时，它并不会立即执行里面的代码，而是返回一个Generator对象。这个Generator对象本身就是一个迭代器，它自动实现了next()方法，并且也实现了[Symbol.iterator]方法（返回自身）。
Generator函数通过yield关键字来“暂停”执行并“产出”一个值。当next()方法被调用时，Generator函数会从上次yield暂停的地方继续执行，直到遇到下一个yield或return。
我们用Generator函数来重写上面createRangeIterator的例子，你会发现代码简洁了不止一点点：
function* rangeGenerator(start, end) {
let current = start;
while (current <= end) {
yield current++; // 每次调用next()，这里就会产出一个值
}
// 当循环结束，Generator函数会自动返回 { value: undefined, done: true }
}
for (const num of rangeGenerator(10, 12)) {
console.log(num); // 输出 10, 11, 12
}
const gen = rangeGenerator(1, 2);
console.log(gen.next()); // { value: 1, done: false }
console.log(gen.next()); // { value: 2, done: false }
console.log(gen.next()); // { value: undefined, done: true }
对比一下，手动实现迭代器需要你管理index状态、手动构建{ value, done }对象，并且小心处理边界条件。而Generator函数则把这些繁琐的细节都封装起来了。你只需要关注你想要“产出”什么值，以及什么时候产出。yield关键字帮你处理了暂停、恢复执行、以及next()方法的返回值格式。
所以，如果你需要创建一个自定义的可迭代对象，并且遍历逻辑相对复杂，或者需要按需生成大量数据（比如无限序列），Generator函数通常是更优的选择。它让异步编程模式（通过yield*和async/await）也变得更加流畅，但那又是另一个话题了。可以说，Generator函数是Iterator接口在实际应用中的一个强大且常用的伙伴。
暂无评论内容