Boucles et décisions : choisir d'exécuter quelques instructions

Les mots-clés If et EndIf

Le moyen le plus simple de permettre à votre programme de décider s'il doit exécuter une séquence d'instructions est d'utiliser le mot-clé If (et ceux associés). La structure de code la plus simple utilisant le mot-clé If ressemble à ceci : 
If <expression>
    ; Instructions
EndIf

Explication : PureBasic calculera la valeur de l'expression qui suit le mot-clé If. Si la valeur de l'expression est Vrai alors les instructions qui suivent le mot-clé If seront exécutées. Si la valeur de l'expression est Faux ces instructions seront ignorées et le programme continuera son exécution à partir de l'instruction située après le mot-clé EndIf. Prenons cet exemple (également disponible ici) : 

If OpenConsole()
    PrintN("Console ouverte avec succes")

    a.l = 3
    b.l = 3
    If a=b
        PrintN("Les valeurs des variables sont identiques.")
    EndIf

    PrintN("Appuyez sur ENTREE pour quitter")
    Input()
    CloseConsole()
EndIf
End

Cet exemple démontre trois points importants de l'utilisation du mot-clé If. Le premier est que n'importe quelle expression peut être utilisée, comme c'est le cas en utilisant le résultat de la commande OpenConsole() sur la première ligne. Si vous recherchez dans le manuel de référence, ou dans le chapitre suivant, la description de la commande OpenConsole() vous verrez qu'elle renvoie une valeur différente de zéro si la console a pu être ouverte, ou une valeur zéro en cas d'échec. Rappelez-vous sur la page précédente nous avons appris qu'une valeur différente de zéro est considérée comme Vrai et une valeur zéro est considérée comme Faux. Par conséquent les instructions à l'intérieur du bloc If seront exécutées si la console s'est ouverte avec succès (dans ce cas, OpenConsole() renvoie une valeur différente de zéro, qui est Vrai, entraînant l'exécution du code). C'est de cette manière que les consoles devraient toujours être ouvertes, en vérifiant si elles l'ont bien été.

Le deuxième point est présenté par le second emploi du mot-clé If (sur la 6ème ligne). Il s'agit de l'utilisation "normale" de If en utilisant un opérateur de comparaison comme expression contrôlant si le code doit être exécuté ou non.

Le dernier point à remarquer est que les blocs If...EndIf sont à l'intérieur l'un de l'autre (on parle alors de bloc imbriqué). Lorsque vous imbriquez des blocs If...EndIf, ou des boucles, vous devez complètement fermer le bloc ou la boucle à l'intérieur de l'autre bloc ou boucle. Vous ne pouvez pas, par exemple, commencer un bloc ou une boucle, commencer un(e) autre bloc (boucle) et ensuite fermer le (la) premier(e) bloc (boucle) avant d'avoir fermé le (la) deuxième.

Enfin, petite suggestion supplémentaire, pensez à indenter le code à l'intérieur des blocs If...EndIf, et des boucles. L'indentation est le fait de mettre des espaces ou des tabulations en début de ligne pour donner l'impression qu'elles sont à l'intérieur du bloc. Cela rend le code plus facile à lire, surtout quand vous rendez la taille des retraits conforme.

Le mot-clé Else

Que se passe-t-il lorsque vous souhaitez exécuter certaines autres instructions si la valeur de l'expression est Faux ? Dans ce cas vous pouvez utiliser le mot-clé Else. La structure d'un bloc If avec une condition Else est présentée ci-dessous : 
If <expression>
    ; Instructions
Else
    ; Instructions alternatives
EndIf

Elle s'interprète de la même manière que le bloc If simple. La valeur de l'expression est calculée et si elle est Vrai alors les instructions suivant le mot-clé If sont exécutées. Lorsque le mot-clé Else est atteint l'exécution s'arrête et saute à la l'instruction située après le mot-clé EndIf.

Cependant, si la valeur de l'expression est Faux alors le programme continue son exécution à partir des instructions qui suivent le mot-clé Else.

L'effet d'un bloc If...Else...EndIf est présenté dans l'exemple suivant (qui peut également être téléchargé ici) : 

If OpenConsole()
    a.l = 3
    b.l = 4
    If a=b
        PrintN("Les valeurs des variables sont identiques.")
    Else
        PrintN("Les valeurs des variables sont differentes.")
    EndIf

    PrintN("Appuyer sur ENTREE pour quitter")
    Input()
    CloseConsole()
EndIf
End
L'exemple est presque le même que le premier, sauf qu'il montre l'effet d'utiliser une condition Else à l'intérieur du bloc If qui compare les valeurs des variables. L'exécution de l'exemple ci-dessus démontrera que le code dans la condition Else est pris en compte. Si maintenant vous changez la valeur de l'une des variables afin qu'elles soient identiques, vous verrez ce qui se passe dans l'autre cas.

Le mot-clé ElseIf

Vous pouvez à présent vérifier des expressions et exécuter des instructions selon que la valeur de l'expression est Vrai ou Faux. Mais comment vérifier de nombreuses expressions différentes ? Une solution consisterait à imbriquer plusieurs blocs If...EndIf l'un dans l'autre. Cependant, une solution plus sympathique est d'utiliser le mot-clé ElseIf. C'est un mélange des mot-clés Else et If (comme vous l'avez surement deviné :). La structure d'un bloc If contenant des conditions ElseIf est présentée ci-dessous : 
If <expression 1>
    ; Instructions
