基础

ES5

  • splice()
  • push() pop() // 增加，删除
  • shift() unshift() // 删除数组首位，在数组首位插入一个元素
  • sort() // 默认排序顺序为按字母升序，数字升序

  • reverse() // 数组元素方向反转

  • concat() // 先创建一个当前数组的副本，然后再把它的参数添加到副本末尾，最后返回新构建的数组，不影响原始数组

  • slice(begin, end) // 浅拷贝数组的元素
  • indexOf() // 返回在数组中可以找到一个给定元素的第一个索引，如果不存在，则返回-1，（indexOf不能识别NaN）
  • lastIndexOf()
  • Array.isArray() // 用于确定传递的值是否是一个 Array
  • join()
  • map()
  • filter()
  • every() // 每一项都符合条件才返回true
  • some() // 有一个符合添加就返回true

    Array.reduce()

    对累加器和数组中的每个元素（从左到右）应用一个函数，将其简化为单个值
    accumulator 累加器累加回调的返回值
    currentValue 数组中正在处理的元素
    initialValue 累加器的初始值 ```javascript arr.reduce(callback(accumulator, currentValue[, index[, array]])[, initialValue])

let arr = [{ id: 1, type: ‘A’, total: 3 }, { id: 2, type: ‘B’, total: 5 }, { id: 3, type: ‘E’, total: 7 },…] // 所有total的值 arr.reduce((sum, { total }) => { return sum + total; }, 0)

  1. <a name="kfsY8"></a>
  2. ### ES6
  4. - Array.fill(item,start,end)  -- 填充数组
  5. - find()  --  找出第一个符合条件的数组成员
  6. - findIndex  -- 返回第一个符合条件的数组成员的位置
  7. - [1, [2, [3]]].flat(Infinity)  -- 拉平嵌套的数组，都转成一维数组
  8. - includes()  -- includes可以检测NaN，indexOf不能检测NaN
  9. - Array.of()  -- 返回由所有参数值组成的数组
  10. - entries()，keys()，values() -- 遍历
  11. <a name="CoHtK"></a>
  12. #### Array.from(arrayLike,mapFn,thisArg)    
  13. 从类似数组或可迭代对象创建一个新的(浅拷贝)的数组实例  <br /> mapFn   新数组中的每个元素会执行该函数  <br /> thisArg   执行回调函数mapFn时this对象  
  14. <a name="AgSlR"></a>
  15. ## 常用操作
  16. <a name="kqseY"></a>
  17. ### 判断是不是数组的方法
  18. ```javascript
  19. [1, 2, 3] instanceof Array
  21. [1, 2, 3].constructor === Array
  23. // 最常用
  24. Array.isArray([1, 2, 3])
  26. Object.prototype.toString.call([1, 2, 3]) === '[object Array]'

类数组和数组的转换

类数组： 拥有length属性， 类型为Object， 元素属性名是数值或者可转换为数值的字符

  1. Array.prototype.slice.call(xArr);
  3. Array.from(xArr)
  5. Array.of(xArr)
  7. [...xArr]
  9. // 传给 apply 的第二个参数（数组或者类数组）会被转换为一个参数列表
  10. Array.apply(null,xArr)
  12. // 遍历push

数组去重

  1. // 利用 set 去重
  2. [...new Set(arr)]
  3. Array.from(new Set(arr))
  5. // 双重循环 + 相等则 splice 移除
  7. // 新建数组 + 添加前includes验证 
  8. arr.forEach((item,index) => {
  9.   if(!res.includes(item)){
  10.     res.push(item)
  11.   }
  12. })
  14. // 新建数组 + 添加前map验证 
  15. function unique(arr){
  16.   let map = new Map()
  17.   for(item of arr){
  18.     if(!map.has(item)){
  19.       map.set(item,true)
  20.     }
  21.   }
  22.   return [...map.keys()]
  23. }
  25. // reduce + includes
  26. arr.reduce((acc,cur) => {
  27.   // return acc.includes(cur) ? acc : acc.concat(cur)
  28.   return acc.includes(cur) ? acc : [...acc,cur]
  29. },[])

数组扁平化

  1. let arr = [1,[1,2,[3]]]
  3. // flat 传参 Infinity，实现完全降维
  4. arr.flat(Infinity)
  6. // reduce + 递归
  7. function flatten(arr) {
  8.   return arr.reduce((acc, cur) => {
  9.     if (Array.isArray(cur)) {
  10.       return [...acc, ...flatten(cur)]
  11.     } else {
  12.       return [...acc, cur]
  13.     }
  14.   },[])
  15. }
  16. // forEach + 递归
  18. // 先转为字符串去掉括号，再 split 转数组  （数据类型相同）
  19. arr.toString().split(",")
  21. // while + some
  22. while(arr.some(item => Array.isArray(item))){
  23.   arr = [].concat(...arr)
  24. }

数组元素出现个数/数组中重复的元素

  1. // map + filter
  2. function search(arr) {
  3.   const map = new Map()
  4.   // 没有就存,有就加1
  5.   for (item of arr) {
  6.     if (!map.has(item)) {
  7.       map.set(item, 1)
  8.     } else {
  9.       map.set(item, map.get(item) + 1)
  10.     }
  11.   }
  12.   // 找出重复元素，即出现次数大于1
  13.   // const searchArr = [...map.entries()].filter(item => item[1] > 1)  // 过滤出item[1]即次数大于1的
  14.   // return searchArr.map(item => item[0]) // 提出item[0]也就是值
  16.   // 找出重复次数最多的元素
  17.   return [...map.entries()].filter(item => item[1] === Math.max(...map.values())).map(item => item[0])
  18. }