JS-陣列常用方法整理

想了解陣列有哪些原生方法，控制臺輸出，如圖：

length：陣列的實體屬性，回傳或設定一個陣列中的元素個數，

toString()：可以把陣列轉換成字串，并回傳結果，

toLocaleString()：回傳陣列中每個元素的本地化表示形式，

let a = [1234,'hello',21];
a.length; //3
a.toString();  //'1234','hello','21'
a.toLocaleString();  //'1,234','hello','21'

join([seperator])：回傳一個字串，由每個元素轉換而成的字串使用指定的seperator拼接而成，

let a = [1234,'hello',21];
a.join('-'); //'1234-hello-21'

concat()：拼接兩個或更多的陣列，并回傳結果，此方法不會更改現有陣列，而是回傳一個新陣列，每個引數可以是一個值，也可以是一個陣列，可以接收任意多個引數，可用作拷貝陣列，

let a = [1234,'hello',21];
let b = a.concat(50,60,[1,2,3]); //[1234, "hello", 21, 50, 60, 1, 2, 3]

reverse()：顛倒陣列中元素的順序，現有陣列內容會改變，

let a = [1234,'hello',21];
let b = a.reverse();
a; //[21, "hello", 1234]
b; //[21, "hello", 1234]

sort()：講陣列元素按Unicode碼進行重新排序，

let a = [1234,'hello',21,'bar',6,789];
a.sort();
a; //[1234, 21, 6, 789, "bar", "hello"]

slice(start, [end]) : 回傳現有陣列的一個子陣列，從下標為start的位置開始取，到下標為end的為止(獲取內容不包括end)，若引數為負數，則表示從尾部開始算起，end引數可以省略，可用作拷貝陣列，

let a = [1234,'hello',21,'bar',6,789];
let b = a.slice(1,4); //["hello", 21, "bar"]
let c = a.slice(2); //[21, "bar", 6, 789]
let d = a.slice(-4,-2); //[21, "bar"]
a; //[1234, "hello", 21, "bar", 6, 789]

splice(start,count,e1,e2,...en)：從陣列中洗掉一部分元素，并添加另一部分元素，start為指定添加/洗掉的起始位置，可取負值，count為要洗掉的個數，0表示不洗掉，e1，e2表示在start新添加的項，回傳會洗掉的專案，現有陣列會改變，

let a = [10,20,30,40,50];
let b = a.splice(2,2,110);
b; //[30,40]
a; //[10,20,110,50,]
let c = a.splice(2,0,[70,80,90]);
c; //[]
a; //[10,20,[70,80,90],110,50]

push()：將一個或多個元素添加到陣列的末尾，并回傳該陣列的新長度，

unshift()：將一個或多個元素添加到陣列的開頭，并回傳該陣列的新長度，

pop()：從陣列中洗掉最后一個元素，并回傳該元素的值，此方法更改陣列的長度，

shift()：從陣列中洗掉第一個元素，并回傳該元素的值，此方法更改陣列的長度，

let a = [10,20,30,40,50];
let a1 = a.push(60);
a1; //6
a; //[10,20,30,40,50,60]

let b = [10,20,30,40,50];
let b1 = b.unshift(60);
b1; //6
b; //[60,10,20,30,40,50]

let c = [10,20,30,40,50];
let c1 = c.pop();
c1; //50
c; //[10,20,30,40]

let d = [10,20,30,40,50];
let d1 = d.shift();
d1; //10
d; //[20,30,40,50]

includes()：用來判斷一個陣列是否包含一個指定的值，根據情況，如果包含則回傳 true，否則回傳false，

let array1 = [1, 2, 3];
array1.includes(2); //true

indexOf(value, [fromIndex])：回傳在陣列中可以找到一個給定元素的第一個索引，如果不存在，則回傳-1，fromIndex為可選，指定從該下標處開始進行查找，

lastIndexOf(value, [fromIndex])：回傳指定元素在陣列中的最后一個的索引，如果不存在則回傳 -1，從陣列的后面向前查找，從 fromIndex 處開始，

let beasts = ['ant', 'bison', 'camel', 'duck', 'bison'];
beasts.indexOf('bison'); //1
beasts.indexOf('bison', 2); //4
beasts.indexOf('giraffe'); //-1

