• 12 heures
  • {0} Facile|{1} Moyenne|{2} Difficile

Ce cours est visible gratuitement en ligne.

Ce cours existe en livre papier.

Vous pouvez être accompagné et mentoré par un professeur particulier par visioconférence sur ce cours.

J'ai tout compris !

Mis à jour le 30/04/2014

Les variables

Connectez-vous ou inscrivez-vous gratuitement pour bénéficier de toutes les fonctionnalités de ce cours !

Les variables sont un des éléments les plus importants dans tous les langages de programmation : elles permettent de mémoriser des informations de toutes sortes. Sans elles, les programmes seraient tous très basiques et moins puissants, le monde informatique serait alors d'un ennui mortel. :lol:

Un petit exemple concret : vous voulez que votre programme vous dise bonjour, après lui avoir donné votre nom. Une variable (appelée monNom par exemple) se chargera alors de mémoriser le mot que vous lui entrerez pour plus tard permettre au programme de vous appeler par votre nom : il lui suffira de regarder ce qu'il se trouve dans la variable monNom.

Déclarer et utiliser des variables

Déclaration

Le mot-clé var

La première chose à faire avant d'utiliser des variables, c'est de les créer :

var maVariable;

Pour cela, nous avons à notre disposition un mot-clé (ou mot réservé) obligatoire : var. Cette instruction permet de déclarer une variable ; elle s'utilise de la façon suivante : var suivit d'un espace et du nom de la variable.

Désormais, vous savez créer une variable, mais le code précédent n'est pas très utile. En effet, chaque variable possède un type, indispensable, qui décrit son comportement et son utilité (par exemple : nombre, entier, chaîne de caractères, etc.). Sans ce type, le langage ne saurait pas à qui il a affaire en lisant une variable et surtout comment l'utiliser.

Le typage

Il faut donc assigner un type à chaque nouvelle variable pour que le programme puisse la reconnaître. Pour cela, on utilise les deux points ainsi :

var maVariable:sonType;

Ce type suivra la variable tout au long de l’exécution du programme.

Avant, en Actionscript 2, il était possible de déclarer des variables sans les typer, le lecteur Flash se chargeait de deviner le type de ces variables. Bien entendu, cette technique est à proscrire pour des raisons de performances et de rigueur (imaginez plusieurs centaines de variables à qui vous avez affaire, mais dont vous ne connaissez pas le type). Désormais, les variables doivent être typées à la création : on appelle cela le typage strict. C'est une des principales raisons de l'amélioration des performances des animations depuis le passage à l'Actionscript 3.

Les différents types que vous pourrez utiliser seront détaillés un peu plus loin.

Initialiser la nouvelle variable

Après avoir créé une variable, il vous prendra peut-être l'envie d'y mettre quelque chose pour la réutiliser plus tard :

var maVariable:sonType = ceQueJeMetsDedans;

Vous remarquerez qu'on peut remplir une variable directement à sa création (ce qui est drôlement pratique), en mettant un signe égal après le type ; on appelle cette opération l'initialisation. Ainsi, dès qu'elle sera créée, la variable maVariablesera du type sonTypeet contiendra ceQueJeMetsDedans.

Vous n'êtes évidemment pas obligés d'initialiser les variables, vous pourrez leur donner une valeur (ou un contenu si vous préférez) plus tard à l'aide de l'affectation.

Les valeurs par défaut

Lorsque vous créez une variable et que vous ne l'initialisez pas, elle n'est pas tout à fait vide ; en effet, elle contient automatiquement une valeur par défaut qui sera souvent null, sauf quelques cas particuliers selon le type de la variable. Ainsi, si vous écrivez ceci :

var maVariable:sonType;
maVariable

contiendra sa valeur par défaut, donnée par son type.

Utiliser les variables

Affectation

Tout au long de l’exécution du programme, vous aurez sûrement besoin de modifier le contenu d'une variable en fonction des besoins du moment. La méthode est presque identique à l'initialisation, car on utilise à nouveau le signe égal :

