Forums Développement Multimédia

Les formations Mediabox
Les formations Mediabox

Structures de contrôle : If

Par Nataly, le 21 mai 2011

Variables, fonctions, syntaxe
Objets, méthodes, propriétés…
Clics et événements souris sur les boutons et les clips
Champs texte et objet String
Structures de contrôle alternatives : if (ici)
MovieClip : manipuler
• Structures de contrôle alternatives : switch
• Structures de contrôle répétitives : for - while
Liste d'affichage, imbrication et profondeur des objets
Liste d'affichage, gestion dynamique des objets
Les tableaux

Structures de contrôle, qu'est-ce que c'est ?

Comme leur nom l'indique elles sont destinées à contrôler l'exécution du code.

En AS elles sont de deux types : répétitives ou alternatives.
A peine si je développe, la terminologie est très parlante : les premières permettent d'exécuter la ou les mêmes lignes plusieurs fois, couramment on parle de boucles ; les secondes permettent d'exécuter un bloc de code ou un autre selon les circonstances, ce sont par exemple les fameux if, et c'est par là que nous allons attaquer.

La syntaxe

A la fin du mois, s'il me reste des sous je m'offrirai de jolis escarpins (messieurs, remplacez par console de jeu ou accessoire moto :mrgreen:)
Ce type de situation, on en gère à longueur de vie et on s'en sort très bien (quoique). La fin de mois arrivée, on regarde le solde de son compte, selon qu'il est positif (supérieur à zéro) ou non, on défouraille ou pas la carte bleue. Quelque fois on a prévu une alternative : ce week-end s'il fait beau j'irai à la piscine sinon j'irai au cinéma. Pareil ça nous prend deux secondes de consulter la météo et de foncer à un endroit ou l'autre selon les prévisions.

En code c'est le même principe, on pose une condition et on prévoit ce qui sera fait selon qu'elle sera vérifiée ou pas.

Le plus souvent on présente la syntaxe comme suit :

if(condition){
     // instruction si condition vérifiée
} else{
    // instruction si condition pas vérifiée
}


Pour peu qu'on soit suffisamment anglophone pour savoir que if signifie si et else sinon, ça se lit quasi couramment.
Juste pour le plaisir de traduire en code mon exemple à la noix d'introduction, imaginons une variable soldeDeMonCompte, et posons comme consigne :
Si soldeDeMonCompte supérieur à 0 on trace “je me fais un cadeau” sinon on trace “dommage”. 'Supérieur à' s'écrit > en AS (et dans tous les langages que je connaisse), ça nous donne donc.

var soldeDeMonCompte:Number=1000 //oui bon, on peut rêver… :D
 
if(soldeDeMonCompte > 0){
    trace("je me fais un cadeau")
} else {
   trace ("dommage")
}


Changez la valeur de soldeDeMonCompte pour une valeur négative et constatez que dans la fenêtre de sortie c'est dommage qui s'écrit.

La séquence de frappe magique :
Si vous tapez successivement la touche esc (échappe) puis i puis f vous aurez le bonheur de voir toute la structure if s'écrire, parenthèses et accolades, vous n'avez plus qu'à “remplir”
Et… Tada ! chaque fois plus fort : si vous posez le curseur juste avant l'accolade fermante puis tapez [esc e l] eh bien c'est la branche else qui vient prendre place ;)


Jusque là ça va j'imagine, débarrassons nous donc de la liste des opérateurs de comparaison et on aura tout ce qu'il faut pour avancer bien tranquillement :

En français AS
Inférieur (au sens strict) <
Inférieur ou égal < =
Supérieur (au sens strict) >
Supérieur ou égal >=
Egal == Piège
Différent != ! se lit not (en anglais) soit 'non' ou 'pas' (pas égal)


Rien de compliqué mais attention un piège quand même : l'opérateur d'égalité.

Ne confondez pas = et ==


