JavaScript中的迭代器(iterator)对象和生成器(Generator)函数

掘一
389 阅读10分钟

一、什么是迭代器

1.1. 认识迭代器

  • 迭代器也是一个具体的对象，这个对象需要符合迭代器协议（iterator protocol）；
    • 迭代器协议定义了产生一系列值（无论是有限还是无限个）的标准方式；
    • 那么在 JavaScript 中这个标准就是一个特定的 next 方法；

      next 方法：一个无参或者一个参数的函数，返回一个应当拥有以下两个属性的对象；

      1）done：

      如果迭代器可以产生序列中的下一个值，则为 false（这等同于没有指定 done 这个属性）；

      如果迭代器已将序列迭代完毕，则为 true。这种情况下，value 是可选的，如果它依然存 在，即为迭代结束之后的默认返回值；

      2）value：

      迭代器返回的任何 JavaScript 值。done 为 true 时可省略；

  • 迭代器是帮助我们对某个数据结构进行遍历的对象； 
    const iterator = {
  next: function() {
    return { done: true, value: 'yzh' };
  }
};

1.2. 访问数组

创建一个迭代器对象来访问数组

const names = ['ace', 'sabot', 'luffy'];

let index = 0;
// 创建一个迭代器对象来访问数组；
const nameIterator = {
  next: function() {
    if (index < names.length) {
      return { done: false, value: names[index++] };
    } else {
      return { done: true, value: undefined };
    }
  }
};

console.log(nameIterator.next()); //{ done: false, value: 'ace' }
console.log(nameIterator.next()); //{ done: false, value: 'sabot' }
console.log(nameIterator.next()); //{ done: false, value: 'luffy' }
console.log(nameIterator.next()); //{ done: true, value: undefined }
console.log(nameIterator.next()); //{ done: true, value: undefined }

1.3. 生成迭代器函数

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 names = ['ace', 'sabot', 'luffy'];
const nums = [12, 8, 9, 10];

const namesIterator = createArrayIterator(names);
console.log(namesIterator.next()); //{ done: false, value: 'ace' }
console.log(namesIterator.next()); //{ done: false, value: 'sabot' }
console.log(namesIterator.next()); //{ done: false, value: 'luffy' }
console.log(namesIterator.next()); //{ done: true, value: undefined }

console.log('---------------------------');

const numsIterator = createArrayIterator(nums);
console.log(numsIterator.next()); //{ done: false, value: 12 }
console.log(numsIterator.next()); //{ done: false, value: 8 }
console.log(numsIterator.next()); //{ done: false, value: 9 }
console.log(numsIterator.next()); //{ done: false, value: 10 }
console.log(numsIterator.next()); //{ done: true, value: undefined }

二、可迭代对象

2.1. 认识可迭代对象

  • 当一个对象实现了iterable protocol协议时，它就是一个可迭代对象；
  • 这个对象的要求是必须实现 @@iterator 方法，在代码中我们使用 Symbol.iterator 访问该属性； 
    const iterableObj = {
  names: ['ace', 'sabot', 'luffy'],
  [Symbol.iterator]: function() {
    let index = 0;

    return {
      next: () => {
        if (index < this.names.length) {
          return { done: false, value: this.names[index++] };
        } else {
          return { done: true, value: undefined };
        }
      }
    }
  }
};

// iterableObj对象就是一个可迭代对象
const namesIterable = iterableObj[Symbol.iterator]();
console.log(namesIterable.next());
console.log(namesIterable.next());
console.log(namesIterable.next());
console.log(namesIterable.next());

    // for...of可以遍历的东西必须是一个可迭代对象；
/**
 * 只要done为false，内部就会调next() 取value的值；
 */
for (const item of iterableObj) {
  console.log(item);
};

2.2. 内置可迭代对象

  • 我们平时创建的很多原生对象已经实现了可迭代协议，会生成一个迭代器对象的：
  • String、Array、Map、Set、arguments对象、NodeList集合； 
    // 数组本身是一个可迭代对象
const names = ["yzh", "ace", "luffy"];
// 获取可迭代的函数
console.log(names[Symbol.iterator]); //[Function: values]
// 调用可迭代函数，获取迭代器
const iterator1 = names[Symbol.iterator]();
console.log(iterator1.next());
console.log(iterator1.next());
console.log(iterator1.next());
console.log(iterator1.next());

