ActionScript

Un article de Wikipédia, l'encyclopédie libre.

image:Langage_progr.png
Cet article fait partie de la série
langages de programmation
Langages à objets
C++ - C# - D
Eiffel - Groovy - Java
Lisaac - Python - Ruby
Simula - Smalltalk
Langages impératifs
APL - ASP - Assembleur
BASIC - C - COBOL - Natural
Forth - Fortran - Limbo - Logo
Pascal - Perl - PHP - TCL
Visual Basic - WLangage
Langages fonctionnels
Haskell - ML/OCaml
Lisp/Common Lisp
Scheme - XSLT
Langages déclaratifs
Clips - Prolog
Langages concurrents
Ada 95 - Erlang
Voir aussi
Conception - Codage
Tests - Optimisations

ActionScript est le langage de programmation utilisé au sein des applications Adobe Flash et Adobe Flex.

ActionScript est un langage de script, (orienté objet), basé sur ECMAScript (conforme à 100 % avec la norme ECMA-262, révision 3, depuis ActionScript 3.0).

ECMAScript étant une version standardisée de JavaScript, ActionScript et JavaScript partagent une syntaxe semblable.

Ce langage permet d'ajouter de l'interactivité aux animations Flash, en répondant aux actions de l'utilisateur, et en pilotant les movie clip (conteneurs graphiques permettant de hiérarchiser les animations), et les différents objets multimédias (images, son, vidéo...). Il permet également la communication de l'application avec le serveur, notamment par le chargement de fichiers ou la communication avec un langage serveur comme le PHP.

Sommaire

[modifier] Les variables

[modifier] Déclaration

Les variables dans ActionScript se définissent ainsi:

// (chaîne de caractères)
 a1 = "exemple";
 // nombres
 a2 = 9;
 
 a3 = "Ceci est un " + a1;
 // a3 = Ceci est un exemple
 a4 = a2*100;
 // a4 = 9 x 100 = 900

Il est possible (et même conseillé) de déclarer en même temps le type de variable :

// Declaration locale
 var str:String = "Ceci est une chaîne de caractères";
 var n:Number = 10;
 var T:Array = new Array();
 
 // Déclaration impossible
 var this.n:Number = 10;
 
 var x;
 x:Number = 5;

L'instruction var est indispensable pour préciser le type de variable. De même, var ne permet qu'une déclaration locale. Ainsi, la déclaration d'une variable avec var au sein d'une fonction entraînera la destruction de cette variable une fois la fonction terminée.

[modifier] Suppression

Comme indiqué dans la sous-partie précédente, une variable définie avec l'outil var ne le sera que localement. Ainsi, elle sera automatiquement supprimée à la sortie de la fonction, et ne pourra être utilisée qu'au sein de cette fonction.

Il est cependant possible de détruire une variable avant la fin de la fonction :

var A:String = "Je suis définie !";
 
 trace (A); // Retourne "Je suis définie !"
 delete A;
 trace (A); // Retourne "undefined"

[modifier] Les commentaires

Les commentaires sont les mêmes que ceux du C/C++. On peut commenter le code de deux façons :

  • commenter la fin de la ligne avec //
  • commenter un bloc de lignes avec /* ... */

exemples :

var x:Number = 6; // commentaire de fin de ligne (x=6 est exécuté)
 
 /* commentaire multi-lignes : les deux lignes suivantes sont commentées
 var x:Number = 6;
 var z:Number = 2;
 */

autre exemple :

/* Programme de Charles Pascoueleuiee */
 var x:Number = 6;
 var z:Number = 2;
 var y:Number = x * z;

Le commentaire /* est encore ouvert et ne sera refermé qu'au prochain */. L'erreur peut être difficile à trouver ! il faut bien penser à toujours apparier les /* et */.

Il est préférable de toujours utiliser la notation //. Ainsi on peut facilement mettre en commentaire (pour du debug par exemple) du code contenant des commentaires, en utilisant la notation /* ... */.

[modifier] Le langage

Pour se faire une idée de la syntaxe d'ActionScript, voici l'exemple d'un programme permettant d'afficher les vingt premières puissances de deux :

