阿金博客

Appearance

迭代器-生成器和 await-async ​

本章我们来学习迭代器（Iterator）和生成器（Generator）。
迭代器和生成器本身在开发中某些场景里面我们是会直接使用的，也是很多语法的底层原理（比如 for of 循环、await、async 的底层）

一. 迭代器 Iterator ​

1.1. 什么是迭代器？ ​

迭代器（iterator），是确使用户可在容器对象（container，例如链表或数组）上遍访的对象，使用该接口无需关心对象的内部实现细节。

  • 其行为像数据库中的光标，迭代器最早出现在 1974 年设计的 CLU 编程语言中；
  • 在各种编程语言的实现中，迭代器的实现方式各不相同，但是基本都有迭代器，比如 Java、Python 等；

从迭代器的定义我们可以看出来，迭代器是帮助我们对某个数据结构进行遍历的对象。

在 JavaScript 中，迭代器也是一个具体的对象，这个对象需要符合迭代器协议（iterator protocol）：

  • 迭代器协议定义了产生一系列值（无论是优先还是无限个）的标准方式；
  • 那么在 js 中这个标准就是一个特定的 next 方法；

next 方法有如下的要求：

  • 一个无参数函数，返回一个应当拥有以下两个属性的对象：
  • done（boolean）
    • 如果迭代器可以产生序列中的下一个值，则为 false。（这等价于没有指定 done 这个属性。）
    • 如果迭代器已将序列迭代完毕，则为 true。这种情况下，value 是可选的，如果它依然存在，即为迭代结束之后的默认返回值。
  • value
    • 迭代器返回的任何 JavaScript 值。done 为 true 时可省略。

那么我们可以自己编写一个迭代器：

javascript
const friends = ["lilei", "kobe", "james"];

// 创建一个迭代器，用于迭代friends
let index = 0;
const friendsIterator = {
  next: function () {
    if (index < friends.length) {
      return { done: false, value: friends[index++] };
    } else {
      return { done: true, value: undefined };
    }
  },
};

接下来我们可以使用这个迭代器：

javascript
console.log(friendsIterator.next()); // { done: false, value: 'lilei' }
console.log(friendsIterator.next()); // { done: false, value: 'kobe' }
console.log(friendsIterator.next()); // { done: false, value: 'james' }
console.log(friendsIterator.next()); // { done: true, value: undefined }

那么如果我们每个数组需要用上面的方式创建迭代器会有点麻烦，我们也可以封装一个函数：

javascript
function createArrayIterator(arr) {
  let index = 0;
  return {
    next: function () {
      if (index < arr.length) {
        return { done: false, value: arr[index++] };
      } else {
        return { done: true, value: undefined };
      }
    },
  };
}

const friendsIterator = createArrayIterator(friends);
console.log(friendsIterator.next());
console.log(friendsIterator.next());
console.log(friendsIterator.next());
console.log(friendsIterator.next());

我们也可以生成一个无限的数字迭代器：

javascript
function createNumberIterator() {
  let count = 0;
  return {
    next: function () {
      return { done: false, value: count++ };
    },
  };
}

const numIterator = createNumberIterator();
console.log(numIterator.next());
console.log(numIterator.next());
console.log(numIterator.next());

1.2. 可迭代的对象 ​

但是上面的代码整体来说看起来是有点奇怪的：

  • 我们获取一个数组的时候，需要自己创建一个 index 变量，再创建一个所谓的迭代器对象；
  • 事实上我们可以对上面的代码进行进一步的封装，让其变成一个可迭代对象；

什么又是可迭代对象呢？

  • 它和迭代器是不同的概念；
  • 当一个对象实现了 iterable protocol 协议时，它就是一个可迭代对象；
  • 这个对象的要求是必须实现 @@iterator 方法，在代码中我们使用 Symbol.iterator 访问该属性；

我们对上面的代码进行重构：

javascript
const info = {
  friends: ["lilei", "kobe", "james"],
  [Symbol.iterator]: function () {
    let index = 0;
    return {
      next: () => {
        if (index < this.friends.length) {
          return { done: false, value: this.friends[index++] };
        } else {
          return { done: true, value: undefined };
        }
      },
    };
  },
};

