JS數組Array常用方法有哪些

這篇“JS數組Array常用方法有哪些”文章的知識點大部分人都不太理解，所以小編給大家總結了以下內容，內容詳細，步驟清晰，具有一定的借鑒價值，希望大家閱讀完這篇文章能有所收獲，下面我們一起來看看這篇“JS數組Array常用方法有哪些”文章吧。

一、JavaScript中創建數組的方式

（1）使用 Array 構造函數：

var arr1 = new Array(); //創建一個空數組
var arr2 = new Array(15); // 創建一個長度為15的數組
var a = new Array([15]); //指創建一個數組，長度為1，并且第一位是15
var arr3 = new Array("sf","zs","zsf"); // 創建一個包含3個字符串的數組

（2）使用數組字面量表示法：

var arr4 = []; //創建一個空數組
var arr5 = [15]; // 創建一個數組，長度為1，包含‘15'數字
var arr6 = ["sf","zs","zsf"]; // 創建一個包含3個字符串的數組

二、數組方法概括

數組的方法我們一般以是否會改變原數組進行區分

使用以下方法會改變原數據

使用以下方法不會改變原數據

三、方法詳解

1、pop()

pop()：數組末尾移除最后一項，減少數組的 length 值，然后返回移除的項

ar arr = [1,2,3];
console.log(arr.pop());     //3
console.log(arr);           //[1,2]---原數組改變

2、shift()

功能：方法用于刪除并返回數組的第一個元素。

var arr = [1,2,3]
console.log(arr.shift());       //1
console.log(arr);               //[2,3]---原數組改變

3、push()

功能：向數組的末尾添加一個或更多元素，并返回新的長度。

var arr = [1,2,3];
console.log(arr.push("hello"));  //4
console.log(arr);                //[1,2,3,"hello"]---原數組改變
console.log(arr.push("a","b"));  //6
console.log(arr);                //[1,2,3,"hello","a","b"]---原數組改變

4、unshift()

功能：向數組的開頭添加一個或更多元素，并返回新的長度。

var arr = [1,2,3];
console.log(arr.unshift("hello"));  //4
console.log(arr);                   //["hello",1,2,3]---原數組改變
console.log(arr.unshift("a","b"));  //6
console.log(arr);                   //["a","b","hello",1,2,3]---原數組改變

5、sort()

功能：對數組中的元素進行排序，默認是升序。

var arr = [6,1,5,2,3];
console.log(arr.sort());    //[1, 2, 3, 5, 6]
console.log(arr);           //[1, 2, 3, 5, 6]---原數組改變

注意：sort默認把所有元素先轉換為String再排序，而字符串根據ASCII碼進行排序

// 案例一：看上去正常的結果
['Google', 'Apple', 'Microsoft'].sort(); // ['Apple', 'Google', 'Microsoft'];

// 案例二：apple排在了最后
['Google', 'apple', 'Microsoft'].sort(); // ['Google', 'Microsoft", 'apple']

// 案例三：無法理解的結果
[10, 20, 1, 2].sort(); // [1, 10, 2, 20]

我們可以看到案例二和案例三，就會發現直接使用sort()沒有辦法排序復雜的數組

因此我們可以如下使用它

var arr = [10, 20, 1, 2];
arr.sort((x, y)=> {
	if (x < y) {
		return -1;
	}
	if (x > y) {
		return 1;
	}
	return 0;
});
console.log(arr); // [1, 2, 10, 20]

6、reverse()

功能: 反轉數組項的順序。

var arr = [13, 24, 51, 3];
console.log(arr.reverse()); //[3, 51, 24, 13]
console.log(arr); //[3, 51, 24, 13](原數組改變)

7、splice()

功能：很強大的數組方法，它有很多種用法，可以實現刪除、插入和替換。

array.splice(index, howmany, item1, ....., itemX)

