Une condition simple: SI...
Lorsque l'on réalise un programme informatique, on a très souvent besoin d'exprimer une condition, c'est à dire faire une action seulement dans certain cas. Par exemple "si ton age est plus petit que 18 alors tu es mineur".
Dans le code on va pouvoir faire même genre de structure, avec le mot-clé
if (signifiant "si" en langue anglaise).
Le but est de tester certaines valeurs, qui sont bien évidemment stockées dans des variables, et d'exécuter une suite d'instruction seulement dans le cas où la condition est vraie (c'est à dire qu'elle renvoie un booléen
true).
Sans plus attendre voici le squelette de code minimal d'une condition
if simple ainsi qu'un exemple d'utilisation :
Code : C# | if( /* expression booléenne */ )
{
// Le code présent ici n'est exécuté que si l'expression booléenne renvoie true
}
// Le code juste après ce commentaire est exécuté dans tout les cas.
|
Code : C# | int age = 17;
if(age >= 18)
{
Console.WriteLine("Tu es majeur.");
}
|
Essayez ce code, puis réessayez en mettant la variable age à 19.
Dans nos tests nous pouvons utiliser tout ce que nous avons vu jusqu'à présent dans ce chapitre : l'égalité et les comparaisons ainsi que les opérations
et et
ou.
Ce dernier code est bien beau! Mais si la personne est mineure, je doit ré-utiliser un test if ?
On pourrait

