Wie kann man vermeiden in einer Liste doppeltes Objekts Hinzufügen

Question

Dies ist meine Modellklasse

export class PersonModel { 

    persCode:number; 
    name:string; 
    contactNumber:number; 
    remarks:string; 
    } 

I

affectedPersons: PersonModel[] = []; 

eine Liste von Objekten von PersonModel habe Wie kann ich überprüfen, ob ein Objekt vorhanden ist in dieser Liste. So kann ich vermeiden, doppelte Werte hinzuzufügen.

addVisitor() { 
     let visitorVal : PersonModel ; 
     visitorVal = this.affectedPersons.filter(x => x.name == this.visitorName && x.contactNumber== this.visitorMob && x.remarks==this.visitorRemark, x => console.log("x "+ JSON.stringify(x))) 
      .map(x => x)[0]; 

     } 

Dies funktioniert nicht. Wie kann ich dies erreichen

Answer 1

Definieren Sie das Konzept von "gleich" in Form einer JS-Funktion. Dafür sind sie da.

function objectsAreEqual(obj1, obj2) { 
    return obj1.name === obj2.visitorName && 
    obj1.contactNumber === obj2.visitorMob && 
    obj1.remarks === objs.visitorRemark; 
} 

Jetzt können Sie feststellen, ob ein Objekt in einem Array von Objekten mit ist

const visitorAlreadyInArray = arr.some(obj => objectsAreEqual(obj, newObj)) 

Wenn Sie das tatsächliche passende Objekt finden wollen, dann

const visitorVal = arr.find(obj => objectsAreEqual(obj, newObj)) 

filter kann in Arbeit dieser Fall, aber es ist nicht die beste Lösung. Logischerweise ist der Filter so konzipiert, dass er eine Liste von Dingen eingrenzt. Das ist nicht das, was du versuchst. Sie versuchen, finden Sie eine eine Sache. Das ist, was find ist. Es hat den Vorteil, dass es aufhört, sobald es das Ding findet, nach dem es sucht. Im Vertrag läuft filter weiter auf alle Elemente des Arrays, selbst nachdem es das erste Match bereits gefunden hat.

Dies ist jedoch nicht wirklich eine ideale Lösung. Sie haben die Namen der Eigenschaften Ihrer Objekte fest in die Lösung eingefügt. Das bedeutet, dass Sie jedes Mal, wenn Sie eine Eigenschaft ändern oder hinzufügen, diesen Teil des Codes ändern müssen. Das ist keine gute Sache. Wir wollen eine bessere Version schreiben, die unabhängig von den Eigenschaften funktioniert.

Dazu müssen Sie zunächst zur konsistenten Benennung von Eigenschaften wechseln. Statt einen Namen für die Eigenschaften der Objekte in Ihrem Array zu verwenden (name) und einen anderen Namen für die Eigenschaften des Objekts, das Sie abzugleichen versuchen (visitorName), verwenden Sie für beide denselben Namen (name).

Jetzt können wir eine Funktion schreiben, die zwei beliebige Objekte vergleicht, um sicherzustellen, dass alle ihre Eigenschaften identisch sind. Dies ist ein altes Problem. Sie müssen entscheiden, ob Sie die beiden Objekte verschachtelt miteinander vergleichen möchten, wenn sie Unterobjekte enthalten. Here is a thread on this topic. Wenn Sie wollen einfach nur eine „flache“ Vergleich zu tun, dann können Sie so etwas wie tun:

function compareObjects(obj1, obj2) { 
    const obj1Keys = Object.keys(obj1); 
    const obj2Keys = Object.keyw(obj2); 

    return obj1Keys.length === obj2Keys.length && 
    obj1Keys.every(key => obj1[key] === obj2[key]); 
} 

Jetzt kann ich diese nutzen, um das passende Objekt im Array zu finden, indem er sagte

arr.find(obj => compareObjects(obj, newObj)) 

Dieser Wille Überprüfen Sie, dass alle die Eigenschaften identisch sind. Wenn Sie stattdessen überprüfen möchten, ob eine Teilmenge der Eigenschaften die Änderung ist, müssen Sie dies auf irgendeine Weise optimieren, indem Sie die Liste der Eigenschaften übergeben, die Sie überprüfen möchten.

Beachten Sie, dass nichts davon mit TypeScript oder Angular zu tun hat. Es ist pures JavaScript.Allerdings mit Typoskript, könnten Sie die compareObjects Funktion in einer Art und Weise schreiben, die mehr typsicher ist, indem darauf bestanden, dass die beiden Eingänge beide Objekte sein, und vom gleichen Typ:

function compareObjects<T extends object>(obj1: T, obj2: T) { 
    const obj1Keys = Object.keys(obj1); 
    const obj2Keys = Object.keyw(obj2); 

    return obj1Keys.length === obj2Keys.length && 
    obj1Keys.every(key => obj1[key] === obj2[key]); 
} 

Nun wird der Compiler, wenn Sie sich beschweren Versuchen Sie, zwei inkompatible Objekte miteinander zu vergleichen.