我在尝试做同样的事情时遇到了这个帖子，但我想尝试一些不同的东西。我刚刚完成了下面的功能。我还有另一个变量“compareKeys”（键数组），用于进行浅对象比较。我将来可能会把它改成一个函数。

无论如何，我没有包括那部分，因为它不适用于这个问题。我还将代码放入jsperf中。编辑：我修复了jsperf中的条目。与140k相比，我的函数的运算速度约为99k次/秒。

对于代码：我首先创建一个可用索引数组，然后通过迭代第一个数组来消除它们。最后，我通过使用两个数组之间不匹配的缩减索引数组来插入“剩余部分”。

http://jsperf.com/merge-two-arrays-keeping-only-unique-values/26

function indiceMerge(a1, a2) {
    var ai = [];
    for (var x = 0; x < a2.length; x++) {
        ai.push(x)
    };

    for (var x = 0; x < a1.length; x++) {
        for (var y = 0; y < ai.length; y++) {
            if (a1[x] === a2[ai[y]]) {
                ai.splice(y, 1);
                y--;
            }
        }
    }

    for (var x = 0; x < ai.length; x++) {
        a1.push(a2[ai[x]]);
    }

    return a1;
}

编辑：

只有在项目很少的情况下，第一种解决方案才是最快的。当项目超过400项时，Set解决方案将变得最快。当有100000个项目时，它比第一个解决方案快一千倍。

考虑到只有当有很多项时，性能才是重要的，而且Set解决方案是迄今为止最可读的，在大多数情况下，它应该是正确的解决方案

以下性能结果是用少量项目计算的

基于jsperf，将两个数组合并为一个新数组的最快方法（编辑：如果少于400项）如下：

for (var i = 0; i < array2.length; i++)
    if (array1.indexOf(array2[i]) === -1)
      array1.push(array2[i]);

这个慢17%：

array2.forEach(v => array1.includes(v) ? null : array1.push(v));

这个速度慢45%（编辑：当项目少于100个时。当项目较多时，速度快得多）：

var a = [...new Set([...array1 ,...array2])];

而被接受的答案要慢55%（而且写起来要长得多）（编辑：当有10万个项目时，它比任何其他方法都慢几个数量级）

var a = array1.concat(array2);
for (var i = 0; i < a.length; ++i) {
    for (var j = i + 1; j < a.length; ++j) {
        if (a[i] === a[j])
            a.splice(j--, 1);
    }
}

https://jsperf.com/merge-2-arrays-without-duplicate

使用Lodash

我发现@GijsjanB的答案很有用，但我的数组包含具有许多属性的对象，因此我不得不使用其中一个属性来消除它们的重复。

这是我使用lodash的解决方案

userList1 = [{ id: 1 }, { id: 2 }, { id: 3 }]
userList2 = [{ id: 3 }, { id: 4 }, { id: 5 }]
// id 3 is repeated in both arrays

users = _.unionWith(userList1, userList2, function(a, b){ return a.id == b.id });

// users = [{ id: 1 }, { id: 2 }, { id: 3 }, { id: 4 }, { id: 5 }]

作为第三个参数传递的函数有两个参数（两个元素），如果它们相等，则必须返回true。

我简化了这个答案的最佳部分，并将其转化为一个很好的函数：

function mergeUnique(arr1, arr2){
    return arr1.concat(arr2.filter(function (item) {
        return arr1.indexOf(item) === -1;
    }));
}

减少他们！！！

这种替代方法不是显式地合并和重复数据消除，而是采用一个数组并用另一个数组减少它，这样第一个数组的每个值都可以在累积行为中迭代和销毁，因为递归性，所以通过利用数组的持久性来忽略已经包含的值。

array2.reduce(reducer, array1.reduce(reducer, []))

测试示例：

var array1=[“Vijendra”，“Singh”，“辛格”]；var array2=[“Singh”，“Shakya”，“Shakya”]；const reducer=（accumulator，currentValue）=>accumulater.includes（currentValue）？累加器：[…累加器，currentValue]；控制台日志(array2.reduce（reducer，array1.reduce，[]））);//需要减少第一阵列，以确保减少第二阵列上用作初始值的重复数据消除阵列

结论

在枯燥乏味的时候，每一种方法都需要避免（并不是说它没有用处）。

处理重复数据消除的concat（）限制。

不需要Undercore.js、JQuery或Lo Dash等外部库，也不需要创建任何内置函数来实现所需的合并和重复数据消除效果。

哦，嘿！，它可以作为一个内衬完成！！！

由于ES5（ECMAScript 2015）、漂亮的include（）和华丽的reduce（），这个答案是可能的。

下面是使用Set的另一个简单解决方案：

常量o1={a:1}；const arr1=['！@#$%^&*（）'，'gh'，123，o1，1，true，undefined，null]；常量arr2=['！@#$%^&*（）'，123，'abc'，o1，0x001，true，void 0，0]；const mergeUnique=（…args）=>[…新集合（[].contat（…arg））]；console.log（mergeUnique（arr1，arr2））；