一丶Iterator 和 for…of 循环

1.Iterator（遍历器）的概念

Iterator是一种接口，为各种不同的数据结构提供统一的访问机制。任何数据结构只要部署 Iterator 接口，就可以完成遍历操作（即依次处理该数据结构的所有成员）。
Iterator 的作用有三个：一是为各种数据结构，提供一个统一的、简便的访问接口；二是使得数据结构的成员能够按某种次序排列；三是 ES6 创造了一种新的遍历命令for...of循环，Iterator 接口主要供for...of消费。
Iterator 的遍历过程是这样的。
（1）创建一个指针对象，指向当前数据结构的起始位置。也就是说，遍历器对象本质上，就是一个指针对象。
（2）第一次调用指针对象的next方法，可以将指针指向数据结构的第一个成员。
（3）第二次调用指针对象的next方法，指针就指向数据结构的第二个成员。
（4）不断调用指针对象的next方法，直到它指向数据结构的结束位置。
每一次调用next方法，都会返回数据结构的当前成员的信息。具体来说，就是返回一个包含value和done两个属性的对象。其中，value属性是当前成员的值，done属性是一个布尔值，表示遍历是否结束。
下面是一个模拟next方法返回值的例子。

  1. var it = makeIterator(['a', 'b']);
  2. it.next() // { value: "a", done: false }
  3. it.next() // { value: "b", done: false }
  4. it.next() // { value: undefined, done: true }
  5. function makeIterator(array) {
  6.   var nextIndex = 0;
  7.   return {
  8.     next: function() {
  9.       return nextIndex < array.length ?
  10.         {value: array[nextIndex++], done: false} :
  11.         {value: undefined, done: true};
  12.     }
  13.   };
  14. }

2.默认 Iterator 接口

