### array
* 數組轉換方法
* 棧方法
* 隊列方法
* 排序方法
* 操作方法
* 位置方法和查找方法
* 迭代方法
* 歸并方法
* * * * *
> 除Object類型外，Array可能是ECMAScript中最常用的類型了，而且ECMAScript中的數組與其他語言中的數組有著很大的區別，ECMAScript中的數組的每一項都可以保存任何類型的數據，而且，ECMAScript中對數組大小是可以動態調動的，即可隨著數據的增加縮減自動容維。在javascript中定義數組有如下幾種方式：
~~~
/*構造函數方式創建*/
let a = new Array() //創建一個空數組
let b = new Array(3) //創建一個長度為3的數組
/*字面量方式創建*/
let c = [] //創建一個空數組
let c = [1,2,3,4] //創建一個長度為4的數組，其中每一項包含一個數字
~~~
> 與對象一樣，在使用數組字面量定義數組時，不會調用Array()構造函數
#### 數組轉換方法
> 如之前所述，所有對象都具有toLocaleString() / toString() / valueOf()方法，其中，調用數組對toString()方法會返回數組中每個值的字符串形式拼接而成的一個以逗號分隔帶字符串。而調用valueOf()返回的還是原數組，而toLocaleString()一般返回的值都與toString()相同，如下：
~~~
let c = [1,2,3,4]
console.log(c.toString()) // 1,2,3,4
console.log(c.valueOf()) // [1,2,3,4]
console.log(b.toLocaleString()) // 1,2,3,4
~~~
> 同時ES6也為我們提供了將數據結構轉為數組的方法Array.from，它可以將類似數組的對象（array-like object）和可遍歷（iterable）的對象（包括ES6新增的數據結構Set和Map），代碼如下：
~~~
let arrayLike = {
'0': 'a',
'1': 'b',
'2': 'c',
length: 3
};
// ES5的寫法
var arr1 = [].slice.call(arrayLike); // ['a', 'b', 'c']
// ES6的寫法
let arr2 = Array.from(arrayLike); // ['a', 'b', 'c']
~~~
> ES6新增Array.of方法，用于將一組值轉換為數組。代碼如下：
~~~
Array.of(3, 11, 8) // [3,11,8]
~~~
> Array.of基本上可以用來替代Array()或new Array()，并且不存在由于參數不同而導致的重載。它的行為非常統一。Array.of總是返回參數值組成的數組。如果沒有參數，就返回一個空數組。
#### 棧方法
> 在理解棧方法之前，先來理解一下“棧”的數據結構，即“最新添加的項最早被移除”。而棧中“項”的推入（數組中的插入）和彈出（數組中的移除），只發生在一個位置“棧的頂部”，ECMAScript專門提供了數組的push()方法和pop()方法來實現類似棧的行為。push()方法可以接收人意數量的參數（上面已經說過了，javascript數組對存儲的數據類型沒有限制），把他們逐個添加到數組末尾，并返回修改后的數組長度。pop()方法則是刪除數組的最后一項，減少數組的length值，然后返回移除的項。如下：
~~~
let w = ["andy","tom"]
console.log(w.pop()) // 返回字符串tom，此時數組中只有[ "andy" ] 一項了
console.log(w.push("tom","jack")) //返回數組w的length值3，此時數組已變為[ "andy","tom","jack"]
~~~
#### 隊列方法
> 棧數據結構的訪問規則是后進先出，而隊列數據結構的訪問規則是先進先出，隊列從數組的末端添加項，從數組的前端移除項。實現這一操作的數組方法就是shift()，它能夠移除數組中第一項并返回該項，同時數組長度減1，結合shift()和push()方法就可以像使用隊列一樣操作數組。如下：
~~~
let w = ["andy","tom"]
console.log(w.shift()) // 返回字符串andy，此時數組中只有[ "tom" ] 一項了
console.log(w.push("andy","jack")) //返回數組w的length值3，此時數組已變為[ "tom","andy","jack"]
~~~
> javascript還提供了unshift()方法，顧名思義，該方法與shift()方法用途相反，它能在數組前端添加任意個項，并返回數組長度，因此同時使用unshift()和pop()方法，就可以從相反的方向來模擬隊列，如下：
~~~
let w = ["andy","tom"]
console.log(w.pop()) // 返回字符串tom，此時數組中只有[ "andy" ] 一項了
console.log(w.unshift("tom","jack")) //返回數組w的length值3，此時數組已變為[ "tom","jack","andy"]
~~~
#### 排序方法
> 在javascript數組中已經存在兩個方法可以直接用來排序：reverse()和sort()，reverse()方法用來反轉數組項的順序，如下：
~~~
let n = [1,2,3,4,5]
console.log(n.reverse()) // [5,4,3,2,1]
~~~
> sort()方法按升序排序，即按值從小到大排序。如下：
~~~
let n = [1,2,5,4,3,18,10]
console.log(n.reverse()) // [1,2,3,4,5,10,18]
~~~
#### 操作方法
>concat()方法可以基于當前數組中的所有項創建一個新數組，具體來說這個方法會先創建一個當前數組的副本，然后將接收到的參數添加到這個副本的末尾，最后返回新建的數組，如下：
~~~
let a = [1,2]
let b = a.concat(5,[3,4])
console.log(b) // [1,2,5,3,4]
~~~
> slice()方法可以繼續數組中的一個或多個項創建一個新數組，slice方法接收一個或兩個參數，即要返回項的起始和結束位置。在只有一個參數的情況下，slice()方法返回從該參數指定位置開始到當前數組末尾的所有項。如果有兩個參數，該方法返回起始位置和結束位置之間的項，但不飽和結束位置的項。
> 注意：slice()方法不會影響原數組，如下：
~~~
let s1 = [1,2,3,4,5]
let s2 = s1.slice(1)
let s3 = s1.slice(1,3)
console.log(s2) // 2,3,4,5
console.log(s3) // 2,3,4
~~~
> 敲黑板：?? 下面介紹splice()，與上面的slice()不是一個方法，一定要擦亮雙眼看清楚！！！splice != slice
> splice()方法可以說是javascript數組操作中最強大的方法了，它有很多種用法，它的主要用途是項數組中部插入項，具體有如下三種方式：
> * 刪除：splice(0,2)會刪除數組前兩項，顯而易見，它第一個參數是起始位置，第二個參數是操作項的個數，而不是結束位置！！！??
> * 插入：可以指向任意位置插入任意數量的axing，只需要提供3個參數：起始位置／要刪除項的個數（0表示不刪除，適合插入時使用）／要插入的項，如果要插入多個項，可以再傳入第四／第五／第六...個參數。例如：splice(2,0,"andy","tom")會從當前位置2開始插入字符串"andy"和"tom"。
> * 替換：如上插入的第二個參數（要刪除的項的個數）是0，表示不刪除，那么我們可以將0改為我們想要替換掉的項的個數，來刪掉需要替換掉項，來達到替換掉目的。
> 上面操作方法等實際案例如下：
~~~
let i = ["andy","tom","jack"]
i.splice(0,1) //刪除數組i的第一個項
console.log(i) // ["tom","jack"]
i.splice(1,0,"小明"] // 在數組i的位置1后面插入一個項"小明"
console.log(i) // ["tom","jack","小明"]
i.splice(2,1,"andy") //在數組i的位置2后面刪除一項，然后插入一個項"andy"
console.log(i) // ["tom","jack","andy"]
~~~
#### 位置方法和查找方法
> 與之前的String字符串的位置方法一樣，數組實例也有兩個相同的位置方法：indexOf()和lastIndexOf()，在數組實例中的indexOf()方法和lastIndexOf()方法接收兩個參數：要查找的項和（后面一個參數可選）起點位置索引。其中indexOf()方法從數組開頭向后匹配，lastIndexOf()方法從數組末尾開始向前匹配，這兩個方法都返回要查找的項在數組中的索引位置，或者在沒有找到的情況下返回-1，在匹配的過程中會使用全等符（===）也就是說：匹配項與參數必須是嚴格等于，案例如下：
~~~
let n = [1,2,3,4,5,6]
console.log(n.indexOf(4)) // 3
console.log(n.lastIndexOf(4)) // 3
console.log(n.indexOf(4,4)) // -1
console.log(n.indexOf(4,2)) // 3
~~~
> 數組實例的find方法，用于找出第一個符合條件的數組成員。它的參數是一個回調函數，所有數組成員依次執行該回調函數，直到找出第一個返回值為true的成員，然后返回該成員。如果沒有符合條件的成員，則返回undefined。代碼如下：
~~~
[1, 4, -5, 10].find((n) => n < 0) //找出數組中第一個小于0的成員 -5
~~~
> 數組實例的findIndex方法的用法與find方法非常類似，返回第一個符合條件的數組成員的位置，如果所有成員都不符合條件，則返回-1，該方法接收三個參數：當前值／當前索引／數組本神。代碼如下：
~~~
[1, 5, 10, 15].findIndex(function(value, index, arr) {
return value > 9;
}) //返回第一個小于9的項的位置索引 2
~~~
#### 迭代方法
> ECMAScript5為數組定義了5個迭代方法，每個方法都接收兩個參數：要在每一項上運行的函數和運行該函數函數的作用域(影響this值)。傳入這些方法的函數會接收三個參數：數組項的值／該項在數組中的位置和數組對象本身。根據使用方法不同，這個函數執行后的返回值會（也可能不會）影響方法的返回值。主要是如下5個方法：
> every() :對數組中的每一項運行給定函數，如果該函數對數組的每一項都返回true則返回 true。如下，將數組中的每一項轉為一個浮點數，全部轉換成功就會返回true，但并不會改變原數組的值。
~~~
["1","2","3"].every(parseFloat)
// true
~~~
>filter()：對數組中的每一項運行給定函數，返回該函數中會返回true的項組成的數組。如下，我們繼續用上面的例子來解釋：
~~~
["1","2","Andy"].filter(parseFloat)
// ["1","2"]
// 因為Andy這個字符串強制轉換浮點數之后它也不是一個數字，所以返回了false，filter就返回了他為true的成員
~~~
> forEach() : 遍逆數組中的每一項，并向每一項給定函數，這個方法沒有返回值。這個方法與使用普通的for循環一樣，不明白的可以自己試試。
> map() : 對數組中的每一項運行給定函數，返回每次函數調用的結果組成數組。
~~~
["1","2","Andy"].map(parseFloat)
// [1, 2, NaN]
// 如上：Andy這個字符串強制轉換浮點數之后它也不是一個數字，即非數值 NaN
~~~
> some()：對數組中的每一項運行給定函數，如果該函數對任意項返回true，則返回true。
~~~
["tom","jack","Andy"].some(parseFloat)
// false
// 因為數組中的成員強制轉換浮點數之后都是NaN，所以返回false，但如果把數組中任意一項改為數字字符串，那parseFloat就可以將它轉為浮點數，some函數久會返回true
~~~
> ES6為數組新增了一種遍逆方法：for...of，用for...of進行數組遍歷
~~~
for(let index of [1,2,3,4,5]){
console.log(index)
}
// 1 2 3 4 5
~~~
#### 歸并方法
> ES5中定義了兩個數組歸并方法：reduce()和reduceRight()這兩個方法都會迭代數組所有的項，然后構建一個最終返回的值。其中，reduce()方法從數組的第一項開始，逐個遍逆到最后。而reduceRight()方法則從數組的最后一項開始，向前遍逆到第一項。
> 這兩個方法都接收兩個參數：一個在每一項上調用的函數和一個（可選的）作為歸并基礎的初始值。傳給reduce()he reduceRight()的參數中的第一個函數接收4個參數：前一個值／當前值／項的索引／和數組對象。這個函數返回的任何值都會作為第一個參數自動傳給下一項。
~~~
let u = [1,2,3]
//正序
let n = u.reduce(function(prev,cur,index,arr){
return cur+1
})
//倒序
let b = u.reduceRight(function(prev,cur,index,arr){
return cur +1
})
console.log(n)
console.log(b)
// 4 返回的是數組最后一項+1
// 2 返回數組第一項+1
~~~