您可以简单地使用ECMAScript 6，

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

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

这里有一个稍微不同的循环。通过Chrome最新版本中的一些优化，它是解决两个数组联合的最快方法（Chrome 38.0.2111）。

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

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

var arr = array1.concat(array2),
  len = arr.length;

while (len--) {
  var itm = arr[len];
  if (array3.indexOf(itm) === -1) {
    array3.unshift(itm);
  }
}

while循环：约589k ops/s滤波器：~44k ops/slodash：30.8万次/秒对于循环：225k操作/秒

一条评论指出，我的一个设置变量导致我的循环领先于其他循环，因为它不需要初始化一个空数组来写入。我同意这一点，所以我已经将测试重写为公平的环境，并包含了一个更快的选项。

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

let whileLoopAlt = function (array1, array2) {
    const array3 = array1.slice(0);
    let len1 = array1.length;
    let len2 = array2.length;
    const assoc = {};

    while (len1--) {
        assoc[array1[len1]] = null;
    }

    while (len2--) {
        let itm = array2[len2];

        if (assoc[itm] === undefined) { // Eliminate the indexOf call
            array3.push(itm);
            assoc[itm] = null;
        }
    }

    return array3;
};

在另一种解决方案中，我结合了一个答案的关联数组解决方案，以消除循环中的.indexOf（）调用，该调用通过第二个循环大大降低了速度，并包含了其他用户在其答案中建议的一些其他优化。

这里的最高答案是每个值（i-1）都有一个双循环，但速度仍然很慢。lodash仍然做得很好，我仍然会向任何不介意在项目中添加库的人推荐它。对于那些不想这样做的人来说，我的while循环仍然是一个很好的答案，过滤器的答案在这里表现得很好，在我的测试中击败了最新的Canary Chrome（44.0.2360）。

如果你想加快速度，看看迈克和丹·斯托克的答案。在经历了几乎所有可行的答案之后，这些是迄今为止所有结果中最快的。

对于大型输入，更好的选择是对数组进行排序。然后合并它们。

function sortFunction(a, b) {
        return a - b;
}

arr1.sort(sortFunction);
arr2.sort(sortFunction);

function mergeDedup(arr1, arr2) {

    var i = 0, j = 0, result = [];
    while (i < arr1.length && j < arr2.length) {

        if (arr1[i] < arr2[j]) {
            writeIfNotSameAsBefore(result, arr1[i]);
            i++;
        }
        else if (arr1[i] > arr2[j]) {
            writeIfNotSameAsBefore(result, arr2[j]);
            j++;
        }
        else {
            writeIfNotSameAsBefore(result, arr1[i]);
            i++;
            j++;
        }

    }

    while (i < arr1.length) {
        writeIfNotSameAsBefore(result, arr1[i]);
        i++;
    }

    while (j < arr2.length) {
        writeIfNotSameAsBefore(result, arr2[j]);
        j++;
    }
    return result;
}

function writeIfNotSameAsBefore(arr, item) {
    if (arr[arr.length - 1] !== item) {
        arr[arr.length] = item;
    }
    return arr.length;
}

排序将采用O（nlogn+mlogm），其中n和m是数组的长度，O（x）用于合并，其中x=Max（n，m）；

我的一便士半：

Array.prototype.concat_n_dedupe = function(other_array) {
  return this
    .concat(other_array) // add second
    .reduce(function(uniques, item) { // dedupe all
      if (uniques.indexOf(item) == -1) {
        uniques.push(item);
      }
      return uniques;
    }, []);
};

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

var result = array1.concat_n_dedupe(array2);

console.log(result);

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

变量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]

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

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' ]