新解决方案（使用Array.prototype.indexOf和Array.prototype.cocat）：

Array.prototype.uniqueMerge = function( a ) {
    for ( var nonDuplicates = [], i = 0, l = a.length; i<l; ++i ) {
        if ( this.indexOf( a[i] ) === -1 ) {
            nonDuplicates.push( a[i] );
        }
    }
    return this.concat( nonDuplicates )
};

用法：

>>> ['Vijendra', 'Singh'].uniqueMerge(['Singh', 'Shakya'])
["Vijendra", "Singh", "Shakya"]

Array.prototype.indexOf（用于internet explorer）：

Array.prototype.indexOf = Array.prototype.indexOf || function(elt)
  {
    var len = this.length >>> 0;

    var from = Number(arguments[1]) || 0;
    from = (from < 0) ? Math.ceil(from): Math.floor(from); 
    if (from < 0)from += len;

    for (; from < len; from++)
    {
      if (from in this && this[from] === elt)return from;
    }
    return -1;
  };

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

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.indexOf was introduced in javascript 1.6 (ECMA-262) 
//We need to implement it explicitly for other browsers, 
if (!Array.prototype.indexOf)
{
  Array.prototype.indexOf = function(elt, from)
  {
    var len = this.length >>> 0;

    for (; from < len; from++)
    {
      if (from in this &&
          this[from] === elt)
        return from;
    }
    return -1;
  };
}
//now, on to the problem

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

var merged = array1.concat(array2);
var t;
for(i = 0; i < merged.length; i++)
  if((t = merged.indexOf(i + 1, merged[i])) != -1)
  {
    merged.splice(t, 1);
    i--;//in case of multiple occurrences
  }

其他浏览器的indexOf方法的实现取自MDC

为什么不使用对象？看起来你在尝试建立一套模型。然而，这并不能维持秩序。

var set1 = {"Vijendra":true, "Singh":true}
var set2 = {"Singh":true,  "Shakya":true}

// Merge second object into first
function merge(set1, set2){
  for (var key in set2){
    if (set2.hasOwnProperty(key))
      set1[key] = set2[key]
  }
  return set1
}

merge(set1, set2)

// Create set from array
function setify(array){
  var result = {}
  for (var item in array){
    if (array.hasOwnProperty(item))
      result[array[item]] = true
  }
  return result
}

Array.prototype.merge = function(/* variable number of arrays */){
    for(var i = 0; i < arguments.length; i++){
        var array = arguments[i];
        for(var j = 0; j < array.length; j++){
            if(this.indexOf(array[j]) === -1) {
                this.push(array[j]);
            }
        }
    }
    return this;
};

一个更好的数组合并函数。

在Dojo 1.6中+

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

dojo.forEach(array3, function(item) {
    if (dojo.indexOf(unique, item) > -1) return;
    unique.push(item); 
});

使现代化

参见工作代码。

http://jsfiddle.net/UAxJa/1/

使用Undercore.js或Lo Dash，您可以执行以下操作：

console.log（_.union（[1，2，3]，[101，2，1，10]，[2，1]））；<script src=“https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.15/lodash.min.js“></script>

http://underscorejs.org/#union

http://lodash.com/docs#union

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

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

取两个数组a和b

var a = ['a','b','c'];

var b = ['d','e','f'];
var c = a.concat(b); 


//c is now an an array with: ['a','b','c','d','e','f']

这是我的解决方案https://gist.github.com/4692150深度相等且易于使用的结果：

function merge_arrays(arr1,arr2)
{
   ... 
   return {first:firstPart,common:commonString,second:secondPart,full:finalString}; 
}

console.log(merge_arrays(
[
[1,"10:55"] ,
[2,"10:55"] ,
[3,"10:55"]
],[
[3,"10:55"] ,
[4,"10:55"] ,
[5,"10:55"]
]).second);

result:
[
[4,"10:55"] ,
[5,"10:55"]
]

Array.prototype.add = function(b){
    var a = this.concat();                // clone current object
    if(!b.push || !b.length) return a;    // if b is not an array, or empty, then return a unchanged
    if(!a.length) return b.concat();      // if original is empty, return b

    // go through all the elements of b
    for(var i = 0; i < b.length; i++){
        // if b's value is not in a, then add it
        if(a.indexOf(b[i]) == -1) a.push(b[i]);
    }
    return a;
}

// Example:
console.log([1,2,3].add([3, 4, 5])); // will output [1, 2, 3, 4, 5]

Use:

Array.prototype.merge = function (arr) {
    var key;
    for(key in arr) 
        this[key] = arr[key];
};

之前写过同样的原因（适用于任意数量的数组）：

/**
 * Returns with the union of the given arrays.
 *
 * @param Any amount of arrays to be united.
 * @returns {array} The union array.
 */