En effet l'opérateur = (égal tout court) est un opérateur d'affectation, il permet d'affecter (attribuer) une valeur à une variable. Il ne compare rien du tout.

Pour comparer deux variables (ou données) on utilise == (égal égal).

Par exemple pour vérifier qu'une variable (String) vaut précisément une chaine de caractères (mettons 'bonjour' pour faire original), on écrira :

var uneChaine:String="bonjour";
 
if(uneChaine=="bonjour"){
    trace("la variable vaut 'bonjour'");
}else{
    trace("la variable vaut autre chose : "+uneChaine);
}


Vous constatez qu'il suffit que vous écriviez :

var uneChaine:String="Bonjour";

… pour que l'égalité ne soit pas reconnue.

la variable vaut autre chose : Bonjour

Ça ne vous surprend pas, vous savez depuis longtemps que lettre majuscule ou minuscule ce n'est pas du tout la même chose pour AS (lien à venir).

Oui mais alors pourquoi ça marche quelque fois ? récrimine-t-on dans le fond.
D'abord, ça ne marche jamais. Au pire ça laisse croire, si on a la malchance de multiplier des tests sournois…
Bon d'accord, je vous expliquerai, mais tout à l'heure, il vaut mieux ne pas perdre le fil et retenir le principal : l'opérateur de comparaison d'égalité c'est ==.

Et c'est le moment d'utiliser nos toutes fraîches connaissances sur les champs texte (lien à venir) pour jouer à en vérifier le contenu.

Prenons l'alibi de vérifier un mot de passe.
• Posons sur la scène un champ texte (outil texte, caractéristique “texte de saisie” dans le panneau de propriétés) et nommons le txtSaisie.
• Posons un autre champ texte, dynamique cette fois, pour causer à l'utilisateur (txtSortie).
• Installons un bouton (btTest, par exemple)
On décide arbitrairement d'un mot de passe (sésame), et je vous laisse écrire les quelques lignes qui traceront dans la fenêtre de sortie “OK pour la suite” quand le mot de passe saisi est correct, et “Mot de passe incorrect” dans txtSortie dans le cas contraire (au clic sur le bouton, bien sûr).


Une possibilité :

btTest.addEventListener(MouseEvent.CLICK, test);
 
function test(me:MouseEvent):void {
	if (txtSaisie.text!="sésame") {
		txtSortie.text="Mot de passe incorrect";
	} else {
		trace("OK pour la suite");
		// suite du traitement potentiellement long
	}
}

une autre :

btTest.addEventListener(MouseEvent.CLICK, test);
 
function test(me:MouseEvent):void {
	if (txtSaisie.text=="sésame") {
		trace("OK pour la suite");
		// suite du traitement potentiellement long
	} else {
		txtSortie.text="Mot de passe incorrect";
	}
}


Else facultatif

Et c'est là qu'il devient urgent de se débarrasser du else, pour le moins de se mettre bien d'accord que la branche else est facultative.

Si le mot de passe est mauvais on ne fait rien (si ce n'est prévenir l'utilisateur), s'il est bon on se lance dans les grandes manœuvres, a-t-on dit. On risque donc de se retrouver avec de nombreuses lignes dans une des branches de la structure de contrôle.
Ce n'est pas mal en soi, mais fort peu lisible, et d'autant moins qu'on risque d'avoir recours à de nouveaux tests, et à imbriquer des if dans des else…

Sachez qu'on peut éviter ça, la branche else est facultative. On peut se contenter de penser : si le mot de passe n'est pas bon je préviens l'utilisateur et j'arrête tout.
Vous vous en souvenez peut-être (lien à venir) c'est le mot return qui permet d'interrompre l'exécution d'un bloc de code.

function test(me:MouseEvent):void {
	if (txtSaisie.text!="sésame") {
		txtSortie.text="Mot de passe incorrect";
                return; // on sort de la fonction le reste du code n'est pas exécuté
	} 
	// un traitement potentiellement long	
}


