ES6学习随笔--字符串模板、解构赋值、对象、循环、函数、Promise、Generrator

在线编译器：babel、github

在nongjs中使用
'use strict'
let a = ;

运行node ：
node --harmony_destructuring  xxx.js

代码块：
    用{}包起来的代码块，比如 if for while
    特点：只能在代码块里面使用

    var 只有函数作用域，可以重复声明，
    let const 有块级作用域，不可重复声明

    封闭空间
    ES5:
    (function() {
        var a = ;
    })();

    ES6:
    {
        let a = ;
    }

    总结：块级作用域，其实就匿名函数立即调用

const：用来定义常量，一旦赋值，再也修改不了；const 定义常量，声明的时候必须有初始值。

【字符串】
定义字符串： const str = `继续前行，不忘初心`;

字符串的拼接：
    ES5：
    'abc'+变量+'def'
    ES6：
    `abc${变量}def`

【解构赋值】：左边和右边的解构是一样的
    var [a,b,c] = [,,];
    alert(b);  // => 5

    var {a,b,c} = {b:,a:,c:}
    alert(a);  // =>12   json和顺序无关，json是无序的

    let [a,[b,c],d] = [,[,],];
    console.log(a,b,c,d);     // 模式匹配  ==》左侧和右侧格式相同

    解构赋值可以给默认值：
    ES5:
    var a = json.a || ;
    ES6:
    let {time = , id = } = {};

    function getPos() {
        return {left: , top:};
    }

    let {left, top} = getPos();
    console.log(left, top);

【数组的复制】
》var arr = [,,];
var arr2 = [];
for(var i=; i<arr.length;i++) {
    arr2[i] = arr[i]
}
arr2.pop();  // arr不会改变
console.log(arr, arr2)

》let arr = [,,];
let arr2 = Array.from(arr);

》Es6：
    let arr = [,,];
    let arr2 = [...arr];
    arr.pop();
    console.log(arr2,arr);
》argument
    function show(){
        console.log(arguments);  // =>arguments是不定参数的数组，只有数组的长度和下标，没有数组的方法，在这里执行数组的arguments.push(5) 会报错
    }
    function show(...args) {
        console.log(args);   // 使用超级复制...可以在新数组中使用数组的方法
    }
    show(,,,);

【map对象】
    var map = new Map();
    //设置  map.set(name,value);
    map.set('a','apple');
    map.set('b','banana');
    console.log(map);  // =>  {a => apple, b => banana}
    //获取  map.get(name);
    alert(map.get('a'));  // => apple
    //删除  map.delelte(name)
    map.delelte(a);
    console.log(map);

【循环】
    ES6中新增： for of 循环，遍历(迭代，循环)，整个对象，表现类似于for in，
    区别： 可以循环数组，不可以循环json，真正的目的是为了循环map对象

    let arr = ['a','b','c','d'];

    for(var i in arr) {
        console.log(i);   // 遍历的是数组的索引
    }

    for(let i of arr) {
        console.log(i);   // 遍历的是数组的每一项
    }
   ---------------------------------------------------
    var map = new Map();
    map.set('a','apple');
    map.set('b','banana');
    map.set('c','ccc');
    map.set('d','ddd');

    // map函数不能使用for in循环
    for(let name of map) {
        console.log(name);   //  name代表整个键值对  a,apple  本质是循环了map.entries()
    }
    // 如果想循环出key 和 value
    for(let [key,value] of map) {
        console.log(key, value);    // a apple
    }
    // 只循环key   也可以循环数组
    for(let key of may.key()) {
        console.log(key);
    }
    // 只循环value
    for(let val of map.values()) {
        console.log(val)
    }