function uniteArrays()
{
    var union = [];
    for (var argumentIndex = 0; argumentIndex < arguments.length; argumentIndex++)
    {
        eachArgument = arguments[argumentIndex];
        if (typeof eachArgument !== 'array')
        {
            eachArray = eachArgument;
            for (var index = 0; index < eachArray.length; index++)
            {
                eachValue = eachArray[index];
                if (arrayHasValue(union, eachValue) == false)
                union.push(eachValue);
            }
        }
    }

    return union;
}    

function arrayHasValue(array, value)
{ return array.indexOf(value) != -1; }

合并无限数量的数组或非数组并保持其唯一性：

function flatMerge() {
    return Array.prototype.reduce.call(arguments, function (result, current) {
        if (!(current instanceof Array)) {
            if (result.indexOf(current) === -1) {
                result.push(current);
            }
        } else {
            current.forEach(function (value) {
                console.log(value);
                if (result.indexOf(value) === -1) {
                    result.push(value);
                }
            });
        }
        return result;
    }, []);
}

flatMerge([1,2,3], 4, 4, [3, 2, 1, 5], [7, 6, 8, 9], 5, [4], 2, [3, 2, 5]);
// [1, 2, 3, 4, 5, 7, 6, 8, 9]

flatMerge([1,2,3], [3, 2, 1, 5], [7, 6, 8, 9]);
// [1, 2, 3, 5, 7, 6, 8, 9]

flatMerge(1, 3, 5, 7);
// [1, 3, 5, 7]

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

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

这是我需要合并（或返回两个数组的并集）时使用的函数。

var union = function (a, b) {
  for (var i = 0; i < b.length; i++)
    if (a.indexOf(b[i]) === -1)
      a.push(b[i]);
  return a;
};

var a = [1, 2, 3, 'a', 'b', 'c'];
var b = [2, 3, 4, 'b', 'c', 'd'];

a = union(a, b);
//> [1, 2, 3, "a", "b", "c", 4, "d"]

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

var array3 = union(array1, array2);
//> ["Vijendra", "Singh", "Shakya"]

function set(a, b) {
  return a.concat(b).filter(function(x,i,c) { return c.indexOf(x) == i; });
}

这里是关于计算时间方面最有效的方法。它还保持元素的初始顺序。

首先过滤第二个数组中的所有重复项，然后将剩下的连接到第一个数组。

var a = [1,2,3];
var b = [5,4,3];
var c = a.concat(b.filter(function(i){
    return a.indexOf(i) == -1;
}));
console.log(c); // [1, 2, 3, 5, 4]

这里有一个稍微改进（更快）的版本，但有一个缺点，即数组不能错过值：

var i, c = a.slice(), ci = c.length;
for(i = 0; i < b.length; i++){
    if(c.indexOf(b[i]) == -1)
        c[ci++] = b[i];
}

这里有一个稍微不同的循环。通过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）。

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

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

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

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

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

这是一个使用扩展运算符和数组泛型的ECMAScript 6解决方案。

目前，它只适用于Firefox，也可能适用于Internet Explorer技术预览版。

但如果你使用巴别尔，你现在就可以拥有它。

常量输入=[[1, 2, 3],[101, 2, 1, 10],[2, 1]];常量合并重复数据消除=（arr）=>{return[…new Set（[].contat（…arr））]；}console.log（“输出”，合并重复数据消除（输入））；

只需避开嵌套循环（O（n^2））和.indexOf（）（+O（n））。

