[Teil A: Kurze Einführung in SOLID Typescript

I – Interface-Segregations-Prinzip (ISP)

Clients sollten nicht gezwungen werden, Schnittstellen zu implementieren, die sie nicht verwenden.

Das bedeutet, dass Schnittstellen klein und spezifisch auf die Bedürfnisse der implementierenden Klasse abgestimmt sein sollten.
Zum Beispiel:

❌Schlecht

interface Work{
    eat(): void;
    work(): void;
}

class Developer implements Work{
    eat() {
        console.log("eat");
    }
    work() {
        console.log("work");
    }
}
class Robot implements Work{
    eat() {
        throw new Error("eat"); // Robot does not need to inherit eat() method
    }
    work() {
        console.log("work");
    }
}

✅Gut

interface Workable  {
    work(): void;
}
interface Eatable {
    eat(): void;
}
class Developer implements Workable, Eatable {
    eat() {}

    work(): void {
    }
}

Basierend auf der Stärke der Schnittstelle kann eine Klasse mehrere Schnittstellen implementieren. Sie sollten die Benutzeroberfläche in kleinere Teile unterteilen, um den Anforderungen Ihrer Klasse besser gerecht zu werden

---

D – Abhängigkeitsinversionsprinzip (DIP)

*High-Level-Module sollten nicht von Low-Level-Modulen abhängen. Beide sollten von Abstraktionen abhängen.
*
Dieses Prinzip fördert die Verwendung der Abhängigkeitsinjektion
Zum Beispiel:

❌Schlecht

class BackendDeveloper {
    develop(){
        console.log("Developing developer");
    }
}
class FrontendDeveloper {
    develop(){
        console.log("FrontendDeveloper");
    }
}
class Project {
    backendDeveloper: BackendDeveloper;
    frontendDeveloper: FrontendDeveloper;
    constructor() {
        this.backendDeveloper = new BackendDeveloper();
        this.frontendDeveloper = new FrontendDeveloper();
    }
    build(){
        this.backendDeveloper.develop();
        this.frontendDeveloper.develop();
    }
}

Im Codeausschnitt gibt es mehrere Probleme. Das wichtigste Problem, das Sie sehen können, ist jedoch:

• Wenn Sie MobileDeveloper() hinzufügen möchten, müssen Sie Project() ändern, was sich auf andere Methoden auswirkt, die es verwenden
• Project() ist eng mit backendDeveloper und frontendDeveloper verbunden

✅Gut

interface Developer {
    developer(): void
}
class BackendDev implements Developer {
    developer() {
        console.log("Developer Developer");
    }
}
class FrontendDeveloper implements Developer {
    developer() {
        console.log("Developer Developer");
    }
}
class Project {
    constructor(private developers: Developer[]) {
    }
    build(){
        this.developers.forEach(developer => {developer.developer();});
    }
}

High-Level-Modul hängt von Abstraktionen ab (Entwicklerschnittstelle).
Low-Level-Module implementieren die Abstraktion.
Durch die lose Kopplung lässt es sich leicht erweitern und warten.

MobileDev hinzufügen:

class MobileDeveloper implements Developer {
  develop() {
    console.log("Writing mobile code");
  }
}

// Usage
const developers: Developer[] = [
  new BackendDeveloper(),
  new FrontendDeveloper(),
  new MobileDeveloper(), //easy to add and make it does not change in Project()
];
const project = new Project(developers);
project.build();

Vielen Dank :)))

Das obige ist der detaillierte Inhalt von[Teil A: Kurze Einführung in SOLID Typescript. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!