C # loop – break vs. continue

break sortira complètement de la boucle, continue simplement l’itération en cours.

Par exemple:

 for (int i = 0; i < 10; i++) { if (i == 0) { break; } DoSomeThingWith(i); } 

La rupture provoquera la sortie de la boucle lors de la première itération - DoSomeThingWith ne sera jamais exécuté. Ça ici:

 for (int i = 0; i < 10; i++) { if(i == 0) { continue; } DoSomeThingWith(i); } 

DoSomeThingWith pas DoSomeThingWith pour i = 0 , mais la boucle continuera et DoSomeThingWith sera exécuté pour i = 1 à i = 9 .

Un moyen très simple de comprendre cela est de placer le mot “loop” après chacun des mots-clés. Les termes ont maintenant du sens s’ils sont simplement lus comme des phrases de tous les jours.

break loop – le bouclage est rompu et s’arrête.

continue loop – la boucle continue à s’exécuter avec la prochaine itération.

break provoque le saut du programme hors de la scope de la boucle la plus interne

 for(i = 0; i < 10; i++) { if(i == 2) break; } 

Fonctionne comme ça

 for(i = 0; i < 10; i++) { if(i == 2) goto BREAK; } BREAK:; 

continuer à sauter à la fin de la boucle. Dans une boucle for, continuez jusqu'à l'expression d'incrément.

 for(i = 0; i < 10; i++) { if(i == 2) continue; printf("%d", i); } 

Fonctionne comme ça

 for(i = 0; i < 10; i++) { if(i == 2) goto CONTINUE; printf("%d", i); CONTINUE:; } 

break arrêterait complètement la boucle foreach , continue au prochain DataRow .

Il y a plus que quelques personnes qui n’aiment pas la break et continue . La dernière plainte que j’ai vue à leur sujet était en JavaScript: The Good Parts de Douglas Crockford. Mais je trouve que parfois, l’utilisation de l’un d’eux simplifie vraiment les choses, surtout si votre langage ne comprend pas un style de boucle à do-until ou à do-until .

J’ai tendance à utiliser des boucles d’ break qui recherchent quelque chose dans une liste. Une fois trouvé, il ne sert à rien de continuer, alors vous pourriez tout aussi bien quitter.

J’utilise continue lorsque je fais quelque chose avec la plupart des éléments d’une liste, mais je veux tout de même en sauter quelques-uns.

La déclaration de break est également utile lors de la recherche d’une réponse valide de la part de quelqu’un ou de quelque chose. Au lieu de:

 Ask a question While the answer is invalid: Ask the question 

Vous pourriez éliminer certains doublons et utiliser:

 While True: Ask a question If the answer is valid: break 

La boucle à do-until que j’ai mentionnée précédemment est la solution la plus élégante à ce problème particulier:

 Do: Ask a question Until the answer is valid 

Pas de duplication et pas de break non plus.

Tous ont donné une très bonne explication. Je publie toujours ma réponse pour donner un exemple si cela peut aider.

 // break statement for (int i = 0; i < 5; i++) { if (i == 3) { break; // It will force to come out from the loop } lblDisplay.Text = lblDisplay.Text + i + "[Printed] "; } 

Voici la sortie:

0 [Imprimé] 1 [Imprimé] 2 [Imprimé]

So 3 [Printed] & 4 [Printed] ne sera pas affiché car il y a une rupture quand i == 3

 //continue statement for (int i = 0; i < 5; i++) { if (i == 3) { continue; // It will take the control to start point of loop } lblDisplay.Text = lblDisplay.Text + i + "[Printed] "; } 

Voici la sortie:

0 [Imprimé] 1 [Imprimé] 2 [Imprimé] 4 [Imprimé]

Donc 3 [Imprimé] ne sera pas affiché car il y a continuer quand i == 3

J’avais toujours l’habitude de me demander si je devais utiliser la pause ou continuer. C’est ce qui m’aide à me rappeler:

Quand utiliser pause vs continuer?

1. Break – c’est comme casser. C’est sortingste, vous vous séparez.

2. Continuer – signifie que vous allez vous reposer aujourd’hui et tout régler demain (c.-à-d. Ignorer l’itération actuelle)!

