Les conditions

• Les variables
• Sommaire
• Les boucles

Nous avons vu dans le précédent chapitre comment manipuler les nombres à l'aide d'opérateurs et de variables. Nous allons voir à présent comment tester le contenu de ces variables ; ainsi vous pourrez exécuter des instructions ou non pour les différentes valeurs que pourront prendre vos variables. Comme vous pourrez le voir, les conditions sont très utiles dans le monde de l'informatique, et sont la base de l'interactivité des machines, sans quoi elles feraient toujours la même chose…

• Écriture d'une condition
• L'instruction if...else
• L'instruction switch

Écriture d'une condition

Qu'est-ce qu'une condition ?

Les conditions permettent de tester le contenu d'une ou plusieurs variables. Ainsi vous pourrez exécuter des instructions différentes suivant le résultat du test. Grâce à ces structures conditionnelles, le programme sera alors en mesure de prendre des décisions. Nos programmes seront donc moins monotones et pourront réagir différemment suivant les circonstances : imaginez si tous les programmes faisaient exactement la même chose quel que soit le contexte, cela serait bien ennuyant ! Voici le genre d'instructions que nous serons capables de réaliser à l'aide des conditions :

1
2

SI ma condition est vraie
ALORS effectuer mes instructions

Dans une condition, nous pourrons ainsi tester différentes choses. Par exemple, nous pourrions tester un nombre entier pour savoir s'il est positif ou non. Nous cherchons donc une relation entre deux valeurs pour pouvoir les comparer. Pour cela nous utiliserons donc divers opérateurs présentés dans la suite. Si la condition est vraie, alors les instructions qui la suivent sont exécutées. Dans le cas contraire, elles sont tout simplement ignorées.

Ne vous inquiétez pas si vous avez du mal à saisir le concept, vous comprendrez mieux au fil du chapitre.

Les opérateurs relationnels

Les opérateurs relationnels permettent de comparer une variable à une valeur, ou encore deux variables entre elles. Dans le tableau ci-dessous sont répertoriés les différents symboles correspondant. Ces symboles seront utilisés en permanence, c'est pourquoi il serait judicieux de les retenir.

De manière générale, les opérateurs sont utilisés ainsi : une variable ou une valeur, l'opérateur et une autre variable ou valeur. Voici quelques exemples de conditions :

1
2
3
4

// Cette condition est vraie si monEntier contient un nombre supérieur à 2
monEntier > 2
// Cette  deuxième condition est vraie si maVariable et monAutreVariable contiennent la même valeur
monVariable == monAutreVariable

Vous pouvez également comparer des chaînes de caractères :

1
2
3
4
5
6

var t1:String = "Salut";
var t2:String = "Salut";
var t3:String = "Bonjour";
trace(t1 == t2); // Affiche : true
trace(t1 == t3); // Affiche : false
trace(t1 > t3); // Affiche : true, car Salut est après Bonjour dans l'ordre alphabétique

Comparer deux variables : une question de types

Un opérateur relationnel permet de comparer uniquement deux expressions du même type. Il n'est pas possible de comparer deux variables dont l'une par exemple, serait de type int et l'autre de type String. Si cela se produisait, le compilateur vous afficherait un message d'erreur de ce type : « Error: Comparison between… ». Toutefois, il existe une exception : les nombres, qui peuvent être comparés entre eux même si leur type varie entre int, uint et Number. Par exemple, le code suivant fonctionnera sans erreur :

1
2
3

var nombre:Number = 0.4;
var entier:int = 1;
trace(nombre < entier); // Affiche : true

Et bien, il suffit de transformer l'une de nos deux variables pour que les deux aient exactement le même type ! Par exemple, transformons le nombre en chaîne de caractères :

1
2
3

var nombre:Number = 3.14;
var texte:String = "3.14";
trace(nombre.toString() == texte); // Affiche : true

En effet, taper .toString() derrière notre variable de type Number transforme sa valeur en chaîne de caractères afin que la comparaison fonctionne correctement !

Précisions sur les opérateurs stricts

