Iterator和Generator是什么

Iterator和Generator是什么

JavaScript发表留言

1. 迭代器

1.1. 什么是迭代器？

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

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

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

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

迭代器协议定义了产生一系列值（无论是有限还是无限个）的标准方式；

在 JavaScript 中这个标准就是一个特定的 next 方法；

next 方法有如下的要求：

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

1.2. 迭代器的代码练习

JavaScript 中迭代器

const names = ["abc", "cba", "nba"];

// 给数组names创建一个迭代器(迭代器: names的迭代器)
let index = 0;
const namesIterator = {
  next: function () {
    // done: Boolean
    // value: 具体值/undefined
    if (index < names.length) {
      return { done: false, value: names[index++] };
    } else {
      return { done: true };
    }
  },
};

console.log(namesIterator.next());
console.log(namesIterator.next());
console.log(namesIterator.next());
console.log(namesIterator.next());

为数组创建迭代器

const names = ["abc", "cba", "nba"];
const nums = [100, 24, 55, 66, 86];

// 封装一个函数
function createArrayIterator(arr) {
  let index = 0;
  return {
    next: function () {
      if (index < arr.length) {
        return { done: false, value: arr[index++] };
      } else {
        return { done: true };
      }
    },
  };
}

const namesIterator = createArrayIterator(names);
console.log(namesIterator.next());
console.log(namesIterator.next());
console.log(namesIterator.next());
console.log(namesIterator.next());

1.3. 可迭代对象

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

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

什么又是可迭代对象呢？

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

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

  • 当一个对象变成一个可迭代对象的时候，就可以进行某些迭代操作；
  • 比如 for…of 操作时，其实就会调用它的 @@iterator 方法；

1.4. 可迭代对象的代码

// 将infos变成一个可迭代对象
/*
    1.必须实现一个特定的函数: [Symbol.iterator]
    2.这个函数需要返回一个迭代器(这个迭代器用于迭代当前的对象)
*/
const infos = {
  friends: ["kobe", "james", "curry"],
  [Symbol.iterator]: function () {
    let index = 0;
    const infosIterator = {
      next: function () {
        // done: Boolean
        // value: 具体值/undefined
        if (index < infos.friends.length) {
          return { done: false, value: infos.friends[index++] };
        } else {
          return { done: true };
        }
      },
    };
    return infosIterator;
  },
};

// 可迭代对象必然具备下面的特点
const iterator = infos[Symbol.iterator]();
console.log(iterator.next());
console.log(iterator.next());
console.log(iterator.next());
console.log(iterator.next());

// 可迭对象可以进行for of操作
for (const item of infos) {
  console.log(item);
}

// 可迭代对象必然有一个[Symbol.iterator]函数
// 数组是一个可迭代对象
const students = ["张三", "李四", "王五"];
console.log(students[Symbol.iterator]);
const studentIterator = students[Symbol.iterator]();
console.log(studentIterator.next());
console.log(studentIterator.next());
console.log(studentIterator.next());
console.log(studentIterator.next());

1.5. 原生迭代器对象

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

  • String、Array、Map、Set、arguments 对象、NodeList 集合；

image-20230113142735310

image-20230113142743769

1.6. 可迭代对象的应用

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

  • 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);

image-20230113142910076

1.7. 自定义类的迭代

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

  • 在面向对象开发中，我们可以通过class 定义一个自己的类，这个类可以创建很多的对象：
  • 如果我们也希望自己的类创建出来的对象默认是可迭代的，那么在设计类的时候我们就可以添加上 @@iterator 方法；
class Person {
  constructor(name, age, height, friends) {
    this.name = name;
    this.age = age;
    this.height = height;
    this.friends = friends;
  }

  // 实例方法
  running() {}
  [Symbol.iterator]() {
    let index = 0;
    const iterator = {
      next: () => {
        if (index < this.friends.length) {
          return { done: false, value: this.friends[index++] };
        } else {
          return { done: true };
        }
      },
    };
    return iterator;
  }
}

const p1 = new Person("why", 18, 1.88, ["curry", "kobe", "james", "tatumu"]);
const p2 = new Person("kobe", 30, 1.98, ["curry", "james", "aonier", "weide"]);

