深入理解 JavaScript Iterator 接口与 Generator 生成器用法

Iterator 概念

Iterator 是一种统一的接口机制，旨在为各类不同的数据结构提供一致的访问方式。

定义 Iterator 即创建一个包含 next() 方法的对象。每次调用 next() 方法，都会返回一个结果对象，该对象包含两个属性：value 表示当前遍历的值，done 表示遍历是否已经结束。

function makeIterator(Array){
    let index = 0;
    return {
        next: function(){
            return (
                Array.length > index ?
                {value: Array[index++]}:
                {done: true}
            )
        }
    }
}
let iterator = makeIterator(['1','2'])
console.log(iterator.next()); // {value: '1'}
console.log(iterator.next()); // {value: '2'}
console.log(iterator.next()); // {done: true}

Iterator 的主要作用包括：

为各种数据结构提供统一且简便的访问接口；
使数据结构的成员能够按照特定的顺序进行排列和访问；
供 for...of 循环进行消费和遍历。

默认 Iterator 接口

ES6 引入了 for...of 语句来遍历迭代器对象。如果我们尝试直接使用上述手动创建的迭代器配合 for...of 语句进行遍历，将会遇到如下问题：

let iterator = makeIterator(['1','2'])
for (let value of iterator) {
    console.log(value);
} // iterator is not iterable

结果报错提示 iterator is not iterable。这是因为 ES6 规定，默认的 Iterator 接口必须部署在数据结构的 Symbol.iterator 属性中。只有当一个数据结构拥有 Symbol.iterator 属性时，它才被视为可遍历（iterable）。

我们可以对自定义的 makeIterator 函数进行如下改造，以符合 ES6 规范：

const MakeIterator = (Array) => ({
    [Symbol.iterator](){
        let index = 0;
        return {
            next(){
                let length = Array.length;
                if(index < length){
                    return {value: Array[index++]}
                }else{
                    return {done: true}
                }
            }
        }
    }
})
for(let value of MakeIterator([1,2])){
    console.log(value)
}
// 1
// 2

Iterator 的 return() 方法

我们为 MakeIterator 对象添加 return 方法。当 for...of 循环提前退出时（通常是因为发生错误或者执行了 break 语句），JavaScript 引擎会自动调用 return() 方法，从而终止遍历过程。

利用这一特性，如果一个对象在遍历完成前需要执行清理或释放资源的操作（例如文件读取失败时关闭文件句柄），我们可以部署 return() 方法来处理这些逻辑。

const MakeIterator = (Array) => ({
    [Symbol.iterator](){
        let index = 0;
        return {
            next(){
                let length = Array.length;
                if(index < length){
                    return {value: Array[index++]}
                }else{
                    return {done: true}
                }
            },
            return(){
                return {done: true}
            }
        }
    }
})
for(let value of MakeIterator([1, 2, 3])){
    console.log(value) // 1
    // 方式1
    break;
    // 方式2
    // throw new Error('error');
}

原生具备 Iterator 接口的数据结构

数组
Set
Map
类数组对象，例如 arguments 对象、DOM NodeList 对象以及 typedArray 对象

// arguments 对象
function sum(){
    for(let value of arguments){
        console.log(value)
    }
}
sum(1,2)
// 1
// 2
// typedArray 对象
let typeArry = new Int8Array(2);
typeArry[0] = 1;
typeArry[1] = 2;
for(let value of typeArry){
    console.log(value) 
}
// 1
// 2

Generator 对象

function* gen(){
    yield 1;
    yield 2;
}
for(let value of gen()){
    console.log(value)
}

String

Q: 为什么 Object 不具有原生 Iterator ？

A: 对象（Object）之所以没有默认部署 Iterator 接口，主要是因为对象的属性遍历顺序是不确定的，无法保证哪个属性先遍历、哪个后遍历。

从本质上讲，遍历器是一种线性处理机制。对于任何非线性的数据结构，如果要部署遍历器接口，就等于强制实施一种线性转换。

然而，严格来讲，为对象部署遍历器接口并非必需，因为此时对象实质上被用作 Map 结构，ES5 未提供 Map 结构，而 ES6 原生支持。

调用 Iterator 接口的场合

解构赋值

let set = new Set().add('a').add('b').add('c');
let [x,y] = set; // x='a'; y='b'

扩展运算符

