尼采般地抒情

公告栏

此网站主题为本人手写主题,主题还在开发中……


作者:尼采般地抒情

站点信息

文章数目:296 篇
已运行时间:
目录
  1. 一、利用 ES6 Set 去重(ES6 中最常用)
  2. 二、利用 for 嵌套 for,然后 splice 去重(ES5 中最常用)
  3. 三、利用 includes/indexOf 去重
  4. 四、利用 sort()
  5. 五、利用 filter
  6. 六、利用 reduce
  7. 利用对象的属性不能相同的特点进行去重(这种数组去重的方法有问题,不建议用,有待改进)
  8. 利用 hasOwnProperty
  9. 利用递归去重
  10. 利用 Map 数据结构去重

尼采般地抒情

尼采般地抒情

公告栏

此网站主题为本人手写主题,主题还在开发中……


作者:尼采般地抒情

站点信息

文章数目:296 篇
已运行时间:

总结来看,去重分三种思路:

  • es6 的 Set 数据结构
  • Array 的各类 api
  • 利用对象的属性

文章参考:https://segmentfault.com/a/1190000016418021

一、利用 ES6 Set 去重(ES6 中最常用)

arr_test = [
  0,
  0,
  999,
  999,
  "字符串",
  "字符串",
  true,
  true,
  false,
  false,
  undefined,
  undefined,
  null,
  null,
  NaN,
  NaN,
  {},
  {},
  [],
  [],
];

let unique_set = (arr) => {
  return Array.from(new Set(arr));
};

console.log(unique_set(arr_test));

或者……

console.log([...new Set(arr_test)]);

image.png

去不掉
  • {}
  • []

二、利用 for 嵌套 for,然后 splice 去重(ES5 中最常用)

arr_test = [
  0,
  0,
  999,
  999,
  "字符串",
  "字符串",
  true,
  true,
  false,
  false,
  undefined,
  undefined,
  null,
  null,
  NaN,
  NaN,
  {},
  {},
  [],
  [],
];

let unique_for_for_splice = (arr) => {
  for (let i = 0; i < arr.length; i++) {
    for (let j = i + 1; j < arr.length; j++) {
      if (arr[i] === arr[j]) {
        arr.splice(j, 1);
      }
    }
  }
  return arr;
};
console.log(unique_for_for_splice(arr_test));

image.png

去不掉
  • NaN
  • {}
  • []

三、利用 includes/indexOf 去重

let unique_includes = (arr) => {
  let result = [];
  arr.forEach((data) => {
    if (!result.includes(data)) result.push(data);
  });
  return result;
};
console.log(unique_includes(arr_test));
let unique_indexof = (arr) => {
  let result = [];
  arr.forEach((data) => {
    if (result.indexOf(data) === -1) result.push(data);
  });
  return result;
};
console.log(unique_indexof(arr_test));

image.png

四、利用 sort()

let unique_sort = (arr) => {
  arr.sort().forEach((data, index) => {
    if (data === arr[index + 1] && index < arr.length - 1)
      arr.splice(index + 1, 1);
  });
  return arr;
};
console.log(unique_indexof(arr_test));

image.png

五、利用 filter

let unique_filter = (arr) => {
  return arr.filter((data, index, arr) => {
    return arr.indexOf(data, 0) === index;
  });
};
console.log(unique_filter(arr_test));

image.png

六、利用 reduce

let unique_reduce = (arr) => {
  return arr.reduce((a, b) => (a.includes(b) ? a : [...a, b]), []);
};
console.log(unique_reduce(arr_test));

image.png

利用对象的属性不能相同的特点进行去重(这种数组去重的方法有问题,不建议用,有待改进)

function unique(arr) {
    if (!Array.isArray(arr)) {
        console.log('type error!')
        return
    }
    var arrry= \[\];
     var  obj = {};
    for (var i = 0; i < arr.length; i++) {
        if (!obj\[arr\[i\]\]) {
            arrry.push(arr\[i\])
            obj\[arr\[i\]\] = 1
        } else {
            obj\[arr\[i\]\]++
        }
    }
    return arrry;
}
    var arr = \[1,1,'true','true',true,true,15,15,false,false, undefined,undefined, null,null, NaN, NaN,'NaN', 0, 0, 'a', 'a',{},{}\];
        console.log(unique(arr))
//\[1, "true", 15, false, undefined, null, NaN, 0, "a", {…}\]    //两个true直接去掉了,NaN和{}去重

利用 hasOwnProperty

function unique(arr) {
    var obj = {};
    return arr.filter(function(item, index, arr){
        return obj.hasOwnProperty(typeof item + item) ? false : (obj\[typeof item + item\] = true)
    })
}
    var arr = \[1,1,'true','true',true,true,15,15,false,false, undefined,undefined, null,null, NaN, NaN,'NaN', 0, 0, 'a', 'a',{},{}\];
        console.log(unique(arr))
//\[1, "true", true, 15, false, undefined, null, NaN, "NaN", 0, "a", {…}\]   //所有的都去重了

利用 hasOwnProperty 判断是否存在对象属性

利用递归去重

function unique(arr) {
        var array\= arr;
        var len = array.length;

    array.sort(function(a,b){   //排序后更加方便去重
        return a - b;
    })

    function loop(index){
        if(index >= 1){
            if(array\[index\] === array\[index\-1\]){
                array.splice(index,1);
            }
            loop(index - 1);    //递归loop,然后数组去重
        }
    }
    loop(len\-1);
    return array;
}
 var arr = \[1,1,'true','true',true,true,15,15,false,false, undefined,undefined, null,null, NaN, NaN,'NaN', 0, 0, 'a', 'a',{},{}\];
console.log(unique(arr))
//\[1, "a", "true", true, 15, false, 1, {…}, null, NaN, NaN, "NaN", 0, "a", {…}, undefined\]

利用 Map 数据结构去重

function arrayNonRepeatfy(arr) {
  let map = new Map();
  let array = new Array();  // 数组用于返回结果
  for (let i = 0; i < arr.length; i++) {
    if(map .has(arr\[i\])) {  // 如果有该key值
      map .set(arr\[i\], true);
    } else {
      map .set(arr\[i\], false);   // 如果没有该key值
      array .push(arr\[i\]);
    }
  }
  return array ;
}
 var arr = \[1,1,'true','true',true,true,15,15,false,false, undefined,undefined, null,null, NaN, NaN,'NaN', 0, 0, 'a', 'a',{},{}\];
    console.log(unique(arr))
//\[1, "a", "true", true, 15, false, 1, {…}, null, NaN, NaN, "NaN", 0, "a", {…}, undefined\]

创建一个空 Map 数据结构,遍历需要去重的数组,把数组的每一个元素作为 key 存到 Map 中。由于 Map 中不会出现相同的 key 值,所以最终得到的就是去重后的结果。

PS:有些文章提到了 foreach+indexOf 数组去重的方法,个人觉得都是大同小异,所以没有写上去。

评论区

Beaudar Twikoo

最新评论

Loading...