摘要：和用法與類似，都是變量的聲明，但是具有塊級作用域。首先，當你聲明一個變量的時候，必須要初始化。將一個類數組對象和或可遍歷對象轉換成真正的數組不會改變原有對象，返回一個新的數組。

直接進入正題吧，盡量關于ES6的知識點都能涉及到。

let 和 const 用法與 var 類似，
都是變量的聲明，但是let具有塊級作用域。那是什么概念呢？看下面的例子。

for(var i = 0; i<10; ++i) {}
console.log(i); //10
for(let j = 0; j<10; ++j) {};
console.log(j); //undefined

上面的例子很明顯的展示了let的塊級作用域特性。
let不可以重復聲明，會提示我們:

let x = 10;let x = 20; // Uncaught SyntaxError: Identifier "x" has already been declared

當我們在全局聲明var的時候，我們可以通過window來獲取這個變量，但是let不可以，
你可以將let變量看其處在一個無形的作用域內。
我覺得在大部分時候都應該優先使用let,<不敢說任何時候，總怕來個例外..>。
關于const,顧名思義，不可改變，但這也要引用類型和基本類型。
首先，當你聲明一個const變量的時候，必須要初始化。

const x; //Uncaught SyntaxError: Missing initializer in const declaration

基本類型:

 `const x = 10;x = 20;//Uncaught TypeError: Identifier "x" has already been declared`   

引用類型: 就有點特殊了，我們可以對它帶有的屬性進行，只要不改變它的指向。

const obj = {name: "jack"};obj.name = "berry";obj.id = 1;// OK
obj = {}; //Uncaught TypeError: Assignment to constant variable.  

Array實在用到它的地方太多了，所以我們有必要對于它新添加的方法都來過一遍。

將一個類數組對象和或可遍歷對象轉換成真正的數組, 不會改變原有對象，返回一個新的數組。
類數組對象:有2種最常見的，我們都拿出來說下。

let x = document.querySelectorAll("*");
console.log(Array.isArray(x));// false
let y = Array.from(x);
console.log(Array.isArray(x));// false
console.log(Array.isArray(y));// true

   function foo () {
    console.log(Array.isArray(arguments));//false

    let args = Array.from(arguments, x => x * x);
    console.log(Array.isArray(args));//true
    console.log(args);//[1, 4, 9]
}
foo(1, 2, 3);

你可以看到我們在foo函數內對于arguments處理的時候 出現了 x => x*x,這也是ES6的新特性(箭頭函數)這我們將在后面提到。這邊我們可以發現Array.from不僅可以轉換成數組，而且可以對其中的值進行操作，我們來看下它完整的函數定義。
Array.from(arrayLike[, mapFn[, thisArg]])
第一個是必需參數，即要轉換的對象，第二個是可選參數，是一個函數，第三個也是可選參數，指定mapFn的this對象。
所以啦，我們拆出來看成Array.from(arrayLike).map(mapFn, thisArg)

arr.fill(value[, start = 0[, end = this.length]])

使用 value 填充從 start至end的區間，并且會修改原數組對象，并且返回自身， 隨便看個例子就好。

    let arr = [1, 2, 3];
    console.log(arr.fill(10, 0, 2)); //[10, 10, 3]
    console.log(arr); //[10, 10, 3]

Array.of(element0[, element1[, ...[, elementN]]])

將所有傳進來的參數都放進同一個數組，并且返回這個新的數組。

console.log(Array.of("ab", 1, null, undefined));//["ab", 1, null, undefined]

arr.find(callback[, thisArg])

callback中可以傳遞的參數和在ES5中引入的新方法,如map, filter一樣，有三個參數，分別是:value,index,array,同時, thisArg可以指定函數中的this
函數不會修改原數組，如果callback返回true,則退出，并返回當前value,如果遍歷結束，返回false,則返回undefined，我們看下下面這個例子就清楚了。

    let arr = [3, 5, 7, 8];
    let res1 = arr.find((value, index, arr) => value+index>=6);
    console.log(res1); //5
    let res2 = arr.find((value, index, arr) => value < index);
    console.log(res2); //undefined

