摘要：一簡介與的關(guān)系是的規(guī)格，是的一種實現(xiàn)另外的方言還有和轉(zhuǎn)碼器命令行環(huán)境安裝直接運行代碼命令將轉(zhuǎn)換成命令瀏覽器環(huán)境加入，代碼用環(huán)境安裝，，根目錄建立文件加載為的一個鉤子設(shè)置完文件后，在應(yīng)用入口加入若有使用，等全局對象及上方法安裝

ES是JS的規(guī)格，JS是ES的一種實現(xiàn)（另外的ECMAScript方言還有Jscript和ActionScript）；

安裝babel-cli, babel-preset-2015；

直接運行ES6代碼：babel-node命令；

將ES6轉(zhuǎn)換成ES5：babel命令；

加入brower.js，ES6代碼用type="text/babel"

安裝 babel-core，babel-preset-2015，根目錄建立.babelrc文件：

{
    "preset":["es2015"]
}

(1) babel加載為require的一個鉤子：設(shè)置完.babelrc文件后，在應(yīng)用入口加入require("babel-core/register")；

(2) 若有使用Iterator，Generator等全局對象及上方法：安裝babel-polyfill模塊，并在應(yīng)用頭部require("babel-polyfill")

與var類似，但變量只在let的代碼塊內(nèi)有效；

var a = [];
for (let i = 0; i < 10;i++) {
    a[i] =function () {
        console.log(i);
    };
}
a[6](); 
// 6，變量i是let聲明的，當(dāng)前的i只在本輪循環(huán)有效，所以每一次循環(huán)的i其實都是一個新的變量，最后輸出的是6；若用var i = 0，則將為10

注意：

(1) 無“變量提升”，用let聲明的對象之前需要先聲明再使用；

(2) 暫時性死區(qū)（Temporal Dead Zone），只要一進入當(dāng)前作用域，所要使用的變量就已經(jīng)存在了，但是不可獲取，只有等到聲明變量的那一行代碼出現(xiàn)，才可以獲取和使用該變量；同時，也意味著：typeof操作不是絕對安全的！

// 2.暫時性死區(qū) 例子
var tmp = 123;
if (true) {
    tmp = "abc"; //ReferenceError
    let tmp;
}

typeof x; // ReferenceError
let x;

function bar(x = y, y = 2) {
    return [x, y];
}
bar(); // 報錯

(3) 不允許重復(fù)聲明，相同作用域中不能用var,let再次聲明let變量（若不是相同作用域則無妨，即再嵌套一個{}，花括號里外就是不同作用域）；

可以在塊級作用域中聲明函數(shù)，且該行為類似于let：

function f() { console.log("I am outside!"); }
(function () {
    if(false) {
        //重復(fù)聲明一次函數(shù)f
        function f() { console.log("I am inside!"); }
    }
    f();
}());

以上代碼在不同的版本下會有差別：

ES5：運行結(jié)果“I am inside!”，相當(dāng)于聲明提前；

ES6：運行結(jié)果“I am outside!”，相當(dāng)于里面的是塊作用域，f() 用的是閉包里的；

ES6的瀏覽器：報錯“f is not a function”，根據(jù)規(guī)則：函數(shù)聲明會提前到全局、函數(shù)作用域的頭部（類似var），也會提前到塊級作用域的頭部，相當(dāng)于在只執(zhí)行函數(shù)頭部var f = undefined；

與let相同，塊級作用域，但是常量需要初始化；

const聲明對象時，其地址不可變，但其中內(nèi)容可變；

用ES5的命令var, function聲明的變量依然是全局對象的屬性，而用ES6命令聲明的變量則不是；

以上規(guī)則在Node的REPL中適用，模塊環(huán)境下，則只能用global.a來調(diào)用全局變量；

例子：

var [a, b, c] = [1, 2,3]; // 則abc分別為123

跳過：let [x, , y] = [1, 2, 3]; // y為3