Iterator 接口的目的，就是为所有数据结构，提供了一种统一的访问机制，即for...of循环（详见下文）。当使用for...of循环遍历某种数据结构时，该循环会自动去寻找 Iterator 接口。
一种数据结构只要部署了 Iterator 接口，我们就称这种数据结构是“可遍历的”（iterable）。
ES6 规定，默认的 Iterator 接口部署在数据结构的Symbol.iterator属性，或者说，一个数据结构只要具有Symbol.iterator属性，就可以认为是“可遍历的”（iterable）。Symbol.iterator属性本身是一个函数，就是当前数据结构默认的遍历器生成函数。执行这个函数，就会返回一个遍历器。至于属性名Symbol.iterator，它是一个表达式，返回Symbol对象的iterator属性，这是一个预定义好的、类型为 Symbol 的特殊值，所以要放在方括号内（参见《Symbol》一章）。
原生具备 Iterator 接口的数据结构如下。

  • Array
  • Map
  • Set
  • String
  • TypedArray
  • 函数的 arguments 对象

  • NodeList 对象

    3.遍历器对象的 return()，throw()

    遍历器对象除了具有next方法，还可以具有return方法和throw方法。如果你自己写遍历器对象生成函数，那么next方法是必须部署的，return方法和throw方法是否部署是可选的。
    return方法的使用场合是，如果for...of循环提前退出（通常是因为出错，或者有break语句），就会调用return方法。如果一个对象在完成遍历前，需要清理或释放资源，就可以部署return方法。

    1. function readLinesSync(file) {
    2. return {
    3.   [Symbol.iterator]() {
    4.     return {
    5.       next() {
    6.         return { done: false };
    7.       },
    8.       return() {
    9.         file.close();
    10.         return { done: true };
    11.       }
    12.     };
    13.   },
    14. };
    15. }

    4.for…of 循环

    ES6 借鉴 C++、Java、C# 和 Python 语言，引入了for...of循环，作为遍历所有数据结构的统一的方法。
    一个数据结构只要部署了Symbol.iterator属性，就被视为具有 iterator 接口，就可以用for...of循环遍历它的成员。也就是说，for...of循环内部调用的是数据结构的Symbol.iterator方法。
    for...of循环可以使用的范围包括数组、Set 和 Map 结构、某些类似数组的对象（比如arguments对象、DOM NodeList 对象）、后文的 Generator 对象，以及字符串。

    1.数组

    数组原生具备iterator接口（即默认部署了Symbol.iterator属性），for...of循环本质上就是调用这个接口产生的遍历器，可以用下面的代码证明。

    1. const arr = ['red', 'green', 'blue'];
    2. for(let v of arr) {
    3. console.log(v); // red green blue
    4. }
    5. const obj = {};
    6. obj[Symbol.iterator] = arr[Symbol.iterator].bind(arr);
    7. for(let v of obj) {
    8. console.log(v); // red green blue
    9. }

    上面代码中，空对象obj部署了数组arr的Symbol.iterator属性，结果obj的for...of循环，产生了与arr完全一样的结果。
    for...of循环可以代替数组实例的forEach方法。

    1. const arr = ['red', 'green', 'blue'];
    2. arr.forEach(function (element, index) {
    3. console.log(element); // red green blue
    4. console.log(index);   // 0 1 2
    5. });

    JavaScript 原有的for...in循环，只能获得对象的键名，不能直接获取键值。ES6 提供for...of循环，允许遍历获得键值。

    1. var arr = ['a', 'b', 'c', 'd'];
    2. for (let a in arr) {
    3. console.log(a); // 0 1 2 3
    4. }
    5. for (let a of arr) {
    6. console.log(a); // a b c d
    7. }

    上面代码表明，for...in循环读取键名，for...of循环读取键值。如果要通过for...of循环，获取数组的索引，可以借助数组实例的entries方法和keys方法（参见《数组的扩展》一章）。
    for...of循环调用遍历器接口，数组的遍历器接口只返回具有数字索引的属性。这一点跟for...in循环也不一样。

    1. let arr = [3, 5, 7];
    2. arr.foo = 'hello';
    3. for (let i in arr) {
    4. console.log(i); // "0", "1", "2", "foo"
    5. }
    6. for (let i of arr) {
    7. console.log(i); //  "3", "5", "7"
    8. }

    上面代码中，for...of循环不会返回数组arr的foo属性。

    2.Set 和 Map 结构

    Set 和 Map 结构也原生具有 Iterator 接口，可以直接使用for...of循环。

    1. var engines = new Set(["Gecko", "Trident", "Webkit", "Webkit"]);
    2. for (var e of engines) {
    3. console.log(e);
    4. }
    5. // Gecko
    6. // Trident
    7. // Webkit
    8. var es6 = new Map();
    9. es6.set("edition", 6);
    10. es6.set("committee", "TC39");
    11. es6.set("standard", "ECMA-262");
    12. for (var [name, value] of es6) {
    13. console.log(name + ": " + value);
    14. }
    15. // edition: 6
    16. // committee: TC39
    17. // standard: ECMA-262

    3.计算生成的数据结构

    有些数据结构是在现有数据结构的基础上，计算生成的。比如，ES6 的数组、Set、Map 都部署了以下三个方法，调用后都返回遍历器对象。

  • entries() 返回一个遍历器对象，用来遍历[键名, 键值]组成的数组。对于数组，键名就是索引值；对于 Set，键名与键值相同。Map 结构的 Iterator 接口，默认就是调用entries方法。

  • keys() 返回一个遍历器对象，用来遍历所有的键名。
  • values() 返回一个遍历器对象，用来遍历所有的键值。

这三个方法调用后生成的遍历器对象，所遍历的都是计算生成的数据结构。

  1. let arr = ['a', 'b', 'c'];
  2. for (let pair of arr.entries()) {
  3.   console.log(pair);
  4. }
  5. // [0, 'a']
  6. // [1, 'b']
  7. // [2, 'c']

4.类似数组的对象

类似数组的对象包括好几类。下面是for...of循环用于字符串、DOM NodeList 对象、arguments对象的例子。

  1. // 字符串
  2. let str = "hello";
  3. for (let s of str) {
  4.   console.log(s); // h e l l o
  5. }
  6. // DOM NodeList对象
  7. let paras = document.querySelectorAll("p");
  8. for (let p of paras) {
  9.   p.classList.add("test");
  10. }
  11. // arguments对象
  12. function printArgs() {
  13.   for (let x of arguments) {
  14.     console.log(x);
  15.   }
  16. }
  17. printArgs('a', 'b');
  18. // 'a'
  19. // 'b'

并不是所有类似数组的对象都具有 Iterator 接口，一个简便的解决方法，就是使用Array.from方法将其转为数组。

  1. let arrayLike = { length: 2, 0: 'a', 1: 'b' };
  2. // 报错
  3. for (let x of arrayLike) {
  4.   console.log(x);
  5. }
  6. // 正确
  7. for (let x of Array.from(arrayLike)) {
  8.   console.log(x);
  9. }