函数合并（a，b）{var哈希＝｛｝；变量i；对于（i=0；i<a.length；i++）{hash[a[i]=真；}对于（i=0；i<b.length；i++）{hash[b[i]]=真；}return Object.keys（哈希）；}var array1=[“Vijendra”，“Singh”]；var array2=[“Singh”，“Shakya”]；var array3=合并（array1，array2）；console.log（array3）；

Array.prototype.pushUnique = function(values)
{
    for (var i=0; i < values.length; i++)
        if (this.indexOf(values[i]) == -1)
            this.push(values[i]);
};

Try:

var array1 = ["Vijendra","Singh"];
var array2 = ["Singh", "Shakya"];
array1.pushUnique(array2);
alert(array1.toString());  // Output: Vijendra,Singh,Shakya

下面是一个简单的例子：

var unique = function(array) {
    var unique = []
    for (var i = 0; i < array.length; i += 1) {
        if (unique.indexOf(array[i]) == -1) {
            unique.push(array[i])
        }
    }
    return unique
}

var uniqueList = unique(["AAPL", "MSFT"].concat(["MSFT", "BBEP", "GE"]));

我们定义unique（array）来删除冗余元素，并使用concat函数来组合两个数组。

如果像我一样，您需要支持较旧的浏览器，这适用于IE6+

function es3Merge(a, b) {
    var hash = {},
        i = (a = a.slice(0)).length,
        e;

    while (i--) {
        hash[a[i]] = 1;
    }

    for (i = 0; i < b.length; i++) {
        hash[e = b[i]] || a.push(e);
    }

    return a;
};

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

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

这是我的第二个答案，但我相信最快的答案是什么？我希望有人帮我检查并在评论中回复。

我的第一次尝试达到了99k操作/秒，这一次的复测是390k操作/每秒，而另一次领先的jsperf测试是140k（对我来说）。

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

这次我尝试尽可能减少阵列交互，看起来我获得了一些性能。

function findMerge(a1, a2) {
    var len1 = a1.length;

    for (var x = 0; x < a2.length; x++) {
        var found = false;

        for (var y = 0; y < len1; y++) {
            if (a2[x] === a1[y]) {
                found = true;
                break;
            }
        }

        if(!found){
            a1.push(a2.splice(x--, 1)[0]);
        }
    }

    return a1;
}

编辑：我对我的功能做了一些更改，与jsperf站点上的其他功能相比，性能非常出色。

我的一便士半：

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

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

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

这很快，可以整理任意数量的数组，并且可以处理数字和字符串。

function collate(a){ // Pass an array of arrays to collate into one array
    var h = { n: {}, s: {} };
    for (var i=0; i < a.length; i++) for (var j=0; j < a[i].length; j++)
        (typeof a[i][j] === "number" ? h.n[a[i][j]] = true : h.s[a[i][j]] = true);
    var b = Object.keys(h.n);
    for (var i=0; i< b.length; i++)
        b[i]=Number(b[i]);
    return b.concat(Object.keys(h.s));
}

> a = [ [1,2,3], [3,4,5], [1,5,6], ["spoon", "fork", "5"] ]
> collate( a )

[1, 2, 3, 4, 5, 6, "5", "spoon", "fork"]

如果你不需要区分5和“5”，那么

function collate(a){
    var h = {};
    for (i=0; i < a.length; i++) for (var j=0; j < a[i].length; j++)
        h[a[i][j]] = typeof a[i][j] === "number";
    for (i=0, b=Object.keys(h); i< b.length; i++)
        if (h[b[i]])
            b[i]=Number(b[i]);
    return b;
}
[1, 2, 3, 4, "5", 6, "spoon", "fork"]

可以。

如果你不介意（或者更愿意）所有值都以字符串结尾，那么就这样：

function collate(a){
    var h = {};
    for (var i=0; i < a.length; i++)
        for (var j=0; j < a[i].length; j++)
            h[a[i][j]] = true;
    return Object.keys(h)
}
["1", "2", "3", "4", "5", "6", "spoon", "fork"]

如果您实际上不需要数组，但只想收集唯一值并对其进行迭代，那么（在大多数浏览器（和node.js）中）：

h = new Map();
for (i=0; i < a.length; i++)
    for (var j=0; j < a[i].length; j++)
        h.set(a[i][j]);

这可能更好。

最佳解决方案。。。

您可以直接在浏览器控制台中点击。。。

无重复项

a = [1, 2, 3];
b = [3, 2, 1, "prince"];

a.concat(b.filter(function(el) {
    return a.indexOf(el) === -1;
}));

具有重复项

["prince", "asish", 5].concat(["ravi", 4])

如果你想要没有重复，你可以从这里尝试一个更好的解决方案-大喊代码。

[1, 2, 3].concat([3, 2, 1, "prince"].filter(function(el) {
    return [1, 2, 3].indexOf(el) === -1;
}));

在Chrome浏览器控制台上试用

 f12 > console

输出：

["prince", "asish", 5, "ravi", 4]

[1, 2, 3, "prince"]

您可以简单地使用ECMAScript 6，

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

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

看起来接受的答案是我测试中最慢的；

注意，我正在按Key合并2个对象数组

<!DOCTYPE html>
<html>
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width">
  <title>JS Bin</title>
</head>
<body>
<button type='button' onclick='doit()'>do it</button>
<script>
function doit(){
    var items = [];
    var items2 = [];
    var itemskeys = {};
    for(var i = 0; i < 10000; i++){
        items.push({K:i, C:"123"});
        itemskeys[i] = i;
    }

    for(var i = 9000; i < 11000; i++){
        items2.push({K:i, C:"123"});
    }

    console.time('merge');
    var res = items.slice(0);

    //method1();
    method0();
    //method2();

    console.log(res.length);
    console.timeEnd('merge');

    function method0(){
        for(var i = 0; i < items2.length; i++){
            var isok = 1;
            var k = items2[i].K;
            if(itemskeys[k] == null){
                itemskeys[i] = res.length;
                res.push(items2[i]);
            }
        }
    }

    function method1(){
        for(var i = 0; i < items2.length; i++){
            var isok = 1;
            var k = items2[i].K;

            for(var j = 0; j < items.length; j++){
                if(items[j].K == k){
                    isok = 0;
                    break;
                }
            }

            if(isok) res.push(items2[i]);
        }  
    }

    function method2(){
        res = res.concat(items2);
        for(var i = 0; i < res.length; ++i) {
            for(var j = i+1; j < res.length; ++j) {
                if(res[i].K === res[j].K)
                    res.splice(j--, 1);
            }
        }
    }
}
</script>
</body>
</html>

const merge（…args）=>（新集合（[].contat（…arg）））

[...array1,...array2] //   =>  don't remove duplication 

OR

[...new Set([...array1 ,...array2])]; //   => remove duplication

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

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）；

ES2015的功能方法

按照函数方法，两个数组的联合只是concat和filter的组合。为了提供最佳性能，我们使用本机Set数据类型，该类型针对属性查找进行了优化。

无论如何，结合联合函数的关键问题是如何处理重复项。以下排列是可能的：

Array A      + Array B

[unique]     + [unique]
[duplicated] + [unique]
[unique]     + [duplicated]
[duplicated] + [duplicated]

前两种排列很容易用一个函数处理。然而，后两个更复杂，因为只要依赖Set查找，就无法处理它们。由于切换到普通的旧Object属性查找会严重影响性能，因此下面的实现只会忽略第三个和第四个排列。你必须构建一个单独的union版本来支持它们。

//小型、可重复使用的辅助功能常量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））；}//模拟数据常量xs=[1,2,2,3,4,5]；常量=[0,1,2,3,3,4,5,6,6]；//我们来了console.log（“unique/unique”，union（重复数据消除（xs））（ys））；console.log（“重复/唯一”，union（xs）（ys））；

从这里开始，实现unionn函数变得很简单，它接受任意数量的数组（灵感来自naomik的评论）：

//小型、可重复使用的辅助功能常量未修正=f=>（a，b）=>f（a）（b）；常量foldl=f=>acc=>xs=>xs.reduce（uncurry（f），acc）；常量应用=f=>a=>f（a）；常量flip=f=>b=>a=>f（a）（b）；常量concat=xs=>y=>xs.contat（y）；const createSet=xs=>新集合（xs）；常量过滤器=f=>xs=>xs.filter（apply（f））；//工会和工会常量并集=xs=>ys=>{const zs=创建集（xs）；返回凹面（xs）(滤波器（x=>zs.has（x）? 假的：zs.add（x）)（ys））；}常量unionn=（头，…尾）=>foldl（联合）（头）（尾）；//模拟数据常量xs=[1,2,2,3,4,5]；常量=[0,1,2,3,3,4,5,6,6]；常数zs=[0,1,2,3,4,5,6,7,8,9]；//我们来了console.log（unionn（xs，ys，zs））；

事实证明unionn只是foldl（又名Array.protocol.reduce），它将union作为其缩减器。注意：由于实现没有使用额外的累加器，所以当您在没有参数的情况下应用它时，它会抛出错误。

最简单的方法是使用concat（）合并数组，然后使用filter（）删除重复项，或者使用concat（）将合并的数组放入Set（）中。

第一种方式：

const firstArray = [1,2, 2];
const secondArray = [3,4];
// now lets merge them
const mergedArray = firstArray.concat(secondArray); // [1,2,2,3,4]
//now use filter to remove dups
const removeDuplicates = mergedArray.filter((elem, index) =>  mergedArray.indexOf(elem) === index); // [1,2,3, 4]

第二种方式（但对UI有性能影响）：

const firstArray = [1,2, 2];
const secondArray = [3,4];
// now lets merge them
const mergedArray = firstArray.concat(secondArray); // [1,2,2,3,4]
const removeDuplicates = new Set(mergedArray);

var MergeArrays=function(arrayOne, arrayTwo, equalityField) {
    var mergeDictionary = {};

    for (var i = 0; i < arrayOne.length; i++) {
        mergeDictionary[arrayOne[i][equalityField]] = arrayOne[i];
    }

    for (var i = 0; i < arrayTwo.length; i++) {
        mergeDictionary[arrayTwo[i][equalityField]] = arrayTwo[i];
    }

    return $.map(mergeDictionary, function (value, key) { return value });
}

利用字典和Jquery，您可以合并这两个数组，而不会得到重复项。在我的示例中，我在对象上使用给定的字段，但可能只是对象本身。

使用reduce func查看的另一种方法：

function mergeDistinct(arResult, candidate){
  if (-1 == arResult.indexOf(candidate)) {
    arResult.push(candidate);
  }
  return arResult;
}

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

var arMerge = [];
arMerge = array1.reduce(mergeDistinct, arMerge);
arMerge = array2.reduce(mergeDistinct, arMerge);//["Vijendra","Singh","Shakya"];

只需使用Undercore.js的=>uniq即可实现：

array3 = _.uniq(array1.concat(array2))

console.log(array3)

它将印刷[“Vijendra”、“Singh”、“Shakya”]。

用法：https://gist.github.com/samad-aghaei/7250ffb74ed80732debb1cbb14d2bfb0

var _uniqueMerge = function(opts, _ref){
    for(var key in _ref)
        if (_ref && _ref[key] && _ref[key].constructor && _ref[key].constructor === Object)
          _ref[key] = _uniqueMerge((opts ? opts[key] : null), _ref[key] );
        else if(opts && opts.hasOwnProperty(key))
          _ref[key] = opts[key];
        else _ref[key] = _ref[key][1];
    return _ref;
}

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

最好也是最简单的方法是使用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"]

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

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

我简化了这个答案的最佳部分，并将其转化为一个很好的函数：

function mergeUnique(arr1, arr2){
    return arr1.concat(arr2.filter(function (item) {
        return arr1.indexOf(item) === -1;
    }));
}

作为LiraNuna的一部分的单线解决方案：

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

// Merges both arrays
let array3 = array1.concat(array2); 

//REMOVE DUPLICATE
let removeDuplicate = [...new Set(array3)];
console.log(removeDuplicate);

您可以合并结果并过滤重复项：

let combinedItems = [];

// items is an Array of arrays: [[1,2,3],[1,5,6],...]    
items.forEach(currItems => {
    if (currItems && currItems.length > 0) {
        combinedItems = combinedItems.concat(currItems);
    }
});

let noDuplicateItems = combinedItems.filter((item, index) => {
    return !combinedItems.includes(item, index + 1);
});

使用Lodash

我发现@GijsjanB的答案很有用，但我的数组包含具有许多属性的对象，因此我不得不使用其中一个属性来消除它们的重复。

这是我使用lodash的解决方案

userList1 = [{ id: 1 }, { id: 2 }, { id: 3 }]
userList2 = [{ id: 3 }, { id: 4 }, { id: 5 }]
// id 3 is repeated in both arrays

users = _.unionWith(userList1, userList2, function(a, b){ return a.id == b.id });

// users = [{ id: 1 }, { id: 2 }, { id: 3 }, { id: 4 }, { id: 5 }]

作为第三个参数传递的函数有两个参数（两个元素），如果它们相等，则必须返回true。

/***对仅保留唯一值的数组进行重复数据消除。*使用哈希表（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

为此……这里有一个单行解决方案：

const x = [...new Set([['C', 'B'],['B', 'A']].reduce( (a, e) => a.concat(e), []))].sort()
// ['A', 'B', 'C']

不是特别可读，但它可能会帮助某人：

将初始累加器值设置为空数组的reduce函数应用于空数组。reduce函数使用concat将每个子数组附加到累加器数组上。其结果作为构造函数参数传递，以创建新的Set。排列运算符用于将集合转换为数组。sort（）函数应用于新数组。

使用集合（ECMAScript 2015），将非常简单：

const array1=[“Vijendra”，“Singh”]；const array2=[“Singh”，“Shakya”]；console.log（Array.from（new Set（array1.concat（array2））））；

我学会了一种用扩展运算符连接两个数组的小方法：

var array1 = ['tom', 'dick', 'harry'];
var array2 = ['martin', 'ricky'];

array1.push(...array2);

“…”扩展运算符将以下数组拆分为单个项，然后push可以将它们作为单独的参数处理。

可以使用Set完成。

var array1=[“Vijendra”，“Singh”]；var array2=[“Singh”，“Shakya”]；var array3=array1.concat（array2）；var tempSet=新集合（array3）；array3=Array.from（tempSet）；//显示输出document.body.querySelector（“div”）.innerHTML=JSON.stringify（array3）；<div style=“width:100%；height:4rem；line height:4rem；background color:steelblue；color:#DDD；text align:center；font-family:Calibri”>临时文本</div>

var a = [1,2,3]
var b = [1,2,4,5]

我喜欢一行。这将把不同的b元素推到

b.forEach(item => a.includes(item) ? null : a.push(item));

另一个版本不会修改

var c = a.slice();
b.forEach(item => c.includes(item) ? null : c.push(item));

DeDuplicate单个或Merge和DeDupliplicate多个数组输入。示例如下。

使用ES6-设置，用于，销毁

我编写了一个接受多个数组参数的简单函数。与上面的解决方案几乎相同，只是有更实际的用例。此函数不会将重复的值连接到一个数组中，以便在稍后阶段删除它们。

短功能定义（仅9行）

/**
* This function merging only arrays unique values. It does not merges arrays in to array with duplicate values at any stage.
*
* @params ...args Function accept multiple array input (merges them to single array with no duplicates)
* it also can be used to filter duplicates in single array
*/
function arrayDeDuplicate(...args){
   let set = new Set(); // init Set object (available as of ES6)
   for(let arr of args){ // for of loops through values
      arr.map((value) => { // map adds each value to Set object
         set.add(value); // set.add method adds only unique values
      });
   }
   return [...set]; // destructuring set object back to array object
   // alternativly we culd use:  return Array.from(set);
}

使用示例代码笔：

// SCENARIO 
let a = [1,2,3,4,5,6];
let b = [4,5,6,7,8,9,10,10,10];
let c = [43,23,1,2,3];
let d = ['a','b','c','d'];
let e = ['b','c','d','e'];

// USEAGE
let uniqueArrayAll = arrayDeDuplicate(a, b, c, d, e);
let uniqueArraySingle = arrayDeDuplicate(b);

// OUTPUT
console.log(uniqueArrayAll); // [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 43, 23, "a", "b", "c", "d", "e"]
console.log(uniqueArraySingle); // [4, 5, 6, 7, 8, 9, 10]

array1.concat(array2).filter((value, pos, arr)=>arr.indexOf(value)===pos)

这一行的优点在于性能，而且在使用数组时，通常都是链接方法，如filter、map等，因此您可以添加这一行，它将使用array1对array2进行合并和重复数据消除，而无需引用后面的一行（当您链接没有的方法时），例如：

someSource()
.reduce(...)
.filter(...)
.map(...) 
// and now you want to concat array2 and deduplicate:
.concat(array2).filter((value, pos, arr)=>arr.indexOf(value)===pos)
// and keep chaining stuff
.map(...)
.find(...)
// etc

（我不想污染Array.prototype，这将是尊重链的唯一方式——定义一个新函数将打破它——所以我认为这样做是实现这一点的唯一方式）

对于ES6，只有一行：

a = [1, 2, 3, 4]
b = [4, 5]
[...new Set(a.concat(b))]  // [1, 2, 3, 4, 5]

var arr1 = [1, 3, 5, 6];
var arr2 = [3, 6, 10, 11, 12];
arr1.concat(arr2.filter(ele => !arr1.includes(ele)));
console.log(arr1);

output :- [1, 3, 5, 6, 10, 11, 12]

您可以使用loadash unionWith-_.unionWith（〔arrays〕，〔comparator〕）

此方法类似于_.union，只是它接受被调用来比较数组元素的比较器。结果值从出现该值的第一个数组中选择。比较器由两个参数调用：（arrVal，othVal）。

var array1=[“Vijendra”，“Singh”]；var array2=[“Singh”，“Shakya”]；var array3=_.unionWith（array1，array2，_.isEqual）；console.log（array3）；<script src=“https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.11/lodash.min.js“></script>

如果不希望复制特定属性（例如ID）

let noDuplicate = array1.filter ( i => array2.findIndex(a => i.id==a.id)==-1 );
let result = [...noDuplicate, ...array2];

如果您纯粹使用underscore.js，它没有unionWith、unionBy

您可以尝试：_uniq（_.union（arr1，arr2），（obj）=>obj.key）（key是每个对象的关键参数）这将有助于在两个数组合并后获得唯一性。

给定两个没有重复的简单类型的排序数组，这将在O（n）时间内合并它们，并且输出也将被排序。

function merge(a, b) {
    let i=0;
    let j=0;
    let c = [];
    for (;;) {
        if (i == a.length) {
            if (j == b.length) return c;
            c.push(b[j++]);
        } else if (j == b.length || a[i] < b[j]) {
            c.push(a[i++]);
        } else {
            if (a[i] == b[j]) ++i;   // skip duplicates
            c.push(b[j++]);
        }
    }
}

var array1=[“一”，“二”]；var array2=[“two”，“three”]；var collectionOfTwoArrays=[…array1，…array2]；var uniqueList=array=>[…new Set（array）]；console.log（'集合：'）；console.log（collectionOfTwoArrays）；console.log（'没有重复项的集合：'）；console.log（uniqueList（collectionOfTwoArrays））；

你可以试试这个：

常量union=（a，b）=>Array.from（新集合（[…a，…b]））；console.log（联合（[“neymar”，“mesi”]，[“ronaldo”，“neymmar”]）；

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

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

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

模块化，通用

这可以通过组成两个基本功能来实现。

const getUniqueMerge = (...arrs) => getUniqueArr(mergeArrs(...arrs))
const getUniqueArr = (array) => Array.from(new Set(array))  
const mergeArrs = (...arrs) => [].concat(...arrs)

它可以处理无限的数组或值

console.log(getUniqueMerge(["Vijendra","Singh"],["Singh", "Shakya"])
// ["Vijendra", "Singh", "Shakya"]

console.log(getUniqueMerge(["Sheldon", "Cooper"], ["and", "Cooper", "Amy", "and"], "Farrah", "Amy", "Fowler"))
// ["Sheldon", "Cooper", "and", "Amy", "Farrah", "Fowler"]

我认为这工作得更快。

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

ES2019年

可以像union（array1，array2，array3，…）一样使用它

/**
 * Merges two or more arrays keeping unique items. This method does
 * not change the existing arrays, but instead returns a new array.
 */
function union<T>(...arrays: T[]) {
  return [...new Set([...arrays].flat())];
}

这是ES2019，因为flat（）函数，但您可以使用core js将其作为polyfill获取。这里的T是TypeScript泛型类型，如果不使用TypeScript，则可以删除它。如果您使用的是TypeScript，请确保在tsconfig.json中的编译器选项中添加“lib”：[“es2019.array”]。

或

只需使用lodash。union

减少他们！！！

这种替代方法不是显式地合并和重复数据消除，而是采用一个数组并用另一个数组减少它，这样第一个数组的每个值都可以在累积行为中迭代和销毁，因为递归性，所以通过利用数组的持久性来忽略已经包含的值。

array2.reduce(reducer, array1.reduce(reducer, []))

测试示例：

var array1=[“Vijendra”，“Singh”，“辛格”]；var array2=[“Singh”，“Shakya”，“Shakya”]；const reducer=（accumulator，currentValue）=>accumulater.includes（currentValue）？累加器：[…累加器，currentValue]；控制台日志(array2.reduce（reducer，array1.reduce，[]））);//需要减少第一阵列，以确保减少第二阵列上用作初始值的重复数据消除阵列

结论

在枯燥乏味的时候，每一种方法都需要避免（并不是说它没有用处）。

处理重复数据消除的concat（）限制。

不需要Undercore.js、JQuery或Lo Dash等外部库，也不需要创建任何内置函数来实现所需的合并和重复数据消除效果。

哦，嘿！，它可以作为一个内衬完成！！！

由于ES5（ECMAScript 2015）、漂亮的include（）和华丽的reduce（），这个答案是可能的。

   //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
   */

合并两个阵列有很多解决方案。它们可以分为两大类（除了使用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)));

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

