Boucle C # - pause vs continuer

Dans une boucle C # (n'hésitez pas à répondre pour d'autres langages), quelle est la différence entre break et continue pour quitter la structure de la boucle et passer à l'itération suivante?

Exemple:

foreach (DataRow row in myTable.Rows)
{
    if (someConditionEvalsToTrue)
    {
        break; //what's the difference between this and continue ?
        //continue;
    }
}

breakquittera complètement la boucle, sauteracontinue simplement l'itération en cours.

Par exemple:

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

    DoSomeThingWith(i);
}

La rupture entraînera la sortie de la boucle à la première itération - DoSomeThingWithne sera jamais exécutée. Ça ici:

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

    DoSomeThingWith(i);
}

N'exécutera pas DoSomeThingWithpour i = 0, mais la boucle continuera et DoSomeThingWithsera exécutée pour i = 1to i = 9.

Un moyen très simple de comprendre cela est de placer le mot "boucle" après chacun des mots clés. Les termes ont désormais un sens s'ils sont simplement lus comme des phrases de tous les jours.

break loop - le bouclage est interrompu et s'arrête.

continue loop - la boucle continue de s'exécuter avec l'itération suivante.

break fait sauter le compteur de programmes hors de la portée de la boucle la plus intérieure

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 les sauts jusqu'à la fin de la boucle. Dans une boucle for, continuez de sauter à l'expression d'incrémentation.

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:;
}

J'étais toujours confus si je devais utiliser pause ou continuer. C'est ce qui m'aide à me souvenir:

Quand utiliser break vs continue?

1. Break - c'est comme rompre. C'est triste, vous vous séparez. La boucle est fermée.

2. Continuer - signifie que vous allez vous reposer aujourd'hui et trier le tout demain (c'est-à-dire sauter l'itération actuelle)!

breakarrêterait foreachcomplètement la boucle, continuepasserait à la suivante DataRow.

Il y a plus de quelques personnes qui n'aiment pas breaket 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 utiliser l'un d'eux simplifie vraiment les choses, surtout si votre langue n'inclut pas de style do-whileou do-untilde boucle.

J'ai tendance à utiliser des breakboucles qui recherchent quelque chose dans une liste. Une fois trouvé, il ne sert à rien de continuer, vous pouvez donc aussi bien arrêter.

J'utilise continuelorsque je fais quelque chose avec la plupart des éléments d'une liste, mais je veux quand même en sauter quelques-uns.

La breakdéclaration est également utile lors du sondage pour une réponse valide de quelqu'un ou quelque chose. Au lieu de:

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

Vous pouvez éliminer certains doublons et utiliser:

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

La do-untilboucle que j'ai mentionnée précédemment est la solution la plus élégante pour ce problème particulier:

Do:
    Ask a question
    Until the answer is valid

Pas de duplication, pas breakbesoin non plus.

Tous ont donné une très bonne explication. Je poste toujours ma réponse juste 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é]

Donc 3 [Imprimé] & 4 [Imprimé] ne seront pas affichés car il y a une pause lorsque 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 s'affichera pas car il continue quand i == 3

Pause

Break force une boucle à sortir immédiatement.

Continuer

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

Réponse simple:

Break quitte immédiatement la boucle.
Continuer commence le traitement de l'élément suivant. (S'il y en a, en sautant sur la ligne d'évaluation du pour / pendant)

Par exemple

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

Imprime 1, 2, 3 (sur des lignes distinctes).

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 un continuer.

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

    Console.WriteLine(i);
}

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

Ainsi, breakarrête la boucle, tandis que continuepasse à l'itération suivante.

Ruby est malheureusement un peu différent. PS: Ma mémoire est un peu floue à ce sujet, donc je m'excuse si je me trompe

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

Les boucles (comme tout le reste) 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, donc 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 des choses avec le résultat d'un bloc, c'est là que ça devient salissant. break / next signifie différentes choses dans le contexte d'un bloc.

pause sautera hors du code qui a appelé le bloc

ensuite sautera le reste du code dans le bloc et «retournera» 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 a de terribles cas d'angle. C'est le deuxième pire que j'ai vu depuis mes années d'utilisation :-)

Permettez-moi de dire l'évidence: notez que l'ajout ni de pause ni de poursuite reprendra votre programme; c'est-à-dire que j'ai piégé pour une certaine erreur, puis après l'avoir enregistré, je voulais reprendre le traitement, et il y avait plus de tâches de code entre la ligne suivante, donc je l'ai simplement laissé passer.

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

Pour passer à l'itération suivante de la boucle, continue est utilisé;

La coupure est utile si vous parcourez une collection d'objets (comme des lignes dans une table de données) et que vous recherchez une correspondance particulière, lorsque vous trouvez cette correspondance, il n'est pas nécessaire de continuer à travers les lignes restantes, donc vous voulez rompre en dehors.

Continuer est utile lorsque vous avez accompli ce dont vous avez besoin dans une itération en boucle. Vous devrez normalement continuer après un if .

si vous ne voulez pas utiliser break, augmentez simplement la valeur de I de manière à rendre la condition d'itération fausse et la boucle ne s'exécutera pas à la prochaine itération.

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

Comme pour les autres langues:

'VB
For i=0 To 10
   If i=5 then Exit For '= break in C#;
   'Do Something for i<5
next

For i=0 To 10
   If i=5 then Continue For '= continue in C#
   'Do Something for i<>5...
Next