5.对象

对于普通的对象，for...of结构不能直接使用，会报错，必须部署了 Iterator 接口后才能使用。但是，这样情况下，for...in循环依然可以用来遍历键名。

  1. let es6 = {
  2.   edition: 6,
  3.   committee: "TC39",
  4.   standard: "ECMA-262"
  5. };
  6. for (let e in es6) {
  7.   console.log(e);
  8. }
  9. // edition
  10. // committee
  11. // standard
  12. for (let e of es6) {
  13.   console.log(e);
  14. }
  15. // TypeError: es6[Symbol.iterator] is not a function

上面代码表示，对于普通的对象，for...in循环可以遍历键名，for...of循环会报错。
一种解决方法是，使用Object.keys方法将对象的键名生成一个数组，然后遍历这个数组。

  1. for (var key of Object.keys(someObject)) {
  2.   console.log(key + ': ' + someObject[key]);
  3. }

另一个方法是使用 Generator 函数将对象重新包装一下。

  1. function* entries(obj) {
  2.   for (let key of Object.keys(obj)) {
  3.     yield [key, obj[key]];
  4.   }
  5. }
  6. for (let [key, value] of entries(obj)) {
  7.   console.log(key, '->', value);
  8. }
  9. // a -> 1
  10. // b -> 2
  11. // c -> 3

6.与其他遍历语法的比较

以数组为例，JavaScript 提供多种遍历语法。最原始的写法就是for循环。

  1. for (var index = 0; index < myArray.length; index++) {
  2.   console.log(myArray[index]);
  3. }

这种写法比较麻烦，因此数组提供内置的forEach方法。

  1. myArray.forEach(function (value) {
  2.   console.log(value);
  3. });

这种写法的问题在于，无法中途跳出forEach循环，break命令或return命令都不能奏效。
for...in循环可以遍历数组的键名。

  1. for (var index in myArray) {
  2.   console.log(myArray[index]);
  3. }

for...in循环有几个缺点。

  • 数组的键名是数字，但是for...in循环是以字符串作为键名“0”、“1”、“2”等等。
  • for...in循环不仅遍历数字键名，还会遍历手动添加的其他键，甚至包括原型链上的键。
  • 某些情况下，for...in循环会以任意顺序遍历键名。

总之，for...in循环主要是为遍历对象而设计的，不适用于遍历数组。
for...of循环相比上面几种做法，有一些显著的优点。

  1. for (let value of myArray) {
  2.   console.log(value);
  3. }
  • 有着同for...in一样的简洁语法，但是没有for...in那些缺点。
  • 不同于forEach方法，它可以与break、continue和return配合使用。
  • 提供了遍历所有数据结构的统一操作接口。

下面是一个使用 break 语句，跳出for...of循环的例子。

  1. for (var n of fibonacci) {
  2.   if (n > 1000)
  3.     break;
  4.   console.log(n);
  5. }

上面的例子，会输出斐波纳契数列小于等于 1000 的项。如果当前项大于 1000，就会使用break语句跳出for...of循环。

二丶Generator函数的语法

1.yield 表达式

由于 Generator 函数返回的遍历器对象，只有调用next方法才会遍历下一个内部状态，所以其实提供了一种可以暂停执行的函数。yield表达式就是暂停标志。
遍历器对象的next方法的运行逻辑如下。
（1）遇到yield表达式，就暂停执行后面的操作，并将紧跟在yield后面的那个表达式的值，作为返回的对象的value属性值。
（2）下一次调用next方法时，再继续往下执行，直到遇到下一个yield表达式。
（3）如果没有再遇到新的yield表达式，就一直运行到函数结束，直到return语句为止，并将return语句后面的表达式的值，作为返回的对象的value属性值。
（4）如果该函数没有return语句，则返回的对象的value属性值为undefined。
需要注意的是，yield表达式后面的表达式，只有当调用next方法、内部指针指向该语句时才会执行，因此等于为 JavaScript 提供了手动的“惰性求值”（Lazy Evaluation）的语法功能。

  1. function* gen() {
  2.   yield  123 + 456;
  3. }

