1、利用 ES6 Set 去重(ES6 中最常用)
- Set 对象是 ES6 中新定义的数据结构,类似于数组,它允许你存储任何类型的唯一值,不管是原始值还是对象引用。
Array.from()
方法就是将一个类数组对象或者可遍历对象转换成一个真正的数组。
var arr = [1, 1, 'true', 'true', true, true, 15, 15, false, false, undefined, undefined, null, null, NaN,
NaN, 'NaN', 0, 0, 'a', 'a', {}, {}, [], []];
function unique(arr) {
return Array.from(new Set(arr));
}
console.log(unique(arr));
- 不考虑兼容性,这种去重的方法代码最少。这种方法无法去掉
{}
空对象,后面的高阶方法会添加去掉重复 “{}
” 的方法。
2、利用剩余参数去重 […new Set(arr)]
- 剩余参数语法允许我们将一个不定数量的参数表示为一个数组。
var arr = [1, 1, 'true', 'true', true, true, 15, 15, false, false, undefined, undefined, null, null, NaN,
NaN, 'NaN', 0, 0, 'a', 'a', {}, {}, [], []];
var Arr = [...new Set(arr)];
console.log(Arr);
3、利用 indexOf 去重
indexOf()
方法可返回某个指定的字符串值在字符串中首次出现的位置。
var arr = [1, 1, 'true', 'true', true, true, 15, 15, false, false, undefined, undefined, null, null, NaN,
NaN, 'NaN', 0, 0, 'a', 'a', {}, {}, [], []];
function unique(arr) {
if (!Array.isArray(arr)) {
console.log('type error!');
return;
}
var Arr = [];
for (let i = 0; i < arr.length; i++) {
if (Arr.indexOf(arr[i]) === -1) {
Arr.push(arr[i]);
}
}
return Arr;
}
console.log(unique(arr));
4、利用对象的属性不能相同的特点进行去重(这种数组去重的方法有问题,不建议用,有待改进)
var arr = [1, 1, 'true', 'true', true, true, 15, 15, false, false, undefined, undefined, null, null, NaN,
NaN, 'NaN', 0, 0, 'a', 'a', {}, {}, [], []];
function unique(arr) {
if (!Array.isArray(arr)) {
console.log('type error!');
return;
}
var Arr = [];
var obj = {};
for (let i = 0; i < arr.length; i++) {
if (!obj[arr[i]]) {
Arr.push(arr[i]);
obj[arr[i]] = 1;
} else {
obj[arr[i]]++;
}
}
return Arr;
}
console.log(unique(arr));
5、利用 for 嵌套 for,然后 splice 去重(ES5中最常用)
splice()
方法可删除从第一个参数处开始的零个或多个元素,并且用参数列表中声明的一个或多个值来替换那些被删除的元素。- 双层循环,外层循环元素,内层循环时比较值。值相同时,则删去这个值。
var arr = [1, 1, 'true', 'true', true, true, 15, 15, false, false, undefined, undefined, null, null, NaN,
NaN, 'NaN', 0, 0, 'a', 'a', {}, {}, [], []];
function unique(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);
j--;
}
}
}
return arr;
}
console.log(unique(arr));
6、利用 sort()
var arr = [1, 1, 'true', 'true', true, true, 15, 15, false, false, undefined, undefined, null, null, NaN,
NaN, 'NaN', 0, 0, 'a', 'a', {}, {}, [], []];
function unique(arr) {
if (!Array.isArray(arr)) {
console.log('type error!')
return;
}
arr = arr.sort(function (a, b) {
return a - b;
});
var Arr = [arr[0]];
for (let i = 1; i < arr.length; i++) {
if (arr[i] !== arr[i - 1]) {
Arr.push(arr[i]);
}
}
return Arr;
}
console.log(unique(arr));
undefined]
7、利用 includes
includes()
方法用来判断一个数组是否包含一个指定的值,如果是返回 true,否则false。
var arr = [1, 1, 'true', 'true', true, true, 15, 15, false, false, undefined, undefined, null, null, NaN,
NaN, 'NaN', 0, 0, 'a', 'a', {}, {}, [], []];
function unique(arr) {
if (!Array.isArray(arr)) {
console.log('type error!')
return;
}
var Arr = [];
for (let i = 0; i < arr.length; i++) {
if (!Arr.includes(arr[i])) {
Arr.push(arr[i]);
}
}
return Arr;
}
console.log(unique(arr));
8、利用 hasOwnProperty 判断是否存在对象属性
Object
的 hasOwnProperty()
方法返回一个布尔值,判断对象是否包含特定的自身(非继承)属性。filter()
方法创建一个新的数组,新数组中的元素是通过检查指定数组中符合条件的所有元素。
var arr = [1, 1, 'true', 'true', true, true, 15, 15, false, false, undefined, undefined, null, null, NaN,
NaN, 'NaN', 0, 0, 'a', 'a', {}, {}, [], []];
function unique(arr) {
var obj = {};
return arr.filter(function (item, index, arr) {
return obj.hasOwnProperty(typeof item + item) ? false : (obj[typeof item + item] = true);
});
}
console.log(unique(arr));
9、利用 filter+indexOf
indexOf()
方法可返回某个指定的字符串值在字符串中首次出现的位置。
var arr = [1, 1, 'true', 'true', true, true, 15, 15, false, false, undefined, undefined, null, null, NaN,
NaN, 'NaN', 0, 0, 'a', 'a', {}, {}, [], []];
function unique(arr) {
return arr.filter(function (item, index, arr) {
return arr.indexOf(item, 0) === index;
});
}
console.log(unique(arr));
10、利用递归去重
splice()
方法可删除从第一个参数处开始的零个或多个元素,并且用参数列表中声明的一个或多个值来替换那些被删除的元素。
var arr = [1, 1, 'true', 'true', true, true, 15, 15, false, false, undefined, undefined, null, null, NaN,
NaN, 'NaN', 0, 0, 'a', 'a', {}, {}, [], []];
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(len - 1);
return array;
}
console.log(unique(arr));
undefined]
11、利用 Map 数据结构去重
map()
方法创建一个新数组,其结果是该数组中的每个元素都调用一个提供的函数后返回的结果。- 创建一个空 Map 数据结构,遍历需要去重的数组,把数组的每一个元素作为 key 存到 Map 中。由于 Map 中不会出现相同的 key 值,所以最终得到的就是去重后的结果。
var arr = [1, 1, 'true', 'true', true, true, 15, 15, false, false, undefined, undefined, null, null, NaN,
NaN, 'NaN', 0, 0, 'a', 'a', {}, {}, [], []];
function unique(arr) {
let map = new Map();
let array = new Array();
for (let i = 0; i < arr.length; i++) {
if (map.has(arr[i])) {
map.set(arr[i], true);
} else {
map.set(arr[i], false);
array.push(arr[i]);
}
}
return array;
}
console.log(unique(arr));
12、利用 reduce+includes
reduce()
方法接收一个函数作为累加器,数组中的每个值(从左到右)开始缩减,最终计算为一个值。includes()
方法用来判断一个数组是否包含一个指定的值,如果是返回 true,否则 false。
var arr = [1, 1, 'true', 'true', true, true, 15, 15, false, false, undefined, undefined, null, null, NaN,
NaN, 'NaN', 0, 0, 'a', 'a', {}, {}, [], []];
function unique(arr) {
return arr.reduce((prev, cur) => prev.includes(cur) ? prev : [...prev, cur], []);
}
console.log(unique(arr));
13、JS数组去重(多维,复杂类型皆可)
参考: JS数组去重——终极版(多维,复杂类型皆可)
function unique(arr) {
let objArr = arr.filter((item) => {
return Object.prototype.toString.call(item) === "[object Object]";
});
let otherTypeArr = arr.filter((item) => {
return Object.prototype.toString.call(item) !== "[object Object]";
});
let obj = {};
otherTypeArr = otherTypeArr.filter((item, index) => {
let newItem = item + JSON.stringify(item);
return obj.hasOwnProperty(newItem) ? false : (obj[newItem] = true);
});
if (objArr.length !== 0) {
var objToStrArr = [];
var keyArr = [];
var key = "";
var currentObj = {};
var currentStr = "";
objArr.forEach(item => {
keyArr = [];
for (key in item) {
keyArr.push(key);
}
keyArr.sort();
currentObj = {};
keyArr.forEach(ele => {
currentObj[ele] = item[ele];
})
currentStr = JSON.stringify(currentObj);
currentStr = currentStr.replace(/(\s|[\\t])/g, "");
objToStrArr.push(currentStr);
})
objToStrArr.sort();
var tmepArr = [];
objToStrArr.forEach((item, i) => {
if (item !== tmepArr[tmepArr.length - 1]) {
tmepArr.push(item);
}
})
var resultArr = [];
tmepArr.forEach((item) => {
resultArr.push(JSON.parse(item));
})
objArr = resultArr;
}
return [...otherTypeArr, ...objArr];
}