如何摆脱多重循环?


478

给出以下代码(不起作用):

while True:
    #snip: print out current state
    while True:
        ok = get_input("Is this ok? (y/n)")
        if ok.lower() == "y": break 2 #this doesn't work :(
        if ok.lower() == "n": break
    #do more processing with menus and stuff

有没有办法使这项工作?还是我要进行一次检查以打破输入循环,然后再进行另一项限制较大的检查(如果用户满意的话)在外部循环中一起分解?


87
为什么Python不只有'break(n)',其中n是您想要突破的级别数。
内森

2
goto如果您深陷于很多循环中,那么C ++非常适合
Drake Johnson

Answers:


511

我的第一个直觉是将嵌套循环重构为一个函数,然后使用它return来分解。


3
这是我的另一种想法,因为我确定get_input_yn()函数在其他地方也很有用。
马修·沙利

96
在这种特定情况下达成共识,但在一般情况下“我有嵌套循环,我该怎么办”重构可能没有意义。
quick_dry

当必须屈服而不是使用return时,使用异常可能会更容易,但是在这种情况下,您可能应该使用itertools.islice()。
罗伯特·金

5
通常可以将内部循环重构为自己的方法,返回true继续,返回false破坏外部循环。while condition1:/如果不是MyLoop2(params):中断。另一种方法是设置一个布尔标志,在两个级别上都对其进行测试。更多=真/当condition1和更多:/而condition2和更多:/如果stopCondition:更多=假/中断/ ...
ToolmakerSteve13年

7
我同意努力使用return是正确的方法。根据Python Zen的说法,其理由是“扁平比嵌套更好”。我们在这里有三个嵌套层次,如果这开始妨碍了,是时候减少嵌套或至少将整个嵌套提取为自己的功能了。
Lutz Prechelt 2014年

239

这是另一种简短的方法。缺点是您只能打破外部循环,但是有时正是您想要的。

for a in xrange(10):
    for b in xrange(20):
        if something(a, b):
            # Break the inner loop...
            break
    else:
        # Continue if the inner loop wasn't broken.
        continue
    # Inner loop was broken, break the outer.
    break

这使用了for / else构造,其解释如下:为什么python在for和while循环之后为什么使用'else'?

关键见解:似乎外部循环总是在中断。但是,如果内部循环不中断,那么外部循环也不会。

continue句话是魔术。在for-else子句中。根据定义,如果没有内部中断,则会发生这种情况。在这种情况下,可以continue巧妙地规避外部中断。


6
@eugeney为什么不呢?第一个中断将退出内部循环。
纳文2014年

5
@eugeney我觉得我在这里缺少什么。你能举个例子吗?
纳文2014年

4
@Mingliang可以继续之前。
Baldrickk

1
从Raymond Hettinger的视频(youtu.be/OSGv2VnC0go?t=971)中了解到这一点,将附加在for循环上的“ else”语句读为“ no_break”,则它变得更容易理解。
Ambareesh

2
这很聪明。:-)但是,不是直接的。坦白地说,我不相信将标记为break或break(n)排除在Python外的说法。解决方法增加了更多复杂性。
rfportilla

148

PEP 3136建议标记为中断/继续。Guido 拒绝了它,因为“如此复杂的代码很少需要此功能”。PEP确实提到了一些解决方法(例如,异常技术),而Guido认为在大多数情况下,使用return进行重构将更为简单。


73
尽管重构/ return通常是要走的路,但我已经看到很多情况下,简单的“ break 2”语句非常有意义。另外,refactor /对于而言return不相同continue。在这些情况下,与将其重构为一个小函数,引发异常或涉及在每个嵌套级别设置要中断的标志的复杂逻辑相比,数字中断和继续将更易于遵循和混乱。圭多(Guido)拒绝了这很遗憾。
James Haigh

10
break; break会好的。
PyRulez

5
@Jeyekomon问题是您不需要3个或更多嵌套循环即可解决此问题。2个嵌套循环非常常见
Jon

6
“如此复杂以至于需要此功能的代码很少见”。但是,如果您确实使用过如此复杂的代码,则缺少标记循环将使其变得更加复杂,因为您必须手动转发break所有循环。笨。
BallpointBen

