这很简单，可以用jQuery在一行中完成：

var arr1 = ['Vijendra', 'Singh'], arr2 =['Singh', 'Shakya'];

$.unique(arr1.concat(arr2))//one line

["Vijendra", "Singh", "Shakya"]

如果要检查唯一对象，请在比较中使用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;
}

带过滤器的最简单解决方案：

var array1 = ["Vijendra","Singh"];
var array2 = ["Singh", "Shakya"];

var mergedArrayWithoutDuplicates = array1.concat(
  array2.filter(seccondArrayItem => !array1.includes(seccondArrayItem))
);

   //1.merge two array into one array

   var arr1 = [0, 1, 2, 4];
   var arr2 = [4, 5, 6];

   //for merge array we use "Array.concat"

   let combineArray = arr1.concat(arr2); //output

   alert(combineArray); //now out put is 0,1,2,4,4,5,6 but 4 reapeat

   //2.same thing with "Spread Syntex"

   let spreadArray = [...arr1, ...arr2];

   alert(spreadArray);  //now out put is 0,1,2,4,4,5,6 but 4 reapete


   /*
       if we need remove duplicate element method use are
       1.Using set
       2.using .filter
       3.using .reduce
   */

编辑：

只有在项目很少的情况下，第一种解决方案才是最快的。当项目超过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

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

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。老实说，我不知道浏览器是如何进行哈希的，但它在数千个数据点上表现良好。