淺顯易懂----Javascript數組全解析

時間 2019-11-12

原文原文鏈接

寫在前面

除了Object 以外，Array 類型恐怕是 ECMAScript 中最經常使用的類型了。並且，ECMAScript中的數組與其餘多數語言中的數組有着至關大的區別。雖然ECMAScript數組與其餘語言中的數組都是數據的有序列表，但與其餘語言不一樣的是，ECMAScript數組的每一項能夠保存任何類型的數據。也就是說，能夠用數組的第一個位置來保存字符串，用第二位置來保存數值用第三個位置來保存對象，以此類推。並且，ECMAScript數組的大小是能夠動態調整的，便可以隨着數據的添加自動增加以容納新增數據。javascript

建立數組

1.1 使用 Array 構造函數

有三種方式來調用構造函數：前端

調用時沒有參數，該方法建立一個沒有任何元素的空數組，等同於[]。

let animals = new Array();
複製代碼

調用時有一個數值參數，用於指定長度，而該參數會自動變成 length屬性的值，下面的代碼將建立 length 值爲 10 的數組：

let animals = new Array(10);
複製代碼

直接向Array構造函數傳遞數組中應該包含的項，構造函數的參數將成爲新數組的元素。

let animals = new Array("cat", "dog", "pig");
複製代碼

另外，在使用 Array 構造函數時也能夠省略 new 操做符。以下面的例子所示，省略 new 操做符的結果相同：java

let animals = Array(3); // 建立一個包含 3 項的數組
let names = Array("pig"); // 建立一個包含 1 項，即字符串"pig"的數組
複製代碼

1.2 使用數組字面量表示法

數組字面量由一對包含數組項的方括號表示，多個數組項之間以逗號隔開。數組

以下所示：bash

let animals = ["pig", "dog", "cat"]; // 建立一個包含 3 個字符串的數組
let names = []; // 建立一個空數組
let values = [1,2,]; // 這樣會建立一個包含 2 或 3 項的數組
let count = [1,,3]; //數組有三個元素，中間那個值爲undefined
let options = [,,,,,]; // 這樣會建立一個包含 5 或 6 項的數組
複製代碼

數組元素的讀和寫

在讀取和設置數組的值時，要使用方括號並提供相應值的基於的數字索引，方括號中的索引表示要訪問的值。app

let animals = ["pig", "dog", "cat"]; // 定義一個字符串數組
alert(animals[0]); // 顯示第一項 
animals[2] = "black"; // 修改第三項 
animals[3] = "brown"; // 新增第四項
複製代碼

數組的項數保存在其 length 屬性中，這個屬性始終會返回 0 或更大的值:框架

let animals = ["pig", "dog", "cat"]; // 建立一個包含 3 個字符串的數組
let names = []; // 建立一個空數組
alert(animals.length); //3 
alert(names.length); //0
複製代碼

能夠利用數組中的length屬性從數組的末尾移除項或向數組中添加新項：函數

let animals = ["pig", "dog", "cat"]; // 建立一個包含 3 個字符串的數組
animals.length = 2; 
alert(animals[2]); //undefined
複製代碼

這個例子中的數組 animals一開始有3個值。將其length屬性設置爲2會移除最後一項（位置爲2 的那一項），結果再訪問 animals[2]就會顯示 undefined.post

若是將其 length 屬性設置爲大於數組項數的值，則新增的每一項都會取得 undefined 值:測試

let animals = ["pig", "cat", "dog"]; // 建立一個包含 3 個字符串的數組
animals.length = 4; 
alert(animals[3]); //undefined
複製代碼

在此，雖然 animals 數組包含3個項，但把它的length屬性設置成了4。這個數組不存在位置 3，因此訪問這個位置的值就獲得了特殊值 undefined。

利用 length 屬性也能夠方便地在數組末尾添加新項:

let animals = ["red", "blue", "green"]; // 建立一個包含 3 個字符串的數組
animals[animals.length] = "tigger"; //（在位置 3）添加一種動物
animals[animals.length] = "brid"; //（在位置 4）再添加一種動物
複製代碼

因爲數組最後一項的索引始終是length-1，所以下一個新項的位置就是length。每當在數組末尾添加一項後，其 length 屬性都會自動更新:

let animals = ["pig", "cat", "dog"]; // 建立一個包含 3 個字符串的數組
animals[99] = "brid"; // 在位置99的索引上添加一種動物
alert(animals.length); // 100
複製代碼

檢測數組

用於肯定某個對象是否是數組。

使用 instanceof 操做符

if (animals instanceof Array){ 
 //對數組執行某些操做
}
複製代碼

instanceof運算符其實用來判斷一個構造函數的prototype屬性所指向的對象是否存在另一個要檢測對象的原型鏈上。

instanceof 操做符的問題在於，它假定只有一個全局執行環境。若是網頁中包含多個框架，那實際上就存在兩個以上不一樣的全局執行環境，從而存在兩個以上不一樣版本的Array構造函數。若是你從一個框架向另外一個框架傳入一個數組，那麼傳入的數組與在第二個框架中原生建立的數組分別具備各自不一樣的構造函數。

使用 Array.isArray()方法

if (Array.isArray(value)){ 
 //對數組執行某些操做
}
複製代碼

數組方法

數組的轉換方法

在javascript 中全部對象都具備 toLocaleString()、toString()和 valueOf()方法。

其中，調用數組的 toString()方法會返回由數組中每一個值的字符串形式拼接而成的一個以逗號分隔的字符串。而調用 valueOf()返回的仍是數組。實際上，爲了建立這個字符串會調用數組每一項的 toString()方法。

let colors = ["red", "blue", "green"]; // 建立一個包含 3 個字符串的數組
console.log(colors.toString()); // red,blue,green 
console.log(colors.valueOf()); // ["red","blue","green"] 
console.log(colors); // red,blue,green 
console.log(typeof(colors.toString()));// string
console.log(typeof(colors.valueOf())); //object
console.log(Array.isArray(colors.valueOf()));  //true
複製代碼

toLocaleString()方法常常也會返回與 toString()方法相同的值。在默認狀況是是調用 totring()，只有當toLocalString()方法的值和toString()的值不同的狀況下才會出現不同的結果。

let obj1 = { 
 toLocaleString : function () { 
 return "小黃瓜1"; 
 }, 
 
 toString : function() { 
 return "小嗨瓜1"; 
 } 
}; 
let obj2 = { 
 toLocaleString : function () { 
 return "小黃瓜2"; 
 }, 
 
 toString : function() { 
 return "小嗨瓜2"; 
 } 
}; 
let people = [obj1, obj2]; 
console.log(people); //小黃瓜1,小黃瓜2 
console.log(people.toString()); //小黃瓜1,小黃瓜2 
console.log(people.toLocaleString()); //小嗨瓜1,小嗨瓜2 
複製代碼

數組繼承的 toLocaleString()、toString()和valueOf()方法，在默認狀況下都會以逗號分隔的字符串的形式返回數組項，不改變原數組。

Array.join()方法

可使用不一樣的分隔符來構建這個字符串。join()方法只接收一個參數，即用做分隔符的字符串，而後返回包含全部數組項的字符串。

let animal = ["dog", "pig", "cat"]; 
alert(animal.join(",")); //dog,pig,cat 
alert(animal.join("||")); //dog||pig||cat 
複製代碼

若是不給 join()方法傳入任何值，或者給它傳入 undefined，則使用逗號做爲分隔符。

經過join()方法能夠實現重複字符串，只需傳入字符串以及重複的次數，就能返回重複後的字符串:

function mark(str , n){
    return new Array(n + 1).join(str);
}
console.log(mark("小黃瓜" , 4));     //小黃瓜小黃瓜小黃瓜小黃瓜
console.log(mark("小嗨瓜" , 3));     //小嗨瓜小嗨瓜小嗨瓜
複製代碼

不改變原數組，返回包含全部數組項的字符串。

Array.from()方法(ES6)

將類(僞)數組對象或可遍歷對象轉換爲真數組。

let arr =Array.of(3,4,5,'小黃瓜','li');
console.log(arr);  //[3, 4, 5, '小黃瓜',"li"]

//字符串轉數組
let str = "huanggua";
console.log(Array.from(str));	//Array(5) ["h","u","a","n","g","g","u","a"]

//將類數組對象轉換爲真正數組：
let arrList = {
    0: 'xiao', 
    1: '22',
    2: '男',
    3: ['xiao','huang','gua'],
    4: 5,
    'length': 5
}
let arr = Array.from(arrList)
console.log(arr) // Array(4) ['xiao','22','男',['xiao','huang','gua'],5]

//一、該類數組對象必須具備length屬性，用於指定數組的長度。若是沒有length屬性，那麼轉換後的數組是一個空數組
//二、該類數組對象的屬性名必須爲數值型或字符串型的數字


let arrayLike = {
    '0': 'a',
    '1': 'b',
    '2': 'c',
    length: 3
};
 
// ES5的寫法
let arr1 = [].slice.call(arrayLike); // ['a', 'b', 'c']
 
// ES6的寫法
let arr2 = Array.from(arrayLike); // ['a', 'b', 'c']
複製代碼

Array.of()方法(ES6)

將一組值，轉成數組。

let arr = Array.of('apple','banana','orange');
console.log(arr);	//['apple','banana','orange']
複製代碼

數組元素的添加和刪除

Array.push()方法能夠接收任意數量的參數，把它們逐個添加到數組末尾。

let animals = new Array(); // 建立一個數組
let count = animals.push("pig", "dog"); // 推入兩項
console.log(count); //2 
count = animals.push("cat"); // 推入另外一項
console.log(count); //3
console.log(animals) //["pig","dog","cat"]
複製代碼

push() 方法返回修改後數組的長度,改變原數組。

Array.pop()方法則從數組末尾移除最後一項，減小數組的 length 值。

let animals = ["pig","dog","cat"];
let item = animals.pop(); // 刪除最後一項
console.log(item); //"cat" 
console.log(animals.length); //2
console.log(animals);   //["pig","dog"]
複製代碼

pop() 方法返回移除的項,改變原數組。

Array.shift()方法，它可以移除數組中的第一個項，同時將數組長度減 1。

let animals = ["pig","dog","cat"];
let item = animals.shift(); //取得第一項
console.log(item); //"pig" 
console.log(animals.length); //2
console.log(animals);//["dog","cat"]
複製代碼

shift() 方法返回移除的項,改變原數組。

Array.unshift()方法,它能在數組前端添加任意個項。

let animals = ["pig","dog","cat"];
let count = colors.unshift("brid", "trigger");
console.log(count); //5
console.log(animals); //["brid", "trigger","pig","dog","cat"];
複製代碼

unshift() 方法返回新數組的長度,改變原數組。

數組的排序方法

Array.reverse()方法會反轉數組項的順序。

let colors = [1, 2, 3, 4, 5]; 
colors.reverse(); 
alert(colors); //5,4,3,2,1
複製代碼

reverse() 方法會改變原數組,返回值是通過排序以後的數組。

Array.sort()方法按升序排列數組項——即最小的值位於最前面，最大的值排在最後面。sort()方法會調用每一個數組項的 toString()轉型方法，而後比較獲得的字符串，以肯定如何排序。

let colors = [0, 1, 5, 10, 15]; 
colors.sort(); 
alert(colors); //0,1,10,15,5
複製代碼

