## Instructions conditionnelles

Les programmes faits d'une simple suite d'instructions comme celui de l'exercice précédent sont bien ennuyeux. Ils font toujours la même chose, et ne peuvent pas réagir aux conditions extérieurs. Une instruction conditionnelle permet au programme de s'adapter en disant quelque chose comme S'il pleut, prend un parapluie.

La syntaxe en [!thelang] est la suivante :

    [!java|scala|c]if (condition) {
        aFaireSiVraie();
        aFaireEnsuiteSiVraie();
    }[/!][!python]if condition:
        aFaireSiVraie()
        aFaireEnsuiteSiVraie()[/!]
    aFaireDansTousLesCas()[!java|c];[/!]

Le mot `if` signifie «si» en anglais. Si la condition est vraie, alors le code du bloc suivant sera exécuté, puis l'exécution se poursuivra avec la suite du code, après le bloc. Sinon, si la condition est fausse, le bloc suivant sera ignoré et l'exécution passera directement au code placé après lui. Le bloc conditionnel peut contenir plusieurs instructions. Il peut même contenir d'autre tests, avec leurs sous-blocs associés.

Dans cet exemple, les instructions `aFaireSiVraie()` et `aFaireEnsuiteSiVraie()` seront exécutée si (et seulement si) la condition est vraie tandis que l'instruction `aFaireDansTousLesCas()` sera exécutée que la condition soit vraie ou fausse.

En [!thelang], les blocs sont [!java|scala|c]délimités par des accolades : le symbole { commence un bloc tandis que le symbole } le ferme. Les caractères blancs ne sont pas pris en compte[/!][!java|c].[/!][!scala], tant que les instructions restent séparées soit par des points-virgules, soit par des retour à la ligne.[/!] [!java|scala|c]Il reste très important d'indenter correctement votre code pour qu'il reste lisible.[/!] [!python]marqués par l'indentation : toutes les lignes indentés (=décalées vers la droite par des espaces) font partie du bloc. Il est assez courant d'utiliser quatre espaces pour indenter le code, mais cela fonctionne quel que soit le nombre de caractères blancs utilisés pour cela. Simplement, toutes les lignes d'un bloc donné doivent utiliser le même nombre de blancs. La fin des blocs de code n'est pas marquée par un symbole particulier: il s'arrête dès que les lignes ne sont plus indentées. N'oubliez pas les deux points (:) à la fin de la ligne `if`, python en a besoin pour savoir qu'un nouveau bloc commence. Le fait que python utilise l'indentation pour maquer les blocs est un avantage pour les débutants: cela vous forcera à respecter des critères stricts de mise en forme de votre code.[/!] Il est très facile de se perdre dans un code qui n'est pas correctement indenté. Il est donc important que vous fassiez en sorte que votre code reste clair et lisible pour que le relire et le modifier reste plaisant et productif.

Toutes les instructions d'un bloc doivent avoir la même indentation, et il n'est pas possible de couper un bloc. Les deux exemples suivants de code sont incorrects et vont générer des erreurs.

    if condition:
        quoiFaire()
          quoiFaireEnsuite() # une espace de trop
    quoiFaireDansTousLesCas()

    if condition:
        quoiFaire()
    quoiFaireDansTousLesCas()
        quoiFaireEnsuite() # Ce bloc n'est rattaché à aucune ligne de condition

La condition doit être une expression de type `[!c]int[/!][!java]boolean[/!][!scala|python]Boolean[/!]` (expression booléenne). Le sous-bloc sera exécuté seulement si cette expression vaut `[!c]1[/!][!java|scala]true[/!][!python]True[/!]` (vrai), et il sera ignoré si sa valeur est `[!c]0[/!][!java|scala]false[/!][!python]False[/!]` (faux). `[!java|scala]true[/!][!python]True[/!]` et `[!java|scala]false[/!][!python]False[/!]` sont des constantes définies directement par [!thelang], tout comme 0 ou 1 en mathématiques.

La condition peut aussi être une variable booléenne (nous reviendrons sur les variables dans un autre exercice, pas de panique) ou un test arithmétique,comme `x == 5`, qui teste si la valeur actuelle de `x` est 5, ou bien comme != (teste l'inégalité, càd si le membre gauche a une valeur différente du membre droit), < (inférieur à), > (supérieur à), <= (inférieur ou égal à), >= (supérieur ou égal à).

Attention au piège classique, qui consiste à tester l'égalité d'une variable avec = au lieu de ==. Heureusement, [!java|scala|c]le compilateur[/!][!python]l'interpréteur[/!] détecte le plus souvent ce problème et vous le signale, mais pas tout le temps. Si la variable est de type booléen, il peut se faire prendre au piège, et il convient donc d'être attentif...

La condition peut également être un appel à certaines méthodes particulières, dont le résultat est un booléen. Par exemple, la méthode `estFaceMur()` de la buggle renvoie [!c]1[/!][!java|python|scala]vrai[/!] si la buggle est face à un mur, et [!c]0[/!][!java|python|scala]faux[/!] sinon.

Enfin, il est possible de construire une condition composée de plusieurs sous-conditions reliées par des opérations booléennes:

- `cond1 [!java|scala|c]&&[/!][!python]and[/!] cond2` est vraie si `cond1` et `cond2` est vraie (d'ailleurs, si `cond1` est fausse, `cond2` n'est même pas évaluée puisqu'on sait déjà que la conjonction des deux propositions ne peut pas être vraie).
- `cond1 [!java|scala|c]||[/!][!python]or[/!] cond2` est vraie si `cond1` ou `cond2` est vraie (d'ailleurs, si `cond1` est vraie, `cond2` n'est même pas évaluée puisqu'on sait déjà que la disjonction des deux propositions ne peut pas être fausse).
- `[!java|scala|c]![/!][!python]not [/!]cond` est vraie si `cond` ne l'est pas.
- Quand les expressions deviennent compliquées, il est préférable d'ajouter quelques parenthèses pour lever toute ambiguïté sur l'ordre d'évaluation. N'hésitez pas à mettre suffisamment de parenthèses pour la rendre plus lisible.

Pour finir, il est possible de spécifier ce qu'il faut faire quand la condition est fausse, en utilisant la syntaxe suivante («else» signifie «sinon» en anglais). Dans ce cas, l'instruction `aFaireSiLaConditionEstFausse()` ne sera exécutée que si la condition est fausse.

    [!java|scala|c]if (condition) {
        aFaireSiLaConditionEstVraie();
    } else {
        aFaireSiElleEstFausse();
    }[/!][!python]if (condition):
        aFaireSiLaConditionEstVraie()
    else:
        aFaireSiElleEstFausse()[/!]

N'oubliez pas les deux points (:) après le else, ils indiquent qu'un nouveau bloc débute.

### Objectif de cet exercice

Si la buggle est face à un mur, il faut reculer d'un pas; Sinon, il faut avancer d'un pas. Pour savoir si on est face à un mur, il suffit d'utiliser la méthode prédéfinie des buggles nommée `estFaceMur()`.

Cet exercice est un peu particulier : il faut que votre programme fonctionne pour plusieurs buggles, chacune étant dans une situation initiale différente. Le même code sera utilisé pour chacune d'entre elles.

Quand votre programme fonctionne, passez à l'exercice suivant (qui est caché par défaut dans un sous-arbre de la fenêtre de sélection).