ActionScript
Un article de Wikipédia, l'encyclopédie libre.
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
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.
[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] 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.
- Obligation de comprendre et d'utiliser l'orienté objet.
- 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
- (fr) French community
- 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
- (en) OpenSource Flash : site regroupant la plupart des projets OpenSource autour d'ActionScript
- (en) asUnit : implémentation des tests unitaires en 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...
- (fr) Les bases de l'ActionScript 3 : Apprentissage simple de l'Action Script 3 en français.
- (fr) Pratique d'ActionScript 3 : Livre d'apprentissage d'ActionScript 3 en creative common
[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