sort()方法也會根據測試字符串的結果改變原來的順序。由於數值 5 雖然小於 10，但在進行字符串比較時，"10"則位於"5"的前面，因而數組的順序就被修改。

所以 sort()方法能夠接收一個比較函數做爲參數，以便咱們指定哪一個值位於哪一個值的前面。比較函數接收兩個參數，若是第一個參數應該位於第二個以前則返回一個負數，若是兩個參數相等則返回 0，若是第一個參數應該位於第二個以後則返回一個正數。如下就是一個簡單的比較函數：

a. 升序排序：

function compare(value1,value2){
    if(value1 < value2){
        return -1;
    }else if(value1 > value2){
        return 1;
    }else{
        return 0
    }
}

let colors = [1,2,3,5,4,7];
colors.sort(compare);
console.log(colors); //[1,2,3,4,5,7]
複製代碼

對於數值類型或者其 valueOf()方法會返回數值類型的對象類型也能夠寫成：

function compare(value1,value2){
    return value1 - value2;
    //降序:value2 - value1
}
複製代碼

b. 按照數組對象中的某個屬性值進行排序：

let arr:[
    {name:"小黃瓜" , age:"22"},
    {name:"小綠瓜" , age:"12"},
    {name:"小紅瓜" , age:"44"},
]

function compare(option){
    return function(value1,value2){
        let obj1 = value1[option];
        let obj2 = value2[option];
        return obj1 - obj2;
    }
}

arr.sort(compare("age"));
複製代碼

sort() 方法會改變原數組,返回值是通過排序以後的數組。

數組的合併方法

Array.concat()方法

這個方法會先建立當前數組一個副本，而後將接收到的參數添加到這個副本的末尾，最後返回新構建的數組。在沒有給 concat()方法傳遞參數的狀況下，它只是複製當前數組並返回副本。若是傳遞給 concat()方法的是一或多個數組，則該方法會將這些數組中的每一項都添加到結果數組中。若是傳遞的值不是數組，這些值就會被簡單地添加到結果數組的末尾。

let animals = ["pig", "dog", "cat"]; 
let animals2 = animals.concat("brid", ["trigger", "panda"]); 
console.log(animals); //[pig,dog,cat] 
console.log(animals2); //[pig,dog,cat,brid,trigger,panda]
複製代碼

返回合併後的新數組，不改變原數組。

...擴展運算符 ES6中的解構賦值方法

let animals1 = ["pig", "dog", "cat"];
let animals2 = ["trigger", "panda"];
let animals3 = [...animals1 , ...animals2];
console.log(animals3); //["pig", "dog", "cat","trigger", "panda"]
複製代碼

數組的截取

Array.slice()方法

接受一或兩個參數，即要返回項的起始和結束位置。在只有一個參數的狀況下，slice()方法返回從該參數指定位置開始到當前數組末尾的全部項。若是有兩個參數，該方法返回起始和結束位置之間的項— —但不包括結束位置的項。

let animals = ["pig","dog","cat","brid","trigger","panda"]; 
let animals2 = animals.slice(1); 
let animals3 = animals.slice(1,4); 
console.log(animals2); //dog,cat,brid,trigger,panda
console.log(animals3); //dog,cat,brid
複製代碼

返回截取的數組,不改變原數組。

數組的操做方法

Array.splice()方法

splice()方法的用法：

刪除：能夠刪除任意數量的項，只需指定 2 個參數：要刪除的第一項的位置和要刪除的項數。例如，splice(0,2)會刪除數組中的前兩項。
插入：能夠向指定位置插入任意數量的項，只需提供 3 個參數：起始位置、0（要刪除的項數）和要插入的項。若是要插入多個項，能夠再傳入第4、第五，以致任意多個項。例如， splice(2,0,"pig","dog")會從當前數組的位置 2 開始插入字符串"pig"和"dog"。
替換：能夠向指定位置插入任意數量的項，且同時刪除任意數量的項，只需指定 3 個參數：起始位置、要刪除的項數和要插入的任意數量的項。插入的項數沒必要與刪除的項數相等。例如， splice (2,1,"pig","dog")會刪除當前數組位置 2 的項，而後再從位置 2 開始插入字符串 "pig"和"dog"。

