ÔĽŅ

1.5 - Conditions If then else

Parfois il est nécessaire que le programme prenne une décision.
Cela va determiner le comportement, l'intelligence du programme.
Par exemple si une variable a une certaine valeur, alors faire tel action, sinon faire autre chose.
Ou encore, si l'utilisateur répond avec tel valeur, alors .... etc.
Les conditions permettent de modifier le déroulement du programme en vérifiant certaine condition que vous avez déterminées.

synopsis

  1. prérequis
  2. notions de base
  3. if then
  4. else, else if
  5. not
  6. autres conditions
  7. operateurs
  8. à toi de jouer
  9. sommaire

  10. << retour aux tu(r)toriaux

prérequis

Avant de lire ce tutoriel, il est important d'avoir lu : 1.1 - Qu'est ce qu'un programme ?1.3 - Boucles loops1.4 - Variables1.6 - Boucle for

notions de base

Que sont les booléens et les conditions ?

booléen

Dans le tutoriel pr√©c√©dent, nous avons vu deux types de donn√©es : le number (nombre) qui repr√©sente toute valeur num√©rique manipul√© dans le programme et la cha√ģne pour manipuler les phrase.
Nous allons voir un troisième type, le booléen.
Un booléen est un type qui représente seulement deux états : true (vrai) et false (faux).

condition

Une condition est une opération qui doit être vérifiée (dont le résultat doit être vrai) :
Par exemple, nous voulons modifier le comportement d'un programme si le nombre est plus grand qu'un autre. Ou is la phrase est différente d'une autre.

Nous allons articuler ce tutoriel autour de cet exemple :

 
basic
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
algo.hide (); // cache la tortue
set i = 0;

algo.setColor (10); // la couleur de départ est verte
loop (4) {
  i++; // le conteur sera utilis√© dans les exemples suivants
  algo.disc (50);
  algo.jump (100);
  algo.turnRight (90);
}

if then

L'instruction If vas exécuter le bloque de code si la condition ce vérifie à un point du programme.
Sa syntaxe est : if (condition) {bloque}
Par exemple nous avons besoin de changer la couleur d'algo à la moitié de la boucle : On pourrait écrire 2 boucles qui se suivent loop (2) {} .... loop (2) {} mais ce n'est pas très élégant. Sinon nous pouvons vérifier, à chaque passage de la boucle, que notre vert soit plus grand que 2 et dans ce cas changer la couleur. if (i == 3) { autre couleur }

 
la moitié magenta
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
algo.hide (); // cache la tortue
set i = 0;
algo.setColor (10); // la couleur de départ est verte

loop (4) {
  i++; // compteur
 
  if (i == 3) {
    // la couleur deviens magenta √† partir du spot 3
    algo.setColor (13); // magenta
  }
  algo.disc (50);
  algo.jump (100);
  algo.turnRight (90);
}

Note que dans l'expression booléenne le symbole '==' est utilisé pour vérifier l'égalité.
Ce symbole a été choisi pour le distinguer de l'assignation '='
Donc le programme va changer la couleur (changement contenue dans le bloque) quand i sera égale à 3. Comme il n'y a pas d'autre instruction de changement de couleur, les spots suivants garderons la couleur magenta.

else, else if

else

L'instruction else (sinon) exécute le bloque de code si la condition n'est pas (NOT) vérifié au point du programme.
Elle est utilisée après l'instruction if et sa syntaxe est : if (condition) {bloque} else {bloque}.
Nous allons modifier le précédent code pour changer la couleur du 2 et uniquement celui-là

 
le spot 2 est magenta
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
algo.hide (); // cache la tortue
set i = 0;

loop (4) {
  i++; // compteur
  if (i == 2) {
    algo.setColor (13); // magenta
  } else {
    algo.setColor (10); // vert
  }
  algo.disc (50);
  algo.jump (100);
  algo.turnRight (90);
}

else if