上面代码中，yield后面的表达式123 + 456，不会立即求值，只会在next方法将指针移到这一句时，才会求值。

2.与 Iterator 接口的关系

上一章说过，任意一个对象的Symbol.iterator方法，等于该对象的遍历器生成函数，调用该函数会返回该对象的一个遍历器对象。
由于 Generator 函数就是遍历器生成函数，因此可以把 Generator 赋值给对象的Symbol.iterator属性，从而使得该对象具有 Iterator 接口。

  1. var myIterable = {};
  2. myIterable[Symbol.iterator] = function* () {
  3.   yield 1;
  4.   yield 2;
  5.   yield 3;
  6. };
  7. [...myIterable] // [1, 2, 3]

上面代码中，Generator 函数赋值给Symbol.iterator属性，从而使得myIterable对象具有了 Iterator 接口，可以被...运算符遍历了。

3.next 方法的参数

yield表达式本身没有返回值，或者说总是返回undefined。next方法可以带一个参数，该参数就会被当作上一个yield表达式的返回值。

  1. function* f() {
  2.   for(var i = 0; true; i++) {
  3.     var reset = yield i;
  4.     if(reset) { i = -1; }
  5.   }
  6. }
  7. var g = f();
  8. g.next() // { value: 0, done: false }
  9. g.next() // { value: 1, done: false }
  10. g.next(true) // { value: 0, done: false }

上面代码先定义了一个可以无限运行的 Generator 函数f，如果next方法没有参数，每次运行到yield表达式，变量reset的值总是undefined。当next方法带一个参数true时，变量reset就被重置为这个参数（即true），因此i会等于-1，下一轮循环就会从-1开始递增。
这个功能有很重要的语法意义。Generator 函数从暂停状态到恢复运行，它的上下文状态（context）是不变的。通过next方法的参数，就有办法在 Generator 函数开始运行之后，继续向函数体内部注入值。也就是说，可以在 Generator 函数运行的不同阶段，从外部向内部注入不同的值，从而调整函数行为。

4.for…of 循环

for...of循环可以自动遍历 Generator 函数运行时生成的Iterator对象，且此时不再需要调用next方法。

  1. function* foo() {
  2.   yield 1;
  3.   yield 2;
  4.   yield 3;
  5.   yield 4;
  6.   yield 5;
  7.   return 6;
  8. }
  9. for (let v of foo()) {
  10.   console.log(v);
  11. }
  12. // 1 2 3 4 5

上面代码使用for...of循环，依次显示 5 个yield表达式的值。这里需要注意，一旦next方法的返回对象的done属性为true，for...of循环就会中止，且不包含该返回对象，所以上面代码的return语句返回的6，不包括在for...of循环之中。

5.Generator.prototype.throw()

Generator 函数返回的遍历器对象，都有一个throw方法，可以在函数体外抛出错误，然后在 Generator 函数体内捕获。

  1. var g = function* () {
  2.   try {
  3.     yield;
  4.   } catch (e) {
  5.     console.log('内部捕获', e);
  6.   }
  7. };
  8. var i = g();
  9. i.next();
  10. try {
  11.   i.throw('a');
  12.   i.throw('b');
  13. } catch (e) {
  14.   console.log('外部捕获', e);
  15. }
  16. // 内部捕获 a
  17. // 外部捕获 b

上面代码中，遍历器对象i连续抛出两个错误。第一个错误被 Generator 函数体内的catch语句捕获。i第二次抛出错误，由于 Generator 函数内部的catch语句已经执行过了，不会再捕捉到这个错误了，所以这个错误就被抛出了 Generator 函数体，被函数体外的catch语句捕获。

6.Generator.prototype.return()

Generator 函数返回的遍历器对象，还有一个return方法，可以返回给定的值，并且终结遍历 Generator 函数。

  1. function* gen() {
  2.   yield 1;
  3.   yield 2;
  4.   yield 3;
  5. }
  6. var g = gen();
  7. g.next()        // { value: 1, done: false }
  8. g.return('foo') // { value: "foo", done: true }
  9. g.next()        // { value: undefined, done: true }

上面代码中，遍历器对象g调用return方法后，返回值的value属性就是return方法的参数foo。并且，Generator 函数的遍历就终止了，返回值的done属性为true，以后再调用next方法，done属性总是返回true。
如果return方法调用时，不提供参数，则返回值的value属性为undefined。