【函数】
    ES5：
        function show(a) {
            return a;
        }
        show();
    ES56:
        箭头函数：
            .箭头函数中this的指向：this的指向指向window
            var a = ;
            var json = {
                a: ,
                b: ,
                show: () => {
                    return this.a;
                }
            }

            alert(json.show());   // => 100,因为箭头函数中的this指向了window

            .箭头函数中arguments不能使用了

        对象：对象语法简洁化
            单体模式
                var  person = {
                     name: 'abc',
                     age: ,
                     showName: function() {
                         alert(this.name);
                     },
                     showAge: function() {
                         alert(this.age);
                     }
                }
                // 解决this的指向window的问题
                var name = 'abc';
                var age = ;
                var person ={
                    name,
                    age,
                    showName() {
                        return this.name;
                    },
                    showAge() {
                        return this.age;
                    }
                }

            面向对象：
                ES5：
                    function Person(name, age) {
                        this.name = name;
                        this.age = age;
                    }
                    Person.prototye.showName = function() {
                        return this.name;
                    }
                    Person.prototype.showAge = function() {
                        return this.age;
                    }

                    var p1 = new Person('json',);
                    alert(p1.showAge());

                ES6:有类class，有构造函数 constructor()

                    class Person {   // 类
                        constructor(name = 'default' , age = ) {   //  函数的默认值
                            this.name = name;
                            this.age = age;
                        }
                        showName() {
                            return this.name;
                        }
                        showAge() {
                            return this.age;
                        }
                    }

                    let p1 = new Person('json',);
                    let p2 = new Person('lison',);

                    alert(p1.showName == p2.showName);  // => true
                    alert(p1.constructor == p2.constructor);  // => true

            函数的默认值

                function move(obj = '对象必须要填写', json= {}, {time:,easiong='ease-out'} = {}) {
                    console.log(json);
                }

                move();

            面向对象的继承：
                ES5:   子类.prototype = new 父类();
                    function Worker(name,age) {
                        Person.apply(this, arguments);
                    }
                    Worker.prototype = new Person();

                    var p1 = new Person('jason',,'要饭的')

                ES6:  使用super() 来继承父级的构造函数，constructor表示自己独有的，会覆盖父级过来的属性
                    class Person {   // 类
                        constructor(name = 'default' , age = ) {   //  函数的默认值
                            this.name = name;
                            this.age = age;
                        }
                        showName() {
                            return this.name;
                        }
                        showAge() {
                            return this.age;
                        }
                    }
                    class Worker extends Person {
                        constructor(name, age, job = '失业') {
                            surper(name, age);
                             this.job = job;
                        }
                        showJob() {
                            return this.job;
                        }
                    }

                    let p1 = new Person('aaa',);
                    let w1 = new Worker('json',);

                    alert(w1.showJob());   // => 失业

                    //面向对象选项卡
                        <style media="screen">
                          #box div{
                            width:4rem;
                            height:4rem;
                            background:#ccc;
                            border:.01rem solid #;
                            display:none;
                          }
                          #box .on{
                            background: #f60;
                            color: aqua
                          }
                        </style>
                      </head>
                      <body>
                        <div id="box">
                          <input type="button" value="aaa"  class="on">
                          <input type="button" value="bbb">
                          <input type="button" value="ccc">
                          <div style="display:block;"></div>
                          <div></div>
                          <div></div>
                        </div>

                      <script>
                        // 面向对象的选项卡
                        class Tab {
                          constructor(id) {
                            this.oBox = document.getElementById(id);
                            this.aBtn = this.oBox.getElementsByTagName('input');
                            this.aDiv = this.oBox.getElementsByTagName('div');
                            this.init();
                          }
                          init(){
                              for(let i=; i<this.aBtn.length; i++){
                                  this.aBtn[i].onclick = function(){
                                      this.hide();
                                      this.show(i);
                                  }.bind(this);
                              }
                          }
                          hide() {
                            for(let i=; i<this.aBtn.length; i++) {
                              this.aBtn[i].className = '';
                              this.aDiv[i].style.display = 'none';
                            }
                          }
                          show(index) {
                              this.aBtn[index].className = 'on';
                              this.aDiv[index].style.display = 'block';
                          }
                        }

                        new Tab('box');

                        // 继承（自动播放选项卡）
                        // 继承
                        class AutoTab extends Tab {
                          constructor(id) {
                            super(id);
                            setInterval(this.next.bind(this),);
                          }
                          next() {
                            this.iNow++;
                            if(this.iNow == this.aBtn.length) {
                              this.iNow = ;
                            }
                            this.hide();
                            this.show(this.iNow);
                          }
                        }

                        new Tab('box');
                        new AutoTab('autoBox');

