Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
zwetan
salut,
Y a t-il une différence entre:
function MaClasse() { this.maFonction = uneFonction; }
function uneFonction () { ; }
Et:
function MaClasse() { ; }
MaClasse.prototype.maFonction = uneFonction;
function uneFonction () { ; }
oui et non
premièrement ce ne sont pas des classes mais des constructeurs
dans les deux cas tu copies la fonction "uneFonction" car une fonction ne peut etre copiée que par valeur, jamais par reference
mais il y a une différence
dans le 1er cas, ton constructeur va crée un objet qui au moment où il s initialisera definira une propriete de l'objet "maFonction" qui sera une copie de "uneFonction"
a chaque instanciation d'objet la fonction sera copiée (gros gachis mémoire)
dans le 2nd cas tu copies 1 fois "uneFonction" dans le prototype de l'objet, et a chaque instanciation d'un objet, la methode "maFonction" sera liée dynamiquement a l'objet sans etre copiée
idéalement pour avoir le meilleur rapport poid mémoire / ligne de code ecrite il serait mieux de faire cela:
MaClasse = function() { //... this.method = function() {} //copié dans chaque objet, on veut eviter cela this.prop = true; //copié dans chaque objet
var privProp = "secret"; //copié dans chaque objet, reste en mémoire mais non accesible en dehors du scope de la fonction constructrice
this.recupPrivProp = function() //acces a la propriete privée mais impossible de la modifier { return privProp; }
var privFonction = function() //copié dans chaque objet, reste en mémoire mais non accesible en dehors du scope de la fonction constructrice { //... }
this.getPrivFunction = function() //acces a la fonction privée { return privFonction(); } }
MaClasse.prototype.maFonction = function() //partagé par tous les objets { //code de uneFonction ici }
MaClass.prototype.maProp = "hello world"; //partagé par tous les objets
MaClass.propStatique = false; //associé à l'espace de nom de l'objet
si c'est dans le but de pouvoir recuperer plus facilement la liste des fonctions dans ton editeur de code
zwetan
salut,
Y a t-il une différence entre:
function MaClasse() {
this.maFonction = uneFonction;
}
function uneFonction () {
;
}
Et:
function MaClasse() {
;
}
MaClasse.prototype.maFonction = uneFonction;
function uneFonction () {
;
}
oui et non
premièrement ce ne sont pas des classes mais des constructeurs
dans les deux cas tu copies la fonction "uneFonction"
car une fonction ne peut etre copiée que par valeur, jamais par reference
mais il y a une différence
dans le 1er cas, ton constructeur va crée un objet
qui au moment où il s initialisera definira une propriete de l'objet
"maFonction"
qui sera une copie de "uneFonction"
a chaque instanciation d'objet la fonction sera copiée (gros gachis mémoire)
dans le 2nd cas tu copies 1 fois "uneFonction" dans le prototype de l'objet,
et
a chaque instanciation d'un objet, la methode "maFonction" sera liée
dynamiquement
a l'objet sans etre copiée
idéalement pour avoir le meilleur rapport poid mémoire / ligne de code
ecrite
il serait mieux de faire cela:
MaClasse = function()
{
//...
this.method = function() {} //copié dans chaque objet, on veut eviter
cela
this.prop = true; //copié dans chaque objet
var privProp = "secret"; //copié dans chaque objet, reste en mémoire
mais non accesible en dehors du scope de la fonction constructrice
this.recupPrivProp = function() //acces a la propriete privée mais
impossible de la modifier
{
return privProp;
}
var privFonction = function() //copié dans chaque objet, reste en
mémoire mais non accesible en dehors du scope de la fonction constructrice
{
//...
}
this.getPrivFunction = function() //acces a la fonction privée
{
return privFonction();
}
}
MaClasse.prototype.maFonction = function() //partagé par tous les objets
{
//code de uneFonction ici
}
MaClass.prototype.maProp = "hello world"; //partagé par tous les objets
MaClass.propStatique = false; //associé à l'espace de nom de l'objet
function MaClasse() { this.maFonction = uneFonction; }
function uneFonction () { ; }
Et:
function MaClasse() { ; }
MaClasse.prototype.maFonction = uneFonction;
function uneFonction () { ; }
oui et non
premièrement ce ne sont pas des classes mais des constructeurs
dans les deux cas tu copies la fonction "uneFonction" car une fonction ne peut etre copiée que par valeur, jamais par reference
mais il y a une différence
dans le 1er cas, ton constructeur va crée un objet qui au moment où il s initialisera definira une propriete de l'objet "maFonction" qui sera une copie de "uneFonction"
a chaque instanciation d'objet la fonction sera copiée (gros gachis mémoire)
dans le 2nd cas tu copies 1 fois "uneFonction" dans le prototype de l'objet, et a chaque instanciation d'un objet, la methode "maFonction" sera liée dynamiquement a l'objet sans etre copiée
idéalement pour avoir le meilleur rapport poid mémoire / ligne de code ecrite il serait mieux de faire cela:
MaClasse = function() { //... this.method = function() {} //copié dans chaque objet, on veut eviter cela this.prop = true; //copié dans chaque objet
var privProp = "secret"; //copié dans chaque objet, reste en mémoire mais non accesible en dehors du scope de la fonction constructrice
this.recupPrivProp = function() //acces a la propriete privée mais impossible de la modifier { return privProp; }
var privFonction = function() //copié dans chaque objet, reste en mémoire mais non accesible en dehors du scope de la fonction constructrice { //... }
this.getPrivFunction = function() //acces a la fonction privée { return privFonction(); } }
MaClasse.prototype.maFonction = function() //partagé par tous les objets { //code de uneFonction ici }
MaClass.prototype.maProp = "hello world"; //partagé par tous les objets
MaClass.propStatique = false; //associé à l'espace de nom de l'objet
si c'est dans le but de pouvoir recuperer plus facilement la liste des fonctions dans ton editeur de code
zwetan
Vincent Nabet
Bonjour,
Merci zwetan pour cette réponse précise.
Vincent
salut,
Y a t-il une différence entre:
function MaClasse() { this.maFonction = uneFonction; }
function uneFonction () { ; }
Et:
function MaClasse() { ; }
MaClasse.prototype.maFonction = uneFonction;
function uneFonction () { ; }
oui et non
premièrement ce ne sont pas des classes mais des constructeurs
dans les deux cas tu copies la fonction "uneFonction" car une fonction ne peut etre copiée que par valeur, jamais par reference
mais il y a une différence
dans le 1er cas, ton constructeur va crée un objet qui au moment où il s initialisera definira une propriete de l'objet "maFonction" qui sera une copie de "uneFonction"
a chaque instanciation d'objet la fonction sera copiée (gros gachis mémoire)
dans le 2nd cas tu copies 1 fois "uneFonction" dans le prototype de l'objet, et a chaque instanciation d'un objet, la methode "maFonction" sera liée dynamiquement a l'objet sans etre copiée
idéalement pour avoir le meilleur rapport poid mémoire / ligne de code ecrite il serait mieux de faire cela:
MaClasse = function() { //... this.method = function() {} //copié dans chaque objet, on veut eviter cela this.prop = true; //copié dans chaque objet
var privProp = "secret"; //copié dans chaque objet, reste en mémoire mais non accesible en dehors du scope de la fonction constructrice
this.recupPrivProp = function() //acces a la propriete privée mais impossible de la modifier { return privProp; }
var privFonction = function() //copié dans chaque objet, reste en mémoire mais non accesible en dehors du scope de la fonction constructrice { //... }
this.getPrivFunction = function() //acces a la fonction privée { return privFonction(); } }
MaClasse.prototype.maFonction = function() //partagé par tous les objets { //code de uneFonction ici }
MaClass.prototype.maProp = "hello world"; //partagé par tous les objets
MaClass.propStatique = false; //associé à l'espace de nom de l'objet
si c'est dans le but de pouvoir recuperer plus facilement la liste des fonctions dans ton editeur de code
zwetan
Bonjour,
Merci zwetan pour cette réponse précise.
Vincent
salut,
Y a t-il une différence entre:
function MaClasse() {
this.maFonction = uneFonction;
}
function uneFonction () {
;
}
Et:
function MaClasse() {
;
}
MaClasse.prototype.maFonction = uneFonction;
function uneFonction () {
;
}
oui et non
premièrement ce ne sont pas des classes mais des constructeurs
dans les deux cas tu copies la fonction "uneFonction"
car une fonction ne peut etre copiée que par valeur, jamais par reference
mais il y a une différence
dans le 1er cas, ton constructeur va crée un objet
qui au moment où il s initialisera definira une propriete de l'objet
"maFonction"
qui sera une copie de "uneFonction"
a chaque instanciation d'objet la fonction sera copiée (gros gachis mémoire)
dans le 2nd cas tu copies 1 fois "uneFonction" dans le prototype de l'objet,
et
a chaque instanciation d'un objet, la methode "maFonction" sera liée
dynamiquement
a l'objet sans etre copiée
idéalement pour avoir le meilleur rapport poid mémoire / ligne de code
ecrite
il serait mieux de faire cela:
MaClasse = function()
{
//...
this.method = function() {} //copié dans chaque objet, on veut eviter
cela
this.prop = true; //copié dans chaque objet
var privProp = "secret"; //copié dans chaque objet, reste en mémoire
mais non accesible en dehors du scope de la fonction constructrice
this.recupPrivProp = function() //acces a la propriete privée mais
impossible de la modifier
{
return privProp;
}
var privFonction = function() //copié dans chaque objet, reste en
mémoire mais non accesible en dehors du scope de la fonction constructrice
{
//...
}
this.getPrivFunction = function() //acces a la fonction privée
{
return privFonction();
}
}
MaClasse.prototype.maFonction = function() //partagé par tous les objets
{
//code de uneFonction ici
}
MaClass.prototype.maProp = "hello world"; //partagé par tous les objets
MaClass.propStatique = false; //associé à l'espace de nom de l'objet
function MaClasse() { this.maFonction = uneFonction; }
function uneFonction () { ; }
Et:
function MaClasse() { ; }
MaClasse.prototype.maFonction = uneFonction;
function uneFonction () { ; }
oui et non
premièrement ce ne sont pas des classes mais des constructeurs
dans les deux cas tu copies la fonction "uneFonction" car une fonction ne peut etre copiée que par valeur, jamais par reference
mais il y a une différence
dans le 1er cas, ton constructeur va crée un objet qui au moment où il s initialisera definira une propriete de l'objet "maFonction" qui sera une copie de "uneFonction"
a chaque instanciation d'objet la fonction sera copiée (gros gachis mémoire)
dans le 2nd cas tu copies 1 fois "uneFonction" dans le prototype de l'objet, et a chaque instanciation d'un objet, la methode "maFonction" sera liée dynamiquement a l'objet sans etre copiée
idéalement pour avoir le meilleur rapport poid mémoire / ligne de code ecrite il serait mieux de faire cela:
MaClasse = function() { //... this.method = function() {} //copié dans chaque objet, on veut eviter cela this.prop = true; //copié dans chaque objet
var privProp = "secret"; //copié dans chaque objet, reste en mémoire mais non accesible en dehors du scope de la fonction constructrice
this.recupPrivProp = function() //acces a la propriete privée mais impossible de la modifier { return privProp; }
var privFonction = function() //copié dans chaque objet, reste en mémoire mais non accesible en dehors du scope de la fonction constructrice { //... }
this.getPrivFunction = function() //acces a la fonction privée { return privFonction(); } }
MaClasse.prototype.maFonction = function() //partagé par tous les objets { //code de uneFonction ici }
MaClass.prototype.maProp = "hello world"; //partagé par tous les objets
MaClass.propStatique = false; //associé à l'espace de nom de l'objet