//刪除
let animals = ["pig", "dog", "cat"]; 
let newAnimals = animals.splice(0,1); // 刪除第一項
console.log(animals); // dog, cat 
console.log(newAnimals); // pig，返回的數組中只包含一項

//插入
let animals = ["pig" , "dog" , "cat"];
let newAnimals = animals.splice(1, 0, "brid", "panda"); // 從位置 1 開始插入兩項
console.log(animals); // pig,brid,panda,dog,cat,
console.log(newAnimals); // 返回的是一個空數組

//替換
let animals = ["pig" , "dog", "cat"];
let newAnimals = animals.splice(1, 1, "red", "purple"); // 插入兩項，刪除一項
console.log(animals); // pig,red,purple,cat 
console.log(newAnimals); // dog，返回的數組中只包含一項
複製代碼

fill()方法(ES6)

填充, 參數替換原數組內容，可是會改變原來的數組。

參數：
該方法有三個參數：
fill(value, start, end)
value：想要替換的內容。
start：開始位置（數組的下標），能夠省略。
end：替換結束位置（數組的下標），若是省略不寫就默認爲數組結束。
複製代碼

//一、只傳入一個值（替換的內容），那將覆蓋全部數組內的內容
let animals = ["dog", "cat", "pig", "brid"];
animals.fill("panda");
//panda,panda,panda,panda

//二、傳入三個參數（替換的內容，起始位置，結束位置），那將把填充值替換到起始位置和結束位置之間
let animals = ["dog", "cat", "pig", "brid"];
animals.fill("panda", 2, 4);
//dog,cat,panda,panda
複製代碼

返回修改後的數組，改變原數組。

Array.copyWithin()方法

操做當前數組自身，用來把某些個位置的元素複製並覆蓋到其餘位置。

該函數有三個參數。
target：目的起始位置。
start：複製源的起始位置，能夠省略，能夠是負數。
end：複製源的結束位置，能夠省略，能夠是負數，實際結束位置是end-1。
複製代碼

let arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
let newArr = arr.copyWithin(1, 3, 6);  //將4，5，6複製覆蓋到1下標的位置
console.log(newArr);   //[1,4,5,6,5,6,7,8,9,10,11]
複製代碼

返回值爲複製覆蓋後的新數組,改變原數組。

數組的位置方法

Array.indexOf()方法

返回要查找的項在數組中的位置，或者在沒找到的狀況下返回-1。接受兩個參數：要查找的項和（可選的）表示查找起點位置的索引。

Array.lastIndexOf()方法

從數組的末尾開始向前查找

let numbers = [1,2,3,4,5,4,3,2,1]; 
console.log(numbers.indexOf(4)); //3 
console.log(numbers.lastIndexOf(4)); //5 
console.log(numbers.indexOf(4, 4)); //5 
console.log(numbers.lastIndexOf(4, 4)); //3 

let person = { name: "Nicholas" }; 
let people = [{ name: "Nicholas" }]; 
let morePeople = [person]; 
console.log(people.indexOf(person)); //-1 
console.log(morePeople.indexOf(person)); //0 
複製代碼

返回查找到的下標，不會改變原數組。

find()方法(ES6)

查找數組內元素，找到第一個符合條件的數組成員，返回該成員的值，若是沒有找到，返回undefined。

例子：
let arr = [0,1,2,3,4,5];
let result = arr.find(function(item, index, Array){
	return item > 1;		// 查找第一個大於1的值
})
console.log(result);	// 2
複製代碼

findIndex()方法(ES6)

