Qu'est-ce qui est prioritaire en JavaScript?
Pour comprendre le concept de substitution dans JavaScript, révisons d'abord le concept de substitution dans son ensemble.
La substitution de méthode est un concept de POO étroitement lié à l'héritage. Lorsqu'une méthode de classe enfant remplace la méthode de classe parente du même nom, paramètres et type de retour, elle est appelée substitution de méthode. Rappelons également que cela est complètement différent du concept de surcharge de méthode. Une surcharge de méthode se produit lorsqu'il existe deux fonctions portant le même nom mais des paramètres différents.
Maintenant, essayons de comprendre ce concept du point de vue de JavaScript. Nous savons que JavaScript n'est «relativement» pas orienté objet. Il a le concept d'Objets qui le qualifie pour être orienté objet, mais il n'a pas le concept de Classes. Il est de nature prototypique. Oui oui, je vous entends crier fort que nous pouvons déclarer des classes en JavaScript mais permettez-moi de vous rappeler que cette notation de classe n'est qu'un sucre syntaxique pour l'architecture prototypique sous-jacente.
Ainsi, JavaScript prend en charge le concept de substitution de méthode. Et il le fait de manière très étrange. Après tout, c'est le langage le plus mal compris dans le monde de la programmation. JavaScript prend en charge la substitution, mais pas la surcharge.
Remarque - Dans tous les exemples de cet article, nous utiliserions la console développeur des navigateurs. Ouvrez simplement les outils de développement du navigateur (Ctrl / Cmd + Maj + C) et accédez à l'onglet Console dans la fenêtre des outils de développement.
Cela ressemble à ceci dans Chrome:
C'est le terrain de jeu de la plupart des concepts liés à JavaScript. Nous utiliserions ce terrain de jeu tout au long de cet article.
Comment le remplacement fonctionne-t-il en JavaScript?
En JavaScript, tous les objets héritent du prototype Object. Tous les objets sont des instances d'Object. Ainsi, chaque fois que vous créez un nouvel objet, JavaScript définit automatiquement une propriété _proto_ (prototype) pour le nouvel objet. Lorsqu'un objet enfant est créé, il possède à nouveau une propriété _proto_ et ainsi de suite. Désormais, lorsque vous essayez d'accéder à une méthode ou à une propriété d'un objet, JavaScript vérifie d'abord si l'objet possède cette méthode / propriété. Si ce n'est pas le cas, JavaScript vérifie si la _proto_ de l'objet possède cette méthode / propriété. Sinon, JavaScript vérifie si la _proto_ de son objet parent possède cette méthode / propriété. Il continue à rechercher dans la chaîne jusqu'à ce que la méthode / propriété soit trouvée ou que la _proto_ de l'objet soit rencontrée et recherchée. Par exemple, Date.prototype. ((Prototype)) est Object.prototype.
Maintenant, voyez la chaîne à l'envers. C'est ainsi que le remplacement fonctionne en JavaScript. Une méthode continuerait de remplacer la méthode de l'objet parent même s'il s'agit d'une méthode Object. Par exemple, nous pouvons même remplacer les fonctionnalités de base telles que la création d'un objet Date.
Voyons cela avec un exemple:
new Date(); //the JavaScript Date() method
//overriding the JavaScript Date() method
function Date()(
this.date = "This method overrides the default constructor of Date class.";
);
var date2 = new Date();
console.log(date2);
Types de substitution en JavaScript
Aucun type de substitution n'est défini en JavaScript. Cependant, en fonction du comportement du langage de programmation, nous pouvons dire que la substitution de méthode en JavaScript fonctionne de la manière suivante.
1) Le premier comportement
La première façon est celle que nous avons vue ci-dessus lorsque nous avons défini une méthode pour remplacer le constructeur Date par défaut de JavaScript. Ceci est d'une manière similaire à la troisième manière illustrée ci-dessous car tous les objets en JavaScript sont une instance du prototype d'objet. Ce qui différencie le troisième comportement est l'utilisation du super mot-clé. Nous verrons plus en illustrant le troisième comportement.
Voyons un autre exemple similaire. Cette fois, nous remplacerions la fonctionnalité d'alerte. Le comportement par défaut de la fonction d'alerte en JavaScript consiste à afficher une petite boîte de dialogue en haut de la page avec le message que nous transmettons en paramètre.
Maintenant, lorsque nous le remplaçons par notre propre code, la fonction d'alerte par défaut n'est plus appelée.
function alert(msg) (
console.log(msg);
);
alert("This is an alert.");
2) Le deuxième comportement
La deuxième façon consiste à surcharger des fonctions en JavaScript. N'oubliez pas que JavaScript ne prend pas en charge la surcharge de fonctions. Ainsi, au lieu de surcharger votre fonction, JavaScript remplacerait toutes les définitions précédentes de votre fonction par la dernière.
Voyons cela en action.
//Calculate area of rectangle
function calculateArea(x, y)(
return x*y;
)
//Calculate area of square
function calculateArea(a)(
return a*a;
)
console.log("Area of rectangle 2x3 is : " + calculateArea(2, 3));
console.log("Area of square 5x5 is : " + calculateArea(5));
Remarquez le résultat. JavaScript appelle toujours la deuxième définition de la fonction et renvoie le carré du premier paramètre. Les paramètres suivants sont ignorés.
3) Le troisième comportement
Le troisième comportement apparaît dans l'image lorsque nous impliquons les classes et l'héritage dans JavaScript. Lorsqu'une classe enfant hérite des méthodes de la classe parent et définit ses propres méthodes avec le même nom, les méthodes de la classe parent sont remplacées. Ce n'est pas ce que nous souhaiterions dans des applications réelles. Nous voudrions que nos méthodes de classe parent soient accessibles même lorsqu'elles sont remplacées par des méthodes de classe enfant. Ainsi, le super mot-clé vient à notre secours. En utilisant le mot clé super, nous pouvons accéder aux méthodes de la classe parent.
Voyons cela en action.
//the parent class
class Person (
greet() (
console.log("Hello. I am a person.");
);
)
//the child class
class Employee extends Person (
greet() (
super.greet(); //calling parent class method via keyword 'super'
console.log("Hello. I am an employee.");
)
)
let per = new Person(); //parent class object
let emp = new Employee(); //child class object
per.greet();
emp.greet();
Revenez maintenant au premier exemple de comportement et essayez d'utiliser le super mot-clé ici. Vous remarquerez que cela ne fonctionne pas. En effet, lorsque nous avons créé notre méthode dans le premier exemple, nous n'avons pas étendu la classe parente. Nous avons créé la méthode dans la portée globale, remplaçant ainsi toutes les autres définitions de la méthode.
Conclusion
Revoyons notre compréhension de la substitution de méthode en JavaScript. Nous avons appris que JavaScript prend en charge la substitution, mais pas la surcharge. Si nous essayons de surcharger les méthodes, JavaScript remplace toutes les définitions précédentes par la dernière. Cela est vrai même pour les fonctions principales!
Ensuite, nous avons vu comment nous pouvons remplacer les méthodes dans les classes enfants et accéder ensuite aux méthodes de la classe parent selon les besoins. C'est un concept très utile car il nous permet d'étendre les fonctionnalités de nos classes parentes et améliore ainsi la réutilisabilité du code.
Articles recommandés
Ceci est un guide de remplacement en JavaScript. Nous discutons ici du fonctionnement de la substitution en JavaScript et des types de substitution en JavaScript. Vous pouvez également consulter l'article suivant pour en savoir plus -
- Que peut faire Javascript?
- Qu'est-ce que JavaScript?
- Comment installer JavaScript
- Cadres Python - qu'est-ce que le cadre Python?
- Introduction au remplacement en C ++
- Introduction au remplacement dans les POO
- Surcharge en Java
- Surcharge de méthode en C #
- Surcharge et remplacement en C #