maVariable = nouveauContenu;

Ainsi, la valeur nouveauContenu sera stockée dans la variable maVariable.

Lecture

Il est tout aussi intéressant de pouvoir lire une variable pour utiliser son contenu : par exemple, le programme aura besoin de regarder ce que contient la variable monNom pour pouvoir afficher « Bonjour Georges ! » si j'ai mis « Georges » dans la variable avant.
Par exemple, pour copier le contenu de la variable a dans la variable b, il faut donc écrire :

b = a; // Je prends ce qu'il y a dans la variable a, et je le mets dans b

Vous pouvez voir ainsi que la façon de procéder est très simple : il suffit de renseigner le nom de la variable.

Avec les déclarations des variables, cela donnerait :

var a:typeDeA = contenuA;
var b:typeDeB = contenuB;
b = a; // Je prends ce qu'il y a dans la variable a, et je le mets dans b
// La variable b contient maintenant "contenuA"

Les nombres

Les différents types

Comme vous pouvez vous en douter, les nombres sont très utilisés dans le monde de l'informatique, étant donné que le numérique est basé sur des suites de 0 et de 1. Il existe différents types de nombres en ActionScript 3, chacun ayant sa spécificité.

Le type int

Le type int sert à manipuler des entiers relatifs. Voici un exemple de déclaration et d'initialisation de ce type de variables :

var monEntier:int = -100;

