Exercice - Utiliser l’instruction if

  • 10 minutes

L’instruction de création de branche la plus utilisée est l’instruction if. L’instruction if repose sur une expression booléenne qui est placée entre parenthèses. Si l’expression est vraie (true), le code après l’instruction if est exécuté. Si l’expression est fausse (false), le code après l’instruction if est ignoré.

Créer un jeu de chiffres aléatoires en utilisant des instructions if

Inventons un jeu qui va nous aider à écrire des instructions if. Nous allons créer quelques règles pour le jeu, puis les implémenter dans du code.

Nous allons utiliser la méthode Random.Next() pour simuler le lancement de trois dés à six faces. Nous allons évaluer les valeurs pour calculer le score. Si le score est supérieur à un total arbitraire, nous allons afficher un message indiquant à l’utilisateur qu’il a gagné. Dans le cas contraire, nous afficherons un message l’informant qu’il a perdu.

  • Si deux des dés que vous lancez ont la même valeur, vous obtenez deux points bonus pour avoir fait un double.
  • Si les trois dés lancés ont la même valeur, vous obtenez six points bonus pour avoir fait un triple.
  • Si la somme des trois dés et des points bonus est supérieure ou égale à 15, vous avez gagné la partie. Sinon, vous avez perdu.

Nous ajouterons d’autres règles lorsque nous aurons une plus grande compréhension de l’instruction if.

Important

Nous allons abondamment utiliser la classe System.Random que nous avons abordée dans le module Appeler des méthodes de la bibliothèque de classes .NET à l’aide du langage C#. Pour vous rappeler du fonctionnement de Random.Next(), reportez-vous à ce module.

Étape 1 - Écrire du code qui génère trois nombres aléatoires et les affiche dans la sortie

Dans l’éditeur .NET, supprimez le code de toutes les étapes précédentes en le mettant en surbrillance, puis en sélectionnant la touche Retour arrière sur le clavier. Ensuite, sélectionnez Exécuter dans l’extrait de code suivant pour exécuter le code dans l’éditeur .NET :

Random dice = new Random();

int roll1 = dice.Next(1, 7);
int roll2 = dice.Next(1, 7);
int roll3 = dice.Next(1, 7);

int total = roll1 + roll2 + roll3;

Console.WriteLine($"Dice roll: {roll1} + {roll2} + {roll3} = {total}");

Nous allons créer une nouvelle instance de la classe System.Random et stocker la référence à cet objet dans la variable dice. Ensuite, nous appelons la méthode Random.Next() sur l’objet dice à trois reprises, en fournissant la limite inférieure et la limite supérieure, afin que les valeurs possibles soient comprises entre 1 et 6. Nous enregistrons les trois nombres aléatoires dans les variables roll1, roll2 et roll3, respectivement.

Ensuite, nous additionnons les résultats des trois lancements de dés, puis enregistrons la valeur dans la variable total.

Enfin, nous affichons toutes les valeurs en utilisant une interpolation de chaîne.

Lorsque vous exécutez le code, vous devriez voir le message suivant (les chiffres seront différents, car ils sont générés de manière aléatoire) :

Dice roll: 4 + 5 + 2 = 11

L’étape 1 correspond à l’étape de configuration. À présent, nous pouvons ajouter la logique de décision à notre code pour rendre le jeu plus intéressant.

Étape 2 - Ajoutez une instruction if pour afficher des messages différents en fonction de la valeur de la variable du total

Modifiez le code de l’étape précédente pour inclure l’instruction if :

Random dice = new Random();

int roll1 = dice.Next(1, 7);
int roll2 = dice.Next(1, 7);
int roll3 = dice.Next(1, 7);

int total = roll1 + roll2 + roll3;

Console.WriteLine($"Dice roll: {roll1} + {roll2} + {roll3} = {total}");

if (total > 14)
{
    Console.WriteLine("You win!");
}

if (total < 15)
{
    Console.WriteLine("Sorry, you lose.");
}

Nous avons ajouté deux instructions if pour gérer les scénarios de partie gagnée et perdue. Nous allons nous concentrer sur la première instruction if.

L’instruction if se compose de trois parties :

  • Le mot clé if.
  • Une expression booléenne entre parenthèses ().
  • Un bloc de code entre accolades { }.

Au moment de l’exécution, l’expression booléenne total > 14 est évaluée. Si l’expression est vraie (true) et si la valeur de total est supérieure à 14, le flux d’exécution passera au code défini dans le bloc de code. Autrement dit, il exécute le code compris entre accolades.

En revanche, si l’expression booléenne est fausse (false), le flux d’exécution ignorera le bloc de code. Autrement dit, il n’exécute pas le code compris entre accolades.

Enfin, la deuxième instruction if contrôle le message qui s’affiche si l’utilisateur perd la partie. Dans l’unité suivante, nous allons utiliser une variante de l’instruction if pour raccourcir ces deux instructions en une seule instruction et exprimer plus clairement notre intention.

Qu’est-ce qu’une expression booléenne ?

