(1) let 用来声明块级作用域的变量，所以下面例子能打印出正确的数字，而不是像var一样全都是打印最后一个.

    1. var _div = document.getElementsByTagName('div');
    2. for(let i=0;i<_div.length;i++){
    3.     _div[i].onclick = function(){
    4.         console.log(i)
    5.     }
    6. }

    (2) es5中，给prototype设置的属性或方法，可以在要调用时直接用.属性或.方法来调用
    es6中直接用class声明方法实例，然后同样.方法来调用内部属性或方法：

    1. class ObjFn{
    2.     //构造器
    3.     constructor(){
    4.         this.name = '我是zzz,es6'
    5.         console.log( this )
    6.     }
    7.     age(){
    8.         console.log( this.name + '，今年18岁' );
    9.     }
    10. }
    11. let _objFn = new ObjFn();
    12. _objFn.age();

    (3) es6 子类继承父类,子类中的super()相当于在此实例化了一个父类对象。一般没有继承，就用不着super()

    1. // 这是父类
    2. class ObjFn{
    3.        constructor(){
    4.               this.name = '我是zzz,es6'
    5.        }
    6.        age(){
    7.               console.log( this.name + '，今年18岁' );
    8.        }
    9. }
    10. // 这是子类
    11. class SubClassFn extends ObjFn{
    12.        constructor(){
    13.               //这super()就是先得到了父类的this，也就是父类的实例对象
    14.               super();
    15.               this.eat = '就是能吃';
    16.        }
    17. }
    19. let _subClassFn = new SubClassFn();
    20. //调用父类的age()
    21. _subClassFn.age();
    22. console.log( _subClassFn.eat )

    (4) destructuring，解构。
    es6，可以按照一定的模式，从数组和对象当中去取值、赋值，
    这个过程，被称为解构。

    1. // es5的赋值写法
    2. var aa = 111;
    3. var bb = 222;
    4. var xxobj = {aa:aa,bb:bb};
    5. console.log( xxobj );
    7. // es6的赋值的写法：
    8. let a1 = 123;
    9. let a2 = 444;
    10. let obj = {a1,a2}
    11. console.log( obj );
    13. // es6的取值的写法：
    14. let _xxObj = {
    15.        name:'我是zzz',
    16.        age: '今年18'
    17. }
    18. //name和age就是定义的变量，注意命名要和_xxObj中的一样
    19. let {name, age} = _xxObj;
    20. console.log( name, age );

    (5) generator函数，有yield值，分段执行。

    1. // 定义Generator函数，
    2. // 现在这个函数里面的值，就有了四个阶段，
    3. // 每个阶段有不同的状态
    4. function* xxfn(){
    5.        yield 'a';
    6.        yield 'b';
    7.        yield 'c';
    8.        return 'd end.. '
    9. }
    10. // xxfn(),这种方式并不是执行xxfn函数
    11. // 返回的也不是xxfn函数的运行的结果
    12. var _xxfn = xxfn();
    13. // 打印出来的是，
    14. // 是一个指向其内部状态的指针对外 ，
    15. // 就是一个引用，是一个迭代器对象的引用
    16. console.log( _xxfn );

    打印结果：
    ES6常用概念 - 图1
    要一个个获取到每一次yield返回的值，就用next()

    1. function* xxfn(){
    2.        yield 'a11';
    3.        yield 'b22';
    4.        yield 'c333';
    5.        return 'd end.. '
    6. }
    7. var _xxfn = xxfn();
    9. // 这是运行到第一个 yield语句
    10. console.log( _xxfn.next() );
    11. // 结果是Object {value: "a11", done: false}

    /*’a11’，就是xxfn这个函数执行到了第一个yield语句之后得到的值；
    关于done : false，这里的false，是说 xxfn这个函数，还没执行完。在这就是暂停一下。