3
显然,我只能编辑5分钟的帖子(已经6分钟了)。因此,这是我编辑过的帖子:我的2分:Perl标记了break(但称其为“ last”)和“ next”以直接进行下一次迭代。这一点也不罕见-我一直都在使用它。我是Python的新手,并且已经需要它。同样,编号的中断对于重构来说将是可怕的-更好地标记要中断的循环,然后使用break <label>明确指出要中断的循环。
约翰·迪恩

119

首先,普通逻辑是有帮助的。

如果由于某种原因无法确定终止条件,则例外是后备计划。

class GetOutOfLoop( Exception ):
    pass

try:
    done= False
    while not done:
        isok= False
        while not (done or isok):
            ok = get_input("Is this ok? (y/n)")
            if ok in ("y", "Y") or ok in ("n", "N") : 
                done= True # probably better
                raise GetOutOfLoop
        # other stuff
except GetOutOfLoop:
    pass

对于此特定示例,可能不需要例外。

另一方面,在字符模式应用程序中,我们经常有“ Y”,“ N”和“ Q”选项。对于“ Q”选项,我们希望立即退出。那更例外。


4
严重的是,异常的代价非常低廉,惯用的python使用很多异常。同样,定义和抛出自定义变量也很容易。
Gregg Lind

13
有趣的主意。我爱还是恨它都使我感到沮丧。
Craig McQueen 2010年

8
如果单独显示两个变体,则此解决方案将更有帮助。(1)使用标志(done)。(2)提出例外。将它们合并为一个解决方案只会使其看起来很复杂。对于将来的读者:请使用涉及的所有行done,或者定义GetOutOfLoop(Exception)和引发/除外。
ToolmakerSteve

4
通常,对于除异常之外的其他任何事物都使用try块是很不受欢迎的。尝试块是专门为错误处理而设计的,从样式上来说,将它们用于某些奇怪的控制流并不是很好。
nobillygreen 2013年

2
在Python3中,这将是raise Exception('GetOutOfLoop')except Exception:
tommy.carstensen

54

我倾向于同意重构为函数通常是解决这种情况的最佳方法,但是对于确实需要打破嵌套循环的情况,这是@ S.Lott描述的异常引发方法的一个有趣变体。它使用Python的with语句使异常引发看起来更好。使用以下命令定义一个新的上下文管理器(您只需执行一次):

from contextlib import contextmanager
@contextmanager
def nested_break():
    class NestedBreakException(Exception):
        pass
    try:
        yield NestedBreakException
    except NestedBreakException:
        pass

现在,您可以按以下方式使用此上下文管理器:

with nested_break() as mylabel:
    while True:
        print "current state"
        while True:
            ok = raw_input("Is this ok? (y/n)")
            if ok == "y" or ok == "Y": raise mylabel
            if ok == "n" or ok == "N": break
        print "more processing"

优点:(1)稍微干净一些(没有显式的try-except块),并且(2)Exception每次使用都会获得一个定制的子类nested_break;无需Exception每次都声明自己的子类。


40

首先,您还可以考虑使获取和验证输入的过程成为一个函数。在该函数中,您可以只返回正确的值,否则返回while循环。这从根本上消除了您解决的问题,通常可以在更一般的情况下使用(突破多个循环)。如果您绝对必须在您的代码中保留此结构,并且真的不想处理簿记布尔值...

您还可以按以下方式使用goto(从此处使用April Fools模块):

#import the stuff
from goto import goto, label

while True:
    #snip: print out current state
    while True:
        ok = get_input("Is this ok? (y/n)")
        if ok == "y" or ok == "Y": goto .breakall
        if ok == "n" or ok == "N": break
    #do more processing with menus and stuff
label .breakall

我知道,我知道“您不应该使用goto”以及所有其他功能,但是在像这样的奇怪情况下它可以很好地工作。


1
如果是类似的东西在INTERCAL的来自命令,然后什么
1800信息

3
我喜欢这个玩笑,但是堆栈溢出的重点是促进良好的代码,因此我不得不拒绝您:(
Christian Oudard

13
我认为这是一个干净,易读的解决方案,足以胜任良好的代码,所以我投票赞成。:)
JT Hurley

1
@JTHurley不,这不干净而且可读。我的意思是,在此示例中,它看起来像是干净且可读的但在任何现实生活中,goto都会造成混乱。(这也是非常反Python的东西)
Alois Mahdal

2
goto的代表不好,我认为任何专业的编码人员都应该能够正确处理它。
艾伯特·伦肖

33

