迭代器
概念:迭代器是一种特殊对象,包含一个next()方法,每次调用都返回一个结果对象。结果对象有两个属性:一个是value,表示下一个将要返回的值;一个是done,布尔值,当没有更多可返回的数据时返回true。
function createIterator(items){
var i = 0 ;
return {
next : function (){
var done = (i>=items.length);
var value = !done?items[i++]:undefined;
return {
done,
value
}
}
}
}
var iterator = createIterator([1,2]) ;
console.log(iterator.next()); // {done: false, value: 1}
console.log(iterator.next()); // {done: false, value: 2}
//之后所有的调用都会返回相同的内容
console.log(iterator.next()); // {done: true, value: undefined}
上面只是原理,ES6中引入了生成器来简化创建迭代器的过程
生成器
概念:生成器是一种返回迭代器的函数,通过function关键字后的星号(*)来表示,函数中会用到关键字yield。星号可以紧挨着function关键字,也可以在中间添加一个空格:
// 生成器
function *createIterator(){
yield 1;
yield 2;
}
// 生成器的调用方式与普通函数相同,只不过返回的是一个迭代器
var iterator = createIterator() ;
console.log(iterator.next()); //{value: 1, done: false}
console.log(iterator.next()); //{value: 2, done: false}
//之后所有的调用都会返回相同的内容
console.log(iterator.next()); //{value: undefined, done: true}
在这个例子中,星号表示这是一个生成器;yield关键字指定调用迭代器的next()的返回值和返回顺序。
没当执行完一句yield语句后函数会自动停止执行。
function *createIterator(items){
for( let i=0; i<items.length; i++ ){
yield items[i]
}
}
let iterator = createIterator([1,2]) ;
console.log(iterator.next()); // {done: false, value: 1}
console.log(iterator.next()); // {done: false, value: 2}
//之后所有的调用都会返回相同的内容
console.log(iterator.next()); // {done: true, value: undefined}
yield关键字只可在生成器内部使用,嵌套的非生成器函数不算内部
- 生成器函数表达式
let createIterator = function *(items){
for( let i=0; i<items.length; i++ ){
yield items[i]
}
}
let iterator = createIterator([1,2]) ;
console.log(iterator.next()); // {done: false, value: 1}
console.log(iterator.next()); // {done: false, value: 2}
//之后所有的调用都会返回相同的内容
console.log(iterator.next()); // {done: true, value: undefined}
不能用箭头函数来创建生成器
-
生成器对象方法
由于生成器本身就是函数,因而可以将它们添加到对象中。
let obj = {
createIterator : function *(items){
for( let i=0; i<items.length; i++ ){
yield items[i]
}
}
}
let iterator = obj.createIterator([1,2]) ;
简写法:
let obj = {
*createIterator(items){
for( let i=0; i<items.length; i++ ){
yield items[i]
}
}
}
let iterator = obj.createIterator([1,2]) ;
可迭代对象和for-of循环
可迭代对象具有Symbol.iterator属性,通过制定的函数可以返回一个作用于附属对象的迭代器。
由于生成器默认会为Symbol.iterator属性赋值,因此所有通过生成器创建的迭代器都是可迭代对象。
for-of循环每执行一次都会调用可迭代对象的next()方法,并将迭代器返回的结果对象的value属性存储在一个变量中,循环将持续执行这一过程直到返回对象的done属性的值为true。
let values = [ 1, 2, 3 ]
for(let num of values){
console.log(num)
}
// 分别输出1、2、3
如果将for-of语句用于不可迭代对象、null或undefined将会导致程序抛出错误
-
访问默认迭代器
可以通过Symbol.iterator来访问对象默认的迭代器:
let values = [ 1, 2, 3 ];
let iterator = values[Symbol.iterator]();
console.log(iterator.next()); // { value : 1, done : false }
console.log(iterator.next()); // { value : 2, done : false }
console.log(iterator.next()); // { value : 3, done : false }
console.log(iterator.next()); // { value : undefined, done : true }
由于具有Symbol.iterator属性的对象都有默认的迭代器,因此可以用它来检测对象是否为可迭代对象:
function isIterable(object){
return typeof object[Symbol.iterator] === 'function';
}
console.log( isIterable([1,2,3]) ) // true
console.log( isIterable("Hello") ) // true
console.log( isIterable(new WeakMap()) ) // false
-
创建可迭代对象
默认情况下,开发者定义的对象都是不可迭代对象,但如果给Symbol.iterator属性添加一个生成器,则可以将其变为可迭代对象:
let collection = {
items : [],
*[Symbol.iterator](){
for(let item of this.items){
yield item
}
}
}
collection.items.push(1);
collection.items.push(2);
for (let x of collection){
console.log(x)
}
// 分别输出1、2
内建迭代器
-
集合对象迭代器
在ES6中有3种类型的集合对象:数组、Map集合和Set集合。
这3种对象都内建了以下三种迭代器:- entries() 返回一个迭代器,其值为多个键值对;
- values() 返回一个迭代器,其值为集合的值;
- keys() 返回一个迭代器,其值为集合中的所有键名。
entries()
每次调用next()方法时,entries()迭代器都会返回一个数组,数组中的两个元素分别表示集合中每个元素的键与值。
如果被遍历的对象是数组,则第一个元素是数字类型的索引;
如果是Set集合,则第一个元素与第二个元素都是值(Set集合中的值被同时作为键与值使用);
如果是Map集合,则第一个元素为键名,第二个元素为键值。
let colors = ['red'];
let numbers = new Set([1234]);
let maps = new Map([['key','value']]);
for (let entry of colors.entries()){
console.log(entry); // [0, "red"]
}
for (let entry of numbers.entries()){
console.log(entry); //[1234, 1234]
}
for (let entry of maps.entries()){
console.log(entry); //["key", "value"]
}
values()
调用values()迭代器时返回集合中所存在的值:
let colors = ['red'];
let numbers = new Set([1234]);
let maps = new Map([['key','value']]);
for (let entry of colors.values()){
console.log(entry); //"red"
}
for (let entry of numbers.values()){
console.log(entry); //1234
}
for (let entry of maps.values()){
console.log(entry); //value
}
keys()
调用keys()迭代器时返回集合中存在的每一个键:
let colors = ['red'];
let numbers = new Set([1234]);
let maps = new Map([['key','value']]);
for (let entry of colors.keys()){
console.log(entry); // 0
}
for (let entry of numbers.keys()){
console.log(entry); // 1234
}
for (let entry of maps.keys()){
console.log(entry); // ‘key’
}
不同集合类型的默认迭代器
每个集合类型都有一个默认迭代器,在for-of循环中,如果没有显式指定则使用默认的迭代器。
数组和Set集合的默认迭代器是values()方法
Map集合的默认迭代器是entries()方法
let colors = ['red'];
let numbers = new Set([1234]);
let maps = new Map([['key','value']]);
for (let entry of colors){
console.log(entry); // red
}
for (let entry of numbers){
console.log(entry); // 1234
}
for (let entry of maps){
console.log(entry); // ["key", "value"]
}
结构与for-of循环
如果要在for-of循环中使用结构语法,则可以利用Map集合默认构造函数的行为来简化编码过程:
let data = new Map();
data.set('name','欧阳不乖')
data.set('age',18)
for(let [key, value] of data){
console.log(`${key} = ${value}`)
}
// name = 欧阳不乖
// age = 18
- 字符串迭代器
let message = 'Hi 欧阳不乖';
for(let w of message){
console.log(w)
}
//H
// i
// (空)
//欧
//阳
//不
//乖
- NodeList迭代器
let divs = document.getElementByTags('div');
for (let div of divs){
console.log(div.id)
}
展开运算符与非数组可迭代对象
在数组字面量中可以多次使用展开运算符,将可迭代对象中的多个元素依次插入新数组中,替换原先展开运算符所在的位置:
let smallNumbers = [ 1, 2, 3 ];
let bigNumbers = [ 100, 101, 102 ];
let allNumbers = [0, ...smallNumbers, ...bigNumbers];
console.log(allNumbers); // [0, 1, 2, 3, 100, 101, 102]
高级迭代器功能
- 给迭代器传递参数
function *createIterator(){
let first = yield 1;
let second = yield first +2;
yield second +3;
}
let iterator = createIterator();
console.log( iterator.next() ); // {value: 1, done: false}
console.log( iterator.next(4) ); // {value: 6, done: false}
console.log( iterator.next(5) ); // {value: 8, done: false}
console.log( iterator.next() ); // {value: undefined, done: true}
这里有一个特例,第一次调用next()方法时无论传入什么样的参数都会被丢弃。
让我们从下面的代码分解步骤,来理解一下代码内部的具体细节:
执行步骤
-
在迭代器中抛出错误
通过throw()方法,当迭代器恢复执行时可令其抛出一个错误。
function *createIterator(){
let first = yield 1;
let second = yield first +2;
yield second +3;
}
let iterator = createIterator();
console.log( iterator.next() ); // {value: 1, done: false}
console.log( iterator.next(4) ); // {value: 6, done: false}
console.log( iterator.throw(new Error('BOOM')) ); //浏览器抛出错误:Uncaught Error: BOOM
console.log( iterator.next() ); //这里什么都不会再发生了
如下图所示,错误抛出则立即阻止了后续代码的执行,红色背景区域的代码永远都不会被执行了:
错误抛出位置示意图
-
生成器返回语句
在生成器中,return表示所有操作已经完成,属性done被设置为true;如果同时提供了相应的值,则属性value会被设置为这个值:
function *createIterator(){
yield 1;
return 'finished'; //之后的代码将不再执行
yield 2;
yield 3;
}
let iterator = createIterator();
console.log(iterator.next()); // {value: 1, done: false}
console.log(iterator.next()); // {value: "finished", done: true}
console.log(iterator.next()); // {value: undefined, done: true}
通过return语句指定的返回值,只会在返回对象中出现一次,在后续调用返回的对象中,value属性会被重置为undefined。
展开运算符与for-of循环语句会直接忽略通过return语句指定的任何返回值,只要done一变为true就立即停止读取其他的值。
-
委托生成器
在某些情况下,我们需要将两个迭代器合二为一,这时可以创建一个生成器,再给yield语句添加一个星号,就可以将生成数据的过程委托给其他迭代器。
当定义这些生成器时,只需将星号放置在关键字yield和生成器的函数名之间即可:
function *createNumberIterator(){
yield 1;
yield 2
}
function * createColorIterator(){
yield 'red';
yield 'blue';
}
function *createCombinedIterator(){
yield *createNumberIterator();
yield *createColorIterator();
yield true;
}
let iterator = createCombinedIterator();
console.log( iterator.next() ); // {value: 1, done: false}
console.log( iterator.next() ); // {value: 2, done: false}
console.log( iterator.next() ); // {value: "red", done: false}
console.log( iterator.next() ); // {value: "blue", done: false}
console.log( iterator.next() ); // {value: undefined, done: true}
yield *也可以直接应用于字符串,例如 yield *‘hello’
异步任务执行
- 简单任务执行器
function run(taskDef){
// 创建一个无使用限制的迭代器
let task = taskDef();
// 开始执行任务
let result = task.next();
// 循环调用next()的函数
function step(){
// 如果任务尚未完成,则继续执行
if(!result.done){
result = task.next();
}
}
// 开始迭代执行
step();
}
run(function *(){
console.log(1);
yield;
console.log(2)
})
// 1
// 2
-
向任务执行器传递数据
给任务执行器传递数据最简单的办法是,把yield返回值传入下一次next()方法的调用:
function run(taskDef){
// 创建一个无使用限制的迭代器
let task = taskDef();
// 开始执行任务
let result = task.next();
// 循环调用next()的函数
function step(){
// 如果任务尚未完成,则继续执行
if(!result.done){
result = task.next(result.value);
step();
}
}
// 开始执行迭代
step();
}
run(function *(){
let value = yield 1;
console.log(value); // 1
value = yield value+3;
console.log(value) // 4
})
- 异步任务执行器
网友评论