Discussion :

[Hibou57]

Hallo ragazo/ragaza,

J'ai quelques doutes quand à la possibilité de trouver une réponse claire à cette question, parce qu'évidement les navigateurs ne se comportent certainement pas tous de la même manière. Mais peut-être certaines personnes auront-elles aux moins des informations valables pour InternetExplorer.

La question :
Un « constructeur » peut attacher une « méthode » à un « objet » de deux manières (je met tout entre guillemet... parce que franchement qui oserait dire que JavaScript est un labgage orienté objet ?).

Sans ordre de préférences, les deux manières de faire sont les suivantes.

Code JavaScript :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
function Class ()
{
   this.method = method;
   function method ()
   {
      // The method code comes here
   }
}

Code JavaScript :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
function Class ()
{
   this.method = Class_method;
}
 
function Class_method ()
{
   // The method code comes here
}

J'ai personnellement une préférence pour la première manière de faire (inutile d'en donner les raisons ici). Mais je me demande si elle présente oui ou non des risque de consomation de mémoire inutile. En clair : est-ce que le code de la méthode sera dupliqué autant de fois que d'objets seront créés ? Bien sûr, la méthode restera toujours attacher par référence : mais le navigateur va t-il à chaque fois donner une référence à une copie du code ou donnera t-il une référence à une seule instance du code ?

Pensez au cas où de nombreux « objets » sont créés ....

Cette question venant bien sûr dans le soucis d'économie de la mémoire ...

Award (récompense) : la reconnaissance de la communauté developpez.net à toutes personnes qui aurait des informations fiables sur ce délit de gaspillage potentiel.

P.S. Pas terrible la nouvelle manière d'afficher les section de code sur le forum : sur IE, la boite de code est deux fois plus large que le code lui-même... pas fameux C'était bien mieux comme c'était avant

[javatwister]

pas de réponse définitive, mais il semble bien que le prototypage évite la répétition d'une recherche de méthodes pour chaque objet:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
function Class (){
//  définitions
}
 
function Class_method (){
// méthode à affecter aux objets Class
}
 
Class.prototype.method=Class_method;

[Hibou57]

Gracias JavaDancer ... heuuuu.. (je fais encore l'imbécile)

pas de réponse définitive, mais il semble bien que le prototypage évite la répétition d'une recherche de méthodes pour chaque objet

Répétition d'une recherche ? Quelle recherche ? Je pensais naïvement que les navigateurs ajoutent un membre à l'objet, et qu'à ce membre est assigné une référence à la méthode, et que donc l'appel est direct. Ce n'est pas comme ça que ça se passe ?

Dis moi, tu as l'air de connaître des choses trés interessantes que j'aimerais bien savoir moi aussi.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
function Class (){
//  définitions
}
 
function Class_method (){
// méthode à affecter aux objets Class
}
 
Class.prototype.method=Class_method;

Petite parenthèse préalable : je n'utilise habituellement pas le prototypage (même si j'en connais l'existance), parce que j'utilise autant que possible des méthodes basiques, et je ne suis pas certains que le prototypage fonctionne bien partout.... tout ça pour dire que je ne connais pas cette question en profondeur, mais je peux faire quelques remarques tout-de-même.

La cible du prototypage, n'est bien sûr pas la fonction elle-même, mais est plutôt une référence à ce qui a créé l'objet. C'est-à-dire qu'apparement c'est une sorte de pseudo classe -- au moins dans le cas où il n'y a qu'un seul constructeur (j'y reviens plus loin).

Donc on a une sorte d'objet, qui fait référence à l'origine commune de tout les objet créé par ce constructeur. Cet objet contient des références aux méthodes, et les objet contiennent chacun une référence ver cet objet. Il y a donc une indirection lors de l'appel, ce qui le rend légérement plus long, mais en même temps, il y a effectivement logiquement économie de mémoire. Pas économie au niveau du stockage des méthodes, mais économie au niveau du stockage des références au méthodes, car celles-ci sont factorisé dans un seules objet. Chaque objet, au lieu d'avoir des références vers toutes les méthode, n'aura qu'un référence vers cet objet, qui finalement contiendra les références vers les méthodes. D'un certaine manière, cet objet fonctionne la TMV -- Table des Méthodes Virtuelles -- des langages à objet.

C'est donc un premier pas vers l'économie.

Mais une question ma chatouille : bien que JavaScript ne connaisse pas le typage, le typage y existe tout de même conceptuellement dans l'esprit du/de-la developpeur(se), et on peut donc tout de même y parler de typage. Et il se trouve qu'un type peut avoir plusieurs constructeur. Donc il faut prototyper tout les constructeur. Si lors d'une réutilisation de code, un nouveau constructeur est créé, alors il faudra donc le prototyper lui-aussi. Mais il se peut que des prototypages soient oubliés ou même que certains ne soient pas connus. C'est donc une source d'erreur. Le risque d'erreur provient de la délocalisation du prototypage, qui peut se produire n'importe où dans le code, et donc être partitiellement invisible à qui réutilise un code.

J'y vois bien une solution -- que je ne donne pas tout de suite -- mais elle nécéssiterait que la cible du prototypage puisse être une référence à un constructeur, et non pas seulement un identificateur de constructeur.

Peut-on faire par exemple

Code JavaScript :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
var C;
function Truc ()
{
   // Any code
}
C = Truc;
C.prototype.method = ....;

Est-ce autorisé ?

Bon, au moins c'est vrai que le prototypage semble garantirles risques de duplication du code.

[javatwister]

pour ne répondre qu'à ta dernière question, oui,

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

C.prototype.method = ....;

est une déclaration valable;


pour le reste, j'attends que passe ma migraine...
en tout cas (même si c'est hors-sujet), tu peux être sûr que si à la ligne suivante, tu déclares un nouvel objet Truc() et que tu demandes

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

monTruc.method();

tu bénéficieras de ladite méthode;

[gKsam]

J'utilise très peu le prototypage. Mais j'utilise beaucoup cette façon là :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
function Class ()
{
   this.method = Class_method;
}
 
function Class_method ()
{
   // The method code comes here
}

Je ne me suis pas encore très intéressé à cela. Si tu veux regarder comment je fait, je crois que la meilleur méthode c'est de récupérer ma fonctiothèques
içi

Je vais y regarder de plus près aussi car cela m'intéresse aussi. Ce n'est pas parce que c'est du côté client que l'on ne doit pas optimiser le fonctionnement.

[Hibou57]

Ce n'est pas parce que c'est du côté client que l'on ne doit pas optimiser le fonctionnement.

Je dirais même plus : c'est parce que c'est du côté client que l'on doit optimiser le fonctionnement.

@JavaTwister: moi aussi j'ai la migraine en ce moment... mais j'espère qu'elle passera dans le week-end

[gKsam]

J'ai trouvé quelque chose. Mais pour javascript.

http://developer.mozilla.org/fr/docs...Core:Fonctions
au paragraphe "Question de performance"

Je n'ai rien trouvé pour le JScript sur le site de msdn sur cette histoire de performance

Ouf! j'utilise la méthode la plus rapide. Ce n'est pas celle que tu utilises

Sur ce coups là on est encore inversé...