引入一个新变量,将其用作“循环断路器”。首先给它分配一些东西(False,0,等等),然后在外循环内部,从它断开之前,将值更改为其他东西(True,1,...)。一旦循环退出,请在“父”循环中检查该值。让我示范一下:

breaker = False #our mighty loop exiter!
while True:
    while True:
        if conditionMet:
            #insert code here...
            breaker = True 
            break
    if breaker: # the interesting part!
        break   # <--- !

如果您有无限循环,这是唯一的出路。对于其他循环,执行速度实际上要快得多。如果您有许多嵌套循环,这也适用。您可以全部退出,也可以退出几个。无限可能!希望这对您有所帮助!


22

要打破多个嵌套循环而不重构为函数,请使用带有内置StopIteration异常的“模拟goto语句” :

try:
    for outer in range(100):
        for inner in range(100):
            if break_early():
                raise StopIteration

except StopIteration: pass

这个讨论关于使用goto语句的嵌套循环的突破。


1
这看起来比创建自己的类来处理异常要好得多,而且看起来很干净。有什么原因我不应该这样做吗?
mgjk

实际上StopIteration用于生成器,但是我认为通常您没有任何未捕获的StopIteration异常。因此,这似乎是一个不错的解决方案,但是在创建新异常方面没有错误。
科瓦尔斯基

1
对我来说最好的和最简单的解决方案
Alexandre Huat

16

keeplooping=True
while keeplooping:
    #Do Stuff
    while keeplooping:
          #do some other stuff
          if finisheddoingstuff(): keeplooping=False

或类似的东西。您可以在内部循环中设置一个变量,并在内部循环退出后立即在外部循环中检查它,如果合适的话,可以中断。我有点像GOTO方法,但前提是您不介意使用愚人节的笑话模块-它不是Python语言的,但确实有道理。


这是一种标志设置!
SIslam

我认为这是一个很好的解决方案。
科瓦尔斯基

13

这不是最漂亮的方法,但是我认为这是最好的方法。

def loop():
    while True:
    #snip: print out current state
        while True:
            ok = get_input("Is this ok? (y/n)")
            if ok == "y" or ok == "Y": return
            if ok == "n" or ok == "N": break
        #do more processing with menus and stuff

我很确定您也可以在这里使用递归来解决问题,但是我不知道这是否对您来说是个好选择。


这对我来说是正确的解决方案。我的用例与OP的用例非常不同。我在本质上相同的数据上循环了两次以查找排列,所以我不想将两个while循环分开。
布赖恩·彼得森

9

如果两个条件都成立,为什么不继续循环呢?我认为这是一种更Python化的方式:

dejaVu = True

while dejaVu:
    while True:
        ok = raw_input("Is this ok? (y/n)")
        if ok == "y" or ok == "Y" or ok == "n" or ok == "N":
            dejaVu = False
            break

是不是

祝一切顺利。


为什么不只是while dejaVu:?您仍然将其设置为true。
马修·沙利

嘿,行得通!我当时想在两种True情况下跳过两个循环,但只要一个就足够了。
MauroAspé2012年

2
@MatthewScharley我认为这是为了表明它在嵌套循环中有效。
手柄

@MauroAspé,这将无法完全满足OP的要求。它仍将执行整个外部循环,但目标是如果您破坏其余代码,则将不会执行
yamm 2015年

@yamm不能if not dejaVu: break在底部使用a来解决并退出主循环吗?我认为解决方案最接近要求的解决方案。+1
milcak

8

将循环逻辑分解为一个迭代器,该迭代器产生循环变量并在完成后返回-这是一个简单的示例,它以行/列的形式排列图像,直到我们没有图像或放置位置为止:

def it(rows, cols, images):
    i = 0
    for r in xrange(rows):
        for c in xrange(cols):
            if i >= len(images):
                return
            yield r, c, images[i]
            i += 1 

for r, c, image in it(rows=4, cols=4, images=['a.jpg', 'b.jpg', 'c.jpg']):
    ... do something with r, c, image ...

这具有拆分复杂的循环逻辑和处理的优点。


3

在这种情况下,正如其他人指出的那样,功能分解也是解决之道。Python 3中的代码:

def user_confirms():
    while True:
        answer = input("Is this OK? (y/n) ").strip().lower()
        if answer in "yn":
            return answer == "y"

def main():
    while True:
        # do stuff
        if user_confirms():
            break