Une expression booléenne est tout code qui retourne une valeur booléenne, true ou false. Les expressions booléennes les plus simples sont des valeurs true et false. Une expression booléenne peut également être le résultat d’une méthode qui retourne la valeur true ou false. Par exemple, voici un exemple de code simple utilisant la méthode string.Contains() pour déterminer si une chaîne contient une autre chaîne :

string message = "The quick brown fox jumps over the lazy dog.";
bool result = message.Contains("dog");
Console.WriteLine(result);

if (message.Contains("fox"))
{
    Console.WriteLine("What does the fox say?");
}

Étant donné que message.Contains("fox") retourne une valeur true ou false, il est qualifié en tant qu’expression booléenne et peut être utilisé dans une instruction if.

D’autres expressions booléennes simples peuvent être créées à l’aide d’opérateurs permettant de comparer deux valeurs. Ces opérateurs sont les suivants :

  • ==, l’opérateur « égal à » pour tester l’égalité.
  • >, l’opérateur « supérieur à » pour vérifier que la valeur de gauche est supérieure à celle de droite.
  • <, l’opérateur « inférieur à » pour vérifier que la valeur de gauche est inférieure à celle de droite.
  • >=, l’opérateur « supérieur ou égal à ».
  • <=, l’opérateur « inférieur ou égal à ».
  • et ainsi de suite

Notes

Nous avons consacré un module entier aux expressions booléennes. Vous pouvez choisir parmi de nombreux opérateurs pour construire une expression booléenne. Et nous n’aborderons ici que les principaux. Pour plus d’informations, consultez le module Évaluer des expressions booléennes pour prendre des décisions en C#.

Dans notre exemple, nous avons évalué l’expression booléenne total > 14. Toutefois, nous aurions pu choisir l’expression booléenne total >= 15 puisque, dans ce cas, elles sont identiques. Étant donné que les règles de notre jeu spécifient que la partie est gagnée si le résultat de deux dés plus les points bonus est supérieur ou égal à 15, il est préférable d’utiliser la dernière. Nous allons effectuer ce changement dans la prochaine étape de l’exercice.

Qu’est-ce qu’un bloc de code ?

Un bloc de code est une collection d’une ou de plusieurs lignes de code qui sont comprises entre une accolade ouvrante et une accolade fermante ({ }). Il constitue une unité de code complète qui a un objectif unique dans le système logiciel. Dans ce cas, lors de l’exécution, toutes les lignes de code du bloc de code sont exécutées si l’expression booléenne a la valeur true. À l’inverse, si l’expression booléenne est fausse (false), toutes les lignes de code du bloc de code sont ignorées.

Il existe des blocs de code à de nombreux niveaux en C#. En effet, l’éditeur .NET masque le fait que notre code est exécuté à l’intérieur d’un bloc de code qui définit une méthode. Vous verrez plus précisément cette structure quand vous commencerez à écrire du code C# à l’aide de Visual Studio Code ou de l’IDE de Visual Studio.

Des blocs de code peuvent contenir d’autres blocs de code. Nous en verrons une démonstration plus loin dans ce module, lorsque nous imbriquerons une instruction if à l’intérieur d’une autre instruction.

Notes

Nous avons consacré un module entier aux blocs de code. Les blocs de code sont essentiels pour comprendre l’organisation et la structure du code, et définissent les limites de la portée des variables. Pour plus d’informations, consultez le module Contrôler la portée et la logique des variables à l’aide de blocs de code en C#.

Étape 3 - Ajouter une autre instruction if pour implémenter les points bonus d’un double

Ensuite, implémentons une nouvelle règle : « Si deux dés que vous lancez ont la même valeur, vous obtenez deux points bonus pour avoir fait un double ». Modifiez le code de l’étape précédente pour qu’il corresponde à celui de la liste de codes suivante :

Random dice = new Random();

int roll1 = dice.Next(1, 7);
int roll2 = dice.Next(1, 7);
int roll3 = dice.Next(1, 7);

int total = roll1 + roll2 + roll3;

Console.WriteLine($"Dice roll: {roll1} + {roll2} + {roll3} = {total}");

if ((roll1 == roll2) || (roll2 == roll3) || (roll1 == roll3))
{
    Console.WriteLine("You rolled doubles! +2 bonus to total!");
    total += 2;
}

if (total >= 15)
{
    Console.WriteLine("You win!");
}

if (total < 15)
{
    Console.WriteLine("Sorry, you lose.");
}

Ici, nous allons combiner trois expressions booléennes afin de créer une longue expression booléenne dans une seule ligne de code. Ce type de code est parfois appelé condition composée. Nous avons un jeu de parenthèses externes qui combine trois jeux de parenthèses internes, séparés par deux barres verticales.

Deux barres verticales (||) correspondent à l’opérateur logique OU, qui indique essentiellement ceci : « L’expression à gauche OU l’expression à droite doit être vraie (true) pour que toute l’expression booléenne soit vraie (true) ». Si les deux expressions booléennes sont fausses (false), l’expression booléenne entière est fausse (false). Nous utilisons deux opérateurs logiques OU de façon à pouvoir étendre l’évaluation à une troisième expression booléenne.

