ES6中對字符串、函數、對象、數組等都舉行了擴大，以為目標呢就是完美一下JS所為門外漢詬病的一些偽bug.實在個人以為不完美的JS才是真的美，什麼東西都無懈可擊了就顯得不夠風趣了。好了，接下來又要最先拾人涕唾了…

重要解說:

1. 擴大運算符…
2. Array.from()
3. Array.of()
4. Array.prototype.find() 和 Array.prototype.findIndex() –經常運用

1.擴大運算符… 用於將數組轉為逗號分開的參數序列

如: …[1,2,3] => 1,2,3 –只限一維轉換,這類轉換隻需放進函數中挪用才有意義，不能零丁存在

基本用法:
   function plus(x,y){
        return x+y;
    }

    plus(...[3,7]);
    //10
    plus(3,...[7])
    plus(...[3],7)
    //能夠天真的置於函數參數中恣意位置，只需依據傳進的數據舉行剖析即可。
    
    //Array原生push要領(可向數組末端增加一個或多個元素,遞次增加，且不建立新數組，直接修正原數組)
    let arr = [1,2,3];
    arr.push(4,5); //直接傳參
    arr // [1,2,3,4,5]

    //運用擴大的體式格局:傳入一個數組，舉行拼接
    arr.push(...[6,7,8]);
    arr //[1,2,3,4,5,6,7,8]
    

運用:
    i.數組的淺拷貝
        let arr = [12,34,56];

        let arr2 = [...arr];
        let [...arr3] = arr;
        arr2 // [12,34,56]
        arr3 // [12,34,56]

        arr2 == arr 
        //false

    ii.兼并數組
        [...arr,...arr2,...arr3]
        //[12, 34, 56, 12, 34, 56, 12, 34, 56]

    iii.連繫解構賦值，天生盈餘數組 -- 擴大運算符只能置於參數末了
        let [one,...rest] = [1,2,3,4,5];
        one // 1
        rest // [2,3,4,5]

    iv. 擴大字符串成數組 --以為這個彷佛沒啥用,'babe'.split('')也能夠
        [...'babe']
        //["b", "a", "b", "e"]
        //不過阮先生的書上說擴大運算符的寫法能夠辨認四個字節的Unicode字符
        //有相干需求能夠運用這類體式格局剖解字符串

    v. 完成了Iterator接口的對象均能夠運用擴大運算符轉化成真正的數組(關於Iterator下次再寫)
        
        function convert2Arr(){
          return [...arguments];
        }
        
        let result = convert2Arr(1,2,3,4,5);
        result // [1,2,3,4,5]

2.Array.from()

用於將類數組對象、可遍歷的對象轉為真正的數組(類數組對象特性:屬性為非負整數、存在length屬性、length>=0)

//類數組對象
let obj = {
    0:'hello',
    1:'world',
    4:'outof bounds data',
    length:3   //由於length不能動態轉變，隨便賦值，末了獲得的數組長度就是其值
}
Array.from(obj);
// ["hello", "world", undefined]
//依據屬性名對應到數組的index,凌駕length部份捨棄。沒有對應的屬性，置為undefined

//完成了Iterator接口的數據結構
let str = 'babe';
Array.from(str);
// ["b", "a", "b", "e"]
[...str]
// ["b", "a", "b", "e"]
//嗯，以為如今JavaScript向著更幸運的方向生長了，條條大路通羅馬。

注重:
    Array.from()是一個很不嚴謹的角色，只需對象含有length屬性，且值為正整數就可以轉
    不保證轉出來的東西質量是不是符合要求。
    Array.from({user:'babe',length:5})
    // [undefined, undefined, undefined, undefined, undefined]
        
    Array.from()可吸收第二個參數，用於對數組的每一項舉行處置懲罰並返回
    Array.from([1,2,3],x=>x*x)
    // [1, 4, 9]
        
    Array.from([1,2,3],x=>{x*x})
    //[undefined, undefined, undefined]  --牢記處置懲罰函數中一定要返回
        
    Array.from()還可吸收第三個參數，如許在處置懲罰函數中就可以夠運用傳進去的對象域中的值
    let that = {
        user:'babe'
    }
    let obj = {
        0:'babe',
        1:'zhangsan',
        2:'lisi',
        length:3
    }
    let result = Array.from(obj,(user) =>{
        if(user == that.user){
            return user;
        }

        return 0;
    },that);
    result //["babe", 0, 0]

3.Array.of()

用於將一組值轉換為數組，存在的意義是替換以組織函數的情勢建立數組，修複數組建立因參數不一致致使表現情勢差別的偽bug.

//原始體式格局
new Array()
// []
new Array(2)
// [empty × 2]
new Array(1,2,3,4,5)
// [1, 2, 3, 4, 5]

//先進改進體式格局
Array.of();
// []
Array.of(2);
// [2]
Array.of(1,2,3,4,5);
// [1, 2, 3, 4, 5]

4.Array.prototype.find() 和 Array.prototype.findIndex()要領 –經常運用

find要領用於查找第一條符合要求的數據，找到返回該數據，不然返回undefined; findIndex則用於找到第一條符合要求的數組位置，找到返回index,不然返回-1;—-這兩個要領都能夠運用indexOf替換，只是比indexOf更邃密(能夠查找NaN所在位置)

let result = [
    {extractId:1,sec:'Fi900'},
    {extractId:2,sec:'Fi901'},
    {extractId:3,sec:'Fi902'},
    {extractId:4,sec:'Fj900'},
    {extractId:5,sec:'Fj901'}
];

result.find(obj => obj.sec == 'Fi902')
// {extractId: 3, sec: "Fi902"}
result.findIndex(obj => obj.sec == 'Fi902')
// 2

//這個還要記着一個處置懲罰函數的吸收參數遞次，依次為:當前值、當前位置、原始數組
result.find((val,index,arr)=>{...});
result.findIndex((val,index,arr)=>{});
//此兩個要領都可吸收第二個參數，傳進去一個作用域對象,然後在處置懲罰函數中能夠運用傳入的對象
let scope = {extractId:2};
result.findIndex(item=>item.extractId == scope.extractId,scope);
// 1

本日就先寫到這裏了(每次都有點有頭無尾，引見的也只是我感興趣的點，今後只管全，然後有側重點)，假如bug請斧正Thanks♪(･ω･)ﾉ