數(shù)組：let [head, ...tail] = [1, 2, 3, 4]; // tail為[2,3,4]

左邊解構(gòu)不成功（左邊多），則變量為undefined；

右邊不完全解構(gòu)（左邊少），則忽略右邊；

右邊為非可遍歷，則報錯；

例子：(右邊必須為=== undefined）

let [x, y, ...z] = ["a"];
x // "a"
y // undefined
z // []

注意：

惰性求值：若默認(rèn)為函數(shù)，只有在解構(gòu)用到默認(rèn)值時才調(diào)用；

可以用已經(jīng)聲明的變量作為默認(rèn)值，未聲明的則報錯；

同名屬性賦值，左邊含義為{模式：變量}，完整格式如：

var { foo: foo, bar: bar } = { foo:"aaa", bar: "bbb" }；

若模式與變量同名則可以省略模式，否則必須完整

var { foo: baz } = { foo: "aaa", bar:"bbb" }；// 變量baz為"aaa"

注意：

“變量”部分的重新聲明（代碼見后）；

嵌套賦值（代碼見后）；

將已聲明的變量用于解構(gòu)賦值，需要加括號（代碼見后）；

// --------- 1. 變量部分重新聲明 ---------
let foo;
let {foo} = {foo: 1}; // SyntaxError: Duplicate declaration "foo"
({foo} = {foo: 1}); // 成功

let baz;
let {bar: baz} = {bar: 1}; // SyntaxError: Duplicate declaration "baz"
({bar: baz} = {bar: 1});  // 成功

// --------- 2. 嵌套賦值 ---------
let obj = {};
let arr = [];

({ foo: obj.prop, bar: arr[0] } = { foo: 123,bar: true });
obj // {prop:123}
arr // [true]

// 以下報錯
var {foo: {bar}} = {baz:"baz"}; // 因為foo為undefined，則foo.bar會報錯

// --------- 3. 將已聲明的變量用于解構(gòu)賦值，需要注意 ---------
var x;
{x} = {x: 1};

// 正確的寫法
({x} = {x: 1});
// 因為“{”在行首，會被理解為一個代碼塊，故而后面報錯；

等式的右邊會轉(zhuǎn)換層包裝對象，故而等式左邊可以寫成 length:s, toString: s；

例子：

function add([x, y]){
    returnx + y;
}
add([1, 2]); // 3

對比 設(shè)定參數(shù)對象默認(rèn)值 與 對象解構(gòu)的默認(rèn)值 的區(qū)別：

// 對象解構(gòu)的默認(rèn)值
function move({x = 0, y = 0} = {}) {
  return[x, y];
}
move({x: 3, y: 8}); // [3, 8]
move({x: 3}); // [3, 0]
move({}); // [0, 0]
move(); // [0, 0] 

// 參數(shù)對象的默認(rèn)值
function move({x, y} = { x: 0, y: 0 }) {
  return[x, y];
}
move({x: 3, y: 8}); // [3, 8]
move({x: 3}); // [3, undefined]
move({}); // [undefined, undefined]
move(); // [0, 0]

聲明中不可使用圓括號，賦值語句中的非模式部分（變量與整體）可以使用圓括號；

用途：保證對象屬性名的唯一性；

生成方法：通過Symbol()函數(shù)，可傳參數(shù)作為描述；

注意：

不能在Symbol()函數(shù)前面加new，否則報錯，因為Symbol不是對象；

Symbol()函數(shù)不能與其他類型的值進行運算，但可轉(zhuǎn)成字符串或布爾值(true)；

Symbol(s)中的參數(shù)僅僅用于toString()控制臺輸出作為人工區(qū)分，即使沒有參數(shù)也是不同的變量；

var s1 = Symbol();
var s2 = Sy mbol();
s1 === s2 // false

a[mySymbol] = "xx";
a = {
  [mySymbol] = "xx" //方括號不能去
};
Object.defineProperty(a, mySymbol, {
  value: "xx" 
});

當(dāng)Symbol作為屬性名時，不能用點運算符，a.mySymbol其實為a["mySymbol"]；

用Object.getOwnPropertySymbols()，返回數(shù)組，其成員是所有用作屬性名的Symbol值；

Reflect.ownKeys()，返回自身所有類型的鍵名，包括Symbol值；

重新使用同一個Symbol，搜索有沒有s為名字的Symbol，有就返回，無則新建Symbol；這是全局的，即使不同iframe也用同一個Symbol；

返回一個已用Symbol.for()登記的Symbol類型值的key；

Symbol.hasInstance：指向內(nèi)部方法，當(dāng)其他對象使用instanceof運算符時，會調(diào)用這個方法；

Symbol.isConcatSpreadable：布爾值，表示使用concat()時，是展開成元素還是整個數(shù)組

Symbol.species：指向一個方法，當(dāng)該對象作為構(gòu)函創(chuàng)造實例時，調(diào)用該方法；

Symbol.match：指向一個方法，執(zhí)行match()時會調(diào)用；

Symbol.replace：指向一個方法，執(zhí)行replace()時會調(diào)用；

Symbol.search：指向一個方法，執(zhí)行search()時會調(diào)用；

Symbol.split：指向一個方法，執(zhí)行split()時會調(diào)用；

Symbol.iterator：指向該對象的默認(rèn)遍歷器；

Symbol.toPrimitive：指向一個方法，該對象被轉(zhuǎn)為原始類型的值時調(diào)用，返回該對象對應(yīng)的原始類型值；

Symbol.toStringTag：指向一個方法，調(diào)用toString()方法時，返回成[object xxx]

Symbol.unscopables：指向一個對象，指定了使用with關(guān)鍵字時，哪些屬性被with排除；

集合，類似數(shù)組，成員值唯一；采用===，除了NaN；

new Set([array]) 

Set.prototype.constructor：構(gòu)造函數(shù)，默認(rèn)就是Set函數(shù)；

Set.prototype.size：返回Set實例的成員總數(shù)；

add(value)：添加某個值，返回Set結(jié)構(gòu)本身；

delete(value)：刪除某個值，返回一個布爾值，表示刪除是否成功；

has(value)：返回一個布爾值，表示該值是否為Set的成員；

clear()：清除所有成員，沒有返回值；

以下為遍歷方法

keys()：返回鍵名的遍歷器，Set鍵名與鍵值相同；

values()：返回鍵值的遍歷器，Set鍵名與鍵值相同；

entries()：返回鍵值對的遍歷器；

forEach(func)：使用回調(diào)函數(shù)遍歷每個成員；

元素只能是對象；

其中的對象都是弱引用，垃圾回收機制不考慮其對象的引用，即若無其他對象引用該對象，則回收；

因無法引用該對象，故無法遍歷；

WeakSet.prototype.add(value)：向WeakSet實例添加一個新成員；

WeakSet.prototype.delete(value)：清除WeakSet實例的指定成員；

WeakSet.prototype.has(value)：返回一個布爾值，表示某個值是否在WeakSet實例之中；

類似對象，鍵值對的集合，但其鍵的范圍不限于字符串；參數(shù)是數(shù)組，其成員是[[key1, value1], [key2, value2]]；

同一個鍵多次賦值，則會覆蓋；

讀取未知的鍵，返回undefined；

對同一個對象的引用作為鍵，Map才視為同一個鍵，NaN、正負(fù)0分別視為同一個對象；

map.set(["a"], 555);
map.get(["a"]);        //undefined 

var k1 = ["a"];
var k2 = ["a"];
map
.set(k1, 111)
.set(k2, 222);
map.get(k1) // 111
map.get(k2) // 222

size屬性：返回成員總數(shù)；

set(key, value)：設(shè)置key所對應(yīng)的鍵值，然后返回整個Map結(jié)構(gòu)，若已存在鍵，則更新值；

get(key)：讀取對應(yīng)鍵值，無則返回undefined；

has(key)：返回布爾值，表示是否在Map中；

delete(key)：刪除某個鍵，返回true，失敗則false；

clear()：清除所有成員，無返回；

遍歷方法：keys(), values(), entries(), forEach()；

與Map結(jié)構(gòu)類似，唯一區(qū)別在于只接受對象作為鍵名（null除外）；

WeakMap的專用場合就是，它的鍵所對應(yīng)的對象，可能會在將來消失，WeakMap結(jié)構(gòu)有助于防止內(nèi)存泄漏；

沒有遍歷操作，也沒有size屬性；

無法清空；

class類型看成是函數(shù)，類本身就是指向構(gòu)造函數(shù)；

類的方法都定義在prototype對象上面，所以類的新方法可以添加在prototype對象上面；

//定義類
class Point {
  constructor(x, y) {
    this.x = x;
    this.y = y;
 }  // 這里無分號

  toString() {
      return "(" + this.x + ", " + this.y + ")";
  }
}

class表達式

const MyClass = class Me {...}
// 該類的名字是MyClass而不是Me，Me只在Class內(nèi)部代碼可用

new命令生成對象實例時，調(diào)用該方法；

若無顯式的，則默認(rèn)添加一個空的constructor函數(shù)；

注意：無變量提升；

class ColorPoint extends Point {
  constructor(x, y, color) {
    super(x, y); // 調(diào)用父類的constructor(x, y), 必須要調(diào)用super()方法，因為子類需要用到父類的this
   this.color = color;
}

  toString() {
    return this.color + " " + super.toString(); // 調(diào)用父類的toString()
  }
}

子類的__proto__屬性，表示構(gòu)造函數(shù)的繼承，總是指向父類；

子類prototype屬性的__proto__屬性，表示方法的繼承，總是指向父類的prototype屬性；

子類繼承Object

A.proto === Object // true
A.prototype.proto === Object.prototype // true

不存在任何繼承

A.proto === Function.prototype // true
A.prototype.proto === Object.prototype // true

子類繼承null

A.proto === Function.prototype // true
A.prototype.proto === undefined // true

子類實例的__proto__屬性的__proto__屬性，指向父類實例的__proto__屬性，即子類的原型的原型，是父類的原型；

ES5中，先創(chuàng)建子類this，父類的屬性添加到子類上，由于父類內(nèi)部屬性無法獲取，導(dǎo)致無法繼承原生的構(gòu)造函數(shù)；

ES6中，先新建父類this，然后再用子類構(gòu)造函數(shù)修飾this，這使得父類的所有行為都可以繼承；

class MyClass {
 constructor() {
   // ...
  }
  get prop() {
      return "getter";
  }
  set prop(value) {
   console.log("setter: "+value);
  }
}

class Foo {
  constructor(...args) {
    this.args = args;
  }
  *Symbol.iterator {
      for(let arg of this.args) {
        yield arg;
    }
  }
}

在方法前加上static關(guān)鍵字，就表示該方法不會被實例繼承，而是直接通過類來調(diào)用；

父類的靜態(tài)方法，可以被子類繼承，也可用super對象調(diào)用；

（ES6規(guī)定，只有靜態(tài)方法，無靜態(tài)屬性，ES7草案有靜態(tài)屬性）

實例屬性

class MyClass {
  myProp = 42;
  constructor() {
      console.log(this.myProp); // 42
  }
}

靜態(tài)屬性

class MyClass {
  static myStaticProp = 42;
  constructor() {
    console.log(MyClass.myProp); // 42
  }
}

返回new命令作用于的那個構(gòu)造函數(shù)，如果構(gòu)造函數(shù)不是通過new命令調(diào)用的，new.target會返回undefined；

Class內(nèi)部調(diào)用new.target，返回當(dāng)前Class；

子類繼承父類時，new.target會返回子類；