Tout d’abord, nous évaluons (roll1 == roll2). Si sa valeur est vraie (true), l’expression entière est vraie (true). Si sa valeur est false, nous évaluons (roll2 == roll3). Si sa valeur est vraie (true), l’expression entière est vraie (true). Si sa valeur est false, nous évaluons (roll1 == roll3). Si sa valeur est vraie (true), l’expression entière est vraie (true). Si les trois sont fausses (false), l’expression entière est fausse (false).

Si l’expression booléenne composée est vraie (true), nous exécutons le bloc de code suivant. Cette fois-ci, il y a deux lignes de code. La première ligne de code affiche un message. La deuxième ligne de code incrémente la valeur de total de 2.

Enfin, nous avons également modifié la vérification pour voir si l’utilisateur a gagné à utiliser l’opérateur >=. Ce scénario ressemble davantage à l’exigence que nous avons posée au départ, mais il devrait fonctionner de manière identique à ce que nous avons écrit précédemment.

if (total >= 15)

Étape 4 - Ajouter une autre instruction if pour implémenter les points bonus d’un triple

Ensuite, ajoutons une autre nouvelle règle : « Si les trois dés lancés ont la même valeur, vous obtenez six points bonus pour avoir fait un triple ». Modifiez le code des étapes précédentes pour qu’il corresponde à la liste de codes suivante :

Random dice = new Random();

int roll1 = dice.Next(1, 7);
int roll2 = dice.Next(1, 7);
int roll3 = dice.Next(1, 7);

int total = roll1 + roll2 + roll3;

Console.WriteLine($"Dice roll: {roll1} + {roll2} + {roll3} = {total}");

if ((roll1 == roll2) || (roll2 == roll3) || (roll1 == roll3))
{
    Console.WriteLine("You rolled doubles! +2 bonus to total!");
    total += 2;
}

if ((roll1 == roll2) && (roll2 == roll3)) 
{
    Console.WriteLine("You rolled triples! +6 bonus to total!");
    total += 6;
}

if (total >= 15)
{
    Console.WriteLine("You win!");
}

if (total < 15)
{
    Console.WriteLine("Sorry, you lose.");
}

Ici, nous allons combiner deux expressions booléennes afin de créer une expression booléenne composée dans une seule ligne de code. Nous avons un jeu de parenthèses externes qui combine deux jeux de parenthèses internes, séparés par deux esperluettes.

Deux esperluettes (&&) correspondent à l’opérateur logique ET, qui indique que : « Si les deux expressions sont vraies (true), l’expression entière est vraie (true) ». Dans ce cas, si roll1 est égal à roll2, et roll2 est égal à roll3, roll1 doit être égal à roll3, ce qui signifie que l’utilisateur a fait un triple.

Si vous exécutez le code, il se peut que vous voyiez une sortie semblable à cet exemple :

Dice roll: 3 + 6 + 1 = 10
Sorry, you lose.

Ou comme cet exemple :

Dice roll: 1 + 4 + 4 = 9
You rolled doubles! +2 bonus to total!
Sorry, you lose.

Ou comme cet exemple :

Dice roll: 5 + 6 + 4 = 15
You win!

Si vous avez de la chance, vous verrez cette sortie :

Dice roll: 6 + 6 + 6 = 18
You rolled doubles! +2 bonus to total!
You rolled triples! +6 bonus to total!
You win!

Mais attendez : devons-nous vraiment récompenser le joueur pour avoir obtenu à la fois un triple et un double ? Après tout, l’obtention d’un triple implique celle d’un double. Idéalement, les points bonus ne devraient pas se cumuler. Il devrait s’agir de deux bonus distincts. Nous avons là notre premier bogue logique.

Problèmes de logique et opportunités d’améliorer le code

Même si nous avons bien commencé et avons appris beaucoup sur l’instruction if, les expressions booléennes, les blocs de code, les opérateurs logiques OU et ET, etc., il reste beaucoup de choses que nous pouvons améliorer. C’est ce que nous allons faire dans l’unité suivante.

Récapitulatif

  • Utilisez une instruction if pour créer une branche dans la logique de votre code. L’instruction de décision if exécute du code dans son bloc de code si son expression booléenne a la valeur true. Si ce n’est pas le cas, le runtime ignore le bloc de code et continue jusqu’à la ligne de code qui vient après celui-ci.
  • Une expression booléenne est toute expression qui retourne une valeur booléenne.
  • Les opérateurs booléens comparent les valeurs de gauche et de droite pour tester leur égalité, et effectuer d’autres types de comparaisons.
  • Un bloc de code est compris entre accolades { }. Il rassemble des lignes de code qui doivent être traitées comme une unité.
  • L’opérateur logique ET && agrège deux expressions de sorte que les deux sous-expressions doivent avoir la valeur true pour que l’expression entière ait la valeur true.
  • L’opérateur logique OU || agrège deux expressions de sorte que si l’une des deux sous-expressions a la valeur true, l’expression entière a la valeur true.