Je profite de mes dernières heures de trial MX 2004 au bureau (eh eh, je l'ai pas installé à la maison 8)) pour pousser un (autre) coup de gueule sur la traduction de l'AS2 en AS1 ... :(

Décidemment, AS2 a beau être plus sympa à utiliser, le fait de poser les limitations du typage fort au moment de la compilation n'arrête pas de m'embêter. Il oblige à réécrire deux fois le même code, ce qui va entièrement à l'encontre des principes de base de la POO ... :?

Je veux créer deux classes dont l'une hérite de l'autre. Les constructeurs de ces deux classes prennent les mêmes paramètres. Je veux alors créer une méthode clone qui va me retourner un clone de l'objet (jusque là, rien de bien original). Pourtant, je vais être obligé de réécrire cette méthode pour la classe fille, car le typage fort m'empêche de créer une méthode dans la classe mère qui fonctionnera pour la classe fille. Dans le pire des cas, je veux bien me passer du typage fort pour la fonction clone (ou juste réécrire le typage de la méthode), mais pas réécrire la méthode entière ! :(

Voila ce que je suis obligé de faire :
// classe Parent
class Parent {
   var _prop1:Number;
   var _prop2:Number;
   function Parent(p1:Number) {
      this._prop1 = p1;
      this._prop2 = p1;
   }
   function clone() : Parent {
      var ret : Parent = new Parent(this._prop1);
      return ret;
   }
}
// classe Child
class Child extends Parent {
   function Child(p1:Number) {
      super(p1);
      this._prop2 = p1 + 10;
   }
   function clone() : Child {
      var ret : Child = new Child(this._prop1);
      return ret;
   }
} Et voila ce que j'aimerais (je devrais ?) pouvoir faire// classe Parent
class Parent {
   var _prop1:Number;
   var _prop2:Number;
   function Parent(p1:Number) {
      this._prop1 = p1;
      this._prop2 = p1;
   }
   function clone() : Parent {
      var ret : Parent = new this.constructor(this._prop1);
      return ret;
   }
}
// classe Child
class Child extends Parent {
   function Child(p1:Number) {
      super(p1);
      this._prop2 = p1 + 10;
   }
   function clone() : Child {
      return super.clone();
   }
} La deuxième possibilité serait possible avec un typage fort à l'execution (runtime) et pas à la compilation. J'ai bien essayé d'enlever le typage de la méthode clone (typage du retour et typage de la variable ret), mais il ne m'autorise pas à faire le new this.constructor, prétextant que this.constructor n'est pas une fonction, et en m'affichant comme message : A function call on a non-function was attempted. var ret = new this.constructor(this._prop1); Pourtant, le script suivant ne peut pas mentir :roll:trace(typeof this.constructor); // Affiche : function