beasts.lastIndexOf('bison'); //4
beasts.lastIndexOf('bison', 2); //1
beasts.lastIndexOf('giraffe'); //-1

find()：回傳陣列中滿足提供的測驗函式的第一個元素的值，否則回傳undefined，

findIndex()：回傳陣列中滿足提供的測驗函式的第一個元素的索引，否則回傳-1，

let array1 = [5, 12, 8, 130, 44];
let val = array1.find(element => element > 10);
let index = array1.findIndex(element => element > 10);
val; //12
index; //1

forEach()：對陣列的每個元素執行一次提供的函式，

filter()：創建一個新陣列, 其包含通過所提供函式實作的測驗的所有元素，

map()：創建一個新陣列，其結果是該陣列中的每個元素都呼叫一個提供的函式后回傳的結果，

reduce(reducer[,initialValue])：對陣列中的每個元素執行一個由您提供的reducer函式(升序執行)，將其結果匯總為單個回傳值，reducer 函式接收4個引數:Accumulator (acc) (累計器)、Current Value (cur) (當前值)、Current Index (idx) (當前索引)、Source Array (src) (源陣列)，initialValue作為第一次呼叫 callback函式時的第一個引數的值，如果沒有提供初始值，則將使用陣列中的第一個元素，

accumulator為累加器，currentValue為當前值，index為當前索引，array為源陣列，

every()：測驗一個陣列內的所有元素是否都能通過某個指定函式的測驗，它回傳一個布林值，

some()：測驗陣列中是不是至少有1個元素通過了被提供的函式測驗，它回傳的是一個Boolean型別的值，

let array1 = ['a', 'b', 'c'];
array1.forEach(element => console.log(element)); //'a'\n 'b'\n 'c' 
array1; //['a', 'b', 'c']

let words = ['spray', 'limit', 'elite', 'exuberant', 'destruction', 'present'];
let result = words.filter(word => word.length > 6);
result; //["exuberant", "destruction", "present"]
words; //["spray", "limit", "elite", "exuberant", "destruction", "present"]

let array2 = [1, 4, 9, 16];
let map1 = array2.map(x => x * 2);
map1; //[2, 8, 18, 32]
array2; //[1, 4, 9, 16]

let array3 = [1, 2, 3, 4];
let reducer = (accumulator, currentValue) => accumulator + currentValue;
array3.reduce(reducer); //10
array3.reduce(reducer, 5); //15
array3; //[1, 2, 3, 4]

let isBelowThreshold = (currentValue) => currentValue < 40;
let array4 = [1, 30, 39, 29, 10, 13];
let array5 = [1, 30, 39, 291, 10, 13];
array4.every(isBelowThreshold); // true
array5.every(isBelowThreshold); // false

let array = [1, 2, 3, 4, 5];
let even = (element) => element % 2 === 0;
array.some(even); // true

flat([depth])：會按照一個可指定的深度遞回遍歷陣列，并將所有元素與遍歷到的子陣列中的元素合并為一個新陣列回傳，depth指定要提取嵌套陣列的結構深度，默認值為 1，可用作扁平化嵌套陣列，

let arr1 = [1, 2, [3, 4],[5,[6,[7]]]];
let b = arr1.flat(); 
let c = arr1.flat(2); 
let d = arr1.flat(Infinity); 
arr1; // [1, 2, [3, 4],[5,[6,[7]]]]
b; // [1, 2, [3, 4],[5,[6,[7]]]]
c; //[1,2,3,4,5,[6,[7]]]
d; //[1,2,3,4,5,6,7]

Array.from()：從一個類似陣列或可迭代物件創建一個新的，淺拷貝的陣列實體，

Array.of()：用于將一組值，轉換為陣列，

let arrayLike = {
    '0': 'a',
    '1': 'b',
    '2': 'c',
    length: 3
};
let arr2 = Array.from(arrayLike); // ['a', 'b', 'c']

Array.of(3, 11, 8) // [3,11,8]
Array.of(3) // [3]
Array.of(3).length // 1

Array.isArray()：確定傳遞的值是否是一個array，

Array.isArray([1, 2, 3]);  // true
Array.isArray({foo: 123}); // false
Array.isArray("foobar");   // false
Array.isArray(undefined);  // false

先介紹這么多，有空的時候再補充，

標籤：其他

上一篇：Vue-router

下一篇：web前端-基礎篇