js 如何用union合并数组并去重

const arr1 = [1, 2, 3, 4]; const arr2 = [3, 4, 5, 6]; const arr3 = [6, 7, 8, 1];  // 步骤：合并所有数组，创建Set，再转回数组 const combinedAndUniqueArray = Array.from(new Set([...arr1, ...arr2, ...arr3]));  console.log(combinedAndUniqueArray); // 输出: [1, 2, 3, 4, 5, 6, 7, 8]  // 或者更简洁一点，如果只合并两个： const newArr1 = [1, 2, 3]; const newArr2 = [3, 4, 5]; const unionSetResult = [...new Set([...newArr1, ...newArr2])]; console.log(unionSetResult); // 输出: [1, 2, 3, 4, 5]

function mergeAndDeduplicateManual(arrA, arrB) {   const result = [...arrA]; // 先把第一个数组的元素都放进来    for (const item of arrB) {     if (result.indexOf(item) === -1) { // 如果结果数组中还没有这个元素       result.push(item); // 就加进去     }   }   return result; }  const manualArr1 = [10, 20, 30]; const manualArr2 = [20, 40, 50]; console.log(mergeAndDeduplicateManual(manualArr1, manualArr2)); // 输出: [10, 20, 30, 40, 50]  // 多个数组的话，可以链式调用或者用 reduce const allArrays = [[1, 2], [2, 3], [3, 4]]; const mergedAllManual = allArrays.reduce((acc, currentArr) => {   for (const item of currentArr) {     if (!acc.includes(item)) {       acc.push(item);     }   }   return acc; }, []); console.log(mergedAllManual); // 输出: [1, 2, 3, 4]

result

O(N*M)

const list1 = [1, 2, 3]; const list2 = [3, 4, 5]; const list3 = [5, 6, 7];  const allLists = [list1, list2, list3];  const uniqueCombined = allLists.reduce((accSet, currentArray) => {   currentArray.forEach(item => accSet.add(item)); // 将当前数组的每个元素添加到Set中   return accSet; }, new Set()); // 初始值是一个空的Set  console.log(Array.from(uniqueCombined)); // 输出: [1, 2, 3, 4, 5, 6, 7]

const numbers1 = [1, 2, 3, 2]; const numbers2 = [3, 4, 5, 4]; const uniqueNumbers = [...new Set([...numbers1, ...numbers2])]; console.log(uniqueNumbers); // [1, 2, 3, 4, 5]

const obj1 = { id: 1, name: 'A' }; const obj2 = { id: 2, name: 'B' }; const obj3 = { id: 1, name: 'A' }; // 内容和obj1一样，但引用不同  const objectArray = [obj1, obj2, obj3]; const uniqueObjectsByReference = [...new Set(objectArray)]; console.log(uniqueObjectsByReference); // 输出: [{ id: 1, name: 'A' }, { id: 2, name: 'B' }, { id: 1, name: 'A' }] // 注意，obj1和obj3都被保留了，因为它们是不同的对象实例

const users1 = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }]; const users2 = [{ id: 2, name: 'Bob' }, { id: 3, name: 'Charlie' }];  // 使用 Map 来存储唯一的对象，key是id const uniqueUsersMap = new Map(); [...users1, ...users2].forEach(user => {   uniqueUsersMap.set(user.id, user); // 如果id相同，新的会覆盖旧的 });  const uniqueUsers = Array.from(uniqueUsersMap.values()); console.log(uniqueUsers); // 输出: [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }, { id: 3, name: 'Charlie' }]

// 简洁且高效 const arrA = ['apple', 'banana']; const arrB = ['banana', 'orange']; const result = [...new Set([...arrA, ...arrB])]; console.log(result); // ['apple', 'banana', 'orange']

sku

uuid

const productsA = [{ id: 'p001', name: 'Laptop' }, { id: 'p002', name: 'Mouse' }]; const productsB = [{ id: 'p002', name: 'Mouse Pro' }, { id: 'p003', name: 'Keyboard' }];  // 创建一个Map，以id为key，对象为value const uniqueProductsMap = new Map();  // 合并所有产品，并用Map去重 [...productsA, ...productsB].forEach(product => {   // Map的set方法会覆盖同名的key，这正是我们想要的去重效果   // 这里选择保留后出现的重复项（Mouse Pro会覆盖Mouse）   uniqueProductsMap.set(product.id, product); });  const uniqueProducts = Array.from(uniqueProductsMap.values()); console.log(uniqueProducts); /* 输出: [   { id: 'p001', name: 'Laptop' },   { id: 'p002', name: 'Mouse Pro' }, // 注意这里是Mouse Pro，因为后来的覆盖了   { id: 'p003', name: 'Keyboard' } ] */  // 如果你想保留先出现的重复项，可以这样写： const uniqueProductsMapPreserveFirst = new Map(); [...productsA, ...productsB].forEach(product => {   if (!uniqueProductsMapPreserveFirst.has(product.id)) {     uniqueProductsMapPreserveFirst.set(product.id, product);   } }); const uniqueProductsPreserveFirst = Array.from(uniqueProductsMapPreserveFirst.values()); console.log(uniqueProductsPreserveFirst); /* 输出: [   { id: 'p001', name: 'Laptop' },   { id: 'p002', name: 'Mouse' }, // 这里是Mouse，因为先出现的被保留了   { id: 'p003', name: 'Keyboard' } ] */

// 这是一个简化的深比较函数示例，实际情况可能需要更健壮的库 function isEqualDeep(obj1, obj2) {   if (obj1 === obj2) return true; // 相同引用或基本类型值相等    if (typeof obj1 !== 'object' || obj1 === null ||       typeof obj2 !== 'object' || obj2 === null) {     return false; // 类型不同或不是对象   }    const keys1 = Object.keys(obj1);   const keys2 = Object.keys(obj2);    if (keys1.length !== keys2.length) return false;    for (const key of keys1) {     if (!keys2.includes(key) || !isEqualDeep(obj1[key], obj2[key])) {       return false;     }   }   return true; }  const itemA = { name: 'Shirt', color: 'blue', sizes: ['M', 'L'] }; const itemB = { name: 'Shirt', color: 'red', sizes: ['M', 'L'] }; const itemC = { name: 'Shirt', color: 'blue', sizes: ['M', 'L'] }; // 内容与itemA相同  const clothes = [itemA, itemB, itemC]; const uniqueClothes = [];  clothes.forEach(currentItem => {   const isDuplicate = uniqueClothes.some(existingItem => isEqualDeep(existingItem, currentItem));   if (!isDuplicate) {     uniqueClothes.push(currentItem);   } });  console.log(uniqueClothes); /* 输出: [   { name: 'Shirt', color: 'blue', sizes: ['M', 'L'] },   { name: 'Shirt', color: 'red', sizes: ['M', 'L'] } ] */

_.isEqual

const data1 = { a: 1, b: 'x' }; const data2 = { b: 'x', a: 1 }; // 属性顺序不同，但内容相同 const data3 = { a: 2, b: 'y' };  const rawData = [data1, data2, data3];  // 注意：JSON.stringify对属性顺序敏感，这可能导致去重失败 // 比如 {a:1, b:2} 和 {b:2, a:1} 序列化结果不同 const uniqueStrings = new Set(rawData.map(item => JSON.stringify(item)));  const finalUniqueData = Array.from(uniqueStrings).map(str => JSON.parse(str)); console.log(finalUniqueData); /* 输出: [   { a: 1, b: 'x' },   { b: 'x', a: 1 }, // data1和data2都被保留了，因为JSON.stringify对属性顺序敏感   { a: 2, b: 'y' } ] */  // 如果要解决属性顺序问题，可能需要先对对象属性进行排序 function stableStringify(obj) {   return JSON.stringify(Object.keys(obj).sort().reduce((sortedObj, key) => {     sortedObj[key] = obj[key];     return sortedObj;   }, {})); }  const uniqueStringsStable = new Set(rawData.map(item => stableStringify(item))); const finalUniqueDataStable = Array.from(uniqueStringsStable).map(str => JSON.parse(str)); console.log(finalUniqueDataStable); /* 输出: [   { a: 1, b: 'x' }, // data1和data2现在被视为重复，只保留了一个   { a: 2, b: 'y' } ] */