Ce type permet de manipuler des nombres codés sur 32 bits (c'est-à-dire 32 « 0 » ou « 1 »), donc compris entre -2 147 483 648 et 2 147 483 647. Si vous sortez de cet encadrement, vous obtiendrez une erreur. La valeur par défaut de ce type est 0.

Le type uint

Le type uint sert à manipuler des entiers naturels ou non-signés (c'est-à-dire positifs), voici un exemple de déclaration et d'initialisation :

var monEntier:uint = 42;

Le type uint permet d'utiliser des entiers naturels codés sur 32 bits également, donc compris entre 0 et 4 294 967 295. Comme le type int, la valeur par défaut est 0, et vous obtiendrez aussi une erreur si vous sortez de cet encadrement.
Dans certaines situations, l'utilisation de ce type ralentit légèrement l’exécution de votre programme. Ainsi, je vous conseille d'utiliser le type int si les nombres que vous voulez manipuler sont inférieurs à 2 147 483 647.

Le type Number

Le type Number sert à manipuler tous les nombres (entiers comme flottants), dans un intervalle extrêmement grand. On peut presque considérer qu'on peut y mettre tous les nombres.
Voici comment les utiliser :

var monNombre:Number = 3.1415;

La valeur par défaut de ce type est NaN.

Ainsi, le code suivant ne ferait pas d'erreur, mais la variable nbr aurait pour valeur NaN :

var nbr:Number = Number("Je veux un nombre !"); // On force la variable à contenir du texte...
trace(nbr); // Affiche : NaN

Vous êtes curieux de savoir quels sont le minimum et le maximum autorisés ? Voici le code pour les afficher :

trace(Number.MIN_VALUE + " à " + Number.MAX_VALUE);
// Affiche : 4.9406564584124654e-324 à 1.79769313486231e+308
// Le "e" signifie "fois dix puissance" ; par exemple, 1e+10 équivaut à 1x10^10 = 10 000 000 000
// 1.79769313486231e+308 est donc un nombre à 309 chiffres :p

Opérations sur les nombres

Les opérateurs de base

Pour effectuer une opération entre deux nombres, on procède comme sur les cahiers de Maths à l'école ! :D
L'opération est effectuée lors de l'exécution du programme et le résultat peut être stocké dans une variable monNombre par exemple. Voici un tableau qui regroupe les opérations de base :

Nom de l'opération

Symbole

Exemple

Addition

+

monNombre = 1 + 4; // monNombre = 5

Soustraction

-

monNombre = 8 - 3; // monNombre = 5

Multiplication

*

monNombre = 2 * 3; // monNombre = 6

Division

/

monNombre = 8 / 4; // monNombre = 2

Modulo

%

monNombre = 8 % 5; // monNombre = 3

Ces opérations peuvent être effectuées sur des variables des trois types de nombres que nous avons vu précédemment, même en les mélangeant. Voici quelques exemples de calculs :

var unEntier:uint = 3 + 42;
var unAutreEntier:int = -25;
var monResultat:Number = unEntier * unAutreEntier;
monResultat = monResultat / 100;
trace(monResultat); // Affiche : -11.25

Notez également qu'il faut être prudent sur le type de variables utilisé pour les calculs. Je rappelle qu'un nombre à virgule sera automatiquement arrondi à l'entier inférieur si vous tentez de l'affecter à une variable de type int ou uint. Repérez donc ce qui se déroule au fil de ces instructions :

var unEntier:uint = 2;
var unNombre:Number = 3.14;
var monResultat:int = unEntier + unNombre;
trace(monResultat); // Affiche : 5
Simplifier les calculs

Comme dans beaucoup de langages, il est possible en Actionscript de simplifier des calculs de ce genre :

monResultat = monResultat / 100;

Ainsi l'écriture de cette instruction peut être simplifiée et réduite sous la forme :

monResultat /= 100;

Ce code est donc plus rapide à écrire, et provoque le même résultat que précédemment. Bien évidemment, cette manipulation n'est pas réservée à la division, mais peut être effectuée avec n'importe quel autre opérateur arithmétique : +=, -=, *=, /= et %=.

Nous avons à présent fait le tour des opérateurs disponibles en Actionscript. ^^

Mais qu'en est-il des autres opérations mathématiques plus complexes, comme la racine carrée ?

En effet, il n'existe pas d'opérateurs arithmétiques en Actionscript 3 pour effectuer de telles opérations. Heureusement, une classe un peu spéciale appelée Math est fournie par Flash.

La classe Math

Cette classe n'a pas besoin d'être importée, elle est accessible en permanence. Elle contient une flopée d'outils mathématiques très utiles comme les puissances, les fonctions trigonométriques, les nombres aléatoires...

Les puissances

Ces fonctions de la classe Math vous permettent de manipuler les puissances sur des nombres :

var monNombre:Number = 42;
// Elever à la puissance
trace(Math.pow(monNombre, 5));
// Racine carrée
trace(Math.sqrt(monNombre));
Les arrondis

Il existe trois types d'arrondis : l'arrondi classique, l'arrondi à l'entier inférieur le plus proche et l'arrondi à l'entier supérieur le plus proche :

var monNombre:Number = 3.1415;
// Arrondi
trace(Math.round(monNombre)); // 3
// Entier inférieur
trace(Math.floor(monNombre)); // 3
// Entier supérieur
trace(Math.ceil(monNombre)); // 4
Trigonométrie

Cosinus, sinus, tangente, arc-cosinus, arc-sinus et arc-tangente sont des fonctions trigonométriques que nous propose la classe Math :

var angle1:Number = Math.PI / 2;
var angle2:Number = Math.PI / 6;

// Cosinus
trace(Math.cos(angle1));
// 6.123233995736766e-17

// Sinus
trace(Math.sin(angle1));
// 1

// Tangente
trace(Math.tan(angle1));
// 16331239353195370

// ArcCosinus
trace(Math.acos(angle2 / angle1));
// 1.2309594173407747

// ArcSinus
trace(Math.asin(angle2 / angle1));
// 0.3398369094541219

// ArcTangente
trace(Math.atan(angle1));
// 1.0038848218538872
Nombre aléatoire

Il serait très intéressant de fabriquer des nombres aléatoires, pour des jeux par exemple. Cela est possible avec la fonction Math.random() :

trace(Math.random()); // Affiche un nombre flottant aléatoire compris entre 0 et 1

Pour générer un nombre aléatoire entre deux valeurs a et b, il faut utiliser la formule suivante :

trace(a + Math.random() * (b - a));
Création d'un nombre aléatoire
Création d'un nombre aléatoire

Les chaînes de caractères

Les chaînes de caractères sont également très utilisées. Il s’agit d'une suite de caractères qui forme du texte. Par exemple, « Hello world ! » est une chaîne de caractères ; son premier caractère est le « H », et son dernier caractère est le « ! ».

Une chaîne de caractères est toujours entourée de guillemets, comme nous l'avons vu dans le chapitre précédent :

trace("Hello world !");

Mais vous pouvez aussi mettre des apostrophes à la place des guillemets :

trace('Hello world !');

Échappement des caractères spéciaux

Mais si je veux mettre des guillemets ou des apostrophes dans ma chaîne de caractères ?

Je vous voyais venir ! Effectivement, mettre des guillemets dans une chaîne de caractères à guillemets ou des apostrophes dans une chaîne de caractères à apostrophes serait problématique : en effet, le compilateur pensera que vous avez terminé votre chaîne au deuxième guillemet ou apostrophe rencontré, et se demandera pourquoi diable d'autres caractères se baladent derrière ! :euh:

Dans cet exemple, vous pouvez voir que la coloration syntaxique nous montre le problème :

trace("Hello.swf a dit : "Hello world !"");

En effet, le « Hello world ! » n'est dans ce cas plus considéré comme faisant partie de la chaîne de caractères...

Pour remédier à cela, il faut échapper le ou les caractères qui posent problème. Cela consiste à mettre un autre caractère spécial, l'antislash (\), qui permettra de dire que le caractère suivant doit être pris pour un caractère tout à fait banal dans notre chaîne.

Ainsi, le code correct serait :

trace("Hello.swf a dit : \"Hello world !\"");

Vous pouvez également remplacer les guillemets par des apostrophes dans les cas où ça vous arrange de faire ainsi :

trace('Hello.swf a dit : "Hello world !"');

Plus besoin d'échapper, car ce n'est plus le caractère guillemet qui précise où débute et où se termine la chaîne, mais l'apostrophe. Par contre, si vous voulez mettre une apostrophe en plus, le problème va revenir :

trace('Hello.swf m'a dit : "Hello world !"');

Encore une fois, le compilateur ne va vraiment rien comprendre à ce que vous lui écrivez. Solution : échapper le caractère apostrophe qui pose problème ! ^^

trace('Hello.swf m\'a dit : "Hello world !"');
trace('Hello.swf m\'a dit : \"Hello world !\"');

Utiliser les variables

Maintenant, si nous voulons mémoriser des chaînes de caractères, il va falloir les ranger dans des variables de type String.
Par exemple, pour mémoriser notre phrase « Hello world ! » dans la variable coucou, il faut procéder ainsi :

var coucou:String = "Hello world !";
trace(coucou); // Affiche : Hello world !

Concaténation de chaînes

Concaténer deux chaînes de caractères consiste à les assembler pour ne former qu'une seule chaîne. Par exemple, concaténer la chaîne « Hello » avec la chaîne « world ! » donnerait une nouvelle chaîne plus grande : « Hello world ! ».
Pour cela, il faut utiliser l'opérateur + (qui sert aussi à additionner deux nombres), de cette façon :

"Hello" + " world !"

Ainsi, si l'on voulait afficher notre texte en deux parties, nous écririons ceci :

trace("Hello" + " world !");

Il est alors possible de concaténer des chaînes avec des variables de tout type (y compris avec des nombres) et de différentes manières :

var coucouDebut:String = "Hello ";
var coucouFin:String = " !";
var monNom:String = "Jérôme";
var monAge:int = 42;
trace(coucouDebut + monNom + coucouFin + " Tu as " + monAge + " ans, n'est-ce pas ?");
// Affiche : Hello Jérôme ! Tu as 42 ans, n'est-ce pas ?

trace(Number.MIN_VALUE + " à " + Number.MAX_VALUE);
// Affiche : 4.9406564584124654e-324 à 1.79769313486231e+308

Quelques variables et fonctions utiles

Ces variables ou fonctions sont obligatoirement attachées à une variable de type String à l'aide d'un point. Vous ne pouvez pas les utiliser sur une chaîne de caractères simple comme "Hello world !".

Longueur d'une chaîne

Pour connaître la longueur d'une chaîne de caractères, c'est-à-dire, le nombre de caractères qu'elle contient, il faut utiliser la variable length disponible sur notre chaîne de cette manière :

var coucou:String = "Hello world !";
trace("Cette chaîne contient " + coucou.length + " caractères.");
// Affiche : Cette chaîne contient 13 caractères.

Le point est important : il signifie que c'est la longueur de cette chaîne particulière que l'on veut. ;)

Changer la casse d'une chaîne

La casse est l'état d'une lettre, c'est-à-dire si elle est en minuscule ou en majuscule. Il est possible de modifier la casse de l'ensemble d'une chaîne de caractères en utilisant les fonctions toLowerCase() (en casse minuscule) et toUpperCase() (en casse majuscule) :

var coucou:String = "Hello world !";
// En minuscules
trace(coucou.toLowerCase()); // hello world !
// En majuscules
trace(coucou.toUpperCase()); // HELLO WORLD !
Rechercher dans une chaîne

Il peut être utile de rechercher un ou plusieurs caractères dans une chaîne. Pour cela, on utilise la fonction indexOf() (position de) :

maVariable.indexOf("Chaîne recherchée");

La fonction renvoie la position du premier caractère de la chaîne recherché dans la variable, ou -1 si elle ne l'a pas trouvé.

Cherchons la position de la première lettre « a » dans notre variable :

var coucou:String = "Hello world !";
trace(coucou.indexOf("a")); // -1, on n'a rien trouvé :(

Effectivement, il n'y a pas de « a » dans notre chaîne... Retentons notre chance avec le mot « world » :

trace(coucou.indexOf("world")); // 6 ! Victoire !

Bravo, nous avons trouvé le mot « world » à la septième lettre !

Remplacer dans une chaîne

Cette fonction replace() est similaire à la fonction de recherche, mais il faut en plus indiquer le texte qui va remplacer l'ancien.

maVariable.replace("Chaîne recherchée", "Chaîne à insérer à la place");

Modifions dynamiquement notre chaîne pour remplacer « world » par « Jérôme » :

trace(coucou.replace("world", "Jérôme")); // Hello Jérôme !

La variable de départ n'est pas modifiée : la fonction se contente de renvoyer la nouvelle chaîne que l'on peut afficher ou mettre dans une variable :

var coucou:String = "Hello world !";
var salut:String = coucou.replace("world", "Jérôme");
trace(salut); // Hello Jérôme !
trace(coucou); // Hello world !
var coucou:String = "Hello world world world !";
trace(coucou.replace("world", "Jérôme")); // Hello Jérôme world world !

Pour pouvoir remplacer tous les « world » en « Jérôme », il faut faire autant de replace()que nécessaire :

var coucou:String = "Hello world world world !";
coucou = coucou.replace("world", "Jérôme");
trace(coucou); // Hello Jérôme world world !
coucou = coucou.replace("world", "Jérôme");
trace(coucou); // Hello Jérôme Jérôme world !
coucou = coucou.replace("world", "Jérôme");
trace(coucou); // Hello Jérôme Jérôme Jérôme !
En résumé
  • Une variable permet de mémoriser une valeur.

  • Le mot-clévar sert à déclarer une variable qui peut être affectée d'une valeur par un signe « = ».

  • On utilise les trois types int, uint et Number pour des valeurs numériques.

  • Pour effectuer des calculs, il existe principalement les opérateurs de base : +, -, *, / et %.

  • Grâce à la classe Math, il est possible de réaliser des opérations mathématiques complexes.

  • Le type String est réservé à l'utilisation des chaînes de caractères.

  • Différentes fonctions permettent de manipuler les chaînes de caractères et il est possible de les concaténer grâce à l'opérateur +.

Exemple de certificat de réussite
Exemple de certificat de réussite