Et puis pour ceux qui exigent encore plus de lisibilité, vous pouvez tout écrire sur la même ligne :

function test(me:MouseEvent):void {
	if (txtSaisie.text!="sésame") txtSortie.text="Mot de passe incorrect"; return;
 
	// un traitement potentiellement long	
}


Notez que dans ce cas on peut se passer des accolades et qu'il est indispensable de séparer les instruction par un point-virule.

Moi je n'aime pas du tout, ne serait-ce que parce que ça proscrit l'utilisation de la mise en forme automatique (depuis Flash), mais vous risquez de le rencontrer, n'en soyez pas surpris1).

Si ça vous perturbe, oubliez : je resterai sur la bonne vieille syntaxe standard (et auto-formatable2))

Bien sûr l'histoire du mot de passe, c'est un alibi à s'entrainer. Dans la réalité il est vraiment rare que le mot de passe soit stocké en dur, et le serait-il que pour des questions de sécurité on complique un peu les choses ;)
Notez malgré tout que c'est le même principe qui est utilisé pour vérifier qu'un champ texte n'est pas vide avant d'en traiter le contenu, ce qui n'est plus du tout de l'ordre de l'alibi.




identifier les champs vides

Un champ texte vide contient une chaine vide.
Une chaine, on l'exprime en entre guillemets.
Vide c'est rien, et rien entre guillemets ça donne ”” (guillemets guillemets) ;)
Vous pouvez donc écrire :

function test(me:MouseEvent):void {
	if (txtSaisie.text=="") {
		txtSortie.text="Saisissez quelque chose";
                return; // on sort de la fonction le reste du code n'est pas exécuté
	} 
	// suite du traitement
        trace("tout va bien on continue");	
}


…voire :

function test(me:MouseEvent):void {
	if (txtSaisie.text=="") txtSortie.text="Saisissez quelque chose"; return;
 
	// suite du traitement
        trace("tout va bien on continue");	
}

Et même si j'ai dit que je n'aime pas bien la syntaxe sur une ligne, force est de reconnaitre que pour vérifier que tous les champs requis d'un formulaire sont remplis ce n'est pas si mal (souvent femme varie, il faut vous y faire :-P). Imaginez par exemple une poignée de champs : nom, prénom, pseudo, mot de passe…

function enregistrement(me:MouseEvent):void {
	if (txtNom.text=="")     txtSortie.text="Le champ nom ne peut être vide"; return;
	if (txtPrénom.text=="")  txtSortie.text="Le champ prénom ne peut être vide"; return;
	if (txtPseudo.text=="")  txtSortie.text="Le champ pseudonyme ne peut être vide"; return;
	if (txtMdP1.text=="")     txtSortie.text="Le champ mot de passe ne peut être vide"; return; 
 
        if (txtMdP1.text != txtMdP2.text ) {
              txtSortie.text="Attention à vérification du mot de passe";
              txtMdP1.text=""; // vider les champs mot de passe pour forcer une nouvelle saisie
              txtMdP2.text=""; 
              return;
        }
	// suite du traitement
        trace("tout va bien on continue");	
}


Ici j'ai imaginé deux champs de saisie pour le mot de passe, le deuxième étant destiné à éviter les fautes de frappe.

else if

Voilà une branche encore plus facultative que le “else tout court”. Je veux dire que quand on en arrive à une structure empilant les else if on peut souvent changer son fusil d'épaule. Mais bon, puisqu'il faut en parler, faisons le (dure, ma vie).

Else if en anglais, sinon si en français. Vous pourrez ajouter successivement autant de conditions à vérifier que vous le souhaitez, en ajoutant simplement les unes sous les autres des branches qui respectent cette construction.

else if (condition){
    //instruction(s)
}


