Si le langage ActionScript 1.0 rest très proche de la spécification ECMA, et donc de JavaScript, il n'en reste pas moins que le langage de Flash dispose de nombreuses spécificités, la plupart dues au format (tout ce qui concerne la timeline et les clips, par exemple), d'autres plus pragmatiques. Il en est ainsi de la programmation OO dans Flash, notamment du polymorphisme et de l'héritage, ce que nous allons voir dans cet article.

Explication
Les proriétés prototype et __proto__ étant des spécificités de ECMA-262, JavaScript et ActionScript (plus précisément, __proto__ n'existe qu'au sein de l'environnement de développement Flash), il ne sera probablement pas utile au développeur OO pur d'apprendre à les reconnaître, à les comprendre et à s'en servir. Au contraire, le développeur Flash qui souhaite se glisser dans les fonctions OO du langage ne peut que gagner à les avoir dans sa trousse à outils.

Dans son incarnation première, ActionScript ne dispose pas d'une syntaxe formelle de classe, et fait à la place appel aux prototypes. La version 2.0 du langage, lancée avec Flash MX 2004, comble ce manque et reconnaît les classes publiques, privées et statiques, les interfaces... AS 2.0 n'est cependant pas encore d'actualité, et AS1.0 n'est pas prêt de disparaître...

Prototype
Chaque classe doit avoir une fonction constructeur, qui prend généralement en charge l'initialisation des variables de base nécessaire au bon fonctionnement de la classe. Sa création peut être implicite ou explicite. Il faut maintenant savoir que toute fonction contructeur se voit automatiquement attribuer une propriété appellée "prototype". Celle-ci permet d'accéder aux valeurs des propriétés des objets créés avec cette fonction, et donc de créer et modifier les propriétés et méthodes d'une classe :

function Humain(poucesOpposables, homnivore)
  {
   this.poucesOpposables = true;
   this.homnivore = true;
   }

var damoiselle = new Humain();
damoiselle.prototype.prenom = "Marie-Pétronille";
damoiselle.prototype.sexe = "F";

Humain.prototype.getPrenom = function()
  {
  return this.prenom;
  }

damoiselle.getPrenom(); // renvoi "Marie-Pétronille"

Il peut sembler plus logique d'écrire Humain.prenom="Untel", mais le fait est qu'ActionScript 1.0 ne le permet simplement pas : les prototypes permettent de passer outre ce défaut de conception d'AS1.

__proto__
Contrepartie de la fonction prototype, __proto__ indique de quel objet une propriétés est l'héritière : __proto__ fait référence au prototype de sa fonction constructeur. Ainsi, damoiselle.__proto__ équivaud à Humain.prototype.

trace(damoiselle.__proto__.homnivore); // affiche "true"

Principalement à usage interne, __proto__ peut néanmoins se révéler pratique lorsque l'on veut explicitement connaître certaines propriétés ou méthodes des ancètres. Si un élément (une priorité surchargée par exemple) n'est pas trouvé dans un objet, l'interpréteur ActionScript ira lui-même les chercher dans le __proto__ de l'objet, ou chez l'ancètre supérieur, et ainsi de suite. Si l'on sait où on veut récuperer cette information, on peut directement écrire (par exemple) :

damoiselle.__proto__.__proto__.__proto__.getGenre;

Flash utilise donc depuis sa version 5 un système à part d'héritage. La dernière version fait un mélange judicieux de ECMAScript 4 et JavaScript2.0, se rapprochant ainsi de la syntaxe Java, ce qui rend la programmation OO au sein de l'environnement Flash beaucoup plus "logique". Et si nous allons voir les nouveautés d'ActionScript 2.0 dans un prochain article, il reste important de maîtriser ActionScript 1.0, la version 7 du Flash Player étant loin d'être présente sur tous les postes connectés.