// 函数中arguments也是一个可迭代对象
function foo(x, y, z) {
  console.log(arguments[Symbol.iterator]);

  for (const arg of arguments) {
    console.log(arg)
  }
};

foo(10, 20, 30);

// Map/Set
const set = new Set();
set.add(10);
set.add(100);
set.add(1000);

console.log(set[Symbol.iterator]); //[Function: values]

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

2.3. 可迭代对象的应用

  • JavaScript中语法：for ...of、展开语法（spread syntax）、yield*、解构赋值；
  • 创建一些对象时：new Map([Iterable])、new WeakMap([iterable])、new Set([iterable])、new WeakSet([iterable])；
  • 一些方法的调用：Promise.all(iterable)、Promise.race(iterable)、Array.from(iterable)； 
    const iterableObj = {
  names: ['ace', 'sabot', 'luffy'],
  [Symbol.iterator]: function() {
    let index = 0;

    return {
      next: () => {
        if (index < this.names.length) {
          return { done: false, value: this.names[index++] };
        } else {
          return { done: true, value: undefined };
        }
      }
    }
  }
};

// 1.
const names = ["aaa", "bbb", "ccc"];
const newNames = [...names, ...iterableObj];
console.log(newNames); //[ 'aaa', 'bbb', 'ccc', 'ace', 'sabot', 'luffy' ]

// 2.
const set1 = new Set(iterableObj);
const arr1 = Array.from(iterableObj);
console.log('-----', set1, arr1); //Set(3) { 'ace', 'sabot', 'luffy' } [ 'ace', 'sabot', 'luffy' ];

// 3.
Promise.all(iterableObj).then(res => {
  console.log(res)
});

三、自定义类的可迭代性

