Dart en 10 chapitres : Chap 3 Conditions.

Salut, j’espère que ça évolue bien.

Nous voici encore dans notre cours de “Dart en 10 chapitres”, si vous avez manqué les chapitres précédents, n’avancez pas sans revenir dessus, en cliquant ici.

0. Vue d’ensemble

Sous ce chapitre, nous parlerons de la première notion de la logique de programmation, celle de “conditions”.

Les conditions en programmation sont des structures, d’où on parle de “structures conditionnelles”, qui permettent de contrôler le flux d’exécution d’un programme.

Elles permettent d’exécuter du code uniquement si une condition est vraie.

Avant de s’y plonger revoyons rapidement une notion basique de l’algorithme, les opérateurs.

Voyons leur notation et rôle en Dart :

a. Opérateur d’égalité == :

• Cet opérateur est utilisé pour vérifier si deux valeurs sont égales.
• Il retourne true si les valeurs sont égales et false si elles ne le sont pas.

int a = 10;
int b = 10;

print(a == b);
//Ici, la valeur vaut true car 10 est égal à 10

b. Opérateur d’inégalité != :

• Cet opérateur est utilisé pour vérifier si deux valeurs sont différentes.
• Il retourne true si les valeurs sont différentes et false si elles sont égales.

int a = 10;
int b = 10;

print(a != b);
//Ici, la valeur vaut false car 10 n'est pas différent de 10

c. Opérateur supérieur à >:

• Cet opérateur est utilisé pour vérifier si une valeur est supérieure à une autre.
• Il retourne true si la valeur de gauche est supérieure à la valeur de droite et false si elle ne l'est pas.

d. Opérateur inférieur à <:

• Cet opérateur est utilisé pour vérifier si une valeur est inférieure à une autre.
• Il retourne true si la valeur de gauche est inférieure à la valeur de droite et false si elle ne l'est pas.

e. Opérateur supérieur ou égal à >=:

• Cet opérateur est utilisé pour vérifier si une valeur est supérieure ou égale à une autre.
• Il retourne true si la valeur de gauche est supérieure ou égale à la valeur de droite et false si elle ne l'est pas.

f. Opérateur inférieur ou égal à <=:

• Cet opérateur est utilisé pour vérifier si une valeur est inférieure ou égale à une autre.
• Il retourne true si la valeur de gauche est inférieure ou égale à la valeur de droite et false si elle ne l'est pas.

Nous pouvons aussi ajouter d’autres opérateurs logiques à la liste :

g. Opérateur ET &&: Les deux expressions doivent être vraies pour que le résultat soit vrai.

h. Opérateur OU ||: L’un des deux expressions doit être vraie pour que le résultat soit vrai.

Il y a tant d’autres que nous n’allons pas revenir dessus ici, nous n’avons épinglé que ceux qui sont les plus retrouvés et qu’on utilisera souvent.

Nous allons classer ces structures en 4 catégories :

1. Les Instructions à if

Les instructions à if sont des instructions n’ayant qu’une seule expression booléenne, donc n’exécutent qu’une seule bloc d’instructions si la condition est vraie.

//Exemple d'une instruction à if
int age = 20;
if(age >= 18){
  print("Est majeur.");
}

2. Les Instructions à if ... else

Les instructions à if ... else sont celles qui ont une expression booléenne qui vérifie si la condition est vraie, si oui, le bloc du if s’exécute, sinon c’est le bloc de else qui est exécuté.

//Exemple d'une instruction à if ... else
int age = 10;
if(age >= 18){
  print("Est majeur.");
} else {
  print("Est mineur.");
}

Comme dans cet exemple, vu que la variable age est inférieur à 18 ce qui fait que la première expression, celle de if , n’est pas vraie alors c’est le bloc de else qui est exécuté. D’où notre algorithme ici aura un outpout de : “Est mineur”.

exemple d’une instruction à if … else

Allez ! Vu qu’on y est, avant d’avancer sur les autres instructions, je vous ferai certains bonus de Dart.

a. Les opérateurs ternaires

Dart nous propose des raccourcis, dit “opérateurs ternaires”, à ce qui concerne les instructions à if ... else .

Le if sera remplacé que par un point d’interrogation (?) après l’expression booléenne, et le else par deux-points (:) après le bloc du if.

D’où un syntaxe du genre :

condition (expression booléenne) ? instruction1 : instruction2;

Voyons cela en exemple :

/*Exemple d'une instruction à if ... else
  utilisant les opérateurs ternaires ? ... :
*/
int age = 10;
(age >= 18) ? print("Est majeur.") : print("Est mineur.");

b. Le contrary check expression

C’est une expression qui utilise le signe d’exclamation (!) pour prendre la valeur contraire d’une expression ou d’une valeur. Simplement comprennons par un exemple :

//Exemple d'une contrary checking expression
  bool estMajeur = false;  
  if(!estMajeur){
    print('Tu es mineur');
  } else {
    print('Tu es majeur');
  }

/*Exemple d'une contrary checking expression
  avec les opérateurs ternaires
*/
  bool estMajeur = false;  
  !estMajeur ? print('Tu es mineur') : print('Tu es majeur');

Et voilà, nous n’avons pas eu à entrer plusieurs conditions, juste ce (!) a suffit pour prendre la valeur contraire de notre variable estMajeur .

