C # boucle - pause vs continuer

Un moyen très facile de comprendre cela est de placer le mot "boucle" après chacun des mots-clés. Les Termes ont maintenant un sens s'ils sont lus comme des phrases quotidiennes.

break boucle - boucle est cassé et s'arrête.

continue boucle - boucle continue à exécuter avec la prochaine itération.

Break fait sauter le compteur de programme hors de la portée de la boucle la plus interne

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

Fonctionne comme ceci

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

Continuer sauts à la fin de la boucle. Dans une boucle for, continuer saute à l'expression d'incrément.

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

    printf("%d", i);
}

Fonctionne comme ceci

for(i = 0; i < 10; i++)
{
    if(i == 2)
        goto CONTINUE;

    printf("%d", i);

    CONTINUE:;
}

break arrête complètement la boucle foreach, continue passe à la suivante DataRow.

, Il ya plus de quelques personnes qui n'aiment pas les break et continue. La dernière plainte que j'ai vue à leur sujet était dans JavaScript: The Good Parts de Douglas Crockford. Mais je trouve que parfois l'utilisation de l'un d'entre eux simplifie vraiment les choses, surtout si votre langue n'inclut pas un style de boucle do-while ou do-until.

J'ai tendance à utiliser break dans les boucles qui recherchent quelque chose dans une liste. Une fois trouvé, il ne sert à rien de continuer, alors vous pourriez aussi bien cesser de fumer.

J'utilise continue lorsque vous faites quelque chose avec la plupart des éléments d'une liste, mais encore envie de sauter un peu.

L'instruction break est également utile lors de l'interrogation d'une réponse valide de quelqu'un ou de quelque chose. Au lieu de:

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

Vous pourriez éliminer une certaine duplication 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 pour ce problème particulier:

Do:
    Ask a question
    Until the answer is valid

Pas de duplication, et pas de break nécessaire 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é ] et 4 [imprimé] ne seront pas affichés car il y a 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 l'habitude de toujours être confus si je devrais utiliser break, ou continuer. C'est ce qui m'aide à me souvenir:

Quand utiliser break vs continuer?

1. Pause - c'est comme rompre. C'est triste, vous les gars sont la séparation.

1. continuer - signifie que vous allez vous reposer aujourd'hui et tout Trier demain (c'est-à-dire ignorer l'itération actuelle)!

Pause -

Break force une boucle à quitter immédiatement.

Continuer

Cela fait le contraire de break. Au lieu de terminer la boucle, il boucle immédiatement à nouveau, en sautant le reste 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.

Remplacer 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 (sauter 2).

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

Ruby est malheureusement un peu différent. PS: ma mémoire est un peu brumeuse à ce sujet, donc mes excuses 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

Boucles (comme tout le reste) sont des expressions, et "retour" la dernière chose qu'ils ont fait. La plupart du temps, obtenir la valeur de retour à partir d'une boucle est inutile, donc tout le monde fait cela

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. pause/suivant signifier différentes choses dans le contexte d'un bloc.

Break va sauter hors du code qui a appelé le bloc

Suivant va sauter le reste du code dans le bloc, et 'retourner' ce que vous spécifiez à l'appelant du bloc. Cela n'a aucun sens sans exemple.

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.

Alors oui. Ruby est génial, mais il a des corner-cases horribles. C'est le deuxième pire que j'ai vu dans mes années d'utilisation: -)

Réponse Simple:

Pause - quitte immédiatement la boucle.
continuer commence à traiter l'élément suivant. (S'il y en a, en sautant à la ligne d'évaluation du for / while)

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

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

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

Break est utile si vous parcourez une collection d'objets (comme des lignes dans un Datatable) 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 sortir.

Continuer est utile lorsque vous avez accompli ce que vous besoin de côté une itération de boucle. Vous aurez normalement continuer après un si.

Si vous ne voulez pas utiliser break vous augmentez simplement la valeur de I de telle sorte qu'elle rende la condition d'itération fausse et que la boucle ne s'exécute pas lors de l'itération suivante.

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