网上去重的办法很多，查重的办法不多，先实现一个利用indexOf实现查重的办法。
checkRepeat (data, type) {
let arr = data
let rep = [];
arr.forEach((item,index)=>{
console.log(arr.indexOf(item),index)
if(arr.indexOf(item)!==index){ // 匹配数组元素item第一次出现的index和当前循环的index，如果不同，说明有重复
let obj = {};
obj.key = (arr.indexOf(item) + 1) + '|' + (index + 1); // 用'|'分隔两个重复项的下标
obj.value = item;
rep.push(obj);
}
});
return rep
}
接下来用几种办法实现数组去重
一、利用ES6 Set去重
let a =let a = [0, 0 , 1, 1,4,{}, "true", true, 13, NaN, "NaN", "NaN",false, undefined, null, NaN, null, undefined,"NaN", 0, "a", {}, 1, 1, 2,3,3,4]
let b = [...new Set(a)]
console.log(b)
二、利用indexOf去重
此办法思路和文章一开始的查重思路类似，这种办法对NaN无法去重 这里有两种实现方法，第二种是发现重复项，用数组的最后一项覆盖当前项，并把最后一项删除
function uniqueArr(arr) {
if (!Array.isArray(arr)) {
console.log('type error!')
return
}
var array = [];
for (let i = 0; i < arr.length; i++) {
if (array.indexOf(arr[i]) === -1) {
array.push(arr[i])
}
}
return array;
}
let a = [0, 0 , 1, 1,4,{}, "true", true, 13, NaN, "NaN", "NaN",false, undefined, null, NaN, null, undefined,"NaN", 0, "a", {}, 1, 1, 2,3,3,4]
let b = uniqueArr(a)
console.log(b)
function uniqueArr(arr) {
if (!Array.isArray(arr)) {
console.log('type error!')
return
}
for (let i = 0; i < arr.length-1; i++) {
// 拿出当前项与后面进行比较，利用slice方法把当前项的后面拿出来作为型数组
let args = arr.slice(i+1),
item = arr[i]
if (args.indexOf(item) > -1) {
// 发现重复项，把数组最后一项赋值当前项，所以会改变新数组里面内容的位置
arr[i] = arr[arr.length - 1]
// 最后一项不要了 数组长度减去1，当前循环索引减去1
arr.length--
i--
}
}
return arr;
}
let a = [0, 0 , 1, 1,4,{}, "true", true, 13, NaN, "NaN", "NaN",false, undefined, null, NaN, null, undefined,"NaN", 0, "a", {}, 1, 1, 2,3,3,4]
let b = uniqueArr(a)
console.log(b)
三、for嵌套循环，splice实现。这种办法的缺点是NaN无法去重
function uniqueArr(arr){
for(let i=0; i<arr.length; i++){
for(let j=i+1; j<arr.length; j++){
if(arr[i]===arr[j]){ //第一个和后面一个重复，splice方法删除后一个
arr.splice(j,1);
j--;
}
}
}
return arr;
}
let a = [0, 0 , 1, 1,4,{}, "true", true, 13, NaN, "NaN", "NaN",false, undefined, null, NaN, null, undefined,"NaN", 0, "a", {}, 1, 1, 2,3,3,4]
let b = uniqueArr(a)
console.log(b)
四、数组排序后，比较相邻2项，将重复的去除，缺点是只能针对数字去重，如果加入其它（比如字符串，布尔类型，对象类型，那么会把相同的数字隔开，起不到相邻去重的效果）。
这里有两种办法，一种是排序后相邻项比较大小，一种是排序后相邻项正则匹配。
function uniqueArr(arr) {
arr.sort((a, b) => a - b)
for (let i = 1; i<arr.length;i++) {
if (arr[i-1] === arr[i]) {
arr.splice(i-1,1)
i--
}
}
return arr
}
// let a = [0, 2 , 5, 1,4,{}, "true", true, 13, NaN, "NaN", "NaN",false, null, null, undefined, null, NaN, null, undefined,"NaN", 0, "a", {}, 1, 1, 2,3,3,4]
let a = [15, 24, 2, 11, 7, 93, 21, 24, 24, 15, 15, 7, 92, 15, 2, 15, 21]
let b = uniqueArr(a)
console.log(b)
function uniqueArr(arr) {
if (!Array.isArray(arr)) {
console.log('type error!')
return
}
let str = arr.sort((a, b) => a - b).join('@') + '@';
let reg = /(\d+@)\1*/g,
ary = []
console.log(str)
str.replace(reg, (val, group1) => {
ary.push(Number(group1.slice(0,group1.length-1)))
});
return ary
}
let a = [12, 23, 12, 15, 25, 23, 25, 14, 16, 12, 12];
let b = uniqueArr(a)
console.log(b)
五、利用对象键值对去重，利用对象键值对，当键值已经存在时，说明当前项之前出现过了，重复了，用数组最后一项覆盖当前项。优点是可以把NaN去重，缺点是undefined无法去重。
function uniqueArr(arr) {
let obj = {}
for (let i = 0; i < arr.length; i++) {
let item = arr[i]
// 利用对象键值对，当键值已经存在时，说明当前项之前出现过了，重复了，用数组最后一项覆盖当前项
if (obj[item] !== undefined) {
arr[i] = arr[arr.length-1]
i--
arr.length--
continue
}
obj[item] = item
}
return arr
}
let a = [0, 2 , 5, 1,4, "true", true, 13, NaN, "NaN", "NaN",false, null, null, undefined, null, NaN, null, undefined,"NaN", 0, "a", 1, 1, 2,3,3,4]
let b = uniqueArr(a)
console.log(b)
