以下是带有对象数组的对象的选项：

const a = [{param1: "1", param2: 1},{param1: "2", param2: 2},{param1: "4", param2: 4}]
const b = [{param1: "1", param2: 1},{param1: "4", param2: 5}]


var result = a.concat(b.filter(item =>
         !JSON.stringify(a).includes(JSON.stringify(item))
    ));

console.log(result);
//Result [{param1: "1", param2: 1},{param1: "2", param2: 2},{param1: "4", param2: 4},{param1: "4", param2: 5}]

只是把我的两分钱扔进去。

function mergeStringArrays(a, b){
    var hash = {};
    var ret = [];

    for(var i=0; i < a.length; i++){
        var e = a[i];
        if (!hash[e]){
            hash[e] = true;
            ret.push(e);
        }
    }

    for(var i=0; i < b.length; i++){
        var e = b[i];
        if (!hash[e]){
            hash[e] = true;
            ret.push(e);
        }
    }

    return ret;
}

这是我经常使用的方法，它使用一个对象作为哈希查找表来执行重复检查。假设哈希值是O（1），那么这将在O（n）中运行，其中n是a.length+b.length。老实说，我不知道浏览器是如何进行哈希的，但它在数千个数据点上表现良好。

仅合并阵列（不删除重复项）

ES5版本使用Array.concat：

var array1=[“Vijendra”，“Singh”]；var array2=[“Singh”，“Shakya”]；array1=array1.concat（array2）；console.log（array1）；

ES6版本使用销毁

const array1 = ["Vijendra","Singh"];
const array2 = ["Singh", "Shakya"];
const array3 = [...array1, ...array2];

由于没有“内置”的方法来删除重复项（ECMA-262实际上有Array.forEach，这将非常好），因此我们必须手动执行：

Array.prototype.unique = function() {
    var a = this.concat();
    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);
        }
    }

    return a;
};

然后，要使用它：

var array1 = ["Vijendra","Singh"];
var array2 = ["Singh", "Shakya"];
// Merges both arrays and gets unique items
var array3 = array1.concat(array2).unique(); 

这也将保持阵列的顺序（即，不需要排序）。

由于许多人对Array.prototype的原型扩充和in循环感到恼火，这里有一种不太侵入性的方法来使用它：

function arrayUnique(array) {
    var a = array.concat();
    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);
        }
    }

    return a;
}

var array1 = ["Vijendra","Singh"];
var array2 = ["Singh", "Shakya"];
    // Merges both arrays and gets unique items
var array3 = arrayUnique(array1.concat(array2));

对于那些有幸使用ES5可用的浏览器的人，可以像这样使用Object.defineProperty：

Object.defineProperty(Array.prototype, 'unique', {
    enumerable: false,
    configurable: false,
    writable: false,
    value: function() {
        var a = this.concat();
        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);
            }
        }

        return a;
    }
});

Array.prototype.union = function (other_array) {
/* you can include a test to check whether other_array really is an array */
  other_array.forEach(function(v) { if(this.indexOf(v) === -1) {this.push(v);}}, this);    
}

表演

今天2020.10.15我在Chrome v86、Safari v13.1.2和Firefox v81上对MacOs HighSierra 10.13.6进行了测试，以确定所选的解决方案。

后果

适用于所有浏览器

解决方案H快速/最快解决方案L很快解决方案D在大型阵列的chrome上速度最快解决方案G在小阵列上速度很快解决方案M对于小型阵列来说是最慢的解决方案E对于大型阵列来说是最慢的

细节

我执行两个测试用例：

对于2元素数组-您可以在此处运行对于10000个元素数组-您可以在这里运行

关于解决方案A.BCDEGHJLM在下面的片段中显示