当我们要问一个问题，我们转成这样的一个东西有什么好处呢？

  • 当一个对象变成一个可迭代对象的时候，进行某些迭代操作，比如 for...of 操作时，其实就会调用它的 @@iterator 方法；
javascript
for (const item of info) {
  console.log(item);
}

1.3. 原生迭代器对象 ​

事实上我们平时创建的很多原生对象已经实现了可迭代协议，会生成一个迭代器对象的：

  • String、Array、Map、Set、arguments 对象、NodeList 集合；
javascript
const str = "Hello World";

for (const s of str) {
  console.log(s);
}

const arr = ["abc", "cba", "nba"];
for (const item of arr) {
  console.log(item);
}

function foo(x, y, z) {
  for (const arg of arguments) {
    console.log(arg);
  }
}

foo(20, 30, 40);

可迭代对象的拆解：

javascript
// 数组本身是一个可迭代对象
const names = ["abc", "cba", "nba"];

// 获取可迭代的函数
console.log(names[Symbol.iterator]); // [Function: values]

// 调用可迭代函数, 获取到迭代器
const iterator = names[Symbol.iterator]();
console.log(iterator.next());
console.log(iterator.next());
console.log(iterator.next());
console.log(iterator.next()); // { value: undefined, done: true }

那么这些东西可以被用在哪里呢？

  • JavaScript 中语法：for ...of、展开语法（spread syntax）、yield*（后面讲）、解构赋值（Destructuring_assignment）；
  • 创建一些对象时：new Map([Iterable])、new WeakMap([iterable])、new Set([iterable])、new WeakSet([iterable]);
  • 一些方法的调用：Promise.all(iterable)、Promise.race(iterable)、Array.from(iterable);
javascript
// 1.for...of
for (const item of info) {
  console.log(item);
}

// 2.展开运算符
console.log([...info, "curry"]);

// 3.解构
const [name1, name2] = info;
console.log(name1, name2);

// 4.创建其他解构
console.log(new Set(info));
console.log(Array.from(info));

// 5.调用方法
Promise.all(info).then((res) => {
  console.log(res); // [ 'lilei', 'kobe', 'james' ]
});

1.4. 自定义类迭代 ​

在前面我们看到 Array、Set、String、Map 等类创建出来的对象都是可迭代对象：

  • 在面向对象开发中，我们可以通过 class 定义一个自己的类，这个类可以创建很多的对象：
  • 如果我们也希望自己的类创建出来的对象默认是可迭代的，那么在设计类的时候我们就可以添加上 @@iterator 方法；

案例：创建一个 classroom 的类

  • 教室中有自己的位置、名称、当前教室的学生；
  • 这个教室可以进来新学生（push）；
  • 创建的教室对象是可迭代对象；
javascript
class Classroom {
  constructor(name, address, initialStudent) {
    this.name = name;
    this.address = address;
    this.students = initialStudent || [];
  }

  push(student) {
    this.students.push(student);
  }

  [Symbol.iterator]() {
    let index = 0;
    return {
      next: () => {
        if (index < this.students.length) {
          return { done: false, value: this.students[index++] };
        } else {
          return { done: true };
        }
      },
    };
  }
}

接下来我们可以使用这个类：

javascript
const classroom1 = new Classroom("2201", "3幢", ["abc", "cba"]);
const classroom2 = new Classroom("3383", "5幢", ["james", "kobe"]);

for (const stu of classroom1) {
  console.log(stu);
}

for (const stu of classroom2) {
  console.log(stu);
}

迭代器在某些情况下会在没有完全迭代的情况下终止：

  • 比如遍历的过程中通过 break、continue、return、throw 中断了循环操作；
  • 比如在解构的时候，没有解构所有的值；

那么这个时候我们想要监听中断的话，可以添加 return 方法：

javascript
class Classroom {
  constructor(name, address, initialStudent) {
    this.name = name;
    this.address = address;
    this.students = initialStudent || [];
  }

  push(student) {
    this.students.push(student);
  }

  [Symbol.iterator]() {
    let index = 0;
    return {
      next: () => {
        if (index < this.students.length) {
          return { done: false, value: this.students[index++] };
        } else {
          return { done: true };
        }
      },
      return() {
        console.log("迭代器提前终止了");
        return { done: true };
      },
    };
  }
}

比如在循环、解构的时候终止：

javascript
const classroom1 = new Classroom("2201", "3幢", ["abc", "cba"]);

