什么是迭代器?

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

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

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

在JavaScript中,迭代器也是一个具体的对象,这个对象需要符合迭代器协议(iterator protocol):

  • 迭代器协议定义了产生一系列值(无论是有限还是无限个)的标准方式;
  • 在JavaScript中这个标准就是一个特定的next方法;

next方法有如下的要求:

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

迭代器的代码练习

      const names = ["abc", "cba", "nba"];
      // 给数组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 nums = [100,32,436,657]
      const names = ["abc", "cba", "nba"];
      const nums = [100, 54, 54, 87, 23];
      
      // 封装一个函数
      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());

      const numsIterator = createArrayIterator(nums);
      console.log(numsIterator.next());
      console.log(numsIterator.next());
      console.log(numsIterator.next());
      console.log(numsIterator.next());

可迭代对象

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

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

什么又是可迭代对象呢?

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

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

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

可迭代对象的代码

      // 将 infos 编程一个可迭代对象
      /*
        1.必须实现一个特定的函数: [Symbol.iterator]
        2.这个函数需要返回一个迭代器(这个迭代器用于迭代当前的对象)
      */
      const infos = {
        friends: ["rick", "jack", "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;
        },
      };

      // 给 info 创建一个迭代器,迭代infos中的friends
      /* console.log(infosIterator.next());
      console.log(infosIterator.next());
      console.log(infosIterator.next());
      console.log(infosIterator.next()); */

      // 可迭代独享必然具备下面的特点
      const iterator = infos[Symbol.iterator]();
      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());

优化

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

      // 2.迭代infos中的key/value
      const infos = {
        name: "why",
        age: 18,
        height: 1.73,
        [Symbol.iterator]: function () {
          // const keys = Object.keys(this);
          // const values = Object.values(this);
          const entries = Object.entries(this);
          let index = 0;
          const infosIterator = {
            next: () => {
              if (index < entries.length) {
                return { done: false, value: entries[index++] };
              } else {
                return { done: true };
              }
            },
          };
          return infosIterator;
        },
      };
  
      // 给 info 创建一个迭代器,迭代infos中的friends
      /* console.log(infosIterator.next());
      console.log(infosIterator.next());
      console.log(infosIterator.next());
      console.log(infosIterator.next()); */

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

      // 可迭代对象可以进行 for...of 操作
      for (const item of infos) {
        const [key, value] = item;
        console.log(key, value);
      }

原生迭代器对象

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

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

      // 1.数组
      /* const names = ["abc", "cba", "nba"];
      for (const name of names) {
        console.log(name);
      }
      console.log(names[Symbol.iterator]()); */

      // 2.Set
      const set = new Set(["abc", "cba", "nba"]);
      for (const item of set) {
        console.log(item);
      }

      const setIterator = set[Symbol.iterator]();
      console.log(setIterator.next());
      console.log(setIterator.next());
      console.log(setIterator.next());
      console.log(setIterator.next());

      // 3.argument
      function foo() {
        for (const arg of arguments) {
          console.log(arg);
        }
      }
      foo(112, 2224, 567, 9, 0);

可迭代对象的应用

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

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

      // 1.用在特定的语法上

      const names = ["abc", "cba", "nba"];
      const info = {
        name: "why",
        age: 39,
        height: 1.76,
        [Symbol.iterator]: function () {
          const values = Object.values(this);
          let index = 0;
          const infosIterator = {
            next: () => {
              if (index < values.length) {
                return { done: false, value: values[index++] };
              } else {
                return { done: true };
              }
            },
          };
          return infosIterator;
        },
      };
      function foo(...args) {
        console.log(args);
      }

      foo(...info);

      // 2.一些类的构造方法中,也是传入的可迭代对象
      const set = new Set(["aaa", "bbb", "ccc"]);
      const set2 = new Set("abc");
      console.log(set2);

      const set3 = new Set(info);
      console.log(set3);
      
      // 3.一些常用的方法

      const p1 = Promise.resolve("aaa");
      const p2 = Promise.resolve("bbb");
      const p3 = Promise.resolve("ccc");
      const pSet = new Set();

      pSet.add(p1);
      pSet.add(p2);
      pSet.add(p3);
      Promise.all(pSet).then((res) => {
        console.log("res:", res);
      });


      function bar() {
        // console.log(arguments)
        // 将arguments转成Array类型
        const arr = Array.from(arguments);
        console.log(arr);
      }
  
      bar("fff", "fuck", 111);

自定义类的迭代

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

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

案例:创建一个classroom的类

  • 教室中有自己的位置、名称、当前教室的学生;
  • 这个教室可以进来新学生(push);
  • 创建的教室对象是可迭代对象;