Les opérateurs stricts (=== et !==) servent à comparer deux objets quelconques (par exemple, deux variables), en regardant non seulement leur valeur, mais aussi leur type. Ces opérateurs sont peu utilisés : en général, on connaît à l'avance le type des variables que l'on manipule. Par exemple, je déclare et initialise trois variables de type Object, c'est-à-dire qu'elles n'ont pas de type bien défini et que l'on peut y mettre ce que l'on souhaite ; attention toutefois à ne pas abuser de ce type un peu spécial, il ralentit l'exécution de votre programme. Ensuite, je teste la valeur de ces variables avec ==, pour finalement tester leur valeur et leur type en même temps avec ===. De toute évidence, le caractère « 3 » n'est pas du même type que l'entier 3.

1
2
3
4
5
6

var nom:Object = "42";
var prenom:Object = "42";
var age:Object = 42
trace(nom === prenom); // Affiche : true
trace(nom == age); // Affiche : true
trace(nom === age); // Affiche : false

Les opérateurs logiques

Contrairement aux opérateurs précédents qui permettaient de comparer des valeurs, les opérateurs logiques servent à combiner plusieurs conditions. Ceux-ci peuvent avoir leur utilité lorsque nous voulons tester par exemple, si un nombre est compris dans un intervalle. Les opérateurs relationnels ne permettent pas ce genre de comparaison. C'est pourquoi nous pouvons contourner le problème en combinant plusieurs conditions. Prenons un exemple : nous voulons savoir si une variable monNombre est comprise entre 0 et 10. Pour cela nous pourrions décomposer ce test en deux conditions :

• monNombre est supérieur à 0
• monNombre est inférieur à 10.

Les opérateurs logiques nous permettent alors d'associer ces deux conditions en une seule : monNombre > 0 ET monNombre < 10.

Le tableau ci-dessous présente donc ces différents opérateurs, ainsi que les symboles qui leur sont associés :

Ainsi, nous allons comparer notre nombre par rapport à un intervalle à l'aide de l'opérateur && :

1
2

// Test pour savoir si monNombre est compris entre 0 et 10
monNombre > 0 && monNombre < 10

La priorité des opérateurs

Pour décider dans quel ordre les différentes opérations seront effectuées, les opérateurs respectent les règles de priorité suivantes :

• les opérateurs arithmétiques (+, -, *, /, %) sont prioritaires par rapport aux opérateurs relationnels (==, !=, <, >, etc…) ;
• les opérateurs relationnels sont prioritaires par rapport aux opérateurs logiques (!, && et ||) ;
• les opérations entourées de parenthèses sont toujours prioritaires.

Ainsi la condition 3 + 4 > 5 est vraie du fait que l'addition est effectuée avant la comparaison.

Quelques exemples d'opérations imbriquées :

1
2
3
4
5

trace(1 == 2); // Affiche : false
trace(1 + 1 == 2); // Affiche : true
trace(1 == 2 || 2 == 2); // Affiche : true
trace(1 != 2 && 1 + 1 == 2); // Affiche : true
trace(1 != 2 && 1 + 2 == 2); // Affiche : false

Pour mieux comprendre l'utilisation de ces conditions, nous allons étudier différentes structures qui les utilisent. Commençons tout de suite avec l'instruction if...else.

L'instruction if...else

La structure de base

La syntaxe

L'instruction if...else est la structure de base des conditions. Grâce à elle, nous pouvons exécuter des instructions différentes suivant si la condition est vraie ou fausse. Sans plus attendre, voyons la structure if...else écrite en Actionscript :

1
2
3
4
5
6
7
8

if(/* Condition */)
{
    // Instructions si la condition est vraie
}
else
{
    // Instructions si la condition est fausse
}

Vous remarquerez donc dans cette structure, les deux blocs d'instructions définis par les paires d'accolades. Si la condition est vérifiée alors le premier bloc d'instructions sera exécuté, sinon (traduction du mot « else ») ce sera le second. Bien entendu, l'écriture du bloc else n'est pas obligatoire. En revanche, il n'est pas possible d'écrire un bloc else seul. Vous pourriez donc vous contenter du code suivant :

1
2
3
4

if(/* Condition */)
{
    // Instructions si la condition est vraie
}

Parce que rien ne vaut un bon exemple, nous allons tout de suite tester une première condition dans notre IDE. Pour cela, nous prendrons une variable nommée maVie représentant par exemple, la vie restante dans un jeu quelconque. Nous pourrions alors tester si vous êtes encore en vie ou si vous êtes mort. Voici donc le code à insérer juste après le commentaire // entry point de votre classe Main :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

var maVie:uint = 1;

