·45 分钟阅读·管理员
JavaScript迭代协议详解
本文系统讲解JavaScript迭代协议,涵盖可迭代协议([Symbol.iterator])、迭代器协议(next方法)、迭代器对象及可迭代的迭代器四大核心概念,厘清三者关系与区别,结合大量代码示例说明实现方式、应用场景及最佳实践,帮助开发者深入理解for...of、展开运算符等语法底层机制。
JavaScript
小孩子看了根本把持不住!
JavaScript 迭代协议完全指南
目录
核心概念关系图
┌─────────────────────────────────────────────────────────┐
│ 迭代协议体系 │
├─────────────────────────────────────────────────────────┤
│ │
│ ┌──────────────────┐ ┌──────────────────┐ │
│ │ 可迭代协议 │ │ 迭代器协议 │ │
│ │ [Symbol.iterator]│ │ .next() 方法 │ │
│ └────────┬─────────┘ └────────┬─────────┘ │
│ │ │ │
│ ▼ ▼ │
│ ┌──────────────────┐ ┌──────────────────┐ │
│ │ 可迭代对象 │ │ 迭代器对象 │ │
│ │ Iterable │ │ Iterator │ │
│ └────────┬─────────┘ └────────┬─────────┘ │
│ │ │ │
│ │ ┌───────────────┘ │
│ ▼ ▼ │
│ ┌─────────────────────────────┐ │
│ │ 可迭代的迭代器 │ │
│ │ (既是迭代器,又可迭代) │ │
│ └─────────────────────────────┘ │
└─────────────────────────────────────────────────────────┘
快速对比表
| 特性 | 可迭代对象 | 迭代器 | 可迭代的迭代器 |
|---|---|---|---|
[Symbol.iterator] |
✅ 有 | ❌ 无 | ✅ 有(返回自己) |
next() |
❌ 无(返回的迭代器有) | ✅ 有 | ✅ 有 |
for...of |
✅ 可以 | ❌ 不可以 | ✅ 可以 |
| 可重复遍历 | ✅ 可以 | ❌ 状态会消耗 | ❌ 状态会消耗 |
| 典型用途 | 数据容器 | 遍历指针 | 特殊场景(生成器) |
| 示例 | Array, Set, Map | arr[Symbol.iterator]() |
生成器对象 |
一、可迭代协议
定义
对象必须实现 @@iterator 方法(通过 [Symbol.iterator] 访问),该方法返回一个迭代器对象。
协议要求
javascript
// 可迭代协议的实现规范
const iterable = {
[Symbol.iterator]() {
// 必须返回一个迭代器对象(有 next() 方法)
return {
next() {
return {
value: any, // 当前迭代的值
done: boolean // 是否迭代完成
};
}
};
}
};
完整示例
javascript
// ✅ 实现了可迭代协议的自定义对象
const myIterable = {
data: [1, 2, 3, 4, 5],
[Symbol.iterator]() {
let index = 0;
const data = this.data;
return {
next() {
if (index < data.length) {
return { value: data[index++], done: false };
}
return { value: undefined, done: true };
}
};
}
};
// 使用 for...of 遍历
for (const item of myIterable) {
console.log(item); // 1, 2, 3, 4, 5
}
// 使用展开运算符
const arr = [...myIterable]; // [1, 2, 3, 4, 5]
// 使用解构赋值
const [first, second, third] = myIterable;
console.log(first, second, third); // 1, 2, 3
// 使用 Array.from
const copied = Array.from(myIterable); // [1, 2, 3, 4, 5]
原生可迭代对象
JavaScript 内置的这些对象都实现了可迭代协议:
javascript
// 1. 数组
const array = [1, 2, 3];
console.log(array[Symbol.iterator]); // ƒ values()
// 2. 字符串
const string = "hello";
console.log(string[Symbol.iterator]); // ƒ [Symbol.iterator]()
// 3. Map
const map = new Map([['a', 1], ['b', 2]]);
console.log(map[Symbol.iterator]); // ƒ entries()
// 4. Set
const set = new Set([1, 2, 3]);
console.log(set[Symbol.iterator]); // ƒ values()
// 5. arguments 对象
function test() {
console.log(arguments[Symbol.iterator]);
}
test(1, 2, 3);
// 6. NodeList
const nodeList = document.querySelectorAll('div');
console.log(nodeList[Symbol.iterator]);
检查对象是否可迭代
javascript
// 检查函数
function isIterable(obj) {
return obj != null && typeof obj[Symbol.iterator] === 'function';
}
// 使用示例
console.log(isIterable([1, 2, 3])); // true
console.log(isIterable('hello')); // true
console.log(isIterable({ a: 1 })); // false
console.log(isIterable(null)); // false
console.log(isIterable(new Set())); // true
二、迭代器协议
定义
对象必须实现 next() 方法,该方法返回一个包含 value 和 done 属性的对象。
协议要求
javascript
// 迭代器协议的实现规范
const iterator = {
next() {
return {
value: any, // 任意 JavaScript 值
done: boolean // true 表示迭代完成
};
},
// 可选方法
return(value) {
// 提前终止迭代器时调用(如 break、throw、return)
return { value: value, done: true };
},
throw(exception) {
// 在迭代器中抛出异常时调用
throw exception;
}
};
基本示例
javascript
// ✅ 实现了迭代器协议的对象
const counter = {
count: 0,
next() {
this.count++;
if (this.count <= 3) {
return { value: this.count, done: false };
}
return { done: true };
}
};
console.log(counter.next()); // { value: 1, done: false }
console.log(counter.next()); // { value: 2, done: false }
console.log(counter.next()); // { value: 3, done: false }
console.log(counter.next()); // { done: true }
console.log(counter.next()); // { done: true }
可选方法:return()
javascript
const iteratorWithReturn = {
data: [1, 2, 3, 4, 5],
index: 0,
next() {
if (this.index < this.data.length) {
return { value: this.data[this.index++], done: false };
}
return { done: true };
},
return(value) {
console.log('迭代器提前终止');
return { value: value, done: true };
}
};
// 模拟 for...of 的 break 行为
const iterable = {
[Symbol.iterator]() { return iteratorWithReturn; }
};
for (const item of iterable) {
console.log(item);
if (item === 3) {
break; // 会触发 return() 方法
}
}
// 输出:
// 1
// 2
// 3
// 迭代器提前终止
三、迭代器
定义
实现了迭代器协议的对象(具有 next() 方法的对象)。
创建迭代器的几种方式
方式 1:手动创建
javascript
function createArrayIterator(array) {
let index = 0;
return {
next() {
if (index < array.length) {
return { value: array[index++], done: false };
}
return { value: undefined, done: true };
}
};
}
const iterator = createArrayIterator([10, 20, 30]);
console.log(iterator.next()); // { value: 10, done: false }
console.log(iterator.next()); // { value: 20, done: false }
console.log(iterator.next()); // { value: 30, done: false }
console.log(iterator.next()); // { done: true }
方式 2:使用生成器函数
javascript
function* arrayGenerator(array) {
for (const item of array) {
yield item;
}
}
const iterator = arrayGenerator([10, 20, 30]);
console.log(iterator.next()); // { value: 10, done: false }
console.log(iterator.next()); // { value: 20, done: false }
console.log(iterator.next()); // { value: 30, done: false }
console.log(iterator.next()); // { done: true }
方式 3:从可迭代对象获取
javascript
const array = [1, 2, 3];
const iterator = array[Symbol.iterator]();
console.log(iterator.next()); // { value: 1, done: false }
console.log(iterator.next()); // { value: 2, done: false }
console.log(iterator.next()); // { value: 3, done: false }
console.log(iterator.next()); // { done: true }
迭代器的特点
javascript
// 1. 懒惰求值(按需计算)
function* infiniteNumbers() {
let num = 0;
while (true) {
yield num++;
}
}
const infiniteIterator = infiniteNumbers();
console.log(infiniteIterator.next().value); // 0
console.log(infiniteIterator.next().value); // 1
console.log(infiniteIterator.next().value); // 2
// 只计算需要的部分,不会无限循环
// 2. 状态保持
const statefulIterator = (function() {
let count = 0;
return {
next() {
count++;
return { value: count, done: false };
}
};
})();
console.log(statefulIterator.next()); // { value: 1, done: false }
console.log(statefulIterator.next()); // { value: 2, done: false }
// 记住上次的状态
// 3. 一次性使用
const arr = [1, 2, 3];
const it = arr[Symbol.iterator]();
console.log(it.next()); // { value: 1, done: false }
console.log(it.next()); // { value: 2, done: false }
console.log(it.next()); // { value: 3, done: false }
console.log(it.next()); // { done: true }
// 迭代完成后,不会重置
四、可迭代的迭代器
定义
既是迭代器(有 next() 方法),又是可迭代的(有 [Symbol.iterator]() 方法)对象。
关键特征
javascript
// 可迭代的迭代器的核心特征
const iterableIterator = {
// 特征 1: 实现了迭代器协议
next() {
return { value: ..., done: ... };
},
// 特征 2: 实现了可迭代协议
[Symbol.iterator]() {
return this; // ⭐ 返回自己(关键!)
}
};
完整示例
javascript
// ⭐ 可迭代的迭代器完整实现
const iterableIterator = {
data: ['a', 'b', 'c'],
index: 0,
// 迭代器协议
next() {
if (this.index < this.data.length) {
return { value: this.data[this.index++], done: false };
}
return { done: true };
},
// 可迭代协议:返回自己
[Symbol.iterator]() {
return this;
}
};
// 方式 1: 手动调用 next()
console.log('--- 手动调用 ---');
console.log(iterableIterator.next()); // { value: 'a', done: false }
console.log(iterableIterator.next()); // { value: 'b', done: false }
// 方式 2: 使用 for...of
console.log('--- for...of ---');
for (const item of iterableIterator) {
console.log(item); // 'c'
}
// 方式 3: 使用展开运算符
const arr = [...iterableIterator];
console.log('--- 展开运算符 ---');
console.log(arr); // [](状态已消耗)
为什么需要可迭代的迭代器?
javascript
// 场景:在某些情况下需要迭代器本身也是可迭代的
// 1. 传递给接受可迭代对象的函数
function processIterable(iterable) {
// 这个函数期望接收一个可迭代对象
for (const item of iterable) {
console.log(item);
}
}
// 可迭代的迭代器可以直接传递
const iterableIterator = {
index: 0,
data: [1, 2, 3],
next() {
if (this.index < this.data.length) {
return { value: this.data[this.index++], done: false };
}
return { done: true };
},
[Symbol.iterator]() {
return this;
}
};
processIterable(iterableIterator); // ✅ 正常工作
生成器:自动创建可迭代的迭代器
javascript
// ⭐ 生成器函数自动返回可迭代的迭代器
function* myGenerator() {
yield 1;
yield 2;
yield 3;
}
const gen = myGenerator();
// 既是迭代器
console.log(gen.next()); // { value: 1, done: false }
console.log(gen.next()); // { value: 2, done: false }
// 又是可迭代的
console.log(gen[Symbol.iterator]() === gen); // true
// 可以被 for...of 遍历
for (const item of gen) {
console.log(item); // 3
}
重要注意事项
javascript
// ⚠️ 可迭代的迭代器只能遍历一次
const singleUseIterator = {
data: [1, 2, 3],
index: 0,
next() {
if (this.index < this.data.length) {
return { value: this.data[this.index++], done: false };
}
return { done: true };
},
[Symbol.iterator]() {
return this; // 总是返回同一个对象
}
};
// 第一次遍历
console.log('第一次:', [...singleUseIterator]); // [1, 2, 3]
// 第二次遍历(状态已消耗)
console.log('第二次:', [...singleUseIterator]); // []
// 对比:可迭代对象每次创建新迭代器
const multiUseIterable = {
data: [1, 2, 3],
[Symbol.iterator]() {
let index = 0;
return {
next: () => {
if (index < this.data.length) {
return { value: this.data[index++], done: false };
}
return { done: true };
}
};
}
};
console.log('第一次:', [...multiUseIterable]); // [1, 2, 3]
console.log('第二次:', [...multiUseIterable]); // [1, 2, 3] ✅
五、关键区别对比
对比 1:普通迭代器 vs 可迭代的迭代器
javascript
// ❌ 普通迭代器:不能被 for...of 遍历
const plainIterator = {
index: 0,
data: [1, 2, 3],
next() {
if (this.index < this.data.length) {
return { value: this.data[this.index++], done: false };
}
return { done: true };
}
// 缺少 [Symbol.iterator]
};
try {
for (const item of plainIterator) {
console.log(item);
}
} catch (e) {
console.log(e); // TypeError: plainIterator is not iterable
}
// ✅ 可迭代的迭代器:可以被 for...of 遍历
const iterableIterator = {
index: 0,
data: [1, 2, 3],
next() {
if (this.index < this.data.length) {
return { value: this.data[this.index++], done: false };
}
return { done: true };
},
[Symbol.iterator]() {
return this; // ⭐ 关键区别
}
};
for (const item of iterableIterator) {
console.log(item); // 1, 2, 3 ✅
}
对比 2:可迭代对象 vs 可迭代的迭代器
javascript
// 📦 可迭代对象:工厂模式
const iterableObject = {
data: [1, 2, 3],
[Symbol.iterator]() {
let index = 0;
return {
next: () => {
if (index < this.data.length) {
return { value: this.data[index++], done: false };
}
return { done: true };
}
};
}
};
// 每次调用 [Symbol.iterator] 都创建新的迭代器
const iter1 = iterableObject[Symbol.iterator]();
const iter2 = iterableObject[Symbol.iterator]();
console.log(iter1 === iter2); // false ✅
// 可以多次遍历
console.log('第1次:', [...iterableObject]); // [1, 2, 3]
console.log('第2次:', [...iterableObject]); // [1, 2, 3] ✅
// 🔄 可迭代的迭代器:单例模式
const iterableIterator = {
index: 0,
data: [1, 2, 3],
next() {
if (this.index < this.data.length) {
return { value: this.data[this.index++], done: false };
}
return { done: true };
},
[Symbol.iterator]() {
return this; // 总是返回自己
}
};
console.log(iterableIterator[Symbol.iterator]() === iterableIterator); // true
// 只能遍历一次
console.log('第1次:', [...iterableIterator]); // [1, 2, 3]
console.log('第2次:', [...iterableIterator]); // [] ⚠️
对比 3:适用场景
javascript
// 场景 1: 可迭代对象 - 数据容器
class Stack {
constructor() {
this.items = [];
}
push(item) {
this.items.push(item);
}
// 可迭代协议:每次创建新迭代器
[Symbol.iterator]() {
let index = this.items.length - 1;
return {
next: () => {
if (index >= 0) {
return { value: this.items[index--], done: false };
}
return { done: true };
}
};
}
}
const stack = new Stack();
stack.push(1);
stack.push(2);
stack.push(3);
console.log([...stack]); // [3, 2, 1]
console.log([...stack]); // [3, 2, 1] ✅ 可重复
// 场景 2: 可迭代的迭代器 - 流式处理
function* dataStream() {
let count = 0;
while (count < 5) {
yield count++;
}
}
const stream = dataStream();
// 部分消费
console.log(stream.next().value); // 0
console.log(stream.next().value); // 1
// 也可以作为可迭代对象
for (const item of stream) {
console.log(item); // 2, 3, 4
}
六、实际应用场景
场景 1:自定义数据结构
javascript
// 实现一个范围类
class Range {
constructor(start, end, step = 1) {
this.start = start;
this.end = end;
this.step = step;
}
[Symbol.iterator]() {
let current = this.start;
return {
next: () => {
if (current <= this.end) {
const value = current;
current += this.step;
return { value, done: false };
}
return { done: true };
}
};
}
}
// 使用示例
const range = new Range(1, 10, 2);
console.log([...range]); // [1, 3, 5, 7, 9]
for (const n of range) {
console.log(n); // 1, 3, 5, 7, 9
}
// 配合解构
const [a, b, c] = new Range(1, 5);
console.log(a, b, c); // 1, 2, 3
场景 2:树形结构遍历
javascript
class TreeNode {
constructor(value, children = []) {
this.value = value;
this.children = children;
}
// 深度优先遍历
*[Symbol.iterator]() {
yield this.value;
for (const child of this.children) {
yield* child; // 委托给子节点的迭代器
}
}
}
// 构建树
const tree = new TreeNode(1, [
new TreeNode(2, [
new TreeNode(4),
new TreeNode(5)
]),
new TreeNode(3, [
new TreeNode(6),
new TreeNode(7)
])
]);
// 遍历整棵树
console.log([...tree]); // [1, 2, 4, 5, 3, 6, 7]
for (const value of tree) {
console.log(value); // 1, 2, 4, 5, 3, 6, 7
}
场景 3:无限序列
javascript
// 无限斐波那契数列
const fibonacci = {
[Symbol.iterator]: function*() {
let [prev, curr] = [0, 1];
while (true) {
yield curr;
[prev, curr] = [curr, prev + curr];
}
}
};
// 手动控制
const fib = fibonacci[Symbol.iterator]();
console.log(fib.next().value); // 1
console.log(fib.next().value); // 1
console.log(fib.next().value); // 2
console.log(fib.next().value); // 3
console.log(fib.next().value); // 5
// 配合限制函数
function* take(iterable, n) {
const iterator = iterable[Symbol.iterator]();
for (let i = 0; i < n; i++) {
const { value, done } = iterator.next();
if (done) break;
yield value;
}
}
console.log([...take(fibonacci, 10)]); // [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
场景 4:分页数据加载
javascript
class PaginatedData {
constructor(fetchFunction) {
this.fetchFunction = fetchFunction;
this.currentPage = 0;
this.hasMore = true;
}
[Symbol.iterator]() {
return this;
}
async next() {
if (!this.hasMore) {
return { done: true };
}
try {
const data = await this.fetchFunction(this.currentPage);
this.currentPage++;
if (data.length === 0) {
this.hasMore = false;
return { done: true };
}
return { value: data, done: false };
} catch (error) {
return { done: true };
}
}
}
// 使用示例
const paginator = new PaginatedData(async (page) => {
const response = await fetch(`/api/data?page=${page}`);
return response.json();
});
// 异步迭代
for await (const data of paginator) {
console.log('收到数据:', data);
if (data.length < 10) break; // 最后一批
}
场景 5:链式操作
javascript
class LazySequence {
constructor(iterable) {
this.iterable = iterable;
}
[Symbol.iterator]() {
return this.iterable[Symbol.iterator]();
}
map(fn) {
const self = this;
return new LazySequence({
[Symbol.iterator]: function*() {
for (const item of self) {
yield fn(item);
}
}
});
}
filter(predicate) {
const self = this;
return new LazySequence({
[Symbol.iterator]: function*() {
for (const item of self) {
if (predicate(item)) {
yield item;
}
}
}
});
}
take(n) {
const self = this;
return new LazySequence({
[Symbol.iterator]: function*() {
let count = 0;
for (const item of self) {
if (count >= n) break;
yield item;
count++;
}
}
});
}
toArray() {
return [...this];
}
}
// 使用示例
const result = new LazySequence([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
.filter(x => x % 2 === 0)
.map(x => x * x)
.take(3)
.toArray();
console.log(result); // [4, 16, 36]
场景 6:异步迭代
javascript
// 异步迭代器协议
class AsyncDatabase {
constructor() {
this.data = [1, 2, 3, 4, 5];
}
async *[Symbol.asyncIterator]() {
for (const item of this.data) {
// 模拟异步操作
await new Promise(resolve => setTimeout(resolve, 100));
yield item;
}
}
}
// 使用异步 for...of
(async () => {
const db = new AsyncDatabase();
for await (const item of db) {
console.log('获取到:', item);
}
})();
七、最佳实践
1. 选择正确的迭代方式
javascript
// ✅ 推荐:需要多次遍历时使用可迭代对象
class Collection {
constructor(items) {
this.items = items;
}
[Symbol.iterator]() {
let index = 0;
return {
next: () => {
if (index < this.items.length) {
return { value: this.items[index++], done: false };
}
return { done: true };
}
};
}
}
// ✅ 推荐:一次性遍历时使用生成器
function* processItems(items) {
for (const item of items) {
yield item * 2;
}
}
2. 实现完整的迭代器协议
javascript
// ✅ 好的实现:包含 return 方法
const wellBehavedIterator = {
data: [1, 2, 3, 4, 5],
index: 0,
next() {
if (this.index < this.data.length) {
return { value: this.data[this.index++], done: false };
}
return { done: true };
},
return(value) {
console.log('清理资源');
this.index = this.data.length;
return { value, done: true };
}
};
// 使用
const iterable = {
[Symbol.iterator]() { return wellBehavedIterator; }
};
for (const item of iterable) {
if (item === 3) break; // 会触发 return()
}
// 输出:清理资源
3. 使用委托迭代器
javascript
// ✅ 推荐:使用 yield* 委托
class Composite {
constructor(iterables) {
this.iterables = iterables;
}
*[Symbol.iterator]() {
for (const iterable of this.iterables) {
yield* iterable; // 委托给子迭代器
}
}
}
const composite = new Composite([
[1, 2],
new Set([3, 4]),
'56'
]);
console.log([...composite]); // [1, 2, 3, 4, '5', '6']
4. 错误处理
javascript
// ✅ 好的做法:在迭代器中处理错误
function* safeIterator(iterable) {
const iterator = iterable[Symbol.iterator]();
while (true) {
try {
const { value, done } = iterator.next();
if (done) break;
yield value;
} catch (error) {
console.error('迭代错误:', error);
break;
}
}
}
// 使用
const problematicIterable = {
[Symbol.iterator]() {
let count = 0;
return {
next() {
count++;
if (count === 3) {
throw new Error('出错了!');
}
return { value: count, done: false };
}
};
}
};
for (const item of safeIterator(problematicIterable)) {
console.log(item);
}
// 输出:
// 1
// 2
// 迭代错误: Error: 出错了!
八、常见问题
Q1: 为什么需要两种协议?
A:
- 可迭代协议:定义"如何获取迭代器",让对象可以与
for...of等语法配合 - 迭代器协议:定义"如何迭代",维护遍历状态
这种分离设计使得一个可迭代对象可以被多次遍历(每次创建新的迭代器),而迭代器本身维护单次遍历的状态。
Q2: 什么时候使用可迭代的迭代器?
A:
- 生成器自动创建可迭代的迭代器
- 需要在某些接受可迭代对象的 API 中使用迭代器
- 实现流式处理时
javascript
// 示例:生成器就是可迭代的迭代器
function* counter() {
let count = 0;
while (true) {
yield count++;
}
}
const c = counter();
// 可以手动控制
console.log(c.next().value); // 0
// 也可以传递给接受可迭代对象的函数
console.log([...take(c, 5)]); // [1, 2, 3, 4, 5]
Q3: 如何检查对象是否实现了迭代协议?
A:
javascript
// 检查可迭代协议
function isIterable(obj) {
return obj != null && typeof obj[Symbol.iterator] === 'function';
}
// 检查迭代器协议
function isIterator(obj) {
return obj != null && typeof obj.next === 'function';
}
// 检查是否是可迭代的迭代器
function isIterableIterator(obj) {
return isIterable(obj) && isIterator(obj);
}
// 测试
const arr = [1, 2, 3];
const iterator = arr[Symbol.iterator]();
const gen = (function*() {})();
console.log(isIterable(arr)); // true
console.log(isIterator(arr)); // false
console.log(isIterableIterator(arr)); // false
console.log(isIterable(iterator)); // false
console.log(isIterator(iterator)); // true
console.log(isIterableIterator(iterator)); // false
console.log(isIterable(gen)); // true
console.log(isIterator(gen)); // true
console.log(isIterableIterator(gen)); // true ✅
Q4: 迭代器可以被重用吗?
A:
javascript
const arr = [1, 2, 3];
const iterator = arr[Symbol.iterator]();
// 第一次遍历
console.log([...iterator]); // [1, 2, 3]
// 第二次遍历(空数组,已消耗)
console.log([...iterator]); // []
// 解决方案:每次创建新迭代器
console.log([...arr]); // [1, 2, 3]
console.log([...arr]); // [1, 2, 3] ✅
Q5: 如何实现异步迭代?
A:
javascript
// 异步迭代器协议
class AsyncQueue {
constructor() {
this.items = [];
}
enqueue(item) {
this.items.push(item);
}
async *[Symbol.asyncIterator]() {
while (this.items.length > 0) {
// 模拟异步处理
await new Promise(resolve => setTimeout(resolve, 100));
yield this.items.shift();
}
}
}
// 使用
(async () => {
const queue = new AsyncQueue();
queue.enqueue(1);
queue.enqueue(2);
queue.enqueue(3);
for await (const item of queue) {
console.log('处理:', item);
}
})();
Q6: 如何提前终止迭代?
A:
javascript
// 方法 1: break
for (const item of iterable) {
if (item === target) break;
}
// 方法 2: return()
const iterator = iterable[Symbol.iterator]();
const result = iterator.next();
if (condition) {
iterator.return('提前结束');
}
// 方法 3: throw()
try {
for (const item of iterable) {
if (shouldStop) throw new StopIteration();
}
} catch (e) {
if (!(e instanceof StopIteration)) throw e;
}
总结
记忆口诀
可迭代对象有工厂([Symbol.iterator])
迭代器有指针(next() 方法)
可迭代的迭代器是特殊的存在
生成器函数自动创建它
可迭代对象可以多次遍历
迭代器状态消耗用一次就完
理解协议分离的关键
掌握 lazy evaluation 的精髓
核心要点
- 可迭代协议 =
[Symbol.iterator]()方法 - 迭代器协议 =
next()方法返回{ value, done } - 可迭代对象 = 实现了可迭代协议的对象
- 迭代器 = 实现了迭代器协议的对象
- 可迭代的迭代器 = 同时实现两种协议,
[Symbol.iterator]()返回this - 生成器 = 自动创建可迭代的迭代器
实践建议
- 优先使用生成器函数创建迭代器
- 需要多次遍历时实现可迭代对象
- 一次性流式处理可以使用可迭代的迭代器
- 总是实现
return()方法以支持提前终止 - 使用
yield*委托给其他迭代器
参考资料
- MDN - Iteration protocols
- MDN - Iterators and generators
- ECMAScript Specification - Iterable Interface
- ECMAScript Specification - Iterator Interface