Zusammenführen von zwei Arrays in JavaScript und Duplizieren von Elementen

Question

Ich habe zwei JavaScript-Arrays:

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

Ich möchte, dass die Ausgabe so aussieht:

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

Im Ausgabe-Array sollten wiederholte Wörter entfernt werden.

Wie kann ich zwei Arrays in JavaScript zusammenführen, so dass ich nur die eindeutigen Elemente aus jedem Array in der gleichen Reihenfolge erhalte, in der sie in die ursprünglichen Arrays eingefügt wurden?

Answer 1

Ich weiß, dass es bei dieser Frage nicht um die Anordnung von Objekten geht, aber die Suchenden landen hier.

Es lohnt sich also, für künftige Leser eine korrekte ES6-Methode zum Zusammenführen und anschließenden Entfernen von Duplikaten hinzuzufügen

Array von Objekten :

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

Answer 2

Vermeiden Sie einfach verschachtelte Schleifen (O(n^2)), und .indexOf() (+O(n)).

function merge(a, b) {
  var hash = {};
  var i;

  for (i = 0; i < a.length; i++) {
    hash[a[i]] = true;
  }
  for (i = 0; i < b.length; i++) {
    hash[b[i]] = true;
  }
  return Object.keys(hash);
}

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

var array3 = merge(array1, array2);

console.log(array3);

Answer 3

Ich möchte nur meinen Senf dazugeben.

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

Dies ist eine Methode, die ich häufig verwende. Sie verwendet ein Objekt als Hashlookup-Tabelle, um die Duplikatprüfung durchzuführen. Angenommen, der Hash ist O(1), dann läuft dies in O(n), wobei n a.length + b.length ist. Ich habe ehrlich gesagt keine Ahnung, wie der Browser den Hash durchführt, aber er ist bei vielen Tausend Datenpunkten sehr leistungsfähig.

Answer 4

EDIT:

Die erste Lösung ist nur dann die schnellste, wenn es nur wenige Artikel gibt. Bei mehr als 400 Einträgen ist die Set Lösung die schnellste ist. Und wenn es 100.000 Elemente gibt, ist sie tausendmal schneller als die erste Lösung.

In Anbetracht der Tatsache, dass Leistung nur dann wichtig ist, wenn es viele Artikel gibt, und dass die Set Lösung bei weitem die lesbarste ist, sollte sie in den meisten Fällen die richtige Lösung sein

Die nachstehenden Perf-Ergebnisse wurden mit einer kleinen Anzahl von Items berechnet

---

Basierend auf jsperf, der schnellste Weg (edit: wenn es weniger als 400 Artikel gibt) um zwei Arrays in einem neuen zu verschmelzen, ist die folgende:

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

Dieser ist 17 % langsamer:

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

Dieser ist 45 % langsamer (edit: wenn es weniger als 100 Artikel gibt. Es ist viel schneller, wenn es eine Menge von Elementen ist) :

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

Und die akzeptierten Antworten sind 55% langsamer (und viel länger zu schreiben) (edit: und es ist um mehrere Größenordnungen langsamer als jede der anderen Methoden, wenn es 100 000 Artikel gibt)

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

Answer 5

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

Eine viel bessere Array-Merge-Funktion.