for (const item of p2) {
  console.log(item);
}

1.8. 迭代器的中断

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

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

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

class Person {
  constructor(name, age, height, friends) {
    this.name = name;
    this.age = age;
    this.height = height;
    this.friends = friends;
  }

  // 实例方法
  running() {}
  [Symbol.iterator]() {
    let index = 0;
    const iterator = {
      next: () => {
        if (index < this.friends.length) {
          return { done: false, value: this.friends[index++] };
        } else {
          return { done: true };
        }
      },
      return: () => {
        console.log("监听到迭代器中断了");
        return { done: true };
      },
    };
    return iterator;
  }
}

const p1 = new Person("why", 18, 1.88, ["curry", "kobe", "james", "tatumu"]);

for (const item of p1) {
  console.log(item);
  if (item === "kobe") {
    break;
  }
}

2. 生成器

2.1. 什么是生成器？

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

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

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

  • 首先，生成器函数需要在 function 的后面加一个符号：*
  • 其次，生成器函数可以通过 yield 关键字来控制函数的执行流程：
  • 最后，生成器函数的返回值是一个 Generator（生成器）：
    • 生成器事实上是一种特殊的迭代器；
    • MDN：Instead, they return a special type of iterator, called a Generator.

2.2. 生成器函数执行

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

  • 那么我们如何可以让它执行函数中的东西呢？调用 next即可；
  • 我们之前学习迭代器时，知道迭代器的 next 是会有返回值的；
  • 但是我们很多时候不希望 next 返回的是一个 undefined，这个时候我们可以通过 yield 来返回结果；

image-20230113143645052

2.3. 生成器传递参数–next 函数

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

  • 答案是可以的；
  • 我们在调用 next 函数的时候，可以给它传递参数，那么这个参数会作为上一个 yield 语句的返回值；
  • 注意：也就是说我们是为本次的函数代码块执行提供了一个值；

image-20230113143821876

2.4. 生成器提前结束–return 函数

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

  • return 传值后这个生成器函数就会结束，之后调用 next 不会继续生成值了；

image-20230113143934056

2.5. 生成器抛出异常–throw 函数

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

  • 抛出异常后我们可以在生成器函数中捕获异常；
  • 但是在catch 语句中不能继续 yield 新的值了，但是可以在 catch 语句外使用 yield 继续中断函数的执行；

image-20230113144114214

2.6. 生成器替代迭代器

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

// 1.对之前的代码进行重构(用生成器函数)
const names = ["abc", "cba", "nba"];

function* createArrayIterator(arr) {
  for (let i = 0; i < arr.length; i++) {
    yield arr[i];
  }
}

const namesIterator = createArrayIterator(names);
console.log(namesIterator.next());
console.log(namesIterator.next());
console.log(namesIterator.next());
console.log(namesIterator.next());

// 2.生成器函数, 可以生成某个范围的值
// [3, 9)
function* createRangeGenerator(start, end) {
  for (let i = start; i < end; i++) {
    yield i;
  }
}

const rangeGen = createRangeGenerator(3, 9);
console.log(rangeGen.next());
console.log(rangeGen.next());
console.log(rangeGen.next());
console.log(rangeGen.next());
console.log(rangeGen.next());
console.log(rangeGen.next());
console.log(rangeGen.next());
console.log(rangeGen.next());

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

  • 这个时候相当于是一种 yield 的语法糖，只不过会依次迭代这个可迭代对象，每次迭代其中的一个值；
// 1.yield*替换之前的方案
const names = ["abc", "cba", "nba"];
const nums = [100, 22, 66, 88, 55];

function* createArrayIterator(arr) {
  yield* arr;
}

const namesIterator = createArrayIterator(names);
console.log(namesIterator.next());
console.log(namesIterator.next());
console.log(namesIterator.next());
console.log(namesIterator.next());

2.7. 自定义类迭代–生成器实现

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

// 2.yield替换类中的实现
class Person {
  constructor(name, age, height, friends) {
    this.name = name;
    this.age = age;
    this.height = height;
    this.friends = friends;
  }