因此，值得为未来的读者添加一种适当的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} ]

编辑：

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

如果您合并对象数组，请考虑使用lodash UnionBy函数，它允许您设置自定义谓词比较对象：

import { unionBy } from 'lodash';

const a = [{a: 1, b: 2}];
const b = [{a: 1, b: 3}];
const c = [{a: 2, b: 4}];

const result = UnionBy(a,b,c, x => x.a);

结果是：〔｛a:1；b:2｝，｛a:2；b:4｝〕

结果中使用了来自数组的第一个传递匹配

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

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

表演

今天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，因为它们修改了输入数组，基准测试给出了错误的结果

对于n个数组，可以这样得到并集。

function union(arrays) {
    return new Set(arrays.flat()).keys();
};

构建一个测试人员来检查一些面向性能的答案的速度。请随意添加更多内容。到目前为止，Set是最简单和最快的选项（随着记录数量的增加，它的边距会更大），至少对于简单的number类型来说是如此。

常量记录=10000，//每个阵列的最大记录数max_int=100，//每个数组的最大整数值dup_rate=.5//复制率让perf={}，//性能记录器，ts＝0，te＝0，array1=[]，//初始化数组array2＝[]，array1b＝[]，array2b＝[]，a=[]；//填充随机化数组for（设i=0；i<记录；i++）{设r=Math.random（），n=r*max_int；如果（Math.random（）<.5）{array1.push（n）；r<dup_rate&&array2.push（n）；}其他{阵列2.push（n）；r<dup_rate&&array1.push（n）；}}//缺少rfdc的简单深度副本，以防有人想要使用更复杂的数据类型进行测试array1b=JSON.parse（JSON.stringify（array1））；array2b=JSON.parse（JSON.stringfy（array2））；console.log（'数组1中的记录：'，array1.length，array1b.length）；console.log（'数组2中的记录：'，array2.length，array2b.length）；//试验方法1（jsperf per@Pitouli）ts=performance.now（）；for（设i=0；i<array2.length；i++）如果（array1.indexOf（array2[i]）==-1）array1.push（array2[i]）//修改数组1te=performance.now（）；perf.m1=te-ts；console.log（'方法1合并'，array1.length，'记录在：'，perf.m1）；array1=JSON.parse（JSON.stringify（array1b））//重置阵列1//测试方法2（经典的Each）ts=performance.now（）；array2.forEach（v=>array1.includes（v）？null:array1.push（v））//修改数组1te=performance.now（）；perf.m2=te-ts；console.log（'方法2合并'，array1.length，'记录在：'，perf.m2中）；//测试方法3（最简单的本机选项）ts=performance.now（）；a=[…新集合（[…array1，…array2]）]//不修改源阵列te=performance.now（）；perf.m3=te-ts；console.log（'方法3合并'，a.length，'记录在：'，perf.m3）；//测试方法4（选定答案）ts=performance.now（）；a=阵列1.concat（阵列2）//不修改源阵列for（设i=0；i<a.length；++i）{for（设j=i+1；j<a.length；++j）{如果（a[i]===a[j]）a.接头（j-，1）；}}te=performance.now（）；perf.m4=te-ts；console.log（'Method 4 merged'，a.length，'records in：'，perf.m4）；//试验方法5（@Kamil Kielczewski）ts=performance.now（）；函数K（arr1，arr2）{设r=[]，h＝{}；而（arr1.length）{设e=arr1.shift（）//修改数组1如果（！h[e]）h[e]=1&&r.push（e）；}而（arr2.长度）{设e=arr2.shift（）//修改数组2如果（！h[e]）h[e]=1&&r.push（e）；}返回r；}a=K（阵列1，阵列2）；te=performance.now（）；perf.m5=te-ts；console.log（'Method 5 merged'，a.length，'records in：'，perf.m4）；array1=JSON.parse（JSON.stringify（array1b））//重置阵列1array2=JSON.parse（JSON.stringfy（array2b））//重置阵列2for（设i=1；i<6；i++）{console.log（'方法：'，i，'速度为'，（perf[m'+i]/perf.m1*100）.toFixed（2），'方法1的%'）；}

