Back

Les Boucles en Dart

les boucles en dart

  1. Présentation

    • Dans les langages de programmation, les boucles permettent à un bloc de code d’être exécuté à plusieurs fois.
    • Une boucle est définie comme un segment de code qui s’exécute plusieurs fois.
    • L’itération fait référence au processus dans lequel le segment de code est exécuté une fois. Une itération fait référence à l’exécution unique d’une boucle. Une boucle peut subir plusieurs itérations.
    • Le langage Dart fournit les types de boucles suivants :
      • for
      • for..in
      • while
      • do..while
  2. La boucle for en Dart

    • Comme dans la plupart des les langages, la boucle for dans le langage Dart, permet de répéter une expression un certain nombre de fois.
    • La boucle For dans Dart est similaire à celle de Java et le flux d’exécution est également le même que celui de Java
    • La boucle for est une boucle à pré-condition. Cela veut dire la condition est évaluée avant l’exécution de l’expression. Si cette condition est vraie, la portion de code est exécutée sinon toute la boucle est terminée et le programme continue.
    • Syntaxe et interprétation du boucle for.
      • for (initialisation, condition, itération ){
            expression
        }
        • initialisation :
          • Spécifie l’initialisation de la boucle. Il permet d’initialiser un compteur qui sera ensuite utilisé dans la boucle.
          • Dans la boucle for, l’initialisation se produit d’abord et une seule fois, ce qui signifie que la partie d’initialisation de la boucle for ne s’exécute qu’une seule fois.
        • condition :
          • Si l’expression est vraie true, l’ expression est exécutée puis l’itération est évaluée (s’il en existe une). Si la condition est omise elle est considérée comme vrai true. Si la condition est fausse false , l’instruction for se termine et le contrôle passe à l’instruction suivante du programme.
          • La condition dans la boucle for est évaluée à chaque itération, si la condition est vraie, les instructions à l’intérieur du corps de la boucle for sont exécutées.
          • Une fois que la condition renvoie false, les instructions de la boucle for ne s’exécutent pas et le contrôle est transféré à l’instruction suivante du programme après la boucle for.
        • itération :
          • est une expression qui s’ exécute à chaque itération de la boucle après l’ exécution de la portion de code de la boucle. L’ itération est généralement une incrémention ou une décrémentation.
          • Après chaque exécution du corps de la boucle for, la partie incrémentation/décrémentation de la boucle for s’exécute et met à jour le compteur de boucle.
    • Exemple
      • for (var compteur = 1; compteur <= 3 ; compteur++){
            print("la valeur du compteur est $compteur");
        }
        /* Output
        la valeur du compteur est 1
        la valeur du compteur est 2
        la valeur du compteur est 3*/
    • Application
      • Afficher les nombres de 1 à 10 à l'aide de la boucle for
        • void main() {
            for (int i = 1; i <= 10; i++) {
              print(i);
            }
          }
      • Afficher les nombres de 10 à 1 à l'aide de la boucle for
        • void main() {
            for (int i = 10; i >= 1; i--) {
              print(i);
            }
          }
  3. La boucle for..in

    • La boucle For…in dans Dart prend une expression ou un objet comme itérateur. Il est similaire à celui de Java et son flux d’exécution est également le même que celui de Java.
    • Cette boucle permet de faire une itération dans une collection liste, ensemble ou dictionnaire. la boucle for .. in est une boucle de parcours . C'est à dire que la boucle est exécutée sur chacun des éléments d'une collection.
    • Syntaxe et interprétation du boucle for..in.
      • for (var in expression) {
           // Body of loop
        }
    • Exemple
      • var langues = ['Français', 'Anglais', 'Espagnol', 'Arabe'];
        for (var l in langues){
            print(l);
        }
        /* Output
        Français
        Anglais
        Espagnol
        Arabe*/
  4. La boucle while

    • Le mot while se traduit par tant que. Alors cette boucle s'exécute tant que sa condition est vraie.
    • La boucle while est une boucle à pré-condition. Cela veut dire que la condition est évaluée avant l' exécution de l'expression.
    • Syntaxe et interprétation du boucle While.
      • while(condition){
            text expression;
        }
    • Exemple
      • void main() {
          int i = 0;
          while (i < 5) {
            print("index : $i");
            i += 1; // i=i+1
          }
        }
        /* Output
        index : 0
        index : 1
        index : 2
        index : 3
        index : 4*/
  5. Boucle Do-While dans Dart

    • La boucle do..while répète une séquence d'instructions tant que la condition est vraie.
    • La boucle do..while exécute d'abord les instructions, puis vérifie la condition. Si la condition est vraie, elle continuera à s'exécuter et si la condition est fausse, la boucle se terminera.
    • Syntaxe et interprétation du boucle Do-While.
      • do {
            // ...
            Bloc d'instructions
            // ...
        }
        while (condition);
    • Exemple
      • void main() {
          int i = 4;
          int j = 0;
          do {
            print("index : $j");
            j += 1;
          } while (j <= i);
        }
        /* Output
        index : 0
        index : 1
        index : 2
        index : 3
        index : 4*/
  6. Applications

    • App01
      • Écrire un programme Dart qui vérifie si un nombre saisie par l'utilisateur est premier ou non
        • Le programme doit afficher un message pour les deux cas.
          Solution
          import 'dart:io';
          import 'dart:math';
          
          void main() {
            print('Veuillez saisir un nombre pour vérifier s\'il est premier ou non');
            int? nbr = int.parse(stdin.readLineSync()!);
            print('$nbr');
            if (verifierPremier(nbr)) {
              print('$nbr est un nombre premier');
            } else {
              print('$nbr n\'est pas premier');
            }
          }
          
          bool verifierPremier(int nbr) {
            if (nbr <= 1) {
              return false;
            }
            for (int i = 2; i <= sqrt(nbr); i++) {
              if (nbr % i == 0) {
                return false;
              }
            }
            return true;
          }
          
    • App02
      • Écrire un programme Dart qui permet d'afficher la liste de tous les nombres premiers inférieurs 100.
        • Un nombre premier est un entier naturel qui admet exactement deux diviseurs distincts entiers et positifs. Ces deux diviseurs sont 1 et le nombre considéré, puisque tout nombre a pour diviseurs 1 et lui-même comme le montre l’égalité les nombres premiers étant ceux qui n’en possèdent aucun autre.

          Solution
          void main() {
            print("Liste des nombres premiers inférieurs 100:");
            print('----------------------------');
            for (int i = 2; i <= 100; i++) {
              verifierPremier(i);
            }
          }
          
          void verifierPremier(int nbrPremiers) {
            int i, j = 0;
            bool nbrTrouve = false;
            j = nbrPremiers ~/ 2;
            //print("La valeur de j est :$j");
            for (i = 2; i <= j; i++) {
              if (nbrPremiers % i == 0) {
                nbrTrouve = true;
                break;
              }
            }
            if (nbrTrouve == false) {
              print('$nbrPremiers');
            }
          }
          
    • App03
      • Écrire un programme Dart qui permet de rechercher la liste de tous les nombres premiers inférieurs à un nombre donné (saisie par l'utilisateur)
        • Solution
          import 'dart:io';
          
          void main() {
            print(
                "Les nombres premiers inférieurs à un nombre saisie par l'utilisateur:");
            print('Veuillez saisir un nombre entier positif');
            int? nbr = int.parse(stdin.readLineSync()!);
            print("Liste des nombres premiers inférures à $nbr");
            print('----------------------------');
            for (int i = 2; i <= nbr; i++) {
              verifierPremier(i);
            }
          }
          
          void verifierPremier(int nbrPremiers) {
            int i, j = 0;
            bool nbrTrouve = false;
            j = nbrPremiers ~/ 2;
            //print("La valeur de j est :$j");
            for (i = 2; i <= j; i++) {
              if (nbrPremiers % i == 0) {
                nbrTrouve = true;
                break;
              }
            }
            if (nbrTrouve == false) {
              print('$nbrPremiers');
            }
          }
          
    • App04
      • Écrire un programme en langage Dart qui affiche les 100 premiers nombres entiers sur la même ligne.
      • Le résultat doit correspondre au schéma suivant:
      • Les Boucles en Dart

      • Afficher la somme des nombres pairs, impairs et premiers
        • Solution
          import 'dart:io';
          
          void main() {
            int sommePair = 0, sommeImpair = 0, sommePremiers = 0;
            for (int i = 2; i <= 100; i++) {
              if (i % 2 == 0) {
                sommePair += i;
              } else {
                sommeImpair += i;
              }
              if (verifierPremier(i)) {
                sommePremiers += i;
              }
              if (i != 100) {
                stdout.write("$i, ");
              } else {
                stdout.write(i);
              }
            }
            print("\nLa somme des nombres pairs est: $sommePair");
            print("La somme des nombres impairs est: $sommeImpair");
            print("La somme des nombres premiers est: $sommePremiers");
          }
          
          bool verifierPremier(int num) {
            int j = 0;
            if (num <= 1) {
              return false;
            }
            j = num ~/ 2;
            for (int i = 2; i <= j; i++) {
              if (num % i == 0) {
                return false;
              }
            }
            return true;
          }
          
    • App05
      • Écrire un programme Dart qui demande à l'utilisateur un nombre compris entre 1 et 3 jusqu’à ce que la réponse convienne.
        • Solution
          import 'dart:convert';
          import 'dart:io';
          
          void main() {
            int nbr = 0;
            int i = 1;
            print("Veuillez saisir un nombre entre 1 et 3");
            do {
              print(
                  'Essaie de saisie numéro: $i est: ${nbr = int.parse(stdin.readLineSync()!)}');
              i += 1;
            } while (nbr < 1 || nbr > 3);
            print("--------------------Fin du programme-------------------------------");
          }
          
    • App06
      • Écrire un programme Dart qui demande un nombre compris entre 10 et 20, jusqu’à ce que la réponse convienne.
        • En cas de réponse supérieure à 20, on fera apparaître un message : "Plus petit ! ", et inversement, " Plus grand !" si le nombre est inférieur à 10.
        • En cas de réponse juste le programme affiche le nombre des essaies total et les essaies "Plus petit ! " et " Plus grand !
          Solution

          import 'dart:io';
          
          void main() {
            int nbr = 0;
            int i = 1;
            int nbrPlusPetit = 0, nbrPlusGrand = 0;
            print("Veuillez saisir un nombre entre 10 et 20");
            do {
              print(
                  'Essaie de saisie numéro: $i est: ${nbr = int.parse(stdin.readLineSync()!)}');
              if (nbr < 10) {
                print("Plus petit !");
                nbrPlusPetit += 1;
              } else if (nbr > 20) {
                print("Plus grand !");
                nbrPlusGrand += 1;
              }
              i += 1;
            } while (nbr < 10 || nbr > 20);
            print("Nombre des essaies 'Plus grand !' est: $nbrPlusGrand");
            print("Nombre des essaies 'Plus petit !' est : $nbrPlusPetit");
            print("Nombre total des essaies est : ${i - 1}");
          
            print("--------------------Fin du programme-------------------------------");
          }
          

    • App07
      • Écrire un programme Dart avec une boucle do..while qui compte de 3 à 22 selon le modèle suivant :3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
        • Solution

          import 'dart:io';
          
          void main() {
            int i = 3;
            do {
              stdout.write("$i ");
              i += 1;
            } while (i < 23);
          }
          

    • App08
      • Écrire un programme Dart qui affiche "apcpedagogie est cool." 5 fois avec toutes les boucles.
        • Solution
          void main() {
            // Boucle for
            for (var m = 0; m < 5; m++) {
              print("apcpedagogie est cool.");
            }
            // Boucle While
            var i = 0;
            while (i != 5) {
              print("apcpedagogie est cool.");
              i++;
            }
            // Boucle DoWhile
            var x = 0;
            do {
              print("apcpedagogie est cool.");
              x++;
            } while (x != 5);
          }
    • App09
      • Écrire un programme Dart qui affiche une liste incrémenté des nombres inférieurs à nbr à l'aide de la boucle for
        • Le nombre nbr est donnée par l'utilisateur
        • Afficher la somme des nombres affichés.
          Solution

          import 'dart:io';
          
          void main() {
            print('Veuillez saisir un nombre');
            int? nbr = int.parse(stdin.readLineSync()!);
            int somme = 0;
            for (int i = nbr; i >= 1; i--) {
              somme += i;
              stdout.write("$i ");
            }
            print("\nLa somme des nombres est: $somme");
          }
          



Riadh HAJJI

Abonnez vous à notre chaîne YouTube gratuitement