迭代器(Iterator)是一种设计模式(Design Pattern),可以让程序开发人员依照一定顺序来走访某数据结构中的数据,还可以顺便对数据进行一些运算。JavaScript 在 ES6 之后内置了 Symbol.iterator 这个 symbol 类型的值,专门用在前面介绍过的 for-of 循环上。而同样在 ES6 之后内置的产生器(Generator)则是用来快速产生迭代器的语法,它还额外提供了能够从外部影响迭代器内部动作的功能。
迭代器(Iterator)
在 TypeScript 中,若要拿一个对象当作迭代器来用,则这个对象必须要提供 next 方法,且这个方法必须要回传一个类型为 { done: boolean, value?: any } 的对象。例如以下这个对象,就是一个迭代器:
const iterator = {
next: () => (
{
done: false,
value: 1,
}
),
};
我们可以替任意对象加上 Symbol.iterator 属性,这个 Symbol.iterator 属性值必须要是一个会回传迭代器对象的函数。例如:
const iterator = {
next: () => (
{
done: false,
value: 1,
}
),
};
const o = {
[Symbol.iterator]: () => {
return iterator;
},
};
以上这个 o 对象即为「可迭代」的对象,我们可以将其用在 for-of 的 of 关键字后。例如:
const iterator = {
next: () => (
{
done: false,
value: 1,
}
),
};
const o = {
[Symbol.iterator]: () => {
return iterator;
},
};
for (const e of o) {
console.log(e);
}
以上程序,由于使用到 Symbol.iterator 这个在 ES6 之后才有的 symbol 类型的值,因此若要通过编译,就要将 TypeScript 的编译目标设为 ES6 以上的版本。编译出来的 JavaScript 程序在运行之后会不断地输出 1。
不错,这个 for-of 循环会根据我们的迭代器的 next 方法所回传的类型为 { done: boolean, value?: any } 的对象,来替变量 e 赋值。在每次循环开始迭代的时候,迭代器的 next 方法都会被调用,如果此时回传的对象的 done 字段为 false,表示这个循环还没有运行完,此时会将 value 字段的值指派给 of 关键字前的常数或变量来保存。
如果 next 方法回传的对象的 done 字段为 true,表示这个循环已经运行完了,就不会再去管 value 字段的值,直接跳出循环。
举个比较复杂的例子吧!制作一个能够让 for-of 循环反向走访数组的迭代器。程序如下:
type RevIteratorResult<T> = { done: false, value: T } | { done: true, value: undefined };
class RevIterator<T> {
private array: T[];
private currentIndex = 0;
constructor(array: T[]) {
this.array = array;
this.currentIndex = array.length;
}
next(): RevIteratorResult<T> {
if (--this.currentIndex < 0) {
return {
done: true,
value: undefined,
};
} else {
return {
done: false,
value: this.array[this.currentIndex],
};
}
}
[Symbol.iterator](): RevIterator<T> {
return this;
}
}
const a = [1, 3, 5, 7, 9];
for (const e of new RevIterator(a)) {
console.log(e);
}
以上程序会输出:
7
5
3
1
这边比较需要提起的几个地方,首先是程序第 27 行,我们可以直接在类别中的方法名称使用中括号 [] 来使用一个 symbol 类型的值作为属性。再来是这个 RevIterator 类别因为同时有 next 方法和 Symbol.iterator 属性,所以它本身就是「可被迭代的迭代器」,其实体可以直接被用在 for-of 循环的 of 关键字后。
不过事实上,以上并不是一个好的迭代器实作方式。我们应该要套用 TypeScript 内置的 IterableIterator 界面和 IteratorResult 类型来实作「可被迭代的迭代器」。
IterableIterator 界面和 IteratorResult 类型的定义如下:
interface IteratorYieldResult<TYield> {
done?: false;
value: TYield;
}
interface IteratorReturnResult<TReturn> {
done: true;
value: TReturn;
}
type IteratorResult<T, TReturn = any> = IteratorYieldResult<T> | IteratorReturnResult<TReturn>;
interface Iterator<T, TReturn = any, TNext = undefined> {
next(...args: [] | [TNext]): IteratorResult<T, TReturn>;
return?(value?: TReturn): IteratorResult<T, TReturn>;
throw?(e?: any): IteratorResult<T, TReturn>;
}
interface Iterable<T> {
[Symbol.iterator](): Iterator<T>;
}
interface IterableIterator<T> extends Iterator<T> {
[Symbol.iterator](): IterableIterator<T>;
}
先不要去管 Iterator 界面中的 return 和 throw 属性,这两个是可选的,通常我们自行实作迭代器时并不会用到它们。在套用 IterableIterator 界面和 IteratorResult 类型之后,我们的程序变得如下:
class RevIterator<T> implements IterableIterator<T> {
private array: T[];
private currentIndex = 0;
constructor(array: T[]) {
this.array = array;
this.currentIndex = array.length;
}
next(): IteratorResult<T> {
if (--this.currentIndex < 0) {
return {
done: true,
value: undefined,
};
} else {
return {
done: false,
value: this.array[this.currentIndex],
};
}
}
[Symbol.iterator](): IterableIterator<T> {
return this;
}
}
const a = [1, 3, 5, 7, 9];
for (const e of new RevIterator(a)) {
console.log(e);
}
程序第 25 行,其实也还是可以用 RevIterator<T> 作为函数回传值的类型,因为 RevIterator 类别本身就实作 IterableIterator 界面。
产生器(Generator)
懒人迭代器
由于迭代器在实作上还是有一点麻烦,因此 ES6 之后还有提供产生器,可以在 function 关键字后紧接着一个星号 * 将任何的函数变成产生器函数来用,而产生器函数所回传的值就是一个「迭代器」或「可被迭代的迭代器」。
如果 TypeScript 编译目标是 ES5 之前的版本,就会在运行阶段去判断 Symbol.iterator 这个 symbol 类型的值是否可用(换句话说就算编译目标是 ES5 之前的版本,也还是可以使用产生器)。不过若还要将「可被迭代的对象」用在 for-of 循环的话,还需要将 downlevelIteration 这个编译设置项目设为 true。
举例来说:
function* g() {
return 1;
}
const iterator = g();
console.log(iterator.next());
以上程序会输出:
在产生器函数中,我们可以用 return 关键字来回传当 done 字段值为 true 时的 value 字段值。而 done 字段值为 false 时的 value 字段值则是用 yield 关键字来回传的。
举例来说:
function* g() {
yield 1;
yield 2;
yield 3;
return 4;
}
const iterator = g();
console.log(iterator.next());
console.log(iterator.next());
console.log(iterator.next());
console.log(iterator.next());
console.log(iterator.next());
console.log(iterator.next());
以上程序会输出:
{ value: 2, done: false }
{ value: 3, done: false }
{ value: 4, done: true }
{ value: undefined, done: true }
{ value: undefined, done: true }
也就是说,调用产生器产生出来的「可被迭代的迭代器」的 next 方法,会去运行产生器函数主体中的代码。如果运行到 yield 关键字的叙述,就会将结果先返回并暂停运行产生器函数主体中的代码,直到下一次 next 方法被调用,才会从产生器函数主体中先前暂停的位置继续运行程序。如果运行到 return 关键字的叙述,就会将最终结果回传。此后再去调用 next 方法,得到的结果都会是 { value: undefined, done: true }。
我们可以将刚才的反向迭代器用产生器来进行改写,如下:
function* generateRevIterator<T>(array: T[]) {
let currentIndex = array.length;
while (--currentIndex >= 0) {
yield array[currentIndex];
}
}
const a = [1, 3, 5, 7, 9];
for (const e of generateRevIterator(a)) {
console.log(e);
}
要成功编译以上程序的话,tsconfig.json 的设置档可以是(但不限于)以下这样:
{
"compilerOptions": {
...
"target": "ES6"
...
}
...
}
或
{
"compilerOptions": {
...
"target": "ES5",
"downlevelIteration": true
...
}
...
}
从外部影响迭代器内部的动作
return
产生器函数回传的迭代器会提供 return 方法(即 Iterator 界面定义的那个 return 属性)。这个 return 方法可以控制迭代器立刻进入结束状态,如果产生器主体中有使用 return 关键字来回传数据的话,return 方法就会有一个参数,其类型即为 return 关键字所回传的值的类型,这个参数会被放入 return 方法回传的对象的 value 属性中。
举例来说:
function* g() {
console.log("Step: 1");
yield 1;
console.log("Step: 2");
yield 2;
console.log("Step: 3");
return 3;
}
const iterator = g();
console.log(iterator.next());
console.log(iterator.return(0));
console.log(iterator.next());
以上程序会输出:
{ value: 1, done: false }
{ value: 0, done: true }
{ value: undefined, done: true }
throw
产生器函数回传的迭代器会提供 throw 方法(即 Iterator 界面定义的那个 throw 属性)。这个 throw 方法可以控制迭代器在暂停点(yield 关键字的位置)抛出错误消息,如果迭代器已经迭代完成了(已回传过 done 属性为 true 的对象),则会在调用迭代器 throw 方法的位置抛出错误消息。throw 方法有一个参数,即为要抛出的错误消息。
举例来说:
function* g() {
console.log("Step: 1");
try {
yield 1;
} catch (err) {
console.log(`Step 1 Error: ${err}`);
}
console.log("Step: 2");
try {
yield 2;
} catch (err) {
console.log(`Step 2 Error: ${err}`);
}
console.log("Step: 3");
return 3;
}
const iterator = g();
console.log(iterator.next());
console.log(iterator.next());
console.log(iterator.throw("22222"));
console.log(iterator.next());
try {
console.log(iterator.throw("ttttt"));
} catch (err) {
console.log(`throw: ${err}`);
}
以上程序会输出:
{ value: 1, done: false }
Step: 2
{ value: 2, done: false }
Step 2 Error: 22222
Step: 3
{ value: 3, done: true }
{ value: undefined, done: true }
throw: ttttt
next
产生器函数回传的迭代器会提供的 next 方法其实也可以影响迭代器内部的运作,传进 next 方法作为第一个参数的值会被当下正在暂停、即将继续运行的那个 yield 关键字给回传。
举例来说:
function* g() {
console.log("Step: 1");
const a = yield 1;
console.log("Step: 2");
yield a;
console.log("Step: 3");
return 3;
}
const iterator = g();
console.log(iterator.next(100));
console.log(iterator.next(200));
console.log(iterator.next(300));
以上程序会输出:
{ value: 1, done: false }
Step: 2
{ value: 200, done: false }
Step: 3
{ value: 3, done: true }
程序第 10 行调用 g 这个产生器函数只会产生一个迭代器,并指派给 iterator 变量来保存,并不会去运行产生器函数主体中的程序叙述。
程序第 12 行,第一次调用 iterator 的 next 方法,会去运行产生器函数主体中的程序叙述。运行到第 3 行时会遇到 yield 关键字,产生器函数主体中的程序叙述会暂停运行,然后将数值 1 回传出来。
程序第 13 行,第二次调用 iterator 的 next 方法,并且将数值 200 代入其第一个参数,此时程序第 3 行,产生器函数主体中正在暂停的 yield 关键字会回传数值 200,然后指派给变量 a 来保存,并继续运行产生器函数主体中的程序叙述。运行到第 5 行时会遇到 yield 关键字,产生器函数主体中的程序叙述会暂停运行,然后将变量 a 保存的值,也就是数值 200 回传出来。
程序第 14 行,第三次调用 iterator 的 next 方法,并且将数值 300 代入其第一个参数,此时程序第 5 行,产生器函数主体中正在暂停的 yield 关键字会回传数值 300,但是并没有指派给任何变量或常数来保存,接着继续运行产生器函数主体中的程序叙述。运行到第 7 行时会遇到 return 关键字,产生器函数主体中之后的程序叙述会停止运行,然后数值 3 会被回传出来。
总结
在这个章节中,我们学会了在 TypeScript 中设计迭代器的方式,并且也学会透过产生器来快速产生「加强版」的迭代器。在接下来的三个章节中,要来搞懂 JavaScript 复杂的回呼(callback)、Promise 和「async/await」语法。