3

Python while ... else结构中有一个隐藏的技巧,可用于模拟两次中断,而无需进行大量代码更改/添加。本质上,如果while条件为假,else则触发该块。既不例外,continue也不break触发该else块。有关更多信息,请参见“ Python while语句上的Else子句 ”或while(v2.7)上的Python文档的答案。

while True:
    #snip: print out current state
    ok = ""
    while ok != "y" and ok != "n":
        ok = get_input("Is this ok? (y/n)")
        if ok == "n" or ok == "N":
            break    # Breaks out of inner loop, skipping else

    else:
        break        # Breaks out of outer loop

    #do more processing with menus and stuff

唯一的缺点是您需要将双破折号条件移入while条件(或添加一个标志变量)。for循环也存在这种变化,else在循环完成后将触发该块。


这似乎不能满足两次休息的要求。适用于确切的给定问题,但不适用于实际的问题。
达卡龙

@Dakkaron您确定已正确理解代码?该代码确实确实解决了OP的问题,并且与请求类似地中断。但是,它不会中断多个循环,而是使用else子句来代替将中断加倍的需求。
holroy '16

根据我的理解,问题是How to break out of multiple loops in Python?,答案应该是“它不起作用,请尝试其他方法”。我知道它可以修复OP的确切示例,但不能回答他们的问题。
达卡龙

@Dakkaron,请参阅代码下的问题说明,我认为它确实回答了OP的问题。
holroy

2

将迭代减少到单级循环的另一种方法是通过使用python参考中也指定的生成器

for i, j in ((i, j) for i in A for j in B):
    print(i , j)
    if (some_condition):
        break

您可以将其扩展到循环的任意数量的级别

缺点是您不能再只打破一个级别。全部或全无。

另一个缺点是它不适用于while循环。我本来想在Python上发布此答案-打破所有循环中的`break`,但不幸的是,它已作为此副本的副本关闭了


1
它也适用于while循环,您只需要将生成器编写为def(带有yield),而不必将其理解为。
Veky

是的,PyCon的一位发言人在这里声称,即使@RobertRossney接受的答案也不是真正的Python语言,但是生成器是打破多个循环的正确方法。(我建议您观看整个视频!)
Post169

2

我来这里的原因是我有一个外部循环和一个内部循环,如下所示:

for x in array:
  for y in dont_use_these_values:
    if x.value==y:
      array.remove(x)  # fixed, was array.pop(x) in my original answer
      continue

  do some other stuff with x

如您所见,它实际上不会转到下一个x,而是会转到下一个y。

我发现解决这个问题的方法只是遍历两次数组:

for x in array:
  for y in dont_use_these_values:
    if x.value==y:
      array.remove(x)  # fixed, was array.pop(x) in my original answer
      continue

for x in array:
  do some other stuff with x

我知道这是OP的特定情况,但我希望将其发布,以帮助某人以不同的方式思考他们的问题,同时保持简单。


这可能不是Python。数组的类型是什么?可能列出,但其中包含什么?即使它包含整数,array.pop(x)可能也不会做您想要的。
Veky

那是个很好的观点。我找不到我引用的代码。对于任何阅读此内容的人,array.pop(i)“从数组中删除索引为i的项目,并将其返回。” 根据python文档。因此,需要获取数组中项x的索引以使此代码按预期工作。还有array.remove(x)函数可以完成预期的工作。我将修改上面的答案以解决该错误。假设第二个数组不包含重复项,因为array.remove(x)将仅删除找到的x的第一个实例。
弥敦道(Nathan Garabedian)

好,那我明白了。在那种情况下,简单地使用break代替代替就continue可以实现您想要的,不是吗?:-)
Veky

是的,为了提高效率和清晰度,您可能想在这些示例中使用break而不是继续。:)
内森·加拉比迪安

2

尝试使用无限生成器。

from itertools import repeat
inputs = (get_input("Is this ok? (y/n)") for _ in repeat(None))
response = (i.lower()=="y" for i in inputs if i.lower() in ("y", "n"))

while True:
    #snip: print out current state
    if next(response):
        break
    #do more processing with menus and stuff

2

通过使用一个函数:

def myloop():
    for i in range(1,6,1):  # 1st loop
        print('i:',i)
        for j in range(1,11,2):  # 2nd loop
            print('   i, j:' ,i, j)
            for k in range(1,21,4):  # 3rd loop
                print('      i,j,k:', i,j,k)
                if i%3==0 and j%3==0 and k%3==0:
                    return  # getting out of all loops

