javascript et héritage

c'est pas énorme, 45 lignes (avec qq commentaires) mais si je peux en
mettre une quarantaine en commun, c'est tjs ça...

Je sais pas trop si ça peut être compatible avec des
truc = new machin();
surtout si machin() est prévu pour être générique et multi usages
mais ...

var cm=new CookieManager(true);
var cc=new CookieManager(false,'maroon',80);

function CookieManager(name-path,color,angle) {
var name = 'yvontoolkit'
if(!name-path) {
archivage couleur, angle
name = 'yvoncolor';
}
path = path-name? 'domain_machin_chouette' : '/';
code commun : name, path, durée étoussa
}

ou

function CookieManager(quoi,color,angle) {
var path = quoi? 'domain_machin_chouette' : '/';
var name = quoi? 'yvontoolkit' : 'yvoncolor';
code commun durée étoussa
if(typeof(color)!='undefined') {
jSon truc-machin couleur, angle
}
}

onunload = "CookieManager(true);
CookieManager(false,yvcolor,yvangle);"


ou

function CookieManager() {
var lequel = arguments.length==0;
var path = lequel? 'domain_machin_chouette' : '/';
var name = lequel? 'yvontoolkit' : 'yvoncolor';
code commun durée étoussa
if(!lequel) {
jSon(arguments);
}
}

onunload = "CookieManager();
CookieManager(ytcolor,ytangle);"

--
Stephane Moriaux et son (moins) vieux Mac déjà dépassé
Stephane Moriaux and his (less) old Mac already out of date

ASM <stephanemoriaux.NoAdmin@wanadoo.fr.invalid> wrote:

Je sais pas trop si ça peut être compatible avec des
truc = new machin();
surtout si machin() est prévu pour être générique et multi usages
mais ...

var cm=new CookieManager(true);
var cc=new CookieManager(false,'maroon',80);

ouais, ajouter un argument au constructeur, c'est efficace merci !
ce n'est pas de l'héritage mais je m'en fiche )))

ou, autre solution, baser mon switch sur le nombre d'arguments filé à
#write :

var cm=new CookieManager();
cm.write(maroon',80);
// => deux args une string + un nombre => on cause couleur

cm.write(json);
// => un arg en string => on cause json

le seul pb que j'entrevois avec ce genre de solution est qu'avec un :

va cm=new CookieManager();

je peux très bien, avec un même objet cm écrire un cookie type json
qu'un cookie type couleur le #write sera tjs conforme, par contre ie
#read ne le sera pas. (je réfléchis tout haut).

finalement, il y a une solution très simple, garder CookieManager tel
quel mais ajouter deux couples de write, read :

cm.writeJson(json);
cm.writeColor(couleur, angle);

cm.readJson();
cm.readColor();

bon je gagne 45 lignes - ce qu'il faut ajouter (une dizaine de lignes au
max), mais c'est plus "convivial à utiliser...



j'ai upgradé ma page :

<http://81.57.96.20/DHTML/fixed_layout.xhtml>

le ToolTip, expliquant comment les couleurs sont fabriquées y est
"opérationnel" *...

* cliquer sur le "?" en haut à droite !
--
It's easy to play any musical instrument: all you have to do is
touch the right key at the right time and the instrument will
play itself. -- J.S. Bach

Une Bévue wrote:

je suis en train de me bâtir un toolkit spécifique et je suis en train
de regarder comment avoir le code le + court possible.

Un code court n'est pas un gage de qualité. Il vaut mieux raisonner en terme
d'extensibilité (Ajouter un nouveau type de "cookie") et de réutilisabilité
(Utiliser tes cookies dans d'autres projets, constitution d'une bibliothèque
de scripts par ex.) dans ton cas.

Sinon je ne comprends pas le lien entre le sujet et le corps de ton message.
Tu n'y parles pas d'héritage et encore moins de prototypage, la version
JavaScript de l'héritage de langages comme C++ ou Java.

