Quizz JavaScript - reponse : Le mot clé prototype - heritage en JavaScript
Voici avec un peu de retard la réponse au quizz JavaScript : le mot clé prototype.
La bonne réponse est :
Cyril
Je suis Cyril
En effet le prototype est le même pour toutes les instances d'un objet, il n'est pas figé lorsque l'on créer une instance, c'est une des particularités des langages dynamiques.
Le prototype est une propriété de l'objet function, il est créé dès que l'on appelle le constructeur d'une fonction c'est à dire dès que l'on fait une nouvelle instance d'une fonction :
var obj = new myFunction();
// obj.prototype existe
Cette propriété est un objet qui contient tous les membres (fonctions et propriétés) accessible par les instances de la fonction.
var f = function(){}
f.prototype.hello = function(){
Sys.Debug.trace('hello');
}
var o = new f();
o.hello(); // est accessible
On peut bien sur redéfinir un membre au niveau de l'instance d'un objet :
var f = function(){}
f.prototype.hello = function(){
Sys.Debug.trace('hello');
}
var o = new f();
o.hello = function(){
Sys.Debug.trace('hello modifié pour l'objet o uniquement');
}
o.hello(); // affiche hello modifié ...
var p = new f();
p.hello(); // affiche hello
En fait quand on appelle une méthode d'une instance, l'interpréteur JavaScript va d'abord regarder s'il trouve la méthode au niveau de l'instance puis il va regarder le prototype. Mais comme le prototype est une instance d'un objet il possède lui aussi un prototype, l'interpréteur va aussi regarder dans le prototype du prototype et ainsi de suite jusqu'à ce qu'il trouve la méthode. C'est une des façons de faire de l'héritage en JavaScript.
var f = function(){}
f.prototype.hello = function(){
Sys.Debug.trace('hello');
}
var g = function(){}
g.prototype = new f();
g.prototype.coucou = function(){
Sys.Debug.trace('coucou');
}
var o = new g();
o.coucou(); // affiche coucou
o.hello(); // affiche hello
Lorsque l'interpréteur arrive sur o.hello() il va d'abord rechercher dans l'instance puis dans le prototype et enfin dans le prototype du prototype. On peut également redéfinir la méthode hello au niveau du type g et appeler la méthode hello de f, c'est à dire surcharger une méthode et appeler la méthode de base.
var f = function(){}
f.prototype.hello = function(){
Sys.Debug.trace('hello from f');
}
var g = function(){}
g.prototype = new f();
g.prototype.hello = function(){
f.prototype.hello.apply(this, []); // appel de la méthode de base
Sys.Debug.trace('hello from g');
}
var o = new g();
o.hello(); // affiche hello from g et hello from g
Bien sur, on peut encore faire pleins d'autres choses avec le prototype d'une fonction, mais le but ici est de montrer que l'on peut changer les méthodes d'un type n'importe quand, le prototype n'est pas figé à une instance d'un objet.
En savoir plus sur le mot clé prototype :