var str = 'hello';
[...str] //  ['h','e','l','l','o']

既然扩展运算符也是调用 Iterator 接口，那么为什么 Object 没有部署 Iterator 接口，却也能使用 ... 运算符呢？

原因在于扩展运算符的应用场景分为两种不同的情况：

一种是用在函数参数或数组展开的场合，这种情况下要求对象必须是可迭代的（iterable）；
另一种是用于对象展开，即 {…obj} 的形式，这种情况下要求对象必须是可枚举的（enumerable）。

let obj1 = {
    name: 'qianxun'
} 
let obj2 = {
    age: 3
}
// 数组对象是可枚举的
let obj = {...obj1, ...obj2}
console.log(obj) //{name: 'qianxun', age: 3}
// 普通对象默认是不可迭代的
let obj = [...obj1, ...obj2]
console.log(obj) // object is not iterable

模拟实现 for of

function forOf(obj, cb){
    let iteratorValue = obj[Symbol.iterator]();
    let result = iteratorValue.next()
    while(!result.done){
        cb(result.value)
        result = iteratorValue.next()
    }
}
forOf([1,2,3], (value)=>{
    console.log(value)
})
// 1
// 2
// 3

Generator

认识 Generator

概念上

Generator 函数是 ES6 提供的一种异步编程解决方案。从概念上看，Generator 函数是一个状态机，它封装了多个内部状态；

同时，Generator 函数还是一个遍历器对象生成函数，执行该函数后会返回一个遍历器对象。

形式上

1. function 关键字与函数名之间必须有一个星号（*）；

2. 函数体内部使用 yield 表达式来定义不同的内部状态。

function* simpleGenerator(){
    yield 1;
    yield 2;
}
simpleGenerator()

如上我们创建了一个简单的 Generator，接下来我们带着两个问题进行探究：

Generator 函数运行后会发生什么？
函数中的 yield 表达式有什么作用？

function* simpleGenerator(){
    console.log('hello world');
    yield 1;
    yield 2;
}
let generator = simpleGenerator(); // simpleGenerator {&lt;suspended}}
console.log(generator.next())
// hello world
// {value: 1, done: false}
console.log(generator.next())
// {value: 2, done: false}

Generator 生成器函数运行后返回一个生成器对象，而普通函数会直接执行函数内部的代码。每次调用生成器对象的 next 方法，会执行函数代码直到遇到下一个 yield 关键字并停止执行，同时返回一个 {value: Value, done: Boolean} 的对象。

next 方法的参数

yield 表达式本身没有返回值，或者说总是返回 undefined。next 方法可以带一个参数，该参数会被当作上一个 yield 表达式的返回值。通过 next 方法的参数，可以在 Generator 函数运行的不同阶段，从外部向内部注入不同的值，从而调整函数行为。需要注意的是，由于 next 方法的参数表示上一个 yield 表达式的返回值，所以在第一次使用 next 方法时，传递参数是无效的。

function sum(x){
    return function(y){
        return x + y;
    }
}
console.log(sum(1)(2))
// 利用next传参改写
function* sum(x){
    let y = yield x;
    while(true){
       y = yield x + y;
    }
}
let gen = sum(2)
console.log(gen.next()) // 2
console.log(gen.next(1)) // 3
console.log(gen.next(2))  // 4

yield 表达式

yield 表达式的作用：定义内部状态和暂停执行。yield 表达式与 return 语句的区别如下：

yield 表达式表示函数暂停执行，下一次调用 next 时再从该位置继续向后执行，而 return 语句不具备位置记忆的功能；
一个函数里，只能执行一个 return 语句，但是可以执行多个 yield 表达式；
任何函数都可以使用 return 语句，yield 表达式只能用在 Generator 函数里面，用在其他地方都会报错；
yield 表达式如果参与运算放在圆括号里面；用作函数参数或放在赋值表达式的右边，可以不加括号。

function *gen () {
  console.log('hello' + yield) ×
  console.log('hello' + (yield)) √
  console.log('hello' + yield 1) ×
  console.log('hello' + (yield 1)) √
  foo(yield 1)  √
  const param = yield 2  √
}

基于 Generator 生成器函数中可以支持多个 yield，我们可以实现一个函数有多个返回值的场景：

