摘要：它是用來作為回調函數使用的，主要是為了簡化回調函數的寫法。簡單用法，簡化回調我們都知道數組的并不是根據數值大小來排序的，需要排序時，要通過回調函數的形式來確定排序方式箭頭函數簡化。

let 特性：

不允許重復聲明

沒有變量提升（預解析）

塊級作用域（一對 {} 包括的區域稱為一個代碼塊，let 聲明的變量只在該代碼塊起作用）

例子1 ：簡單的打印數據

使用 var:

for(var i = 0; i<10 ; i++ ){
    setTimeout(()=>console.log(i)) // 執行10次，全都打印 10
}

使用 let:

for(let i = 0; i<10 ; i++ ){
    setTimeout(()=>console.log(i)) // 執行10次，打印 0 - 9
}

之前我們要實現這樣的打印，必須使用閉包：

for(var i = 0; i<10;i++){
    (function(j){
        setTimeout(()=>console.log(j)) // 執行10次，打印 0 - 9
    })(i)
}

例子二：在網頁中常常會有切換 tab ，展示對應的信息的需求，我們使用 var 來處理時，常常使用的自定義屬性，來保存點擊的索引。btns[i].index=i。用于找到對應的元素。：

html模板：

1
2
3
11111
22223
33333

js:

var btns = document.querySelectorAll("button")
var divs = document.querySelectorAll("div")
for (var i=0 ;i
使用 let：
var btns = document.querySelectorAll("button")
var divs = document.querySelectorAll("div")
for (let i=0 ;i
const 除了具備上述 let 的特性外，還有自己的一個特性：定義之后的值，是固定不變不能被修改的。
值得注意的是下面這兩種情況是不會報錯的：
{
    const a = {value:1}
    a.value = 2
    console.log(a) // {value:2}

    const b = [1,2,3]
    b.push(4)
    console.log(b) // [1,2,3,4]
}
解構賦值
ES6 允許按照一定的模式，從數組和對象中提取值，這樣就稱為解構
數組：按照對應的順序解構
{
    var arr = [[1,2,3],[4,5,6],[7,8,9]]
    var [a,b,c] = arr
    // a : [1,2,3]
    // b : [4,5,6]
    // c : [7,8,9]
    // 用法1
    var x = 1;
    var y = 2;
    [y,x] = [x,y]
    console.log(x,y) // 2 1
}
對象按照對應的名稱一一對應進行解析：
{
    var obj={
        get:function(){
            return "get"
        },
        value:1,
        data:[1,2,3],
        str:"string"
    }
    var {str,get,data} = obj
    console.log(str) // string
    console.log(get()) //get
    console.log(data) // [1,2,3]
}
模板字符串
模板字符串 是增強版的字符串，使用反引號（`）作為標識 。可以當做普通字符串使用，也可以用來定義多行字符串（會保留換行）。或者在字符串中嵌入變量。
在模板字符串，需要引用變量使用 ${變量名} 的形式。在 {}可以進行運算，也可以引用對象屬性。
{
    var name = "xiaoming"
    var age = 19
    var str = `my name is ${name} ,my age is ${age}`
    console.log(str) //"my name is xiaoming ,my age is 19"
}
擴展
Array.from(arrayLike[, mapFn[, thisArg]])

arrayLike : 想要轉換成真實數組的類數組對象或可遍歷對象。

mapFn : 可選參數，如果指定了該參數，則最后生成的數組會經過該函數的加工處理后再返回。

thisArg : 可選參數，執行 mapFn 函數時 this 的值。方法用于將兩類對象轉為真正的數組：類似數組的對象和可遍歷的對象（包括 ES6 新增的數據結構 Set 和 Map ）


{
    // NodeList對象
    let ps = document.querySelectorAll("p");
    Array.from(ps);
    // 將可迭代對象（Set 對象）轉換成數組
    Array.from(new Set(["foo", window]));       // ["foo", window]
    // 使用 map 函數轉換數組元素
    Array.from([1, 2, 3], x => x + x);      // [2, 4, 6]
    // 將類數組對象（arguments）轉換成數組
    (function () {
        var args = Array.from(arguments);
        return args;
    })(1, 2, 3);                            // [1, 2, 3]
}
而在這之前，我們要轉類數組對象，只能用這樣的形式: [].slice.call(ps)
當然或許你根本不需要轉，因為我們有 for of 了,只要有遍歷接口的類型，它就可以進行遍歷
（Set,String,Array,NodeList等等）
{    
    // NodeList對象
    let ps = document.querySelectorAll("p");
    for (let v of ps){
        console.log(v)
    }
    //當然你可能同樣需要下標： `arr.keys()`,`arr.values()`,`arr.entries()`
    for (let [i,item] of ps.entries()){
        console.log(i,item)
    }
}
Object.assign()：拷貝源對象自身的可枚舉的屬性到目標對象身上
{
    var obj = { a: 1 };
    var copy = Object.assign({}, obj);
    console.log(copy); // { a: 1 }
}
值得注意的是， Object.assign()執行的是淺拷貝。假如源對象的屬性值是一個指向對象的引用，它也只拷貝那個引用值。
{
    let a = { b: {c:4} , d: { e: {f:1}} }
    let g = Object.assign({},a)
    g.d.e = 32 // 設置 g.d.e 為 32
    console.log(g) // {"b":{"c":4},"d":{"e":32}}
    console.log(a) // {"b":{"c":4},"d":{"e":32}}
}
如果你需要的不是合并，而只是普通json對象的復制，建議使用 JSON.parse(JSON.stringify(a))，這樣不會有上面的副作用產生。
函數參數默認值。定義默認值得參數必須是尾參數，因為函數形參定義默認值后該參數可以被忽略
{
    function fn(a,b=2){
        return {a,b}
    }
    console.info(fn(1)) //{a: 1, b: 2}
}
rest參數：用于獲取獲取函數的多余參數。與參數默認值一樣，必須為尾參數
{
    function foo(a,b,...args){
        console.info(args)
    }
    foo(1,2,3,4,5,6) // [3, 4, 5, 6]
}
擴展運算符...：它好比 rest 參數的逆運算。可以將一個數組轉為用逗號分隔的參數序列。
{
    // 更好的 apply 方法，例如我們在算最大值的時候：
    var arr = [1,2,3,4,5]
    console.info(Math.max.apply(null,arr))
    console.info(Math.max(...arr)) // 使用擴展運算符
    console.info(Math.max(1,2,3,4,5)) // 最終都會被解析成這樣

    // 當然還能這樣用
    var str = "string"
    var arr = [...str,4,5] // ["s", "t", "r", "i", "n", "g", 4, 5]

}
箭頭函數 Arrow Functions：箭頭函數并不是用來替代現有函數而出現的，并且也無法替代。它是用來作為回調函數使用的，主要是為了簡化回調函數的寫法。
主要有三個特性：

箭頭函數自身沒有 this 。函數內的 this 指向箭頭函數 定義時所在的對象 ，而不是使用時所在的對象。

箭頭函數內部，不存在 arguments 對象

不可以當作構造函數，不可以使用 new 指令。


簡單用法，簡化回調：
{
    // 我們都知道數組的 sort 并不是根據數值大小來排序的，需要排序時，要通過回調函數的形式來確定排序方式 
    var arr = [7,8,9,10]
    arr.sort() // [10, 7, 8, 9]
    arr.sort(function(a,b){return a-b}) // [7, 8, 9, 10]
    arr.sort((a,b)=> a - b ) // 箭頭函數簡化。當僅有一條語句時，有一個隱式的 return 
}
沒有 arguments
{
    var foo = (a,b,c)=>{
        console.log(a,b,c)
        console.log(arguments)
    };
    foo(1,2,3)
    // 1 2 3
    // Uncaught ReferenceError: arguments is not defined      
}
不要在對象的方法中使用箭頭函數：
{
    window.name="window";
    var obj = {
        name:"obj",     
        getName: function(){
            console.log(this.name)
        }
    }
    obj.getName() // obj
    var getName = obj.getName
    getName() // window， this 總是指向調用者
    //-----------------
    var obj = {
        name:"obj",     
        getName: () =>{
            console.log(this.name)
        }
    }
    obj.getName() // window
    /**
        這里由于對象 a，并不能構成一個作用域。所以會再往上達到全局作用域，所以 this 指向 window..
     */
}