master

分支 (1)

管理

管理

master

test_demo
/
10、generator函数.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>

</body>
</html>
<script>
    /**
     * 本质上就是一个暂停函数
     * @returns {IterableIterator<number>}
     */
    function* f() {
        console.log("执行了！");
        yield '第一次';
        return 'ending';
    }

    var generater = f();
    setTimeout(function () {
        console.log(generater.next())
    }, 2000)
    setTimeout(function () {
        console.log(generater.next())
    }, 4000)
    setTimeout(function () {
        console.log(generater.next())
    }, 6000)


    /**
     * 注入参数
     * @returns {string}
     */
    function* dataConsumer() {
        console.log('Started');
        console.log(`1. ${yield}`);
        console.log(`2. ${yield}`);
        return 'result';
    }

    let genObj = dataConsumer();
    genObj.next();
    // Started
    genObj.next('a')
    // 1. a
    genObj.next('b')

    // 2. b


    /**
     * 使用for  of不再需要next
     * @returns {IterableIterator<number>}
     */
    function* foo() {
        yield 1;
        yield 2;
        yield 3;
        yield 4;
        yield 5;
        return 6;
    }

    for (let v of foo()) {
        console.log(v);
    }


    /**
     * 使用for of循环斐波那契数列
     * @returns {IterableIterator<number>}
     */
    function* fibonacci() {
        let [prev, curr] = [0, 1];
        for (; ;) {
            yield curr;
            [prev, curr] = [curr, prev + curr];
        }
    }

    for (let n of fibonacci()) {
        if (n > 100000) break;
        console.log(n,'@@@@@@@@@2');
    }

    /**
     * 便利对象
     * @param obj
     * @returns {any[]}
     */
    function* objectEntries(obj) {
        let propKeys = Reflect.ownKeys(obj);

        for (let propKey of propKeys) {
            yield [propKey, obj[propKey]];
        }
    }

    let jane = {first: 'Jane', last: 'Doe'};

    for (let [key, value] of objectEntries(jane)) {
        console.log(`${key}: ${value}`);
    }
    // first: Jane
    // last: Doe

    /**
     * 外部主动抛错让内部捕获
     * 注意：抛错需要至少执行一次next
     * @returns {IterableIterator<*>}
     */
    var g = function* () {
        try {
            yield;
        } catch (e) {
            console.log('内部捕获', e);
        }
    };

    var i = g();
    i.next();

    try {
        i.throw('a');
        i.throw('b');
    } catch (e) {
        console.log('外部捕获', e);
    }
    // 内部捕获 a
    // 外部捕获 b

    /**
     * 手动return
     * @returns {IterableIterator<number>}
     */
    function* back() {
        yield 1;
        yield 2;
        yield 3;
    }

    var g11 = back();

    console.log(g11.next());          // { value: 1, done: false }
    console.log(g11.return('foo'));      // { value: "foo", done: true }
    console.log(g11.next());          // { value: undefined, done: true }

    /**
     * 总结：本质上是控制函数执行节奏，按照既定目的向下执行
     */

    /**
     * 解决异步任务；Generator 函数是协程在 ES6 的实现，最大特点就是可以交出函数的执行权（即暂停执行）。
     * 第一步，协程A开始执行。
     * 第二步，协程A执行到一半，进入暂停，执行权转移到协程B。
     * 第三步，（一段时间后）协程B交还执行权。
     * 第四步，协程A恢复执行。
     */


    /**
     * co模块，自动执行generator函数
     */

    var gen444 = function* () {
        var f1 = yield readFile('/etc/fstab');
        var f2 = yield readFile('/etc/shells');
        console.log(f1.toString());
        console.log(f2.toString());
    };
    /**
     * 返回一个promise对象
     */
    co(gen444).then(function () {
        console.log('Generator 函数执行完成');
    }).catch(function (error) {
        console.log('发生错误！', error);
    });


    /**
     * promise补充2018标准，finally不管成功失败都会执行
     */

    promise
        .then(result => {

        })
        .catch(error => {

        })
        .finally(() => {
            console.log("我一定会执行哟~~");
        });
    /**
     * Promise.all都成功才成功
     * Promise.race获取最先返回的结果执行==》用途请求超时设置
     */

    /**
     * 不分同步异步写法
     * 提案写法promise.try，目前处于草案阶段
     */
    (async () => f())()
        .then(function (res) {

        })
        .catch(function (err) {

        })
</script>