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

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

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

直接運(yùn)行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的一個(gè)鉤子：設(shè)置完.babelrc文件后，在應(yīng)用入口加入require("babel-core/register")；

(2) 若有使用Iterator，Generator等全局對(duì)象及上方法：安裝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其實(shí)都是一個(gè)新的變量，最后輸出的是6；若用var i = 0，則將為10

注意：

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

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

// 2.暫時(shí)性死區(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(); // 報(bào)錯(cuò)

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

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

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

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

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

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

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

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

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

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

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

例子：

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

跳過(guò)：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)（左邊少），則忽略右邊；

右邊為非可遍歷，則報(bào)錯(cuò)；

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

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

注意：

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

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

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

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

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

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

注意：

“變量”部分的重新聲明（代碼見(jiàn)后）；

嵌套賦值（代碼見(jiàn)后）；

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

// --------- 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]

// 以下報(bào)錯(cuò)
var {foo: {bar}} = {baz:"baz"}; // 因?yàn)閒oo為undefined，則foo.bar會(huì)報(bào)錯(cuò)

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

// 正確的寫(xiě)法
({x} = {x: 1});
// 因?yàn)椤皗”在行首，會(huì)被理解為一個(gè)代碼塊，故而后面報(bào)錯(cuò)；

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

例子：

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

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

// 對(duì)象解構(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ù)對(duì)象的默認(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]

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

用途：保證對(duì)象屬性名的唯一性；

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

注意：

不能在Symbol()函數(shù)前面加new，否則報(bào)錯(cuò)，因?yàn)镾ymbol不是對(duì)象；

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

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

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

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

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

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

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

重新使用同一個(gè)Symbol，搜索有沒(méi)有s為名字的Symbol，有就返回，無(wú)則新建Symbol；這是全局的，即使不同iframe也用同一個(gè)Symbol；

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

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

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

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

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

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

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

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

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

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

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

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

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

new Set([array]) 

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

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

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

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

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

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

以下為遍歷方法

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

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

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

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

元素只能是對(duì)象；

其中的對(duì)象都是弱引用，垃圾回收機(jī)制不考慮其對(duì)象的引用，即若無(wú)其他對(duì)象引用該對(duì)象，則回收；

因無(wú)法引用該對(duì)象，故無(wú)法遍歷；

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

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

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

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

同一個(gè)鍵多次賦值，則會(huì)覆蓋；

讀取未知的鍵，返回undefined；

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

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所對(duì)應(yīng)的鍵值，然后返回整個(gè)Map結(jié)構(gòu)，若已存在鍵，則更新值；

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

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

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

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

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

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

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

沒(méi)有遍歷操作，也沒(méi)有size屬性；

無(wú)法清空；

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

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

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

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

class表達(dá)式

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

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

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

注意：無(wú)變量提升；

class ColorPoint extends Point {
  constructor(x, y, color) {
    super(x, y); // 調(diào)用父類的constructor(x, y), 必須要調(diào)用super()方法，因?yàn)樽宇愋枰玫礁割惖膖his
   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

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

ES5中，先創(chuàng)建子類this，父類的屬性添加到子類上，由于父類內(nèi)部屬性無(wú)法獲取，導(dǎo)致無(wú)法繼承原生的構(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)鍵字，就表示該方法不會(huì)被實(shí)例繼承，而是直接通過(guò)類來(lái)調(diào)用；

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

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

實(shí)例屬性

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è)構(gòu)造函數(shù)，如果構(gòu)造函數(shù)不是通過(guò)new命令調(diào)用的，new.target會(huì)返回undefined；

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

子類繼承父類時(shí)，new.target會(huì)返回子類；