数组去重的十三种方法
Set (ES6中常见)Set中存放的数据都是不会重复的数据
let arr1 = new Set([20, 20, 30, 'aa', 'aa', 4, 4, 5, 5])
console.log(arr1) //Set(5) {20, 30, 'aa', 4, 5}
[...new Set()]
let arr2 = [1, 2, 2, 'aa', 'aa', 3, 3, 4, 4]
arr2 = [...new Set(arr2)]
console.log(arr2)
Set + Array.from
Array.from()方法就是将一个类数组对象或者可遍历对象转换成一个真正的数组
let arr1 = new Set([20, 20, 30, 'aa', 'aa', 4, 4, 5, 5])
function newArr(arr1) {
return Array.from(new Set(arr1))
}
console.log(newArr(arr1)) //((5) [20, 30, 'aa', 4, 5]
indexOf()
该方法可返回某个指定的字符串值在字符串中首次出现的位置,如果不存在，则返回-1
let arr3 = [1, 2, 2, 'aa', 'aa', 'b', 'b', 4, 4];
let ary = [];
for (let i = 0; i < arr3.length; i++) {
let d = arr3[i]
if (ary.indexOf(d) == -1) {
ary.push(arr3[i])
}
}
console.log(ary) //(5) [1, 2, 'aa', 'b', 4]
filter() + indexOf()
filter() 方法创建一个新的数组，新数组中的元素是通过检查指定数组中符合条件的所有元素。
let arr4 = [1, 2, 2, 'aa', 'aa', 'b', 'b', 4, 4];
function unique(a) {
let res = a.filter(function(item, index, array) {
/**
item:必须,当前元素的值
index:可选。当前元素的索引值
array:可选。当前元素属于的数组对象
**/
return array.indexOf(item) === index;
});
return res;
}
unique(arr4);
console.log(arr4) //(5) [1, 2, 'aa', 'b', 4]
双重for循环+splice (splice() 方法用于添加或删除数组中的元素。)
双层循环，外层循环元素，内层循环时比较值。值相同时，则删去这个值。
let arr5 = [1, 2, 2, 'aa', 'aa', 'b', 'b', 4, 4];
function unique(ary) {
for (let i = 0; i < ary.length; i++) {
for (j = i + 1; j < ary.length; j++) {
if (ary[i] === ary[j]) {
ary.splice(j, 1);
j--;
}
}
}
return ary;
}
unique(arr5);
console.log(arr5) //[1, 2, 'aa', 'b', 4]
sort()
利用 sort() 排序方法，然后根据排序后的结果进行遍历及相邻元素比对。
let arr6 = [1, 2, 2, 'aa', 'aa', 'b', 'b', 4, 4];
function unique(ary) {
let a = ary.sort(function(a, b) {
return a - b;
});
for (let i = 0; i < a.length; i++) {
if (a[i] === a[i + 1]) {
a.splice(i + 1, 1);
i--;
}
}
return a;
}
unique(arr6)
console.log(arr6) // [1, 2, 'aa', 'b', 4]
includes() 用于判断字符串是否包含指定的子字符串。
如果找到匹配的字符串则返回 true，否则返回 false。
let arr7 = [1, 2, 2, 'aa', 'aa', 'b', 'b', 4, 4]
function unique(ary) {
let newAry = [];
let len = ary.length;
for (let i = 0; i < len; i++) {
let cur = ary[i];
if (!newAry.includes(cur)) {
newAry.push(cur);
}
}
return newAry;
}
console.log(unique(arr7)); //[1, 2, 'aa', 'b', 4]
Map
创建一个空Map数据结构，遍历需要去重的数组，把数组的每一个元素作为key存到Map中。由于Map中不会出现相同的key值，所以最终得到的就是去重后的结果。
let arr8 = [1, 2, 2, 'aa', 'aa', 'b', 'b', 4, 4]
function unique(arr) {
let map = new Map();
let 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;
}
console.log(unique(arr8)) //(5) [1, 2, 'aa', 'b', 4]
reduce
let arr9 = [1, 2, 2, 'aa', 'aa', 'b', 'b', 4, 4];
function unique(ary) {
// reduce : 第一个是函数，第二个参数会传给第一次回调的prev;
return ary.reduce((prev, next) => {
// 该函数返回值是下一次执行的prev;
return prev.includes(next) ? prev : [...prev, next];
}, [])
}
console.log(unique(arr9)); //[1, 2, 'aa', 'b', 4]
hasOwnProperty 检测属性名对象的一个私有属性；返回一个布尔值
let arr10 = [1, 2, 2, 'aa', 'aa', 'b', 'b', 4, 4];
function unique(ary) {
let obj = {};
return ary.filter(function(item, index, a) {
// item : 数组每一个成员
// index: 成员对应的索引
// a : 整个数组
// hasOwnProperty来校验的该属性是否出现过；
return obj.hasOwnProperty(typeof item + item) ? false : obj[typeof item + item] = true;
if (obj.hasOwnProperty(typeof item + item)) {
return false
} else {
obj[typeof item + item] = true;
return true;
}
})
}
console.log(unique(arr10)) // [1, 2, 'aa', 'b', 4]
递归
let arr11 = [1, 2, 2, 'aa', 'aa', 'b', 'b', 4, 4]
function unique(ary) {
let len = ary.length;
//排序后更加方便去重
ary = ary.sort(function(a, b) {
return a - b;
});
function loop(index) {
if (index >= 1) {
if (ary[index] === ary[index - 1]) {
ary.splice(index, 1);
}
//递归loop，然后数组去重
loop(index - 1)
}
}
loop(len - 1);
return ary;
}
console.log(unique(arr11)) //(5) [1, 2, 'aa', 'b', 4]
利用对象属性名不能重复的方法。（不适合引号包裹的数字）
let arr12 = [1, 2, 'aa', 'aa', 'b', 'b', 4, 4, '2']
function unique(ary) {
if (ary instanceof Array) {
let newAry = [];
let obj = {};
// 不适合区分数组项是字符型的数字，例如：2与‘2‘,
for (let i = 0; i < ary.length; i++) {
let cur = ary[i];
obj[cur] = cur;
}
//把对象的属性名放到新数组中
for (let key in obj) {
newAry.push(obj[key]);
}
return newAry;
}
}
console.log(unique(arr12)) //[1, '2', 4, 'aa', 'b']