if(maVie == 0)
{
    trace("Vous êtes mort.");
}
else
{
    trace("Vous êtes toujours en vie.");
}

// Affiche : Vous êtes toujours en vie.

Ici la variable maVie est égale à 1, et donc la condition maVie == 0 est fausse. Ainsi lors de l'exécution, seule l'instruction à l'intérieur des accolades du else sera exécutée. Vous verrez donc apparaitre le message : « Vous êtes toujours en vie. ». N'hésitez pas à tester ce code avec différentes valeurs pour maVie afin de bien comprendre le fonctionnement.

Les règles et conventions d'écriture

Nous allons maintenant définir quelles sont les différentes règles d'écriture ainsi que des conventions fortement recommandées. Tout d'abord, vous aurez sûrement remarqué l'absence de point-virgule « ; » après les accolades. En effet, les conditions ne se terminent jamais par un point-virgule. D'autre part, les parenthèses qui entourent votre condition sont obligatoires. En revanche, les accolades peuvent être facultatives mais uniquement dans un cas ; il s'agit du cas où il n'y a qu'une seule instruction à l'intérieur du bloc d'instructions. Il est alors possible d'écrire votre condition suivant l'une des trois formes ci-dessous :

1
2
3
4

if(maVie == 0)
    trace("Vous êtes mort.");
else
    trace("Vous êtes toujours en vie.");

ou bien :

1
2
3
4
5
6

if(maVie == 0)
    trace("Vous êtes mort.");
else
{
    trace("Vous êtes toujours en vie.");
}

ou encore :

1
2
3
4
5
6

if(maVie == 0)
{
    trace("Vous êtes mort.");
}
else
    trace("Vous êtes toujours en vie.");

Pour finir ce paragraphe, nous parlerons d'une chose très importante en termes de présentation. Vous aurez certainement remarqué la mise en forme utilisée depuis le début pour écrire les conditions :

• l'accolade ouvrante sur une ligne
• vos instructions décalées vers la droite à l'aide d'une tabulation
• l'accolade fermante sur une ligne

Cette mise en forme est appelée l'indentation et n'est pas obligatoire, cependant il est très fortement déconseillé de tout écrire sur une seule ligne ou de ne pas décaler les instructions à l'intérieur des accolades. En effet, respecter ces règles vous permettra de rendre vos codes beaucoup plus clairs et lisibles par vous mais aussi par d'autres personnes qui ne connaîtront pas la façon dont vous avez réalisé votre programme.

Les ternaires

Dans certains cas il est possible de condenser des conditions : On appelle cela les expressions ternaires. Cette technique n'est pas applicable tout le temps, et il ne faut pas en abuser. Pour introduire cette notion, nous allons partir du code suivant :

1
2
3
4
5
6

var monMessage:String;
if(maVie == 0)
    monMessage = "Vous êtes mort.";
else
    monMessage = "Vous êtes toujours en vie.";
trace(monMessage);

Vous remarquerez qu'ici la condition sert uniquement à affecter une variable d'une valeur qui dépend d'une condition. Les expressions ternaires ne peuvent être utilisées que dans ce cas-là ! Il est alors possible de réécrire le code précédent sous une forme condensée :

1
2

var monMessage:String = (maVie == 0) ? "Vous êtes mort." : "Vous êtes toujours en vie.";
trace(monMessage);

Le principe est alors d'écrire l'ensemble de la condition en une seule ligne et d'affecter directement la variable. C'est une forme d'écriture qui peut être pratique, mais sachez qu'en réalité elle est très peu utilisée car elle est difficile à lire. Utilisez donc les expressions ternaires pour diminuer le volume de votre code, mais tâchez de garder un code qui soit le plus facilement lisible !

Le type booléen

En Actionscript, il existe un type de variable de type booléen : Boolean. Ces variables ne peuvent prendre que deux valeurs : true ou false. Les booléens sont très utilisés avec les conditions car ils permettent facilement d'exprimer si une condition est vraie ou fausse. D'ailleurs une condition est elle-même exprimée sous la forme d'un booléen. Pour s'en assurer, vous allez tester le code suivant :

1
2
3
4
5
6

if(true)
    trace("Ma condition est vraie.");
else
    trace("Ma condition est fausse.");

// Affiche : Ma condition est vraie.