下面是使用Set的另一个简单解决方案：

常量o1={a:1}；const arr1=['！@#$%^&*（）'，'gh'，123，o1，1，true，undefined，null]；常量arr2=['！@#$%^&*（）'，123，'abc'，o1，0x001，true，void 0，0]；const mergeUnique=（…args）=>[…新集合（[].contat（…arg））]；console.log（mergeUnique（arr1，arr2））；

关心效率，但想在线实现

const s = new Set(array1);
array2.forEach(a => s.add(a));
const merged_array = [...s]; // optional: convert back in array type

ES6提供了一种单线解决方案，通过使用析构函数和集合来合并多个数组而不重复。

const array1 = ['a','b','c'];
const array2 = ['c','c','d','e'];
const array3 = [...new Set([...array1,...array2])];
console.log(array3); // ["a", "b", "c", "d", "e"]

在当今时代，使用现有的图书馆提供更简单、更优雅的内容：

import {pipe, concat, distinct} from 'iter-ops';

// our inputs:
const array1 = ['Vijendra', 'Singh'];
const array2 = ['Singh', 'Shakya'];

const i = pipe(
    array1,
    concat(array2), // adding array
    distinct() // making it unique
);

console.log([...i]); //=> ['Vijendra', 'Singh', 'Shakya']

