/***对仅保留唯一值的数组进行重复数据消除。*使用哈希表（js对象）过滤重复项。*保持数组元素的顺序。*该算法对于大型阵列（线性时间）特别有效。*/函数数组UniqueFast（arr）{var seen＝｛｝；var结果=[]；变量i，长度=arr.length；对于（i=0；i<len；i++）{var项目=arr[i]；//哈希表查找if（！seed[item]）{result.push（项）；seed[项目]=真；}}返回结果；}/////测试var array1=[“Vijendra”，“Singh”]；var array2=[“Singh”，“Shakya”]；var result=arrayUniqueFast（array1.concat（array2））；document.write（'<br>result:'+result）；

有关阵列重复数据消除的其他方法，请参阅我的基准测试：https://jsperf.com/de-duplicate-an-array-keeping-only-unique-values

假设原始阵列不需要重复数据消除，这应该非常快，保持原始顺序，并且不会修改原始阵列。。。

function arrayMerge(base, addendum){
    var out = [].concat(base);
    for(var i=0,len=addendum.length;i<len;i++){
        if(base.indexOf(addendum[i])<0){
            out.push(addendum[i]);
        }
    }
    return out;
}

用法：

var array1 = ["Vijendra","Singh"];
var array2 = ["Singh", "Shakya"];
var array3 = arrayMerge(array1, array2);

console.log(array3);
//-> [ 'Vijendra', 'Singh', 'Shakya' ]

我在尝试做同样的事情时遇到了这个帖子，但我想尝试一些不同的东西。我刚刚完成了下面的功能。我还有另一个变量“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;
}

您可以简单地使用ECMAScript 6，

var array1 = ["Vijendra", "Singh"];
var array2 = ["Singh", "Shakya"];
var array3 = [...new Set([...array1 ,...array2])];
console.log(array3); // ["Vijendra", "Singh", "Shakya"];

使用排列运算符串联阵列。使用Set创建一组不同的元素。再次使用排列运算符将集合转换为数组。

首先连接两个数组，然后只过滤出唯一的项：

变量a=[1，2，3]，b=[101，2，1，10]var c=交流电（b）var d=c.filter（（项目，位置）=>c.indexOf（项目）===位置）console.log（d）//d为[1，2，3，101，10]

Edit

正如所建议的，一个更具性能的解决方案是在与a连接之前过滤掉b中的唯一项：

变量a=[1，2，3]，b=[101，2，1，10]var c=a.oncat（b.filter（（项）=>a.indexOf（项）<0））console.log（c）//c为[1，2，3，101，10]

我知道这个问题不是关于对象的数组，但搜索者确实会在这里结束。

因此，值得为未来的读者添加一种适当的ES6合并和删除重复项的方法

对象阵列：

var arr1 = [ {a: 1}, {a: 2}, {a: 3} ];
var arr2 = [ {a: 1}, {a: 2}, {a: 4} ];

var arr3 = arr1.concat(arr2.filter( ({a}) => !arr1.find(f => f.a == a) ));

// [ {a: 1}, {a: 2}, {a: 3}, {a: 4} ]