function* gen(num1, num2){
    yield num1 + num2;
    yield num1 - num2;
}
let res = gen(2, 1);
console.log(res.next()) // {value: 3, done: false}
console.log(res.next()) // {value: 1, done: false}

Generator 与 Iterator 之间的关系

由于 Generator 函数就是遍历器生成函数，因此可以把 Generator 赋值给对象的 Symbol.iterator 属性，从而使得该对象具有 Iterator 接口。这种方式实现 Iterator 的代码更加简洁。

let obj = {
    name: 'qianxun',
    age: 3,
    [Symbol.iterator]: function(){
        let that = this;
        let keys = Object.keys(that)
        let index = 0;
        return {
            next: function(){
                return index < keys.length ?
                {value: that[keys[index++]], done: false}:
                {value: undefined, done: true}
            }
        }
    }
}
for(let value of obj){
    console.log(value)
}

Generator:

let obj = {
    name: 'qianxun',
    age: 3,
    [Symbol.iterator]: function* (){
        let keys = Object.keys(this)
        for(let i=0; i< keys.length; i++){
            yield this[keys[i]];
        }
    }
}
for(let value of obj){
    console.log(value)
}

Generator.prototype.return()

return()方法，可以返回给定的值，并且终结遍历 Generator 函数。

function* gen() {
  yield 1;
  yield 2;
  yield 3;
}
var g = gen();
g.next()        // { value: 1, done: false }
// 如果 return() 方法调用时，不提供参数，则返回值的 value 属性为 undefined
g.return('foo') // { value: "foo", done: true }
g.next()        // { value: undefined, done: true }

如果 Generator 函数内部有 try...finally 代码块，且正在执行 try 代码块，那么 return() 方法会导致立刻进入 finally 代码块，执行完以后，整个函数才会结束。

function* numbers () {
  yield 1;
  try {
    yield 2;
    yield 3;
  } finally {
    yield 4;
    yield 5;
  }
  yield 6;
}
var g = numbers();
g.next() // { value: 1, done: false }
g.next() // { value: 2, done: false }
g.return(7) // { value: 4, done: false }
g.next() // { value: 5, done: false }
g.next() // { value: 7, done: true }

yield* 表达式

如果想在 Generator 函数内部，调用另一个 Generator 函数。我们需要在前者的函数体内部，自己手动完成遍历，如果函数调用多层嵌套会导致写法繁琐不易阅读，ES6 提供了 yield* 表达式作为解决方法。

委托给其他生成器

function* g1() {
  yield 2;
  yield 3;
}
function* g2() {
  yield 1;
  yield* g1();
  yield 4;
}
const iterator = g2();
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: 4, done: false }
console.log(iterator.next()); // { value: undefined, done: true }

委托给其他可迭代对象

function* gen(){
    yield* [1,2,3]
}
console.log(gen().next()) // {value: 1, done: false}

Generator 函数的 this

Generator 函数返回一个遍历器，ES6 规定这个遍历器是 Generator 函数的实例，继承了 Generator.prototype 对象上的方法，但无法获取 this 上的属性，因为这时 this 是全局对象，而不是实例对象。

function* gen(){
    this.a = 1
}
gen.prototype.say = function(){
    console.log('hi')
}
let obj = gen()
console.log(obj instanceof gen) // true
obj.say() // hi
obj.next()
console.log(obj.a) //undefined

如果想像构造函数一样访问实例属性，可以修改 this 绑定到 Generator.prototype 上。

function* gen(){
    this.a = 1
}
gen.prototype.say = function(){
    console.log('hi')
}   
let obj = gen.call(gen.prototype)
console.log(obj instanceof gen) // true
obj.say() // hi
obj.next()
console.log(obj.a) //1

Generator 实现一个状态机

function* StateMachine(state){
    let transition;
    while(true){
        if(transition === "INCREMENT"){
            state++;
        }else if(transition === "DECREMENT"){
            state--;
        }
        transition = yield state;
    }
}
const iterator = StateMachine(0);
console.log(iterator.next()); // 0
console.log(iterator.next('INCREMENT')); // 1
console.log(iterator.next('DECREMENT')); // 0

以上就是JavaScript前端迭代器Iterator与生成器Generator讲解的详细内容，更多关于JavaScrip前端迭代器生成器的资料请关注本站其它相关文章！

JavaScript 前端迭代器 Iterator 与生成器 Generator 详解