学习了coderwhy的JavaScript高级语法视频课的笔记

如有错误或者不合适的地方，敬请见谅，欢迎指出和拓展，谢谢各位了

一、迭代器（iterator）

1、什么是迭代器？

• 迭代器（iterator），是确使用户可在容器对象（container，例如链表或数组）上遍访的对象，使用该接口无需关心对象的内部实现细节。
  • 其行为像数据库中的光标，迭代器最早出现在1974年设计的CLU编程语言中；
  • 在各种编程语言的实现中，迭代器的实现方式各不相同，但是基本都有迭代器，比如Java、Python等；
• 从迭代器的定义我们可以看出来，迭代器是帮助我们对某个数据结构进行遍历的对象。
• 在JavaScript中，迭代器也是一个具体的对象，这个对象需要符合迭代器协议（iterator protocol）：
  • 迭代器协议定义了产生一系列值（无论是有限还是无限个）的标准方式；
  • 那么在js中这个标准就是一个特定的next方法；

next方法有如下的要求：

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

// 1、编写一个迭代器
const iterator = {
  next: function () {
    return { done: true, value: 123 }
  }
}

// 2、创建一个迭代器访问数组
const arr = ['a', 'b', 'c']

let index = 0

const arrIterator = {
  next: function () {
    if (index < arr.length) {
      return { done: false, value: arr[index++] }
    } else {
      return { done: true, value: undefined }
    }
  }
}

console.log(arrIterator.next())
console.log(arrIterator.next())
console.log(arrIterator.next())
console.log(arrIterator.next())
/* { done: false, value: 'a' }
{ done: false, value: 'b' }
{ done: false, value: 'c' }
{ done: true, value: undefined } */

// 3、生成迭代器函数
function iterator2(arr2) {
  let index = 0
  return {
    next: function () {
      if (index < arr2.length) {
        return { done: false, value: arr2[index++] }
      } else {
        return { done: true, value: undefined }
      }
    }
  }
}

const arr2 = ['A', 'B', 'C']
const arr3 = [1, 2, 3]

const arr2Iterator = iterator2(arr2)
console.log(arr2Iterator.next())
console.log(arr2Iterator.next())
console.log(arr2Iterator.next())
console.log(arr2Iterator.next())
/* { done: false, value: 'A' }
{ done: false, value: 'B' }
{ done: false, value: 'C' }
{ done: true, value: undefined } */

const arr3Iterator = iterator2(arr3)
console.log(arr3Iterator.next())
console.log(arr3Iterator.next())
console.log(arr3Iterator.next())
console.log(arr3Iterator.next())
/* { done: false, value: 1 }
{ done: false, value: 2 }
{ done: false, value: 3 }
{ done: true, value: undefined } */

2、什么是可迭代对象？

• 上面的代码整体来说看起来是有点奇怪的：
  • 我们获取一个数组的时候，需要自己创建一个index变量，再创建一个所谓的迭代器对象；
  • 事实上我们可以对上面的代码进行进一步的封装，让其变成一个可迭代对象。
• 什么又是可迭代对象呢？
  • 它和迭代器是不同的概念；
  • 当一个对象实现了iterable protocol协议时，它就是一个可迭代对象；
  • 这个对象的要求是必须实现 @@iterator 方法，在代码中我们使用 Symbol.iterator 访问该属性；
  • 当一个对象变成一个可迭代对象的时候，进行某些迭代操作，比如 for...of 操作时，其实就会调用它的 @@iterator 方法。

const objIterable = {
  arr: ['a', 'b', 'c'],
  [Symbol.iterator]: function () {
    let index = 0
    return {
      next: () => {
        if (index < this.arr.length) {
          return { done: false, value: this.arr[index++] }
        } else {
          return { done: true, value: undefined }
        }
      }
    }
  }
}

// 1、objIterable就是可迭代对象
console.log(objIterable[Symbol.iterator]) //[Function: [Symbol.iterator]]

