数组去重
作为刚工作的小菜鸡,在遇到一大串的数据,需要获取一个字段的时候,但是它的数组中还掺杂很多相同字段的数据,我还在想怎么将这些相同字段的归为一类,居然没有想到用数组去重,我对不起老师的教导,对不起老师.
总结一下,在各个地方搜索一下到去重的方法,自己也跑了一遍,没问题
1.数组去重-数字
Methods 1: 思路：定义一个新数组，并存放原数组的第一个元素，然后将元素组一一和新数组的元素对比，若不同则存放在新数组中。
let newArr = [arr[0]];
for (let i = 1; i < arr.length; i++) {
let repeat = false;
for (let j = 0; j < newArr.length; j++) {
if (arr[i] === newArr[j]) {
repeat = true;
break;
}else{
}
}
if (!repeat) {
newArr.push(arr[i]);
}
}
return newArr;
}
console.log(unique([1, 1, 2, 3, 5, 3, 1, 5, 6, 7, 4]));
// 结果是[1, 2, 3, 5, 6, 7, 4]
Methods 2: 思路：先将原数组排序，在与相邻的进行比较，如果不同则存入新数组。
var formArr = arr.sort()
var newArr=[formArr[0]]
for (let i = 1; i < formArr.length; i++) {
if (formArr[i]!==formArr[i-1]) {
newArr.push(formArr[i])
}
}
return newArr
}
console.log(unique2([1, 1, 2, 3, 5, 3, 1, 5, 6, 7, 4]));
// 结果是[1, 2, 3, 4,5, 6, 7]
Methods 3: 利用对象属性存在的特性，如果没有该属性则存入新数组。
var obj={}
var newArr=[]
for (let i = 0; i < arr.length; i++) {
if (!obj[arr[i]]) {
obj[arr[i]] = 1
newArr.push(arr[i])
}
}
return newArr
}
console.log(unique2([1, 1, 2, 3, 5, 3, 1, 5, 6, 7, 4]));
// 结果是[1, 2, 3, 5, 6, 7, 4]
Methods 4: 利用数组的indexOf下标属性来查询。
var newArr = []
for (var i = 0; i < arr.length; i++) {
if (newArr.indexOf(arr[i])===-1) {
newArr.push(arr[i])
}
}
return newArr
}
console.log(unique4([1, 1, 2, 3, 5, 3, 1, 5, 6, 7, 4]));
// 结果是[1, 2, 3, 5, 6, 7, 4]
Methods 5: 利用数组原型对象上的includes方法。
function unique5(arr) {
var newArr = []
for (var i = 0; i < arr.length; i++) {
if (!newArr.includes(arr[i])) {
newArr.push(arr[i])
}
}
return newArr
}
console.log(unique5([1, 1, 2, 3, 5, 3, 1, 5, 6, 7, 4]));
// 结果是[1, 2, 3, 5, 6, 7, 4]
Methods 6: 利用数组原型对象上的 filter 和 includes方法。
var newArr = []
newArr = arr.filter(function (item) {
return newArr.includes(item) ? '' : newArr.push(item)
})
return newArr
}
console.log(unique6([1, 1, 2, 3, 5, 3, 1, 5, 6, 7, 4]));
// 结果是[1, 2, 3, 5, 6, 7, 4]
Methods 7: 利用数组原型对象上的 forEach 和 includes方法。
let newArr = [];
arr.forEach(item => {
return newArr.includes(item) ? '' : newArr.push(item);
});
return newArr;
}
console.log(unique7([1, 1, 2, 3, 5, 3, 1, 5, 6, 7, 4]));
// 结果是[1, 2, 3, 4, 5, 6, 7]
Methods 8: 利用数组原型对象上的 splice 方法。
function unique8(arr) {
var i,j,len = arr.length;
for (i = 0; i < len; i++) {
for (j = i + 1; j < len; j++) {
if (arr[i] == arr[j]) {
arr.splice(j, 1);
len--;
j--;
}
}
}
return arr;
}
console.log(unique8([1, 1, 2, 3, 5, 3, 1, 5, 6, 7, 4]));
Methods 9: 利用数组原型对象上的 lastIndexOf 方法。
function unique9(arr) {
var res = [];
for (var i = 0; i < arr.length; i++) {
res.lastIndexOf(arr[i]) !== -1 ? '' : res.push(arr[i]);
}
return res;
}
console.log(unique9([1, 1, 2, 3, 5, 3, 1, 5, 6, 7, 4]));
// 结果是[1, 2, 3, 5, 6, 7, 4]
Methods 10: 利用 ES6的set 方法。
function unique10(arr) {
//Set数据结构，它类似于数组，其成员的值都是唯一的
return Array.from(new Set(arr)); // 利用Array.from将Set结构转换成数组
}
console.log(unique10([1, 1, 2, 3, 5, 3, 1, 5, 6, 7, 4]));
// 结果是[1, 2, 3, 5, 6, 7, 4]
2.数组去重-对象
Methods 1: 利用双重for循环
let arr = [
{id: 1, name: 'lsm'},
{id: 2, name: 'mjl'},
{id: 1, name: 'lsm'}
]
for (let i = 0; i < arr.length; i++) {
for (let j = i + 1; j < arr.length; j++) {
if (arr[i].id === arr[j].id) {
arr.splice(j, 1)
j--
}
}
}
console.log('arr--', arr)
Methods 2: forEach搭配findindex
{id: 1, name: 'lsm'},
{id: 2, name: 'mjl'},
{id: 1, name: 'lsm'}
]
let newArr1 = []
arr1.forEach((item, index) => {
arr1.findIndex(el => el.id == item.id) == index && newArr1.push(item)
})
console.log('newArr1', newArr1)
总结来说 ：进行双重循环，内层循环根据findInde函数的特性，找到第一个符合条件的值的索引并与外层索引比较。当有重复的对象时，内层循环的索引与外层循环的索引并不一致，实现去重。
findIndex作用：找到遍历的数组中的第一个符合判断条件的值，并返回该值对应的索引，停止遍历
Methods 3: filter搭配findIndex
{id: 1, name: 'lsm'},
{id: 2, name: 'mjl'},
{id: 1, name: 'lsm'}
]
arr2 = arr2.filter((item, index) => {
return arr2.findIndex(el => el.id == item.id) == index
})
console.log('arr3--', arr2)
filter作用：实现数组过滤。判断filter回调函数中的条件是否为true，如果为true，返回该遍历项，最终包装到一个数组中统一返回
Methods 4: forEach搭配some
{id: 1, name: 'lsm'},
{id: 2, name: 'mjl'},
{id: 1, name: 'lsm'}
]
let newArr3 = []
arr3.forEach((item, index) => {
!newArr3.some(el => el.id == item.id) && newArr3push(item)
})
console.log('newArr2', newArr2)
some作用：判断一个数组中有没有符合条件的值，只要数组中有一项符合条件返回true，但是不会终止循环，可以使用return终止循环（该例中并没用到该特性）
Methods 4: filter和find
{id: 1, name: 'lsm'},
{id: 2, name: 'mjl'},
{id: 1, name: 'lsm'}
]
arr4 = arr4.filter(item => {
return arr4.find(el => el.id == item.id) === item
})
console.log('arr4', arr4)
最终总结：
1. 实现引用类型数组去重，主要靠双重循环。
2. 外层的循环可以是forEach、map这种方法，单纯的给内层循环提供去重对象。这要我们在最外面定义一个新的数组，用来存放符合条件的数组。也可以用filter方法，根据filter的特性返回符合条件的数组，不用自定义新数组。
3. 内层的函数实现去重，并且内层的函数要有一个有具体含义的返回值，用于外层函数的判断。可以是some，findIndex，find等。
感谢大家的能看到最后,有什么问题吗欢迎指出,也欢迎各位大佬的指点,总结的不全的地方,还望大家见谅