恩。。。 看函數名字就知道了，上面我們剛提到的find()是找值，這個是找索引，如果找不到則返回-1，所以這邊我們就提下有這個函數，具體就不展開了。

arr.keys()

返回一個數組索引的迭代器, 額！！這下又牽扯出新知識了，迭代器。
一步一步來，先繼續這里的，可以將問題先留著，先看下它的用法。

    for (let i of [10, 20, 30].keys()) {
        console.log(i);//0, 1, 2
    }

上面，我們的例子會輸出0, 1, 2,這很好理解，就如我們上面說的，返回當前數組的索引，細心的話可以發現，我們for的遍歷采用了for ... of的方式，這也是ES6帶給我們的全新的遍歷方法，相比于for...in會在當前對象上所有屬性去循環，而它則是直接在數據上進行循環,對于for...of我們也暫且先不展開，因為它的篇幅也實在可以扯出太多。

arr.values()

和我們上面提到的方法對應，返回每個索引下對應的值，也是一個迭代器，我們可以用相同的for...of進行遍歷

    for (let i of [10, 20, 30].values()) {
        console.log(i);//10, 20, 30
    }

arr.entries()

返回一個迭代器，包含每一個數組中的 索引與其值， 也可以稱其為鍵值對

    for (let i of [10, 20, 30].entries()) {
        console.log(i);//[0, 10], [1, 20], [2, 30]
    }

關于 箭頭函數 其實我們在上面舉例的時候，就已經提到了，可能你已經感受到了它帶來的便捷，在 箭頭函數中的this指針繼承于它所在的詞法作用域。我們可以通過下面的例子來感受一下，這也是我們大力推行 箭頭函數 的一個原因,可以讓我們少考慮一點函數中的this指針帶來的困擾。

let obj1 = {
    arr: [1, 2, 3],
    foo () {
        setTimeout(function () {
            console.log(this.arr);
        }, 0);
    }
}
obj1.foo();//undefined


let obj2 = {
    arr: [1, 2, 3],
    foo () {
        let _self = this;
        setTimeout(function () {
            console.log(_self.arr);
        }, 0);
    }
}
obj2.foo();//[1, 2, 3]

let obj3 = {
    arr: [1, 2, 3],
    foo () {
        setTimeout(() => {
            console.log(this.arr);
        }, 0);
    }
}
obj3.foo();//[1, 2, 3]

我們往常處理this指針帶來的問題可能會使用 第二種方法或者bind()這邊就不給出了，我們可以很清楚地對比得出，箭頭函數給我們帶來的好處。
對了，可能你發現了，在obj中，我對于foo屬性的值是函數時候的寫法，這也是一個能節省代碼量的方法，使用起來相當方便。

即便箭頭函數不需要參數，我們也必須用()來表示，只有在只有一個參數的情況下，我們才可以省略(),對于箭頭函數的返回值，有2種情況，當你沒有使用{}將包裹，并且只有單行表達式時，則默認以其作為返回值，反之則應顯示聲明return,一個特殊情況是對于對象字面量作為返回值時，始終應當將其用()包裹，否則將以 undefind 處理

console.log(["a"].map( () => {} )); // undefined
console.log(["a"].map( () => ({}) )); // Object
console.log(["a"].map( () => {
    return {};
})) // Object

看上去 似乎還是 第三種更直觀。。

它 沒有 arguments,也不可以對其進行new操作，它沒有自身的this指針，同時它永遠是匿名函數。

如果大家有興趣關于這方面更多知識，可以自行去以下網站，同時也是我有關ES6的資料來源。
MDN
ES6 in depth
極客學院-深度解析ES6

有任何錯誤，還請指正~~