const iterator = objIterable[Symbol.iterator]()
console.log(iterator.next())
console.log(iterator.next())
console.log(iterator.next())
console.log(iterator.next())
/* { done: false, value: 'a' }
{ done: false, value: 'b' }
{ done: false, value: 'c' }
{ done: true, value: undefined } */

// 2、for...of可以遍历的东西必须是一个可迭代对象
for (const item of objIterable) {
  console.log(item)
  /* a
     b
     c */
}

3、原生迭代器对象

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

// 1、数组
const arr = [1, 2, 3]
const arrIterator = arr[Symbol.iterator]()
console.log(arrIterator.next())
console.log(arrIterator.next())
console.log(arrIterator.next())
console.log(arrIterator.next())
/* { value: 1, done: false }
{ value: 2, done: false }
{ value: 3, done: false }
{ value: undefined, done: true } */

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

console.log(set[Symbol.iterator])

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

// 3、函数中arguments也是一个可迭代对象
function foo(x, y, z) {
  console.log(arguments[Symbol.iterator])
  for (const arg of arguments) {
    console.log(arg)
  }
}

foo(10, 20, 30)

• 可迭代对象运用场景
  • 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.for...of场景
const arr = [1, 2, 3]

for (const item of arr) {
  console.log(item)
}

// 2.展开语法(spread syntax)
const iterableObj = {
  names: ['abc', 'cba', 'nba'],
  [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 }
        }
      }
    }
  }
}

const names = ['abc', 'cba', 'nba']
const newNames = [...names, ...iterableObj]
console.log(newNames)

const obj = { name: 'why', age: 18 }
// for (const item of obj) {...}

// ES9(ES2018)中新增的一个特性: 用的不是迭代器
const newObj = { ...obj }
console.log(newObj)

// 3.解构语法
const [name1, name2] = names
// const { name, age } = obj 不一样，ES9新增的特性

// 4.创建一些其他对象时
const set1 = new Set(iterableObj)
const set2 = new Set(names)

const arr1 = Array.from(iterableObj)

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

4、自定义类的迭代

• 在前面我们看到Array、Set、String、Map等类创建出来的对象都是可迭代对象；
• 在面向对象开发中，我们可以通过class定义一个自己的类，这个类可以创建很多的对象。如果我们也希望自己的类创建出来的对象默认是可迭代的，那么在设计类的时候我们就可以添加上 @@iterator 方法。

class Student {
  constructor(name, age, arr) {
    this.name = name
    this.age = age
    this.arr = arr
  }

  [Symbol.iterator] = function () {
    let index = 0
    return {
      next: () => {
        if (index < this.arr.length) {
          return { done: false, value: this.arr[index++] }
        } else {
          return { done: true, value: undefined }
        }
      },
      
      // 终止迭代器
      return: () => {
        console.log('迭代器终止了')
        return { done: true, value: undefined }
      }
    }
  }
}

const stu = new Student('xxx', 18, ['a', 'b', 'c'])

// 1、
for (const item of stu) {
  console.log(item)
  /* a
     b
     c */
}

// 2、终止迭代器
for (const item of stu) {
  console.log(item)
  
  if (item === 'b') {
    break
  }
  /* a
     b
     迭代器终止了 */
}

二、生成器（generator）

1、什么是生成器？

• 生成器是ES6中新增的一种函数控制、使用的方案，它可以让我们更加灵活的控制函数什么时候继续执行、暂停执 行等。
• 平时我们会编写很多的函数，这些函数终止的条件通常是返回值或者发生了异常。
• 生成器函数也是一个函数，但是和普通的函数有一些区别：
  • 首先，生成器函数需要在function的后面加一个符号：*
  • 其次，生成器函数可以通过yield关键字来控制函数的执行流程：
  • 最后，生成器函数的返回值是一个Generator（生成器）：
  • 生成器事实上是一种特殊的迭代器；
  • MDN：Instead, they return a special type of iterator, called a Generator。

// 1、普通函数
function foo() {
  const value1 = 100
  console.log(value1)

  const value2 = 200
  console.log(value2)

  const value3 = 300
  console.log(value3)
}