这两者都是高性能的，因为我们只迭代一次，而且代码非常容易阅读。

注：我是iter ops的作者。

如果您有非常大的列表，则不执行此操作，因为已经记录了许多解决方案，所以这不适合合并，但我用此解决方案解决了我的问题（因为大多数数组过滤解决方案都适用于简单数组）

const uniqueVehiclesServiced = 
  invoice.services.sort().filter(function(item, pos, ary) {
    const firstIndex = invoice.services.findIndex((el, i, arr) => el.product.vin === item.product.vin)

  return !pos || firstIndex == pos;
});

我有一个类似的请求，但它具有数组中元素的Id。

这里是我进行重复数据消除的方法。

它简单，易于维护，使用方便。

// Vijendra's Id = Id_0
// Singh's Id = Id_1
// Shakya's Id = Id_2

let item0 = { 'Id': 'Id_0', 'value': 'Vijendra' };
let item1 = { 'Id': 'Id_1', 'value': 'Singh' };
let item2 = { 'Id': 'Id_2', 'value': 'Shakya' };

let array = [];

array = [ item0, item1, item1, item2 ];

let obj = {};
array.forEach(item => {
    obj[item.Id] = item;
});

let deduplicatedArray = [];
let deduplicatedArrayOnlyValues = [];
for(let [index, item] of Object.values(obj).entries()){
    deduplicatedArray = [ ...deduplicatedArray, item ];
    deduplicatedArrayOnlyValues = [ ...deduplicatedArrayOnlyValues , item.value ];
};
    
console.log( JSON.stringify(array) );
console.log( JSON.stringify(deduplicatedArray) );
console.log( JSON.stringify(deduplicatedArrayOnlyValues ) );

控制台日志

[{"recordId":"Id_0","value":"Vijendra"},{"recordId":"Id_1","value":"Singh"},{"recordId":"Id_1","value":"Singh"},{"recordId":"Id_2","value":"Shakya"}]

[{"recordId":"Id_0","value":"Vijendra"},{"recordId":"Id_1","value":"Singh"},{"recordId":"Id_2","value":"Shakya"}]

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

ES 6版本

试试这个。。。这应该能解决你的问题

var array1=[“Vijendra”，“Singh”]；var array2=[“Singh”，“Shakya”]；

var输出=[…new Set（[…array1，…array2]）]

console.log（“合并数组”，输出）

使用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）；

可以使用新的“集”删除重复

[...new Set([...array1 ,...array2])]

const array3 = array1.filter(t=> !array2.includes(t)).concat(array2)