Loop de C # - quebra x continua

Em um loop C # (sinta-se à vontade para responder a outros idiomas), qual é a diferença entre break e continue como um meio de deixar a estrutura do loop e ir para a próxima iteração?

Exemplo:

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

breaksairá completamente do loop, continueapenas ignorará a iteração atual.

Por exemplo:

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

    DoSomeThingWith(i);
}

A quebra fará com que o loop saia na primeira iteração - DoSomeThingWithnunca será executado. Isso aqui:

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

    DoSomeThingWith(i);
}

Não será executado DoSomeThingWithpara i = 0, mas o loop continuará e DoSomeThingWithserá executado para i = 1para i = 9.

Uma maneira realmente fácil de entender isso é colocar a palavra "loop" após cada uma das palavras-chave. Os termos agora fazem sentido se forem apenas lidos como frases do cotidiano.

break loop - o loop está quebrado e para.

continue loop - loop continua a executar com a próxima iteração.

break faz com que o contador de programas salte fora do escopo do loop mais interno

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

Funciona assim

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

continue pula para o final do loop. Em um loop for, continue pula para a expressão de incremento.

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

    printf("%d", i);
}

Funciona assim

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

    printf("%d", i);

    CONTINUE:;
}

Eu sempre me confundia se deveria usar o intervalo ou continuar. Isto é o que me ajuda a lembrar:

Quando usar break vs continue?

1. Quebrar - é como terminar. É triste, vocês estão se separando. O loop é encerrado.

2. Continuar - significa que você vai descansar hoje e resolver tudo amanhã (ou seja, pular a iteração atual)!

breakinterromperia foreachcompletamente o loop, continuepassaria para o próximo DataRow.

Existem mais do que algumas pessoas que não gostam breake continue. A última reclamação que vi sobre eles foi em JavaScript: The Good Parts, de Douglas Crockford. Mas acho que, às vezes usando um deles realmente simplifica as coisas, especialmente se o seu idioma não incluir um do-whileou do-untilestilo de loop.

Eu costumo usar breakloops que estão procurando alguma coisa na lista. Uma vez encontrado, não faz sentido continuar, então é melhor sair.

Uso continueao fazer algo com a maioria dos elementos de uma lista, mas ainda quero pular alguns.

A breakdeclaração também é útil ao pesquisar uma resposta válida de alguém ou algo. Ao invés de:

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

Você pode eliminar algumas duplicações e usar:

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

O do-untilloop que eu mencionei antes é a solução mais elegante para esse problema específico:

Do:
    Ask a question
    Until the answer is valid

Sem duplicação e sem breaknecessidade.

Todos deram uma explicação muito boa. Ainda estou postando minha resposta apenas para dar um exemplo, se isso puder ajudar.

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

Aqui está a saída:

0 [Impresso] 1 [Impresso] 2 [Impresso]

Portanto, 3 [Impresso] e 4 [Impresso] não serão exibidos, pois há uma pausa quando 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] ";
}

Aqui está a saída:

0 [Impresso] 1 [Impresso] 2 [Impresso] 4 [Impresso]

Então 3 [Impresso] não será exibido, pois continua quando i == 3

Quebrar

A quebra força um loop a sair imediatamente.

Continuar

Isso faz o oposto do intervalo. Em vez de encerrar o loop, ele imediatamente volta ao loop, pulando o restante do código.

Resposta simples:

Break sai do loop imediatamente.
Continuar inicia o processamento do próximo item. (Se houver, saltando para a linha de avaliação do por / enquanto)

Por exemplo

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

Imprime 1, 2, 3 (em linhas separadas).

Adicione uma condição de interrupção em i = 2

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

    Console.WriteLine(i);
}

Agora o loop imprime 1 e para.

Substitua a pausa por uma continuação.

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

    Console.WriteLine(i);
}

Agora, faça um loop das impressões 1 e 3 (pulando 2).

Assim, breakinterrompe o loop, enquanto continuepula para a próxima iteração.

Infelizmente, Ruby é um pouco diferente. PS: Minha memória está um pouco obscura com isso, então peço desculpas se eu estiver errado

em vez de quebrar / continuar, tem quebra / próximo, que se comporta da mesma maneira em termos de loops

Loops (como todo o resto) são expressões e "retornam" a última coisa que eles fizeram. Na maioria das vezes, obter o valor de retorno de um loop é inútil, então todo mundo faz isso

a = 5
while a < 10
    a + 1
end

No entanto, você pode fazer isso

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

No entanto, muitos códigos ruby ​​'emulam' um loop usando um bloco. O exemplo canônico é

10.times do |x|
    puts x
end

Como é muito mais comum as pessoas quererem fazer as coisas com o resultado de um bloco, é aqui que fica confuso. break / next significa coisas diferentes no contexto de um bloco.

break pulará do código que chamou o bloco

next pulará o restante do código no bloco e retornará o que você especificar para o chamador do bloco. Isso não faz sentido sem exemplos.

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.

Então sim. Ruby é incrível, mas tem alguns casos de canto horríveis. Este é o segundo pior que já vi nos meus anos de uso :-)

Por favor, deixe-me declarar o óbvio: observe que adicionar nem interromper nem continuar retomará seu programa; ou seja, fiquei preso por um determinado erro e, depois de registrá-lo, quis retomar o processamento, e havia mais tarefas de código entre a próxima linha, então deixei passar.

Para sair completamente de um loop foreach, é usada a pausa ;

Para ir para a próxima iteração no loop, continue é usado;

Quebrar é útil se você estiver percorrendo uma coleção de Objetos (como Linhas em um Datatable) e estiver procurando por uma correspondência específica. Quando você encontrar essa correspondência, não será necessário continuar pelas linhas restantes, portanto, você deseja interromper Fora.

Continuar é útil quando você realiza o que precisa ao lado de uma iteração de loop. Você normalmente continuará após um if .

se você não quiser usar break, apenas aumente o valor de I de forma a tornar a condição de iteração falsa e o loop não será executado na próxima iteração.

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
}

Quanto aos outros 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