• index:必需。整數，指定在什么位置添加/刪除項目，使用負值指定從數組末尾開始的位置

• howmany:可選。要刪除的項目數。如果設置為 0，則不會刪除任何項目。

• item1, …, itemX:可選。要添加到數組中的新項目。

splice()方法始終都會返回一個數組，該數組中包含從原始數組中刪除的項，如果沒有刪除任何項，則返回一個空數組。

var arr = [1,3,5,7,9,11];
var arrRemoved = arr.splice(0,2);
console.log(arr); //[5, 7, 9, 11]
console.log(arrRemoved); //[1, 3]
var arrRemoved2 = arr.splice(2,0,4,6);
console.log(arr); // [5, 7, 4, 6, 9, 11]
console.log(arrRemoved2); // []
var arrRemoved3 = arr.splice(1,1,2,4);
console.log(arr); // [5, 2, 4, 4, 6, 9, 11]
console.log(arrRemoved3); //[7]

1、join()

功能：根據指定分隔符將數組中的所有元素放入一個字符串，并返回這個字符串。
參數：join(str);參數可選，默認為","號，以傳入的字符作為分隔符。

var arr = [1,2,3];
console.log(arr.join());         //1,2,3
console.log(arr.join("-"));      //1-2-3

通過join()方法可以實現重復字符串，只需傳入字符串以及重復的次數，就能返回重復后的字符串，函數如下：

function repeatString(str, n) {
	return new Array(n + 1).join(str);
}
console.log(repeatString("abc", 3)); // abcabcabc
console.log(repeatString("Hi", 5)); // HiHiHiHiHi

2、concat()

功能: 將參數添加到原數組中。這個方法會先創建當前數組一個副本，然后將接收到的參數添加到這個副本的末尾，最后返回新構建的數組。在沒有給 concat()方法傳遞參數的情況下，它只是復制當前數組并返回副本。

const arr1 = [1,2,3];
const arr2 = [4,5,6];
const arr3 = arr1.concat(arr2);
console.log(arr3);  //[1,2,3,4,5,6]

3、slice()

功能: 返回從原數組中指定開始下標到結束下標之間的項組成的新數組。

array.slice(start, end)

slice()方法可以接受一或兩個參數，即要返回項的起始(start)和結束位置(end)。

• 在只有一個參數的情況下， slice()方法返回從該參數指定位置開始到當前數組末尾的所有項。

• 如果有兩個參數，該方法返回起始和結束位置之間的項——但不包括結束位置的項。

• 如果start > end 的索引的話，則返回空數組

var arr = [1,3,5,7,9,11];
var arrCopy1 = arr.slice(1);
var arrCopy2 = arr.slice(1,4);
var arrCopy3 = arr.slice(1,-2);
var arrCopy4 = arr.slice(-4,-1);
console.log(arr); //[1, 3, 5, 7, 9, 11](原數組沒變)
console.log(arrCopy1); //[3, 5, 7, 9, 11]
console.log(arrCopy2); //[3, 5, 7]
console.log(arrCopy3); //[3, 5, 7]
console.log(arrCopy4); //[5, 7, 9]

4、toString()

功能：轉換成字符串，類似于沒有參數的join()。該方法會在數據發生隱式類型轉換時被自動調用，如果手動調用，就是直接轉為字符串。

var arr = [1,2,3];
console.log(arr.toString());     //1,2,3
console.log(arr);                //[1,2,3]---原數組未改變

5、valueOf()

功能：返回數組的原始值（一般情況下其實就是數組自身），一般由js在后臺調用，并不顯式的出現在代碼中

var arr = [1,2,3];
console.log(arr.valueOf());         //[1,2,3]
console.log(arr);                   //[1,2,3]
//為了證明返回的是數組自身
console.log(arr.valueOf() == arr);  //true

6、indexOf()

功能：根據指定的數據，從左向右，查詢在數組中出現的位置，如果不存在指定的數據，返回-1。該方法是查詢方法，不會對數組產生改變。

