la fonction pour créer une class est createClass, mais peux ètre renomé.
liste des arguments de createClass:
- le constructeur,
- le prototype,
- une super classe
- un objet en plus à étendre au prototype dont les méthodes n'utilise pas Self ou Super
Dans vos méthodes vous pourrez donc faire un appel à la super classe, via Super() :
liste des arguments de Super:
- la propriété a appeler ou retourner
- le contexte
- un tableau d'arguments à passer à la méthode
et aussi à Self, qui renvoie non pas le constructeur de l'instance (appel static classique en js), mais du constructeur de la classe définissant la méthode appelé.
liste des arguments de Self:
- la propriété a appeler ou retourner
- un tableau d'arguments à passer à la méthode
Les appels static sont fais classiquement, via le constructeur, exemple :
this.constructor.maMéthodeStatique();
j'allais oublié, les méthodes static peuvent être mit dans l'objet prototype, (2ème arguments de createClass) avec en préfixe 'static_', regarder l'exemple.
bye
Source / Exemple :
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="fr" lang="fr">
<head>
<title>IDClass</title>
<style></style>
<script type="text/javascript">
createClass = function(){
// variable et méthode privées
//enregistre dans le prototype les propriété d'un objet (ex maClass.implement({prop : valeur})
//se nomme ainsi pour pas utiliser extend qui porterais encore plus a confusion , il ne s'agit pas d'interface!!
function implement(o){
for(var i in o){
if(/^static_/.test(i)){
this[i.replace(/^static_/, '')] = o[i];
}else this.prototype[i] = o[i];
}
}
var nfn,//string d'une foncyion à évaluer
have;//si on doit déclarer les fonction Super et Self
//retourn si la proriété est une méthode et si elle utilise Super ou Self
function chk(fn){
if(typeof fn == 'function' && /Self|Super/.test(nfn = fn.toString())){
have = true;
return true;
}
}
return function(_constructor, _prototype, _super, _implements){
have = false;
//réévalue le constructeur, si il utilise Super ou Self , accéssible que depuis cette appel de fonction
_constructor = chk(_constructor) ? eval('[' + nfn + ']')[0] : _constructor || function(){};
_prototype =_prototype || {};
//réévalue toute les méthodes , si elles utilisent Super ou Self ,
for(var i in _prototype)
_prototype[i] = !/^static_/.test(i) && chk(_prototype[i]) ? eval('[' + nfn + ']')[0] : _prototype[i];
//si une ou plus de méthode appel Super ou Self
if(have){
var Super = function(prop, inst, args){
var re = prop == 'constructor' ? _super : _super.prototype[prop];
if(typeof re == 'function')
return re.apply(inst, args || []);
return re;
}
var Self = function(prop, args){
var re = _constructor[prop];
if(typeof re == 'function')
return re.apply(null, args || []);
return re;
}
}
//ajout la méthode static implement
_constructor.implement = implement;
//gestion native d'extension d'une class, qui permet le polymorphisme via instanceof
if(_super){
var t=function(){};
t.prototype = _super.prototype;
_constructor.prototype = new t();
_constructor.prototype.constructor = _constructor;
}
//ajoute les prop du prototype
_constructor.implement(_prototype);
//ajoute les prop en plus, qui n'appel pas de super ou self
if(_implements)
_constructor.implement(_implements);
return _constructor;
}
}();
//ATTENTION !! une fois vaux classe déclaré, il n'est plus possible de rajouter des méthodes devant appeler un super ou self..
var test1 = createClass(function(){
alert('constructor1');
Self('test');
this.constructor.test(true);
},{
fntest : function(){
alert('fnTest1');
},
static_test : function(){
alert('staticTest1 --- appel par self');
}
}
);
var test2 = createClass(function(){
alert('constructor2');
Super('constructor', this);
Self('test');
},{
fntest : function(){
alert('fnTest2');
},
static_test : function(){
alert('staticTest2 --- appel par self');
}
}, test1);
var test3 = createClass(function(){
alert('constructor3');
Super('constructor', this);
Self('test');
},{
fntest : function(){
alert('fnTesn3');
},
static_test : function(bys){
alert(bys ? 'staticTest3 --- appel static classique via le consructeur' : 'staticTest3 --- appel par self');
}
}, test2);
var obj1 = new test3;
//garde la gestion native du polymorphisme
alert(obj1 instanceof test1);
</script>
</head>
<body>
</body>
Vous n'êtes pas encore membre ?
inscrivez-vous, c'est gratuit et ça prend moins d'une minute !
Les membres obtiennent plus de réponses que les utilisateurs anonymes.
Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.
Le fait d'être membre vous permet d'avoir des options supplémentaires.