3.1. 创建一个类

  • 创建出来的对象都是可迭代带对象 
    class Classroom {
  constructor(address, name, students) {
    this.address = address;
    this.name = name;
    this.students = students;
  }

  entry(newStudent) {
    this.students.push(newStudent);
  }

  [Symbol.iterator]() {
    let index = 0;

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

const room = new Classroom('3号教学楼', '三年级三班', ['ace', 'sabo', 'luffy']);
room.entry('yzh');
console.log(room.students); //[ 'ace', 'sabo', 'luffy', 'yzh' ]


for (const student of room) {
  console.log(student);
};

3.2. 迭代器的中断

  • 迭代器会在某些情况下中断：
    • 比如遍历的过程中通过break、continue、return、throw中断了循环操作；
    • 比如在解构的时候，没有解构所有的值；
  • 这个时候我们想要监听中断的话，可以添加return方法： 
        [Symbol.iterator]() {
      let index = 0;

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

console.log('-----------------------');

for (const student of room) {
  console.log(student);
  if (student === 'sabo') break;
}

四、什么是生成器

生成器是ES6中新增的一种函数控制、使用的方案，它可以让我们更加灵活的控制函数什么时候继续执行、暂停执行等。平时我们会编写很多的函数，这些函数终止的条件通常是返回值或者发生了异常；

4.1. 认识生成器函数

  • 生成器函数也是一个函数，但是和普通的函数有一些区别：
    • 首先，生成器函数需要在function的后面加一个符号 * ；
    • 其次，生成器函数可以通过yield关键字来控制函数的执行流程；
    • 最后，生成器函数的返回值是一个Generator（生成器）；
  • 生成器事实上是一种特殊的迭代器； 
    function* foo() {
  console.log('函数开始执行');

  const value = 100;
  console.log('第一段代码执行：', value);
  yield

  const value2 = 200;
  console.log('第二段代码执行：', value2);
  yield

  const value3 = 300;
  console.log('第三段代码执行：', value3);
  yield

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

// 调用生成器函数时，foo的执行体压根没有执行，只是返回了一个生成器对象；
const generator = foo();

generator.next();  //函数开始执行  第一段代码执行： 100

generator.next();  //第二段代码执行： 200

generator.next(); //第三段代码执行： 300

generator.next();  //函数结束执行

4.2. 生成器函数的执行 - 返回值

  • 当遇到 yield 时候只暂停函数的执行，当遇到 return 时生成器就停止执行了；
  • 我们之前学习迭代器时，知道迭代器的next是会有返回值的；
  • 但是我们很多时候不希望next返回的是一个undefined，这个时候我们可以通过yield来返回结果； 
    function* foo() {
  console.log('函数开始执行');

  const value = 100;
  console.log('第一段代码执行：', value);
  yield value

  const value2 = 200;
  console.log('第二段代码执行：', value2);
  yield value2

  const value3 = 300;
  console.log('第三段代码执行：', value3);
  yield value3

  console.log('函数结束执行');
  return '123123dsadsa';
};

// 调用生成器函数时，会给我们返回一个生成器对象；
const generator = foo();

console.log('-第一个返回值：', generator.next());  //函数开始执行  第一段代码执行： 100 -第一个返回值： { value: 100, done: false }

console.log('-第二个返回值：', generator.next());   //第二段代码执行： 200 -第二个返回值： { value: 200, done: false }

console.log('-第三个返回值：', generator.next());  //第三段代码执行： 300 -第三个返回值： { value: 300, done: false }

console.log('-最后结束返回值：', generator.next());   //函数结束执行 -最后结束返回值： { value: '123123dsadsa', done: true }

4.3. 生成器传递参数 - next函数

  • 函数既然可以暂停来分段执行，那么函数应该是可以传递参数的，我们可以给每个分段来传递参数；
  • 在调用next函数的时候，可以给它传递参数，那么这个参数会作为上一个yield语句的返回值； 
    function* foo(n) {
  console.log('函数开始执行');

  const value = 100 * n;
  console.log('第一段代码执行：', value);
  const num1 = yield value;

  const value2 = 200 + num1;
  console.log('第二段代码执行：', value2);
  const num2 = yield value2

  const value3 = 300 + num2;
  console.log('第三段代码执行：', value3);
  yield value3

  console.log('函数结束执行');
  return '123123dsadsa';
};

// 调用生成器函数时，会给我们返回一个生成器对象；
const generator = foo(5);

console.log('第一个返回值：', generator.next()); //函数开始执行 第一段代码执行： 500 第一个返回值： { value: 500, done: false }

// 参数在上一个yield的返回值（这里指的是：num1）
console.log('第二个返回值：', generator.next(10)); //第二段代码执行： 210 第二个返回值： { value: 210, done: false }

console.log('第三个返回值：', generator.next(20)); //第三段代码执行： 320 第三个返回值： { value: 320, done: false }

console.log('最后结束返回值：', generator.next()); //函数结束执行 最后结束返回值： { value: '123123dsadsa', done: true }

4.4. 生成器提前结束 - return函数

  • 还有一个可以给生成器函数传递参数的方法是通过return函数；
  • return传值后这个生成器函数就会结束，之后调用next不会继续生成值了； 
    function* foo(n) {
  console.log('函数开始执行');

  const value = 100 * n;
  console.log('第一段代码执行：', value);
  const num1 = yield value;

  // 调用return 方法相当于
  // return num1

  const value2 = 200 + num1;
  console.log('第二段代码执行：', value2);
  const num2 = yield value2

  const value3 = 300 + num2;
  console.log('第三段代码执行：', value3);
  yield value3

  console.log('函数结束执行');
  return '123123dsadsa';
};

// 调用生成器函数时，会给我们返回一个生成器对象；
const generator = foo(5);

console.log('第一个返回值：', generator.next()); //第一段代码执行： 500  第一个返回值： { value: 500, done: false }

// 参数在上一个yield的返回值
console.log('第二个返回值：', generator.return(10)); //第二个返回值： { value: 10, done: true }

4.5. 生成器抛出异常 - throw函数

  • 除了给生成器函数内部传递参数之外，也可以给生成器函数内部抛出异常；
  • 抛出异常后我们可以在生成器函数中捕获异常； 
    function* foo() {
  console.log('函数开始执行');

  const value = 100;
  console.log('第一段代码执行：', value);
  // 捕获异常
  try {
    yield value;
  } catch (err) {
    console.log('捕获异常到异常：', err);

    // yield 'dsadsadsal12'
    //{ value: 'dsadsadsal12', done: false }
  }

  const value2 = 200;
  console.log('第二段代码执行：', value2);
  yield value2;

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

// 调用生成器函数时，会给我们返回一个生成器对象；
const generator = foo();

console.log(generator.next());

// console.log(generator.next());
console.log(generator.throw('error message'));

五、生成器替代迭代器

  • 生成器是一种特殊的迭代器，在某些情况下我们可以使用生成器来替代迭代器；
  • 还可以使用yield* 来生产一个可迭代对象，这个时候相当于是一种yield的语法糖，只不过会依次迭代这个可迭代对象，每次迭代其中的一个值；

5.1. 生成器来替代迭代器

function* createArrayIterator(arr) {
  //1.
  // yield arr[0];
  // yield arr[1];
  // yield arr[2];

  //2.
  // for (const item of arr) {
  //   yield item;
  // }
  
  //3.
  yield* arr;
};

const names = ['ace', 'sabot', 'luffy'];
const namesIterator = createArrayIterator(names);
console.log(namesIterator.next()); //{ value: 'ace', done: false }
console.log(namesIterator.next()); //{ value: 'sabo', done: false }
console.log(namesIterator.next()); //{ value: 'luffy', done: false }
console.log(namesIterator.next()); //{ value: undefined, done: true }

5.2. 创建一个函数, 这个函数可以迭代一个范围内的数字

function* createRangeIterator(start, end) {
  let index = start;

  while (index < end) {
    yield index++;
  }
};
const numsIterator = createRangeIterator(10, 20);
console.log(numsIterator.next()); //{ value: 10, done: false }
console.log(numsIterator.next()); //{ value: 11, done: false }
console.log(numsIterator.next()); //{ value: 12, done: false }
console.log(numsIterator.next()); //{ value: 13, done: false }
console.log(numsIterator.next()); //{ value: 14, done: false }

5.3. 自定义类的迭代

class Classmovie {
  constructor(movies) {
    this.movies = movies;
  }

  // [Symbol.iterator] = function*() {
  //   yield* this.movies;
  // }
  *[Symbol.iterator]() {
    yield* this.movies;
  }
}

const classmovie = new Classmovie(['《绝命毒师》', '《风骚律师》', '《纸牌屋》', '《POI疑犯追踪》']);

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

5.4. 对生成器的操作

  • 既然生成器是一个迭代器，那么我们可以对其进行如下的操作： 
    function* createArrayIterator(arr) {
  yield* arr;
};

const names = ['ace', 'sabo', 'luffy'];

const namesIterator = createArrayIterator(names);
for (const item of namesIterator) {
  console.log('for', 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);
});

六、异步处理方案

  • 需求：
    • 我们需要向服务器发送网络请求获取数据，一共需要发送三次请求（url: yzh -> res: yzh）；
    • 第二次的请求url依赖于第一次的结果（url: res + "aaa" -> res: yzhaaa）；
    • 第三次的请求url依赖于第二次的结果（url: res + "bbb" => res: yzhaaabbb）；
  • 前面： 
    // request.js
function requestData(url) {
  // 异步请求的代码会被放入到executor中
  return new Promise((resolve, reject) => {
    // 模拟网络请求
    setTimeout(() => {
      // 拿到请求的结果
      resolve(url)
    }, 2000);
  })
};

6.1. 多次回调（回调地狱）

requestData("yzh").then(res => {
  requestData(res + "aaa").then(res => {
    requestData(res + "bbb").then(res => {
      console.log(res) //yzhaaabbb
    })
  })
})

6.2. Promise中then的返回值来解决

requestData("yzh").then(res => {
  return requestData(res + "aaa")
}).then(res => {
  return requestData(res + "bbb")
}).then(res => {
  console.log(res) //yzhaaabbb
})

6.3. Promise + generator实现

  • 前面： 
    function* getData() {
  const res1 = yield requestData("yzh")
  const res2 = yield requestData(res1 + "aaa")
  const res3 = yield requestData(res2 + "bbb")
  const res4 = yield requestData(res3 + "ccc")
  console.log(res4)
}
  • 1）手动执行生成函数 
    const generator = getData()
generator.next().value.then(res => {
  generator.next(res).value.then(res => {
    generator.next(res).value.then(res => {
      generator.next(res).value.then(res => {
        console.log(res);
      })
    })
  })
})
  • 2）自己封装了一个自动执行的函数 
    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()
};

execGenerator(getData);

6.4. async/await

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

getData()

s·all good, man

avatar
文章
阅读
粉丝