Flux de contrôle Dart

Le flux de contrôle détermine l'ordre d'exécution du code dans un programme.

Ce chapitre présente les jugements conditionnels (if/else, switch) et les instructions de boucle (for, while) en Dart, ainsi que l'utilisation de break et continue.


Instructions conditionnelles if / else / else if

L'instruction if est la structure de flux de contrôle la plus élémentaire ; elle décide s'il faut exécuter une portion de code en fonction d'une condition.

Exemple

Instructions if de base :

void main() {
  int score = 85;

  // If de base : s'exécute lorsque la condition est vraie
  if (score >= 60) {
    print(EXEMPLE, félicitations, vous avez réussi !);
  }

  // if-else : choisir l'un des deux
  if (score >= 90) {
    print('Excellent');
  } else {
    print(Continuez comme ça !);
  }

  // if-else if-else : sélection à branches multiples
  if (score >= 90) {
    print(Note : A);
  } else if (score >= 80) {
    print(Note : B);
  } else if (score >= 70) {
    print(Note : C);
  } else if (score >= 60) {
    print(Note : D);
  } else {
    print(Note : F (échec));
  }
}
EXAMPLE 恭喜,你及格了!
继续加油
等级:B

En Dart, les expressions conditionnelles doivent être de type bool. Vous ne pouvez pas utiliser 0, '', null, etc. comme conditions à la manière de JavaScript—cela provoquera directement des erreurs de compilation en Dart.

Instructions if imbriquées

Les instructions if peuvent être imbriquées les unes dans les autres pour gérer une logique plus complexe.

Exemple