// https://stackoverflow.com/a/10499519/860099函数A（arr1，arr2）{返回_并集（arr1，arr2）}// https://stackoverflow.com/a/53149853/860099函数B（arr1，arr2）{return _.unionWith（arr1，arr2，_.isEqual）；}// https://stackoverflow.com/a/27664971/860099函数C（arr1，arr2）{return[…new Set（[…arr1，…arr2]）]}// https://stackoverflow.com/a/48130841/860099函数D（arr1，arr2）{return Array.from（新集合（arr1.concat（arr2）））}// https://stackoverflow.com/a/23080662/860099函数E（arr1，arr2）{return arr1.concat（arr2.filter（（项）=>arr1.indexOf（项）<0））}// https://stackoverflow.com/a/28631880/860099函数G（arr1，arr2）{var哈希＝｛｝；变量i；对于（i=0；i<arr1.length；i++）{hash[arr1[i]=真；}对于（i=0；i<arr2.length；i++）{hash[ar2[i]=真；}return Object.keys（哈希）；}// https://stackoverflow.com/a/13847481/860099函数H（a，b）{var哈希＝｛｝；var ret=[]；对于（var i=0；i<a.length；i++）{变量e=a[i]；if（！hash[e]）{hash[e]=真；ret.push（e）；}}对于（var i=0；i<b.length；i++）{变量e=b[i]；if（！hash[e]）{hash[e]=真；ret.push（e）；}}返回ret；}// https://stackoverflow.com/a/1584377/860099函数J（arr1，arr2）{函数arrayUnique（数组）{var a=array.contat（）；对于（var i=0；i<a.length；++i）{对于（var j=i+1；j<a.length；++j）{如果（a[i]===a[j]）a.接头（j-，1）；}}返回a；}return arrayUnique（arr1.concat（arr2））；}// https://stackoverflow.com/a/25120770/860099函数L（array1，array2）{常量数组3=数组1.slice（0）；设len1=阵列长度；设len2=阵列2.length；常量assoc＝｛｝；而（len1--）{assoc[array1[len1]]=空；}而（len2--）{设itm=array2[len2]；if（assoc[itm]==未定义）｛//消除indexOf调用array3.push（itm）；assoc[itm]=空；}}返回数组3；}// https://stackoverflow.com/a/39336712/860099函数M（arr1，arr2）{常量comp=f=>g=>x=>f（g（x））；常量应用=f=>a=>f（a）；常量flip=f=>b=>a=>f（a）（b）；常量concat=xs=>y=>xs.contat（y）；const afrom=应用（Array.from）；const createSet=xs=>新集合（xs）；常量过滤器=f=>xs=>xs.filter（apply（f））；常量重复数据删除=comp（afrom）（createSet）；常量并集=xs=>ys=>{const zs=创建集（xs）；返回凹面（xs）(滤波器（x=>zs.has（x）? 假的：zs.add（x）)（ys））；}返回联合（重复数据消除（arr1））（arr2）}// -------------//测试// -------------var array1=[“Vijendra”，“Singh”]；var array2=[“Singh”，“Shakya”]；[A、B、C、D、E、G、H、J、L、M]。对于每个（f=>{console.log（`${f.name}[${f（[…array1]，[…array2]）}]`）；})<script src=“https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.20/lodash.min.js“integrity=”sha512-90vH1Z83AJY9DmlWa8WkjkV79yfS2n2Oxhsi2dZbIv0nC4E6m5AbH8Nh156kkM7JePmqD6tcZsfad1ueoaovww==“crossrorigin=”匿名“></script>此代码段仅显示性能测试中使用的函数-它本身不执行测试！

下面是chrome的示例测试运行

更新

我删除了案例F、I、K，因为它们修改了输入数组，基准测试给出了错误的结果

如果要检查唯一对象，请在比较中使用JSON.stringify。

function arrayUnique(array) {
    var a = array.concat();
    for(var i=0; i<a.length; ++i) {
        for(var j=i+1; j<a.length; ++j) {
            if(JSON.stringify(a[i]) === JSON.stringify(a[j]))
                a.splice(j--, 1);
        }
    }

    return a;
}