ECMAScript之Generator

Generator是一种新函数，但是用法和函数完全不一样，目的主要是解决异步问题，我们叫做“生成器”

简单实例

function* generatorFun() {
  yield '第一步';
  yield '第二步';
  return '结束。';
}

var gF = generatorFun();

console.log(gF.next()) // => {value: "第一步", done: false}
console.log(gF.next()) // => {value: "第二步", done: false}
console.log(gF.next()) // => {value: "结束。", done: true}
console.log(gF.next()) // => {value: undefined, done: true}

格式和关键词

function* generatorName(){} // => 格式
yield // => 调用节点，每一次next()都会寻找yield节点直到下一个yield节点。(注意：yield表达式只能用在 Generator 函数里面，用在其他地方都会报错。)
next() // => 调用方法，进入generator中寻找yield或者return。

带参实例

function* generatorFun(x) {
  let y = 2*(yield (x+1))
  let z = yield (y/3)
  return (x+y+z)
}

var gF = generatorFun(5);
// 第一步
console.log(gF.next()) // => {value: "6", done: false}
// 第二步
console.log(gF.next(6)) // => {value: "4", done: false}
// 第三步
console.log(gF.next(7)) // => {value: "24", done: true}
// 第四步
console.log(gF.next()) // => {value: undefined, done: true}

解释

next方法可以带一个参数，该参数就会被当作上一个yield表达式的返回值。

重点就是参数会被当做上一个yield表达式的返回值。无比重要！理解不了这点你永远也搞不懂为啥会打印出这些结果。反正我不知道是不是我思维的缺陷，我花了起码三个小时才勉强理解！

• 第一步：默认为5 所以返回第一个表达式的值 yield(x + 1) 也就是6；x = 5;
• 第二步：调用时传值为6，覆盖上一个表达式的值，那么yield（x+1） = 6；所以y = 2*6 = 12；所以yield(y/3) = 4; y = 12;
• 第三步：调用时传值为7，覆盖上一个表达式的值，也就是yield（y/3）= 7; z = 7;和值就是x + y + z = 5+12+ 7 = 24
• 第四步：无值返回undefined

循环for...of

Generator对象是可以循环的，这里要涉及Iterator对象，你先别管就只管知道可以循环，怎么用就好了。

function* foo(x) {
 yield 1
 yield 2
 yield 3
 yield 4
 return 5
}

for(let key of foo()){
  console.log(key)
}
// => 1,2,3,4

注意：一旦next方法的返回对象的done属性为true，for...of循环就会中止，且不包含该返回对象，所以上面代码的return语句返回的5，不包括在for...of循环之中。
好处：不用再使用next()方法！

其他方式...，from，解构……

function* numbers () {
  yield 1
  yield 2
  return 3
  yield 4
}

// 扩展运算符
[...numbers()] // [1, 2]

// Array.from 方法
Array.from(numbers()) // [1, 2]

// 解构赋值
let [x, y] = numbers();
x // 1
y // 2

终结方法return()

function* myFun(){
  yield 1
  yield 2
  yield 3
}

var mF = myFun()

console.log(mF.next()) // => {value: 1, done: false}
console.log(mF.return('ending')) // => {value: "ending", done: true}
console.log(mF.next()) // => {value: undefined, done: true}

本来第三步应该返回三的，但是因为有了.return()方法就终结了！

yield*表达式

看实例

function* myFun(){
  yield 1
  yield 2
  yield 3
}
function* myFunOne(){
  yield 'a'
  yield myFun()
  yield 'b'
}

var mF = myFunOne()

console.log(mF.next()) // => {value: "a", done: false}
console.log(mF.next()) // => {value: Generator, done: false}
console.log(mF.next()) // => {value: "b", done: true}

// *************我们想要的结果可是不一样的********************
// 我们来修改一下
function* myFunTwo(){
  yield 'a'
  yield* myFun()
  yield 'b'
}

var mF = myFunTwo()

console.log(mF.next()) // => { value: "a", done: false }
console.log(mF.next()) // => { value: 1, done: false }
console.log(mF.next()) // => { value: 2, done: false }

// 实际上，任何数据结构只要有 Iterator 接口，就可以被yield*遍历。
let read = (function* () {
  yield 'hello';
  yield* 'hello';
})();

read.next().value // "hello"
read.next().value // "h"

今天先到这儿，明天继续补上