- 現有數組
const arr = [1,2,3];
const arr2 = [7,8,9]
- arr.push() 在數組末尾添加新元素，返回值：數組新長度
console.log(arr.push(5));//4
arr.push(5)
console.log(arr);//[1,2,3,5]
- arr.pop() 刪除數組的最后一個元素，返回值：該元素
console.log(arr.pop());//3
arr.pop()
console.log(arr);//[1,2]
- arr.unshift() 在數組的首位添加一個新元素，返回值：數組的新長度
console.log(arr.unshift(0));//4
arr.unshift(0)
console.log(arr);//[0,1,2,3]
- arr.shift() 刪除數組的首位元素，返回值：該元素
console.log(arr.shift());//1
arr.shift()
console.log(arr);//[2,3]
- arr.reverse() 顛倒數組，返回值：顛倒后的數組
console.log(arr.reverse());//[3,2,1]
- arr.slice() 選擇數組的一部分，返回值：選擇的數組部分,不改變原數組
//兩個參數(開始索引，結束索引)，選擇內容為從開始索引到結束索引(不包含結束索引)
console.log(arr.slice(0,2));[1,2]
arr.slice(0,2)
console.log(arr);//[1,2,3]，
- arr.splice() 從數組中添加，刪除元素，返回值：被刪除的元素，改變原數組
/*
*arr.splice(index,howmany,item1,item2)
*三個參數 index howmany item
*index 必選 整數 指定在什么位置添加或者刪除元素，負值則為數組末尾位置
*howmany 可選 要刪除的元素數量 0為不刪除
*item 可選 可以為多個 要添加到數組的元素
*/
console.log(arr.splice(0,1));//[1]
console.log(arr);[2,3]
console.log(arr.splice(0,0,22,33));//[]
console.log(arr);//[22,33,2,3]
- arr.toString() 將數組轉化為字符串，返回值：改變后的字符串，不改變原數組
console.log(arr.toString());//1,2,3
console.log(arr);//[1,2,3]
- Array.isArray() 判斷對象是否是數組，返回值：Boolean
console.log(Array.isArray(arr));//true
const obj={a:10}
console.log(Array.isArray(obj));//false
let str = 'hello'
console.log(Array.isArray(str));//false
- arr.join() 將數組的所有元素拼成一個字符串，返回值：拼接后的字符串，不改變原數組
console.log(arr.join());//1,2,3 默認是以 , 拼接
console.log(arr.join('-'));//1-2-3
console.log('拼接');//1拼接2拼接3
- arr.map() map循環，返回值：每個元素調用函數后的結果，不會改變原數組
//函數為必填項
console.log(arr.map(item=>item+2));[3,4,5]
- arr.forEach() forEach循環，元素按順序執行調用函數，沒有返回值
console.log(arr.forEach(item=>item+=2));//undefined
//一般用于對數組進行的處理
const temp = []
arr.forEach(item=>{
temp.push(item+=5)
})
console.log(temp);//[6,7,8]
- arr.filter() 數組過濾，返回值：符合函數過濾條件的元素，不改變原數組
//參數為一個函數 必選
console.log(arr.filter(item=>item>0));//[1,2]
- arr.concat() 合并數組，合并后的新數組,不改變原數組
const arr2 = [4,5,6];
const arr3 = [7,8,9];
console.log(arr.concat(arr2,arr3));//[1,2,3,4,5,6,7,8,9]
console.log(arr);//[1,2,3]
- 合并數組 ES6的...擴展運算符
const arr2 = [4,5,6];
const arr3 = [7,8,9];
console.log([...arr,...arr2,...arr3]);//[1,2,3,4,5,6,7,8,9]
- arr.fill() 靜態值填充數組中的指定元素，返回值：改變后的數組，會改變原數組
/*
* array.fill(value, start, end)
* 有三個參數
* value 靜態的值
* start 可選 開始索引
* end 可選 結束索引,不包含結束索引，默認為數組長度
*/
console.log(arr.fill('a',1,2));//[a,'a',3]
- arr.copyWithin() 將數組中的元素復制到數組的另一個位置，覆蓋現有的，返回值：復制之后的，改變原數組
/*
* array.copyWithin(target, start, end)
* 三個參數
* target 必選 元素被復制到的索引位置
* start 可選 開始復制的索引位置
* end 可選 結束復制的索引位置,不選則為最后的索引
*/
console.log(arr.copyWithin(1,0));//[1,1,2]
console.log(arr);//[1,1,2]
- arr.indexOf() 從數組中搜索指定元素，有則返回第一次出現的索引，沒有則返回-1
console.log(arr.indexOf(3));//2
console.log(4);//-1
- arr.lastIndexOf() 倒序從數組中搜尋某個元素，有則返回索引，沒有返回-1
console.log(arr.lastIndexOf(4));//-1
console.log(arr.lastIndexOf(2));//1
- arr.find() 元素查找，返回值：第一個符合函數過濾條件的元素，沒有則為undefined，不改變原數組
console.log(arr.find(item=>item>0));//1
console.log(arr.find(item=>item>3));//undefined
- arr.findIndex() 獲取第一個符合條件的元素的索引，類似于arr.indexOF()，返回值：第一個符合條件的元素的索引，沒有則返回undefined，不改變原數組
console.log(arr.finIndex(item=>item>2));//2
console.log(arr.findindex(item=>item<0));//undefined
- arr.every() 判斷數組的元素是否全部符合條件，返回值：Boolean，不會改變原數組
//參數是一個函數 必填
console.log(arr.every(item=>item>3));//false
console.log(arr.every(item=>item>0));//true
- arr.includes() 判斷數組是否包含指定元素，返回值：Boolean，區分大小寫，不改變原數組
console.log(arr.includes(4));//false
console.log(2);//true
- arr.some() 檢查數組中的元素是否符合條件，返回值：Boolean，不改變原數組
//參數為一個函數 必選
//和arr.includes()類似，區別：找到后則不再往下尋找
console.log(arr.some(item=>item>3));//false
console.log(item.some(1));//true
- arr.keys() 返回帶有數組鍵的Array interator對象，不改變原數組
console.log(arr.keys());//Array interator
let temp = arr.keys()
let arr2 = []
for(let item of temp){
arr2.push(item)
}
console.log(arr2);//[0,1,2]原數組的鍵的數組
- arr.entries() 返回帶有鍵/值對形式的Array interator對象，帶有interator接口的可以使用for...of...循環不改變原數組
console.log(arr.entries());//Array Interator {}
let temp = arr.entries()
let arr2 = []
for(let item of temp){
arr2.push(item)
};
//變成了二維數組，數組的第一個值為索引，第二個值為元素本身
console.log(arr2);//[[0,1],[1,2],[2,3]]
- arr.sort() 排序，默認是按字母和升序將值作為字符串進行排序，有一些局限性，所以一般情況下傳入一個比較函數使用，返回值：排序后的函數，會改變原數組
const arr2 = [10,5,32,65,235]
console.log(arr.sort((a,b)=>{return a-b}));//[5,10,32,65,235]升序
console.log(arr.sort((a,b)=>{return b-a}));//[235,65,32,10,5] 降序
console.log(arr2);//[235,65,32,10,5]
- arr.valueOf() 返回數組，是數組的默認方法，不會改變原數組
console.log(arr.valueOf());//[1,2,3]
- 數組去重(只列舉一個代碼最少的),不改變原數組
const arr2 = [NaN,NaN,'aa','aa',2,24,24,null.null]
console.log([...new Set(arr2)])
- arr.reduce() 數組求和或其他
previousValue 上一次回調函數的返回值，初始值為：initialValue，若initialValue沒有值則使用第一個元素
item 下一個元素，initialValue有值時，初始值為第一個元素，若initialValue沒有值，初始值為第二個元素，之后每次執行回調都使用下一個元素
index 元素下標
arr 調用方法的數組
initialValue 初始值【可選】initialValue有值時，第一次調用會傳給previousValue,回調執行arr.length次，沒有值時，回調執行arr.length-1次
arr.reduce((previousValue, item, index, arr) => {}, initialValue)
let arr = [1,3,2,4,5,6,7,8]
let res = arr.reduce((prev,item,index,arr)=>{
return prev + item
},0)
console.log(res) // 36
附一個小示例：
[1,2,3,4,5][2,3,5,1,9]，[3,7,8]，[3,4,5,6] 取出在所有數組里出現的元素，以及元素出現的次數。
const arr1 = [1, 2, 3, 4, 5]
const arr2 = [2, 3, 4, 5, 6]
const arr3 = [3, 4, 5, 6, 7]
const arr4 = [4, 5, 6, 7, 8]
let arr = [].concat(arr1, arr2, arr3, arr4)//合并數組
// 記錄每個元素出現的次數 {1:1,2:3,...}
const res = arr.reduce((prev, cur) => {
if (cur in prev) {
prev[cur]++
} else {
prev[cur] = 1
}
return prev
}, {})
// 對象轉換為數組套數組的形式，并根據出現的次數進行排序
let resArr = Object.entries(res).sort((a, b) => { return b[1] - a[1] })// a-b 升序 b-a 降序
console.log('結果', resArr)
// 打印結果示例： [['4', 4],['5', 4],['3', 3],['6', 3],['2', 2],['7', 2],['1', 1],['8', 1]]
- 為了方便使用，特此記錄