【模块化】---也可以解决变量冲突，定义加载顺序
导出：a.js:
    const a = ;
    export default a;

    // export default function sum() {  // 导出函数的返回值
    //     return a+b;
    // }

 引用：
     import modA from './a.js';

导出多个模块：
    const a = ;
    const b = ;

    export default {  // 相当于导出一个json
        a,
        b
    }

【Promise】协议、承诺  是一个对象，用来异步操作数据（消息）
状态：
    pending(等待、处理中) => Resolve(完成、fullFilled)
                          => Rejected(拒绝、失败)

    let p1 = new Promise(function(resolve,reject) {

    });

    p1.then(成功(resolve),失败(reject));

    Promise.catch();   // 捕获错误 

    let p1 = new Promise( (resolve, reject) => {
        resolve('成功了');
    });

    p1.then(function(value) {
        console.log(value);  // => 成功了
        throw '发生错误了';
    }).catch( function(err) {
        console.log(err);   // => 发生错误了
    })

    Promise.all([p1,p2,p3..])   // 全部，将多个promise对象组合，包装成一个实例

    let p1 = Promise.resolve();
    let p2 = Promise.reject();

    Promise.all([p1,p2]).then(function(res) {
        console.log('错误了'+res);
    },function(res) {
        console.log('错误了'+res);
    });
    //  => 错误了5    只要一个失败就返回失败信息，全部成功才会返回成功信息

    Promise.race([p1,p2,p3...])   // 返回一个promise对象，返回的最先执行的promise

    let p1 = Promise( (resolve, reject) => {
        setTimeout(resolve,,'先执行');
    });
    let p2 = Promise( (resolve, reject) => {
        setTimeout(resolve,,'后执行');
    });

    Promise.race( [ p1, p2] ).then(function(res) {
        console.log(res);    // => 先执行
    });

    Promise.reject()    //  生成一个错误的Promise
    Promise.resolve(value/promise)   //  生成一个成功的Promise ，value:成功的值; promise:成功后的promise;
------------------------------------------------------------
  // 定义一个最简单的ajax
  function ajax(url,fnSucc,fnFail) {
    var oAjax = new XMLHttpRequest();
    oAjax.open('GET',url,true);
    oAjax.send();
    oAjax.onload = function() {
      if(oAjax.readyState ==  && oAjax.status == ) {
        fnSucc(oAjax.responseText);
      }else{
        fnFail(oAjax.status);
      }
    };
  }
  // 点击按钮从a.txt获取数据，如果成功展示到div中，如果失败，在div中显示错误码
  let oBtn = document.getElementById('btn1');
  let oDiv = document.getElementById('div1');

  oBtn.onclick = function() {
    let pro = new Promise( (resolve, reject) => {
        ajax('a.txt', function(str) {
          resolve(str);
        },function(str) {
          reject(str);
        });
    });

    pro.then(function(value) {
      oDiv.innerHTML = value;
    },function(value) {
      oDiv.innerHTML = reject;
    })
  }

【Generrator】 生成器，是一个函数，可以遍历，函数名前面有*，函数内部使用的yield语句，for of函数可以遍历Generrator函数

    语法： function* show() {   // generrator 函数
        yield 'hello';
        yield 'world';
        yield 'ES6';
    }

    let res = show();
    console.log(res.next());    // => Object   {value:'Hello',done:false}      done 表示还没有结束,执行一次出现一次返回值   如果没有return，最后一次循环会出现   {value:undefined, done:true}，如果有return，遇到return显示return的值和done：true

    // Generrator 函数每次返回一个value和一个done

    yield语句本身没有返回值，或者每次返回undefined

    next 可以带参数，给上一个yield

    function* fn() {
        yield ;
        yield ;
        yield ;
        yield ;
        yield ;
        yield ;
        return
    }

    for(let v of fn()) {
        document.write(v);   // => 123456
    }