ActionScript

ECMAScript étant une version standardisée de JavaScript, ActionScript et JavaScript partagent une syntaxe commune, les scripts rédigés dans un langage sont généralement exploitables avec l'autre. Seuls les objets disponibles diffèrent avec l'environnement : classes ActionScript natives pour Flash (MovieClip, Camera, Video, XML, TextField) ou DOM pour les pages HTML (window, document, forms, etc.).

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.

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

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

autre exemple :

 /*Programme de Charles Pascoueleuiee
 x=6;
 z=2
 y=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
x = 0;
// on donne y = 1
y = 1;
//Tant que x est plus petit que 20, ActionSrcipt 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, ect... 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êtte)
    x++;
  //ActionScript écrit y dans la fenetre 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" (conditionel). L'opérateur "else" se traduit par "sinon". L'opérateur "else if" se traduit par "sinon, si" (conditionel).

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

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 = 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");
// ... sinon
} else {
// ... on affiche, sur la fenêtre de sortie la valeur du nombre x et « est plus grand que 50 »  
     trace(x+" est plus grand 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 stock 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". Sinon, il est affiché dans la fenêtre de sortie "x est plus grand que 50".

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

var x = 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 stock 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".

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

var x = 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 stock 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".

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 (rapellons que les programmeurs sont tous des fainéants). Ainsi, cette exemple :

var x = 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 = 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 = 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 = 0;                                // La variable qui nous servira de test
var p = 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
{
     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.
}

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

Article détaillé : Fonction (informatique).

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

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)

Oregano Multiuser Server : il permet entre autres de gérer du clustering entre plusieurs serveurs et d'utiliser des données synchronisées. 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 :

Macromedia Exchange : de nombreux composants sont déposés sur le site officiel de Macromedia.

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] Liens

Documentation et ressources en français : (fr) Wiki mediabox

Documentation du langage (en anglais) sur le site de Macromedia : (en) LiveDocs ActionScript

(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) (es) Cursos ActionScript

(fr) Flash-nouvelle : site de passionnés qui mettent en commun leurs connaissances - Site provisoire

[modifier] Bibliographie

Colin Moock (2003), ActionScript pour Flash MX - La référence - 2ème édition, ISBN 2-84177-271-3
Colin Moock (2004), Le meilleur d'ActionScript 2.0, ISBN 2-84177-313-2

Récupérée de « http://fr.wikipedia.org../../../a/c/t/ActionScript_e777.html »

Catégories : Langage de programmation • Langage orienté objet