一、簡單介紹一些陣列的方法：

1、Array.length：返回陣列的長度；

var arr = [4, 2, 6, 7, 3, 1, 5]
arr.length // 7

2、Array.join()：陣列每個元素用括號裡面的符號連線起來並返回一個字串；

arr.join() // "4,2,6,7,3,1,5"
arr.join('=') // "4=2=6=7=3=1=5"
arr.join(' ') // "4 2 6 7 3 1 5"

3、Array.reverse()：將陣列中的成員顛倒並返回逆序陣列，被呼叫陣列改變；

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

4、Array.sort()：陣列排序按升序排序，被呼叫陣列改變；

arr.sort() //[1, 2, 3, 4, 5, 6, 7]
//與reverse合用可得到降序
arr.sort.reverse() //[7, 6, 5, 4, 3, 2, 1]
console.log(arr) //[7, 6, 5, 4, 3, 2, 1]
['a', 'd', 'c', 'b'].sort() //["a", "b", "c", "d"]

5、Array.concat()：陣列的連線，可以將陣列b連線到arr之後,返回連線後的新陣列，被呼叫陣列不變；

var b = [8, 9, 10]
arr.concat(b) //[4, 2, 6, 7, 3, 1, 5, 8, 9, 10]
console.log(arr) //[4, 2, 6, 7, 3, 1, 5]
 

6、Array.push()：在陣列最後新增元素，返回新陣列的長度，被呼叫陣列改變；

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

7、Array.pop()：刪除陣列的最後一個元素，返回刪除的值，被呼叫陣列改變;

arr.pop() // 8
console.log(arr) //[4, 2, 6, 7, 3, 1, 5]

8、Array.unshift()：與push類似，只是它是在陣列頭部插入元素，返回新陣列的長度，被呼叫陣列改變；

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

9、Array.shift()：與pop類似，只是它是刪除陣列的第一個元素，返回刪除的值，被呼叫陣列改變；

arr.shift() // 8
console.log(arr) //[4, 2, 6, 7, 3, 1, 5]

10、Array.silce()：返回指定陣列的片段或子陣列，它有兩個引數，分別指定片段開始到結束的位置（注意不是序號，序號從0開始，位置從1開始），返回第一個引數指定位置（但不包含第一個引數指定位置）到第二個引數指定位置（含第二個引數指定位置）的片段，如果第二個引數不指定，則返回開始位置到最後的所有元素，被呼叫陣列不變；

arr.slice(1, 5) //返回第1個到第5個位置之間的片段[2, 6, 7, 3]
arr.slice(1) //返回第1個位置到最後的片段[2, 6, 7, 3, 1, 5]
console.log(arr) //[4, 2, 6, 7, 3, 1, 5]

11、Array.splice()：刪除或新增片段，第一個引數指定刪除的開始位置，第二個引數指定刪除元素個數，若第二個不指定則刪除開始位置到最後的所有元素，返回刪除的片段並改變被呼叫陣列，之後的所有引數均為新增的元素，新增到開始指定位置之後；

arr.splice(1,2) //刪除從第一個位置開始後面的兩個元素，返回刪除片段[2, 6],此時arr=[4, 7, 3, 1, 5]
arr.splice(2) //刪除從第一個位置之後的所有元素，返回[3, 1, 5],此時arr=[4, 7]
arr.splice(1,0, 'a', 'b') //在第一個位置後新增‘a’，‘b’元素，返回[],此時arr=[4, 'a', 'b', 7]
arr.splice(1, 2, [1, 2], 3) //返回['a', 'b'],此時arr=[4, [1, 2], 3, 7]，注意這與concat()不同，splice()插入的陣列本身而不是陣列中的元素

12、Array.toString()：將陣列中的所有元素轉換為字串，並用逗號連線為一個字串列表，該方法會無視所有分隔符號，強行轉化；

arr.toString() //與join()一致，返回"4,2,6,7,3,1,5"
['a', 'b', 'c'].toString() //與join(',')，返回"a,b,c"
[1, 2, [3, 4], 5].toString() //無視分隔符，返回"1,2,3,4,5"

13、Array.forEach()：遍歷陣列，將陣列中的每一個元素傳遞給forEach()中的引數，該方法的引數為一個函式，函式中有三個引數：當前陣列成員，當前成員索引值，原陣列本身；

arr.forEach((v, i, a) => {
    console.log(a[i] = v) //輸出七次true
})