7.next()、throw()、return() 的共同点

next()、throw()、return()这三个方法本质上是同一件事，可以放在一起理解。它们的作用都是让 Generator 函数恢复执行，并且使用不同的语句替换yield表达式。

8.yield* 表达式

如果在 Generator 函数内部，调用另一个 Generator 函数。需要在前者的函数体内部，自己手动完成遍历。

  1. function* foo() {
  2.   yield 'a';
  3.   yield 'b';
  4. }
  5. function* bar() {
  6.   yield 'x';
  7.   // 手动遍历 foo()
  8.   for (let i of foo()) {
  9.     console.log(i);
  10.   }
  11.   yield 'y';
  12. }
  13. for (let v of bar()){
  14.   console.log(v);
  15. }
  16. // x
  17. // a
  18. // b
  19. // y

上面代码中，foo和bar都是 Generator 函数，在bar里面调用foo，就需要手动遍历foo。如果有多个 Generator 函数嵌套，写起来就非常麻烦。
ES6 提供了yield*表达式，作为解决办法，用来在一个 Generator 函数里面执行另一个 Generator 函数。

9.作为对象属性的 Generator 函数

如果一个对象的属性是 Generator 函数，可以简写成下面的形式。

  1. let obj = {
  2.   * myGeneratorMethod() {
  3.     ···
  4.   }
  5. };

上面代码中，myGeneratorMethod属性前面有一个星号，表示这个属性是一个 Generator 函数。
它的完整形式如下，与上面的写法是等价的。

  1. let obj = {
  2.   myGeneratorMethod: function* () {
  3.     // ···
  4.   }
  5. };

三丶Generator 函数的异步应用

1.传统方法

ES6 诞生以前，异步编程的方法，大概有下面四种。

  • 回调函数
  • 事件监听
  • 发布/订阅
  • Promise 对象

Generator 函数将 JavaScript 异步编程带入了一个全新的阶段。

2.基本概念

异步

所谓”异步”，简单说就是一个任务不是连续完成的，可以理解成该任务被人为分成两段，先执行第一段，然后转而执行其他任务，等做好了准备，再回过头执行第二段。
比如，有一个任务是读取文件进行处理，任务的第一段是向操作系统发出请求，要求读取文件。然后，程序执行其他任务，等到操作系统返回文件，再接着执行任务的第二段（处理文件）。这种不连续的执行，就叫做异步。
相应地，连续的执行就叫做同步。由于是连续执行，不能插入其他任务，所以操作系统从硬盘读取文件的这段时间，程序只能干等着。

回调函数

JavaScript 语言对异步编程的实现，就是回调函数。所谓回调函数，就是把任务的第二段单独写在一个函数里面，等到重新执行这个任务的时候，就直接调用这个函数。回调函数的英语名字callback，直译过来就是”重新调用”。
读取文件进行处理，是这样写的。

  1. fs.readFile('/etc/passwd', 'utf-8', function (err, data) {
  2.   if (err) throw err;
  3.   console.log(data);
  4. });

上面代码中，readFile函数的第三个参数，就是回调函数，也就是任务的第二段。等到操作系统返回了/etc/passwd这个文件以后，回调函数才会执行。
一个有趣的问题是，为什么 Node 约定，回调函数的第一个参数，必须是错误对象err（如果没有错误，该参数就是null）？
原因是执行分成两段，第一段执行完以后，任务所在的上下文环境就已经结束了。在这以后抛出的错误，原来的上下文环境已经无法捕捉，只能当作参数，传入第二段。

Promise

回调函数本身并没有问题，它的问题出现在多个回调函数嵌套。假定读取A文件之后，再读取B文件，代码如下。

  1. fs.readFile(fileA, 'utf-8', function (err, data) {
  2.   fs.readFile(fileB, 'utf-8', function (err, data) {
  3.     // ...
  4.   });
  5. });

