Le super de java, en javascript .... la super class ;)

Télécharger le projet
Commenter

Description

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>
Télécharger le projet

Codes Sources

A voir également

S'inscrire maintenant

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.

Du même auteur (cs_Kimjoa)