14、Array.map()：陣列的“對映”，將陣列每一項傳給函式，並返回由函式返回值組成的陣列，原陣列不變；

var b = arr.map(x => {
    return x += 1
}) //所有元素自加1，此時b=[5, 3, 7, 8, 4, 2, 6]

15、Array.filter()：陣列“過濾”，將陣列每一項傳給函式，進行判斷，返回由判斷結果的true的元素組成的陣列，原陣列不變；

var b = arr.filter(x => {
    return x % 2 === 0
}) //返回陣列中的偶數陣列，b=[4, 2, 6]


var b = arr.filter(x => {
    return x % 2 === 1
}) //返回陣列中的奇數陣列,b=[[7, 3, 1, 5]

16、Array.every()和Array.some()：every()方法是將陣列每一項傳給函式，進行判斷，若所有結果都為true，則返回true，否則返回false，some()方法則只要有一個為true就返回true，否則返回false；

var b = arr.every(x => {
    return x < 8
}) //所有元素小於8，返回true
var b = arr.every(x => {
    return x < 7
}) //不是所有元素小於7，返回false

var b = arr.some(x => {
    return x < 2
}) //只有一個小於2，返回true
var b = arr.some(x => {
    return x < 1false
}) //沒有元素小於1，返回false

17、Array.reduce()和Array.reduceRight()：reduce可以翻譯為“化簡”，該方法有兩個引數，第一個為函式，函式可以傳入四個引數，第一個為當前累計操作的結果，其餘三個為：當前元素值、當前元素索引值、原陣列物件，該方法第二個引數為一個初始值，如果該引數未指定，則以原陣列第一個元素值為初始值；reduceRight()方法只是方向是從尾到頭，其他與前者一致；

var b = arr.reduce((s, v, i, a) => {
     return s += v
}) //一個累加器，b = 28 
//該函式原理為，先將初始值傳給s，s與傳入的第一個值做運算，將所得結果又作為下一次運算的初始值，以此類推，以上預設初始值為第一個元素
//若傳入一個引數,則初始值改變
var b = arr.reduce((s, v, i, a) => {
     return s += v
},10) //b = 38

18、Array.indexOf()和Array.lastIndexOf()：該方法傳入一個值，並從頭到尾檢索陣列，返回第一個具有該值的元素的索引值，如果沒有則返回-1；lastIndexOf()方法為從尾到頭檢索，返回索引值，沒有返回-1；

[1, 2, 2, 3, 3, 1].indexOf(2) //1

[1, 2, 2, 3, 3, 1].indexOf(4) //-1

[1, 2, 2, 3, 3, 1].lastIndexOf(2) //2

[1, 2, 2, 3, 3, 1].lastIndexOf(3) //4

[1, 2, 2, 3, 3, 1].lastIndexOf(4) //-1

二、ES6中新增的一些方法

1、Array.from()：該方法會將類陣列物件和可遍歷的物件轉化為陣列，比較典型的類陣列物件就是DOM操作的Nodelist以及函式的arguments，只要有length屬性的物件都可以用from()方法轉化為陣列；

<ul id="demo">
    <li></li>
    <li></li>
    <li></li>
    <li></li>
    <li></li>
    <li></li>
    <li></li>
    <li></li>
</ul>

var a = document.getElementsByTagName('li') // HTMLCollection(8) [li, li, li, li, li, li, li, li]

var b=Array.from(a) //轉化Nodelist集合，(8) [li, li, li, li, li, li, li, li]

function f(x, y, z) {
    console.log(Array.from(arguments))
}
f(1, 2, 3) //轉化arguments物件，返回[1,2,3]

var a = {
    0: 'a',
    1: 'b',
    2: 'c',
    length: 3
}
Array.from(a) //['a', 'b', 'c'] ，如果去掉length屬性返回undefined

var a = [1, 2, 3, 3, 2, 1]
var b = new Set(a) //陣列轉化為set結構
Array.from(b) //轉化set資料結構，返回[1,2,3]

2、Array.of()：將一組值轉化為陣列，類似於Array()，但是彌補了Array()一些缺陷；

Array() //[]
Array(1) //[],length為1，Array()括號內只有一個數時，該數表示陣列長度
Array(1,2,3) //[1,2,3]

Array.of() //[]
Array.of(1) //[1]
Array.of(1,2,3) //[1,2,3]

