[Partie A Brève introduction à SOLID Typescript

I - Principe de ségrégation d'interface (ISP)

Les clients ne doivent pas être obligés d'implémenter des interfaces qu'ils n'utilisent pas.

Cela signifie que les interfaces doivent être petites et spécifiques aux besoins de la classe d'implémentation.
Par exemple :

❌Mauvais

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

✅Bien

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

    work(): void {
    }
}

Basé sur la force de l'interface, une classe peut implémenter plusieurs interfaces. Vous devez diviser l'interface en parties plus petites pour mieux répondre aux besoins de votre classe

---

D - Principe d'inversion de dépendance (DIP)

*Les modules de haut niveau ne doivent pas dépendre des modules de bas niveau. Les deux devraient dépendre d’abstractions.
*
Ce principe encourage l'utilisation de l'injection de dépendances
Par exemple :

❌Mauvais

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

Dans l'extrait de code, il y a plusieurs problèmes. Cependant, le problème le plus important que vous pouvez voir est :

• Si vous souhaitez ajouter MobileDeveloper(), vous devrez modifier Project() ce qui aura un impact sur les autres méthodes qui l'utilisent
• Project() est étroitement lié à backendDeveloper et frontendDeveloper

✅Bien

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

Le module de haut niveau dépend des abstractions (interface développeur).
Les modules de bas niveau implémentent l'abstraction.
L'accouplement lâche facilite l'extension et l'entretien.

Ajout de MobileDev :

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();

Merci :)))

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!