Le message en dessous qui dit “Dead code … ” est une indication qu’offre Dart pour signaler qu’il y a un bout de code qui ne sera jamais exécuté, soit parce que le code est inaccessible car il est situé dans une instruction if qui ne sera jamais vraie, ce qui est notre cas vu que nous avons affecté d’une manière statique la valeur false à notre variable et cherchons son contraire qui true pour toujours donc la deuxième partie de la condition ne sera jamais exécuté tant qu’on n’a pas changer manuellement, dans d’autres cas qu’on retrouvera dans la suite du cours.

c. Le null checking expression

Le “null checking expression”, qui utilise deux points d’interrogation (??) pour vérifier si une expression1 ou une valeur1 est nulle et du coup exécuter l’instruction suivante (Donc renvoyer l’expression2 ou la valeur2).

Ce qui nous donne une expression de la forme :

expression1 (valeur1) ?? expression2 (valeur2)

Voyons cela dans un exemple :

//Exemple d'une null checking expression
dynamic estMajeur;
dynamic georges = estMajeur ?? 'Georges est Mineur';
print(georges);

//On peut aussi stocker ces deux valeurs dans deux variable puis checker
dynamic estMajeur;
dynamic estMineur = 'Georges est Mineur';
String georges = estMajeur ?? estMineur ;
print(georges);

Le constat fait est que la valeur de la variable estMajeur est nulle automatiquement notre variable georges a pris la deuxième valeur qui est “Georges est mineur”.

Essayons de donner une valeur à la première variable pour voir :

Bing !!! C’est la première valeur qui est prise en considération.

Quel magnifique langage 🤗

3. Les Instructions à if ... else if ... else

En regardant la structure de cette instruction, nous comprenons que c’est un mariage entre l’instruction à if et celle à if ... else .

Ces instructions fonctionnent de la sorte à avoir à tester plusieurs expressions booléennes avant de finir par exécuter le cas où toutes celles-ci sont fausses. Voyons cela en exemple pour une bonne compréhension :

//Exemple d'une instruction à if ... else if ... else
  int resultat = 40;
  if (resultat >= 90){
    print("Mention A");
  } else if (resultat >= 80){
    print("Mention B");
  } else if (resultat >= 70){
    print("Mention C");
  } else if (resultat >= 60){
    print('Mention D');
  } else if (resultat >= 50){
    print('Mention E');
  } else {
    print("Résultat trop bas");
  }

De même, nous pouvons aussi faire ce mariage avec les opérateurs ternaires vus précédemment et nous aurons quelque chose de ce genre :

/*Exemple d'une instruction à if ... else if ... else
  utilisant les opérateurs ternaires ? ...? ... :
*/
  int resultat = 40;
  (resultat >= 90)
    ? print("Mention A")
    : (resultat >= 80)
      ? print("Mention B")
      : (resultat >= 70)
        ? print("Mention C")
        : (resultat >= 60)
          ? print('Mention D')
          : (resultat >= 50)
            ? print('Mention E')
            : print("Résultat trop bas");

Cool non ! 😉

Ah ! J’adore Dart 💕

4. Les Instructions à switch

Enfin, nous avons les instructions à switch , elles sont utilisées pour exécuter du code en fonction de la valeur d'une variable entrer au début de l’algorithme.

Celles-ci permettent de faire une arborescence des instructions à if ... else if ... else d’une manière plus simple et propre je dirais.

Voyons cela avec notre exemple précédent qui renvoyait la mention de l’étudiant mais ici on aura une mention et cherchera si elle est équivaut à quel pourcentage ou quel rang :

//Exemple d'une instrcution à switch
  dynamic mention = "Y";

  switch (mention) {
    case "A":
      print("90% ou plus");
      break;
    case "B":
      print("80% ou plus");
      break;
    case "C":
      print("70% ou plus");
      break;
    case "D":
      print("60% ou plus");
      break;
    case "E":
      print("50% ou plus");
      break;
    default:
      print("Résultat trop bas");
  }

L’arborescence s’exécute par cas (case), si la valeur de notre variable mention se trouve dans un des cas(case), on l’exécute puis vient break une instruction qui vient nous sortir de l’arborescence de switch une fois le cas retrouvé, sinon on exécute le default ce qui est le cas de notre exemple, vu que la valeur de mention n’existe pas dans l’arborescence, on a exécuté la valeur de default .

5. Conclusion

Ainsi, nous venons de parcourir une autre grande notion de la programmation, les “conditions” ou “structures conditionnelles”, qui, en Dart, a été subdivisée en 4 grandes catégories dans notre cas, à savoir les instructions à if , les instructions à if ... else , les instructions à if ... else if ... else et celles à switch .

Au début, nous avons listé un groupe d’opérateurs en Dart qui nous permettra de travailler dans l’implémentation des conditions.

Aussi, nous avons eu à parler des petites notions qui rendent Dart attrayant et simple :

• les opérateurs ternaires condition ? instruction1 : instruction2 ;
• la contrary checking expression !expression
• la null checking expression expression1 ?? expression2 .

Merci encore et au prochain chapitre où nous verrons les structures itératives (Boucles).

Allez ! Portez-vous bien et n’oubliez pas : “Ne limitez pas vos rêves !”.

😉