查找數組內元素，找到第一個符合條件的數組成員，返回該成員的下標（index），沒找到返回-1。

let arr = ["xiao", "huang", "gua"];
let result = arr.findIndex(function(item, index, Array){
	return item == "gua";		// 查找到的字符串爲gua的下標
})
console.log(result);	// 2
複製代碼

Array.includes()方法

查找數組內是否包含指定的元素, 返回一個布爾值。

該方法的第二個參數表示搜索的起始位置，默認爲0。若是第二個參數爲負數，則表示倒數的位置。

let arr = [1, 2, 3, 4, 5, 6]
let newArr = arr.includes(3); //查找數組中是否包含元素3
console.log(newArr); //true

let arr = [1, 2, 3, 4, 5, 6]
let newArr = arr.includes(3,3);  //從下標3開始查找數組中是否包含元素3
console.log(newArr); //false
複製代碼

返回值爲true或false,不會影響原數組。

數組的迭代方法

參數：

每一個方法都接收兩個參數：要在每一項上運行的函數和（可選的）運行該函數的做用域對象——影響 this 的值。傳入這些方法中的函數會接收三個參數：數組項的值、該項在數組中的位置和數組對象自己。

every()方法

對數組中的每一項運行給定函數，若是該函數對每一項都返回 true，則返回 true。(每一項都返回true，才返回true)。

let numbers = [1,2,3,4,5,4,3,2,1]; 
let everyResult = numbers.every(function(item, index, array){ 
 return (item > 2); 
}); 
console.log(everyResult); //false 
複製代碼

some()方法

對數組中的每一項運行給定函數，若是該函數對任一項返回 true，則返回 true。(有一項返回true，就返回true)。

let numbers = [1,2,3,4,5,4,3,2,1]; 
let everyResult = numbers.some(function(item, index, array){ 
 return (item > 2); 
}); 
console.log(everyResult); //true 
複製代碼

filter()方法(過濾)

對數組中的每一項運行給定函數，返回該函數會返回 true 的項組成的數組。

let numbers = [1,2,3,4,5,4,3,2,1]; 
let everyResult = numbers.filter(function(item, index, array){ 
 return (item > 2); 
}); 
console.log(everyResult); //[3,4,5,4,3]
複製代碼

map()方法(映射)

對數組中的每一項運行給定函數，返回每次函數調用的結果組成的數組。

let numbers = [1,2,3,4,5,4,3,2,1]; 
let everyResult = numbers.map(function(item, index, array){ 
 return (item > 2); 
}); 
console.log(everyResult); //[false, false, true, true, true, true, true, false, false][3,4,5,4,3]

let numbers = [1,2,3,4,5,4,3,2,1]; 
let everyResult = numbers.map(function(item, index, array){ 
 return (item * 2); 
}); 
console.log(everyResult); //[2, 4, 6, 8, 10, 8, 6, 4, 2]
複製代碼

map()方法建立一個新數組，其結果是該數組中的每一個元素都調用一個提供的函數後返回的結果。返回值是一個新的數組。

forEach()方法(遍歷)

對數組中的每一項運行給定函數。這個方法沒有返回值。

let numbers = [1,2,3,4,5,4,3,2,1]; 
numbers.forEach(function(item, index, array){ 
 //執行某些操做 
}); 
複製代碼

forEach() 方法對數組的每一個元素執行一次提供的函數。老是返回undefined。

for...in方法(遍歷下標,無序)

//使用for...in遍歷數組，獲得下標
 let numbers = [1,2,3,4,5,6]; 
    for(item in numbers){
        console.log(item)
    }     //0,1,2,3,4,5

//使用for...in遍歷對象，獲得對象的key值
let numbers = {name:"小黃瓜" , age:"22"}; 
    for(item in numbers){
        console.log(item)
    }     //name , age
複製代碼

for...of方法(循環)(ES6)

let numbers = [1,2,3,4,5]; 
    for(let item of numbers){
        console.log(item)
    }    //1,2,3,4,5