if (test){
   //instruction(s) si test vérifié
} else if (test1){
   //instruction(s) si test1 vérifié
}else if (test2){
   //instruction(s) si test2 vérifié
}else if (test3){
   //instruction(s) si test3 vérifié
}else if (test4){
   //instruction(s) si test4 vérifié
}else if (test5){
   //instruction(s) si test5 vérifié
}else if (test6){
   //instruction(s) si test6 vérifié
}else if (test7){
   //instruction(s) si test7 vérifié
}else {
   //instruction(s) dans tous les autres cas
   // cette branche est bien sûr facultative
}


Aussitôt qu'une condition est vérifiée les instructions de la branche considérée sont exécutées les branches suivantes sont ignorées.

var laValeur:int = 100;
if (laValeur < 40) {
	trace("inf à 40");
} else if (laValeur<=100) {
	trace("inf ou égal 100");
} else if (laValeur==100) {
	trace("égal 100");
} else {
	trace("dans else");
}
inf ou égal 100



Et vous pouvez aussi tester des choses très différentes :

var laValeur:int = 100;
var uneChaine:String = "bonjour";
if (laValeur < 40) {
	trace("inf à 40");
} else if (uneChaine=="bonjour") {
	trace("la chaine vaut bonjour");
} else if (laValeur==100) {
	trace("égal 100");
} else {
	trace("dans else");
}
la chaine vaut bonjour


Vraiment, je ne m'étends pas sur le thème, très vite on va rencontrer la structure switch qui remplace avantageusement l'empilement de else if dans l'immense majorité des cas.

Une meilleure formulation

Pour présenter la structure if, il est de coutume de parler de condition et de présenter la condition en question sous forme de comparaison - entre les parenthèses suivant le mot if. C'est d'ailleurs ce que j'ai fait ;)

Malgré tout il s'agit d'un abus de langage et maintenant qu'on est bien en forme, je vais pratiquer le parler juste. Le vrai du vrai de la réalité programmatique c'est que ce qu'on passe entre parenthèses c'est quelque chose que l'on peut évaluer comme true ou false.

Quand on écrit directement une comparaison entre les parenthèses du if, le programme calcule le résultat et c'est ce résultat qui est traité.
Vérifions :

var soldeDeMonCompte:Number=1000 ;
var soldePositif:Boolean=soldeDeMonCompte > 0 ;
trace( "le solde du compte est-il positif ? "+ soldePositif);
if(soldePositif){
    trace("je me fais un cadeau !")
} else {
   trace ("dommage")
}


le solde du compte est-il positif ? true
je me fais un cadeau !


Ou encore plus indiscutable :

var verif:Boolean=true ;
if(verif){
    trace("la variable vérif vaut vrai")
} else {
   trace ( trace("la variable vérif vaut faux"))
}


la variable vérif vaut vrai



On est donc bien d'accord : la syntaxe du if c'est :

if(une_chose_que_l_on_peut_évaluer_comme_true_ou_false){
   // instruction(s) quand valeurBooléenne vaut true
} else {
   // instruction(s) quand valeurBooléenne vaut false
}


On parle bien d'une expression booléenne et pas d'une condition.
Je sais, je me répète, mais ça vous évitera peut-être d'écrire des choses comme celle ci :

if(unClip.visible==true){
    //traitement
}

l'expression unClip.visible vaut true ou false , inutile de comparer une fois de plus ;) 3)

Utiliser une fonction comme paramètre de if

Et du coup, puisqu'on vient de comprendre que if évalue l'expression qu'on passe entre parenthèse, ça doit bien marcher avec les fonctions pensent les petits rusés dans leur coin…
Et bien oui ! Si une fonction renvoie un booléen alors on peut l'évaluer directement “dans” le if, et par conséquent l'exécuter… :idea:

J'en vois qui me jettent un regard pas convaincu, le mieux c'est un exemple :

Validation d'un formulaire