foo()

// 2、生成器函数
// 当遇到yield时候值暂停函数的执行
// 当遇到return时候生成器就停止执行
function* foo() {
  const value1 = 100
  console.log(value1)
  yield

  const value2 = 200
  console.log(value2)
  yield

  const value3 = 300
  console.log(value3)
  yield

  const value4 = 400
  console.log(value4)
}

// 调用生成器函数时, 会给我们返回一个生成器对象
// generator本质上是一个特殊的iterator
const generator = foo()

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

// 开始执行第二端代码
console.log('----------')
generator.next() //200
generator.next() //300
console.log('----------')
generator.next() //400

// 3、yield的返回值
// 当遇到yield时候值暂停函数的执行
// 当遇到return时候生成器就停止执行
function* foo() {
  console.log('函数开始执行~')

  const value1 = 100
  console.log('第一段代码:', value1)
  yield value1

  const value2 = 200
  console.log('第二段代码:', value2)
  yield value2

  const value3 = 300
  console.log('第三段代码:', value3)
  yield value3

  console.log('函数执行结束~')
  return '123'
}

// generator本质上是一个特殊的iterator
const generator = foo()
console.log('返回值1:', generator.next()) //返回值1: { value: 100, done: false }
console.log('返回值2:', generator.next()) //返回值2: { value: 200, done: false }
console.log('返回值3:', generator.next()) //返回值3: { value: 300, done: false }
console.log('返回值3:', generator.next()) //返回值3: { value: '123', done: true }

• 我们发现上面的生成器函数foo的执行体压根没有执行，它只是返回了一个生成器对象。
  • 那么我们如何可以让它执行函数中的东西呢？调用next即可；
  • 我们之前学习迭代器时，知道迭代器的next是会有返回值的；
  • 但是我们很多时候不希望next返回的是一个undefined，这个时候我们可以通过yield来返回结果。

2、生成器传递参数 – next函数

• 函数既然可以暂停来分段执行，那么函数应该是可以传递参数的，我们可以给每个分段来传递参数：
  • 我们在调用next函数的时候，可以给它传递参数，那么这个参数会作为上一个yield语句的返回值；
  • 注意：也就是说我们是为本次的函数代码块执行提供了一个值。

function* foo(m) {
  let a = 10 * m
  console.log(a) //100
  const n = yield a

  let b = 20 * n
  console.log(b) //200
  yield b
}

const generator = foo(10)
console.log(generator.next()) //{ value: 100, done: false }
console.log(generator.next(10)) //{ value: 200, done: false }

3、生成器提前结束 – return函数

• 还有一个可以给生成器函数传递参数的方法是通过return函数：
  • return传值后这个生成器函数就会结束，之后调用next不会继续生成值了。

function* foo(m) {
  let a = 10 * m
  console.log(a) //100
  const n = yield a

  let b = 20 * n
  console.log(b)
  yield b
}

const generator = foo(10)
console.log(generator.next()) //{ value: 100, done: false }

// 那么就意味着相当于在第一段代码的后面加上return, 就会提前终端生成器函数代码继续执行
console.log(generator.return(10)) //{ value: 10, done: true }

4、生成器抛出异常 – throw函数

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

function* foo() {
  let a = 10
  try {
    yield a
  } catch (err) {
    console.log('报出的异常：' + err) //报出的异常：错误了
    yield 'xxx'
  }

  let b = 20
  yield b
}

const generator = foo()
console.log(generator.next()) //{ value: 10, done: false }
console.log(generator.throw('错误了')) //{ value: 'xxx', done: false }
console.log(generator.next()) //{ value: 20, done: false }

5、生成器替代迭代器

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

// 1、生成器替代迭代器
// 1-1、第一种写法
function* foo() {
  yield 'a'
  yield 'b'
  yield 'c'
}

const generator = foo()
console.log(generator.next())
console.log(generator.next())
console.log(generator.next())
/* { value: 'a', done: false }
{ value: 'b', done: false }
{ value: 'c', done: false } */