Pour cr√©er une suite de teste, il est possible de cha√ģner les conditions 'if'.
Cela sert à tester si une première condition est vraie, sinon une seconde, sinon une troisième ect....
Les instructions 'else if' peuvent √™tre cha√ģn√©es entre la premi√®re instruction 'if' et la derni√®re 'else.'
La syntaxe est : if (condition1) {bloque1} else if (condition2) {bloque2} else if (condition3) {bloque3} .... else {bloqueElse}
Noua allons modifier notre exemple pour avoir une couleur différente pour chaque spot.

 
chacun sa couleur
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
algo.hide (); // cache la tortue
set i = 0;

loop (4) {
  i++; // compteur

  if (i == 1) {
    algo.setColor (10); // vert
  } else if (i == 2) {
    algo.setColor (11); // cyan
  } else if (i == 3) {
    algo.setColor (12); // rouge
  } else { // 4
    algo.setColor (13); // magenta
  }
 
  algo.disc (50);
  algo.jump (100);
  algo.turnRight (90);
}

not

'not' est un opérateur un-aire (qui agit sur une seule valeur, comme moins dans -7 par exemple).
Il représente l'inverse du booléen : not (non) true (vrai) vaut false (faux) et not (non) false (faux) vaut true (vrai).
En AL, sa syntaxe est '!'. Donc !true = false et !false = true.
Pour vérifier la non égalité (la différence) entre deux valeurs nous allons utiliser '!=' (est différent de).
Par exemple, pour vérifier que i est différent de 2 nous allons écrire : i != 2 qui signifie i est différent de 2.
En arithmétique booléenne il est aussi possible de dire !(i == 2) soit non (i égale 2).
Cette seconde écriture sera utile pour des opérations plus complexes sur les booléens.
Nous allons illustrer cela en inversant l'avant dernier exemple :

 
les spots 1, 3 et 4 sont magenta
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
algo.hide (); // cache la tortue
set i = 0;

loop (4) {
  i++; // compteur

  if (i != 2) { // equivalent √† if ( !(i == 2) )
    algo.setColor (13); // magenta
  } else {
    algo.setColor (10); // vert
  }
  algo.disc (50);
  algo.jump (100);
  algo.turnRight (90);
}

autres conditions

Egale et différent ne sont pas les deux seuls opérateurs de comparaison en AL.
Voici la liste des opérateurs disponnibles :

  d√©finition exemple
== égale à i == 2 : i est égale à 2
!= différent de i != 2 : i est différent de 2
< plus petit que i < 2 : i est plus petit que 2
<= plus petit ou égale à i <= 2 : i est plus petit ou égale à 2
> plus grand que i > 2 : i is greater than 2
>= plus grand ou égale à i >= 2 : i est plus grand ou égale à 2

operateurs

ou

En arithmétique booléenne, il est possible de créer des opérations complexes.
'ou' est un opérateur booléen comme '+' en mathématiques (2 + 2).
Il est utilisé pour résoudre des opérations comme : i est égale à 1 ou i est égale à 3.
En AL, sa syntaxe est '||'. Donc pour vérifier la condition précédente nous allons écrire : i == 1 || i == 3
Voici la table complète des possibilités.

|| true false
true true true
false true false


Nous allons modifier l'exemple précédent pour colorer les spots 1 et 3.
Donc nous allons tester que i soit égale à 1 ou à 3 :

 
les spots 1 et 3 sont magenta
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
algo.hide (); // cache la tortue
set i = 0;

loop (4) {
  i++; // compteur

  if (i == 1 || i == 3) { // un sur deux
    algo.setColor (13); // magenta
  } else { // donc 2 et 4
    algo.setColor (10); // vert
  }
  algo.disc (50);
  algo.jump (100);
  algo.turnRight (90);
}

et

'Et' est un opérateur binaire comme 'Ou'.
Il est utilisé pour résoudre des opérations comme : i est plus grand que 2 et i est plus petit que 3. En d'autres termes, que i soit entre 2 et 3.
En AL, sa syntaxe est '&&'. Donc pour vérifier la condition précédente, nous allons écrire : i >= 2 && i <= 3
Voici la table complète des possibilités :