Reprenons notre idée de formulaire d'inscription à valider.
On pourrait charger une fonction des opérations de validation. Si cette fonction a le bon goût de retourner faux quand les conditions de validation ne sont pas remplies, et vrai dans le cas contraire, il ne nous reste plus qu'à l'invoquer pour vérifier le formulaire, et se servir de ce qu'elle renvoie pour continuer ou non le traitement.

btOK.addEventListener(MouseEvent.CLICK, enregistre);
 
function enregistre(me:MouseEvent):void {
	if (!valideFormulaire()) { // pour évaluer le résultat il faut bien exécuter la fonction
		return;		   
	} 
// suite du traitement 
// si on passe là c'est que la validation a renvoyé vrai
}
function valideFormulaire():Boolean {
	if (txtNom.text=="")     txtSortie.text="Le champ nom ne peut être vide"; return(false);
	if (txtPrénom.text=="")  txtSortie.text="Le champ prénom ne peut être vide"; return (false);
	if (txtPseudo.text=="")  txtSortie.text="Le champ pseudonyme ne peut être vide"; return(false);
	if (txtMdP1.text=="")     txtSortie.text="Le champ mot de passe ne peut être vide"; return(false); 
 
        if (txtMdP1.text != txtMdP2.text ) {
              txtSortie.text="Attention à vérification du mot de passe";
              txtMdP1.text=""; // vider les champs mot de passe pour forcer une nouvelle saisie
              txtMdP2.text=""; 
              return(false);
        }
	// tour va bien renvoie vrai
        return(true);	
}

Si vous voulez vous convaincre du principe, posez un point d'arrêt sur la ligne if (!valideFormulaire()), et suivez l'exécution du programme au pas à pas à l'aide du débug.

N'hésitez pas à faire un détour du côté de ce tuto commis par frangois pour notre plus grand bonheur _o_



Maintenant qu'on est au clair sur le fait que le paramètre qu'on passe à if est évalué, je peux répondre à la question des suspicieux qui se demandaient pourquoi quand on confond l'opérateur d'affection = avec l'opérateur de comparaison == il semble quelque fois que ça marche quand même.
Ça va nous permettre d'aborder la dernière subtilité à connaître : la conversion implicite du paramètre.

Attention conversion implicite

Il faut le savoir : si nécessaire, on peut convertir une donnée d'un type sur un autre.
Il faut le savoir aussi, à l'exécution, il arrive que le lecteur se charge tout seul comme un grand d'effectuer des conversions, on parle alors de conversions implicites.

Les conversions implicites (ou coercition) sont parfois effectuées par Flash Player ou Adobe AIR lors de l'exécution.


C'est plutôt pratique, et pour peu qu'on sache bien ce qu'on fait (du moins ce que le lecteur4) fera) ça ne pause aucun problème, voire on peut s'appuyer sur ce comportement.

conversion explicite

Sans nous égarer trop, faisons donc un petit détour par les conversions vers un type booléen.

Pour associer un objet à un autre type de données, vous mettez le nom de l'objet entre parenthèses et le faites précéder du nom du nouveau type.

Ce qui rapporté à nos préoccupations donne ceci.

var testB:Boolean
var toto:int=0
testB=Boolean(toto)
trace(testB)
false

Si vous testez avec toto:int=1 vous obtiendrez true dans la fenêtre de sortie…
Vous trouverez les tableaux de conversion sur la toujours même page de la doc

conversion implicite


Ceci implique que si on passe à un if une valeur non pas booléenne, mais un int par exemple, le lecteur va tout bonnement (et implicitement) effectuer la conversion afin d'évaluer la variable de type int comme si il s'agissait d'un Booléen.

var toto:int=0
if (toto){
   trace( "compris comme true")
}else{
   trace( "compris comme false")
}
compris comme false
Attention qu'on se comprenne bien : la variable considérée (ici toto) n'est pas convertie au sens transformée, elle vaut toujours ce qu'elle vaut, mais le if l'évalue comme le résultat d'une conversion vers un booléen.

