break et continue

Faites boucler i de 1 à 5. Quand i vaut 3, quittez la boucle avec break avant d'écrire. L'écran ne doit montrer que deux lignes : 1, puis 2. Cet arrêt anticipé est un outil de cette page. L'autre outil est continue, qui saute un passage puis poursuit la boucle pour que 3 ne s'écrive pas, mais que 4 et 5 s'écrivent encore. Gardez la classe publique nommée Pine.

break termine la boucle plus tôt

Ouvrez le fichier Pine. Le nom de la classe reste Pine. Cette page ne renomme pas le type. Supprimez tout while simple qui ne fait que compter si cette forme est encore là. Supprimez un for simple sans if d'arrêt anticipé si vous voulez seulement les démos de cette page. Supprimez toute ligne ReadLine. Le fichier que vous gardez n'attend pas de saisie, et l'écran n'est écrit que par la ligne d'écriture qui s'exécute quand le if est false.

Dans Main, écrivez un for qui peut s'arrêter plus tôt :
for (int i = 1; i <= 5; i = i + 1) {
if (i == 3) {
break;
}
Console.WriteLine(i);
}
L'en-tête for a la même forme que vous connaissez déjà : départ, test, pas. À l'intérieur des accolades, un if demande si i vaut 3. Quand c'est true, break; s'exécute. break quitte toute la boucle for d'un coup. La ligne d'écriture sous le if ne s'exécute pas pour ce passage, et i n'atteint jamais 4 ni 5 dans cette boucle. Quand i vaut 1 ou 2, le if est false, donc Console.WriteLine(i) écrit le nombre. Enregistrez le fichier.

Le fichier que vous gardez

Gardez cette forme d'enseignement. Un for de 1 à 5. Un if (i == 3) qui exécute break;. Une ligne d'écriture après le if qui écrit le nom nu i. Il n'y a pas de continue dans le fichier que vous gardez, et pas de guillemets autour de break.

Lisez depuis le haut. using System; prépare les noms courts. public class Pine nomme le type. public static void Main() est l'endroit où l'exécution démarre. Le for fait avancer i de 1 vers 5. Quand i vaut 3, break; termine la boucle. Deux lignes à l'écran : 1, puis 2. Pas de troisième ligne.

Exécutez avec dotnet run. Le programme écrit deux lignes et s'arrête. Il n'attend pas que vous tapiez. Si dotnet run attend, ReadLine est encore dans le fichier. Supprimez cette ligne et gardez le for avec break ci-dessus. L'écran montre 1, puis 2. Si l'écran montre cinq lignes, le break manque ou le if ne correspond jamais. Si l'écran montre le mot break en lettres, une ligne d'écriture a des guillemets autour de ce mot. Vous ne réinstallez pas le kit SDK .NET pour un écran qui montre les mauvaises lignes.

Parcourez l'exécution de break dans l'ordre. i démarre à 1. Le if est false, donc la ligne d'écriture écrit 1. Le pas range 2. Le if est false, donc la ligne d'écriture écrit 2. Le pas range 3. Maintenant i == 3 est true, donc break s'exécute et le for se termine. Rien ne s'écrit pour 3, 4 ou 5. Une boucle simple sans break aurait écrit cinq lignes ; break a raccourci la boucle après deux écritures. Le pas ne s'exécute pas après break sur ce passage, et le test n'est plus demandé, parce que la boucle est déjà terminée.

continue saute un passage

Changez le corps pour que continue remplace break, et gardez la ligne d'écriture après le if :
for (int i = 1; i <= 5; i = i + 1) {
if (i == 3) {
continue;
}
Console.WriteLine(i);
}
Quand i vaut 3, continue; saute le reste de ce passage — y compris la ligne d'écriture — et le for passe au pas et au test suivant. La boucle elle-même ne se termine pas. L'écran doit montrer quatre lignes : 1, 2, 4, et 5. Le trou est l'endroit où 3 aurait dû être.

C'est le second fichier. Ce n'est pas le fichier que vous gardez. Exécutez dotnet run. L'écran montre quatre lignes. Vous n'avez pas changé l'en-tête for — seul break est devenu continue. Après avoir vu quatre lignes, remettez le fichier gardé : break à l'intérieur du if. Les deux versions sont du C# valide. Elles enseignent deux mouvements anticipés différents dans la même forme de boucle.

Relisez l'exécution de continue une fois encore. i va 1, 2, 3, 4, 5. Pour 1 et 2 le if est false et les nombres s'écrivent. Pour 3 continue saute la ligne d'écriture. Pour 4 et 5 les nombres s'écrivent à nouveau. La boucle se termine encore normalement quand i devient 6. continue ne termine jamais le for ; il saute seulement le reste d'un passage. Après continue, le for exécute encore son pas i = i + 1, donc le compteur continue d'avancer même si ce passage n'a rien écrit.

Utilisez le tableau comme contrôle après une exécution, pas à la place d'une. break laisse deux lignes. continue laisse quatre lignes avec 3 manquant. Si 3 apparaît encore alors que vous visiez continue, la ligne d'écriture est probablement au-dessus du if — placez Console.WriteLine(i) sous le continue pour que le saut puisse l'atteindre. Corrigez l'ordre plutôt que de réinstaller le kit SDK .NET.

Règles qui gardent les deux outils clairs

break et continue appartiennent au corps d'une boucle. Écrire break; seul dans Main sans for ou while englobant fait écrire une erreur au build. Il en va de même pour continue;. Sur cette page un if choisit le moment : quand i vaut 3. Vous pourrez écrire d'autres tests plus tard ; les démos gardent i == 3 pour que le changement d'écran soit facile à voir.

break n'est pas continue. break termine la boucle. continue saute un passage et reste dans la boucle. Le break à l'intérieur d'un switch sur une page précédente termine un case ; ici la structure englobante est un for. Ne laissez pas un while simple qui ne fait que compter, ni un for simple sans if, dans le même Main en vous demandant pourquoi chaque nombre de 1 à 5 s'écrit encore. Le Main de cette session doit porter le for plus le if avec break ou continue.

Une confusion courante est d'écrire le mot lui-même : Console.WriteLine("break");. Cela écrit les caractères break. Cela n'arrête pas une boucle. Une autre confusion est de placer Console.WriteLine(i); avant le if qui tient continue, donc 3 s'écrit encore puis continue s'exécute sans rien à sauter. Gardez la ligne d'écriture après le if dans les deux démos. Si vous écrivez continue sans boucle englobante, le build écrit une erreur ; il en va de même pour un break seul hors de toute boucle. Ces deux mots n'ont de sens, dans la forme de cette leçon, qu'à l'intérieur du corps d'une boucle.

Vous pouvez maintenant placer break dans une boucle pour partir plus tôt, ou continue pour sauter un passage et poursuivre. Un if peut choisir quand cela arrive. La page suivante est foreach, où une boucle parcourt chaque valeur d'une collection sans écrire le départ, le test et le pas à la main de la même façon.

L'écran est le mouvement anticipé

Le fichier que vous gardez écrit 1, puis 2. Le mot break est dans le fichier, et break n'est pas à l'écran. Le second fichier écrit quatre lignes avec 3 manquant. Des guillemets autour de break écrivent des lettres, pas un arrêt anticipé.