  // 实例方法
  *[Symbol.iterator]() {
    yield* this.friends;
  }
}

const p = new Person("why", 18, 1.88, ["kobe", "james", "curry"]);
for (const item of p) {
  console.log(item);
}

const pIterator = p[Symbol.iterator]();
console.log(pIterator.next());
console.log(pIterator.next());
console.log(pIterator.next());
console.log(pIterator.next());

2.8. 对生成器的操作

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

image-20230113144632689

3. 异步处理方案

学完了我们前面的 Promise、生成器等，我们目前来看一下异步代码的最终处理方案。

案例需求：

  • 我们需要向服务器发送网络请求获取数据，一共需要发送三次请求；
  • 第二次的请求 url 依赖于第一次的结果；
  • 第三次的请求 url 依赖于第二次的结果；
  • 依次类推；
// 封装请求的方法: url -> promise(result)
function requestData(url) {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      resolve(url);
    }, 2000);
  });
}

// 1.发送一次网络请求
requestData("http://why").then((res) => {
  console.log("res:", res);
});

/*
  需求: 
    1.发送一次网络请求, 等到这次网络请求的结果
    2.发送第二次网络请求, 等待这次网络请求的结果
    3.发送第三次网络请求, 等待这次网络请求的结果
*/
// 方式一: 层层嵌套(回调地狱 callback hell)
function getData1() {
  // 1.第一次请求
  requestData("why").then((res1) => {
    console.log("第一次结果:", res1);

    // 2.第二次请求
    requestData(res1 + "kobe").then((res2) => {
      console.log("第二次结果:", res2);

      // 3.第三次请求
      requestData(res2 + "james").then((res3) => {
        console.log("第三次结果:", res3);
      });
    });
  });
}

// 方式二: 使用Promise进行重构(解决回调地狱)
// 链式调用
function getData2() {
  requestData("why")
    .then((res1) => {
      console.log("第一次结果:", res1);
      return requestData(res1 + "kobe");
    })
    .then((res2) => {
      console.log("第二次结果:", res2);
      return requestData(res2 + "james");
    })
    .then((res3) => {
      console.log("第三次结果:", res3);
    });
}

// 方式三: 最终代码
function* getData3() {
  const res1 = yield requestData("why");
  console.log("res1:", res1);

  const res2 = yield requestData(res1 + "kobe");
  console.log("res2:", res2);

  const res3 = yield requestData(res2 + "james");
  console.log("res3:", res3);
}

const generator1 = getData3();
generator.next().value.then((res1) => {
  generator.next(res1).value.then((res2) => {
    generator.next(res2).value.then((res3) => {
      generator.next(res3);
    });
  });
});

// 方式四: async/await的解决方案
async function getData4() {
  const res1 = await requestData("why");
  console.log("res1:", res1);

  const res2 = await requestData(res1 + "kobe");
  console.log("res2:", res2);

  const res3 = await requestData(res2 + "james");
  console.log("res3:", res3);
}

const generator2 = getData4();

3.1. 自动执行 Generator 函数

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

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

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

// 封装请求的方法: url -> promise(result)
function requestData(url) {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      resolve(url);
    }, 2000);
  });
}

// 生成器的处理方案
function* getData() {
  const res1 = yield requestData("why");
  console.log("res1:", res1);

  const res2 = yield requestData(res1 + "kobe");
  console.log("res2:", res2);

  const res3 = yield requestData(res2 + "james");
  console.log("res3:", res3);

  const res4 = yield requestData(res3 + "curry");
  console.log("res4:", res4);

  const res5 = yield requestData(res4 + "tatumu");
  console.log("res5:", res5);
}

// 自动化执行生成器函数(了解)
function execGenFn(genFn) {
  // 1.获取对应函数的generator
  const generator = genFn();
  // 2.定义一个递归函数
  function exec(res) {
    // result -> { done: true/false, value: 值/undefined }
    const result = generator.next(res);
    if (result.done) return;
    result.value.then((res) => {
      exec(res);
    });
  }
  // 3.执行递归函数
  exec();
}

execGenFn(getData);
打赏微海报分享

留下回复

目录

→ 目录