ElseIf <expression 2>
    ; Instructions
[ElseIf <expression 3>
    ; Instructions]
;...
[ElseIf <expression n-ième>
    ; Instructions]
Else
    ; Instructions alternatives
EndIf

Les conditions ElseIf sont entre crochets car elles sont facultatives. Vous en mettez autant que vous en avez besoin. Vous n'êtes pas obligé d'utiliser la condition Else si elle n'est pas nécessaire. Le code commence par vérifier la valeur de l'expression 1, située après le mot-clé If. Si elle est Vrai alors les instructions suivant le mot-clé If sont exécutées. Lorsque le code atteint la condition ElseIf suivante, il l'ignore et passe directement à l'instruction située après le mot-clé EndIf. Si la valeur de l'expression est Faux alors le programme va à la prochaine condition ElseIf et vérifie la valeur de l'expression. Si la valeur est Vrai alors les instructions qui la suivent sont exécutées, sinon le programme va à la prochaine condition ElseIf. Ceci se répète jusqu'ç ce que l'une des conditions corresponde ou qu'il n'y ait plus d'expressions à vérifier.

PureBasic effectue les vérification des conditions If et ElseIf dans l'ordre où elles sont écrites dans votre source. Donc vous devez mettre les vérifications dans l'ordre dans lequel vous souhaitez qu'elles soient effectuées si certaines d'entre-elles se recoupent. Vous devez également (si vous l'utilisez) vous assurer que le mot-clé Else soit la dernière condition d'un bloc If. Toute autre condition figurant après ce mot n'étant pas vérifiée.

Cet exemple présente l'utilisation du mot-clé ElseIf, et peut également être téléchargé ici : 

If OpenConsole()
    nom$ = "John"
    
    If nom$="Frank"
        PrintN("Salut Frank, ca fait plaisir de te revoir.")
    ElseIf nom$="Bob"
        PrintN("Bob ! Comment vas-tu ?")
    ElseIf nom$<>"John"
        PrintN("Vous n'etes pas John")
    Else
        PrintN("Desole, je ne sais pas qui vous etes.")
    EndIf

    PrintN("Appuyer sur ENTREE pour quitter")
    Input()
    CloseConsole()
EndIf
End

Le fonctionnement de cet exemple est le suivant : à la variable nom$ est affectée la chaîne "John". Elle est ensuite comparée (égalité) à la chaîne "Frank". Comme ces deux valeurs diffèrent le résultat de l'expression est Faux et le code passe à la première condition ElseIf. A nouveau, la variable nom$ est comparée (égalité), mais elles ne correspondent pas donc le code passe au second ElseIf. A cette étape un test d'inégalité est effectué, et comme la chaîne est la même le résultat est Faux. Le code trouve alors la condition Else, qui est exécutée car aucune autre condition renvoyant une valeur Vrai n'a été trouvée.

Sujet précédent Sommaire Sujet suivant
Opérateurs de comparaison et opérateurs logiques Contenu du guide de l'utilisateur Choisir un ensemble d'instruction selon un cas (Select...Case...EndSelect)