摘要：第二步每一個(gè)實(shí)例化好的對(duì)象上都有一個(gè)，它接受兩個(gè)參數(shù)，分別對(duì)應(yīng)成功和失敗的回調(diào)函數(shù)，并且這連個(gè)回調(diào)函數(shù)以之前傳遞出的結(jié)果作為實(shí)參。

1: Block Scope
1.1 變量的塊級(jí)作用域名

let 定義的變量擁有block的作用域
if(true){
    let a = 1;
    console.log(a); // 1
 }
console.log(a); // Uncaught ReferenceError: a is not defined

1.2 function的塊級(jí)作用域

if (true) {
    // Throws a syntax error in ES5, not so in ES6
    function printName() {
        // ...
    }
}

但是在ES6是合法的，并且擁有塊級(jí)作用域：

if (true) {
    console.log(typeof doSomething);        // "function"
    function printName() {
        // ...
    }
    printName();
}
console.log(typeof printName);            // "undefined"

2: Function接受可以設(shè)置默認(rèn)值的參數(shù), 剩余參數(shù)，以及擴(kuò)展參數(shù)
2.1 給參數(shù)設(shè)置默認(rèn)值

function printName(firstName, middleName="Roger", lastName){
  console.log(`${firstName} ${middleName} ${lastName}`);
}

printName("George"); // George Roger undefined
printName("George", undefined, "Waters"); // George Roger Waters
printName("George", null, "Waters"); // George null Waters

從上面的例子可以看出來，只有當(dāng)相應(yīng)的參數(shù)沒有傳值，或者明確傳入undefined時(shí)，才會(huì)使用參數(shù)的默認(rèn)值。

2.2 剩余參數(shù)（rest parameters）

function printName(name, ...keys) {
  console.log(keys); // ["a", "b"]
  console.log(arguments.length); // 3
}
printName("hehe", "a", "b");
console.log(printName.length); // 1

剩余參數(shù)的語法是三個(gè)點(diǎn)（...）跟著一個(gè)變量名，它代表從某個(gè)位置開始到最后的所有剩余參數(shù)，這個(gè)變量是一個(gè)數(shù)組，元素就是每一個(gè)剩余參數(shù)。
并且我們也可以看得出來，剩余參數(shù)的這種語法，對(duì)arguments.length 和function本身的length并沒有影響。

3: Function的箭頭函數(shù)形式：

var sum = (num1, num2) => num1 + num2;

// effectively equivalent to:
var getName = function() {
    return "Nicholas";
};

上面只是一個(gè)很簡單的例子，更多的內(nèi)容會(huì)專門再寫文章延伸。

4: 新添加的基本類型 Symbol

一切的基本類型（primitive type）有：strings, numbers, booleans, null, and undefined。ES6新添加了一個(gè)symbol。

let firstName = Symbol();
let person = {};

person[firstName] = "Nicholas";
console.log(person[firstName]);     // "Nicholas"

5: ES6的面向?qū)ο笮抡Z法：Class

ES6添加了Class，可以像其他面向?qū)ο笳Z言一樣通過new一個(gè)類型來創(chuàng)建一個(gè)實(shí)例：

class Printer {

// equivalent of the PersonType constructor
    constructor(name) {
        this.name = name;
    }

// equivalent of PersonType.prototype.sayName
    printName() {
        console.log(this.name);
    }
}

let printer = new Printer("John");
printer.printName();   // "John"

console.log(printer instanceof Printer);     // true
console.log(printer instanceof Object);          // true

console.log(typeof Printer);                    // "function"
console.log(typeof Printer.prototype.printName);  // "function"

6: JS模塊化編程的支持 import

ES6之前如果想要對(duì)JS模塊化編程，必須借助第三方庫，例如require.js或者browserify.js。但是ES6卻進(jìn)行了原生的支持，再也不需要借用第三方庫了。
首先，export

// this function is private to the module
function subtract(num1, num2) {
    return num1 - num2;
}

// define a function...
function multiply(num1, num2) {
    return num1 * num2;
}

// ...and then export it later
export { multiply };

