迭代器是一种统一访问集合元素的标准接口，1. 核心是通过symbol.iterator获取迭代器对象并调用next()方法返回{value, done}结构；2. for...of循环基于此协议自动遍历可迭代对象如数组、字符串等；3. 自定义可迭代对象需实现symbol.iterator方法且返回含next()的迭代器；4. 常见坑是迭代器为一次性使用，遍历完成后需重新获取新实例才能再次遍历，否则将无法获取数据。
迭代器，简单来说，就是一种统一的、按部就班访问集合中元素的方式。它提供了一个标准接口，让你不必关心数据底层是如何存储的，就能一步步地取出每一个元素，直到取完为止。你可以把它想象成一个遥控器，不管你面前是电视、音响还是空调，只要是支持某种协议的，你都能用这个遥控器来操作它。
解决方案：迭代器的核心使用与实现
在JavaScript这类现代语言里，迭代器的使用其实非常普遍，你可能每天都在用，只是没意识到它的存在。最直观的例子就是
for...of循环。
const numbers = [10, 20, 30, 40];
for (const num of numbers) {
console.log(num); // 依次输出 10, 20, 30, 40
}
// 不仅仅是数组，字符串、Map、Set这些内置的可迭代对象也能用
const greeting = "Hello";
for (const char of greeting) {
console.log(char); // 依次输出 H, e, l, l, o
}for...of循环的背后，就是迭代器协议在默默工作。它会去调用集合的
Symbol.iterator方法，获取到一个迭代器对象，然后不断调用这个迭代器对象的
next()方法，直到
done属性为
true。
如果你想更手动地控制迭代过程，或者想了解它的内部机制，可以直接操作迭代器对象：
const data = ['apple', 'banana', 'cherry'];
const iterator = data[Symbol.iterator](); // 获取数组的迭代器
console.log(iterator.next()); // { value: 'apple', done: false }
console.log(iterator.next()); // { value: 'banana', done: false }
console.log(iterator.next()); // { value: 'cherry', done: false }
console.log(iterator.next()); // { value: undefined, done: true } // 迭代完成每次调用
next()，都会返回一个包含
value（当前值）和
done（是否完成）的对象。当
done为
true时，表示没有更多元素了。理解这个，你就能掌握迭代器的核心用法了。
为什么迭代器是现代编程的基石？它解决了哪些痛点？
在我看来，迭代器最根本的价值在于它提供了一种统一的遍历接口。以前我们处理各种数据结构，比如数组、链表、树或者自定义的集合，可能都要写一套特定的遍历逻辑。这不仅代码重复，而且耦合度高。有了迭代器，只要一个数据结构实现了迭代器协议，我们就能用一套标准化的方式（比如
for...of）去遍历它，大大提升了代码的复用性和可维护性。这是一种非常优雅的解耦方式。
另外一个非常重要的特点是惰性求值（Lazy Evaluation）。这意味着迭代器只在需要时才生成下一个值。这在处理大数据集或无限序列时尤其有用。想象一下，你有一个TB级的日志文件，或者一个永无止境的传感器数据流。你不可能一次性把所有数据都加载到内存中。但通过迭代器，你可以按需读取，每次只处理一小部分数据，这极大地节省了内存，也提高了程序的响应速度。我个人在处理一些大型CSV文件或者网络流数据时，迭代器模式简直是救星，它让我的程序可以处理远超内存容量的数据。
它也使得代码逻辑更清晰。很多时候，我们不需要知道数据是怎么来的，只要能一步步取出来就行。迭代器把“如何遍历”的细节封装起来，让开发者能更专注于“如何处理数据”。
迭代器与生成器：这对好兄弟如何协同工作？
谈到迭代器，就不得不提生成器（Generator）。如果你觉得手动实现一个迭代器（就是那个需要自己管理
value和
done、还要维护内部状态的
next()方法）有点麻烦，那么生成器就是来解救你的。生成器函数（
function*）提供了一种更简洁、更直观的方式来创建迭代器。
看个对比就明白了：
// 手动实现一个简单的范围迭代器（相对繁琐）
function createRangeIterator(start, end) {
let current = start;
return {
next() {
if (current <= end) {
return { value: current++, done: false };
} else {
return { value: undefined, done: true };
}
}
};
}
const myRangeIter = createRangeIterator(1, 3);
console.log(myRangeIter.next()); // { value: 1, done: false }
// 使用生成器实现相同的范围迭代器（简洁优雅）
function* createRangeGenerator(start, end) {
for (let i = start; i <= end; i++) {
yield i; // 每次yield都会暂停函数执行，并返回一个值
}
}
const myRangeGen = createRangeGenerator(1, 3);
console.log(myRangeGen.next()); // { value: 1, done: false }生成器函数执行时，遇到
yield关键字就会暂停，并把
yield后面的表达式的值作为迭代器的
value返回。下次调用
next()时，函数会从上次暂停的地方继续执行。这让编写复杂的迭代逻辑变得异常简单，特别是那些需要维护大量内部状态的迭代器。在处理一些复杂的异步序列或者需要分步执行的计算时，生成器简直是神器，它让异步代码看起来像同步代码一样直观。
如何自定义一个可迭代对象？有哪些常见的“坑”？
要让你的自定义对象也能像数组一样被
for...of循环遍历，它就必须实现迭代器协议。核心就是：你的对象（或其原型链上）必须有一个以
Symbol.iterator为键的方法，这个方法必须返回一个迭代器对象。而这个迭代器对象，如前所述，必须有一个
next()方法，返回
{ value, done }。class MySimpleList {
constructor(...items) {
this.items = items;
}
// 实现 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 myList = new MySimpleList('alpha', 'beta', 'gamma');
for (const item of myList) {
console.log(item); // alpha, beta, gamma
}这里有一个我遇到过的“坑”：在
[Symbol.iterator]()方法内部返回的迭代器对象，它的
next()方法需要能够正确访问到原始集合的数据。如果你不小心直接返回了
this（而
this不是迭代器对象本身），或者没有正确地在闭包中捕获
items，
next()方法就可能拿不到正确的数据，导致迭代失败。确保
next方法能拿到它需要的所有上下文信息，是自定义迭代器时一个容易被忽略的点。
另一个常见的“坑”是迭代器的“一次性”特性。大多数迭代器，尤其是那些由内置数据结构（如数组）生成的迭代器，在被完全消费（即
next()返回
done: true）之后，就不能再次使用了。如果你想重新遍历，你需要重新获取一个新的迭代器实例。
const numbers = [1, 2, 3];
const iter = numbers[Symbol.iterator]();
// 第一次遍历，消耗了迭代器
for (const num of iter) {
console.log("第一次遍历:", num); // 1, 2, 3
}
// 再次尝试遍历同一个迭代器，会发现什么都没有，因为已经“用完了”
for (const num of iter) {
console.log("第二次遍历（不会打印）:", num);
}
// 如果想再次遍历，必须重新获取一个新的迭代器
const newIter = numbers[Symbol.iterator]();
for (const num of newIter) {
console.log("重新获取迭代器后再次遍历:", num); // 1, 2, 3
}这个特性有时会让人困惑，特别是在你将一个迭代器传递给多个函数处理时。你需要明确，迭代器是带有状态的，它记录了当前遍历的位置。如果你需要多次遍历同一份数据，要么每次都重新生成迭代器，要么就将数据转换为一个可以多次遍历的结构（比如数组），再进行处理。理解这一点，能避免很多迭代行为上的意外。
