Comment fonctionnent les boucles Do-While dans la programmation informatique

Lorsque vous apprenez à programmer, comprendre les éléments de base est la clé du succès précoce. Vous aborderez les sujets difficiles plus tard, mais si vous ne comprenez pas les types de variables, les boucles et les fonctions, il est difficile d'aller loin.

La plupart des nouveaux programmeurs découvrent les instructions if-else , boucles while , et boucles for avant longtemps. Mais l'un des types de boucles que vous ne comprenez peut-être pas est la boucle do-while . Voyons comment cette boucle fonctionne, quand vous voudrez l'utiliser, et regardons quelques exemples.

Les bases

Une boucle do-while exécute un bloc de code au moins une fois, vérifie si une condition est vraie, puis continue à exécuter le code à l'intérieur en fonction de la condition. Jetons un coup d'œil à un exemple simple de pseudocode (puisqu'ils vous aident à apprendre !) :

faire { 
 sortie "La variable x est égale à " + x ; 
 x++ ; 
 } tant que (x <5); 
 output "La boucle est terminée."; 
  

Dans ce bout de code, les lignes à l'intérieur du do les parenthèses s'exécutent toujours au moins une fois. Cela signifie que x peut être n'importe quelle valeur au début de la boucle.

Si x est égal à 1 lorsque la boucle démarre, elle se répétera jusqu'à x ne satisfait pas la condition à côté de while . Ainsi, il fonctionnerait un total de 5 fois. Quand x n'est pas inférieur à 5, la boucle se termine et continue sur le code suivant. Cette sortie ressemblerait à ceci :

La variable x vaut 1 La variable x vaut 2 La variable x vaut 3 La variable x vaut 4 La variable x vaut 5 La boucle est terminée. 

Inversement, si x était égal à 20 au démarrage de cette boucle, elle ne s'exécuterait qu'une seule fois. Ainsi, vous verriez une déclaration de sortie, x incrémente jusqu'à 21, et la boucle se terminerait car 21 n'est pas inférieur à 5. Sa sortie serait :

La variable x vaut 20 La boucle est terminée. 
  

Contraste avec les boucles While et For

Comment fonctionne un do-while boucle diffère des autres boucles? La distinction la plus importante est que les boucles do-while testent une condition après exécuter un bloc de code, tandis que d'autres boucles vérifient une condition avant exécuter le code à l'intérieur.

Considérez ce pseudo-code de base while boucle de comparaison :

x =10 ; 
 tandis que (x <5) { 
 output "La boucle a été exécutée !" ; 
 x++ ; 
 } 
  

Ici, x est défini sur 10 et le while boucle vérifie que x est inférieur à 5 avant de s'exécuter. Pour cette raison, le code à l'intérieur ne s'exécute jamais. Appliquer la même logique à une boucle do-while nous donne quelque chose comme ceci :

x =10 ; 
 fais { 
 output "La boucle a été exécutée !" ; 
 x++ ; 
 } tandis que (x <5) 
  

Cette boucle affichera le texte une fois, incrémenter x , puis continuez.

Notez que vous pouvez recréer la fonctionnalité do-while avec une instruction supplémentaire devant un while boucle, comme ceci :

sortie "Bonjour !" ; 
 x++ ; 
 tandis que (x <5) { 
 sortie "Bonjour !" ; 
 x++ ; 
 } 
  

Cependant, c'est maladroit et il n'y a aucune raison de le faire lorsqu'il existe des boucles do-while.

Boucles For

Les boucles Do-while ont une distinction similaire avec for boucles. Un pour loop définit une variable, spécifie la durée d'exécution de la boucle et définit un comportement pour la fin de chaque itération.

Voici un simple pour boucle de comparaison :

for (int je =0; je <5; je++) { 
 output "La boucle a exécuté " + i + " fois."; 
 } 
  

Cela met en évidence un bon contraste entre do-while et pour boucles -- vous savez exactement combien de fois un for boucle s'exécutera car vous avez défini les conditions au début. Si vous modifiez le code ci-dessus dans une boucle do-while comme celle-ci :

faire { 
 output "La boucle a exécuté " + i + " fois."; 
 je++ ; 
 } tant que (i <5); 
  

Vous pourriez vous retrouver avec un problème lorsque la boucle s'exécute. Si vous n'avez pas initialisé i ailleurs, vous ne savez pas quelle sera sa valeur quand le faire partie s'exécute -- et elle s'exécutera au moins une fois. Si je était de 500 lors de l'exécution de cette boucle, la sortie ici serait inexacte.

En résumé :

• Une boucle do-while est utile lorsque vous voulez exécuter une commande au moins une fois, et continuellement jusqu'à ce qu'une condition soit fausse.
• Une boucle while permet de répéter un bloc de code tant qu'une condition est vraie, et de s'arrêter dès que la condition n'est plus vraie.
• Une boucle for vous permet de spécifier exactement combien de fois la boucle doit s'exécuter en définissant vos propres paramètres.

Quitter une boucle Do-While

Bien sûr, vous devez avoir une condition de sortie pour les boucles do-while comme n'importe quelle autre. Sinon, vous pourriez vous retrouver avec une boucle infinie. Considérez l'extrait suivant :

x =5 ; 
 fais { 
 sortie "Cela ne finit jamais!"; 
 } tandis que (x <10); 
  

Si vous n'incrémentez pas x n'importe où ailleurs dans le code, cette boucle s'exécutera indéfiniment. Maintenant, les boucles infinies sont parfois utiles car le programmeur configure le code pour sortir de la boucle ailleurs. Mais le plus souvent, les codeurs novices se heurtent accidentellement à des boucles infinies.

Voici un exemple de boucle infinie appropriée. Disons que vous concevez un jeu où l'utilisateur lance un dé et doit obtenir un 6 pour quitter la base. Vous voulez continuer à lancer le dé jusqu'à ce qu'il atteigne le 6, et vous devez évidemment lancer au moins une fois. Ainsi, vous pourriez utiliser ce code :

faire { 
 int roll =random(1, 2, 3, 4, 5, 6); 
 si (lancer ==6) 
 Pause; 
 } tandis que (vrai); 
  

Le tandis que (vrai) condition signifie que cette boucle s'exécutera indéfiniment, ce que nous voulons car l'utilisateur doit rouler jusqu'à ce qu'il obtienne un 6. Sans la pause déclaration, il resterait bloqué. Mais une fois que l'utilisateur obtient un 6, le si devient vrai, et la séquence sort de la boucle et passe à ce qui suit.

Vous n'êtes pas obligé d'utiliser une instruction break si vous ne le souhaitez pas. En fait, il est probablement préférable d'éviter les instructions break si vous le pouvez. Ils rendent votre code plus difficile à maintenir et se terminer par une condition est plus facile à suivre. Ainsi, le code modifié ci-dessous atteint le même objectif :

faire { 
 int roll =random(1, 2, 3, 4, 5, 6); 
 } tant que (lancer !=6); 
  

Une mauvaise boucle infinie

Une boucle infinie dont vous avez l'intention de sortir, c'est bien. Mais parfois, vous créerez accidentellement une boucle infinie, comme dans l'exemple ci-dessous :

int x =7 ; 
 fais { 
 x =1 ; 
 x =x + 2 ; 
 sortie "x est égal à " + x ; 
 } tandis que (x <10); 
  

Cela pourrait donner l'impression qu'il incrémente x par 2 à chaque boucle et se répète jusqu'à ce que x ne soit pas inférieur à 10, mais regardez de plus près. Parce que la boucle définit x égal à 1 chaque fois qu'il s'exécute, il s'agit d'une boucle infinie. Notez que x =1 et x =x + 2 signifie que x est toujours 3 à la fin du bloc, peu importe le nombre de fois qu'il s'exécute, ce qui signifie x n'est jamais inférieur à 10.

Surveillez les instructions à l'intérieur de votre boucle qui modifient involontairement une variable à chaque exécution pour éviter des situations comme celle-ci.

Exemples concrets

Nous avons discuté de quelques exemples hypothétiques ci-dessus, mais jetons un coup d'œil à quelques exemples concrets utiles de boucles do-while.

Si vous créiez une boucle pour lire les données d'un fichier jusqu'à ce qu'il atteigne la fin, vous utiliseriez une boucle do-while. Évidemment, vous devez saisir au moins un caractère si vous prévoyez de lire à partir d'un fichier, vous pouvez donc utiliser une boucle do-while comme celle-ci (merci à l'utilisateur de Stack Exchange Steven Burnap pour cet exemple) :

faire { 
 résultat =readData(buffer); 
 } tandis que (résultat !=EOF); 
  

Sans do-while, vous devriez utiliser une solution légèrement plus laide :

tandis que (vrai) { 
 résultat =readData(buffer); 
 si (résultat ==EOF) 
 Pause; 
 } 
  

Un autre exemple consiste à saisir l'entrée d'un utilisateur. Disons que vous écrivez un programme qui demande à l'utilisateur d'entrer un nombre positif. En utilisant un do-while, vous pouvez vous assurer que leur entrée est appropriée :

faire { 
 sortie "Veuillez entrer un nombre positif :" ; 
 entrée entière =getInput(); 
 } tandis que (entrée <0); 
  

Avec cette boucle, l'utilisateur voit l'invite à entrer un nombre et entre une valeur une fois. S'ils entrent un nombre négatif, la boucle s'exécute à nouveau et ils sont invités à entrer un nombre positif jusqu'à ce qu'ils se conforment. D'autres boucles n'ont tout simplement pas de sens pour ce type d'action.

Prêt à utiliser les boucles Do-While ?

Nous avons mené une enquête sur les boucles do-while, y compris leurs principes de base, comment les utiliser au mieux et comment elles se comparent aux autres boucles. Si vous ne vous souvenez de rien d'autre dans cet article, sachez que les boucles do-while sont destinées lorsque vous devez exécuter quelque chose au moins une fois, mais que vous ne savez pas combien de fois vous en aurez besoin avant de lancer le boucle .

Pensez à des situations comme celle-ci dans vos programmes, et vous trouverez facilement des endroits où les boucles do-while s'intègrent. Presque tous les meilleurs langages pour débutants prennent en charge les boucles do-while, vous ne devriez donc avoir aucun problème à les implémenter.

Si vous apprenez les bases, assurez-vous de consulter nos meilleures astuces pour maîtriser un nouveau langage de programmation.

À quelles autres situations pouvez-vous penser où un do-while a du sens ? Discutez et faites-nous savoir si vous utilisez des boucles do-while dans vos programmes dans la section des commentaires !

Crédit image :Aaban via Shutterstock.com