簡介
    ECMAScript 6 是JavaScript的下一個(gè)標(biāo)準(zhǔn)，正處在快速開發(fā)之中，ECMAScript 6 的目標(biāo)，是使得JavaScript可以用來編寫復(fù)雜的應(yīng)用程序、函數(shù)庫和代碼的自動生成器（code generator）。最新的瀏覽器已經(jīng)部分支持ECMAScript 6 的語法，ECMAScript 6 目前基本成為業(yè)界標(biāo)準(zhǔn)，它的普及速度比 ES5 要快很多，主要原因是現(xiàn)代瀏覽器對 ES6 的支持相當(dāng)迅速，尤其是 Chrome 和 Firefox 瀏覽器，已經(jīng)支持 ES6 中絕大多數(shù)的特性。
    1. let、const 和 block 作用域
    let 允許創(chuàng)建塊級作用域，ES6 推薦在函數(shù)中使用 let 定義變量，而非 var：
    var a = 2;
    {
     let a = 3;
     console.log(a); // 3
    }
    console.log(a); // 2
    同樣在塊級作用域有效的另一個(gè)變量聲明方式是 const，它可以聲明一個(gè)常量。ES6 中，const 聲明的常量類似于指針，它指向某個(gè)引用，也就是說這個(gè)「常量」并非一成不變的，如：
    {
     const ARR = [5,6];
     ARR.push(7);
     console.log(ARR); // [5,6,7]
     ARR = 10; // TypeError
    }
    有幾個(gè)點(diǎn)需要注意：
    let 關(guān)鍵詞聲明的變量不具備變量提升（hoisting）特性
    let 和 const 聲明只在最靠近的一個(gè)塊中（花括號內(nèi)）有效
    當(dāng)使用常量 const 聲明時(shí)，請使用大寫變量，如：CAPITAL_CASING
    const 在聲明時(shí)必須被賦值
    2. 箭頭函數(shù)（Arrow Functions）
    ES6 中，箭頭函數(shù)就是函數(shù)的一種簡寫形式，使用括號包裹參數(shù)，跟隨一個(gè) =>，緊接著是函數(shù)體：
    var getPrice = function() {
     return 4.55;
    };
    // Implementation with Arrow Function
    var getPrice = () => 4.55;
    需要注意的是，上面栗子中的 getPrice 箭頭函數(shù)采用了簡潔函數(shù)體，它不需要reture 語句，下面這個(gè)栗子使用的是正常函數(shù)體：
    let arr = ['apple', 'banana', 'orange'];
    let breakfast = arr.map(fruit => {
     return fruit + 's';
    });
    console.log(breakfast); // apples bananas oranges
    當(dāng)然，箭頭函數(shù)不僅僅是讓代碼變得簡潔，函數(shù)中 this 總是綁定總是指向?qū)ο笞陨怼＞唧w可以看看下面幾個(gè)栗子：
    function Person() {
     this.age = 0;
     setInterval(function growUp() {
     // 在非嚴(yán)格模式下，growUp() 函數(shù)的 this 指向 window 對象
     this.age++;
     }, 1000);
    }
    var person = new Person();
    我們經(jīng)常需要使用一個(gè)變量來保存 this，然后在 growUp 函數(shù)中引用：
    function Person() {
     var self = this;
     self.age = 0;
     setInterval(function growUp() {
     self.age++;
     }, 1000);
    }
    而使用箭頭函數(shù)可以省卻這個(gè)麻煩：
    function Person(){
     this.age = 0;
     setInterval(() => {
     // |this| 指向 person 對象
     this.age++;
     }, 1000);
    }
    var person = new Person();
    3. 函數(shù)參數(shù)默認(rèn)值
    ES6 中允許你對函數(shù)參數(shù)設(shè)置默認(rèn)值：
    let getFinalPrice = (price, tax=0.7) => price + price * tax;
    getFinalPrice(500); // 850
    4. Spread / Rest 操作符
    Spread / Rest 操作符指的是 ...，具體是 Spread 還是 Rest 需要看上下文語境。
    當(dāng)被用于迭代器中時(shí)，它是一個(gè) Spread 操作符：
    function foo(x,y,z) {
     console.log(x,y,z);
    }
    let arr = [1,2,3];
    foo(...arr); // 1 2 3
    當(dāng)被用于函數(shù)傳參時(shí)，是一個(gè) Rest 操作符：
    function foo(...args) {
     console.log(args);
    }
    foo( 1, 2, 3, 4, 5); // [1, 2, 3, 4, 5]
    5. 對象詞法擴(kuò)展
    ES6 允許聲明在對象字面量時(shí)使用簡寫語法，來初始化屬性變量和函數(shù)的定義方法，并且允許在對象屬性中進(jìn)行計(jì)算操作：
    function getCar(make, model, value) {
     return {
     // 簡寫變量
     make, // 等同于 make: make
     model, // 等同于 model: model
     value, // 等同于 value: value
     // 屬性可以使用表達(dá)式計(jì)算值
     ['make' + make]: true,
     // 忽略 `function` 關(guān)鍵詞簡寫對象函數(shù)
     depreciate() {
     this.value -= 2500;
     }
     };
    }
    let car = getCar('Barret', 'Lee', 40000);
    // output: {
    // make: 'Barret',
    // model:'Lee',
    // value: 40000,
    // makeBarret: true,
    // depreciate: function()
    // }
    6. 二進(jìn)制和八進(jìn)制字面量
    ES6 支持二進(jìn)制和八進(jìn)制的字面量，通過在數(shù)字前面添加 0o 或者 0O 即可將其轉(zhuǎn)換為二進(jìn)制值：
    let oValue = 0o10;
    console.log(oValue); // 8
    let bValue = 0b10; // 二進(jìn)制使用 `0b` 或者 `0B`
    console.log(bValue); // 2
    7. 對象和數(shù)組解構(gòu)
    解構(gòu)可以避免在對象賦值時(shí)產(chǎn)生中間變量：
    function foo() {
     return [1,2,3];
    }
    let arr = foo(); // [1,2,3]
    let [a, b, c] = foo();
    console.log(a, b, c); // 1 2 3
    function bar() {
     return {
     x: 4,
     y: 5,
     z: 6
     };
    }
    let {x: x, y: y, z: z} = bar();
    console.log(x, y, z); // 4 5 6
    8. 對象超類
    ES6 允許在對象中使用 super 方法：
    var parent = {
     foo() {
     console.log("Hello from the Parent");
     }
    }
    var child = {
     foo() {
     super.foo();
     console.log("Hello from the Child");
     }
    }
    Object.setPrototypeOf(child, parent);
    child.foo(); // Hello from the Parent
      // Hello from the Child
    9. 模板語法和分隔符
    ES6 中有一種十分簡潔的方法組裝一堆字符串和變量。
    ${ ... } 用來渲染一個(gè)變量
    ` 作為分隔符
    let user = 'Barret';
    console.log(`Hi ${user}!`); // Hi Barret!
    10. for...of VS for...in
    for...of 用于遍歷一個(gè)迭代器，如數(shù)組：
    let nicknames = ['di', 'boo', 'punkeye'];
    nicknames.size = 3;
    for (let nickname of nicknames) {
     console.log(nickname);
    }
    Result: di, boo, punkeye
    for...in 用來遍歷對象中的屬性：
    let nicknames = ['di', 'boo', 'punkeye'];
    nicknames.size = 3;
    for (let nickname in nicknames) {
     console.log(nickname);
    }
    Result: 0, 1, 2, size
    11. Map 和 WeakMap
    ES6 中兩種新的數(shù)據(jù)結(jié)構(gòu)集：Map 和 WeakMap。事實(shí)上每個(gè)對象都可以看作是一個(gè)Map。
    一個(gè)對象由多個(gè) key-val 對構(gòu)成，在 Map 中，任何類型都可以作為對象的 key，如：
    var myMap = new Map();
    var keyString = "a string",
     keyObj = {},
     keyFunc = function () {};
    // 設(shè)置值
    myMap.set(keyString, "value 與 'a string' 關(guān)聯(lián)");
    myMap.set(keyObj, "value 與 keyObj 關(guān)聯(lián)");
    myMap.set(keyFunc, "value 與 keyFunc 關(guān)聯(lián)");
    myMap.size; // 3
    // 獲取值
    myMap.get(keyString); // "value 與 'a string' 關(guān)聯(lián)"
    myMap.get(keyObj); // "value 與 keyObj 關(guān)聯(lián)"
    myMap.get(keyFunc); // "value 與 keyFunc 關(guān)聯(lián)"
    WeakMap
    WeakMap 就是一個(gè) Map，只不過它的所有 key 都是弱引用，意思就是 WeakMap 中的東西垃圾回收時(shí)不考慮，使用它不用擔(dān)心內(nèi)存泄漏問題。
    另一個(gè)需要注意的點(diǎn)是，WeakMap 的所有 key 必須是對象。它只有四個(gè)方法delete(key),has(key),get(key) 和 set(key, val)：
    let w = new WeakMap();
    w.set('a', 'b'); 
    // Uncaught TypeError: Invalid value used as weak map key
    var o1 = {},
     o2 = function(){},
     o3 = window;
    w.set(o1, 37);
    w.set(o2, "azerty");
    w.set(o3, undefined);
    w.get(o3); // undefined, because that is the set value
    w.has(o1); // true
    w.delete(o1);
    w.has(o1); // false
    12. Set 和 WeakSet
    Set 對象是一組不重復(fù)的值，重復(fù)的值將被忽略，值類型可以是原始類型和引用類型：
    let mySet = new Set([1, 1, 2, 2, 3, 3]);
    mySet.size; // 3
    mySet.has(1); // true
    mySet.add('strings');
    mySet.add({ a: 1, b:2 });
    可以通過 forEach 和 for...of 來遍歷 Set 對象：
    mySet.forEach((item) => {
     console.log(item);
     // 1
     // 2
     // 3
     // 'strings'
     // Object { a: 1, b: 2 }
    });
    for (let value of mySet) {
     console.log(value);
     // 1
     // 2
     // 3
     // 'strings'
     // Object { a: 1, b: 2 }
    }
    Set 同樣有 delete() 和 clear() 方法。
    WeakSet
    類似于 WeakMap，WeakSet 對象可以讓你在一個(gè)集合中保存對象的弱引用，在WeakSet 中的對象只允許出現(xiàn)一次：
    var ws = new WeakSet();
    var obj = {};
    var foo = {};
    ws.add(window);
    ws.add(obj);
    ws.has(window); // true
    ws.has(foo); // false, foo 沒有添加成功
    ws.delete(window); // 從結(jié)合中刪除 window 對象
    ws.has(window); // false, window 對象已經(jīng)被刪除
    13. 類
    ES6 中有 class 語法。值得注意是，這里的 class 不是新的對象繼承模型，它只是原型鏈的語法糖表現(xiàn)形式。
    函數(shù)中使用 static 關(guān)鍵詞定義構(gòu)造函數(shù)的的方法和屬性：
    class Task {
     constructor() {
     console.log("task instantiated!");
     }
     showId() {
     console.log(23);
     }
     static loadAll() {
     console.log("Loading all tasks..");
     }
    }
    console.log(typeof Task); // function
    let task = new Task(); // "task instantiated!"
    task.showId(); // 23
    Task.loadAll(); // "Loading all tasks.."
    類中的繼承和超集：
    class Car {
     constructor() {
     console.log("Creating a new car");
     }
    }
    class Porsche extends Car {
     constructor() {
     super();
     console.log("Creating Porsche");
     }
    }
    let c = new Porsche();
    // Creating a new car
    // Creating Porsche
    extends 允許一個(gè)子類繼承父類，需要注意的是，子類的 constructor 函數(shù)中需要執(zhí)行 super() 函數(shù)。
    當(dāng)然，你也可以在子類方法中調(diào)用父類的方法，如 super.parentMethodName()。
    在 這里 閱讀更多關(guān)于類的介紹。
    有幾點(diǎn)值得注意的是：
    類的聲明不會提升（hoisting)，如果你要使用某個(gè) Class，那你必須在使用之前定義它，否則會拋出一個(gè) ReferenceError 的錯(cuò)誤
    在類中定義函數(shù)不需要使用 function 關(guān)鍵詞
    14. Symbol
    Symbol 是一種新的數(shù)據(jù)類型，它的值是唯一的，不可變的。ES6 中提出 symbol 的目的是為了生成一個(gè)唯一的標(biāo)識符，不過你訪問不到這個(gè)標(biāo)識符：
    var sym = Symbol( "some optional description" );
    console.log(typeof sym); // symbol
    注意，這里 Symbol 前面不能使用 new 操作符。
    如果它被用作一個(gè)對象的屬性，那么這個(gè)屬性會是不可枚舉的：
    var o = {
     val: 10,
     [ Symbol("random") ]: "I'm a symbol",
    };
    console.log(Object.getOwnPropertyNames(o)); // val
    如果要獲取對象 symbol 屬性，需要使用 Object.getOwnPropertySymbols(o)。
    15. 迭代器（Iterators）
    迭代器允許每次訪問數(shù)據(jù)集合的一個(gè)元素，當(dāng)指針指向數(shù)據(jù)集合最后一個(gè)元素是，迭代器便會退出。它提供了 next() 函數(shù)來遍歷一個(gè)序列，這個(gè)方法返回一個(gè)包含 done 和value 屬性的對象。
    ES6 中可以通過 Symbol.iterator 給對象設(shè)置默認(rèn)的遍歷器，無論什么時(shí)候?qū)ο笮枰槐闅v，執(zhí)行它的 @@iterator 方法便可以返回一個(gè)用于獲取值的迭代器。
    數(shù)組默認(rèn)就是一個(gè)迭代器：
    var arr = [11,12,13];
    var itr = arr[Symbol.iterator]();
    itr.next(); // { value: 11, done: false }
    itr.next(); // { value: 12, done: false }
    itr.next(); // { value: 13, done: false }
    itr.next(); // { value: undefined, done: true }
    你可以通過 [Symbol.iterator]() 自定義一個(gè)對象的迭代器。
    16. Generators
    Generator 函數(shù)是 ES6 的新特性，它允許一個(gè)函數(shù)返回的可遍歷對象生成多個(gè)值。
    在使用中你會看到 * 語法和一個(gè)新的關(guān)鍵詞 yield:
    function *infiniteNumbers() {
     var n = 1;
     while (true){
     yield n++;
     }
    }
    var numbers = infiniteNumbers(); // returns an iterable object
    numbers.next(); // { value: 1, done: false }
    numbers.next(); // { value: 2, done: false }
    numbers.next(); // { value: 3, done: false }
    每次執(zhí)行 yield 時(shí)，返回的值變?yōu)榈鞯南乱粋€(gè)值。
    17. Promises
    ES6 對 Promise 有了原生的支持，一個(gè) Promise 是一個(gè)等待被異步執(zhí)行的對象，當(dāng)它執(zhí)行完成后，其狀態(tài)會變成 resolved 或者 rejected。
    var p = new Promise(function(resolve, reject) { 
     if (/* condition */) {
     // fulfilled successfully
     resolve(/* value */); 
     } else {
     // error, rejected
     reject(/* reason */); 
     }
    });
    每一個(gè) Promise 都有一個(gè) .then 方法，這個(gè)方法接受兩個(gè)參數(shù)，第一個(gè)是處理 resolved 狀態(tài)的回調(diào)，一個(gè)是處理 rejected 狀態(tài)的回調(diào)：
    p.then((val) => console.log("Promise Resolved", val),
     (err) => console.log("Promise Rejected", err));
    以上就是為大家整理的ECMAScript6快速入手的簡介，需要的朋友們可以學(xué)習(xí)參考。