void main() {
  bool isLoggedIn = true;
  bool isAdmin = false;
  String username = 'example';

  if (isLoggedIn) {
    // Vérification externe : si connecté
    if (isAdmin) {
      // Vérification interne : si administrateur
      print(Bon retour, admin $username);
    } else {
      print(Bon retour, $username);
    }
  } else {
    print(Veuillez d'abord vous connecter);
  }
}
欢迎回来,example

Trop de niveaux d'imbrication peuvent réduire la lisibilité ; il est recommandé de ne pas dépasser 3 niveaux.

Si la logique est vraiment complexe, envisagez d'utiliser des retours anticipés ou de diviser les fonctions pour simplifier.

Exemple

Remplacer l'imbrication profonde par des retours anticipés :

// Utilisez un retour anticipé au lieu d'une imbrication profonde pour une meilleure lisibilité
String getAccessMessage(bool isLoggedIn, bool isAdmin, String name) {
  // Gérer d'abord le cas « retour si la condition n'est pas remplie »
  if (!isLoggedIn) {
    return Veuillez d'abord vous connecter;
  }

  if (!isAdmin) {
    return 'Vous n'avez pas les permissions d'administrateur';
  }

  // Enfin, la logique principale
  return 'Bon retour, admin $name';
}

void main() {
  print(getAccessMessage(true, false, 'exemple'));
  print(getAccessMessage(true, true, 'exemple'));
}
你没有管理权限
欢迎回来,管理员 example

sélection multi-branches switch / case

Lorsqu'une variable possède plusieurs valeurs fixes possibles, switch est plus clair que if-else if.

Exemple

void main() {
  String day = 'Mercredi';

  switch (day) {
    case 'Lundi':
      print('Une nouvelle semaine a commencé');
      break;  // break termine le cas actuel, empêchant le 'fall-through' vers le cas suivant
    case 'Mardi':
      print('Le deuxième jour de travail acharné');
      break;
    case 'Mercredi':
      print('Au milieu de la semaine');
      break;
    case 'Jeudi':
      print('Bientôt vendredi');
      break;
    case 'Vendredi':
      print('Enfin vendredi !');
      break;
    case 'Samedi':
    case 'Dimanche':
      // Plusieurs cas peuvent partager un même bloc de code
      print('Bon week-end !');
      break;
    default:
      // S'exécute lorsqu'aucun cas ne correspond
      print('Date inconnue');
  }
}
The week is half over.

Le switch de Dart ne passe pas automatiquement d'un cas à l'autre ; chaque cas non vide doit se terminer par break, return, throw ou continue. Si vous voulez obtenir un effet de passage au cas suivant, utilisez continue avec une étiquette.

expression switch (Dart 3.0+)

Dart 3.0 a introduit les expressions switch, qui peuvent produire directement des valeurs, ce qui rend la syntaxe plus concise.

Exemple

void main() {
  String day = 'Mercredi';

  // expression switch : renvoie directement une valeur
  String mood = switch (day) {
    'lundi' => 'Un peu somnolent',
    'mardi' => 'Commence à s'adapter',
    'mercredi' => 'Plein d'énergie',
    'jeudi' => 'J'ai hâte d'être au week-end',
    'vendredi' => 'De bonne humeur',
    'samedi' || 'dimanche' => 'Insouciant',
    _ => 'Inconnu'  // _ est un joker, équivalent à default
  };

  print('EXEMPLE humeur: $mood');
}
EXAMPLE 心情: 干劲十足

Les expressions switch nécessitent de couvrir tous les cas possibles ; le compilateur vous aidera à vérifier les omissions.


Boucle for

La boucle for est la structure de boucle la plus courante, adaptée lorsque vous connaissez le nombre d'itérations.

Boucle for standard

Exemple

void main() {
  // Boucle for standard : initialisation ; condition ; mise à jour
  for (int i = 1; i <= 5; i++) {
    print('EXAMPLE loop $i');
  }

  // La variable de boucle peut aussi être déclarée en dehors
  int j = 0;
  for (; j < 3; j++) {
    print('j = $j');
  }
}
EXAMPLE 第 1 次循环
EXAMPLE 第 2 次循环
EXAMPLE 第 3 次循环
EXAMPLE 第 4 次循环
EXAMPLE 第 5 次循环
j = 0
j = 1
j = 2

boucle for-in (parcours des collections)

for-in est la façon la plus simple d'itérer sur des collections comme List et Set.

Exemple

void main() {
  List<String> fruits = [Apple, Banana, Orange, 'Grape'];

  // for-in : parcourt les éléments de la collection un par un
  for (var fruit in fruits) {
    print(EXAMPLE Fruit: $fruit);
  }
}
EXAMPLE 水果: 苹果
EXAMPLE 水果: 香蕉
EXAMPLE 水果: 橙子
EXAMPLE 水果: 葡萄

méthode forEach

List et Set fournissent également la méthode forEach, qui utilise une fonction de rappel pour traiter chaque élément.

Exemple

void main() {
  List<int> scores = [85, 92, 78, 60];

  // forEach : exécuter la fonction de rappel pour chaque élément
  scores.forEach((score) {
    String result = score >= 60 ? 'Pass' : 'Fail';
    print(EXEMPLE Score: $score -> $result);
  });
}
EXAMPLE 分数: 85 -> 及格
EXAMPLE 分数: 92 -> 及格
EXAMPLE 分数: 78 -> 及格
EXAMPLE 分数: 60 -> 及格

boucles while et do-while

La boucle while vérifie la condition avant chaque itération, ce qui convient aux scénarios où le nombre d'itérations est incertain.

Exemple

void main() {
  // while : vérifier d'abord la condition, puis exécuter
  int count = 3;
  while (count > 0) {
    print(EXEMPLE Compte à rebours: $count);
    count--;  // N'oubliez pas de mettre à jour la variable de condition, sinon ce sera une boucle infinie
  }
  print(Lancement !);
}
EXAMPLE 倒计时: 3
EXAMPLE 倒计时: 2
EXAMPLE 倒计时: 1
发射!

La différence entre do-while et while est que la boucle do-while exécute le corps de la boucle au moins une fois, car la condition est vérifiée à la fin.

Exemple

void main() {
  // do-while: exécuter une fois d'abord, puis vérifier la condition
  int num = 0;
  do {
    print(EXAMPLE s'exécute au moins une fois, num = $num);
    num++;
  } while (num < 0);  // La condition est fausse dès le départ

  print(Boucle terminée, num = $num);
}
EXAMPLE 至少执行一次,num = 0
循环结束,num = 1

La boucle do-while garantit que le corps de la boucle s'exécute au moins une fois, même si la condition n'est pas remplie dès le départ. Cela est utile dans les scénarios "essayer d'abord, puis évaluer", comme la lecture de la saisie utilisateur jusqu'à ce qu'elle soit valide.

while vs for : comment choisir

ScénariosBoucle recommandéeRaison
Nombre d'itérations déterminéforInitialisation, condition et mise à jour écrites ensemble, clair au premier coup d'œil
Nombre d'itérations indéterminéwhileSe concentrer uniquement sur la condition, plus flexible
S'exécute au moins une foisdo-whileExécuter d'abord, puis évaluer
Parcours de collectionsfor-in ou forEachLa manière la plus concise de parcourir des collections

break et continue

break sert à quitter immédiatement toute la boucle, tandis que continue sert à sauter l'itération en cours et à passer à la suivante.

Exemple

void main() {
  // break : arrêter la boucle immédiatement après avoir trouvé la cible
  List<String> names = ['Alice', 'Bob', 'example', 'David'];

  for (var name in names) {
    print(Check: $name);
    if (name == 'example') {
      print(EXAMPLE trouvé !);
      break;  // Quitter la boucle, ne plus vérifier les éléments suivants
    }
  }

  print(---séparateur---);

  // continue : sauter l'itération actuelle
  for (int i = 1; i <= 5; i++) {
    if (i == 3) {
      continue;  // sauter l'itération i=3
    }
    print('EXAMPLE itération $i');
  }
}
检查: Alice
检查: Bob
检查: example
找到 EXAMPLE 了!
---分隔线---
EXAMPLE 第 1 次
EXAMPLE 第 2 次
EXAMPLE 第 4 次
EXAMPLE 第 5 次

Break et continue étiquetés

Dans les boucles imbriquées, les étiquettes permettent de sortir d'une boucle externe spécifiée.

Exemple

void main() {
  // L'étiquette outerLoop marque la boucle externe
  outerLoop:
  for (int i = 1; i <= 3; i++) {
    for (int j = 1; j <= 3; j++) {
      print('i=$i, j=$j');
      if (i == 2 && j == 2) {
        print('Cible trouvée, sortir de la boucle externe');
        break outerLoop;  // Sortir de la boucle externe étiquetée outerLoop
      }
    }
  }
  print('Loop ended');
}
i=1, j=1
i=1, j=2
i=1, j=3
i=2, j=1
i=2, j=2
找到目标,退出外层循环
循环结束

Les étiquettes doivent être utilisées avec prudence. Dans la plupart des cas, il est plus clair d'extraire la logique des boucles imbriquées dans des fonctions indépendantes et d'utiliser return pour sortir.

autres extensions