陣列（Array)常用方法

實體方法

arr.forEach(callback)遍歷陣列，沒有回傳值

callback的引數： item--當前元素 index --當前元素對應的索引號 array --原陣列

 let arr = [1, 2, 3, 4, 5]
    arr.forEach((item, index, array) => {
      item = item * 2
      console.log(`item:${item}    index:${index}     array:${array}`)
    })
    // item:2    index:0     array:1,2,3,4,5
    // item:4    index:1     array:1,2,3,4,5
    // item:6    index:2     array:1,2,3,4,5
    // item:8    index:3     array:1,2,3,4,5
    // item:10   index:4     array:1,2,3,4,5

arr.find(callback)遍歷查找首次滿足條件的值，并回傳值

callback的引數： item--當前元素 index --當前元素對應的索引號 array --原陣列

let arr = [7, 8, 9, 10, 5]
    let a = arr.find((item, index, array) => item > 3)
    console.log(a)  // 0

arr.findIndex(callback)遍歷查找首次滿足條件的值，并回傳索引號

callback的引數： item--當前元素 index --當前元素對應的索引號 array --原陣列

 let arr = [7, 8, 9, 10, 5]
    let a = arr.findIndex((item, index, array) => item > 3)
    console.log(a)  // 7

arr.some(callback)遍歷查找是否存在滿足條件的值，存在就回傳true，否則就回傳false

callback的引數： item--當前元素 index --當前元素對應的索引號 array --原陣列

let arr = [7, 8, 9, 10, 5]
    let a = arr.some((item, index, array) => item > 11)
    console.log(a)  // false
    let b = arr.some((item, index, array) => item < 11)
    console.log(b)  // true

arr.every(callback)遍歷查找是否所有元素都滿足條件，都滿足回傳true，否則回傳false

callback的引數： item--當前元素 index --當前元素對應的索引號 array --原陣列

let arr = [7, 8, 9, 10, 5]
    let a = arr.every((item, index, array) => item > 6)
    console.log(a)  // false
    let b = arr.every((item, index, array) => item < 11)
    console.log(b)  // true

arr.filter(callback) 用于遍歷篩選滿足條件的元素(過濾陣列)，把所有滿足條件的元素回傳到新陣列

callback的引數： item--當前元素 index --當前元素對應的索引號 array --原陣列

let arr = [7, 8, 9, 10, 5]
    let a = arr.filter((item, index, array) => item > 6)
    console.log(a)  // [7, 8, 9, 10]
    let b = arr.filter((item, index, array) => item < 10)
    console.log(b)  //[7, 8, 9, 5]

arr.map(callback)用于遍歷陣列每個元素讓其執行一遍回呼函式，把所有結果放到新陣列回傳

callback的引數： item--當前元素 index --當前元素對應的索引號 array --原陣列

 let arr = [1, 2, 3, 4, 5]
    let a = arr.map((item, index, array) => {
      item = item * 3
    })
    console.log(a)//[3,6,9,12,15]

arr.reduce(callback)用于將陣列中的每個元素執行一遍回呼函式，并回傳計算結果

callback的引數： acc--累計器（累計回呼的回傳值; 它是上一次呼叫回呼時回傳的累積值，或者是提供的初始值） cur--當前元素 index--當前索引值 array --原陣列

 let arr = [1, 2, 3, 4]
    let arr1 = arr.reduce((acc, cur, index, array) => { return acc + cur })
    console.log(arr1)//10
    //callback 被呼叫三次，每次呼叫的引數和回傳值如下表
    // 第一次呼叫     acc=1    cur=2    index=1  arr=[1, 2, 3, 4]   return=3
    // 第二次呼叫     acc=3    cur=3    index=2  arr=[1, 2, 3, 4]   return=6
    // 第三次呼叫     acc=6    cur=4    index=3  arr=[1, 2, 3, 4]   return=10

    let arr2 = arr.reduce((acc, cur, index, array) => { return acc + cur }, 10)
    console.log(arr2)//20
    //callback 被呼叫四次，每次呼叫的引數和回傳值如下表
    // 第一次呼叫     acc=10    cur=1    index=0  arr=[1, 2, 3, 4]   return=11
    // 第二次呼叫     acc=11    cur=2    index=1  arr=[1, 2, 3, 4]   return=13
    // 第三次呼叫     acc=13    cur=3    index=2  arr=[1, 2, 3, 4]   return=16
    // 第四次呼叫     acc=16    cur=4    index=3  arr=[1, 2, 3, 4]   return=20