for (const stu of classroom1) {
  console.log(stu);
  if (stu === "abc") {
    break;
  }
}

const [name] = classroom1;
console.log(name);

二. 生成器 Generator ​

2.1. 什么是生成器 ​

生成器是 ES6 中新增的一种函数控制、使用的方案，它可以让我们更加灵活的控制函数什么时候继续执行、暂停执行等。

平时我们会编写很多的函数，这些函数终止的条件通常是返回值或者发生了异常：

  • 下面的函数在没有遇到 return 或者抛出异常时就会一直执行，直到执行到函数的末尾，默认返回一个 undefined；
javascript
function foo() {
  const value1 = 100;

  const value2 = 200;

  const value3 = 300;
}

生成器函数也是一个函数，但是和普通的函数有一些区别：

首先，生成器函数需要在 function 的后面加一个符号：*

javascript
function* foo() {}

其次，生成器函数可以通过 yield 关键字来控制函数的执行流程：

javascript
function* foo() {
  const value1 = 100;
  console.log(value1);
  yield;

  const value2 = 200;
  console.log(value2);
  yield;

  const value3 = 300;
  console.log(value3);
  yield;
}

最后，生成器函数的返回值是一个 Generator（生成器）：

  • 生成器事实上是一种特殊的迭代器；
  • MDN：Instead, they return a special type of iterator, called a Generator.
javascript
// 返回生成器
const generator = foo();

2.2. 生成器函数执行 ​

我们发现上面的生成器函数 foo 的执行体压根没有执行，它只是返回了一个生成器对象。

  • 那么我们如何可以让它执行函数中的东西呢？
  • 调用 next 即可；
javascript
// 返回生成器
const generator = foo();

// 执行到第一个yield,并且暂停
generator.next();

// 执行到第二个yield,并且暂停
generator.next();

// 执行到第三个yield,并且暂停
generator.next();

// 执行剩余的代码
generator.next();

我们之前学习迭代器时，知道迭代器的 next 是会有返回值的：

javascript
// 执行到第一个yield,并且暂停
console.log(generator.next()); // { value: undefined, done: false }

但是我们很多时候不希望 next 返回的是一个 undefined，这个时候我们可以通过 yield 来返回结果：

javascript
function* foo() {
  console.log("函数开始执行~");
  const value1 = 100;
  console.log(value1);
  yield value1;

  const value2 = 200;
  console.log(value2);
  yield value2;

  const value3 = 300;
  console.log(value3);
  yield value3;

  console.log("函数结束执行~");
}

那么事实上我们可以讲代码编写成如下的函数：

javascript
function* foo() {
  let i = 1;
  while (true) {
    yield i++ * 100;
  }
}

const generator = foo();
console.log(generator.next());
console.log(generator.next());
console.log(generator.next());

2.3. 生成器的参数 ​

函数既然可以暂停来分段执行，那么函数应该是可以传递参数的，我们是否可以给每个分段来传递参数呢？

  • 答案是可以的；
  • 我们在调用 next 函数的时候，可以给它传递参数，那么这个参数会作为上一个 yield 语句的返回值；
  • 注意：也就是说我们是为本次的函数代码块执行提供了一个值；
javascript
function* foo(initial) {
  console.log("函数开始执行~");
  const value1 = yield initial + "aaa";
  const value2 = yield value1 + "bbb";
  const value3 = yield value2 + "ccc";
}

const generator = foo("why");
const result1 = generator.next();
console.log("result1:", result1);
const result2 = generator.next(result1.value);
console.log("result2:", result2);
const result3 = generator.next(result2.value);
console.log("result3:", result3);

还有一个可以给生成器函数传递参数的方法是通过 return 函数：

  • return 传值后这个生成器函数就会结束，之后调用 next 不会继续生成值了；
javascript
function* foo() {
  const value1 = yield "why";
  console.log("value1:", value1);
  const value2 = yield value1;
  const value3 = yield value2;
}

const generator = foo();
console.log(generator.next());
console.log(generator.return(123));
console.log(generator.next());

除了给生成器函数内部传递参数之外，也可以给生成器函数内部抛出异常：

  • 抛出异常后我们可以在生成器函数中捕获异常；
  • 但是在 catch 语句中不能继续 yield 新的值了，但是可以在 catch 语句外使用 yield 继续中断函数的执行；
