最好也是最简单的方法是使用JavaScript的函数“some（）”，该函数返回true或false，指示数组是否包含对象的元素。您可以这样做：

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

var array3 = array1;

array2.forEach(function(elementArray2){
    var isEquals = array1.some(function(elementArray1){
        return elementArray1 === elementArray2;
    })
    if(!isEquals){
        array3.push(elementArray2);
    }
});
console.log(array3);

结果：

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

如你所愿。。。无需复制。。。

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

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;
    }
});

合并两个阵列有很多解决方案。它们可以分为两大类（除了使用lodash或underline.js等第三方库）。

a） 组合两个数组并删除重复项。

b） 在组合项目之前过滤掉它们。

合并两个数组并删除重复项

结合

// mutable operation(array1 is the combined array)
array1.push(...array2);
array1.unshift(...array2);

// immutable operation
const combined = array1.concat(array2);
const combined = [...array1, ...array2];    // ES6

统一

统一数组有很多方法，我个人建议使用以下两种方法。

// a little bit tricky
const merged = combined.filter((item, index) => combined.indexOf(item) === index);
const merged = [...new Set(combined)];

在组合项目之前筛选出项目

还有很多方法，但我个人建议使用以下代码，因为它简单。

const merged = array1.concat(array2.filter(secItem => !array1.includes(secItem)));

我认为这工作得更快。

removeDup = a => {

    for (let i = a.length - 1; i >= 0; i--) {
        for (let j = i-1; j >= 0; j--) {
            if (a[i] === a[j])
                a.splice(j--, 1);
        }
    }

    return a;
}

使用array.contat（）和array.filter（）使用新的Set对象和Spread操作符使用array.contat和新的Set对象

设数组1=[1，2，3，4，5]设数组2=[1，4，6，9]//使用array.contat和array.filter常量array3=array1.concat（array2.filter（（项）=>array1.indexOf（项）==-1））console.log（'array3:'，array3）；//使用新的集合和排列运算符const array4=[…新集合（[…array1，…array2]）]；console.log（'array4:'，array4）；//使用array.contat和新集合const array5=[…新集合（array1.concat（array2））]；console.log（'array5:'，array5）；

我的一便士半：

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);