// on donne x = 0
 var x:Number = 0;
 // on donne y = 1
 var y:Number = 1;
 
 //Tant que x est plus petit que 20, ActionScript exécutera les actions entre les {}
 while (x < 20)
 {
  // On définit les actions
  // l'opération y x 2 est effectuée (1 x 2 = 2 puis 2 * 2 = 4, etc... le nombre y double à chaque fois)
    y *= 2;
 
  // On donne comme nouvelle valeur x = x + 1 (1 puis 2 puis 3 et ainsi de suite jusqu'à 20 pour que l'action s'arrête)
    x++;
 
  // ActionScript écrit y dans la fenêtre de sortie
    trace (y);
 }

[modifier] Les structures de contrôle

Voici quelques exemples de structures de contrôle en ActionScript. Ces structures permettent de gérer facilement les informations.

[modifier] L'instruction if / else / else if

L'instruction if est la plus utilisée dans tous les langages de programmation. Elle permet de vérifier si une condition est vraie puis d'effectuer une telle action en fonction du résultat.

L'opérateur "if" se traduit par "si" (conditionnel). L'opérateur "else" se traduit par "sinon". L'opérateur "else if" se traduit par "sinon, si" (conditionnel).

// Si... alors ...
  if (CONDITIONS) {
    ACTION();
 }

Voilà un exemple simple:

// On prend un nombre x au hasard entre 0 et 1, et le multiplie par 100 (random en anglais signifie aléatoire)
 var x:Number = Math.random()*100;
 
 // Si x est plus petit que 50, alors ...
 if (x < 50)
 {
 // ...on affiche, sur la fenêtre de sortie la valeur du nombre x et « est plus petit que 50 »
      trace (x + " est plus petit que 50");
 }

Ce script peut alors se transcrire en une forme rédigé :

On prend un nombre entre 0 et 1 (ça peut-être 0.1235) et on le multiplie par 100.
On stocke ce nombre dans une variable x, pour être utilisé ultérieurement.
Si x est plus petit que 50
alors
   il est affiché dans la fenêtre de sortie "x est plus petit que 50".
fin

L'opérateur else n'est pas plus compliqué à utiliser :

var x:Number = Math.random()*100;   // Prend un nombre au hasard entre 0 et 1, et le multiplie par 100
 
 if (x < 50)
    trace (x + " est plus petit que 50");
 else
    trace (x + " est plus grand que 50");

Si on traduit ça en français, cela donne :

On prend un nombre entre 0 et 1 (ça peut-être 0.1235) et on le multiplie par 100.
On stocke ce nombre dans une variable x, pour être utilisé ultérieurement.
Si x est plus petit que 50
alors
     Affiche dans la fenêtre de sortie "x est plus petit que 50".
sinon (autrement dit, si x >= 50)
     Affiche dans la fenêtre de sortie "x est plus grand que 50".
fin

L'opérateur else if est très utile si on a plusieurs conditions :

var x:Number = Math.random()*100;   // Prend un nombre au hasard entre 0 et 1, et le multiplie par 100
 
 if (x < 33)
    trace (x + " est plus petit que 33");
 else if (x >= 33 && x < 66)
    trace (x + " est compris entre 33 et 66");
 else
    trace (x + " est plus grand que 66");

Ce qui donne :

On prend un nombre entre 0 et 1 (ça peut-être 0.1235) et on le multiplie par 100.
On stocke ce nombre dans une variable x, pour être utilisé ultérieurement.
Si x est plus petit que 33
alors
     Affiche dans la fenêtre de sortie "x est plus petit que 33".
sinon, si x est plus grand que 33 ET qu'il est plus petit que 66
     Affiche dans la fenêtre de sortie "x est compris entre 33 et 66".
sinon (autrement dit, si x >= 66)
     Affiche dans la fenêtre de sortie "x est plus grand que 66".
fin

Contrairement aux "if" et "else", le nombre de "else if" possibles est illimité. Lorsque l'une des conditions est vraie, aucune des suivantes n'est évaluée.

Il existe une version compactée de l'instruction du type if / else (la plus souvent utilisée), nommée opérateur ternaire. Il permet de remplacer le deuxième exemple, par une seule ligne (rappelons que les programmeurs sont tous des fainéants). Ainsi, cette exemple :