javascript
function* foo() {
  console.log("函数开始执行~");

  try {
    yield "why";
  } catch (err) {
    console.log("内部捕获异常:", err);
  }

  console.log("函数结束执行~");
}

const generator = foo();
const result = generator.next();
if (result !== "why") {
  generator.throw("error message");
}

2.4. 生成器替代迭代器 ​

我们发现生成器是一种特殊的迭代器，那么在某些情况下我们可以使用生成器来替代迭代器：

javascript
function* createArrayIterator(arr) {
  for (const item of arr) {
    yield item;
  }
}

const names = ["abc", "cba", "nba"];
namesIterator = createArrayIterator(names);
console.log(namesIterator.next());
console.log(namesIterator.next());
console.log(namesIterator.next());
console.log(namesIterator.next());

我们再创建一个范围的迭代器对象：

javascript
function* createRangeIterator(start, end) {
  for (let i = start; i < end; i++) {
    yield i;
  }
}

const rangeIterator = createRangeIterator(10, 20);
console.log(rangeIterator.next());
console.log(rangeIterator.next());
console.log(rangeIterator.next());
console.log(rangeIterator.next());

事实上我们还可以使用 yield*来生产一个可迭代对象：

  • 这个时候相当于是一种 yield 的语法糖，只不过会依次迭代这个可迭代对象，每次迭代其中的一个值；
javascript
function* createArrayIterator(arr) {
  yield* arr;
}

const names = ["abc", "cba", "nba"];
const namesIterator = createArrayIterator(names);
console.log(namesIterator.next());
console.log(namesIterator.next());
console.log(namesIterator.next());
console.log(namesIterator.next());

在之前的自定义类迭代中，我们也可以换成生成器：

javascript
class Classroom {
  constructor(name, address, initialStudent) {
    this.name = name;
    this.address = address;
    this.students = initialStudent || [];
  }

  push(student) {
    this.students.push(student);
  }

  *[Symbol.iterator]() {
    yield* this.students;
  }
}

既然生成器是一个迭代器，那么我们可以对其进行如下的操作：

javascript
const namesIterator1 = createArrayIterator(names);
for (const item of namesIterator1) {
  console.log(item);
}

const namesIterator2 = createArrayIterator(names);
const set = new Set(namesIterator2);
console.log(set);

const namesIterator3 = createArrayIterator(names);
Promise.all(namesIterator3).then((res) => {
  console.log(res);
});

2.5. 生成器处理异步 ​

javascript
function requestData(url) {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      resolve(url);
    }, 2000);
  });
}

function getData() {
  requestData("why").then((res1) => {
    requestData(res1 + "aaa").then((res2) => {
      requestData(res2 + "bbb").then((res3) => {
        console.log("res3:", res3);
      });
    });
  });
}

getData();

我们可以对 getData 进行修正：

javascript
function getData() {
  requestData("why")
    .then((res1) => {
      return requestData(res1 + "aaa");
    })
    .then((res2) => {
      return requestData(res2 + "bbb");
    })
    .then((res3) => {
      console.log("res3:", res3);
    });
}

但是上面的代码其实看起来也是阅读性比较差的，有没有办法可以继续来对上面的代码进行优化呢？

javascript
function* getData() {
  const res1 = yield requestData("why");
  const res2 = yield requestData(res1 + "aaa");
  const res3 = yield requestData(res2 + "bbb");
  console.log(res3);
}

我们编写成了生成器函数，但是生成器函数必须自己调用 next 来执行：

javascript
const generator = getData();
generator.next().value.then((res) => {
  generator.next(res).value.then((res) => {
    generator.next(res).value.then((res) => {
      generator.next(res);
    });
  });
});

目前我们的写法有两个问题：

  • 第一，我们不能确定到底需要调用几层的 Promise 关系；
  • 第二，如果还有其他需要这样执行的函数，我们应该如何操作呢？

所以，我们可以封装一个工具函数 execGenerator 自动执行生成器函数：

javascript
function execGenerator(genFn) {
  const generator = genFn();
  function exec(res) {
    const result = generator.next(res);
    if (result.done) return result.value;
    result.value.then((res) => {
      exec(res);
    });
  }
  exec();
}

事实上对于上面的异步处理代码，在 ES8（ES2017）新增了 async、await 关键字：

