前端老司機駕輕就熟的操做數組方法全在這裏了

時間 2019-11-06

標籤前端司機駕輕就熟數組方法這裏简体版

原文原文鏈接

1、總結

1.尋找符合條件元素，返回布爾值

找到第一個，就返回不要使用Array.indexOf，使用Array.includesjavascript

2.尋找符合條件元素，返回元素

找到第一個，就返回不要使用Array.filter，使用Array.findhtml

3.尋找符合條件元素，返回布爾值

遍歷數組，返回不要使用Array.find，使用Array.somejava

4.尋找全部符合條件元素，返回數組

遍歷數組，返回不要使用forEach，使用filterjson

2、方法使用

預覽數組

arr.join(separator)：將數組的元素組起一個字符串，以separator爲分隔符，省略的話默認逗號爲分隔符
arr.push('sss')和pop()：數組末尾添加元素，刪除元素
arr.unshift(''111)和 shift()：數組頭部添加元素，刪除元素
arr.sort(compare)：按升序排列數組項
arr.reverse()：反轉數組項的順序。
concat(arr)：將參數添加到原數組中。返回數組
slice(1,3)：返回從原數組中指定開始下標到結束下標之間的項組成的新數組1,2 返回數組
splice():實現刪除、插入和替換。返回數組
arr.indexOf('22',0)和 lastIndexOf() :接收兩個參數：要查找的項和（可選的）表示查找起點位置的索引。其中，從數組的開頭（位置 0）開始向後查找。未找到返回-1，找到返回個數
forEach() :對數組進行遍歷循環，對數組中的每一項運行給定函數。這個方法沒有返回值。
map():指「映射」，對數組中的每一項運行給定函數，返回每次函數調用的結果組成的數組。
filter() :「過濾」功能，數組中的每一項運行給定函數，返回知足過濾條件組成的數組。
every() :判斷數組中每一項都是否知足條件，只有全部項都知足條件，纔會返回true。
some() :判斷數組中是否存在知足條件的項，只要有一項知足條件，就會返回true。
reduce()和 reduceRight() :迭代數組的全部項，而後構建一個最終返回的值;一個在每一項上調用的函數和（可選的）做爲歸併基礎的初始值。
find():返回知足條件的第一個元素的值,若是沒有符合條件的元素返回 undefined
Array.from():方法是用於相似數組的對象（即有length屬性的對象）和可遍歷對象轉爲真正的數組。
Array.of():方法是將一組值轉變爲數組，參數不分類型，只分數量，數量爲0返回空數組。
findIndex ():findIndex和find差很少，不過默認返回的是索引，若是沒有符合條件的元素返回 -1
fill()：方法用一個固定值填充一個數組中從起始索引到終止索引內的所有元素。不包括終止索引。返回數組
keys()、values()、entries()：這三個方法都是返回一個遍歷器對象，可用for...of循環遍歷，惟一區別：keys()是對鍵名的遍歷、values()對鍵值的遍歷、entries()是對鍵值對的遍歷。
includes()：方法用來判斷一個數組是否包含一個指定的值，若是是返回 true，不然false。
copyWithin()：方法用於從數組的指定位置拷貝元素到數組的另外一個指定位置中，會覆蓋原有成員，返回數組

1.sort()

在排序時，sort()方法會調用每一個數組項的 toString()轉型方法，而後比較獲得的字符串，以肯定如何排序。即便數組中的每一項都是數值， sort()方法比較的也是字符串，所以會出現如下的這種狀況：bash

var arr1 = ["a", "d", "c", "b"];
console.log(arr1.sort()); // ["a", "b", "c", "d"]
arr2 = [13, 24, 51, 3];
console.log(arr2.sort()); // [13, 24, 3, 51]
console.log(arr2); // [13, 24, 3, 51](元數組被改變)
複製代碼

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

function compare(value1, value2) {
  if (value1 < value2) {
    return -1;
  } else if (value1 > value2) {
    return 1;
  } else {
    return 0;
  }
}
arr2 = [13, 24, 51, 3];
console.log(arr2.sort(compare)); // [3, 13, 24, 51]
複製代碼

