Les Constructeurs en JavaScript

Dans ce cas, Personne est un constructeur qui définit deux propriétés, nom et age.

Déclarer une instance de Personne

Pour créer une instance de Personne, vous utiliseriez le mot-clé new suivi du constructeur, et vous passez les arguments nécessaires :

const humain1 = new Personne('Trevor', 19);

Personne.prototype.saluer = function() {
    console.log(`Bonjour, je m'appelle ${this.nom} et j'ai ${this.age} ans.`);
};

1. Même après avoir changé l’âge de personne2, l’âge de personne1reste inchangé.

Pourquoi les Instances sont Importantes ?

Les instances permettent de créer plusieurs objets similaires mais distincts, chacun ayant ses propres données.

Cela est crucial dans les applications réelles où vous avez besoin de gérer et manipuler des données individuelles, comme des utilisateurs, des produits, ou des événements, tout en réutilisant la même logique de base pour leur création et leur gestion.

Une instance est donc une représentation concrète d’une classe ou d’un constructeur. Elle permet d’appliquer un modèle générique à des objets spécifiques, offrant flexibilité et efficacité dans la gestion de vos données en programmation.

Un point important à prendre en compte

Lors de l’ajout de méthodes à un constructeur en JavaScript, il est essentiel de comprendre la distinction entre les propriétés ajoutées directement à une instance d’objet et celles ajoutées via le prototype.

Cela a un impact direct sur l’efficacité et le comportement de votre code.

Pourquoi utiliser .prototype pour ajouter une méthode ?

Lorsque vous ajoutez une méthode via .prototype, vous ne stockez cette méthode qu’une seule fois dans la mémoire. Toutes les instances du constructeur partagent cette méthode.

Cela signifie que chaque objet créé avec ce constructeur a accès à la méthode via son prototype, mais n’a pas sa propre copie de la méthode. Voici un exemple pour illustrer ce point :

 
function Personne(nom, age) {
    this.nom = nom;
    this.age = age;
}

Personne.prototype.saluer = function() {
    console.log(`Bonjour, je m'appelle ${this.nom} et j'ai ${this.age} ans.`);
};

const alice = new Personne('Alice', 30);
const bob = new Personne('Bob', 25);

console.log(alice.saluer === bob.saluer); // Affiche: true

Dans cet exemple, alice et bob partagent la même méthode saluer, car elle est définie sur Personne.prototype. Cela économise de la mémoire, surtout si vous créez de nombreuses instances de Personne.

Que se passerait-il si on ajoutait directement la méthode dans le constructeur ?

Si vous ajoutez une méthode directement à l’intérieur du constructeur, chaque instance aura sa propre copie de la méthode.

Cela peut être inefficace en termes de mémoire, surtout si la méthode est volumineuse ou si vous avez beaucoup d’instances. Voici un exemple pour illustrer cela :

 
function Personne(nom, age) {
    this.nom = nom;
    this.age = age;
    this.saluer = function() {
        console.log(`Bonjour, je m'appelle ${this.nom} et j'ai ${this.age} ans.`);
    };
}

const alice = new Personne('Alice', 30);
const bob = new Personne('Bob', 25);

console.log(alice.saluer === bob.saluer); // Affiche: false

Dans ce cas Pourquoi passer par prototype ?

Voici pourquoi cette méthode ne fait pas ce que vous pourriez attendre d’elle ?

Comprendre ce que fait Personne.saluer

Lorsque vous écrivez Personne.saluer = function() { ... }, vous ajoutez la méthode saluer directement à l’objet Personne, qui est en fait une fonction (le constructeur lui-même).

Cette méthode n’est pas partagée par les instances créées par ce constructeur. Au lieu de cela, vous ajoutez une méthode statique au constructeur Personne.

Cela signifie que la méthode saluer est associée à la fonction Personne et non aux instances créées par Personne.

Par conséquent, la méthode saluer n’est pas accessible à travers les objets créés par ce constructeur.

Exemple pour illustrer cette méthode :

Quelles sont les Avantages, Limites et Bonnes Pratiques avec les constructeurs ?

Les constructeurs en JavaScript sont une composante de la programmation orientée objet (POO) dans ce langage.

Ils permettent de créer et d’initialiser des objets avec un ensemble prédéfini de propriétés et de méthodes.

 Cependant, comme toutes méthodes, ils viennent avec leurs avantages et leurs limites. Voici une analyse détaillée.

Avantages des Constructeurs

1. Encapsulation de la Logique de Création

Les constructeurs encapsulent la logique de création d’objets, ce qui rend le code plus facile a maintenir.

 Vous définissez une fois la structure d’un objet, et chaque instance créée avec ce constructeur suit la même structure.

2. Code Réutilisable

Les constructeurs permettent de réutiliser la même logique pour créer plusieurs objets avec des données différentes. Vous pouvez créer des instances d’un même objet sans dupliquer le code.

 
const personne1 = new Personne('Vita', 30);
const personne2 = new Personne('Kathy', 25);

 
Personne.prototype.saluer = function() {
    console.log(`Bonjour, je m'appelle ${this.nom} et j'ai ${this.age} ans.`);
};

 
personne1.nom = 'Sofia'; // Cela modifie directement la propriété

 
function Employe(nom, age, role) {
    Personne.call(this, nom, age);
    this.role = role;
}
Employe.prototype = Object.create(Personne.prototype);
Employe.prototype.constructor = Employe;

3. Performance et Mémoire

Si vous définissez des méthodes directement dans le constructeur au lieu d’utiliser le prototype, chaque instance aura sa propre copie de la méthode, ce qui peut gaspiller de la mémoire.

 
function Personne(nom, age) {
    this.nom = nom;
    this.age = age;
    this.saluer = function() {
        console.log(`Bonjour, je m'appelle ${this.nom} et j'ai ${this.age} ans.`);
    };
}

 
const personne1 = Personne('Vita', 30); // Oublier 'new' crée un problème.
console.log(personne1); // Affiche: undefined

 
const personne1 = new Personne('Marc', 31);
Object.freeze(personne1);
personne1.age = 35; // Cette ligne n'aura aucun effet

 
class Personne {
    constructor(nom, age) {
        this.nom = nom;
        this.age = age;
    }

    saluer() {
        console.log(`Bonjour, je m'appelle ${this.nom} et j'ai ${this.age} ans.`);
    }
}

Les constructeurs en JavaScript sont puissants et permettent de créer plusieurs mêmes structure d’objets de manière simple et réutilisable.

Cependant, ils nécessitent une compréhension approfondie pour éviter les pièges potentiels tels que l’oubli de new ou la mauvaise gestion de la mémoire.

En utilisant les bonnes pratiques et en combinant les constructeurs avec les classes introduites en ES6, tu peux écrire un code plus propre, plus maintenable et plus performant que ce soit au niveau de la charge mémoire et dans le script de ton programme pour ne pas dupliquer du code inutile.

Le Guide Bonus Exclusif

En allant plus loin, avec ce Guide Bonus Exclusif rien que pour Toi !

Voici un guide complet sur le JavaScript, où tu verras des techniques pour performer en programmation Js.

Ce guide te permettra de perfectionner tes compétences et de devenir un expert JavaScript. Ne le rate pas et développe ton expertise !

En adoptant ce qu’il contient, tu rends ton apprentissage de JavaScript plus performant avec une plus grande facilité tous les jours . Voici de quoi enrichir tout de suite ton savoir-faire ? Le guide complet t’attend !