myloop()

尝试通过注释掉来运行上面的代码return

不使用任何功能:

done = False
for i in range(1,6,1):  # 1st loop
    print('i:', i)
    for j in range(1,11,2):  # 2nd loop
        print('   i, j:' ,i, j)
        for k in range(1,21,4):  # 3rd loop
            print('      i,j,k:', i,j,k)
            if i%3==0 and j%3==0 and k%3==0:
                done = True
                break  # breaking from 3rd loop
        if done: break # breaking from 2nd loop
    if done: break     # breaking from 1st loop

现在,按原样运行上面的代码,然后尝试通过break从底部开始注释掉包含一行的每一行来运行。


2

将多个循环转换为单个可中断循环的一种简单方法是使用 numpy.ndindex

for i in range(n):
  for j in range(n):
    val = x[i, j]
    break # still inside the outer loop!

for i, j in np.ndindex(n, n):
  val = x[i, j]
  break # you left the only loop there was!

您确实必须索引到您的对象中,而不是能够显式地遍历值,但是至少在简单的情况下,它似乎比大多数建议的答案简单约2至20倍。


2
# this version uses a level counter to choose how far to break out

break_levels = 0
while True:
    # snip: print out current state
    while True:
        ok = get_input("Is this ok? (y/n)")
        if ok == "y" or ok == "Y":
            break_levels = 1        # how far nested, excluding this break
            break
        if ok == "n" or ok == "N":
            break                   # normal break
    if break_levels:
        break_levels -= 1
        break                       # pop another level
if break_levels:
    break_levels -= 1
    break

# ...and so on

1

如果不喜欢将其重构为函数,可能会出现如下所示的小技巧

添加了1个break_level变量来控制while循环条件

break_level = 0
# while break_level < 3: # if we have another level of nested loop here
while break_level < 2:
    #snip: print out current state
    while break_level < 1:
        ok = get_input("Is this ok? (y/n)")
        if ok == "y" or ok == "Y": break_level = 2 # break 2 level
        if ok == "n" or ok == "N": break_level = 1 # break 1 level

1

您可以定义一个变量(例如break_statement),然后在发生两次中断条件时将其更改为另一个值,并在if语句中使用它来从第二个循环中断。

while True:
    break_statement=0
    while True:
        ok = raw_input("Is this ok? (y/n)")
        if ok == "n" or ok == "N": 
            break
        if ok == "y" or ok == "Y": 
            break_statement=1
            break
    if break_statement==1:
        break

很好,但是在我们感兴趣的内部层次之上的每个层次中,我们都需要扫描该变量。出于性能方面的考虑,该语言没有GoTo指令,实在是太糟糕了。
Anatoly Alekseev

1

我想提醒您,Python中的函数可以在代码中间创建,并且可以透明地访问周围的变量以进行读取以及使用with nonlocalglobal声明进行写入。

因此,您可以将函数用作“易碎控件结构”,从而定义要返回的位置:

def is_prime(number):

    foo = bar = number

    def return_here():
        nonlocal foo, bar
        init_bar = bar
        while foo > 0:
            bar = init_bar
            while bar >= foo:
                if foo*bar == number:
                    return
                bar -= 1
            foo -= 1

    return_here()

    if foo == 1:
        print(number, 'is prime')
    else:
        print(number, '=', bar, '*', foo)

>>> is_prime(67)
67 is prime
>>> is_prime(117)
117 = 13 * 9
>>> is_prime(16)
16 = 4 * 4

1

两种解决方案

举一个例子:这两个矩阵相等/相同吗?
matrix1和matrix2的大小相同,分别是n,2个二维矩阵。

第一个解决方案没有一个功能

same_matrices = True
inner_loop_broken_once = False
n = len(matrix1)

for i in range(n):
    for j in range(n):

        if matrix1[i][j] != matrix2[i][j]:
            same_matrices = False
            inner_loop_broken_once = True
            break

    if inner_loop_broken_once:
        break

第二个解决方案带有功能
这是我的案例的最终解决方案

def are_two_matrices_the_same (matrix1, matrix2):
    n = len(matrix1)
    for i in range(n):
        for j in range(n):
            if matrix1[i][j] != matrix2[i][j]:
                return False
    return True