var x:Number = Math.random()*100;   // Prend un nombre au hasard entre 0 et 1, et le multiplie par 100
 
 if (x < 50)
   trace (x + " est plus petit que 50");
 else
   trace (x + " est plus grand que 50");

devient :

var x:Number = Math.random()*100;   // Prend un nombre au hasard entre 0 et 1, et le multiplie par 100
 
 (x < 50) ? trace (x + " est plus petit que 50") : trace (x + " est plus grand que 50");

Cette partie finira sur une exception propre aux boucles (if, while, for, ...). Il est possible d'omettre les accolades s'il n'y a dans la condition qu'une seule expression, on peut donc écrire :

var x:Number = Math.random()*100;   // Prend un nombre au hasard entre 0 et 1, et le multiplie par 100
 if (x < 33)
      trace (x + " est plus petit que 33");
 else if (x >= 33 && x < 66)
      trace (x + " est compris entre 33 et 66");
 else
      trace (x + " est plus grand que 66");

[modifier] L'instruction while

L'instruction while va permettre de répéter une action tant que la condition est vérifiée. On traduit "while" par "tant que".

var x:Number = 0;                                // La variable qui nous servira de test
 var p:Number = 0;                                // Va nous servir à compter le nombre de passage
 
 while (x < 20)
 {
      p ++;
 
      if (p == 1)
           trace ("1er passage");
      else
           trace (p + "ème passage");
 
      x = Math.random()*100;               // Prend un nombre réel entre 0 et 100
 }

Traduction :

On initialise la valeur de x et de p à 0.
Tant que x est plus petit que 20
alors
     On incrémente p de 1.
     si p est égal à 1
          tu affiches en fenêtre de sortie que c'est le premier passage
     sinon
          tu affiches le nombre de passages
     Place dans x la valeur d'un nombre pris aléatoirement entre 0 et 100.
on relance la boucle (si la condition est toujours vraie)

Attention cependant, la boucle while se lance et se termine sur la même image. Si vous faites une boucle infinie (ou qui met longtemps avant de se terminer), le FlashPlayer vous avertira du problème et vous demandera si vous voulez annuler ou continuer les calculs.

Même remarque que pour les boucles de conditions, si vous n'avez qu'une seule ligne dans votre boucle while, vous pouvez vous dispenser des accolades.

[modifier] Les fonctions

Les fonctions en ActionScript servent à deux choses :

[modifier] Les fonction-classes

Les fonctions-classes permettent de définir des classes pour créer des objects personnalisés. Elles sont devenues inutiles depuis l'ActionScript 2 qui propose un nouveau système de classe, mais peuvent rester pratique pour certaines utilisations précises.

[modifier] Les fonctions de répétitions

Icône de détail Article détaillé : Fonction (informatique).

Outre les traditionnelles boucles for et while, l'actionscript utilise une classe nommée EventDispatcher qui permet d'exécuter nativement - donc plus rapidement - une répétition d'appels de fonctions sur une liste d'objets et méthodes appelée tableau d'écouteurs.

ainsi pour exécuter plus rapidement une boucle de type

tableau.push(fonction1)
tableau.push(fonction2)
tableau.push(fonction3)....
for indexFonction in tableau{
  tableau[indexFonction].fonction();
}

on tapera plutôt

//version as1: utilise un tableau d'objets, la methode appelée est toujours la même
 asBroadcaster.addListener(objet1);
 asBroadcaster.addListener(objet2);
 asBroadcaster.addListener(objet3);
 asBroadcaster.broadcastMessage("nomFonction");
 
 //version as3: utilise un tableau d'objets ET méthodes
 eventDispatcher.addEventListener("nomEvent",objet1.fonction1);
 eventDispatcher.addEventListener("nomEvent",objet2.fonction2);
 eventDispatcher.addEventListener("nomEvent",objet3.fonction3);
 eventDispatcher.dispatchEvent("nomEvent");

[modifier] Les classes

La grande nouveauté de l'ActionScript 2.0 est l'apparition des classes. Il était déjà possible de créer des classes auparavant mais de façon très limitée, par l'intermédiaire des fonctions (à la manière du javascript). Il est désormais possible de créer des fichiers de classe externes et de les importer à l'aide du mot-clé import. Les classes sont des modèles. Par exemple, la classe personne comportera les propriétés nom, age et taille.