Donc je te conseille de prototyper tes cookies afin de définir des
propriétés (attributs) et comportements (fonctions) communs dans une classe
de base et de prototyper des cookies plus spécifiques.

Jean-Marc Molina <jmmolina@PASDEPOURRIEL-free.fr.invalid> wrote:

Tu n'y parles pas d'héritage et encore moins de prototypage, la version
JavaScript de l'héritage de langages comme C++ ou Java.

Donc je te conseille de prototyper tes cookies afin de définir des
propriétés (attributs) et comportements (fonctions) communs dans une classe
de base et de prototyper des cookies plus spécifiques.

je lis un article sur le net
(<http://www.javascriptkit.com/javatutors/oopjs2.shtml> "Object
Constructor and prototyping")

le protoypage permet d'ajouter des méthodes, mais pas des attibuts.

ce n'est pas vraiment de l'heritage car l'objet ne change pas de nom
comme on peut le faore en java (machin extends bidule) ou ruby (machin
<< bidule) ???
--
Une Bévue

Jean-Marc Molina <jmmolina@PASDEPOURRIEL-free.fr.invalid> wrote:

Donc je te conseille de prototyper tes cookies afin de définir des
propriétés (attributs) et comportements (fonctions) communs dans une classe
de base et de prototyper des cookies plus spécifiques.

--- script js ---------------------------------------------------------
function CookieClass(name,path,domain){
this.name=name;
this.path=path;
this.domain=domain;
this.date=getDate();
function getDate(){
var date=new Date;
date.setMonth(date.getMonth()+6);
return date;
}
}
CookieClass.prototype.__defineGetter__("value",function(){
var alen=this.name.length;
var clen=document.cookie.length;
var i=0;
while (i<clen) {
var j=i+alen;
if (document.cookie.substring(i, j)==this.name) return
getCookieVal(j);
i=document.cookie.indexOf(" ",i)+1;
if (i==0) break;
}
return null;
function getCookieVal(offset){

var endstr=document.cookie.indexOf (";", offset);
if (endstr==-1) endstr=document.cookie.length;
var os=unescape(document.cookie.substring(offset+1, endstr));
return eval('('+os+')');
}
});
CookieClass.prototype.__defineSetter__("value",function(o){
document.cookie=this.name+"="+
escape(o.toJSONString())+
"; expires="+this.date.toGMTString()+
"; path="+this.path+
"; domain="+this.domain;
});
function PageCookie(){
var that=new CookieClass(document.location.basename,
document.location.dirname,
document.location.hostname);
return that;
}
function FixedLayoutCookie(){
var that=new CookieClass("color_cookie",
"/",
document.location.hostname);
return that;
}
------------------------------------------------------------------------

donc je définis un "constructeur" de "classe" CookieClass auquel
j'adjoints un setter et un getter.

ensuite j'étends (plutôt je spécifie) CookieClass par PageCookie qui ne
fait rien d'autre que passer les bons arguments à CookieClass, idem pour
FixedLayoutCookie.

le seul truc qui me gène est que :
this.name=name;
this.path=path;
this.domain=domain;
this.date=getDate();

définissent des attributs *** public ***, comment faire pour avoir ces
mêmes attributs mais non publics enfin, non accessibles par
l'utilisateur ???
--
Une Bévue

Une Bévue wrote:

définissent des attributs *** public ***, comment faire pour avoir ces
mêmes attributs mais non publics enfin, non accessibles par
l'utilisateur ???

C'est impossible en JavaScript 1.X, on ne peut pas définir la portée d'un
attribut (privé, protégé, public).

Une Bévue wrote:

le protoypage permet d'ajouter des méthodes, mais pas des attibuts.

Non on peut aussi ajouter des méthodes que des attributs. Il suffit de les
assigner au prototype dans le constructeur.

ce n'est pas vraiment de l'heritage car l'objet ne change pas de nom
comme on peut le faore en java (machin extends bidule) ou ruby (machin
<< bidule) ???

Désolé j'avais compris que les cookies avaient des comportements différents.
S'il s'agit de paramétrer des cookies il suffit de définir un constructeur
avec des paramètres. S'il s'agit vraiment de créer des objets différents
alors il faut passer par le motif de conception "factory", un peu comme ce
que tu veux avec les fonctions "PageCookie" et "FixedLayoutCookie" en fait.

Jean-Marc Molina wrote:

Bonjour,

définissent des attributs *** public ***, comment faire pour avoir ces
mêmes attributs mais non publics enfin, non accessibles par
l'utilisateur ???

C'est impossible en JavaScript 1.X, on ne peut pas définir la portée d'un
attribut (privé, protégé, public).

Il est parfaitement exact que javascript ne propose pas de mot-clé
permettant de qualifier directement un attribut. Il n'y a donc pas de
qualification explicite.

En revanche, une qualification implicite peut être obtenue à l'aide de
modèles de conception spécifiques à javascript. Le résultat est
strictement le même, il ne s'agit absolument pas d'un "patch" ou d'une
quelconque "bidouille", mais simplement de l'expression directe du
paradigme si particulier de javascript.

---
var Foo = (function() {
var privateStaticProp=0;
var privateStaticMethod=function(){}

return function() { // constructor
var privateInstanceProp=0;
var privateInstanceMethod=function(){}

this.publicInstanceProp=0;
this.publicInstanceMethod=function(){}
}
})();

Foo.publicStaticMember=0;
---

Par ailleurs, le prototypage et les règles de scoping javascript (par
ex. ajout d'un objet dans la scope chain avec une instruction 'with')
permettent d'enrichir considérablement les modèles de conception.

<IMHO>
A l'époque où je les ai étudiées, les propositions de javascript 2.X,
telles que décrites par W.H, ou telles que proposées par JScript.Net, ne
m'ont absolument pas emballé. Je me rappelle avoir pensé, peut-être pas
très honnêtement, qu'elles faisaient alors la démonstration d'une
méconnaissance cruelle du paradigme javascript (et notamment de sa
nature fonctionnelle, telle l'avait envisagée le concepteur du langage).
</IMHO>

Cheers,
Elegie.

Jean-Marc Molina <jmmolina@PASDEPOURRIEL-free.fr.invalid> wrote:

le protoypage permet d'ajouter des méthodes, mais pas des attibuts.

Non on peut aussi ajouter des méthodes que des attributs. Il suffit de les
assigner au prototype dans le constructeur.

euh des méthodes je suis d'accord, des attributs on ne peut en ajouter,
a posteriori qu'avec __define[G|S]etter__
amha

ce n'est pas vraiment de l'heritage car l'objet ne change pas de nom
comme on peut le faore en java (machin extends bidule) ou ruby (machin
<< bidule) ???

Désolé j'avais compris que les cookies avaient des comportements différents.
S'il s'agit de paramétrer des cookies il suffit de définir un constructeur
avec des paramètres. S'il s'agit vraiment de créer des objets différents
alors il faut passer par le motif de conception "factory", un peu comme ce
que tu veux avec les fonctions "PageCookie" et "FixedLayoutCookie" en fait.

c'est ce que j'ai fait
sinon il y a effectivement moyen de permettre l'héritage mais après
avoir créé des fonctions auxiliaires.
--
Une Bévue

Elegie <elegie@invalid.com> wrote:

---
var Foo = (function() {
var privateStaticProp=0;
var privateStaticMethod=function(){}

return function() { // constructor
var privateInstanceProp=0;
var privateInstanceMethod=function(){}

this.publicInstanceProp=0;
this.publicInstanceMethod=function(){}
}
})();

Foo.publicStaticMember=0;
---

OH comme cé zoli ça !

mi too j'ai lu les props pour JS 2, ça ne m'a pas convaincu.
je reste aussi pour la prog fonctionelle.

json devrait passer dans une future release de js, qq'un sait pour quand
est-ce ?
--
Une Bévue