indexOf(value, start);

• value：要查詢的數據；

• start：可選，表示開始查詢的位置，當start為負數時，從數組的尾部向前數；如果查詢不到value的存在，則方法返回-1

var arr = ["h","e","l","l","o"];
console.log(arr.indexOf("l"));        //2
console.log(arr.indexOf("l",3));      //3
console.log(arr.indexOf("l",4));      //-1
console.log(arr.indexOf("l",-1));     //-1
console.log(arr.indexOf("l",-3));     //2

7、lastIndexOf()

功能：根據指定的數據，從右向左，查詢在數組中出現的位置，如果不存在指定的數據，返回-1。該方法是查詢方法，不會對數組產生改變。

lastIndexOf(value, start);

• value：要查詢的數據；

• start：可選，表示開始查詢的位置，當start為負數時，從數組的尾部向前數；如果查詢不到value的存在，則方法返回-1

var arr = ["h","e","l","l","o"];
console.log(arr.lastIndexOf("l"));        //3
console.log(arr.lastIndexOf("l",3));      //3
console.log(arr.lastIndexOf("l",1));      //-1
console.log(arr.lastIndexOf("l",-3));     //2
console.log(arr.lastIndexOf("l",-4));     //-1

8、forEach()

功能：對數組進行遍歷循環，對數組中的每一項運行給定函數。這個方法沒有返回值。

參數: 都是function類型，默認有傳參，參數分別為：遍歷的數組內容；第對應的數組索引，數組本身。

var arr = [1, 2, 3, 4, 5];
arr.forEach((item, index, a)=>{
	console.log(item + '|' + index + '|' + (a === arr));
});
// 輸出為：
// 1|0|true
// 2|1|true
// 3|2|true
// 4|3|true
// 5|4|true

9、map()

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

如果你想要數組里的每一個值都發生變化就使用map

 let arr = [10, 30, 50, 60, 120, 230, 340, 450]
 let newArr = arr.map(item => {
     return item * 2
 })
 console.log(newArr); //[20, 60, 100, 120, 240, 460, 680, 900]
 console.log(arr); //[10, 30, 50, 60, 120, 230, 340, 450]

10、filter()

功能: 過濾，數組中的每一項運行給定函數，返回滿足過濾條件組成的數組。

//過濾出索引為3的倍數 或者 值大于8的元素
var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
var arr2 = arr.filter((item, index) => { 
	return index % 3 === 0 || item >= 8; 
}); 
console.log(arr2); //[1, 4, 7, 8, 9, 10]

11、every()

功能：判斷數組中每一項都是否滿足條件，只有所有項都滿足條件，才會返回true。

var arr = [1, 2, 3, 4, 5];
var arr2 = arr.every((x)=> {
	return x < 10;
}); 
console.log(arr2); //true
var arr3 = arr.every((x) => {
	return x < 3;
}); 
console.log(arr3); // false

12、some()

功能: 判斷數組中是否存在滿足條件的項，只要有一項滿足條件，就會返回true。

var arr = [1, 2, 3, 4, 5];
var arr2 = arr.some((x)=> {
	return x < 3;
}); 
console.log(arr2); //true
var arr3 = arr.some((x)=> {
	return x < 1;
}); 
console.log(arr3); // false

13、reduce()

功能：從數組的第一項開始，逐個遍歷到最后，迭代數組的所有項，然后構建一個最終返回的值。

array.reduce(function(total, currentValue, currentIndex, arr), initialValue)

參數：

• total是當前聚合值即合并的值，他可以是任何類型

• currentValue是數組循環時的當前元素

• currentIndex 是數組元素的索引值

• arr是數組本身

• initialValue傳遞給函數的初始值

