ECMAScript的 Itertor，Generator，Decorator，Module

1.Itertor

// Itertor(遍历器)
        // 遍历器（Iterator）就是这样一种机制。它是一种接口，为各种不同的数据结构提供统一的访问机制。

        // 遍历器生成函数，作用就是返回一个遍历器对象。

        {
            let arr = ['hello', 'world'];
            let map = arr[Symbol.iterator]();
            log(map.next());
            // done: false 说明还有下一步
            log(map.next());
            log(map.next());            
        }

        {
            let obj = {
                start: [1, 3, 2],
                end: [7, 9, 8],
                // 自定义接口
                [Symbol.iterator]() {
                    let self = this;
                    let index = 0;
                    let arr = self.start.concat(self.end);
                    let len = arr.length;
                    return {
                        next() {
                            if(index < len) {
                                return {
                                    value: arr[index++],
                                    done: false
                                }
                            }else {
                                return {
                                    value: arr[index++],
                                    done: true
                                }
                            }
                        }
                    }
                }
            }
            for (let key of obj) {
                log(key);
            }
        }

        // for...of 循环
        // for...of循环可以使用的范围包括数组、Set 和 Map 结构、某些类似数组
        // 的对象（比如arguments对象、DOM NodeList 对象）、后文的 Generator 对象，以及字符串。

        let arr = [3, 5, 7];
        arr.foo = 'hello';

        for (let i in arr) {
            log(i);
        }

        for (let i of arr) {
            log(i);
        }

        var engines = new Set(["g", "t", "w", "i"]);
        for (var e of engines) {
            log(e);
        }

2.Generator

{
            // 
            let draw = function(count) {
                // 具体抽奖逻辑
                alert(`剩余${count}次`)
            }

            let residue = function* (count) {
                while(count > 0) {
                    count--;
                    yield draw(count);
                }
            }

            let star = residue(5);
            let btn = document.createElement('button');
            btn.id = 'start';
            btn.textContent = '抽奖';
            document.body.appendChild(btn);
            document.getElementById('start').addEventListener('click', function() {
                star.next();
            }, false)
        }


        {
            // genertaor 函数
            let tell = function* () {
                yield 'a';
                yield 'b';
                return 'c'
            };

            let k = tell();

            log(k.next());
            // {value: "a", done: false}
            log(k.next());
            // {value: "b", done: false}
            log(k.next());
            // {value: "c", done: true}
            log(k.next());
            // {value: undefined, done: true}
        }

        {
            let obj = {};
            obj[Symbol.iterator] = function* () {
                yield 1;
                yield 2;
                yield 3;
            }

            for(let value of obj) {
                log('value', value)
            }
        }

        {
            // 状态机
            let state = function* () {
                while(1) {
                    yield 'A';
                    yield 'B';
                    yield 'C';
                }
            }
            let status = state();
            log(status.next());
            log(status.next());
            log(status.next());
            log(status.next());
            log(status.next());
            log(status.next());
            log(status.next());
            log(status.next());
        }

        {
            // Generator的语法糖
            let state = async function () {
                while(1) {
                    await 'A';
                    await 'B';
                    await 'C';
                }
            }
        }

        {
            // 长轮询
            let ajax = function* () {
                yield new Promise (function (resolve, reject) {
                    setTimeout(function() {
                        resolve({
                            code: 0
                        })
                    }, 200);
                })
            }

            let pull = function() {
                let generator = ajax();
                let step = generator.next();
                step.value.then(function(d) {
                    if (d.code != 0) {
                        setTimeout(function() {
                            alert('I Love You');
                            pull()
                        }, 1000);
                    }else {
                        console.info(d);
                    }
                })
            }

            pull();
        }

3.Decorator

{
            // 修饰器（也是一个函数）
            let readonly = function(target, name, descriptor) {
                descriptor.writable = false;
                return descriptor
            };  

            class Test{
                readonly
                time() {
                    return '2017-03-11'
                }

            }  

            let test = new Test();

            test.time = function() {
                log('rest time');
            };
            log(test.time());

       }

4.Module

{
            export let a = 123;

            export function test() {
                console.log('test');
            }
            
            export class Hello {
                test() {
                    console.log('class');
                }
            }

            export default {
                a,
                test,
                Hello,
            }

            // 导出语句
            // 在另一个文件里面
            import {a, test, Hello} from '文件名'
            import * as lesson from '文件名'
            // * 代表所有的东西 as 后面的是别名，代表所有的东西都存在 leson 中

            import lesson17 from '文件名'
            //  lesson17 是别名，可以自己起
        }