以上代碼定義在一個(gè)js文件里面，比方說example.js
對(duì)于想要被別人用的方法，可以export出去，同時(shí)可以不export本身的私有函數(shù)。
然后，import
然后在另外一個(gè)js文件里，我想用example.js里的mutiply方法，那么我就在我的js文件里面import就行了：

    import { multiply } from "./example.js";

接下來我就可以在我的js文件里面調(diào)用multiply這個(gè)方法了，就像java一樣。

7: ES6的異步編程Promise

在ES6之前，我們要利用promise來異步編程，必須借助第三方的庫，比方說Promises.js,Q.js.但是現(xiàn)在ES6對(duì)Promise實(shí)現(xiàn)了原生的支持，我們也就不再需要引用第三方庫了.來看一個(gè)ES6原生promise的例子：

//第一步：實(shí)例化一個(gè)Promise對(duì)象
let promiseA = new Promise(function(resolve, reject){
  if(true){
    resolve({name: "nana", age: "19"});
  }else{
    reject({code: "222", message: "hehe"});
  }    
});

let resolveF = function(student){
  console.log(`name: ${student.name}`);
  console.log(`age: ${student.age}`);
}

let rejectF = function(error){
    console.log(error.code);
}

//第二步，調(diào)用Promise對(duì)象上的then()指定異步操作成功和失敗時(shí)候的回調(diào)函數(shù)
promiseA.then(resolveF, rejectF); 

第一步：通過new實(shí)例化一個(gè)Promise，它接受一個(gè)函數(shù)作為參數(shù)。這個(gè)函數(shù)有兩個(gè)參數(shù)：
分別在異步操作成功和失敗的時(shí)候調(diào)用，并且把異步操作的結(jié)果作為接下來的回調(diào)函數(shù)的參數(shù)傳出去。
第二步：每一個(gè)實(shí)例化好的promise對(duì)象上都有一個(gè)then（），它接受兩個(gè)參數(shù)，分別對(duì)應(yīng)promise成功和失敗的回調(diào)函數(shù)，并且這連個(gè)回調(diào)函數(shù)以之前promise傳遞出的結(jié)果作為實(shí)參。所以如代碼所示，在resolveF(student)函數(shù)里，我們拿到的student對(duì)象就是之前在promiseA里面resolve(student)傳遞出來的student對(duì)象。

8: 字符串模版（template strings）

let firstName = "John";
let middleName = "Winston";
let fullName = `${firstName} ${middleName} Lennon`;
console.log(fullName);  //John Winston Lennon

語法很簡單：
1: 把字符串模版包在一對(duì)后引號(hào)（｀｀），注意不是單引號(hào)（‘’）里面
2: 通過${variable}對(duì)變量取值

PS: 后引號(hào)（｀）就是如下圖所示的［esc］鍵正下方的那個(gè)和波浪號(hào)（～）在一起的鍵

9: 解構(gòu)（deconstruction）

let fullName = {
  firstName: "John",
  middleName: "Winston",
  lastName: "Lennon"
};

let {firstName, lastName} = fullName;
console.log(firstName); //John
console.log(lastName); //Lennon

以上是一個(gè)對(duì)對(duì)象解構(gòu)的例子。對(duì)于對(duì)象來說，它是按照與對(duì)象的key的名字一一對(duì)應(yīng)的方式解構(gòu)賦值的。

10: for ...of
for ...of 用來對(duì)數(shù)組或者對(duì)象進(jìn)行循環(huán)，每次得到每個(gè)元素的值value，與for...in的區(qū)別的是，后者每次得到的是數(shù)組的下標(biāo)index或者對(duì)象的key。

let fullName = ["John", "Winston", "Lennon"]
for(let n of fullName) {
  console.log(n); // John Winston Lennon
}

for(let n in fullName){
  console.log(n); // 0 1 2
}

本來一開始想寫一個(gè)概覽，但是寫著寫著就覺得這樣的半壺水好沒有意思。所以這篇文章，就此打住，之后還是針對(duì)每一點(diǎn)都具體地來寫寫吧。