数组置空

  1. let arr = [1,2,3]
  2. arr = []
  3. // 只是改变引用地址，数组先前的内容依旧保存在内存中，当数据量比较大时，可以会造成内存泄漏
  5. let arr = [1,2,3]
  6. arr.length = 0
  7. // 可以彻底清空arr数据的内容
  9. let arr = [1,2,3]
  10. arr.splice(0, arr.length);
  11. // 调用实例方法 splice 删除数组所有元素

注意：通过arr.length清空数组，需要注意当一个数组赋值给多个变量时，多个变量指向同一个数组的引用地址，那么清空一个变量，会导致其他变量也为空，所以在初始赋值时可以考虑使用深拷贝规避下这个问题。

三种方式效率简单对比：

  1. var a = [];
  2. for (var i = 0; i < 100000000; i++) {
  3.   a.push(i);
  4. }
  5. console.time("splice");
  6. a.splice(0, a.length);
  7. console.timeEnd("splice");
  10. var b = [];
  11. for (var i = 0; i < 100000000; i++) {
  12.   b.push(i);
  13. }
  14. console.time("length");
  15. b.length = 0;
  16. console.timeEnd("length");
  18. var c = [];
  19. for (var i = 0; i < 100000000; i++) {
  20.   c.push(i);
  21. }
  22. console.time("赋值[]");
  23. c = [];
  24. console.timeEnd("赋值[]");

image.png

数组中的最小值和最大值

可以简单地使用 Math.min() 或 Math.max() 结合扩展运算符 …

  1. const nums = [2, 4, 6, 8, 1, 3, 5, 7];
  3. Math.max(...nums); // 8
  4. Math.min(...nums); // 1

数组对象

  1. const minBy = (arr, fn) =>
  2.   Math.min(...arr.map(typeof fn === 'function' ? fn : val => val[fn]));
  4. minBy([{ n: 4 }, { n: 2 }, { n: 8 }, { n: 6 }], x => x.n); // 2
  5. minBy([{ n: 4 }, { n: 2 }, { n: 8 }, { n: 6 }], 'n'); // 2
  1. const maxBy = (arr, fn) =>
  2.   Math.max(...arr.map(typeof fn === 'function' ? fn : val => val[fn]));
  4. maxBy([{ n: 4 }, { n: 2 }, { n: 8 }, { n: 6 }], x => x.n); // 8
  5. maxBy([{ n: 4 }, { n: 2 }, { n: 8 }, { n: 6 }], 'n'); // 8

数组去重

ES6 Set去重

  1. var arr = [1,1,8,8,12,12,15,15,16,16];
  2. function unique (arr) {
  3.   return Array.from(new Set(arr))
  4. }
  6. console.log(unique(arr))
  7.  //[1,8,12,15,16]
  10. // 数组去重
  11. let arr = [1, 1, 2, 3];
  12. let unique = [... new Set(arr)];
  14. let a = new Set([1, 2, 3]);
  15. let b = new Set([4, 3, 2]);
  17. // 并集
  18. let union = [...new Set([...a, ...b])]; // [1,2,3,4]
  20. // 交集
  21. let intersect = [...new Set([...a].filter(x => b.has(x)))]; [2,3]
  23. // 差集
  24. let difference = Array.from(new Set([...a].filter(x => !b.has(x)))); [1]

不考虑兼容性，这种去重的方法代码最少。这种方法还无法去掉“{}”空对象，后面的高阶方法会添加去掉重复“{}”的方法。

利用for嵌套for，然后splice去重（ES5中最常用）

  1. var arr = [1, 1, 8, 8, 12, 12, 15, 15, 16, 16];
  3. function unlink(arr) {
  4.     for (var i = 0; i < arr.length; i++) {    // 首次遍历数组
  5.         for (var j = i + 1; j < arr.length; j++) {   // 再次遍历数组
  6.             if (arr[i] == arr[j]) {          // 判断连个值是否相等
  7.                 arr.splice(j, 1);           // 相等删除后者
  8.                 j--;
  9.             }
  10.         }
  11.     }
  12.     return arr
  13. }
  14. console.log(unlink(arr));

Map去重

数组元素包含对象等类型，又该如何去重

  1. let filterRepeatItem = (array: Array<any>) => {
  2.   let map = new Map()
  3.   for (let item of array) {
  4.     if (!map.has(item.valueId)) {
  5.       map.set(item.valueId, item)
  6.     }
  7.   }
  8.   return [...map.values()]
  9. }

数组交集

  1. let arr2 = ['张三', '李四', '王五', '找六', '张三']
  2. let arr3 = ['小明', '小红', '王五', '张三']
  3. let jiaoji = [...new Set(arr2)].filter(item => arr3.includes(item)) // => ['张三', '王五']
  5. // 获取重复项（交集） 
  6.  let getRepeatItem = (
  7.    arr1: Array<LabelMining>,
  8.    arr2: Array<LabelMining>
  9.  ) => {
  10.    const arr2Ids = arr2.map((item) => item.labelId)
  11.    const repeatArr = arr1.filter((item) => arr2Ids.includes(item.labelId))
  12.    return repeatArr
  13.  }

数组是否相同

  1. var a = ["1", "2", "3"];
  2. var b = ["3", "2", "1"];
  4.   /* 用a的第一个元素和b的所有元素从左到右依次进行比较，
  5.       找到相同元素就将a的这个元素和b的这个元素删除掉，
  6.       接着用a的第二个元素和b的所有元素从左到右依次比较，
  7.       相同元素就从a和b中删除掉，去除所有重复项目后，
  8.       最后看a和b中 有没有多余的元素
  9.     */
  10. function sameArr(aa, bb) {
  11.   if (aa.length != bb.length) {
  12.     return false;
  13.   }
  14.   let cc = [...bb];
  15.   for (let item in aa) {
  16.     for (let it in cc) {
  17.       if (aa[item] === cc[it]) {
  18.         cc.splice(it, 1);
  19.       }
  20.     }
  21.   }
  22.   return cc.length < 1 ? true : false;
  23. }
  25. let result = sameArr(a, b);
  26. console.log(result);
  1. function copy(value) {
  2.   return JSON.parse(JSON.stringify(value));
  3. }
  5. function isArrayEqual(value1 = [], value2 = []) {
  6.   let hash = copy(value2);
  7.   if (value1.length === value2.length) {
  8.     for (let i = 0; i < value1.length; i++) {
  9.       const index = hash.indexOf(value1[i]);
  10.       if (index > -1) {
  11.         hash.splice(index, 1);
  12.       } else {
  13.         return false;
  14.       }
  15.     }
  17.     return true;
  18.   }
  20.   return false;
  21. }
  23. console.log(isArrayEqual([1, 2, 3], [2, 1, 3])); // true
  24. console.log(isArrayEqual([1, 2], [1, 1])); // false