Discussion :

[Pascal22]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[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

[Pascal22]

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é.

[marcha]

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

[Pascal22]

merci d'avance...

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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;
}

[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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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)

[Pascal22]

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

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.

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...