自定义类的迭代实现

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

        // 实例方法
        [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("what", 19, 1.74, ["curry", "jack", "tom", "rick"]);
      const p2 = new Person("Rin", 19, 1.74, ["Kin", "jack", "tom", "Min"]);

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

迭代器的中断

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

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

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

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


        // 实例方法
        [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("what", 19, 1.74, ["curry", "jack", "tom", "rick"]);
      const p2 = new Person("Rin", 19, 1.74, ["Kin", "jack", "tom", "Min"]);

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

什么是生成器?

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

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

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

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

生成器函数执行

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

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

      /*
      生成器函数:
        1.function 后面会跟上一个符号: *
        2.代码的执行可以被yield控制
        3.生成器函数默认在执行时,返回一个生成器对象
            1.要想执行函数内部的代码,需要用生成器对象,调用next操作
            2.当遇到yield时,就会中断执行
    */
    // 1.定义类一个生成器函数
      function* foo() {
        console.log("111");
        console.log("222");
        console.log("333");
        yield;
        console.log("444");
        yield;
        console.log("555");
        console.log("666");
      }
      // 2.调用生成器函数,返回一个生成器对像
      const generator = foo();
      // 调用next方法
      generator.next();
      generator.next();
      generator.next();

生成器传递参数 – next函数

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

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

      // 1.定义类一个生成器函数
      function* foo(name1) {
        console.log("执行内部代码: 111", name1);
        console.log("执行内部代码: 222", name1);
        const name2 = yield "aaa";
        console.log("执行内部代码: 333", name2);
        console.log("执行内部代码: 444", name2);
        const name3 = yield "bbb";
        // return "bbb";
        console.log("执行内部代码: 555", name3);
        console.log("执行内部代码: 666", name3);
        yield "ccc";
        return undefined;
      }

      // 2.调用生成器函数,返回一个生成器对像
      const generator = foo("next1");
      // 调用next方法
      /*  console.log(generator.next()); // {done:false,value:'aaa'}
      console.log(generator.next()); // {done:false,value:'bbb'}
      console.log(generator.next()); // {done:false,value:'ccc'}
      console.log(generator.next()); // {done:true,value:undefined} */

      // 3.在中间位置直接return,结果
      /* console.log(generator.next()); // {done:false,value:'aaa'}
      console.log(generator.next()); // {done:true,value:'bbb'}
      console.log(generator.next()); // {done:true,value:'undefined}
      console.log(generator.next()); // {done:true,value:'undefined} */

      // 4.给函数每次执行的时候,传入参数
      console.log(generator.next());
      console.log(generator.next("next2"));
      console.log(generator.next("next3"));

生成器提前结束 – return函数

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

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

生成器抛出异常 – throw函数

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

  • 抛出异常后我们可以在生成器函数中捕获异常;
  • 但是在catch语句中不能继续yield新的值了,但是可以在catch语句外使用yield继续中断函数的执行;
      function* foo(name1) {
        console.log("执行内部代码: 111", name1);
        console.log("执行内部代码: 222", name1);
        const name2 = yield "aaa";
        console.log("执行内部代码: 333", name2);
        console.log("执行内部代码: 444", name2);
        const name3 = yield "bbb";
        // return "bbb";
        console.log("执行内部代码: 555", name3);
        console.log("执行内部代码: 666", name3);
        yield "ccc";
        console.log("最后一次执行");
        return undefined;
      }

      const generator = foo("next1");
      
      // 1.generator.return 提前结束函数
      console.log(generator.next());
      console.log(generator.return("next2"));
      console.log("================");
      console.log(generator.next("next3"));
      console.log(generator.next("next4"));

      // 2.generator.throw 向函数抛出一个异常
      console.log(generator.next());
      console.log(generator.throw(new Error("next2 throw error")));
      console.log("================");
      console.log(generator.next("next3"));
      console.log(generator.next("next4"));

生成器替代迭代器

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

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

  • 这个时候相当于是一种yield的语法糖,只不过会依次迭代这个可迭代对象,每次迭代其中的一个值;
      /*  const names = ["abc", "cba", "nba"];
        const nums = [12, 22, 33, 44, 55, 66];

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

        const numsIterator = createArrayIterator(nums);
        console.log(numsIterator.next());
        console.log(numsIterator.next());

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

      const rangeGen = createRangeGenerator(3, 10);
      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* 语法糖

      // 1.yield*替代之前的实现
      const names = ["abc", "cba", "nba"];
      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.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;
          // yield* Object.value(this);
          yield* Object.entries(this);
        }
      }

      const p = new Person("why", 19, 1.77, ["jack", "tom", "rick"]);
      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());

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

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

对生成器的操作

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

异步处理方案

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

案例需求:

  • 我们需要向服务器发送网络请求获取数据,一共需要发送三次请求;
  • 第二次的请求url依赖于第一次的结果;
  • 第三次的请求url依赖于第二次的结果;
  • 依次类推;

      // 封装请求的方法: url => promise(result)
      function requestData(url) {
        return new Promise((resolve, reject) => {
          setTimeout(() => {
            resolve(url);
          }, 2000);
        });
      }
      
      // 1.发送一次网络请求
      requestData("http://rin").then((res) => {
        console.log("res:", res);
      });

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

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

Generator方案

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

自动执行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 + "what");
        console.log("res2:", res2);
        const res3 = yield requestData(res2 + "jack");
        console.log("res3:", res3);
        const res4 = yield requestData(res2 + "curry");
        console.log("res4:", res4);
      }

      /* const generator = getData();
      generator.next().value.then((res1) => {
        generator.next(res1).value.then((res2) => {
          generator.next(res2).value.then((res3) => {
            generator.next(res3).value.then((res4) => {
              generator.next(res4);
            });
          });
        });
      }); */

      // 自动化执行生成器函数
      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);

Q.E.D.