Nous pouvons remarquer qu'en effet la condition true est vraie, c'est pourquoi l'utilisation de variables de type booléen peut être préférable. Il n'est alors plus nécessaire d'écrire le test « == true » pour une variable de type booléen. Ainsi, si vous utilisez des noms judicieux pour vos variables, le code paraîtra plus clair :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

var estEnVie:Boolean = true;

if(estEnVie)
{
    trace("Vous êtes toujours en vie.");
}
else
{
    trace("Vous êtes mort.");
}

// Affiche : Vous êtes toujours en vie.

Étant donné que le résultat d'une condition est un booléen, il est tout à fait possible de le stocker dans une variable :

1
2
3

var maVie:uint = 1;
var estEnVie:Boolean = (maVie > 0);
trace(estEnVie); // Affiche : true

La structure avec else if

Avant de clore cette partie sur la structure if...else, nous allons voir comment réaliser des tests supplémentaires avec else if. Ici rien de bien compliqué, c'est pourquoi vous comprendrez aisément le code ci-dessous :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

var monNombre:int = 1;

if(monNombre < 0)
{
    trace("Ce nombre est négatif.");
}
else if(monNombre == 0)
{
    trace("Ce nombre est nul.");
}
else
{
    trace("Ce nombre est positif.");
}

// Affiche : Ce nombre est positif.

Bien qu'il soit possible d'effectuer plusieurs tests à la suite à l'aide de cette méthode, cela peut s'avérer assez répétitif. C'est pourquoi, il existe une structure qui permet d'alléger l'écriture de telles conditions : il s'agit de l'instruction switch que nous allons détailler dans la suite.

L'instruction switch

L'utilisation conventionnelle

Face à la structure if...else, la condition switch permet de simplifier et d'alléger le code lorsque vous voulez tester différentes valeurs pour une même variable. Cette structure n'offre pas plus de possibilités que celle en if...else, il s'agit simplement d'une manière différente d'écrire des conditions. Voici comment se présente l'instruction switch :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

switch(/* Variable */)
{
    case /* Argument */ :
        // Instructions
        break;
    case /* Argument */ :
        // Instructions
        break;
    case /* Argument */ :
        // Instructions
        break;
    default :
        // Instructions
}

Pour utiliser cette structure, il suffit de renseigner la variable à tester puis d'étudier les différents arguments. Notez la présence de l'instruction « break; » qui permet de sortir du switch. Cette instruction est obligatoire, en cas d'absence les instructions situées en dessous seraient exécutées. Enfin, le default correspond au cas par défaut, nous pouvons le comparer au else d'une instruction if...else. Voici un exemple de code que vous pouvez tester :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

var monNombre:int = 1;
switch(monNombre)
{
    case 0 :
        trace("Ce nombre vaut 0.");
        break;
    case 1 :
        trace("Ce nombre vaut 1.");
        break;
    case 2 :
        trace("Ce nombre vaut 2.");
        break;
    default :
        trace("Ce nombre ne vaut ni 0, ni 1, ni 2.");
}

Une utilisation spécifique à l'Actionscript

Contrairement à d'autres langages tels que le C ou encore le Java, l'instruction switch en Actionscript ne permet pas uniquement de faire des égalités. En plaçant la valeur true à la place de la variable, il est alors possible de la comparer avec un autre booléen, en particulier une condition. Voici la structure switch pouvant tester diverses conditions :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

switch(true)
{
    case (/* Condition */) :
        // Instructions
        break;
    case (/* Condition */) :
        // Instructions
        break;
    case (/* Condition */) :
        // Instructions
        break;
}

Voici un exemple concret qui permet de tester si une variable monNombre est un nombre négatif, nul ou positif :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

var monNombre:int = 1;
switch(true)
{
    case (monNombre < 0) :
        trace("Ce nombre est négatif.");
        break;
    case (monNombre == 0) :
        trace("Ce nombre est nul.");
        break;
    case (monNombre > 0) :
        trace("Ce nombre est positif.");
        break;
}

En résumé

• Grâce aux conditions, nous pouvons effectuer des choses différentes suivant l'état d'une ou plusieurs variables.
• Les conditions sont réalisées à l'aide d'opérateurs relationnels et logiques, dont le résultat est un booléen.
• L'instruction if...else est la plus utilisée.
• Les expressions ternaires permettent de condenser l'écriture d'une instruction if...else.
• Lorsque vous avez une multitude de valeurs à tester, l'instruction switch est plus appropriée.

• Les variables
• Sommaire
• Les boucles