Home JavaScript

# 什么是迭代器？

  • 迭代器（iterator），是确使用户可在容器对象（container，例如链表或数组）上遍访的对象，使用该接口无需关心对象的内部实现细节。
    • 其行为像数据库中的光标，迭代器最早出现在 1974 年设计的 CLU 编程语言中；
    • 在各种编程语言的实现中，迭代器的实现方式各不相同，但是基本都有迭代器，比如 Java、Python 等；
  • 从迭代器的定义我们可以看出来，迭代器是帮助我们对某个数据结构进行遍历的对象。
  • 在 JavaScript 中，迭代器也是一个具体的对象，这个对象需要符合迭代器协议（iterator protocol）：
    • 迭代器协议定义了产生一系列值（无论是有限还是无限个）的标准方式；
    • 那么在 js 中这个标准就是一个特定的 next 方法；
  • next 方法有如下的要求：
    • 一个无参数或者一个参数的函数，返回一个应当拥有以下两个属性的对象：
    • done（boolean）
      • 如果迭代器可以产生序列中的下一个值，则为 false。（这等价于没有指定 done 这个属性。）
      • 如果迭代器已将序列迭代完毕，则为 true。这种情况下，value 是可选的，如果它依然存在，即为迭代结束之后的默认返回值。
    • value
      • 迭代器返回的任何 JavaScript 值。done 为 true 时可省略

# 编写迭代器

const iterator = {
  next: function() {
    return { done: true, value: 123 }
  }
}

# 创建迭代器对象访问数组

const friends = ['Lain', 'Saber', 'Neko']
let i = 0
const friendsIrerator = {
  next: function () {
    if (i < friends.length) return { value: friends[i++], done: false }
    return { value: undefined, done: true }
  }
}
console.log(friendsIrerator.next()) // { value: 'Lain', done: false }
console.log(friendsIrerator.next()) // { value: 'Saber', done: false }
console.log(friendsIrerator.next()) // { value: 'Neko', done: false }
console.log(friendsIrerator.next()) // { value: undefined, done: true }
console.log(friendsIrerator.next()) // { value: undefined, done: true }
# 封装数组可迭代函数


// 封装迭代器
function createArrayIterator(arr) {
  let i = 0
  return {
    next: function () {
      if (i < arr.length) return { value: arr[i++], done: false }
      return { value: undefined, done: true }
    }
  }
}
const friends = ['Lain', 'Saber', 'Neko']
const friendsIrerator = createArrayIterator(friends)
console.log(friendsIrerator.next()) // {value: 'Lain', done: false}
console.log(friendsIrerator.next()) // {value: 'Saber', done: false}
console.log(friendsIrerator.next()) // {value: 'Neko', done: false}
console.log(friendsIrerator.next()) // {value: undefined, done: true}
console.log(friendsIrerator.next()) // {value: undefined, done: true}
const fruits = ['cherry', 'peach', 'guava']
const fruitsIterator = createArrayIterator(fruits)
console.log(fruitsIterator.next()) // {value: 'cherry', done: false}
console.log(fruitsIterator.next()) // {value: 'peach', done: false}
console.log(fruitsIterator.next()) // {value: 'guava', done: false}
console.log(fruitsIterator.next()) // {value: undefined, done: true}
console.log(fruitsIterator.next()) // {value: undefined, done: true}
# 创建一个无限的迭代器


// 封装一个无限的迭代器
function createNumberIterator(i = 0) {
  return { next: () => ({ value: i++, done: false }) }
}
const numberIterator = createNumberIterator()
console.log(numberIterator.next()) // {value: 0, done: false}
console.log(numberIterator.next()) // {value: 1, done: false}
console.log(numberIterator.next()) // {value: 2, done: false}
console.log(numberIterator.next()) // {value: 3, done: false}
console.log(numberIterator.next()) // {value: 4, done: false}
console.log(numberIterator.next()) // {value: 5, done: false}
// ......
# 可迭代对象


    

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

      

    • 我们获取一个数组的时候，需要自己创建一个 index 变量，再创建一个所谓的迭代器对象；
      • 

    • 事实上我们可以对上面的代码进行进一步的封装，让其变成一个可迭代对象；
      • 

    

    • 

  • 什么又是可迭代对象呢？

      

    • 它和迭代器是不同的概念；
      • 

    • 当一个对象实现了 iterable protocol 协议时，它就是一个可迭代对象；
      • 

    • 这个对象的要求是必须实现 @@iterator 方法，在代码中我们使用 Symbol.iterator 访问该属性；
      • 

    

    • 

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

      

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

    

    • 