2.concat()

concat() ：將參數添加到原數組中。這個方法會先建立當前數組一個副本，而後將接收到的參數添加到這個副本的末尾，最後返回新構建的數組。在沒有給 concat()方法傳遞參數的狀況下，它只是複製當前數組並返回副本。測試

var arr = [1,3,5,7];
var arrCopy = arr.concat(9,[11,13]);
console.log(arrCopy); //[1, 3, 5, 7, 9, 11, 13]
console.log(arr); // [1, 3, 5, 7](原數組未被修改)
複製代碼

從上面測試結果能夠發現：傳入的不是數組，則直接把參數添加到數組後面，若是傳入的是數組，則將數組中的各個項添加到數組中。可是若是傳入的是一個二維數組呢？ui

var arrCopy2 = arr.concat([9,[11,13]]);
console.log(arrCopy2); //[1, 3, 5, 7, 9, Array[2]]
console.log(arrCopy2[5]); //[11, 13]
複製代碼

上述代碼中，arrCopy2數組的第五項是一個包含兩項的() ：將參數添加到原數組中。這個方法會先建立當前數組一個副本，而後將接收到的參數添加到這個副本的末尾，最後返回新構建的數組。在沒有給 concat()方法傳遞參數的狀況下，它只是複製當前數組並返回副本。spa

var arr = [1,3,5,7];
var arrCopy = arr.concat(9,[11,13]);
console.log(arrCopy); //[1, 3, 5, 7, 9, 11, 13]
console.log(arr); // [1, 3, 5, 7](原數組未被修改)
複製代碼

從上面測試結果能夠發現：傳入的不是數組，則直接把參數添加到數組後面，若是傳入的是數組，則將數組中的各個項添加到數組中。可是若是傳入的是一個二維數組呢？

var arrCopy2 = arr.concat([9,[11,13]]);
console.log(arrCopy2); //[1, 3, 5, 7, 9, Array[2]]
console.log(arrCopy2[5]); //[11, 13]
複製代碼

上述代碼中，arrCopy2數組的第五項是一個包含兩項的數組，也就是說concat方法只能將傳入數組中的每一項添加到數組中，若是傳入數組中有些項是數組，那麼也會把這一數組項看成一項添加到arrCopy2中。

3.splice()

splice()：很強大的數組方法，它有不少種用法，能夠實現刪除、插入和替換。

刪除：能夠刪除任意數量的項，只需指定 2 個參數：要刪除的第一項的位置和要刪除的項數。例如， splice(0,2)會刪除數組中的前兩項。

插入：能夠向指定位置插入任意數量的項，只需提供 3 個參數：起始位置、 0（要刪除的項數）和要插入的項。例如，splice(2,0,4,6)會從當前數組的位置 2 開始插入4和6。

替換：能夠向指定位置插入任意數量的項，且同時刪除任意數量的項，只需指定 3 個參數：起始位置、要刪除的項數和要插入的任意數量的項。插入的項數沒必要與刪除的項數相等。例如，splice (2,1,4,6)會刪除當前數組位置 2 的項，而後再從位置 2 開始插入4和6。

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]
複製代碼

4.forEach()

//forEach()：對數組進行遍歷循環，對數組中的每一項運行給定函數。這個方法沒有返回值。參數都是function類型，默認有傳參，參數分別爲：遍歷的數組內容；第對應的數組索引，數組自己。

var arr = [1, 2, 3, 4, 5];
arr.forEach(function(x, index, a){
  console.log(x + '|' + index + '|' + (a === arr));
});
// 輸出爲：
// 1|0|true
// 2|1|true
// 3|2|true
// 4|3|true
// 5|4|true
複製代碼

5.map()

//map()：指「映射」，對數組中的每一項運行給定函數，返回每次函數調用的結果組成的數組。 //下面代碼利用map方法實現數組中每一個數求平方。

