Forums : Xul, Xbl, JS...

ce sont des objets javascript

dans la page un simple eval(toto) donne accès aux différents éléments sans avoir à les parser explicitement.

ceci dit j'aimerais bien trouver de la doc aussi sur ce sujet.

si ce sont bien des objet, il me semble pas instanciable, non ??

Dés que tu défini un objet, quelque soit la méthode que tu utilises pour cela, tu défini automatiquement une instance. en javascript, il n'y a pas de concept de classe/instance.

L'interet de la syntaxe raccourci que tu evoques : comme son nom l'indique, c'est pour faire court

On peut voir ça aussi comme un tableau associatif ou tableau hashé (trés pratique d'ailleurs, comme en PHP).

Voir la rubrique conçernant les objets javascript sur devmo

autre info

le nom de ce type d'objet en javascript est objet initializer ou objet literal.

http://www.cybwarrior.com/articles/read.php?id=36

bon, je suis bien d'accord, qd je fais

function MonObject(val) { // je cree la class MonObject
 this.property = val || "defaultValue" ; // une proprieté de MonObject
 this.methode = function() { // une methode d'une instance de MonObject
 alert(this.property); // preuve en est, on affiche la proprieté initialisé lors de l'instanciation de l'Objet.
 }
}
MonObject.prototype.methode2 = function() { // une autre methode d'une instance de MonObject.
  this.methode();
}
MonObject.staticMethode(obj, obj2) { // methode statique de MonObject, le mot thisn'a pas de signification.
  if(obj.property.length<obj2.property.length) obj.methode();
}

et donc :

var monObjet = new MonObject("value");

mais j'aurais pu tout a fait faire :

monobjet2 = {
 property : "value",
 methode : function() {alert(this.property);},
 methode2 : function() {this.methode()};
};

On est d'accord ???

Bon soit, mais pourkoi le deuxieme cas ne marche pas chez moi ?

sans erreur, sans warning, rien, meme avec try catch, rien.

une deuxieme question, surement mon coté JAVA qui ressort : pourkoi faire créer une instance sans constructeur... ca fait un peut penser au structure C non ?

voila je look les liens, et en tous cas merci de me repondre.

Tu testes dans une page XUL ou HTML ?

Je pose la question car un bug (300079) est ouvert à ce sujet... la syntaxe suivante ne fonctionne que dans un js intégré à une page HTML :

Function.prototype.foo = "bar";
function f(){}
alert(f.foo);

MonObject.staticMethode(obj, obj2) { // methode statique de MonObject, le mot thisn'a pas de signification.

euh, je croyais que le concept de méthode statique n'existait pas en Javascript. Tu es sûr de cette affirmation ?

La différence entre passer par le prototype ou pas est la suivante :

• tout ce qui est défini via le prototype est commun à tout les objets utilisant ce prototype et est partagé par tout ces objets
• tout ce qui défini hors prototype est propre à l'objet.

Ainsi par exemple

  function obj(){
     this.foo =3;
  }
  obj.prototype = {
     bar : 4;
   }

si tu fais :

  var obj2 = new obj();
  obj2.foo = 10;
  obj2.bar = 20;

alors obj.foo vaudra toujours 3, mais obj.bar vaudra 20 et non 4, parce que la propriété bar fait partie du prototype.

Sinon j'ai pas compris quel était ton problème exactement. Tu as un exemple plus précis ?

laurentj a écrit:

MonObject.staticMethode(obj, obj2) { // methode statique de MonObject, le mot thisn'a pas de signification.

euh, je croyais que le concept de méthode statique n'existait pas en Javascript. Tu es sûr de cette affirmation ?

Ben, tu me mets le doute, ceci dit, j'ai oublié le "=function" apres le staticMethode.

Pour moi,

function MonObject() {
  this.methode1 = function() {return 1}
}

equivaut à

function MonObject() {}
MonObject.prototype.methode1=function() {return 1}

maintenant, pour moi en tous cas

MonObject.methode2=function() {return 2;}

est completement different.

var obj1 = new MonObject();
var obj2 = new MonObject();

obj1.methode1(); // retourne 1
obj2.methode1(); // retourne 1

obj2.methode = fucntion() {return 3;}

obj1.methode1(); // retourne 1
obj2.methode1(); // retourne 3

obj1.methode2(); // retourne ?

MonObject.methode2() // retourne 2

Voila comment je vois les choses.

Pour en revenir a object initializer, la structure cité au debut du post, j'ai reussi à la faire marché, je mettais un ";" en trop sur le dernier element de la structure. Les elements entre eux etant séparé par des ",".

En fait tjs à ce que j'ai compris, ca crée une instance d'un object sans avoir de constructeur. En Java, je pense que pour faire cette structure je ferais une Class qui n'aurait que des methodes statics.

Enfin, je trouve, meme si ici on pourra utilisé le mot clé this dans la structure.

Je vais m'en servir pour ajouté des fonctionnalité a des element XUL sans faire de XBL. Exemple :

Je veux mettre un progressmeter en mode indeterminé en bas de ma page xul. J'ai plein de requetes xmlHttpRequest qui ce lance en asynchrone. il m'interesse de faire scroller le progressmeter tant que toute les reponse n'on pas été recu.

Donc

const progressmeter = {
 task : 0,
 init : function() {
   this._obj = document.getElementById("id-progressmeter");
 },
 addTask : function() {
   this._task++;
   this._obj.setAttribute("mode", "undetermined");
 },
 removeTask : function() {
   if(!--this._task) this._obj.setAttribute("mode", "determined");
 }
};

Et voila au debut de chaque requete je fais un

progressmeter.addTask();

et à la reception de la reponse server :

progressmeter.removeTask();

Qu'en pensez vous ?

J'ai vérifié un certain nombre de chose.

Définir une méthode comme ceci :

 MonObjet.uneMethode = function (){..}

Elle ne devient pas une méthode statique. Le concept de méthode statique n'existe pas en javascript. Et on peut utilise le mot clé this à l'interieur.

Ensuite ceci :

function MonObject() {
   this.methode1 = function() { alert("a")}
}

N'équivaut pas du tout contrairement à ce que tu dis, à ça

function MonObject() {}
MonObject.prototype.methode1=function() {alert("a")}

Dans le premier cas, tu défini une propriété qui sera propre à l'objet, tandis que dans le deuxième cas, elle sera commune à toutes les autres.

C'est à dire que si tu fais

 var foo = new MonObjet();
 var bar = new MonObjet();

 foo.method1 = function () { alert("b"); }

bar.method1() et foo.method1() sont différent.

Par contre si tu changes la propriété method2 dans le prototype :

  MonObjet.prototype.methode2 = function (){alert("c");}

foo.methode2() et bar.methode2() sont en fait la méthode du prototype.

Sinon dans ton exemple, obj1.methode2() retourne rien car effectivement, methode2 est une propriété ajouté à MonObject, et non au prototype de MonObject, pour la même raison que je viens d'écrire.

Du coup

  function MonObject(){
      this.foo = 3;
  }
  
  MonObject.foo = 3;

  MonObject.prototype.foo = 3;

Sont trois déclarations différentes et ne sont pas équivalentes.

sinon pour ton progressmeter, y a pas de raisons que ça ne fonctionne pas et c'est pas du tout incorrecte comme façon de faire (à part l'erreur sur le nom de la propriété task (avec ou sans le _ ? ;-) )

Bon, ca marche bien pour mon progressmeter, et je suis d'accord, j'ai mis un _ devant la proprieté task.

par contre, tu me dis que :

function MonObject() {
 this.foo = 3;
}

est different de :

function MonObject() {}
MonObject.prototype.foo = 3;

? la j'ai un doute, j'ai fais moult fois le premier cas, et tous les objets instancié par :

var obj = new MonObject();

ont la propriete foo.

Mais maintenant que tu me le dit, j'ai eu des probleme avec certain propriete non primaire, je me rapelle pas bien, mais effectivement, tu pourrais bien avoir raison.

Je serais curieux de voir pour tous les cas, la structure des objets ainsi créé en memoire.

Voila pour moi mes constatations, je referais d'autres essai demain au boulot pour confirmé ou infirmé tes dire ... :

function MonObject() {
 this.a = 1;
 this.methode1 = function(){
  dump(this.a);
  dump(this.b);
 }
}
MonObject.prototype.b = 2;
MonObject.prototype.methode2 = function(){
 dump(this.a);
 dump(this.b);
}
MonObject.staticMethode = function() {
 dump(3);
}

var obj = new MonObject();
obj.staticMethode(); // retourne undefined de memoire ...
MonObject.staticMethode(); // dump 3 donc methode de class ou static
obj.methode1(); // dump 12 donc accés à 'this' donc methode d'instance
obj.methode2(); // dump 12 aussi donc accés à 'this' donc methode d'instance donc les deux methodes (dans le constructeur ou avec le prototype) sont equivalentes.

Le débat et ouvert....

En tous cas je suis content que ca interesse du monde. Et merci pour les infos.

mais effectivement, tu pourrais bien avoir raison.

c'est pas moi qui le dit : c'est la spec Ecmascript ! ;-)

MonObject.staticMethode();

en javascript, il n'y a pas de méthodes statiques

screugneugneu ! oublie le java, javascript est un langage basé prototype, et non un langage objet

Bon, voici les tests unitaires que j'ai effectué pour confirmer ce qui est écrit dans la doc : http://ljouanneau.com/softs/javascript/t(..)

Regarde le source pour les commentaires.

je suis bien sur d'accord sur les resultats, mais pas sur l'interpretation,

// soit MonObject avec deux méthodes

function MonObject() {
   this.var = 0;
   this.methode1 = function() {alert(this.var+1)}
}
MonObject.prototype.methode2 = function(o) {alert(this.var+2)} 

typeof MonObject.methode1 => undefined; 
typeof MonObject.methode2 => undefined;

// bien sur tu n'a pas instancié d'objet

MonObject();
typeof MonObject.methode1 => undefined; 
typeof MonObject.methode2 => undefined;

// bien sur tu n'a tjs pas instancié d'objet

MonObject.methode3 = function() {alert(this.var)}
MonObject.methode3();

typeof MonObject.methode3 => function;

// tu rajoute une methode au constructeur d'un object, // accessible via la 'Class donc comportement d'une methode static

MonObject.methode3() => alert("undefined");

// this.var est indefinie pour la class puisque propriete d'instance

var foo = new MonObject(); // ici tu instancie et non tu copie !!!!

// enfin tu instancie l'objet

typeof foo.methode1 => function
typeof foo.methode2 => function

// ben oui encore heureux, les methode d'instance, sont accessible pour les instances de l'objet

foo.methode1() => alert(1);
foo.methode2() => alert(2);

// ici pour les instance le mot cle 'this' prend tout son sens

typeof foo.methode3 => undefined

// methode static indefine pour une instance, normal

MonObject.prototype.methode4 = function() {alert(this.var+4)}

typeof MonObject.methode4 => undefined
typeof foo.methode4 => function

// resultat: les deux méthodes sont appelées

// la je suis pas d'accord avec tes commentaires, la methode existe pour l'instance, mais pas pour la Class, normale, methode non static.

foo.methode5 = function() {alert(this.var+5)}

typeof foo.methode5 => function
typeof MonObject.methode5 => undefined

// koi de plus normal, tu rajoute une methode a l'instance foo, c'est comme si foo etait un nouvel objet qui herité de MonObject // MonObject ne connait pas methode5, c'est une methode propre à foo

log("---- changement de method1 et method2 MonObject");

MonObject.methode1 = function() {alert("methode static")};

// pas d'accord, tu ne change pas method1, tu crées une autre methode 1, qui celle ci est static.

MonOnject.methode1() => alert("methode static");
foo.methode1(); => alert(1);

// tu as donc maintenant 2 methode du nom de methode1, une static et une d'instance.

MonObject.prototype.methode2 = function() {alert("blah"+this.var);}

typeof MonOnject.methode2 => undefined
typeof foo.methode2 => function

foo.methode2(); => alert("blah1");

// tu modifie la class pere de foo, il herite de la nouvelle methode

foo.methode10 = function(){alert(this.titi)}
foo.titi = 50;

foo.methode10(); => alert(50);

// normal foo.titi => propriete de l'instance, tu y accede via une methode de l'instance.

La ou je suis d'accord avec toi c'est sur le fait que javascript à un héritage par prototype et non sur les classes, alors effectivement, je suis pas trop au fait des consequences de cette difference, mais tu concederas, que les comportement detaillé ci dessus, s'apparente à un fonctionnement de methode static et methode d'instance en fonction des cas.

J'attends ton feedback... A+