一、两个数组对象进行合并去重
方法一 new Map
let arr=[
{id:1,name:'AAAA'},
{id:2,name:'BBBB'}
]
let arr1=[
{id:1,name:'AAAA'},
{id:3,name:'CCCC'}
]
let arrs=[...arr,...arr1];
//根据id去重
let map=new Map();
for(let item of arrs){
if(!map.has(item.id)){
map.set(item.id,item)
}
}
let newArr=[...map.values()];//把map中所有的值取出来放进数组
方法二 arr.reduce
removedup(arr, batch) {
if (!Array.isArray(arr)) {
return arr;
}
if (arr.length == 0) {
return [];
}
let obj = {};
let uniqueArr = arr.reduce(function (total, item) {
obj[item[batch]] ? '' : (obj[item[batch]] = true && total.push(item));
return total;
}, []);
return uniqueArr;
}
// arrObjList 需要去重的数组对象， score 根据这个属性进行去重
let uniqueArrObjList = removedup(arrObjList, "score");
方法三 遍历数组法
这是最简单的去重方法，实现思路：合并两个数组，然后遍历去吃
let json1=[
{id:1,name:"aaa"},
{id:2,name:"bbb"},
{id:3,name:"ccc"},
]
let json2=[
{id:1,name:"aaa"},
{id:2,name:"bbb"},
{id:4,name:"ddd"},
]
let json = json1.concat(json2); //两个数组对象合并
let newJson = []; //盛放去重后数据的新数组
for(item1 of json){ //循环json数组对象的内容
let flag = true; //建立标记，判断数据是否重复，true为不重复
for(item2 of newJson){ //循环新数组的内容
if(item1.id==item2.id){ //让json数组对象的内容与新数组的内容作比较，相同的话，改变标记为false
flag = false;
}
}
if(flag){ //判断是否重复
newJson.push(item1); //不重复的放入新数组。 新数组的内容会继续进行上边的循环。
}
}
console.log("newJson",newJson);
方法四 利用对象属性的唯一性去重
个人比较推荐，在面对数组中每一项都是一个对象的时候，一些API是不生效的
//利用对象属性的唯一性去重
let list = [
{Staff_Code: "001", Staff_Name: "唐三"},
{Staff_Code: "001", Staff_Name: "唐三"},
{Staff_Code: "002", Staff_Name: "小舞"},
{Staff_Code: "003", Staff_Name: "奥斯卡"}
];
cutarray(arr) {
let obj = {}; //obj用来记录该项重复出现了几次
let brr = []; //brr是去重后的数组
arr.forEach((item) => {
if (obj[item.Staff_Code] == undefined) {
obj[item.Staff_Code] = 1;
brr.push(item);
} else {
obj[item.Staff_Code] += 1;
}
});
return brr;
}
let arr = this.cutarray(list);
二、数组的合并去重
方法一 new Set
let arr1 = [3,5,2,3,6];
let arr2 = [5,2,4,6,8,7,9,2];
let arr = arr1.concat(arr2); //合并数组
let arrNew= new Set(arr); //通过set集合去重
console.log("arrNew",Array.from(arrNew)); //将set集合转化为数组
方法二 遍历数组法
遍历旧数组，把值加入新建的数组（当新数组中不存在该值时）
function uniqueArr(array) {
var n = []; //一个新的临时数组
//遍历当前数组
for (var i = 0; i < array.length; i++) {
//如果当前数组的第i已经保存进了临时数组，那么跳过，
//否则把当前项push到临时数组里面
if (n.indexOf(array[i]) == -1) n.push(array[i]);
}
return n;
}
注意：indexOf是ECMA5的新方法，IE8及以下不支持，所以要做兼容性处理。
if (Array.prototype.indexOf){
Array.prototype.indexOf = function (item) {
var result = -1,a_item = null;
if (this.length == 0) {
return result
}
for (var i = 0,len=this.length;i<len;i++) {
a_item = this[i];
if (a_item === item) {
result = i;
break;
}
}
return result;
}
}
方法三 对象键值对法
该方法执行的速度比其他任何方法都快，但就是占用的内存大一些
实现思路：新建一个js对象以及新数组，遍历要去重的数组时，判断值是否是js对象的键。不是的话，给对象新增该键并放入新数组。
注意：判断是否为对象键时，会自动对传入的键执行‘toString()’，不同的键可能会被误认为是一样的，如：a[1]与a[‘1’]。解决该问题还是得调用“indexOf”
function uniqueArr(arr) {
var n = {},
r = [],
len = arr.length,
val, type;
for (var i = 0; i < len; i++) {
val = arr[i];
type = typeof val;
if (!n[val]) {
n[val] = [type];
r.push(val);
} else if (n[val].indexOf(type) < 0) {
n[val].push(type);
r.push(val);
}
};
return r;
}
console.log(uniqueArr([1,2,[1,2,3],,'1',2,'4','6']))
方法四 数组下标判断法
还是得调用“indexOf”性。
实现思路：如果当前数组的第i项在当前数组中第一次出现的位置不是i，那么表示第i项是重复的，忽略掉。否则存入结果数组。
缺点：如果数组中的值为undefined，则会剔除，不在新数组中。
function uniqueArr(array) {
var n = []; //结果数组
//从第一项开始遍历
for (var i = 0; i < array.length; i++) {
//如果当前数组的第i项在当前数组中第一次出现的位置不是i，
//那么表示第i项是重复的，忽略掉。否则存入结果数组
if (array.indexOf(array[i]) == i) n.push(array[i]);
}
return n;
}
console.log(uniqueArr([1, 2, [1, 2, 3], , '1', 2, '4', '6']))
方法五 排序后相邻除法
function uniqueArr(array) {
array.sort();
var n = [];
for (var i = 0; i < array.length; i++) {
if (array[i] !== n[n.length - 1]) {
n.push(array[i]);
}
}
return n;
}
console.log(uniqueArr([1, 2, [1, 2, 3], , '1', 2, '4', '6']))
或者：递归去重（先给数组排序，然后相邻项判断是否相等，相等的用splice()截去。）文章来源：https://www.toymoban.com/news/detail-603332.html
//递归去重（数组中存储的是原始（基本）数据类型，而非引用类型对象）
cutarray(arr) {
let len=arr.length;
arr.sort((a,b) => a-b); //a-b升序；b-a降序
function loop(index){
if(index >= 1) {
if(arr[index]===arr[index-1]) {
arr.splice(index, 1);
}
loop(index-1)
}
}
return arr;
}
方法六 优化遍历数组法
实现思路：获取没重复的最右一值放入新数组。（检测到有重复值时终止当前循环同时进入顶层循环的下一轮判断）文章来源地址https://www.toymoban.com/news/detail-603332.html
// 思路：获取没重复的最右一值放入新数组
function uniqueArr(array) {
var r = [];
for (var i = 0, l = array.length; i < l; i++) {
for (var j = i + 1; j < l; j++)
if (array[i] === array[j]) j = ++i;
r.push(array[i]);
}
return r;
}
console.log(uniqueArr([1, 2, [1, 2, 3], , '1', 2, '4', '6']))
方法七 利用filter()去重
// 如果新数组的当前元素的索引值 == 该元素在原始数组中的第一个索引，则返回当前元素
/**arr.indexOf(item),该方法将从头到尾地检索数组，看它是否含有对应的元素。如果找到一个item，则返回 item的"第一次出现的位置"。**/
let list = arr.filter((item,index) => arr.indexOf(item) === index );
到了这里，关于js两个数组合并去重的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！