// 1-2、第二种写法
function* foo2(arr) {
  for (const item of arr) {
    yield item
  }
}

const arr = ['a', 'b', 'c']
const generator2 = foo2(arr)
console.log(generator2.next())
console.log(generator2.next())
console.log(generator2.next())
/* { value: 'a', done: false }
{ value: 'b', done: false }
{ value: 'c', done: false } */

// 1-3、第三种写法
function* foo3(arr) {
  // 这个时候相当于是一种yield的语法糖，只不过会依次迭代这个可迭代对象，每次迭代其中的一个值；
  yield* arr
}

const arr3 = ['a', 'b', 'c']
const generator3 = foo3(arr)
console.log(generator3.next())
console.log(generator3.next())
console.log(generator3.next())
/* { value: 'a', done: false }
{ value: 'b', done: false }
{ value: 'c', done: false } */

// 2、创建一个函数, 这个函数可以迭代一个范围内的数字
// 迭代器
let start = 10
let end = 20
const objIterator = {
  next: () => {
    if (start < end) {
      return { done: false, value: start++ }
    } else {
      return { done: true, value: undefined }
    }
  }
}

// 生成器替代迭代器
function* bar(start, end) {
  while (start < end) {
    yield start++
  }
}

const BarGenerator = bar(10, 20)
console.log(BarGenerator.next())
console.log(BarGenerator.next())
console.log(BarGenerator.next())

// 3、class案例
class Student {
  constructor(name, age, arr) {
    this.name = name
    this.age = age
    this.arr = arr
  }

  //   [Symbol.iterator] = function* () {
  //     let index = 0
  //     yield* this.arr
  //   }

  *[Symbol.iterator]() {
    let index = 0
    yield* this.arr
  }
}

const stu = new Student('xxx', 18, ['a', 'b', 'c'])

for (const item of stu) {
  console.log(item)
  /* a
       b
       c */
}

6、异步代码的处理方案

• 学完了我们前面的Promise、生成器等，我们目前来看一下异步代码的最终处理方案。
• 需求：
  • 我们需要向服务器发送网络请求获取数据，一共需要发送三次请求；
  • 第二次的请求url依赖于第一次的结果；
  • 第三次的请求url依赖于第二次的结果；
  • 依次类推。

function foo(url) {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      resolve(url)
    }, 1000)
  })
}

// 1、第一种方法：多次回调-回调地狱
foo('xxx').then(res => {
  foo(res + 'aaa').then(res => {
    foo(res + 'bbb').then(res => {
      foo(res + 'ccc').then(res => {
        console.log(res) //xxxaaabbbccc
      })
    })
  })
})

// 2、第二种方法：Promise中then的返回值来解决
foo('xxx')
  .then(res => {
    return foo(res + 'aaa')
  })
  .then(res => {
    return foo(res + 'bbb')
  })
  .then(res => {
    return foo(res + 'ccc')
  })
  .then(res => {
    console.log(res) //xxxaaabbbccc
  })

// 3.第三种方法: Promise + generator实现
function* bar() {
  const res1 = yield foo('xxx')
  const res2 = yield foo(res1 + 'aaa')
  const res3 = yield foo(res2 + 'bbb')
  const res4 = yield foo(res3 + 'ccc')
  console.log(res4) //xxxaaabbbccc
}

// 3-1、手动执行生成器函数
const generator = bar()
generator.next().value.then(res => {
  generator.next(res).value.then(res => {
    generator.next(res).value.then(res => {
      generator.next(res).value.then(res => {
        generator.next(res)
      })
    })
  })
})

// 3-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(bar)

// 3-3、第三方包co自动执行
// const co = require('co')
// co(bar)

// 4、第四种方案: async/await
async function bar2() {
  const res1 = await foo('xxx')
  const res2 = await foo(res1 + 'aaa')
  const res3 = await foo(res2 + 'bbb')
  const res4 = await foo(res3 + 'ccc')
  console.log(res4) //xxxaaabbbccc
}

bar2()