C # loop - romper vs continuar

En un bucle C # (siéntase libre de responder para otros idiomas), ¿cuál es la diferencia entre romper y continuar como un medio para abandonar la estructura del bucle e ir a la siguiente iteración?

Ejemplo:

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

breaksaldrá del bucle por completo, continuesimplemente saltará la iteración actual.

Por ejemplo:

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

    DoSomeThingWith(i);
}

La ruptura hará que el ciclo 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 se ejecutará DoSomeThingWithpara i = 0, pero el bucle continuará y DoSomeThingWithserá ejecutado por i = 1a i = 9.

Una manera 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.

break loop: el loop se rompe y se detiene.

continue loop - loop continúa ejecutándose con la siguiente iteración.

break 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 salta al final del ciclo. En un bucle for, continuar salta 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:;
}

Siempre me confundía si debía usar break o continuar. Esto es lo que me ayuda a recordar:

¿Cuándo usar break vs continue?

1. Descanso : es como romper. Es triste, ustedes se están separando. Se sale del bucle.

2. Continuar - ¡significa que vas a descansar hoy y resolverlo todo mañana (es decir, omitir la iteración actual)!

breakdetendría el foreachbucle por completo, continuesaltaría al siguiente DataRow.

Hay más de unas pocas personas a las que no les gusta breaky continue. La última queja que vi sobre ellos estaba en JavaScript: The Good Parts por Douglas Crockford. Pero me parece que a veces el uso de uno de ellos realmente simplifica las cosas, sobre todo si la lengua no incluye una do-whileo do-untilestilo de bucle.

Tiendo a usar breaken bucles que buscan algo en una lista. Una vez encontrado, no tiene sentido continuar, por lo que es mejor que renuncies.

Lo uso continuecuando hago algo con la mayoría de los elementos de una lista, pero todavía quiero omitir algunos.

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

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

Podría eliminar algunas duplicaciones y usar:

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

El do-untilciclo que mencioné antes es la solución más elegante para ese problema en particular:

Do:
    Ask a question
    Until the answer is valid

Sin duplicación, y tampoco es breaknecesario.

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 hay continuación cuando i == 3

Rotura

La ruptura obliga a un bucle a salir inmediatamente.

Seguir

Esto hace lo contrario de descanso. En lugar de terminar el bucle, se repite inmediatamente, omitiendo el resto del código.

Respuesta simple:

Break sale del bucle de inmediato.
Continuar comienza a procesar el siguiente elemento. (Si hay alguno, saltando a la línea de evaluación de por / mientras)

Por ejemplo

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

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

Agregar una condición de descanso 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 el descanso con un continuar.

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

    Console.WriteLine(i);
}

Ahora para bucle imprime 1 y 3 (omitiendo 2).

Por lo tanto, breakdetiene el ciclo, mientras que continuesalta a la siguiente iteración.

Ruby desafortunadamente es un poco diferente. PD: Mi memoria es un poco confusa en esto, así que me disculpo si me equivoco

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

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

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 utilizando 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 bloqueo, aquí es donde se complica. break / next significa cosas diferentes en el contexto de un bloque.

el salto saltará del código que llamó al bloque

siguiente omitirá el resto del código en el bloque y "devolverá" lo que especifique a la persona que llama 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 increíble, pero tiene algunos esquinas horribles. Este es el segundo peor que he visto en mis años de usarlo :-)

Permítanme decir lo obvio: tenga en cuenta que al no agregar ni interrumpir ni continuar, reanudará su programa; es decir, atrapé 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.

Para salir completamente de un bucle foreach, se usa el descanso ;

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

El salto es útil si está recorriendo una colección de objetos (como Filas en una tabla de datos) y está buscando una coincidencia particular, cuando encuentra esa coincidencia, no es necesario continuar a través de las filas restantes, por lo que desea dividir fuera.

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

si no desea usar break , simplemente aumente el valor de I de tal manera que haga que la condición de iteración sea falsa y el bucle no se ejecute en la próxima 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
}

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