Preuve :

var toto:int=1
if (toto){
   trace( "compris comme true")
}else{
   trace( "compris comme false")
}
trace("mais toto vaut toujours " + toto)
compris comme true
mais toto vaut toujours 1

Par ailleurs, on sait que si on passe à un if autre chose qu'une valeur booléenne (ou convertible), if évalue l'expression. Dit autrement : fait un calcul ou exécute une fonction et utilise le résultat (en le convertissant au besoin).

Si je rappelle que le lecteur lit de droite à gauche…
…je pense que les choses commencent à vous devenir plus claires ;)

Comment ça non ? :D

Voici le genre de test qui peut vous faire croire que ça marche quand même si on confond comparaison et affectation :

var toto:int=8;
if(toto=0){ // ATTENTION erreur !!! c'est une affectation !
  trace("vrai");
}else{
  trace("faux");
}
faux

Ayez la curiosité de tracer toto en sortie de code :

var toto:int=8;
if(toto=0){
  trace("vrai");
}else{
  trace("faux");
}
trace("toto vaut "+toto)
faux
toto vaut 0

Je vous laisse vous livrer à différent tests avec des valeurs différentes pour toto, et je finis de raconter ce qu'il se passe pour ceux qui voudraient confirmation de leur intuition :

Le lecteur arrive sur cette ligne :

if(toto=0){

D'abord, il rencontre zéro.
Très bien, il “s'en souvient, le garde en tête”.
Puis il rencontre l'opérateur d'affectation = (égal).
Ah ah ! Il va donc s'agir pour lui de valoriser ce qui est tout de suite à gauche de cet opérateur avec ce qu'il “a en tête”, à savoir zéro.
Il le fait. toto vaut maintenant zéro et c'est ce toto qui doit être “traité” par le if.
C'est un int, qu'à cela ne tienne, hop conversion implicite, et nous voici avec l'équivalent de cette ligne :

if(false){ ...


Non seulement ça ne “marche” pas, mais en plus ça change la valeur de toto, ce qui risque de coller un fameux bronks dans le reste du code ;)



Pause exo : un quizz de grammaire

Revenons à nos moutons après cette indispensable digression. C'est le moment de vérifier qu'on a tout bien compris et de se faire la main, sur un exemple un peu concret.

On dirait que … ;)

Bénévoles pour association d'aide aux devoirs, nous avons décidé de faire un petit truc destiné à réviser la conjugaison de l'impératif.

L"extension Adobe Flash Plugin est nécessaire pour afficher ce contenu.
Regardez bien ce qu'il se passe selon qu'on écrit : chante, chantes, prends, prend, va ou vas…
Constatez que la casse de caractère importe peu.
Et dites vous que vous savez le faire ;)

Bien sûr il y a de multiples moyens de s'y prendre, mais d'une façon comme d'une autre il va falloir avoir recours aux if, avec ou sans else, sur une ligne ou entre accolades, chacun son goût.

J'ai choisi de ne pas me compliquer pour le corrigé que je vous propose :
• un bouton (btOK),
• trois clips construits pareil5) : un champ de saisie nommé txtSaisie et le texte statique idoine autours,
• enfin un champ dynamique nommé txtSortie pour afficher les commentaires.
… et un peu de code :mrgreen:


Pour retrouver les propriétés qui rendent les textes non sélectionnables après que la bonne réponse a été validée et virent la bordure, je vous renvoie à la doc ;)

Les opérateurs logiques

Dernière ligne droite ! :)

Ne nous reste plus qu'à voir comment “combiner” plusieurs valeurs booléennes, s'assurer par exemple que plusieurs conditions sont vérifiées à la fois.

On va avoir recours aux opérateurs logiques ET et OU qu'on utilise avec deux opérandes (valeurs) booléens et qui renvoient vrai ou faux selon les valeurs considérées.

