Loops 为什么大多数/所有语言都没有多循环中断函数？

我还没有见过任何编程语言有一个简单的函数来打破嵌套循环。我想知道：
是不是有什么低层次的东西让这变得不可能

下面是我的意思的一个例子（C#）：

只是

break类似于
中断1，并仅使您脱离最内部的循环

有些语言有凌乱的替代方案，如
goto
，它们可以工作，但没有上面提出的解决方案那么优雅。
虽然这是更多的推测，但有一些支持和反对这种可能性的论点

赞成者：

在某些情况下可能非常优雅
反对：

可能导致临时写入深度嵌套的循环，有些人认为这是不可取的

可以使用
goto
实现所需的行为

可以使用辅助变量实现所需的行为

在大多数情况下，嵌套循环可以重构为只使用一个循环

可以使用异常处理实现所需的行为（但另一方面，控制预期的执行流不是异常处理的主要任务）

所说的，我认为“代码> Goto 的合法用法是合法的。
尽管这是一个更大的推测，但也有一些反对和反对的理由。
赞成者：

在某些情况下可能非常优雅
反对：

可能导致临时写入深度嵌套的循环，有些人认为这是不可取的

可以使用
goto
实现所需的行为

可以使用辅助变量实现所需的行为

在大多数情况下，嵌套循环可以重构为只使用一个循环

可以使用异常处理实现所需的行为（但另一方面，控制预期的执行流不是异常处理的主要任务）

以上所说的，我认为“<代码> Goto < /Cord>”的合法用法是合法的。
 < P>不，在低级别上没有什么可以阻止创建像你所提议的那样的东西。还有很多语言是用高级语言实现的，这肯定会允许这种行为

然而，在设计一种反对这种结构的语言时，有几个考虑因素，至少在我看来是这样的

主要论点是，它为一个非常复杂的结构打开了大门，而这个结构可能过于复杂。嵌套循环本质上很难跟踪和了解发生了什么。
如果你加上你的构造，可能会使它们更加复杂

除非您将<代码>返回< /COD>语句作为一种<代码>破解< /代码>当然：
 < P>不，在低级别上没有什么会阻止创建像您所提议的那样的东西。还有很多语言是用高级语言实现的，这肯定会允许这种行为

然而，在设计一种反对这种结构的语言时，有几个考虑因素，至少在我看来是这样的

主要论点是，它为一个非常复杂的结构打开了大门，而这个结构可能过于复杂。嵌套循环本质上很难跟踪和了解发生了什么。
如果你加上你的构造，可能会使它们更加复杂

除非您将<代码>返回< /COD>语句作为一种<代码>中断<代码>当然：
 Perl确实具有与此特性非常相似的特性。而不是嵌套的数量
该功能旨在消除在深度嵌套循环中使用循环控件时的歧义。使用标签可以提高可读性，并在嵌套级别发生变化时提供保护。它减少了内部循环关于外部循环的知识量，尽管它们仍然有知识

嵌套也是非词法的，它将跨越子例程边界。这就是它变得怪异和更像后继的地方

FOREVER:while (1) {
    for my $string (@strings) {
        do_something;
    }
}

sub do_something {
    last FOREVER;
}

出于各种原因，这并不是一个好特性。这种特性会产生非常复杂的逻辑。将深度嵌套的循环重新构造为多个子例程调用几乎总是更好的

sub forever {
    while (1) {
        for my $string (@strings) {
            return;
        }
    }
}

你所要求的，本质上是一个受限的转到。它包含了大多数赞成和反对的相同论点

while (1) {
    for my $string (@strings) {
        goto FOREVER;
    }
}

FOREVER:print "I have escaped!\n"

从结构的角度来看，说“突破第n个嵌套循环”比“跳转”更糟糕。这意味着内部代码对其周围环境有着密切的了解。如果嵌套发生更改，所有内部循环控件都可能会中断。它为重构制造了障碍。例如，如果要在内部循环上执行

while (1) {
    twiddle_strings(@strings);
}

sub twiddle_strings {
    for my $string (@strings) {
        last 2;
    }
}

现在，控制外部循环的代码与内部循环的功能完全不同。如果外环发生变化怎么办

while (1) {
    while(wait_for_lock) {
        twiddle_strings(@strings);
    }
}

sub twiddle_strings {
    for my $string (@strings) {
        last 2;
    }
}

Perl确实具有与此功能非常相似的功能。而不是嵌套的数量

该功能旨在消除在深度嵌套循环中使用循环控件时的歧义。使用标签可以提高可读性，并在嵌套级别发生变化时提供保护。它减少了内部循环关于外部循环的知识量，尽管它们仍然有知识

嵌套也是非词法的，它将跨越子例程边界。这就是它变得怪异和更像后继的地方

FOREVER:while (1) {
    for my $string (@strings) {
        do_something;
    }
}

sub do_something {
    last FOREVER;
}

出于各种原因，这并不是一个好特性。这种特性会产生非常复杂的逻辑。将深度嵌套的循环重新构造为多个子例程调用几乎总是更好的

sub forever {
    while (1) {
        for my $string (@strings) {
            return;
        }
    }
}

你所要求的，本质上是一个受限的转到。它带着我