Mais ce n'est pas ce qu'on fait la plupart du temps. On va voir cela dans un instant
Des traitements alternatifs : SI... SINON...
Tout à l'heure, pour effectuer un traitement lorsque la personne est majeure, et un autre traitement lorsqu'elle est mineure, nous aurions pu faire ainsi :
Code : C# | int age = 17;
if(age >= 18)
{
Console.WriteLine("Tu es majeur.");
}
if(age < 18)
{
Console.WriteLine("Tu es mineur.");
}
|
Ce code fonctionnera, mais il manque d'optimisation et de logique!! En effet, si la personne est majeure, la première condition sera remplie alors que la seconde ne le sera jamais, mais le programme vérifiera tout de même si la seconde est aussi remplie!
Il est en plus plus difficilement modifiable : pour modifier la limite d'âge vous allez devoir modifier le code en deux endroits, ce qui augmente le nombres d'erreurs que l'on peut faire (et ce genre de petite erreur est très difficile à voir sans prendre un peu de recul sur son code).
Heureusement, il y existe une manière bien plus élégante d'opérer. Nous allons pouvoir implémenter la structure algorithmique "si... sinon...", puisque le "si" est traduit en C# par if (traduction anglaise de "si"), le "sinon" sera traduit par... "else" ("sinon" en anglais). Ce qui nous donnera le structure suivante :
Code : C# | if(booleen)
{
//Mettez ici ce que vous avez à faire lorsque la condition est remplie
}
else
{
//Mettez ici ce que vous avez à faire lorsque la condition n'est pas remplie
}
|
Transposé au cas de la vérification de l'âge de la personne, nous aurons le code suivant :
Code : C# | int age = 17;
if (age >= 18)
Console.WriteLine("Vous êtes majeurs");
else
Console.WriteLine("Vous êtes mineurs");
|
Comme vous pouvez le voir ici, lorsqu'un "if" ou un "else" n'est suivi que par une seule instruction, les accolades ( { et } ) deviennent optionnelles.
Cependant évitez d'utiliser cette option, car les erreurs arrivent très vite.
En effet une instruction rajouté ne sera pas interprété comme faisant partie de la structure conditionnelle.
Des conditions complètes : SI ...SINON SI .... [SINON SI]...SINON
Si nos vérifications se complexifient, nous pouvons appliquer la structure algorithmique suivante "SI...SINON SI... SINON...", en ajoutant autant de "SINON SI..." que nous le voulons en veillant bien de les mettre
avant le "SINON..." final.
Prenons l'exemple de grandes multinationales comme une chaine de grandes surfaces et une société ferroviaire qui sont partenaires, nous pouvons avoir des réductions chez la société ferroviaire grâce à la carte de la grande surface, nous pourrions avoir par exemple dans la billetterie automatique le code suivant.
Code : C# 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20 | bool aLaCarteTrain;
bool aUneCarteGrandeSurfacePartenaire;
int tarif;
// Des instructions doivent être ajoutées ici pour assigner une valeur
// aux variables
if (aLaCarteTrain) //S'il a la carte
{
Console.WriteLine("Vous devez payer : " + (tarif*0.5).ToString());
}
else if (aUneCarteGrandeSurfacePartenaire)//S'il a une carte d'un partenaire
{
Console.WriteLine("Vous devez payer : " + (tarif * 0.75).ToString());
}
else//S'il n'a aucune carte de fidélité
{
Console.WriteLine("Vous devez payer : " + tarif.ToString());
}
Console.ReadKey(true);
|
Etant donné que si une condition est vrai, les autres ne seront pas vérifiées par le programme, et par soucis d'optimisation (et même de logique), je vous recommande de mettre les conditions par ordre de "probabilité" décroissante, c'est à dire celle qui a le plus de chance d'être vérifiée en premier, puis celle qui a juste un peu moins de chance, .... et finir par le cas qui a peu de chance de se produire.
Une alternative pratique : le switch
Lorsque l'on enchaine plusieurs "else if" et si les vérifications portent sur une même variables, il peut être pratique d'utiliser un "switch" qui a une logique plus appropriée, par exemple au lieu de faire ça :
Code : Autre1
2
3
4
5
6
7
8
9
| SI variable == "valeur1"
ALORS //Action 1
SINON SI variable == "valeur2"
ALORS //Action 2
SINON SI variable == "valeur3"
ALORS //Action 3
SINON SI variable == "valeur4"
ALORS //Action 4
SINON //Action 5 |
nous ferrons :
Code : Autre1
2
3
4
5
6
| VERIFIER variable
CAS valeur1: //Action 1
CAS valeur2: //Action 2
CAS valeur3: //Action 3
CAS valeur4: //Action 4
SINON //Action 5 |
La syntaxe en exemple est la suivante :
Code : C# 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24 | string couleur = "rouge";
switch (couleur)
{
case "rouge":
Console.WriteLine("Tu aimes la couleur du sang");
break;
case "vert":
Console.WriteLine("Tu aimes la nature");
break;
case "bleu":
Console.WriteLine("Tu aimes la couleur du ciel");
break;
case "blanc":
Console.WriteLine("Tu aimes la purete");
break;
default:
Console.WriteLine("Je n'ai aucune commentaire a faire");
break;
}
|
Nous spécifions dans les parenthèses suivants le mot clés "switch" la variable sur laquelle la vérifications porte. Ensuite, nous mettons le mot clé "case" suivi de la valeur à vérifier suivi des deux points, des actions à effectuer puis le mot clés "break". Ce mot clé break permettra de sortir du switch si un "case" est vérifié (ça ne sert alors à rien de continuer à vérifier, "couleur" ne peux pas avoir deux valeurs en même temps

)
Un raccourci pour if...else... : l'opérateur ternaire
Précédemment nous avons vu des opérateur binaires comme "==" ou "+" et des opérateurs unaires comme "!" (not), sachez qu'il existe aussi un opérateur ternaire (qui s'applique sur trois opérandes!!). On l'appelle "opérateur" (au singulier) mais c'est plutôt deux opérateurs fonctionnant ensembles : "?" et ":". Il va nous servir à écrire de manière très condensée un if...else... simple, imaginez le code de manière suivant :
Code : C# | string texte;
bool unBooleen = true;
if (unBooleen)
texte = "c'est vrai";
else
texte = "c'est faux";
|
Ce code est plutôt court, mais il fait un peu long pour ce que nous voulions faire : assigner une chaine de caractères en fonction de la valeur de vérité d'un booléen ou d'une expression booléenne. Il n'y a en aucun cas des instructions plus complètes après le "if(...)" ni après le "else", dans ce cas, nous utiliserons la syntaxe suivante :
Code : C# | [type] mavariable = expressionBooleenne ? valeurSiVrai : valeurSiFaux ;
|
Ce qui donnera pour notre exemple précédant:
Code : C# | string texte;
bool unBooleen = true;
texte = unBooleen ? "C'est vrai" : "C'est faux";
|
On ne gagne "que" trois lignes de codes, mais sachez qu'il arrive de manière plutôt courante d'avoir à faire des assignations conditionnelles comme celle-ci avec des nombreuses variables l'une à la suite de l'autre, et ce raccourci d'écriture permet de gagner en lisibilité pour celui qui est à l'aise avec les opérateurs ternaires.
Je vous ai montré cet opérateur en dernier étant donné qu'on peut s'en passer et que tout le monde n'a pas la même aisance pour l'utiliser et le lire, sachez donc que je ne vous en voudrais pas si vous ne l'utilisez pas tout les jours

.
Mais trêve de bavardage, le chapitres est bientôt terminé, mais il nous reste encore à voir quelque chose d'essentiel dans n'importe quel langage : les boucles !