如何在JavaScript中合并两个数组并消除重复项

我有两个JavaScript数组：

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

我希望输出为：

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

输出数组应删除重复的字

如何在JavaScript中合并两个数组，以便按照插入原始数组的相同顺序仅从每个数组中获取唯一项？

新解决方案（使用

array.prototype.indexOf

和

array.prototype.concat

）：

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

Array.prototype.indexOf=Array.prototype.indexOf | |函数（elt）
{
var len=this.length>>>0；
var from=Number（参数[1]）| | 0；
from=（from<0）？Math.ceil（from）：Math.floor（from）；
如果（from<0）from+=len；
for（；from

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

ES5版本使用

数组。concat

：

var array1=[“Vijendra”，“Singh”]；
var array2=[“辛格”、“沙基亚”]；
console.log（array1.concat（array2））
//Array.indexOf是在javascript 1.6（ECMA-262）中引入的
//我们需要为其他浏览器显式地实现它，
if（！Array.prototype.indexOf）
{
Array.prototype.indexOf=函数（elt，from）
{
var len=this.length>>>0；
for（；from

其他浏览器的
indexOf
方法的实现取自为什么不使用对象？看起来您正在尝试为一组对象建模。然而，这不会维持秩序

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=函数（/*数组的可变数目*/）{
for（var i=0；i

一个更好的数组合并函数
 使用下划线.js或Lo Dash，您可以执行以下操作：


console.log（u.union（[1,2,3]，[101,2,1,10]，[2,1]）
我只要把两分钱投进去就行了

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

函数合并字符串数组（a，b）{
var hash={}；
var-ret=[]；
对于（变量i=0；i

这是我经常使用的一种方法，它使用一个对象作为hashlookup表来执行重复检查。假设散列是O（1），那么它在O（n）中运行，其中n是a.length+b.length。老实说，我不知道浏览器是如何进行哈希运算的，但它在数千个数据点上表现良好。
Array.prototype.add=function（b）{
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]

var a=this.concat（）；//克隆当前对象
如果（！b.push | | |！b.length）返回a；//如果b不是数组或空，则返回a不变
如果（！a.length）返回b.concat（）；//如果original为空，则返回b
//检查b的所有元素
对于（变量i=0；i
首先连接两个数组，然后仅过滤出唯一项：


var a=[1,2,3]，b=[101,2,1,10]
var c=a.concat（b）
变量d=c.filter（（项目，位置）=>c.indexOf（项目）==pos）
log（d）//d是[1,2,3,101,10]
这里是对循环的一个稍微不同的理解。在最新版本的Chrome中进行了一些优化，这是解决两个阵列合并的最快方法（Chrome38.0.2111）


while循环：~589k次操作/s

过滤器：~445k操作/秒

洛达斯：308k运营/服务

环路：225k运行/秒

一条评论指出，我的一个设置变量导致我的循环领先于其他变量，因为它不必初始化要写入的空数组。我同意这一点，所以我重新编写了测试，以平衡竞争环境，并包括一个更快的选项


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

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

看看吧，如果你想把它的速度提高一个档次。在浏览了几乎所有可行的答案之后，这些是迄今为止最快的结果。
这是一个使用和数组泛型的ECMAScript 6解决方案

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

但是如果你使用，你现在就可以拥有它


const输入=[
[1, 2, 3],
[101, 2, 1, 10],
[2, 1]
];
常量合并重复数据消除=（arr）=>{
返回[…新集合（[].concat（…arr））]；
}
console.log（'output'，merg
//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
  }

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

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

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]

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

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

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

 f12 > console

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

[1, 2, 3, "prince"]

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

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

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

Array A      + Array B

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

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

console.log(array3)

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

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

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

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

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

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

for (var i = 0; i < array2.length; i++)
    if (array1.indexOf(array2[i]) === -1)
      array1.push(array2[i]);

array2.forEach(v => array1.includes(v) ? null : array1.push(v));

var a = [...new Set([...array1 ,...array2])];

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