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

Wenn Sie keine Duplikate einer bestimmten Eigenschaft (z. B. der ID) wünschen

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

Answer 2

Ein funktionaler Ansatz mit ES2015

Nach dem funktionalen Ansatz wird ein union von zwei Array s ist einfach die Zusammensetzung von concat y filter . Um eine optimale Leistung zu gewährleisten, greifen wir auf die native Set Datentyp, der für die Suche nach Eigenschaften optimiert ist.

Wie auch immer, die Schlüsselfrage in Verbindung mit einem union Funktion ist, wie Duplikate zu behandeln sind. Die folgenden Permutationen sind möglich:

Array A      + Array B

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

Die ersten beiden Permutationen sind mit einer einzigen Funktion leicht zu handhaben. Die letzten beiden sind jedoch komplizierter, da man sie nicht verarbeiten kann, solange man sich auf Set Nachschlagen. Seit der Umstellung auf die einfache alte Object Die folgende Implementierung ignoriert einfach die dritte und vierte Permutation, da die Suche nach den Eigenschaften einen erheblichen Leistungsverlust zur Folge hätte. Sie müssten eine separate Version von union um sie zu unterstützen.

---

// small, reusable auxiliary functions

const comp = f => g => x => f(g(x));
const apply = f => a => f(a);
const flip = f => b => a => f(a) (b);
const concat = xs => y => xs.concat(y);
const afrom = apply(Array.from);
const createSet = xs => new Set(xs);
const filter = f => xs => xs.filter(apply(f));

// de-duplication

const dedupe = comp(afrom) (createSet);

// the actual union function

const union = xs => ys => {
  const zs = createSet(xs);  
  return concat(xs) (
    filter(x => zs.has(x)
     ? false
     : zs.add(x)
  ) (ys));
}

// mock data

const xs = [1,2,2,3,4,5];
const ys = [0,1,2,3,3,4,5,6,6];

// here we go

console.log( "unique/unique", union(dedupe(xs)) (ys) );
console.log( "duplicated/unique", union(xs) (ys) );

Von hier an wird es trivial, eine unionn Funktion, die eine beliebige Anzahl von Arrays akzeptiert (inspiriert durch die Kommentare von Naomik):

// small, reusable auxiliary functions

const uncurry = f => (a, b) => f(a) (b);
const foldl = f => acc => xs => xs.reduce(uncurry(f), acc);

const apply = f => a => f(a);
const flip = f => b => a => f(a) (b);
const concat = xs => y => xs.concat(y);
const createSet = xs => new Set(xs);
const filter = f => xs => xs.filter(apply(f));

// union and unionn

const union = xs => ys => {
  const zs = createSet(xs);  
  return concat(xs) (
    filter(x => zs.has(x)
     ? false
     : zs.add(x)
  ) (ys));
}

const unionn = (head, ...tail) => foldl(union) (head) (tail);

// mock data

const xs = [1,2,2,3,4,5];
const ys = [0,1,2,3,3,4,5,6,6];
const zs = [0,1,2,3,4,5,6,7,8,9];

// here we go

console.log( unionn(xs, ys, zs) );

Es stellt sich heraus unionn ist nur foldl (alias Array.prototype.reduce ), die die union als dessen Reduktionsmittel. Hinweis: Da die Implementierung keinen zusätzlichen Akkumulator verwendet, wird sie einen Fehler auslösen, wenn Sie sie ohne Argumente anwenden.

Answer 3

Um der Sache willen... hier eine einzeilige Lösung:

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

Nicht besonders lesenswert, aber vielleicht hilft es jemandem:

1. Wendet eine Reduktionsfunktion an, wobei der anfängliche Akkumulatorwert auf ein leeres Array gesetzt wird.
2. Die Funktion reduce verwendet concat, um jedes Unter-Array an das Akkumulator-Array anzuhängen.
3. Das Ergebnis wird als Konstruktorparameter übergeben, um eine neue Set .
4. Der Spreizungsoperator wird verwendet, um die Set zu einem Array.
5. El sort() Funktion wird auf das neue Array angewendet.

Answer 4

1. Verwendung von array.concat() y array.filter()
2. Neues Set-Objekt verwenden y Spread Operator

3. Verwendung von array.concat y neues Set-Objekt

   let array1 = [1, 2, 3, 4, 5] let array2 = [1, 4, 6, 9]

   // Using array.concat and array.filter const array3 = array1.concat(array2.filter((item)=> array1.indexOf(item) == -1 )) console.log('array3 : ', array3);

   // Using new Set and Spread Operator const array4 = [...new Set([...array1 ,...array2])]; console.log('array4 : ', array4);

   // Using array.concat and new Set const array5 = [...new Set(array1.concat(array2))]; console.log('array5 : ', array5);

Answer 5

Sie können dies versuchen:

const union = (a, b) => Array.from(new Set([...a, ...b]));

console.log(union(["neymar","messi"], ["ronaldo","neymar"]));