會改變自身的方法：##

array.copyWithin（target, start [, end = this.length]）【有兼容性問題】
用于在數(shù)組內的替換操作，即替換元素和被替換元素都是數(shù)組內的元素
參數(shù)皆為整數(shù)，允許start，end為負數(shù)（倒數(shù)第n個）

array.fill(value [,statrt = 0[, end = this.length]])
將數(shù)組中指定區(qū)間的所有元素的值，都替換成value
start，end允許為負值，同上

array.pop()
刪除一個數(shù)組中的最后一個元素，并且返回這個元素

array.push(element1, ...elementN)
添加一個或多個元素到數(shù)組的末尾，并返回數(shù)組新的長度

array.reverse()
前后顛倒數(shù)組中元素的位置，第一個元素會成為最后一個

array.shift()
刪除數(shù)組的第一個元素，并返回這個元素

array.unshift(element1, ...elementN)
在數(shù)組的開頭插入一個或多個元素，并返回數(shù)組的新長度

array.sort([function(a, b)])
對數(shù)組的元素做原地的排序，并返回這個數(shù)組。sort可能不穩(wěn)定，默認按照字符串的unicode碼位點排序

記a和b是兩個將要被比較的元素：

• 如果函數(shù)function（a， b）返回值小于0， 則a會排在b之前
• 如何函數(shù)返回值等于0， 則a和b的相對位置不變（并不被保證）
• 如果函數(shù)返回值大于0，則a會排在b之后
• 比較函數(shù)輸出結果必須穩(wěn)定，否則排序的結果將是不確定的

