C#循环 - 中断与继续

Question

在C#(随意回答其他语言)循环中,break和continue之间的区别是什么,作为离开循环结构的手段,并进入下一次迭代？

例:

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

Answer 1

break将完全退出循环,continue将跳过当前迭代.

例如:

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

    DoSomeThingWith(i);
}

中断将导致循环在第一次迭代时退出 - DoSomeThingWith永远不会执行.这里:

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

    DoSomeThingWith(i);
}

不会执行DoSomeThingWith的i = 0,但循环将继续,并DoSomeThingWith为将被执行i = 1到i = 9.

Answer 2

理解这一点的一个非常简单的方法是在每个关键字后面加上"循环"一词.如果他们只是像日常用语一样阅读,那么这些术语现在就有意义

break 循环 - 循环被打破并停止.

continue 循环 - 循环继续执行下一次迭代.

Answer 3

break导致程序计数器跳出最内层循环的范围

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

像这样工作

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

继续跳转到循环结束.在for循环中,继续跳转到增量表达式.

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

    printf("%d", i);
}

像这样工作

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

    printf("%d", i);

    CONTINUE:;
}

Answer 4

我以前总是对我是否应该使用休息或继续感到困惑.这有助于我记住:

什么时候使用break vs continue？

1. 休息 - 就像分手一样.很遗憾,你们分手了.

2. 继续 - 意味着你今天要给我们一个休息并明天整理出来(即跳过当前的迭代)!

Answer 5

break将foreach完全停止循环,continue将跳到下一个DataRow.

Answer 6

有不止一些人不喜欢break和continue.我看到的最新投诉是用JavaScript:道格拉斯克罗克福德的好零件.但我发现,他们有时会用一个真正简化了的事情,特别是如果你的语言不包括do-while或do-until循环的风格.

我倾向于break在循环中使用正在搜索列表的东西.一旦找到,继续没有意义,所以你也可以放弃.

我在使用continue列表的大多数元素时都会使用,但仍想跳过几个.

break在对某人或某事的有效回复进行投票时,该声明也会派上用场.代替:

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

你可以消除一些重复和使用:

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

do-until我之前提到的循环是针对该特定问题的更优雅的解决方案:

Do:
    Ask a question
    Until the answer is valid

没有重复,也没有break必要.

Answer 7

所有人都给出了非常好的解释.我仍然发布我的答案只是为了给一个例子,如果这可以帮助.

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

这是输出:

0 [已打印] 1 [已打印] 2 [已打印]

所以3 [打印]和4 [打印]将不显示,因为当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] ";
}

这是输出:

0 [已打印] 1 [已打印] 2 [已打印] 4 [已打印]

所以3 [打印]将不会显示,因为当i == 3时会继续显示

Answer 8

打破

断开强制循环立即退出.

继续

这与休息相反.它不是终止循环,而是立即再次循环,跳过剩下的代码.

Answer 9

以身作则

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

打印1,2,3(在单独的行上).

在i = 2处添加中断条件

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

    Console.WriteLine(i);
}

现在循环打印1并停止.

用继续替换休息.

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

    Console.WriteLine(i);
}

现在循环打印1和3(跳过2).

因此,break停止循环,而continue跳到下一次迭代.

Answer 10

不幸的是,Ruby有点不同.PS:我的记忆有点模糊,如果我错了,请道歉

它不是中断/继续,而是中断/下一个,它在循环方面表现相同

循环(就像其他所有东西一样)是表达式,并"返回"他们做的最后一件事.大多数时候,从循环中获取返回值是没有意义的,所以每个人都这样做

a = 5
while a < 10
    a + 1
end

但是你可以这样做

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

但是,很多ruby代码通过使用块来"模拟"循环.典型的例子是

10.times do |x|
    puts x
end

因为人们想要用块的结果来做事情更常见,这就是它变得混乱的地方.break/next表示块的上下文中的不同内容.

break会跳出调用块的代码

next将跳过块中的其余代码,并将您指定的内容"返回"给块的调用者.没有例子,这没有任何意义.

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.

是的.Ruby很棒,但它有一些可怕的角落案例.这是我在使用它的过程中看到的第二个最糟糕的一个:-)

Answer 11

简单回答:

Break会立即退出循环.
继续开始处理下一个项目.(如果有,通过跳转到for/while的评估行)

Answer 12

请让我说明显而易见的事项:请注意,既不添加也不继续,将恢复您的计划; 即我陷入某个错误,然后在记录之后,我想恢复处理,并且在下一行之间有更多的代码任务,所以我让它落空.