数组置空

  1. let arr = [1,2,3]
  2. arr = []
  3. //只是改变引用地址,数组先前的内容依旧保存在内存中,当数据量比较大时,可以会造成内存泄漏
  4. let arr = [1,2,3]
  5. arr.length = 0
  6. //可以彻底清空arr数据的内容

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

数组去重

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. }
  5. console.log(unique(arr))
  6. //[1,8,12,15,16]
  7. // 数组去重
  8. let arr = [1, 1, 2, 3];
  9. let unique = [... new Set(arr)];
  10. let a = new Set([1, 2, 3]);
  11. let b = new Set([4, 3, 2]);
  12. // 并集
  13. let union = [...new Set([...a, ...b])]; // [1,2,3,4]
  14. // 交集
  15. let intersect = [...new Set([...a].filter(x => b.has(x)))]; [2,3]
  16. // 差集
  17. 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];
  2. function unlink(arr) {
  3. for (var i = 0; i < arr.length; i++) { // 首次遍历数组
  4. for (var j = i + 1; j < arr.length; j++) { // 再次遍历数组
  5. if (arr[i] == arr[j]) { // 判断连个值是否相等
  6. arr.splice(j, 1); // 相等删除后者
  7. j--;
  8. }
  9. }
  10. }
  11. return arr
  12. }
  13. 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)) // => ['张三', '王五']
  4. // 获取重复项(交集)
  5. let getRepeatItem = (
  6. arr1: Array<LabelMining>,
  7. arr2: Array<LabelMining>
  8. ) => {
  9. const arr2Ids = arr2.map((item) => item.labelId)
  10. const repeatArr = arr1.filter((item) => arr2Ids.includes(item.labelId))
  11. return repeatArr
  12. }

数组是否相同

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