var arr = [1, 2, 3, 4, 5];
var arr2 = arr.map(function(item){
  return item*item;
});
console.log(arr2); //[1, 4, 9, 16, 25]
複製代碼

6.filter()

//filter()：「過濾」功能，數組中的每一項運行給定函數，返回知足過濾條件組成的數組。

var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
var arr2 = arr.filter(function(x, index) {   
  return index % 3 === 0 || x >= 8;
}); 
console.log(arr2); //[1, 4, 7, 8, 9, 10]
複製代碼

7.every()

every()：判斷數組中每一項都是否知足條件，只有全部項都知足條件，纔會返回true。

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

8.some()

some()：判斷數組中是否存在知足條件的項，只要有一項知足條件，就會返回true。

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

9.reduce()和 reduceRight()

這兩個方法都接收兩個參數：一個在每一項上調用的函數和（可選的）做爲歸併基礎的初始值。

傳給 reduce()和 reduceRight()的函數接收 4 個參數：前一個值、當前值、項的索引和數組對象。這個函數返回的任何值都會做爲第一個參數自動傳給下一項。第一次迭代發生在數組的第二項上，所以第一個參數是數組的第一項，第二個參數就是數組的第二項。

下面代碼用reduce()實現數組求和，數組一開始加了一個初始值10。

var values = [1,2,3,4,5];
var sum = values.reduceRight(function(prev, cur, index, array){
return prev + cur;
},10);
console.log(sum); //25
複製代碼

3、ES6數組方法

1.Array.from()

方法是用於相似數組的對象（即有length屬性的對象）和可遍歷對象轉爲真正的數組。

let json ={
   '0':'盧',
   '1':'本',
   '2':'偉',
   length:3
}
let arr = Array.from(json);
console.log(arr); // ["盧", "本", "偉"]	
複製代碼

2.Array.of()

//將一組值轉變爲數組，參數不分類型，只分數量，數量爲0返回空數組。

<script>
	let arr1 = Array.of(1,2,3);	
	let arr2 = Array.of([1,2,3]);
	let arr3 = Array.of(undefined);
	let arr4 = Array.of();
	console.log(arr1); // [1, 2, 3]
	console.log(arr2); // [[1, 2, 3]]
	console.log(arr3); // [undefined]
	console.log(arr4); // []
</script>
複製代碼

3.find()

返回經過測試（函數內判斷）的數組的第一個元素的值方法返回經過測試（函數內判斷）的數組的第一個元素的值。方法爲數組中的每一個元素都調用一次函數執行。當數組中的元素在測試條件時返回 true 時, find() 返回符合條件的元素，以後的值不會再調用執行函數。若是沒有符合條件的元素返回 undefined。回調函數能夠接收3個參數，依次爲當前的值（currentValue）、當前的位置（index）、原數組（arr）注意：find() 對於空數組，函數是不會執行的。find() 並無改變數組的原始值。

<script>
	let Arr = [1,2,5,7,5,9];
	let result1 = Arr.find(function(currentValue,index,arr){			
		return currentValue>5;
	});
	let result2 = Arr.find(function(currentValue,index,arr){			
		return currentValue>9;
	});
	console.log(result1); // 7
	console.log(result2); // undefined
</script>
複製代碼

find()實現根據id取出數組中的對象

<script>
let Arr = [
	{
		id:1,
		name:"張三"
	},
	{
		id:2,
		name:"李四"
	}		
];
let obj = Arr.find(function(currentValue,index,arr){			
	return currentValue.id===1;
});
console.log(obj.name); // 張三
</script>
複製代碼

4.findIndex ()

findIndex和find差很少，不過默認返回的是索引，若是沒有符合條件的元素返回 -1

<script>
	let Arr = [1,2,5,7,5,9];
	let result1 = Arr.findIndex(function(currentValue,index,arr){			
		return currentValue>5;
	});
	let result2 = Arr.findIndex(function(currentValue,index,arr){			
		return currentValue>9;
	});
	console.log(result1); // 3
	console.log(result2); // -1
</script>
複製代碼

5.fill()

