Héritage des Prototypes en JavaScript

Explication du Schéma et de l’héritage

1. Object.prototype :

   • C’est le prototype ultime de tous les objets en JavaScript. Si une propriété ou une méthode n’est pas trouvée sur un objet, la recherche se poursuit dans Object.prototype. Il contient des méthodes fondamentales comme toString() et hasOwnProperty().

2. Prototypes Spécifiques :

   • animalPrototype : Un prototype spécifique pour les animaux, héritant de Object.prototype. Il peut avoir des méthodes et des propriétés communes à tous les animaux, comme respirer().
   • vehiculePrototype : Un prototype spécifique pour les véhicules, également héritant de Object.prototype. Il peut avoir des méthodes et des propriétés communes à tous les véhicules, comme rouler().

3. Objets Spécifiques :

   • chats et chiens héritent de animalPrototype. Ils ont leurs propres méthodes spécifiques (miauler() pour les chats et aboyer() pour les chiens) tout en héritant des propriétés et méthodes de animalPrototype et, par extension, de Object.prototype.
   • voiture et velo héritent de vehiculePrototype. Ils ont leurs propres méthodes spécifiques (demarrer() pour la voiture et pedaler() pour le vélo) tout en héritant des propriétés et méthodes de vehiculePrototype et, par extension, de Object.prototype.

Exemple de Code Correspondant au schéma ci dessus

Pour illustrer cette chaîne de prototypes avec du code JavaScript, voici un exemple :

 
// Prototype de base pour les animaux
const animalPrototype = {
    respirer() {
        console.log("Respire");
    }
};

// Création des objets héritant de animalPrototype
const chats = Object.create(animalPrototype);
chats.miauler = function() {
    console.log("Miaule");
};

const chiens = Object.create(animalPrototype);
chiens.aboyer = function() {
    console.log("Aboie");
};

// Prototype de base pour les véhicules
const vehiculePrototype = {
    rouler() {
        console.log("Roule");
    }
};

// Création des objets héritant de vehiculePrototype
const voiture = Object.create(vehiculePrototype);
voiture.demarrer = function() {
    console.log("Démarre");
};

const velo = Object.create(vehiculePrototype);
velo.pedaler = function() {
    console.log("Pédale");
};

// Utilisation des objets
chats.respirer();  // "Respire"
chats.miauler();   // "Miaule"

chiens.respirer(); // "Respire"
chiens.aboyer();   // "Aboie"

voiture.rouler();  // "Roule"
voiture.demarrer(); // "Démarre"

velo.rouler();     // "Roule"
velo.pedaler();   // "Pédale"

Description du Code

• animalPrototype contient la méthode respirer.
• vehiculePrototype contient la méthode rouler.
• chats et chiens héritent de animalPrototype, ayant accès à respirer et ajoutant leurs propres méthodes (miauler et aboyer).
• voiture et velo héritent de vehiculePrototype, ayant accès à rouler et ajoutant leurs propres méthodes (demarrer et pedaler).

En utilisant la chaîne de prototypes, vous pouvez facilement structurer vos objets en JavaScript, permettant à des objets plus spécifiques d’hériter et de réutiliser des comportements définis sur des prototypes plus généraux.

Voici une autre représentation visuelle de l’héritage d’une chaîne de prototypes en JavaScript, illustrant la relation entre un objet, son parent, son grand-parent, et finalement la base Object.prototype.

 
        [Object.prototype]  <-- Grand-parent
                |
        [animalPrototype]  <-- Parent
                |
        [chien]           <-- Enfant
                |
        [rex]             <-- Objet spécifique

 
// Prototype de base pour tous les animaux
const animalPrototype = {
    respirer() {
        console.log("Respire");
    }
};

// Prototype pour les chiens, héritant de animalPrototype
const chien = Object.create(animalPrototype);
chien.aboyer = function() {
    console.log("Aboie");
};

// Instance spécifique de chien
const rex = Object.create(chien);
rex.nom = "Rex";

// Utilisation des méthodes héritées
rex.respirer(); // "Respire" - Hérité de animalPrototype
rex.aboyer();   // "Aboie"   - Hérité de chien
console.log(rex.hasOwnProperty('nom')); // true - Méthode héritée de Object.prototype

Analyse du Code

• animalPrototype : Contient une méthode respirer, et hérite de Object.prototype.
• chien : Hérite de animalPrototype et a une méthode spécifique aboyer.
• rex : Hérite de chien et a une propriété spécifique nom. Il a accès à toutes les méthodes de ses prototypes parents et grands-parents.

Ces schémas montrent comment les objets en JavaScript héritent les uns des autres via la chaîne de prototypes.

Dans le dernier exemple chaque objet spécifique comme rex peut accéder aux propriétés et méthodes de ses prototypes parents (chien), grands-parents (animalPrototype), et de la base ultime, Object.prototype. Ce mécanisme permet de structurer et réutiliser le code de manière efficace en JavaScript.