複製代碼

總結:for in老是獲得對像的key或數組,字符串的下標,而for of和forEach同樣,是直接獲得值, forof不能在對象中使用。

數組的歸併方法

參數：

這兩個方法都接收兩個參數：一個在每一項上調用的函數和（可選的）做爲歸併基礎的初始值。
傳給 reduce()和 reduceRight()的函數接收4個參數：前一個值、當前值、項的索引和數組對象。這個函數返回的任何值都會做爲第一個參數自動傳給下一項。第一次迭代發生在數組的第二項上，所以第一個參數是數組的第一項，第二個參數就是數組的第二項。

reduce()方法

從數組的第一項開始，逐個遍歷到最後,累加數組的全部項，而後構建一個最終返回的值。

//數組求和
let numbers = [1,2,3,4,5]; 
let sum = numbers.reduce(function(prev, cur, index, array){ 
 return prev + cur; 
}); 
console.log(sum); //15 
//第一次執行回調函數，prev 是 1，cur 是 2。
複製代碼

reduceRight()方法

從數組的最後一項開始，向前遍歷到第一項

let numbers = [1,2,3,4,5]; 
let sum = numbers.reduceRight(function(prev, cur, index, array){ 
 return prev + cur; 
}); 
console.log(sum); //15 
//第一次執行回調函數，prev 是 5，cur 是 4。
複製代碼

使用 reduce()仍是 reduceRight()，主要取決於要從哪頭開始遍歷數組。除此以外，它們徹底相同。

總結

會改變原數組的方法：

Array.shift():刪除數組第一個元素。返回值爲被刪除的元素。
Array.unshift():向數組的第一個位置添加元素。返回值爲數組的長度。
Array.pop():刪除數組中最後一個元素。返回值爲被刪除的元素。
Array.push():向數組中最後一位添加元素。返回值爲數組的長度。
Array.sort():數組排序。返回值爲排序後的新數組。
Array.reverse():反轉數組中的元素。返回值爲反轉後的新數組。
Array.splice():添加或刪除數組元素。返回值爲被刪除的元素。
fill():(ES6)數組填充。返回值爲修改後的數組。
Array.copyWithin():(ES6)複製覆蓋元素。返回值爲複製覆蓋後的新數組。
複製代碼

不會改變原數組的方法：

Array.slice():截取數組中的元素。返回值爲被截取元素組成的新數組。
Array.concat():合併數組元素。返回值爲元素合併後的新數組。
Array.join():數組轉字符串。返回轉化後的字符串。
toString():數組轉字符串。返回轉化後的字符串。
toLocaleString():數組轉字符串。返回轉化後的字符串。
indexOf():查找數組是否存在某個元素。返回查找到的下標。
lastIndexOf():倒序查找數組是否存在某個元素。返回查找到的下標。
Array.includes():(ES6)查找數組中是否包含指定元素。返回true或false。
複製代碼

遍歷方法：

every():判斷數組中的元素是否全都知足條件。返回true或false。
some():判斷數組中是否有知足條件的元素。返回true或false。
forEach():遍歷。無返回值。
filter():根據條件進行過濾，返回新數組。
map():映射，對數組中的每一個元素進行處理，返回新數組。
reduce():數組的歸併，將元素歸併爲一個值。
reduceRight():從右向左進行歸併。
find():(ES6)根據條件查找數組元素。
findIndex():(ES6)根據條件查找數組元素下標。
複製代碼

後記

斷斷續續接近三天的時間 ,終於將數組的相關方法和用法相對全面的整理了一下，沒想到平時沒用到的還有這麼多方法，其實仔仔細細的對數組的方法所有過一遍仍是能發現好多不同的東西的。

下一篇： javascript對象

本文參考：

Javascript高級程序設計(第三版)

Javascript權威指南(第六版)

ES6 標準入門