3、Array.find()和Array.findIndex()：引數為一個回撥函式，將每一個數組成員傳給回撥函式進行判斷，返回第一個結果為true的陣列成員，與indexOf()類似，只不過indexOf()返回的是索引值，後者返回的陣列成員並且如果全不符合則返回undefined，回撥函式同樣有三個引數：當前陣列成員、當前成員索引值、原陣列本身；findIndex()則與indexOf()不一樣的是findIndex()還可以找到NaN；

[1, 2, 3, 4, 5].find((v, i, a) => {
    return v > 4 //返回5
}
[1, 2, 3, 4, 5].find((v, i, a) => {
    return v > 5 //返回undefined
}
[1, 2, 3, 4, 5].findIndex((v, i, a) => {
    return v < 4 //返回2
})
[1, 2, 3, 4, 5].findIndex((v, i, a) => {
    return v < 1 //返回-1
})

[NaN].indexOf(NaN) //-1
[NaN].findIndex(y => Object.is(NaN, y)) //0

4、Array.fill()：給定一個值，用來填充原陣列，接受三個引數，第一個指定用於替換的值，第二個指定替換開始位置，第三個指定替換結束位置，開始位置預設為0，結束位置如果不指定則預設開始到陣列最後，填充位置包括結束位置；

['a', 'b', 'c'].fill(1) //[1, 1, 1]

['a', 'b', 'c'].fill(1, 2) //["a", "b", 1]

['a', 'b', 'c'].fill(1, 1, 2) //["a", 1, "c"]

['a', 'b', 'c'].fill([1, 2], 1, 2) //可以為陣列，["a", [1, 2], "c"]

['a', 'b', 'c'].fill({hello: 'world'}, 1, 2) //["a", {hello: 'world'}, "c"]

5、Array.includes()：檢索陣列中是否包含某個值，是則返回true，否則返回false，它有兩個引數，第一個為檢索的值，第二個為開始檢索的位置，如果第二個引數為負數則從倒數位置開始向後檢索；

[1, 2, 3, 4, 5].includes(2) //true

[1, 2, 3, 4, 5].includes(2, 1) //true

[1, 2, 3, 4, 5].includes(2, 2) //false

[1, 2, 3, 4, 5].includes(2, -1) //從第倒數1個位置開始向後檢索，返回false

[1, 2, 3, 4, 5].includes(2, -4) //從第倒數4個位置開始向後檢索，返回true

6、Array.copyWithin()：將陣列中的某個成員或某個片段覆蓋指定位置後的相同個數的成員，該方法有三個引數，第一個為開始替換的位置，第二個為擷取成員的位置，預設為0，負數則為倒數位置，第三個為擷取成員結束位置，預設為最後，負數為倒數位置；

[1, 2, 3, 4, 5].copyWithin(1, 2, 4) //擷取第2個位置到第4個位置的片段[3, 4]，覆蓋第1個位置之後的相同個數的成員，返回[1, 3, 4, 4, 5]

[1, 2, 3, 4, 5].copyWithin(1, 2)  //擷取第2個位置到最後位置的片段[3, 4, 5], 覆蓋第1個位置之後的相同個數的成員，返回[1, 3, 4, 5, 5]

[1, 2, 3, 4, 5].copyWithin(1, -2) //擷取倒數第2個位置到最後位置的片段[4, 5]，覆蓋第1個位置之後的相同個數的成員，返回[1, 4, 5, 4, 5]

三、陣列一些簡單的用法

1、陣列去重

1）indexOf()方法

var a = [1, 2, 3, 3, 2, 1]
var b = []
a.forEach(x => {
    if (b.indexOf(x) === -1) {
        b.push(x)
    }
}) //b=[1, 2, 3]

2）Set方法

var a = [1, 2, 3, 3, 2, 1]
var b = new Set(a)
var c = Array.from(b) //[1, 2, 3]

//有點麻煩，封裝為一個函式
function Unique(arr){
    return Array.from(new Set(arr))
}
Unique(a) //[1, 2, 3]

//或者用ES6擴充套件運算子（...）
var unique=[...new Set(arr)] //[1, 2, 3]

2、求陣列最大最小值

//推薦簡單的方法
//由於陣列沒有Math.max()方法，但可以想辦法把陣列成員轉為單個的值

var arr = [4, 2, 6, 7, 3, 1, 5]

Math.max.apply(null, arr) //7

//ES6方法

Math.max(...arr) //7

3、後續遇到好的方法還會更新。。。