祝你今天愉快!


1
# this version breaks up to a certain label

break_label = None
while True:
    # snip: print out current state
    while True:
        ok = get_input("Is this ok? (y/n)")
        if ok == "y" or ok == "Y":
            break_label = "outer"   # specify label to break to
            break
        if ok == "n" or ok == "N":
            break
    if break_label:
        if break_label != "inner":
            break                   # propagate up
        break_label = None          # we have arrived!
if break_label:
    if break_label != "outer":
        break                       # propagate up
    break_label = None              # we have arrived!

#do more processing with menus and stuff

0

希望这会有所帮助:

x = True
y = True
while x == True:
    while y == True:
         ok = get_input("Is this ok? (y/n)") 
         if ok == "y" or ok == "Y":
             x,y = False,False #breaks from both loops
         if ok == "n" or ok == "N": 
             break #breaks from just one

0

这是一个似乎可行的实现:

break_ = False
for i in range(10):
    if break_:
        break
    for j in range(10):
        if j == 3:
            break_ = True
            break
        else:
            print(i, j)

唯一的缺点是您必须break_在循环之前定义。


0

从语言层面上无法做到这一点。有些语言可以跳转,而其他语言则需要带参数,而python则不需要。

最好的选择是:

  1. 设置一个由外循环检查的标志,或设置外循环条件。

  2. 将循环放入函数中,然后使用return一次退出所有循环。

  3. 重新制定您的逻辑。

自1987年以来担任程序员的Vivek Nagarajan


使用功能

def doMywork(data):
    for i in data:
       for e in i:
         return 

使用标志

is_break = False
for i in data:
   if is_break:
      break # outer loop break
   for e in i:
      is_break = True
      break # inner loop break

-3

与之前的相似,但更紧凑。(布尔只是数字)

breaker = False #our mighty loop exiter!
while True:
    while True:
        ok = get_input("Is this ok? (y/n)")
        breaker+= (ok.lower() == "y")
        break

    if breaker: # the interesting part!
        break   # <--- !

2
与以前的代码相比,这看起来很丑陋,并使代码更难理解。还有,这是错误的。它错过了实际检查输入是否可接受的机会,并在1次循环后中断。
埃里克

-3

由于此问题已成为进入特定循环的标准问题,因此我想用给出示例Exception

尽管在多重循环结构中没有名为“循环中断”的标签,但是我们可以利用用户定义的异常来进入我们选择的特定循环。考虑下面的示例,在该示例中,我们将在base-6编号系统中打印最多4位数字的所有数字:

class BreakLoop(Exception):
    def __init__(self, counter):
        Exception.__init__(self, 'Exception 1')
        self.counter = counter

for counter1 in range(6):   # Make it 1000
    try:
        thousand = counter1 * 1000
        for counter2 in range(6):  # Make it 100
            try:
                hundred = counter2 * 100
                for counter3 in range(6): # Make it 10
                    try:
                        ten = counter3 * 10
                        for counter4 in range(6):
                            try:
                                unit = counter4
                                value = thousand + hundred + ten + unit
                                if unit == 4 :
                                    raise BreakLoop(4) # Don't break from loop
                                if ten == 30: 
                                    raise BreakLoop(3) # Break into loop 3
                                if hundred == 500:
                                    raise BreakLoop(2) # Break into loop 2
                                if thousand == 2000:
                                    raise BreakLoop(1) # Break into loop 1

                                print('{:04d}'.format(value))
                            except BreakLoop as bl:
                                if bl.counter != 4:
                                    raise bl
                    except BreakLoop as bl:
                        if bl.counter != 3:
                            raise bl
            except BreakLoop as bl:
                if bl.counter != 2:
                    raise bl
    except BreakLoop as bl:
        pass

当我们打印输出时,我们将永远不会得到单位位置为4的任何值。在那种情况下,我们不会像BreakLoop(4)引发和陷入同一循环那样从任何循环中中断。同样,只要十位有3,我们就会使用进入第三循环BreakLoop(3)。每当百位有5时,我们就使用进入第二个循环BreakLoop(2),每千位有2时,我们使用进入第一个循环BreakLoop(1)

简而言之,在内部循环中引发Exception(内置的或用户定义的),然后将其捕获到要从中恢复控制的循环中。如果要中断所有循环,请在所有循环之外捕获Exception。(我没有在示例中显示这种情况)。

By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.