arr.sort() 對陣列的元素進行排序，并回傳陣列，默認排序順序是在將元素轉換為字串，然后比較它們的UTF-16代碼單元值序列時構建的，根據公式可按照降序和升序比較

let arr = [2, 10, 6, 1, 4, 22, 3]
    console.log(arr.sort())   // [1, 10, 2, 22, 3, 4, 6]
    let arr1 = arr.sort((a, b) => a - b)
    console.log(arr1)   // [1, 2, 3, 4, 6, 10, 22]
    let arr2 = arr.sort((a, b) => b - a)
    console.log(arr2)  // [22, 10, 6, 4, 3, 2, 1]

arr.indexOf()查找在陣列中首次出現的索引位置，如果找到就會回傳首次出現的索引值，找不到就會回傳-1

arr.lastIndexOf()查找在陣列中最后一次出現的索引位置，如果找到就會回傳首次出現的索引值，找不到就回傳-1

let arr = ['a', 'b', 'c', 'a', 'b', 'c', 'd']
    console.log(arr.indexOf('a'))   // 0
    console.log(arr.indexOf('f'))   // -1
    console.log(arr.lastIndexOf('a'))   //3

arr.pop()洗掉陣列的最后一項，并回傳洗掉的元素

arr.shift()洗掉陣列的第一項，并回傳洗掉的元素

let arr = [1, 2, 3, 4, 5]
    console.log(arr.pop())     // 5
    console.log(arr)  //[1,2,3,4]
    console.log(arr.shift())//1
    console.log(arr)//[2,3,4]

arr.splice(）洗掉或替換陣列中一項或幾項元素，并回傳洗掉或替換的元素
第一個引數：從哪個索引值開始；第二個引數：洗掉或替換幾個；第三個引數：替換為什么

let arr = [1, 2, 3, 4, 5]
    let re = arr.splice(1, 1, 'aaa')//替換
    console.log(re);//[2]
    console.log(arr);//[1,'aaa',3,4,5]
    let res = arr.splice(1, 1)//洗掉
    console.log(res);//['aaa']
    console.log(arr)//[1,3,4,5]

arr.push(要添加的元素)從陣列最后的位置追加元素，并回傳新陣列的長度

arr.unshift(要添加的元素)從陣列最前面追加元素，并回傳新陣列的長度

let arr = [1, 2, 3, 4, 5]
    console.log(arr.push(5))   // 6
    console.log(arr) // [1,2,3,4,5,5]
    console.log(arr.unshift(1))   // 7
    console.log(arr) // [1,1,2,3,4,5,5]

arr.reverse() 將陣列反轉,回傳反轉后的陣列

let arr = [1,2,3,4,5]
console.log(arr.reverse())    // [5,4,3,2,1]
console.log(arr)    // [5,4,3,2,1]

arr.concat() 連接兩個陣列 回傳值為連接后的新陣列

let arr = [1,2,3,4,5]
console.log(arr.concat([1,2]))  // [1,2,3,4,5,1,2]
console.log(arr)   // [1,2,3,4,5]

靜態方法

Array.isArray（）判斷是否為陣列，回傳布林值

    let arr = [1, 2, 3, 4, 5]
    let a = Array.isArray(arr)//true
    let str = 'aaa'
    let b = Array.isArray(str)//false

Array.from（）把有length屬性的偽陣列轉成真陣列

let o = {
      0: 'a',
      1: 'b',
      2: 'c',
      3: 'd',
      length: 4
    }
    let arr = Array.from(o)
    console.log(arr);//['a','b','c','d']
    let lis = document.querySelectorAll('li')
    let array = Array.from(lis)
    console.log(array);//[li,li,li]