迭代器(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);
}

以上程序会输出:

9
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());

以上程序会输出:

{ value: 1, done: true }

在产生器函数中,我们可以用 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: 1, done: false }
{ 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());

以上程序会输出:

Step: 1
{ 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}`);
}

以上程序会输出:

Step: 1
{ 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));

以上程序会输出:

Step: 1
{ 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」语法。

下一章:事件循环(Event Loop)与回呼函数(Callback Function)。