Pause

Break force une boucle à sortir immédiatement.

Continuer

Cela fait le contraire de la rupture. Au lieu de terminer la boucle, il reboucle immédiatement, ignorant le rest du code.

Par exemple

 foreach(var i in Enumerable.Range(1,3)) { Console.WriteLine(i); } 

Imprime 1, 2, 3 (sur des lignes séparées).

Ajouter une condition de rupture à i = 2

 foreach(var i in Enumerable.Range(1,3)) { if (i == 2) break; Console.WriteLine(i); } 

Maintenant, la boucle imprime 1 et s’arrête.

Remplacez la pause par une poursuite.

 foreach(var i in Enumerable.Range(1,3)) { if (i == 2) continue; Console.WriteLine(i); } 

Maintenant, pour boucler les impressions 1 et 3 (saut 2).

Ainsi, break arrête la boucle, alors que continue passe à la prochaine itération.

Ruby est malheureusement un peu différent. PS: Ma mémoire est un peu floue sur ce point, alors excuses si je me trompe

au lieu de break / continue, il y a break / next, qui se comportent de la même manière en termes de boucles

Les boucles (comme tout le rest) sont des expressions et “renvoient” la dernière chose qu’elles ont faite. La plupart du temps, obtenir la valeur de retour d’une boucle est inutile, alors tout le monde le fait

 a = 5 while a < 10 a + 1 end 

Vous pouvez cependant le faire

 a = 5 b = while a < 10 a + 1 end # b is now 10 

Cependant, beaucoup de code Ruby «émule» une boucle en utilisant un bloc. L’exemple canonique est

 10.times do |x| puts x end 

Comme il est beaucoup plus courant pour les gens de vouloir faire les choses avec le résultat d’un bloc, c’est là que ça devient désordonné. break / next signifie différentes choses dans le contexte d'un bloc.

pause va sauter du code qui a appelé le bloc

next ignorera le rest du code dans le bloc et 'renverra' ce que vous spécifiez à l'appelant du bloc. Cela n'a aucun sens sans exemples.

 def timesten 10.times{ |t| puts yield t } end timesten do |x| x * 2 end # will print 2 4 6 8 ... and so on timesten do |x| break x * 2 end # won't print anything. The break jumps out of the timesten function entirely, and the call to `puts` inside it gets skipped timesten do |x| break 5 x * 2 end # This is the same as above. it's "returning" 5, but nobody is catching it. If you did a = timesten... then a would get assigned to 5 timesten do |x| next 5 x * 2 end # this would print 5 5 5 ... and so on, because 'next 5' skips the 'x * 2' and 'returns' 5. 

Donc voilà. Ruby est génial, mais il y a de très mauvais casiers. C'est le deuxième pire que j'ai vu dans mes années d'utilisation 🙂

Réponse simple:

La rupture quitte la boucle immédiatement.
Continuer commence le traitement de l’article suivant. (S’il y en a, en sautant à la ligne d’évaluation du pour / tout)

S’il vous plaît laissez-moi énoncer l’évidence: notez que l’ajout ni pause ni continuer, va reprendre votre programme; c’est-à-dire que je suis resté coincé pour une certaine erreur, puis après l’être connecté, je voulais reprendre le traitement, et il y avait plus de tâches de code entre la ligne suivante, alors je l’ai laissé tomber.

Pour sortir complètement d’une boucle foreach, le break est utilisé;

Pour aller à la prochaine itération de la boucle, continue est utilisé;

Le saut est utile si vous parcourez une collection d’objects (comme des lignes dans une liste de données) et que vous recherchez une correspondance particulière, lorsque vous trouvez cette correspondance, vous n’avez pas besoin de continuer à traverser les lignes restantes afin de rompre en dehors.

Continuer est utile lorsque vous avez accompli ce dont vous avez besoin pour effectuer une itération en boucle. Vous aurez normalement continuer après un si .

Si vous ne voulez pas utiliser break, vous augmentez simplement la valeur de I de manière à ce que la condition d’itération soit fausse et que la boucle ne s’exécute pas à la prochaine itération.

 for(int i = 0; i < list.Count; i++){ if(i == 5) i = list.Count; //it will make "i