Icône de détail Article détaillé : Classe (informatique).

[modifier] Les composants

L'autre grande nouveauté de l'ActionScript 2.0 est l'apparition des composants. Il s'agit de clips compilés (la source n'est donc pas forcement disponible) auxquels on a associé une classe de programmation. Ils se manient donc comme des objets à part entière : leurs méthodes (fonctions appliquées à l'objet) peuvent avoir des répercussions graphiques.

Parmi les composants natifs de Macromedia Flash (version MX 2004), on peut trouver les équivalents des « conteneurs » HTML (combos de sélection, zones de texte, de saisie, listes déroulantes, ...), ou encore des composants plus complexes comme des fenêtres, des tableaux de données, des lecteurs multimédia (son, vidéo). La plupart de ces composants « natifs » ne sont disponibles que dans la version « Professionnelle » de Flash MX 2004.

[modifier] Particularités du langage

L'une des particularités d'ActionScript, par rapport aux autres langages web, est d'avoir intégré dans ses objets natifs la possibilité d'ouvrir et d'écouter une Socket grâce à l'objet XMLSocket. Cela permet au serveur de mettre à jour le client (le navigateur) sans que ce dernier ne le demande (aucune action de la part de l'utilisateur). Ainsi, on peut gérer une application ou un jeu multi-utilisateurs en temps réel grâce à un client Flash (donc, un navigateur). Il est alors nécessaire de mettre en place un serveur pour « centraliser » les informations et les redistribuer.

Voici quelques serveurs (Java, Perl) disponibles sur Internet :

  • moockComm : un chat (messagerie instantanée). Cet exemple est plus didacticiel que fonctionnel. Idéal pour comprendre comment fonctionnent les Sockets avec ActionScript.
  • Unity 2 : un autre serveur de Colin Moock. Payant
  • 2iceMP Framework : un multiuser server puissant (gestion de bases SQL intégrée) en PERL. Intègre un module ASTAR de pathfinding notamment. Open Source (LGPL)
  • Palabre : Un serveur simple et évolutif en python permettant de créer rapidement des applications de chat, des jeux multi-joueurs, Open Source (GPL)

ActionScript 2.0 permettant de programmer et de concevoir ses composants, de nombreux développeurs ont fait les leurs et les proposent (gratuitement ou non) sur Internet.

Quelques adresses où se trouvent certains de ces composants :

  • ASLib : bibliothèque ActionScript implémentant des structures classiques de données non intégrées dans le langage basique (Arbres binaires, Listes chaînées, Piles, « Hash Table »).
  • FP XHTML Render : un parseur de XHTML. Il affiche le contenu d'un tel fichier dans un « conteneur » Flash (Fenêtre, ...).

[modifier] D'ActionScript 2.0 à ActionScript 3.0

L'émergence de la version 3.0 d'ActionScript a complètement bouleversé la façon d'appréhender la programmation ActionScript. En effet, cette nouvelle mouture du langage adopte une syntaxe différente mais également une grosse particularité, c'est qu'elle est entièrement pensée et conçue pour développer en orienté objet.

Tout ceci a plusieurs conséquences, bonnes et moins bonnes :

  • Les "anciens" développeurs doivent apprendre une nouvelle syntaxe, ce qui demande un petit temps d'adaptation.
  • Les possibilités d'ActionScript sont encore décuplées.
  • Une ouverture plus franche de la part d'Adobe sur ActionScript nous permet d'espérer une grande compatibilité, frameworks et autres compilateurs externes.
  • La vitesse d'exécution des scripts est meilleure (tant que la programmation est bien réalisée).

[modifier] Liens

  • (en) ActionScript.org : une vaste banque de données de tutoriaux et de morceaux de code pour ActionScript.
  • (fr) www.zoneflash.net : Site consacré au logiciel Flash et à la programmation avec ActionScript.
  • (en) OpenSource Flash : site regroupant la plupart des projets OpenSource autour d'ActionScript
  • (en) Prototype : Large banque de données de function ActionScript.
  • (fr) Flash-France.com : Site français regroupent tutoriaux, fla, sons, polices de texte, etc...

[modifier] Bibliographie