fill()方法用一個固定值填充一個數組中從起始索引到終止索引內的所有元素。不包括終止索引。

語法：array.fill(value, start, end) value：必需。填充的值。 start：可選。開始填充位置。若是這個參數是負數，那麼它規定的是從數組尾部開始算起。 end：可選。中止填充位置 (默認爲 array.length)。若是這個參數是負數，那麼它規定的是從數組尾部開始算起。

<script>
    let arr = [1,2,3,4,5,6];
    arr.fill(0);  // [0, 0, 0, 0, 0, 0]
    arr.fill(0,1);  // [1, 0, 0, 0, 0, 0] 
    arr.fill(0,1,2);  // [1, 0, 3, 4, 5, 6]
    arr.fill(0,-1);  // [1, 2, 3, 4, 5, 0]
    arr.fill(0,1,-1);  // [1, 0, 0, 0, 0, 6]
</script>
複製代碼

6.遍歷數組方法 keys()、values()、entries()

這三個方法都是返回一個遍歷器對象，可用for...of循環遍歷，惟一區別：keys()是對鍵名的遍歷、values()對鍵值的遍歷、entries()是對鍵值對的遍歷。

keys()

<script>
	let arr = ["a","b","c","d"];
	for(let i of arr.keys()){
		console.log(i);
	}
    //打印：
    // 0
    // 1
    // 2
    // 3
</script>
values()

<script>
	let arr = ["a","b","c","d"];
	for(let i of arr.values()){
		console.log(i);
	}
    //打印：
    // a
    // b
    // c
    // d
</script>
entries()

<script>
    let arr = ["a","b","c","d"];
    for(let i of arr.entries()){
        console.log(i);
    }
    //打印：
    // [0, "a"]
    // [1, "b"]
    // [2, "c"]
    // [3, "d"]
    for(let [idx,item] of arr.entries()){
        console.log(idx+":"+item);
    }
    //打印：
    // 0:a
    // 1:b
    // 2:c
    // 3:d
</script>
複製代碼

7.includes()

方法用來判斷一個數組是否包含一個指定的值，若是是返回 true，不然false。

語法：arr.includes(searchElement , fromIndex)

searchElement ：必須。須要查找的元素值。

fromIndex：可選。從該索引處開始查找 searchElement。若是爲負值，則按升序從 array.length + fromIndex 的索引開始搜索。默認爲 0。

<script>
	let arr = ["a","b","c","d"];
	let result1 = arr.includes("b");
	let result2 = arr.includes("b",2);
	let result3 = arr.includes("b",-1);
	let result4 = arr.includes("b",-3);
	console.log(result1);  // true
	console.log(result2);  // false
	console.log(result3);  // flase
	console.log(result4);  // true
</script>
複製代碼

8.copyWithin()

方法用於從數組的指定位置拷貝元素到數組的另外一個指定位置中，會覆蓋原有成員

語法：array.copyWithin(target , start , end)

target ：必需。從該位置開始替換數據。

start ：可選。從該位置開始讀取數據，默認爲 0 。若是爲負值，表示倒數。

end：可選。到該位置前中止讀取數據，默認等於數組長度。若是爲負值，表示倒數。

<script>
    let arr = [1,2,3,4,5,6];
    let result1 = [1,2,3,4,5,6].copyWithin(0);
    let result2 = [1,2,3,4,5,6].copyWithin(0,1);
    let result3 = [1,2,3,4,5,6].copyWithin(1,3,5);
    let result4 = [1,2,3,4,5,6].copyWithin(1,2,-1);
    let result5 = [1,2,3,4,5,6].copyWithin(1,-4,6);
    console.log(result1);  // [1, 2, 3, 4, 5, 6]
    console.log(result2);  // [2, 3, 4, 5, 6, 6]
    console.log(result3);  // [1, 4, 5, 4, 5, 6]
    console.log(result4);  // [1, 3, 4, 5, 5, 6]
    console.log(result5);  // [1, 3, 4, 5, 6, 6]
</script>
複製代碼