ClassObject.js : un framework JavaScript de construction de classes

La définition des propriétés passe par l'utilisation des descripteurs. Ils sont au nombre de huit et peuvent être appelés de n'importe où dans le programme :

• public ;
• private ;
• protected ;
• attribute ;
• method ;
• static ;
• constant ;
• final.

L'initialisation des objets se fait en précisant la méthode __init__. Cette méthode, qui doit être définie comme telle (et non comme un attribut), peut accepter n'importe quel paramètre et ne doit pas être définie comme statique.

Au sein d'une méthode, statique ou non, les propriétés sont accessibles via l'objet this, quelle que soit leur visibilité (publique, privée ou protégée).

Pour créer un attribut, trois syntaxes sont possibles :

var UneClass = Class({
     a : 1
   , b : attribute
   , c : attribute(2)
}) ;

Dans cet exemple, les trois propriétés de la classe UneClasse sont des attributs. a est considéré comme un attribut par défaut. Si on avait précisé une fonction, a aurait été considéré comme une méthode.

Sans aucune précision supplémentaire, ces attributs sont tous trois considérés comme publics, non statiques, non constants, non final.

a et c seront initialisés directement avec des valeurs, respectivement 1 et 2, tandis que b n'aura pas de valeur initiale (en réalité, il vaudra undefined).

Pour créer une méthode, deux syntaxes sont possibles :

var UneClass = Class({
     getA : function() {
        return this.a ;
     }
   , getB : method({
       function() {
          return this.b ;
       }
     }) 
}) ;

On utilise ici une syntaxe simplifiée pour définir getA : on ne précise qu'une fonction. Si on avait utilisé une valeur de tout autre type, getA aurait été défini comme un attribut.

getB utilise la fonction method pour créer une méthode. Cette fonction n'accepte qu'une fonction comme paramètre.

Les méthodes ne peuvent pas être modifiées : sur un objet ou une classe (méthode statique), il n'est pas possible de remplacer la méthode par une autre.

Trois descripteurs définissent la visibilité :

• public ;
• protected ;
• private.

Exemple :

var UneClass = Class({
     getA : method(
        function() {
           return this.a ;
        })
   , a : protected(10)
}) ;

Pour définir une propriété statique, on utilisera le descripteur static.

Un attribut statique est visible à la fois depuis la classe et depuis n'importe quelle instance de la classe.

Exemple :

var UneClasse = Class({
     a : static(1)
}) ;

var i = new UneClass() ;
console.log(UneClasse.a) ; // 1
console.log(i.a) ;         // 1

Il est possible de définir des constantes de classes via le descripteur constant.

Exemple :

var UneClasse = Class({
     a : public.static.constant(1) ;
}) ;

console.log(UneClasse.a) ; // 1

UneClasse.a = 100 ;

console.log(UneClasse.a) ; // 1

Les propriétés final sont des propriétés qui ne peuvent être étendues. On utilisera le descripteur final pour les définir.

Les descripteurs peuvent être chaînés. Il n'y a pas d'ordre particulier à respecter. Par exemple, ces trois écritures sont valables :

private.constant.static
constant.private.static
static.constant.private

La chaîne n'a pas forcément à être cohérente : seul le résultat final compte. Par exemple le descripteur private.public.protected.method.attribute.constant.static est tout à fait valable et désigne un attribut protégé constant et statique.

Il en va de même pour l'initialisation. Par exemple : private.constant(1).static(2) désigne un attribut statique, constant, initialisé à 2.

On pourra aussi initialiser les valeurs via la fonction set des descripteurs (utilisables aussi bien pour les attributs que pour les valeurs).

Il n'est pas obligatoire de préciser la valeur pour les attributs (même s'il est plus logique d'en préciser une pour les constantes).

L'héritage se fait via une propriété particulière : Class. Cette propriété ne sera pas présente dans l'objet final mais fournit des renseignements sur la classe. Cette propriété doit avoir comme valeur un dictionnaire, acceptant pour le moment deux clés :

• extends : indique que la classe hérite des propriétés d'une classe mère ;
• final : indique si oui (true) ou non (false) la classe peut-être étendue (par défaut : false).

Exemple :

var UneClasse = Class({
     a    : 1
   , b    : 2
   , getA : function() {
       return this.a ;
     }
   , getB : function() {
       return this.b ;
     }
}) ;

var ClasseFille = Class({
     c     : private(4)
   , getA  : function() { 
        return this.a + c ;
     }



   , __init__() :
      function() {
        this.super.__init__() ;
        this.b = 12 ;
      }

   , Class : {
         extends : UneClasse
       , final : true}
}) ;

var i = new ClasseFille() ;

Comme on peut le voir dans l'exemple précédent, il est possible d'accéder aux propriétés de la classe parent via l'objet this.super.