一般常用的是前面的兩個參數,后面兩個參數不常用,常用的使用場景便是數組的求和

 // 作用:對數組中所有的內容進行匯總   要傳至少兩個值
 let arr = [10, 30, 50, 60, 120, 230, 340, 450]
 let newArr = arr.reduce((pre, n) => {
     return pre + n
 }, 0)
 console.log(newArr);

14、reduceRight()

功能：（與reduce類似）從數組的最后一項開始，向前逐個遍歷到第一位，迭代數組的所有項，然后構建一個最終返回的值。

array.reduceRight(function(total, currentValue, currentIndex, arr), initialValue)

參數：同reduce。

var arr = [1,2,3,4,5];
var sum = arr.reduceRight(function(pre, cur, index, array){
	return pre + cur;
},10);
console.log(sum); //25

15、findIndex()

功能: 返回數組中滿足提供的測試函數的第一個元素的索引。若沒有則返回-1。

let arr = [10, 2, 9, 17, 22];
let index = arr.findIndex((item) => item > 13)
console.log(index);  // 3

四、實戰

一些算法我們可以使用此方法實現，此處我只寫一些簡單可實現的方法

4.1、實現數組排序（升序 || 降序）

我們使用sort搭配reverse可以快速實現排序，但是我們也可以使用冒泡排序、快速排序等方法

sort的原理本身就是冒泡排序的一種寫法

升序

var arr = [6,1,5,2,3];
console.log(arr.sort());    //[1, 2, 3, 5, 6]

降序

var arr = [6,1,5,2,3];
console.log(arr.sort((a,b)=>{return b - a}));//[6,5,4,3,2,1]

降序

var arr = [6,1,5,2,3];
console.log(arr.sort().reverse());    //[6,5,4,3,2,1]

4.2、數組去重

適用indexOf和push實現

function uniqueArray(arr) {
	var temp = [];
	for (var i = 0; i < arr.length; i++) {
		if (temp.indexOf(arr[i]) == -1) {
			temp.push(arr[i]);
		}
	}
	return temp;
}

使用filter去重

var r = [],
arr = ['apple', 'strawberry', 'banana', 'pear', 'apple', 'orange', 'orange', 'strawberry'];
r = arr.filter(function (element, index, self) {
  return self.indexOf(element) === index;
});
consolo.log(r)//['apple', 'strawberry', 'banana', 'pear', 'orange']

使用reduce實現數組對象去重

//數組重名去重
var resources = [
  { name: "張三", age: "18" },
  { name: "張三", age: "19" },
  { name: "張三", age: "20" },
  { name: "李四", age: "19" },
  { name: "王五", age: "20" },
  { name: "趙六", age: "21" }
]
var temp = {};
resources = resources.reduce((prev, curv) => {
  if (!temp[curv.name]) {// 如果臨時對象沒有就把這個名字加進去，同時把當前的這個對象加入到prev中
  	temp[curv.name] = true;
    prev.push(curv);
  }
	return prev
}, []);
console.log(resources);
//[
//  { name: "張三", age: "18" },
//  { name: "李四", age: "19" },
//  { name: "王五", age: "20" },
//  { name: "趙六", age: "21" }
//]

4.3、找數組元素

數組中重復次數最多的一個元素

var arr = [1,1,1,2,2,2,2,2,2,2,3,3,3,4,4,5,6,7,7,8];
var maxNum = 0;
var maxName = "";
var obj = {};
arr.forEach((ele,index)=>{
	obj[ele] ? obj[ele] += 1 : obj[ele] = 1;
})
for(let r in obj) {
	if(obj[r]>maxNum){
		maxNum = obj[r]
		maxName = r
	}
}

console.log(`最多重復的數${maxName},重復次數為:${maxNum}`) //最多重復的數2,重復次數為:7

以上就是關于“JS數組Array常用方法有哪些”這篇文章的內容，相信大家都有了一定的了解，希望小編分享的內容對大家有幫助，若想了解更多相關的知識內容，請關注億速云行業資訊頻道。