不难想象，如果依次读取两个以上的文件，就会出现多重嵌套。代码不是纵向发展，而是横向发展，很快就会乱成一团，无法管理。因为多个异步操作形成了强耦合，只要有一个操作需要修改，它的上层回调函数和下层回调函数，可能都要跟着修改。这种情况就称为”回调函数地狱”（callback hell）。
Promise 对象就是为了解决这个问题而提出的。它不是新的语法功能，而是一种新的写法，允许将回调函数的嵌套，改成链式调用。采用 Promise，连续读取多个文件，写法如下。

  1. var readFile = require('fs-readfile-promise');
  2. readFile(fileA)
  3. .then(function (data) {
  4.   console.log(data.toString());
  5. })
  6. .then(function () {
  7.   return readFile(fileB);
  8. })
  9. .then(function (data) {
  10.   console.log(data.toString());
  11. })
  12. .catch(function (err) {
  13.   console.log(err);
  14. });

上面代码中，我使用了fs-readfile-promise模块，它的作用就是返回一个 Promise 版本的readFile函数。Promise 提供then方法加载回调函数，catch方法捕捉执行过程中抛出的错误。
可以看到，Promise 的写法只是回调函数的改进，使用then方法以后，异步任务的两段执行看得更清楚了，除此以外，并无新意。
Promise 的最大问题是代码冗余，原来的任务被 Promise 包装了一下，不管什么操作，一眼看去都是一堆then，原来的语义变得很不清楚。
那么，有没有更好的写法呢？

3.Generator 函数

协程

传统的编程语言，早有异步编程的解决方案（其实是多任务的解决方案）。其中有一种叫做”协程”（coroutine），意思是多个线程互相协作，完成异步任务。
协程有点像函数，又有点像线程。它的运行流程大致如下。

  • 第一步，协程A开始执行。
  • 第二步，协程A执行到一半，进入暂停，执行权转移到协程B。
  • 第三步，（一段时间后）协程B交还执行权。
  • 第四步，协程A恢复执行。

上面流程的协程A，就是异步任务，因为它分成两段（或多段）执行。
举例来说，读取文件的协程写法如下。

  1. function* asyncJob() {
  2.   // ...其他代码
  3.   var f = yield readFile(fileA);
  4.   // ...其他代码
  5. }

上面代码的函数asyncJob是一个协程，它的奥妙就在其中的yield命令。它表示执行到此处，执行权将交给其他协程。也就是说，yield命令是异步两个阶段的分界线。
协程遇到yield命令就暂停，等到执行权返回，再从暂停的地方继续往后执行。它的最大优点，就是代码的写法非常像同步操作，如果去除yield命令，简直一模一样。

协程的 Generator 函数实现

Generator 函数是协程在 ES6 的实现，最大特点就是可以交出函数的执行权（即暂停执行）。
整个 Generator 函数就是一个封装的异步任务，或者说是异步任务的容器。异步操作需要暂停的地方，都用yield语句注明。Generator 函数的执行方法如下。

  1. function* gen(x) {
  2.   var y = yield x + 2;
  3.   return y;
  4. }
  5. var g = gen(1);
  6. g.next() // { value: 3, done: false }
  7. g.next() // { value: undefined, done: true }

Generator 函数的数据交换和错误处理

Generator 函数可以暂停执行和恢复执行，这是它能封装异步任务的根本原因。除此之外，它还有两个特性，使它可以作为异步编程的完整解决方案：函数体内外的数据交换和错误处理机制。
next返回值的 value 属性，是 Generator 函数向外输出数据；next方法还可以接受参数，向 Generator 函数体内输入数据。

  1. function* gen(x){
  2.   var y = yield x + 2;
  3.   return y;
  4. }
  5. var g = gen(1);
  6. g.next() // { value: 3, done: false }
  7. g.next(2) // { value: 2, done: true }

上面代码中，第一个next方法的value属性，返回表达式x + 2的值3。第二个next方法带有参数2，这个参数可以传入 Generator 函数，作为上个阶段异步任务的返回结果，被函数体内的变量y接收。因此，这一步的value属性，返回的就是2（变量y的值）。
Generator 函数内部还可以部署错误处理代码，捕获函数体外抛出的错误。

  1. function* gen(x){
  2.   try {
  3.     var y = yield x + 2;
  4.   } catch (e){
  5.     console.log(e);
  6.   }
  7.   return y;
  8. }
  9. var g = gen(1);
  10. g.next();
  11. g.throw('出错了');
  12. // 出错了

上面代码的最后一行，Generator 函数体外，使用指针对象的throw方法抛出的错误，可以被函数体内的try...catch代码块捕获。这意味着，出错的代码与处理错误的代码，实现了时间和空间上的分离，这对于异步编程无疑是很重要的。