Generator 函数

generator（生成器）是ES6标准引入的新的数据类型。一个generator看上去像一个函数，但能够返回屡次。

普通函数

function foo(x) {
    return x + x;
}

var r = foo(1); // 调用foo函数

Generator 函数

function* foo(x) {
    yield x + 1;
    yield x + 2;
    return x + 3;
}

generator和函数不一样的是，generator由function定义（注意多出的号），而且，除了return语句，还能够用yield返回屡次。
著名的斐波那契数列为例，它由0，1开头：

function fib(max) {
    var
        t,
        a = 0,
        b = 1,
        arr = [0, 1];
    while (arr.length < max) {
        [a, b] = [b, a + b];
        arr.push(b);
    }
    return arr;
}

// 测试:
fib(5); // [0, 1, 1, 2, 3]
fib(10); // [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

函数只能返回一次，因此必须返回一个Array。可是，若是换成generator，就能够一次返回一个数，不断返回屡次。用generator改写以下：

function* fib(max) {
    var
        t,
        a = 0,
        b = 1,
        n = 0;
    while (n < max) {
        yield a;
        [a, b] = [b, a + b];
        n ++;
    }
    return;
}

fib(5); // fib {[[GeneratorStatus]]: "suspended", [[GeneratorReceiver]]: Window}

直接调用一个generator和调用函数不同，fib(5)仅仅是建立了一个generator对象，尚未去执行它。

调用generator对象有两个方法，一是不断地调用generator对象的next()方法：
在控制台打印：

function* fib(max) {
    var
        t,
        a = 0,
        b = 1,
        n = 0;
    while (n < max) {
        yield a;
        [a, b] = [b, a + b];
        n ++;
    }
    return;
}
10:05:33.806 undefined
10:05:38.692 fib(5); 
10:05:38.696 fib {<suspended>}
10:05:51.057 var f = fib(5);
f.next()
10:05:51.062 {value: 0, done: false}

next()方法会执行generator的代码，而后，每次遇到yield x;就返回一个对象{value: x, done: true/false}，而后“暂停”。返回的value就是yield的返回值，done表示这个generator是否已经执行结束了。若是done为true，则value就是return的返回值。

当执行到done为true时，这个generator对象就已经所有执行完毕，不要再继续调用next()了。
第二个方法是直接用for ... of循环迭代generator对象，这种方式不须要咱们本身判断done：

'use strict'

function* fib(max) {
    var
        t,
        a = 0,
        b = 1,
        n = 0;
    while (n < max) {
        yield a;
        [a, b] = [b, a + b];
        n ++;
    }
    return;
}

for (var x of fib(10)) {
    console.log(x); // 依次输出0, 1, 1, 2, 3, ...
}

generator和普通函数相比，有什么用？

1. 由于generator能够在执行过程当中屡次返回，因此它看上去就像一个能够记住执行状态的函数
2. generator还有另外一个巨大的好处，就是把异步回调代码变成“同步”代码。
   有了generator的美好时代，用AJAX时能够这么写：

try {
    r1 = yield ajax('http://url-1', data1);
    r2 = yield ajax('http://url-2', data2);
    r3 = yield ajax('http://url-3', data3);
    success(r3);
}
catch (err) {
    handle(err);
}

看上去是同步的代码，实际执行是异步的。
参考网址：https://www.liaoxuefeng.com/wiki/001434446689867b27157e896e74d51a89c25cc8b43bdb3000/00143450083887673122b45a4414333ac366c3c935125e7000