构建一个测试人员来检查一些面向性能的答案的速度。请随意添加更多内容。到目前为止，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的%'）；}

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

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

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

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

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

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

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

减少他们！！！

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

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（），这个答案是可能的。

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