迭代器是一种统一访问集合元素的标准接口，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 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 }
这个特性有时会让人困惑，特别是在你将一个迭代器传递给多个函数处理时。你需要明确，迭代器是带有状态的，它记录了当前遍历的位置。如果你需要多次遍历同一份数据，要么每次都重新生成迭代器，要么就将数据转换为一个可以多次遍历的结构（比如数组），再进行处理。理解这一点，能避免很多迭代行为上的意外。
