Salut
javascript n'est pas à proprement parler un langage full object 
Il est possible de définir des classes et des objets.
Mais il n'existe pas de syntaxe propre à cela.
javascript utilise des fonctions en guise de définition de classe.
L’héritage n'est du coup pas aisé du tout.
Voici comment y parvenir tout de même.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
| <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<meta http-equiv="content-type" content="text/html; charset=windows-1250">
<title></title>
<script language="javascript">
function ClassA () {
this.nom = "mon nom";
this.alert = function () {
alert('Je suis un A');
}
}
function ClassB() {
/* héritage */
this.superclass = ClassA; // classe parente
this.prototype = new this.superclass; // héritage des méthodes
this.superclass(); //appel du super constructeur
delete this.superclass; // inutile de garder la classe parente
this.name = function() {
alert(this.nom);
}
this.alert = function () {
alert('Je suis un B');
this.prototype.alert(); //appel d'une méthode parente
}
}
a = new ClassA;
a.alert();
b = new ClassB;
b.alert();
b.name();
</script>
</head>
<body>
</body>
</html> |
défini une fonction mais en javascript cela est aussi un constructeur d'objet.
ou permet d'obtenir une instance d'un object construit avec le constructeur ClassA.
Cet objet n'a pas à proprement parler de classe. Mais il a un constructeur on peu conceptuellement considérer ce dernier comme une classe. D’où le nom employé dans l'exemple.
Comme dans tout langage à objet on peut définir des membres et des méthodes.
un membre
1
2
3
4
| this.alert = function () {
alert('Je suis un A');
}
} |
une methode.
Comme dans beaucoup de langage à objet c'est le point qui sert à référencer un membre ou une méthode.
1
2
3
| a = new ClassA;
a.alert();
a.nom; |
Reste le problème de l'héritage. il faudrait pouvoir dire qu'une classe fille est dérivée d'une classe parente. Mais les classes n'existant pas réellement en javascript il fait faire avec les constructeurs.
C’est le but du code suivant dans le consturcteur ClassB
1
2
3
4
5
6
7
| function ClassB() {
/* héritage */
this.superclass = ClassA; // classe parente
this.prototype = new this.superclass; // héritage des méthodes
this.superclass(); //appel du super constructeur
delete this.superclass; // inutile de garder la classe parente |
La solution proposée ici consiste à changer le prototype de la fonction. Par défaut celui-ci est Object l'objets dont tout dérive dans javascript.
En faisant cela les instances de ClassB pouront utiliser les méthodes de leurs parents.
this.prototype = new ClassA
Mais les membres ne sont pas dans le Constructeur de ClassB il faut donc faire appel au constructeur parent.
On ne peut écrire
1
2
3
4
5
| function ClassB() {
ClassA();
unA = new ClassA();
this.unA=new ClassA();
this=new ClassA(); |
Car on ne veut pas appeler la fonction ClassA
On ne veut pas de variable temporaire locale a
On ne veut pas de membre this.a construit avec ClassA
Et on ne veut pas devenir un simple objet ClassA
Il faut donc appeler le superconstructeur qui est en fait Mais javascript interdit cet appel. C’est pour cette raison que l'on créé un membre this.superclass que l'on détruit ensuite;
1
2
3
| this.superclass = ClassA; // classe parente
this.superclass(); //appel du super constructeur
delete this.superclass; // inutile de garder la classe parente |
À partir de là nous avons un héritage proche de ce qui nous trouvons dans de nombreux langages.
La surcharge fonctionne, le polymorphisme aussi.
Manque un tout petit bout l'appel à une méthode parente.
dans de nombreux langages.
Pour parvenir à cela en javascript il faut utiliser la syntaxe:
this.prototype.alert(); //appel d'une méthode parente
Concrètement vous pouvez continuer à créer vos classes en javascript de la façon la plus "naturelle" et pour celle ou vous voulez bénéficier d'un héritage il suffit de coller
1
2
3
4
5
| /* héritage */
this.superclass = ClassA; // classe parente
this.prototype = new this.superclass; // héritage des méthodes
this.superclass(); //appel du super constructeur
delete this.superclass; // inutile de garder la classe parente |
et de changer le nom de la classe (ClassA)
Nous n'avons pas un langage full object mais il y a un mieux.
A+
Un pseudo héritage en javascript
Répondre avec citation
Mettre this.constructor.prototype dans le constructeur C devrait normalement faire la même chose que de mettre constC.prototype à l'exterpeur des constructeurs mais j'ignore encore une fois pourquoi les changements ne persistent pas.
Envoyé par Celelibi
Partager