JavaScript ne prend pas en charge l’héritage multiple de la même manière que des langages comme Python ou Java. Ce choix de conception évite des complexités comme le «problème du diamant», où des ambiguïtés d’héritage surviennent. Cependant, il est possible d’obtenir des fonctionnalités similaires grâce à des techniques astucieuses comme la composition et la délégation comportementale. Cet article explore ces approches, en soulignant leurs forces et leurs faiblesses.
Table des matières
- Composition : Combinaison des fonctionnalités
- Délégation comportementale : Dispatch dynamique des méthodes
- Choisir la bonne approche
Composition : Combinaison des fonctionnalités
La composition consiste à créer une nouvelle classe qui utilise les fonctionnalités des classes existantes sans en hériter. Cela favorise une meilleure encapsulation et évite les pièges de l’héritage multiple. Nous y parvenons en créant des instances des classes souhaitées et en intégrant leurs méthodes dans notre nouvelle classe.
Illustrons cela avec un exemple concret. Supposons que nous ayons une classe Car et une classe Engine :
class Car {
constructor(model) {
this.model = model;
}
drive() {
console.log(`${this.model} is driving.`);
}
}
class Engine {
start() {
console.log("Engine started.");
}
stop() {
console.log("Engine stopped.");
}
}
Créons maintenant une classe SportsCar qui intègre à la fois Car et Engine :
class SportsCar {
constructor(model) {
this.car = new Car(model);
this.engine = new Engine();
}
drive() {
this.engine.start();
this.car.drive();
}
stop() {
this.engine.stop();
}
}
let mySportsCar = new SportsCar("Porsche 911");
mySportsCar.drive(); // Sortie : Engine started. Porsche 911 is driving.
mySportsCar.stop(); // Sortie : Engine stopped.
Dans cet exemple, SportsCar n’hérite pas de Car ou Engine, mais il combine efficacement leurs fonctionnalités. Cette approche est simple et facile à comprendre.
Délégation comportementale : Dispatch dynamique des méthodes
La délégation comportementale offre une approche plus flexible. Une nouvelle classe délègue les appels de méthode à des instances d’autres classes, permettant des changements de comportement dynamiques en fonction du contexte. Ceci est particulièrement utile lorsque la relation entre les classes n’est pas statique.
Revoyons l’exemple Car et Engine. Nous allons créer une classe DelegatingCar :
class DelegatingCar {
constructor(delegates = []) {
this.delegates = delegates;
}
addDelegate(delegate) {
this.delegates.push(delegate);
}
performAction(action, ...args) {
for (const delegate of this.delegates) {
if (typeof delegate[action] === 'function') {
return delegate[action](...args);
}
}
throw new Error(`Action '${action}' not found.`);
}
}
let myDelegatingCar = new DelegatingCar([new Car("Ferrari"), new Engine()]);
myDelegatingCar.performAction('drive'); //Sortie: Ferrari is driving.
myDelegatingCar.performAction('start'); //Sortie: Engine started.
DelegatingCar utilise une méthode performAction centrale pour acheminer les requêtes vers le délégué approprié. Cela permet un contrôle plus dynamique, mais cela ajoute de la complexité par rapport à la composition simple.
Choisir la bonne approche
La composition et la délégation comportementale offrent toutes deux de puissantes alternatives à l’héritage multiple en JavaScript. La composition est généralement plus simple et plus lisible, ce qui la rend adaptée à la plupart des scénarios. La délégation comportementale offre une plus grande flexibilité pour un comportement dynamique, mais introduit une complexité supplémentaire. Le choix optimal dépend des exigences spécifiques de votre application. La priorité à la clarté et à la maintenabilité est cruciale.