Toujours pour Flash Forum, j'ai rédigé un tutoriel sur la manière d'intercepter les erreurs et de créer ses propres erreurs avec le nouveau Flash MX 2004

On constate alors que les instructions pour emettre ou intercepter une erreur envoient en fait des instances de la classe Error ou d'une classe qui en hérite. Mais en fait, il n'existe aucune contrainte en ce qui concerne le type d'objet envoyé ou receptionné par ces instructions. On peut alors apparenter ce système avec la programmation évenementielle. De la a y voir d'autres applications, il n'y a qu'un pas ...

Interception d'erreurs dans Flash MX 2004

Auteur : LAlex
Mail : lalex@flash-forum.net
URL : http://www.flash-forum.net
Date de création : 20/09/2003
Version : Flash MX 2004

Présentation
ActionScript 2.0 nous permet maintenant d'intercepter une erreur qui aurait pu se produire durant une portion de code, voire même de créer nos propres erreurs, et de réagir différemment selon le type d'erreur. Nous allons ici voir comment s'en servir.

img:coupe
1. Intercepter une erreur

Les instructions pour intercepter une erreur sont try, catch et finally. Ces instructions sont utilisées avec des groupes de codes entre accolades { et }, comme on le fait avec les boucles ou les fonctions :

• try permet de commencer un portion de code dans laquelle on va pouvoir intercepter une erreur.
  
• catch commence une portion de code qui va être executée si une erreur est interceptée dans la portion try qui la précède. catch fonctionne un peu comme un evenement, c'est-à-dire qu'elle prend un argument qui est de type Error.
  
• finally commence une portion de code qui sera executée quoi qu'il arrive, qu'une erreur soit interceptée ou pas, même si la portion try possède un return, alros que normalement toutes les instructions appellées aprés avoir effectué un return ne sont pas executées.

Un bloc try doit être suivi de au moins un bloc catch ou un bloc finally.

La classe Error contient un constructeur, deux propriétés et une méthode:

• Error( [message] ) : le constructeur prend en paramètre (optionnel) le message d'erreur.
  
• Error.message : spécifie le message d'erreur, le plus souvent destiné à être affiché.
  
• Error.name : Le nom de l'erreur. Ce nom peut servir d'identifiant
  
• Error.toString() : Methode qui retourne une représentation de l'erreur sous forme de chaîne de caractères.

Voyons un exemple classique d'interception d'erreur dans le cadre d'un entretien d'embauche :// On commence a surveiller les erreurs
try {
   candidat = new Individu("DURAND","Pierre","18/06/1987");
   candidat.getPermisDeConduire();
   candidat.getCurriculum();
   // Les autres instructions a effectuer
   // pour l'entretien
} catch (catchedError : Error) {
   // Si une erreur se produit, elle est tranmise à catch
   // dans le parametre catchedError
   trace(catchedError.toString());
   candidat.allerALaPorte();
} finally {
   // Quoi qu'il arrive, on supprime le candidat
   // a la fin de l'entretien
   delete postulant;
}Ici, quand on demande son permis de conduire au candidat, comme il est mineur il n'en a pas, et déclenche donc une erreur. Cette erreur est envoyé comme paramètre à l'instruction catch. img:coupe 2. Provoquer une erreur Il est fréquent que dans la méthode d'une de nos classes, on puisse dire au code qui utilise cette classe que quelque chose s'est mal passé. Nous allons donc "diffuser une erreur", au moyen de l'instruction throw. Cette instruction "emet" une erreur qui lui est fournie juste aprés. Si une instruction throw n'est pas interceptée par un catch, elle se contente d'afficher l'erreur dans la fenêtre de sortie (comme un trace en fait). Voyons comment nous pouvons emmettre une erreur personnalisée lorsqu'un candidat n'est pas majeur :// On crée une fonction qui va vérifier si le candidat est majeur
// S'il ne l'est pas, on emet une erreur avec un message personalisé
function verifierMajorite(c:Individu) {
   if (c.age < 18) {
      throw new Error("Ce candidat n'est pas majeur !");
   }
}
// On déclare notre candidat
var candidat:Individu;
// On commence a surveiller les erreurs
try {
   candidat = new Individu("DURAND","Pierre","18/06/1987");
   verifierMajorite(candidat);
   // La suite de l'entretien
} catch (catchedError : Error) {
   // S'il y a erreur, on affiche le message
   trace(catchedError.message);
} img:coupe 3. Réagir selon le type d'erreur Les instruction try ... catch permettent également de réagir différemment selon le type d'erreur qui survient. Cela est possible grâce aux possibilités de typage fort d'ActionScript 2, en créant plusieurs blocs d'instructions catch qui vont attendre chacun un type d'erreur différent. Cela va nécessiter également de créer des classes qui héritent de la classe Error, et vont posséder leurs propres spécificités. Nous allons ici créer plusieurs classes d'erreurs. Une sera utilisée si le candidat n'st pas majeur, l'autre si le candidat n'a pas d'expérience. Toutes ces classes vont hériter de la classe Error. Les classes sont bien entendus dans des fichiers .as différents. Pour plus d'infos sur les classes AS2 et l'héritage, voir le tuto [tuto de AS1 à AS2]// ===== ErreurTropJeune.as ====
class ErreurTropJeune extends Error {
   var message:String = "Ce candidat est trop jeune";
}
// ===== ErreurTropNovice.as =====
class ErreurTropNovice extends Error {
   var message:String = "Ce candidat n'a pas assez d'experience";
}
// ===== Animation principale =====
// Function qui verifie si le candidat est majeur
// Si ce n'est pas le cas, diffuse l'erreur personalisée
function verifierMajorite(c:Individu) {
   if (c.age < 18) {
      throw new ErreurTropJeune();
   }
}
// Function qui vérifie si le candidat est suffisemment expérimenté
// Si ce n'est pas le cas, diffuse l'erreur personnalisée
function verifierExperience(c:Individu) {
   if (c.experience < 5) {
      throw new ErreurTropNovice();
   }
}
// On déclare notre candidat
var candidat:Individu;
// On commence a surveiller les erreurs
try {
   candidat = new Individu("DURAND","Pierre","18/06/1987");
   verifierMajorite(candidat);
   verifierExperience(candidat);
   // La suite de l'entretien
} catch (catchedError : ErreurTropJeune) {
   // S'il est trop jeune, on lui fait quitter le bureau
   candidat.allerVersLaPorte();
} catch (catchedError : ErreurTropNovice) {
   // S'il manque d'expérience, on le forme
   candidat.allerEnFormation();
} finally {
   // Quoi qu'il arrive, on arrete l'entretien
   delete candidat;
}
img:coupe
4. Conclusion

Aprés avoir vu de quoi il en retourne, à quoi sert la gestion des erreurs ? Tout simplement à savoir quand quelque chose ne va pas ... On pourrais faire une vague comparaison avec le programmation évenementielle, sauf que normalement ca ne se déclenche que quand quelque chose ne va pas ... On peut ainsi intercepter les erreurs qui interviennent dans une classe que l'on ne connaît pas, ou un composant compilé, sur lequel on ne peut pas intervenir au niveau du code source.

En poussant la chose un peu plus loin, on constate que l'instruction throw peut envoyer autre chose que des messages d'erreurs, et qu'en utilisant le typage avec l'instruction catch, on peut recevoir n'importe quel type d'objet. A partir de la, il est facile de trouver des utilisations diverses, qui n'ont même rien à voir avec une interception d'erreur ...

img:coupe
img:remarque msg:tut