常用的方法(数组)

• 现有数组

const arr = [1,2,3];
const arr2 = [7,8,9]

1. arr.push() 在数组末尾添加新元素，返回值：数组新长度

console.log(arr.push(5));//4

arr.push(5)
console.log(arr);//[1,2,3,5]

2. arr.pop() 删除数组的最后一个元素，返回值：该元素

console.log(arr.pop());//3

arr.pop()
console.log(arr);//[1,2]

3. arr.unshift() 在数组的首位添加一个新元素，返回值：数组的新长度

console.log(arr.unshift(0));//4

arr.unshift(0)
console.log(arr);//[0,1,2,3]

4. arr.shift() 删除数组的首位元素，返回值：该元素

console.log(arr.shift());//1

arr.shift()
console.log(arr);//[2,3]

5. arr.reverse() 颠倒数组，返回值：颠倒后的数组

console.log(arr.reverse());//[3,2,1]

6. arr.slice() 选择数组的一部分，返回值：选择的数组部分,不改变原数组

//两个参数(开始索引，结束索引)，选择内容为从开始索引到结束索引(不包含结束索引)
console.log(arr.slice(0,2));[1,2]

arr.slice(0,2)
console.log(arr);//[1,2,3]，

7. 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]

8. arr.toString() 将数组转化为字符串，返回值：改变后的字符串，不改变原数组

console.log(arr.toString());//1,2,3
console.log(arr);//[1,2,3]

9. 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

10. arr.join() 将数组的所有元素拼成一个字符串，返回值：拼接后的字符串，不改变原数组

console.log(arr.join());//1,2,3 默认是以 , 拼接
console.log(arr.join('-'));//1-2-3
console.log('拼接');//1拼接2拼接3

11. arr.map() map循环，返回值：每个元素调用函数后的结果，不会改变原数组

//函数为必填项
console.log(arr.map(item=>item+2));[3,4,5]

12. 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]

13. arr.filter() 数组过滤，返回值：符合函数过滤条件的元素，不改变原数组

//参数为一个函数 必选
console.log(arr.filter(item=>item>0));//[1,2]

14. 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]

15. 合并数组 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]

16. arr.fill() 静态值填充数组中的指定元素，返回值：改变后的数组，会改变原数组

 /*
  * array.fill(value, start, end)
  * 有三个参数
  * value 静态的值
  * start 可选 开始索引
  * end 可选 结束索引,不包含结束索引，默认为数组长度
  */
console.log(arr.fill('a',1,2));//[a,'a',3]

17. 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]

18. arr.indexOf() 从数组中搜索指定元素，有则返回第一次出现的索引，没有则返回-1

console.log(arr.indexOf(3));//2
console.log(4);//-1

19. arr.lastIndexOf() 倒序从数组中搜寻某个元素，有则返回索引，没有返回-1

console.log(arr.lastIndexOf(4));//-1
console.log(arr.lastIndexOf(2));//1

20. arr.find() 元素查找，返回值：第一个符合函数过滤条件的元素，没有则为undefined，不改变原数组

console.log(arr.find(item=>item>0));//1
console.log(arr.find(item=>item>3));//undefined

21. arr.findIndex() 获取第一个符合条件的元素的索引，类似于arr.indexOF()，返回值：第一个符合条件的元素的索引，没有则返回undefined，不改变原数组

console.log(arr.finIndex(item=>item>2));//2
console.log(arr.findindex(item=>item<0));//undefined

22. arr.every() 判断数组的元素是否全部符合条件，返回值：Boolean，不会改变原数组

//参数是一个函数 必填
console.log(arr.every(item=>item>3));//false
console.log(arr.every(item=>item>0));//true

23. arr.includes() 判断数组是否包含指定元素，返回值：Boolean，区分大小写，不改变原数组

console.log(arr.includes(4));//false
console.log(2);//true

24. arr.some() 检查数组中的元素是否符合条件，返回值：Boolean，不改变原数组

//参数为一个函数 必选
//和arr.includes()类似，区别：找到后则不再往下寻找
console.log(arr.some(item=>item>3));//false
console.log(item.some(1));//true

25. 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]原数组的键的数组

26. 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]]

27. 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]

28. arr.valueOf() 返回数组，是数组的默认方法，不会改变原数组

console.log(arr.valueOf());//[1,2,3]

29. 数组去重(只列举一个代码最少的),不改变原数组

const arr2 = [NaN,NaN,'aa','aa',2,24,24,null.null]
console.log([...new Set(arr2)])

30. 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]]

• 为了方便使用，特此记录