摘要：第二步每一個實例化好的對象上都有一個，它接受兩個參數，分別對應成功和失敗的回調函數，并且這連個回調函數以之前傳遞出的結果作為實參。

1: Block Scope
1.1 變量的塊級作用域名

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

1.2 function的塊級作用域

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

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

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

2: Function接受可以設置默認值的參數, 剩余參數，以及擴展參數
2.1 給參數設置默認值

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

從上面的例子可以看出來，只有當相應的參數沒有傳值，或者明確傳入undefined時，才會使用參數的默認值。

2.2 剩余參數（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

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

3: Function的箭頭函數形式：

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

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

上面只是一個很簡單的例子，更多的內容會專門再寫文章延伸。

4: 新添加的基本類型 Symbol

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

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

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

5: ES6的面向對象新語法：Class

ES6添加了Class，可以像其他面向對象語言一樣通過new一個類型來創建一個實例：

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之前如果想要對JS模塊化編程，必須借助第三方庫，例如require.js或者browserify.js。但是ES6卻進行了原生的支持，再也不需要借用第三方庫了。
首先，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 };

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

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

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

7: ES6的異步編程Promise

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

//第一步：實例化一個Promise對象
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);
}

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

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

8: 字符串模版（template strings）

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

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

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

9: 解構（deconstruction）

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

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

以上是一個對對象解構的例子。對于對象來說，它是按照與對象的key的名字一一對應的方式解構賦值的。

10: for ...of
for ...of 用來對數組或者對象進行循環，每次得到每個元素的值value，與for...in的區別的是，后者每次得到的是數組的下標index或者對象的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
}

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