Heritage de modèles d'objets

Version imprimable

débutant en javascript, je cherche à retrouver les fonctionnalités de l'héritage 'à la C++'. J'ai donc, en guise de test, fait cette fonction :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 
//fabrique un constructeur pour instancier un objet de type clsEnfant dérivé de clsParent
//version ultra simpliste (pas d'arguments pour les fonctions)
//permet la surcharge de fonctions
//permet d'acceder aux fonction du parent par parent.nomfonction
function heriteDe(clsParent,clsEnfant)
{
  function Constructeur()   //definition du constructeur
  {
        this.parent=new clsParent(); //instancier un objet parent
        for(var att in this.parent)  //parcourir les acctibuts du parent
        {
          if(typeof this.parent[att]== "function")
          { //definir,depuis l'enfant, une fonction d'acces à la fonction parent
              this[att] = eval("function() { this.parent."+att+"();}");
          }
          else
          { //definir, depuis l'enfant, les getter et setter d'accès à la propriété parent
            eval(" this."+att+" getter =function() {return this.parent."+att+"; }; "+
                 " this."+att+" setter =function(val){this.parent."+att+"=val; } ");
 
          }
        }
        clsEnfant.apply(this); //appliquer le constructeur du modele enfant
  }
  return Constructeur;
}

jeu d'essai :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 
function ProtoParent() //'classe' parente
{
  this.A=0;
  this.C=12;
  this.foncA=function() {this.A=this.A+1;}
  this.foncC=function() {this.C=this.C+5;}
}
function ProtoEnfant() //'classe' enfant
{
  this.B=8;
  this.foncB=function() {this.A=this.A+2; this.B=this.B+2;}
  //foncC surcharche la fonction parente et fait appel à celle-ci
  this.foncC=function() {this.parent.foncC(); this.C=this.C-6; }
}
 
 
var Modele=heriteDe(ProtoParent,ProtoEnfant); //creation du modele d'objet
 
var test= new Modele(); //instanciation de l'objet
 
alert("A: "+test.A+" B :"+test.B+" C: "+test.C);
test.foncA();
alert("fonction foncA appelée (hérité)A:"+test.A+" B :"+test.B+" C: "+test.C);
test.foncB();
alert("fonction foncB appelée A:"+test.A+" B :"+test.B+" C: "+test.C);
test.foncC();
alert("fonction foncC appelée (surcharge et appel interne de la foncC parent) A: "+test.A+" B :"+test.B+" c: "+test.C);

si des spécialistes du javascript pouvait me donner leur avis, afin de savoir si la piste envisagée est bonne où s'il y a d'autres directions plus efficaces.

Merci d'avance

12/09/2007, 15h15
marcha

Salut,

pas le temps de me plonger dans ton code maintenant, mais tu peux
le comparer avec celui de la librairie protoype
http://www.prototypejs.org/api/object/extend
12/09/2007, 15h51
Pascal22

Citation:

le comparer avec celui de la librairie prototype

en fait, j'ai déjà testé Object.extend().
Je l'utilise d'ailleurs,mais elle n'a pas le même objectif (elle étend un objet déjà instancier avec les attributs d'un clone de l'objet fournis en parametre), il n'y a pas de relation parent/enfant.
Là, l'idée c'est de créer un modèle d'objet regroupant par defaut les attributs des 2 modeles (enfant et parent), tous en laissant la possibilité, même en cas de surcharge d'une fonction, d'acceder à celle du parent.

Histoire de mieux situer l'intéret de ma recherche :
Le but général de ce système est de mettre en oeuvre une 'fabrique d'objet'. Avec d'un coté un Hiérarchie de Modèles (avec des comportements du plus générique au plus spécialisé) et d'un autre (en provenance du serveur) des Objets 'Données' Structurés (JSON) que l'on puisse étendre avec une instance du Modèle approprié.
12/09/2007, 16h05
marcha

Ok, j'ai compris. Je vais regarder ça demain.

merci d'avance...

cette nouvelle version autorise les argument pour les fonctions et les déclaration par la propriété prototype :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
 
//fabrique un constructeur pour instancier un objet de type clsEnfant dérivé de clsParent
//Limitation : Les constructeurs ne doivent pas contenir d'arguments
//permet la surcharge de fonctions
//permet d'acceder aux fonction du parent par parent.nomfonction
function heriteDe(clsParent,clsEnfant)
{
  function ConstWrapFonc(NomFonc,NbParams) //construit une fonction d'accès
  {
    var Result="";
    var LstParams="";
    var count=0;
    while(count<NbParams)                //ajouts des paramètre à la liste
    {
     if(count>0)
       LstParams=LstParams+','
     LstParams=LstParams+"par"+count;
     count++;
    }
    Result="function("+LstParams+") { this.parent."+NomFonc+"("+LstParams+");}";
    return Result;
  }
 
  function Constructeur()   //definition du constructeur
  {
        this.parent=new clsParent(); //instancier un objet parent
        for(var att in this.parent)  //parcourir les acctibuts du parent
        {
          if(typeof this.parent[att]== "function")
          {
 
           //definir,depuis l'enfant, une fonction d'acces à la fonction parent
           if(clsEnfant.prototype[att] == null) //exclure les fonctions surchargées par le prototype enfant
             this[att]=eval(ConstWrapFonc(att,this.parent[att].arity));
          }
          else
          {
            //definir, depuis l'enfant, les getter et setter d'accès à la propriété parent
 
            eval(" this."+att+" getter =function() {return this.parent."+att+"; }; "+
                 " this."+att+" setter =function(val){this.parent."+att+"=val; } ");
          }
        }
        clsEnfant.apply(this); //appliquer le constructeur du modele enfant
 
        //ajouter le prototype de la classe enfant
        if(typeof Constructeur.initialized == "undefined")
        {
         for(var att in clsEnfant.prototype)
         {
 
            Constructeur.prototype[att]=clsEnfant.prototype[att];
 
         }
         Constructeur.initialized=true;
        }
  }
  return Constructeur;
}

13/09/2007, 08h53
marcha
Salut,

Je me suis amusé un peu avec ton code, ça m'a l'air pas mal.

par contre pour redéfinir une fonction il me semble que tu pourrai
simplement lié la référence ainsi:
Code:

1 2 3 4 5 if(typeof this.parent[att]== "function") { this[att] = this.parent[att]; }
Comme ça tu te prend pas la tête avec la propagation des
paramètres.

Sinon, pour moi, le terme "surcharge" signifie deux fonctions portant
le même nom mais avec des signatures différentes (ce qui n'existe pas
à ma connaissance en javascript). overloading en anglais

Le terme "redéfinir" me semble plus adapté quand une classe enfant redéfini
une fonction du parent (overriding en anglais)
13/09/2007, 09h33
Pascal22

salut,
merci de t'être penché sur mes interrogation.

Citation:

par contre pour redéfinir une fonction il me semble que tu pourrai
simplement lié la référence ...

effectivement... comme quoi, des fois, on cherche les compliquation... je vais tester mais il n'y a pas de raison de ca ne fonctionne pas.

Citation:

Sinon, pour moi, le terme "surcharge" signifie deux fonctions portant
le même nom mais avec des signatures différentes (ce qui n'existe pas
à ma connaissance en javascript). overloading en anglais

Le terme "redéfinir" me semble plus adapté quand une classe enfant redéfini
une fonction du parent (overriding en anglais)

tu as raison s'est un abus de langage de ma part.

Rassuré je continue mes investigations... j'aurais vraisemblablement d'autres question plus tard...