&& (ET)

Il se note && et s'utilise comme suit :

var resultat:Boolean= varBool1 && varBool2 ;

Dit à ma façon : pour qu'il renvoie vrai il faut que les deux opérandes vaillent vrai.

La doc l'exprime différemment et dresse le tableau qui va bien, je fais l'économie de le reproduire, allez le consulter ;)

Si vous voulez tester :

var nomAnimal:String="lapin";
var nomPoisson:String="carpe"
 
if(nomAnimal=="lapin" && nomPoisson=="carpe"){
    trace("passe dans vrai");
}else {
    trace("passe dans faux");
}
passe dans vrai
var nomAnimal:String="lapin";
var nomPoisson:String="carpe"
 
if(nomAnimal=="lion" && nomPoisson=="carpe"){
    trace("passe dans vrai");
}else {
    trace("passe dans faux");
}
passe dans faux

C'est le membre de gauche qui est évalué d'abord

… me souffle-t-on à l'oreillette…

Opération capilotomie :

On est d'accord : il faut que les deux opérandes vaillent vrai pour que l'opérateur logique ET renvoie lui aussi vrai. Il suffit donc que l'un des deux vaille faux pour que de façon certaine on obtienne faux, quelque soit la valeur du second. Il n'est par conséquent pas utile d'évaluer le deuxième opérande dès lors que le premier vaux faux. Reste à savoir qui est évalué en premier, et bien c'est le membre de gauche.

Vérifions :
On sait (lien à venir) que la valeur par défaut des objets de type complexe c'est null. Par conséquent toute opération sur une variable de type TextField (au hasard) va générer une erreur :

var t:TextField; // seulement déclarée, vaut null
trace(t.visible); // l'éternelle erreur 1009


TypeError: Error #1009: Il est impossible d'accéder à la propriété ou à la méthode d'une référence d'objet nul.



Et maintenant :

var t:TextField;// seulement déclarée, vaut null
var toto:int=10;
 
if (toto>89 && t.visible ) {// toto>89 évalué d'abord, renvoie faux, l'autre membre n'est pas évalué
	trace("O_O");// pour écrire un truc on n'y passera pas, ce n'est pas ce qu'on teste 
}
trace("suite du traitement");
var t:TextField;// seulement déclarée, vaut null
var toto:int=10;
 
if (t.visible && toto>89 ) {// t.visible évalué d'abord, ça crie :D
	trace("O_O");
}
trace("suite du traitement");



Oui, bon, certes, et alors ? Râlerons les plus alertes de ceux qui ont survécu à ce (trop ?) long exposé :mrgreen:
Eh bien d'abord il est bon de le savoir, ça fait de la culture ;) Et puis aussi, dans les cas où on chasse les performances, si l'un des deux membres est une fonction qui effectue de lourds calculs, on peut toujours choisir qu'elle ne soit invoquée que si ça vaut le coup, à savoir si l'autre opérande vaut vrai…

Privilégiez :

if(toto==10 && laFonctionAuxDixMilliardsDeCalculs())

à

if( laFonctionAuxDixMilliardsDeCalculs() && toto==10)

|| (OU)

Il se note || et s'utilise comme suit :

var resultat:Boolean= varBool1 || varBool2 ;

Pour obtenir le caractère | c'est alt-maj-L depuis un mac et (à compléter par le premier pécéïste passant dans le coin).
L'opérateur OU renvoie vrai si l'un des deux opérandes vaut vrai.

Je vous renvoie aussi au beau tableau de la doc.
Si vous voulez tester :

var nomAnimal:String="lapin";
var nomPoisson:String="carpe"
 
if(nomAnimal=="lapin" || nomPoisson=="carpe"){
    trace("passe dans vrai");
}else {
    trace("passe dans faux");
}
passe dans vrai
var nomAnimal:String="lapin";
var nomPoisson:String="carpe"
 
