Le langage ActionScript
ActionScript et ECMAScript
* Standard ECMAScript
* Défini par l'organisme ECMA
* European Computer Manufacturers Association
* Organisme de standardisation pour l'informatique
* Langages reposant sur ce standard
* ActionScript: développé par Adobe / Macromedia
* JavaScript: développé par Netscape
* ActionScript et JavaScript sont des langages très proches
* Différences liées aux versions de l'ECMAScript
* JavaScript: dernière version 1.7 ==> conforme ECMAScript 3
* Future version 2.0 ==> conforme ECMAScript 4
* ActionScript: dernière version 3.0 ==> conforme ECMAScript 4
* Précédente version 2.0 ==> partiellement conforme ECMAScript 4
* Différences liées aux API (Application Public Interface)
* API = fonctionnalités publiques d'une bibliothèque
* JavaScript: DOM (Document Object Model) pour les pages HTML
* ActionScript: DOM pour les documents Flash
Langage ActionScript
* Placé dans un document Flash
* Pour répondre aux événements sur un composant
* Une zone de code par composant
* Placé dans un fichier extérieur à Flash ==> fichier ".as"
* Syntaxe similaire à Java
* Instructions terminées par ";"
* Commentaires
* "//" pour une seule ligne
* "/*...*/" pour plusieurs lignes
* Opérateurs et structures de contrôle identiques
* Sensible à la casse
* Possibilité de définir des variables faiblement typées
* Type peut changer en cours d'exécution
* Pas de type prédéfini à la déclaration
* En général, variables fortement typées
* Type ne peut pas changer en cours d'exécution
* Type déterminé à la déclaration
Variables (1/2)
* Déclaration implicite
* nom_variable = valeur;
* Portée illimitée de la variable
* Variable globale
* Accessible de n'importe où
* Déclaration explicite
* Utilisation du mot-clé "var"
* var nom_variable = valeur;
* Portée de la variable limitée au bloc d'instructions
* Bloc d'instructions = zone entre "{" et "}"
* En dehors de tout bloc = variable globale
* Dans le bloc d'une fonction = variable locale
* Conseil: toujours utiliser "var" pour la déclaration
* Préciser le type à la déclaration
* var nom_variable : type = valeur;
* Ensuite, le type de la variable ne peut plus changer
* Intérêt: contrôle tout au long du code, ce qui empêche certaines erreurs
Variables (2/2)
* Exemple de manipulation de variables
var a : Number = 7;
var b : Number = 3;
function fois2(n:Number) {
var a : Number = 2 * n;
return a;
}
trace("Double de " + b + " = "
+ fois2(b));
trace("Valeur de a = " + a);
* Résultat de l'exemple
Double de 3 = 6
Valeur de a = 7
* Modification de la fonction
function fois2(n:Number) {
a = 2 * n;
return a;
}
* Résultat avec la modification
Double de 3 = 6
Valeur de a = 6
Types de données (1/2)
* Variable sans type de données au moment de sa déclaration
* var x; ==> type inconnu
* Type déterminé à l'initialisation de la variable
* Booléen
* x = true;
* x = false;
* Entier
* x = 27;
* Flottant
* x = 27.13;
* Chaîne de caractères
* x = "Nawouak";
* x = "27";
* Le type d'une variable peut changer en cours d'exécution
var x = 5;
...
x = "cinq";
Types de données (2/2)
* Variable avec type de données au moment de sa déclaration
* var x : Number; ==> type nombre
* Quelques types possibles
* Booléen: Boolean
* var x : Boolean = true;
* Nombre: Number / int / uint
* var x : Number = 27.13 ==> nombre flottant
* var x : int = -27; ==> entier signé
* var x : uint = 27; ==> entier non signé
* Chaîne de caractères: String
* var x : String = "Nawouak";
* Animation: MovieClip
* var x : MovieClip = new MovieClip();
* Le type de la variable ne peut plus changer en cours d'exécution
var x : Number = 5;
...
x = "cinq"; ==> erreur !
Opérateurs
* Opérateurs classiques
* Arithmétique: +, -, *, /, %
* Incrémentation / décrémentation: --, ++
* Affectation: =, +=, -=, *=, /=, %=
* Logique: && (et), || (ou), ! (non)
* Comparaison: ==, <, >, <=, >=, !=
* Chaînes de caractères
* Délimiteurs: ' ou "
* Opérateur de concaténation: +
* Permet de fusionner deux chaînes
* var nom : String = "Nawouak";
chaine = "Bonjour " + nom;
* chaine = "Bonjour ";
chaine += nom;
* chaine = "Bonjour Nawouak"
Chaînes de caractères
* Comment mettre un délimiteur dans une chaîne ?
* "comment mettre "un" entre guillemets ?"
* Plusieurs possibilités
* Alternance des délimiteurs "'" et """
* 'Voila comment mettre "un" entre guillemets ?'
* Rendre les délimiteurs inopérants avec "\"
* "Voila comment mettre \"un\" entre guillemets ?"
Structures de contrôle (1/4)
* Bloc d'instructions délimité par "{" et "}"
* Facultatif si une seule ligne
* if (x == 1) y = 2; ? if (x == 1) { y = 2; }
* Structures conditionnelles
* if (test1) action1
else if (test2) action2
else action3
* switch (variable)
case value1: action1
case value2: action2
default: action3
* Structures de boucle
* while (test) action
* do action while (test)
* for (départ; test; suivant) action
Structures de contrôle (2/4)
* Exemple
Un pingouin dans une scène Flash, il faut choisir sa prochaine action
* Code ActionScript
function action(pingouin:Pingouin) {
var choix : int = Math.floor(Math.random()*4);
if (choix == 0) { pingouin.manger(); }
else if (choix == 1) { pingouin.dormir(); }
else if (choix == 2) {
var direction : int = Math.floor(Math.random()*2);
if (direction == 0) { pingouin.reculer(); }
else { pingouin.avancer(); }
}
else { pingouin.danser(); }
}
Structures de contrôle (3/4)
* Exemple: conversion d'un chiffre en lettres
* Version avec "if" imbriqués
if (x == 1) texte = "un";
else if (x == 2) texte = "deux";
...
else if (x == 9) texte = "neuf";
else texte = "zéro";
* Version avec "switch"
switch (x) {
case 1: texte = "un"; break;
case 2: texte = "deux"; break;
...
case 9: texte = "neuf"; break;
default: texte = "zéro";
}
Structures de contrôle (4/4)
* Exemple: créer 10 pingouins dans une scène Flash
* Création avec boucle "for"
var p : Array = new Array();
for (var i : int = 0; i < 10; i++)
{ p[i] = new Pingouin(); scene.addChild(p[i]); }
* Création avec boucle "while"
var p : Array = new Array();
var i : int = 0;
while (i < 10)
{ p[i] = new Pingouin(); scene.addChild(p[i]); i++; }
* Calcul avec boucle "do...while"
var p : Array = new Array();
var i : int = 0;
do { p[i] = new Pingouin(); scene.addChild(p[i]); i++; }
while (i < 10);
Tableaux simples
* Déclaration d'un tableau
* var tab : Array = new Array();
* Remplissage d'un tableau
* Numérotation des indices commence à 0
* tab[0] = "lundi";
tab[1] = "mardi";
...
tab[6] = "dimanche";
* Déclaration accélérée
* var tab : Array = new Array("lundi",...,"dimanche");
* Connaître le nombre d'éléments
* var nb : int = tab.length;
* Parcours d'un tableau
trace("Il y a " + tab.length + " jours:");
for (var i : int = 0; i < tab.length; i++)
{ trace("jour no " + (i+1) + ": " + tab[i]); }
Tableaux associatifs
* Tableaux indexés par des chaînes
* Association d'une clé (chaîne) à un élément
* Tableau simple: association entier-élément
* Remplissage d'un tableau
tab["lundi"] = "Monday";
tab["mardi"] = "Tuesday";
...
tab["dimanche"] = "Sunday";
* Parcours des éléments
for (var i : String in tab)
{ trace(i + " = " + tab[i]); }
Fonctions (1/2)
* Permettent de factoriser / réutiliser du code
* Portions de code associées à un nom
* Reçoivent des arguments en entrée
* Retournent une valeur en sortie
* function nom(arguments) : type_retour {
action;
return resultat;
}
* Pas de type de retour: Void
* Exemple
function produit(a:Number,b:Number) : Number {
var p : Number = a * b;
return p;
}
Fonctions (2/2)
* Déclaration: function f(x:type) : type
* Exécution: y = f(a);
* L'argument "x" est une copie de "a"
* Modification de "x" limitée à "f"
* Type de "a" = type de "x"
* Le retour est aussi une copie
* Type de "y" = type de retour
* function produit(a:Number,b:Number) : Number {
var c : Number = a * b;
return c;
}
* var w : Number = produit(u,v);