&& true false
true true false
false false false


Nous allons modifier l'exemple précédent afin de colorer les spots 2 et 3.
Donc nous allons tester que le compteur soit entre 2 et 3 :

 
les spots 2 et 3 sont magenta
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
algo.hide (); // cache la tortue
set i = 0;

loop (4) {
  if (i >= 2 && i <= 3) { // entre 2 et 3
    algo.setColor (13); // magenta
  } else { // donc 1 ou 4
    algo.setColor (10); // vert
  }
  algo.disc (50);
  algo.jump (100);
  algo.turnRight (90);
}

A noter que d'écrire 'et' et d'imbriquer les ifs ensembles revient à la même chose.

 
ifs imbriqués
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
set i = 5;
set j = 10;
if (i == 5 && j == 10) {
  // fonctionne
}
// Est la même chose que :
if (i == 5) {
  if (j == 10) {
    // fonctionne aussi
  }
}
 

à toi de jouer

spirale bicolore

Crée une spirale bicolore comme suit en testant is le compteur est à 22.

 
Solution: 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
algo.setColor (10); // initialise la couleur
set i = 0;

loop (45) {
  i++; // compteur

  if (i == 22) { // s'ex√©cute seulement si i est √©gale √† 22
    algo.setColor (13); // change en magenta
  }
 
  algo.go (i * 10);
  algo.turnLeft (121);
}

labyrinthe multicolore

Crée un labyrinthe multicolore, comme la figure suivante.

 
Solution: 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
algo.setColor (10); // initialise la couleur
set i = 0;

loop (40) {
  i++; // compteur

  if (i < 10) {
    algo.setColor (10); // vert
  } else if (i < 20) {
    algo.setColor (11); // cyan
  } else if (i < 30) {
    algo.setColor (12); // red
  } else { // the ten last
    algo.setColor (13); // magenta
  }
 
  algo.go (i * 10);
  algo.turnLeft (90);
}

poser une question

- demande à l'utilisateur : "aimes tu le beurre ? (oui / non)"
- s'il répond 'oui' dit : "ok, tu aimes le beurre, hmmmm c'est bon !"
- sinon dit : "oh! Tu n'aimes pas le beurre."

 
Solution: 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
text.clear();
// demande
set answer = text.inputText ("aimes tu le beurre ? (oui / non) ");

if (answer == "oui") {
  text.output ("ok, tu aimes le beurre, hmmmm c'est bon !");
} else {
  text.output ("oh! Tu n'aimes pas le beurre.");
}

Le timide

Ecrit ton premier jeu !
Le but : deviner un nombre entre 0 et 9 choisi par l'ordinateur.
Les règles sont simples :
- pour deviner tu as 3 essais
- si tu as faux, l'ordinateur te dit si le résultat est plus grand ou plus petit.
- si tu as vrai, tu gagnes.

 
Solution: 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
text.clear();
set tries = 3;
set found = false;
set number = math.random (9);

// main loop
loop (3) {
  if (!found) {
    set answer = text.inputNumber ("trouve le nombre entre 0 et 9:");
   
    if (number < answer) {
      text.output ("non, c'est plus petit.");
    } else if (number > answer) {
      text.output ("non, c'est plus grand..");
    } else {
      text.output ("oui, tu as gagn√©!");
      found = true;
    }
  }
}

if (!found) {
  text.output ("pauvre joueur, tu as perdu!");
}


J'ai une affection particulière pour cet exercice, c'est lui qui m'a fait comprendre la programmation quand j'avais 9 - 10 ans.

ÔĽŅ

sommaire

connaissances

Dans ce tutoriel, vous avez appris :

  • qu'est ce qu'un bool√©en ?
  • qu'est ce qu'une condition ?
  • quoi faire d'autre si une condition est fausse ?
  • qu'est ce qu'un op√©rateur ?
  • comment les employer pour changer le d√©roulement du programme

fonctions utilisées :

FonctionDéscription