sirve - goto c#

C#loop-break vs. continue

Question

En un bucle de C # (no dude en responder para otros idiomas), ¿cuál es la diferencia entre romper y continuar como un medio para abandonar la estructura del bucle y pasar a la siguiente iteración?

Ejemplo:

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

Answer 1

En cuanto a otros idiomas:

''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

Answer 2

Hay más de unas pocas personas a quienes no les gusta break y continue . La última queja que vi sobre ellos fue en JavaScript: The Good Parts de Douglas Crockford. Pero me parece que a veces usar uno de ellos realmente simplifica las cosas, especialmente si su idioma no incluye un estilo de bucle do-while o do-until .

Tiendo a usar los bucles de break que están buscando algo en una lista. Una vez encontrado, no tiene sentido continuar, por lo que es mejor que renuncies.

Utilizo continue cuando hago algo con la mayoría de los elementos de una lista, pero todavía quiero omitir algunos.

La declaración de break también es útil cuando se busca una respuesta válida de alguien o algo. En lugar de:

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

Podrías eliminar alguna duplicación y usar:

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

El bucle de do-until que mencioné anteriormente es la solución más elegante para ese problema en particular:

Do:
    Ask a question
    Until the answer is valid

No hay duplicación, y tampoco break necesita break .

Answer 3

Para salir completamente de un bucle foreach, se usa break ;

Para ir a la siguiente iteración en el bucle, se usa continue ;

La ruptura es útil si recorres una colección de Objetos (como Filas en una Tabla de Datos) y buscas una coincidencia en particular, cuando la encuentres, no es necesario continuar a través de las filas restantes, por lo que debes interrumpir afuera.

Continuar es útil cuando ha logrado lo que necesita en una iteración de bucle. Normalmente tendrás que continuar después de un si .

Answer 4

Permítanme indicar lo obvio: tenga en cuenta que al agregar ni romper ni continuar, se reanudará su programa; es decir, quedé atrapado por un cierto error, luego, después de registrarlo, quise reanudar el procesamiento y hubo más tareas de código entre la siguiente fila, así que simplemente lo dejé pasar.

Answer 5

Por ejemplo

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

Imprime 1, 2, 3 (en líneas separadas).

Añadir una condición de ruptura en i = 2

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

    Console.WriteLine(i);
}

Ahora el bucle imprime 1 y se detiene.

Reemplace la ruptura con un continuar.

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

    Console.WriteLine(i);
}

Ahora a bucle imprime 1 y 3 (saltando 2).

Por lo tanto, break detiene el bucle, mientras que continue salta a la siguiente iteración.

Answer 6

Respuesta simple:

Break sale del loop inmediatamente.
Continuar comienza a procesar el siguiente elemento. (Si hay alguno, saltando a la línea de evaluación de for / while)

Answer 7

Ruby lamentablemente es un poco diferente. PD: mi memoria es un poco confusa en esto así que disculpas si me equivoco

en lugar de break / continue, tiene break / next, que se comporta igual en términos de bucles

Los bucles (como todo lo demás) son expresiones, y "devolver" lo último que hicieron. La mayoría de las veces, obtener el valor de retorno de un bucle no tiene sentido, por lo que todos lo hacen

a = 5
while a < 10
    a + 1
end

Sin embargo puedes hacer esto

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

SIN EMBARGO, una gran cantidad de código ruby ​​''emula'' un bucle usando un bloque. El ejemplo canónico es

10.times do |x|
    puts x
end

Como es mucho más común que las personas quieran hacer cosas con el resultado de un bloque, aquí es donde se complica. romper / siguiente significa cosas diferentes en el contexto de un bloque.

El salto saltará fuera del código que llamó al bloque

A continuación se omitirá el resto del código en el bloque y se "devolverá" lo que especifique al interlocutor del bloque. Esto no tiene ningún sentido sin ejemplos.

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.

Así que sí. Ruby es impresionante, pero tiene algunos casos de esquina horribles. Este es el segundo peor que he visto en mis años de uso :-)

Answer 8

Solía ​​confundirme siempre si debía usar break o continuar. Esto es lo que me ayuda a recordar:

¿Cuándo usar break vs continuar?

1. Romper - es como romper. Es triste, ustedes se están separando. Se sale el bucle.

2. Continuar : significa que vas a dar hoy un descanso y solucionarlo mañana (es decir, omitir la iteración actual).

Answer 9

Todos han dado una muy buena explicación. Todavía estoy publicando mi respuesta solo para dar un ejemplo si eso puede ayudar.

// 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] ";
}

Aquí está la salida:

0 [Impreso] 1 [Impreso] 2 [Impreso]

Por lo tanto, 3 [Impreso] y 4 [Impreso] no se mostrarán ya que hay un descanso cuando 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] ";
}

Aquí está la salida:

0 [Impreso] 1 [Impreso] 2 [Impreso] 4 [Impreso]

Por lo tanto, 3 [Impreso] no se mostrará ya que continúa cuando i == 3

Answer 10

Una forma realmente fácil de entender esto es colocar la palabra "bucle" después de cada una de las palabras clave. Los términos ahora tienen sentido si se leen como frases cotidianas.

bucle de break - el bucle se interrumpe y se detiene.

continue bucle: el bucle continúa ejecutándose con la siguiente iteración.

Answer 11

si no quiere usar break , simplemente aumenta el valor de I de tal manera que haga que la condición de iteración sea falsa y el ciclo no se ejecute en la siguiente iteración.

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
}

Answer 12

break detendría completamente el bucle foreach , continue saltaría a la siguiente DataRow .

Answer 13

break saldrá completamente del bucle, continue solo saltará la iteración actual.

Por ejemplo:

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

    DoSomeThingWith(i);
}

La interrupción hará que el bucle salga en la primera iteración: DoSomeThingWith nunca se ejecutará. Esto aqui:

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

    DoSomeThingWith(i);
}

No ejecutará DoSomeThingWith para i = 0 , pero el bucle continuará y DoSomeThingWith se ejecutará para i = 1 a i = 9 .

Answer 14

Descanso

La ruptura obliga a un bucle a salir inmediatamente.

Continuar

Esto hace lo contrario de romper. En lugar de terminar el bucle, se vuelve a interrumpir inmediatamente, omitiendo el resto del código.

Answer 15

la ruptura hace que el contador del programa salte fuera del alcance del bucle más interno

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

Funciona asi

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

Continuar saltos hasta el final del bucle. En un bucle for, continúe con los saltos a la expresión de incremento.

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

    printf("%d", i);
}

Funciona asi

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

    printf("%d", i);

    CONTINUE:;
}