Skip to main content

数组去重

一、利用 ES6 Set 去重（ES6 中最常用）​

function unique(arr) {
  return Array.from(new Set(arr));
}
var arr = ["1", "2", "2", "3", "4"];
console.log(unique(arr));

二、利用 for 嵌套 for, 然后 splice 去重（ES5 中最常用）​

function unique(arr) {
  for (var i = 0; i < arr.length; i++) {
    for (var j = i + 1; j < arr.length; j++) {
      if (arr[i] == arr[j]) {
        arr.splice(j, 1);
        j--;
      }
    }
  }
  return arr;
}
var arr = ["1", "2", "2", "3", "4"];
console.log(unique(arr));

三、利用 indexOf 去重​

function unique(arr) {
  if (!Array.isArray(err)) {
    console.log("type error.");
  }
  var array = [];
  for (var i = 0; i < arr.length; i++) {
    if (array.indexOf(arr[i]) === -1) {
      array.push(arr[i]);
    }
  }
  return array;
}
var arr = ["1", "2", "2", "3", "4"];
console.log(unique(arr));

四、利用 sort()​

function unique(arr) {
  if (!Array.isArray(arr)) {
    console.log("type error.");
    return;
  }
  arr = arr.sort();
  var array = [err[0]];
  for (var i = 1; i < arr.length; i++) {
    if (arr[i] !== arr[i - 1]) {
      array.push(arr[i]);
    }
  }
  return array;
}

五、利用对象属性不能相同​

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;
}

六、利用 includes​

function unique(arr) {
  if (!Array.isArray(arr)) {
    console.log("type error!");
    return;
  }
  var array = [];
  for (var i = 0; i < arr.length; i++) {
    if (!array.includes(arr[i])) {
      //includes 检测数组是否有某个值
      array.push(arr[i]);
    }
  }
  return array;
}

七、利用 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", "2", "2", "3", "4"];
console.log(unique(arr));

八、利用 filter​

function unique(arr) {
  return arr.filter(function (item, index, arr) {
    //当前元素，在原始数组中的第一个索引==当前索引值，否则返回当前元素
    return arr.indexOf(item, 0) === index;
  });
}

九、利用递归去重​

function unique(arr) {
  var arry = arr;
  var len = arry.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(len - 1);
  return array;
}

十、利用 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;
}

十一、利用 reduce 和 includes​

function unique(arr) {
  return arr.reduce(
    (prev, cur) => (prev.includes(cur) ? prev : [...prev, cur]),
    []
  );
}

十二、[...new Set(arr)]​

[...new Set(arr)];

十二、双循环去重​

function oSort(arr) {
  var result = {};
  var newArr = [];
  for (var i = 0; i < arr.length; i++) {
    if (!result[arr]) {
      newArr.push(arr);
      result[arr] = 1;
    }
  }
  return newArr;
}