array.splice(start, deleteCount[, item1[, item2...])
在任意的位置給數(shù)組添加或刪除任意個元素（拼接），返回被刪除的元素組成的數(shù)組，沒有則返回空數(shù)組

start: 開始操作的索引
deleteCount：要移除的數(shù)組元素的個數(shù)
itemN:要添加進數(shù)組的元素，如果不指定，則splice只刪除數(shù)組元素

不會改變自身的方法##

array.concat(value1, value2.....)
將傳入的數(shù)組或非數(shù)組值與原數(shù)組合并，組成一個新的數(shù)組并返回

注意：concat方法在拷貝原數(shù)組的過程中，

• 對象引用（非對象直接量）：concat方法會復制對象引用放到組合的新數(shù)組里，原數(shù)組和新數(shù)組中的對象引用都指向同一個實際的對象，所以，當實際的對象被修改時，兩個數(shù)組也同時被修改
• 字符串和數(shù)字（是原始值，而不是包裝原始值的string和number對象）：concat方法會復制字符串和數(shù)字的值放到新數(shù)組里

一個栗子：

var arr1 = [1, 2, {a: 'test'}]
var arr2 = ['a', 'b', 'c']

var output = arr1.concat(arr2)
console.log(output) // output[2].a == 'test'
setTimeout(function(){
       arr1[2].a = 'has changed'
       console.warn(output)  //output[2].a == 'has changed'
}, 5000)

另一個栗子：

var arr1 = [1, 2, 3]
var arr2 = ['a', 'b', 'c']

var output = arr1.concat(arr2)
console.log(output) 
setTimeout(function(){
     arr1[2] = 99
     console.warn(output)      //output值并不會改變
 }, 5000)

將非數(shù)組值合并到數(shù)組里：

var alpha = ['a', 'b', 'c']
var output = alpha.concat(1, [2, 3]) //['a', 'b', 'c', 1, 2, 3]

array.includes(searchElement, [, fromIndex])[實驗性質，es7，可能會改變或刪除]
用來判斷當前數(shù)組是否包含某指定的值，如果是，則返回true，否則false

array.join([separator = ','])
將數(shù)組中的所有元素連接成一個字符串(默認用逗號作為分隔符，如果separator是一個空字符串，那么數(shù)組中的所有元素將被直接連接)
如果元素是undefined或者null，則會轉化成空字符串

array.slice([begin = 0 [, end = this.length - 1]])
把數(shù)組中一部分的淺復制（shallow copy）存入一個新的數(shù)組對象中，并返回這個新的數(shù)組
不修改原數(shù)組，只會返回一個包含了原數(shù)組中提取的部分元素的一個新數(shù)組
具體拷貝規(guī)則同concat函數(shù)

array.toString()
返回一個字符串，該字符串由數(shù)組中的每個元素的toString（）返回值經調用join（）方法連接（由逗號隔開）組成。

一個例子：

 var arr = ['abc', 2, {a: 'test'}]
 console.log(arr.toString())        //'abc,2,[object Object]'

array.toLocaleString()
返回一個字符串表示數(shù)組中的元素。數(shù)組中的元素將使用各自的toLocaleString方法轉化成字符串，這些字符串將使用一個特定語言環(huán)境的字符串（例如逗號）隔開

array.indexOf(searchElement[, fromIndex = 0])
返回指定元素能在數(shù)組中找到的第一個索引值，否則返回-1
fromIndex可以為負，表示從倒數(shù)第n個開始（此時仍然從前向后查詢數(shù)組）
使用“嚴格相等”（===）進行匹配

一個例子：

          var obj = {a: 'test'}
          var arr = ['a', 'b', {a: 'test'}]
          console.log(arr.indexOf(obj))     //-1

          var arr2 = [1, 'b', {a: 'test'}]
          console.log(arr2.indexOf('1'))      //-1

array.lastIndexOf(searchElement[, fromIndex = arr.length - 1])
返回指定元素在數(shù)組中的最后一個的索引，如果不存在則返回-1， 從數(shù)組的后面向前查找
同上

遍歷方法##

array.forEach((v, i, a) => {})
讓數(shù)組的每一項都執(zhí)行一次給定的函數(shù)
v表示當前項的值，i表示當前索引，a表示數(shù)組本身
forEach遍歷的范圍在第一次調用 callback前就會確定。調用forEach后添加到數(shù)組中的項不會被 callback訪問到。如果已經存在的值被改變，則傳遞給 callback的值是 forEach遍歷到他們那一刻的值。已刪除的項不會被遍歷到。

array.entries()
返回一個Array Iterator對象，該對象包含數(shù)組中每一個索引的鍵值對

一個例子：

var arr = ["a", "b", "c"];
var eArr = arr.entries();

console.log(eArr.next().value); // [0, "a"]
console.log(eArr.next().value); // [1, "b"]
console.log(eArr.next().value); // [2, "c"]

array.every(callback(v, i, a){})
callback只會為那些已經被賦值的索引調用，不會為那些被刪除或從來沒有被賦值的索引調用
和forEach函數(shù)類似
注意：array.every()返回一個布爾值，即對每個元素的callback函數(shù)結果作邏輯“&”操作

array.some()
使用方法同上，
注意：對每個元素的callback函數(shù)結果作邏輯“||”操作

array.filter((v, i, a) => {})
使用指定的函數(shù)測試所有元素，并創(chuàng)建一個包含所有測試通過的元素的新數(shù)組
callback函數(shù)返回一個布爾值，true即通過測試
callback只會在已經賦值的索引上被調用，對于那些已經被刪除或者從未被賦值的索引不會被調用
不會改變原數(shù)組

array.find((v, i, a) =>{})【有兼容性問題目前】
返回數(shù)組中滿足測試條件的第一個元素，如果沒有滿足條件的元素，則返回undefined

array.keys()
返回一個數(shù)組索引的迭代器（類似于array.entries()方法）

array.map((v, i, a) => {})
返回一個由原數(shù)組中的每個元素調用一個指定方法后的返回值組成的新數(shù)組
map 不修改調用它的原數(shù)組本身（當然可以在 callback 執(zhí)行時改變原數(shù)組）

array.reduce(callback[, initialValue])
該方法接收一個函數(shù)作為累加器（accumulator），數(shù)組中的每個值（從左到右）開始合并，最終為一個值
callback參數(shù)：
previousValue:上一次調用回調返回的值，或者是提供的初始值（initialValue）
currentValue: 數(shù)組中當前被處理的元素
index： index
array： 調用的數(shù)組
如果 initialValue 在調用 reduce 時被提供，那么第一個 previousValue 等于 initialValue ，并且currentValue 等于數(shù)組中的第一個值；如果initialValue 未被提供，那么previousValue 等于數(shù)組中的第一個值，currentValue等于數(shù)組中的第二個值。
一個例子

[0, 1, 2, 3, 4, 5].reduce((p, v, i , a) => {
  return p + v
})

//15

數(shù)組扁平化：

var flattened = [[0, 1], [2, 3], [4, 5]].reduce((a, b) => {
  return a.concat(b)
})
//flattened is [0, 1, 2, 3, 4, 5]

array.reduceRight()
使用同上，與reduce（）的執(zhí)行方向相反