javascript
function requestData(url) {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      resolve(url);
    }, 2000);
  });
}

async function getData() {
  const res1 = await requestData("why");
  const res2 = await requestData(res1 + "aaa");
  const res3 = await requestData(res2 + "bbb");
  const res4 = await requestData(res3 + "ccc");
  console.log(res4);
}

getData();

三. async/await ​

3.1. async 关键字 ​

async 关键字用于声明一个异步函数：

  • async 是 asynchronous 单词的缩写，异步、非同步；
  • sync 是 synchronous 单词的缩写，同步、同时；

async 异步函数可以有很多中写法：

javascript
async function foo1() {}

const foo2 = async function () {};

const foo3 = async () => {};

class Person {
  async foo() {}
}

异步函数的内部代码执行过程和普通的函数是一致的，默认情况下也是会被同步执行：

javascript
async function foo() {
  console.log("异步函数foo开始~");
  console.log("foo function");
  console.log("异步函数foo结束~");
}

console.log("start~");
foo();
console.log("end");

异步函数也可以有返回值，但是异步函数的返回值会被包裹到 Promise.resolve 中：

javascript
async function foo() {
  return "abc";
}

foo().then((res) => {
  console.log("res:", res);
});

如果我们的异步函数的返回值是 Promise，Promise.resolve 的状态会由 Promise 决定：

javascript
async function foo() {
  return new Promise((resolve, reject) => {
    // resolve("aaa")
    reject("bbb");
  });
}

foo()
  .then((res) => {
    console.log("res:", res);
  })
  .catch((err) => {
    console.log("err:", err);
  });

如果我们的异步函数的返回值是一个对象并且实现了 thenable，那么会由对象的 then 方法来决定：

javascript
async function foo() {
  return {
    then: function (resolve, reject) {
      // resolve(111)
      reject(222);
    },
  };
}

foo()
  .then((res) => {
    console.log("res:", res);
  })
  .catch((err) => {
    console.log("err:", err);
  });

如果我们在 async 中抛出了异常，那么程序它并不会像普通函数一样报错，而是会作为 Promise 的 reject 来传递：

javascript
async function foo() {
  throw new Error("foo error message");
}

foo()
  .then((res) => {
    console.log("res:", res);
  })
  .catch((err) => {
    console.log("err:", err);
  });

3.2. await 关键字 ​

async 函数另外一个特殊之处就是可以在它内部使用 await 关键字，而普通函数中是不可以的。

await 关键字有什么特点呢？

  • 通常使用 await 是后面会跟上一个表达式，这个表达式会返回一个 Promise；
  • 那么 await 会等到 Promise 的状态变成 fulfilled 状态，之后继续执行异步函数；
javascript
function requestData(url) {
  console.log("调用了requestData请求");
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      if (url === "coderwhy") {
        // 发送成功了
        resolve("一组成功数据");
      } else {
        // 发送失败了
        reject("请求url错误");
      }
    }, 1000);
  });
}

async function foo() {
  console.log("foo函数开始~");
  const result = await requestData("coderwhy");
  console.log("代码继续执行:", result);
}

foo();

如果 await 后面是一个普通的值，那么会直接返回这个值：

javascript
async function foo() {
  console.log("foo函数开始~")
  const result = await 123
  console.log("代码继续执行:", result)
}

如果await后面是一个theable的对象，那么会根据对象的then方法调用来决定后续的值：

javascript
async function foo() {
  console.log("foo函数开始~")
  const result = await {
    then: function(resolve, reject) {
      resolve("aaa")
    }
  }
  console.log("代码继续执行:", result)
}

如果 await 后面的表达式，返回的 Promise 是 reject 的状态，那么会将这个 reject 结果直接作为 foo 的 Promise 的 reject 值：

javascript
function requestData(url) {
  console.log("调用了requestData请求");
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      if (url === "coderwhy") {
        // 发送成功了
        resolve("一组成功数据");
      } else {
        // 发送失败了
        reject("请求url错误");
      }
    }, 1000);
  });
}

async function foo() {
  console.log("foo函数开始~");
  const result = await requestData("kobe");
  console.log("代码继续执行:", result);
}

foo()
  .then((res) => {
    console.log("res:", res);
  })
  .catch((err) => {
    console.log("err:", err);
  });