Legen Sie Sammlungen, Gleichheit für Objekte, die Kartenarray-Methode und mehr fest

In diesem Beitrag werden wir uns mit der Herausforderung befassen, festzustellen, ob ein Array Duplikate enthält.

Gleichheit zwischen Primitiven und Objekten

Was ist ein doppelter Wert?

Für primitive Werte ist dies offensichtlich. Nehmen Sie zum Beispiel das folgende Array von Zeichenfolgen.

['A', 'B', 'B', 'C']

Was ist mit Objekten? Überprüfen Sie das nächste Array.

[{ char: 'A'}, { char: 'A'}]

{ char: 'A'} !== { char: 'A'}
//true

Erkennen von Duplikaten in Arrays von Grundelementen

Denken Sie daran, dass wir in JavaScript neben Arrays auch SetSammlungen haben.

Sets sind Sammlungen eindeutiger Werte.

Wie Sie verstehen können, sind Werte in einer SetSammlung eindeutig . Wir können das Array einfach in ein Array umwandeln Setund eine neue Sammlung ohne Duplikate erstellen. Dann können wir die Größe der SetSammlung mit der Größe des ursprünglichen Arrays vergleichen und feststellen, ob es Duplikate enthält.

Hier ist, wie wir es machen können.

const arr = [1, 1, 1, 2, 3];
const set = new Set(arr);
const hasDuplicates = set.size < arr.length;
console.log(hasDuplicates)
//true

Die lengthEigenschaft erhält die Größe des Arrays.

Die sizeEigenschaft ruft die Größe der SetSammlung ab.

Erkennen von Duplikaten in Arrays von Objekten

Was ist mit Objekten? Funktioniert die vorherige Logik auch für Objekte?

Lass es uns versuchen.

const arr = [{char: 'A'}, {char: 'A'}];
const set = new Set(arr);
const hasDuplicates = set.size < arr.length;
console.log(hasDuplicates)
//false

Was können wir dann tun?

Wir können zum Beispiel ein Objekt in eine JSON-Zeichenfolge umwandeln. Zwei Objekte mit denselben Eigenschaften und Speichern derselben Werte erzeugen dieselbe JSON-Zeichenfolge. Überprüfen Sie, wie wir das mit der JSON.stringifyFunktion machen können.

const obj1 = { char: 'A' };
const obj2 = { char: 'A' };
const jsonObj1 = JSON.stringify(obj1);
//{"char":"A"}
const jsonObj2 = JSON.stringify(obj2);
//{"char":"A"}
console.log(obj1 === obj2);
//false
console.log(jsonObj1 === jsonObj2);
//true

Wie können wir diese Transformation von einem Array von Objekten zu einem Array von JSON-Strings durchführen?

Die mapArray-Methode konvertiert ein Array von Werten mithilfe einer Zuordnungsfunktion in ein neues Array.

Was ist die Mapping-Funktion in unserem Fall?

Das stimmt. Die Zuordnungsfunktion ist in diesem Fall die JSON.stringify. Übergeben wir es an die Kartenmethode und überprüfen das Ergebnis.

const arr = [{char: 'A'}, {char: 'A'}];
const jsonArr = arr.map(JSON.stringify);
console.log(jsonArr);
//[
//"{"char":"A"}",
//"{"char":"A"}"
//]

const arr = [{char: 'A'}, {char: 'A'}];
const set = new Set(arr.map(JSON.stringify));
const hasDuplicates = set.size < arr.length;
console.log(hasDuplicates)
//true

OK. Dies ist noch einfacher als das, was wir bereits getan haben. Anstatt neue SetObjekte zu erstellen, erstellen wir neue SetIDs. Dieses Set enthält nur die eindeutigen IDs.

Mit wem können wir eine Liste von Objekten in eine Liste von IDs konvertieren?

Ja, einfach mit der mapArray-Methode.

const arr = [
  {id: 1, name: 'Joker'},
  {id: 2, name: 'Bane'},
  {id: 1, name: 'Joker' }
];
const ids = arr.map(obj => obj.id);
console.log(ids);
//[1, 2, 1]

const set = new Set(ids);
const hasDuplicates = set.size < arr.length;
console.log(hasDuplicates)
//true