// 创建一个迭代器对象来访问数组
const iterableObj = {
  friends: ['Lain', 'Sa0ber', 'Neko'],
  [Symbol.iterator]: function (i = 0) {
    return {
      next: () => {
        if (i < this.friends.length) return { value: this.friends[i++], done: false, }
        return { value: undefined, done: true}
      }
    }
  }
}
//iterableObj 对象就是一个可迭代对象
const iterator = iterableObj[Symbol.iterator]()
console.log(iterator.next()) // {value: 'Lain', done: false}
console.log(iterator.next()) // {value: 'Saber', done: false}
console.log(iterator.next()) // {value: 'Neko', done: false}
console.log(iterator.next()) // {value: undefined, done: true}
# 内置创建可迭代对象


# 数组对象本身就是可迭代对象


const friends = ['Lain', 'Saber', 'Neko']
const iterator = friends[Symbol.iterator]()
console.log(iterator.next()) // { value: 'Lain', done: false }
console.log(iterator.next()) // { value: 'Saber', done: false }
console.log(iterator.next()) // { value: 'Neko', done: false }
console.log(iterator.next()) // { value: undefined, done: true }
# set 对象是可迭代对象


const set = new Set()
set.add('Saber')
set.add('Lain')
set.add('Neko')
const setIterator = set[Symbol.iterator]()
console.log(setIterator.next()) // {value: 'Saber', done: false}
console.log(setIterator.next()) // {value: 'Lain', done: false}
console.log(setIterator.next()) // {value: 'Neko', done: false}
# arguments 也是可迭代对象


function foo(x, y, z) {
  for (const arg of arguments){
    console.log(arguments[Symbol.iterator]()) // Array Iterator {}
    console.log(arg) // 10 20 30
  }
} 
foo(10, 20, 30)
# 字符串也是可迭代对象


const str = 'Saber'
console.log(str[Symbol.iterator]) // ƒ [Symbol.iterator]() { [native code] }
for (const k of str) {
  console.log(k) // s a b e r
}
    

  • 我们平时创建的很多原生对象已经实现了可迭代协议，会生成一个迭代器对象的： String、Array、Map、Set、arguments对象、NodeList集合  
    • 



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


    

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



# 自定义类的可迭代性


class Charecters {
  constructor(name, age, frineds) {
    this.name = name
    this.age = age
    this.frineds = frineds
  }
  entery(newCharecter) {
    this.frineds.push(newCharecter)
  }
  [Symbol.iterator](i = 0) {
    return {
      next: () => {
        if (i < this.frineds.length) {
          return { value: this.frineds[i++], done: false }
        }
        return { value: undefined, done: true }
      }
    }
  }
}
const lain = new Charecters('lain', 16, ['saber'])
lain.entery('樱岛麻衣')
for (const item of lain){
  console.log(item) //saber  樱岛麻衣
}
# 迭代器的中断


    

  • 

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

      

    • 比如遍历的过程中通过 break、continue、return、throw 中断了循环操作；
      • 

    • 比如在解构的时候，没有解构所有的值；
      • 

    

    • 

  • 

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

    • 



class Charecters {
  constructor(name, age, frineds) {
    this.name = name
    this.age = age
    this.frineds = frineds
  }
  entery(newCharecter) {
    this.frineds.push(newCharecter)
  }
  [Symbol.iterator](i = 0) {
    return {
      next: () => {
        if (i < this.frineds.length) {
          return { value: this.frineds[i++], done: false }
        }
        return { value: undefined, done: true }
      },
      return: () => {
          console.log( `迭代器提前终止了~`)
          return {value: undefined, done: true}
      }
    }
  }
}
const lain = new Charecters('lain', 16, ['saber'])
lain.entery('樱岛麻衣')
for (const item of lain){
  console.log(item) // saber  
  if(item === 'saber') return // 迭代器提前终止了～
}

      

          
      

  


   


    

  
    
      
    
    Update on
    
  
  
      
        
      
      Views
      
      times
  



      


  
  
Give me a cup of [coffee]~(￣▽￣)~*

  

      
      

        Nico Niconi WeChat Pay
        
WeChat Pay

      

      
      

        Nico Niconi Alipay
        
Alipay