if(nomAnimal=="lion" || nomPoisson=="carpe"){
    trace("passe dans vrai");
}else {
    trace("passe dans faux");
}
passe dans vrai

! (NOT)

C'est un opérateur logique unaire (comprendre qui admet un seul opérande), il a pour conséquence d'inverser la valeur Booléenne d’une variable ou d’une expression. Ça, c'est la doc qui le dit, ne vous laissez pas abuser, il renvoie la valeur inverse, mais ne modifie en aucun cas l'opérande considéré ;)

var b:Boolean=true;
 
trace(!b);
trace(b);// b vaut toujours true
false
true

Imaginons une variable magasinOuvert, booléenne, qui vaut vrai quand le magasin est ouvert et faux dans le cas contraire.
Imaginons qu'on vous donne la consigne suivante : si le magasin est ouvert on le ferme, sinon (il est fermé) on l'ouvre (je parle bien entendu de mettre la variable à jour)

Attention piège… Ce n'est pas parce qu'on emploie assez spontanément un si, qu'il faut vous précipiter sur le if. Ceci, est une mauvaise idée :

if(magasinOuvert){
   magasinOuvert=false;
else{
   magasinOuvert=true;
}


Vous voyez comment vous y prendre plus simplement (donc plus rapidement pour vous et pour le programme) ?

Allez, je le formule différemment, en fait il s'agit d'inverser la valeur de la booléenne… Dit encore autrement je vais affecter à la variable le contraire de ce qu'elle vaut :

magasinOuvert=!magasinOuvert;


Je rappelle que “le processeur lit les lignes d'instruction depuis la droite”. Ce qui se passe, c'est donc la chose suivante : d'abord l'expression !magasinOuvert est évaluée, puis c'est cette valeur qui est attribuée à la variable.

L'opérateur ternaire ?:

Attention, ce n'est pas une structure de contrôle !
Mais puisqu'il rend quelque fois le même service qu'un if, autant en parler.

On l'utilise quand on veut valoriser une variable différemment selon qu'une condition est vérifiée ou pas. Et puisque ce n'est jamais qu'une alternative à la structure si, je vous la présente, non pas en français mais en AS3… ça changera ;)

var age:int=28;
var commentaire:String;
if(age<18){
   commentaire="pas majeur";
} else {
   commentaire="majeur";
}

Ici, la variable commentaire vaut pas majeur ou majeur selon que âge est inférieur à 18 ou pas. C'est la même variable qu'on valorise dans un cas ou l'autre.

A l'aide de l'opérateur ternaire on écrira :

 commentaire=(age<18)?"pas majeur":"majeur";



En français : commentaire vaut …ummf j'en sais rien, ça dépend… age est-il inférieur à 18 ? si oui “pas majeur” sinon “majeur”.

bien sûr, libre à vous de l'écrire dans l'autre sens :

 commentaire=(age>=18)?"majeur":"pas majeur";



Quant aux parenthèses elles sont superflues, je les ai mises pour faciliter la lecture.

commentaire=age>=18?"majeur":"pas majeur";


Une fois de plus pour m'exprimer rapidement j'ai parlé de condition, vous n'êtes pas dupe : il s'agit bel et bien d'une valeur booléenne ;)

Conclusion

Et bien voilà, c'en est fini pour ce qui concerne la structure if. Je ne surcharge pas ce tuto d'exercices, on va, à partir de maintenant, y avoir suffisamment recours pour que vous ayez très largement l'occasion de vous faire la main :)

1) vous rencontrerez souvent suivi d'une seule instruction
2) cmd-Maj-F
3) C'est comme si vous demandiez : “Est-ce que vrai est égal à vrai ?” (quand unClip.visible vaut true)
Ou : “Est-ce que faux est égal à vrai ?”(quand unClip.visible vaut false)
4) Flash Player
5) on duplique les deux derniers, du coup