从基础到中级：BREAK 和 CONTINUE 语句

概述

此处提供的内容仅用于教育目的。在任何情况下，除了学习和掌握所提出的概念外，都不应出于任何目的使用此应用程序。

在上一篇文章“从基础到中级：WHILE 和 DO WHILE 语句”中，我们引入了循环。因此，理解前一篇文章中提供的解释和示例是理解和充分理解本文中概念的前提。

我知道许多初学者程序员很难正确理解循环生成命令的工作原理。然而，循环是必不可少的，几乎存在于你整个职业生涯中开发的每个程序中，即使你只是把创建程序作为爱好。理解并有效地使用与循环相关的命令至关重要。

还有一种循环不使用传统命令，但我们稍后将对此进行探讨。现在，我们将重点介绍循环中经常出现的三个命令。虽然其中两个也可以在循环外使用，但其中一个严格限于循环结构。然而，除非在非常合理的情况下，否则它永远不应该在循环中单独使用。

在本文中，我们将研究这些命令，特别是标题中突出显示的两个命令。换句话说，是时候了解如何从内部控制循环了。亲爱的读者，在这一点上，我敦促你密切关注将要解释的内容。如果你不理解这里介绍的概念，你无疑会在编程过程中的某个时候遇到困难。

可能的答案

在我们开始之前，我在上一篇文章中给你留下了一个小挑战。任务是将以下代码转换为使用循环的版本。

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     Factorial();
07.     Factorial();
08.     Factorial();
09.     Factorial();
10.     Factorial();
11. }
12. //+------------------------------------------------------------------+
13. void Factorial(void)
14. {
15.     static uchar counter = 0;
16.     static ulong value = 1;
17. 
18.     Print("Factorial of ", counter, " => ", value);    
19.     counter = counter + 1;
20.     value = value * counter;
21. }
22. //+------------------------------------------------------------------+

代码 01

如果你无法找到解决方案，不要担心，因为这是现阶段学习过程的一部分。但是，在开始学习之前，不要让材料堆积起来。随着我们向我认为的中级水平迈进，概念将迅速积累。

有多种方法可以将循环转换（或者更确切地说，合并）到代码 01 中，使其更高效。由于我们在上一篇文章中所介绍的内容，我们已经可以采取这样的方法。

简单来说，您可以修改上一篇文章中的代码 07，以实现与执行代码 01 相同的结果。如何做呢？使用代码 02，如下所示：

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     uchar counter = 0;
07. 
08.     while (counter < 5)
09.         Factorial(counter);
10. }
11. //+------------------------------------------------------------------+
12. void Factorial(uchar &counter)
13. {
14.     static ulong value = 1;
15. 
16.     Print("Factorial of ", counter, " => ", value);    
17.     counter = counter + 1;
18.     value = value * counter;
19. }
20. //+------------------------------------------------------------------+

代码 02

这只是解决问题的一种方法。还有其他方法，有些更复杂，有些不那么复杂。然而，鉴于我们迄今为止所涵盖的内容，这个解决方案是一个可靠的选择。现在，如果你不完全理解代码 02 在做什么，或者更重要的是，它为什么会产生与代码 01 相同的输出，请立即停止阅读本文。回到前面的文章，确保你理解代码 02。只有当您对其有了深刻的理解后，您才应该继续阅读本文和后续文章。

既然我已经给出了警告，让我们从本文介绍的第一个语句开始。我们将从循环中可以使用的最简单语句开始。但在深入探讨之前，让我们介绍一个新话题。

RETURN 语句

我知道你们中许多有 MQL5 编程经验的人可能会想：但这个语句与循环无关，它与函数更相关！你说得完全正确。RETURN 语句与函数的相关性远高于与循环的相关性。然而，尽管在函数中它是必需的语句，但在过程中它是可选的。正是因为它在过程中使用时的效果，RETURN 语句有时会出现在循环中。

现在，请密切注意。RETURN 语句的目的是将控制权返回给调用它的函数或过程。然而（这也是许多初学者难以理解的地方），如果你在应用程序的主过程中放置一个 RETURN 语句，如 OnInit 或 OnStart（取决于具体情况），执行 RETURN 将终止你的应用程序。这将导致 MetaTrader 5 将其从图表中删除。这是因为最终，每个应用程序都只是操作系统执行的一个函数或过程。理解这一点可以更容易地理解为什么在 OnInit 或 OnStart 中放置 RETURN 语句会导致应用程序过早结束。

如果 OnInit 中出现 RETURN，则应用程序是否终止取决于返回给 MetaTrader 5 的值。但是，如果在 OnStart 过程中执行 RETURN，则应用程序将被终止。

为了理解这一点，让我们从一个简单的例子开始，如下所示：

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
07. 
08.     return;
09. 
10.     Print(__FUNCTION__, " ", __LINE__, " This line will never be executed...");
11. }
12. //+------------------------------------------------------------------+

代码 03

执行此代码的结果如下：

图 01

这里要理解的关键点是，位于第 8 行的 RETURN 语句位于过程内部。因为它是一个过程，所以它不能与任何返回值相关联。这是为了防止在生成可执行文件时与编译器发生冲突。但是，如果 RETURN 在函数内部，则必须将返回值与之关联。这是因为调用函数必须接收返回值。我们之前在讨论变量时已经讨论过这个问题。

然而，我们目前的重点是不同的。在这里，我们感兴趣的是提前退出循环。当特定条件出现时，这通常是必要的，甚至是可取的。下面是一个可以应用此方法的简单示例：

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
07. 
08.     Procedure_Loop();
09. 
10.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
11. }
12. //+------------------------------------------------------------------+
13. void Procedure_Loop(void)
14. {
15.     char info = 10;
16. 
17.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
18.     
19.     while (info)
20.     {
21.         info = info - 3;
22.         
23.         Print("Loop : ", info);
24.         
25.         if (info < -5) return;
26.     }
27.     
28.     Print(__FUNCTION__, " ", __LINE__, " This line will never be executed...");
29. }
30. //+------------------------------------------------------------------+

代码 04

执行时，代码 04 将产生下图所示的结果：

图 02

此时，您可能会发现这种行为有点不寻常。如果我们希望循环在 info 变量达到低于 -5 的值时终止，为什么不将此条件直接包含在循环的测试表达式中呢？不这样做的原因是，有时我们不希望循环达到某个值；但如果确实如此，我们希望忽略循环存在的例程或过程的其余部分。

由于这个细节，代码 04 中永远不会执行第 28 行。这是因为在 IF 条件触发 RETURN 语句的执行之前，“info”的值不会达到零。因此，图像 02 显示的值范围从 7 到 -8。

您可能想知道：为什么执行第 25 行时应用程序不会终止，从而允许执行第 10 行？这种行为与我们在代码 03 中看到的不同。亲爱的读者，原因在于 OnStart 是 MetaTrader 5 调用的初始过程（或函数），而 Procedure_Loop 是由 OnStart 调用的。因此，当执行 RETURN 语句时，它将控制权返回给最初调用它的函数或过程，在本例中为 OnStart。

稍后将详细解释 MetaTrader 5 管理函数调用的方式。然而，简单来说，MetaTrader 5 调用两个主要函数：OnStart 和 OnInit。只有在这些特定情况下，RETURN 语句才会导致应用程序终止。除此之外，使用 RETURN 不会结束应用程序。

好的，至此，您应该对如何在循环中使用 RETURN 有了充分的了解。如果还有什么不清楚的地方，花点时间练习这些更简单的例子，直到你完全掌握了这个概念。现在，让我们继续本文要探讨的下一个语句。

BREAK 语句

BREAK 语句非常有趣，但需要仔细注意。您应该花些时间研究一下这个语句。初学者在使用它时遇到困难并不罕见。虽然在简单循环中使用 BREAK 非常简单，但在处理更复杂的循环结构时，事情可能会变得更加复杂。

使用 BREAK 时最常见的错误之一是假设它会影响不同的循环甚至另一个控制流语句。这是因为 BREAK 不是专门用于循环的；它也适用于我们稍后讨论的另一种控制结构。然而，就目前而言，不要担心这一点。让我们只关注它在循环中的行为。

有一个重要的概念是许多程序员要么忽略要么忘记的：BREAK 语句遵循一个与 RETURN 非常相似的原则。换句话说，它不是任意放置在循环中的。通常，它是 IF 语句的一部分。为了说明这一点，我们可以从上一节中取出代码 04，并将 RETURN 语句替换为 BREAK。代码的更新版本如下：

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
07. 
08.     Procedure_Loop();
09. 
10.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
11. }
12. //+------------------------------------------------------------------+
13. void Procedure_Loop(void)
14. {
15.     char info = 10;
16. 
17.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
18.     
19.     while (info)
20.     {
21.         info = info - 3;
22.         
23.         Print("Loop : ", info);
24.         
25.         if (info < -5) break;
26.     }
27.     
28.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
29. }
30. //+------------------------------------------------------------------+

代码 05

执行代码 05 时，MetaTrader 5 终端显示的输出如下：

图 03

有趣！这一次，我们得到了以前没有显示过的信息。这真的很有趣，循环似乎很容易使用。现在，我们已准备好处理更复杂的代码。（笑）亲爱的读者，冷静点，我们才刚刚开始。对于这些语句，初学者中经常出现一个问题（实际上是误解）。所以我要求你们练习使用这里给出的代码的变体。

第一个误解与嵌套循环中 BREAK 运算符的使用有关。是的，就像我们可以嵌套多个 IF 语句一样，我们也可以在彼此之间嵌套多个循环。这在处理多维矩阵时非常常见，因为我们不想手动计算索引。但是，让我们来看一个嵌套循环的简单示例，以了解 BREAK 语句在这种情况下的行为。下面是一个简单的示例：

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
07. 
08.     Procedure_Loop();
09. 
10.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
11. }
12. //+------------------------------------------------------------------+
13. void Procedure_Loop(void)
14. {
15.     char    info = 10,
16.             limit = 5;
17. 
18.     do
19.     {
20.         Print(__FUNCTION__, "  ", __LINE__, " : Info (", info, ")  Limit (", limit, ")");
21. 
22.         while (info > limit)
23.         {
24.             if (limit < 0) break;
25. 
26.             info = info - 3;
27. 
28.             Print(__FUNCTION__, "  ", __LINE__, " : Info (", info, ")  Limit (", limit, ")");
29.         }
30.         info = info + limit;
31.         limit = limit - 2;
32. 
33.         Print(__FUNCTION__, "  ", __LINE__, " : Info (", info, ")  Limit (", limit, ")");
34. 
35.     }while (info > 0);
36. 
37.     Print(__FUNCTION__, "  ", __LINE__, " : Info (", info, ")  Limit (", limit, ")");
38. }
39. //+------------------------------------------------------------------+

代码 06

尽管由于打印消息的数量，代码06 最初可能看起来很复杂，但实际上非常简单。它有效地演示了 BREAK 语句如何在嵌套循环中操作。当你运行代码 06 时，结果非常有趣。如下所示：

图 04

现在，亲爱的读者，请密切注意。在第 18 行开始的循环中，还有一个从第 22 行开始的嵌套循环。在这个嵌套循环中，第 24 行发生条件检查。这就是事情变得有趣的地方。您可能希望稍后进行实验，将 BREAK 语句替换为 RETURN 语句，以观察代码的行为。但现在，让我们专注于使用 BREAK 时会发生什么。

很明显，这里正在进行某种形式的计数。但它是如何被控制的？这是关键问题。通常，我们需要跟踪特定的值，但手动分析多个嵌套循环的输出可能很麻烦。在许多情况下，我们会开发一个数学表达式或公式来定义如何进行计算。一旦我们有了这个公式，我们就以代码的形式实现它。

这样做时，我们必须相信我们将数学表达式转换为函数代码的能力。如果正在处理的值的数量或生成方式特别复杂或广泛，我们无法单独分析每个值。相反，我们使用采样 — 我们在定义的范围内确定预期值，并仅分析该范围。这就是为什么掌握每个命令并了解每个操作的功能至关重要。

回到代码，您可能会注意到，在图像 04 中，第 28 行仅在某些情况下打印，即使第 22 行循环中的条件表明它应该更频繁地执行。发生这种情况是因为 BREAK 语句在条件指示应该结束之前终止了内部循环。然而，在这种特定情况下，打破内循环不会导致外循环终止。这就是为什么您还应该尝试用 RETURN 替换 BREAK，看看它如何影响终端中的最终输出。结果存在明显差异。

通过遵循执行流程，您将很容易理解这个概念。由于我们在前面的文章中已经探讨了 WHILE 和 DO-WHILE 循环以及 IF 语句的执行流程，因此您也应该能够在这种情况下对它们进行可视化。但是，我们还没有演示遇到 BREAK 语句时的执行流程。如下所示：

图 05

这里，LOOP 代表任何允许创建循环的命令。但是，BREAK 语句被描述为可以自由地放置在代码中。在这一点上，我们需要澄清。如果我们要包括正确实现 BREAK 语句的所有必要条件，我们需要在这里添加 IF 语句的执行流。当 IF 内部的条件计算为 true 时，执行 BREAK 语句，流程遵循图像中显示的路径。此外，请注意，BREAK 语句可以放置在循环例程执行之前、期间或之后。通常，它位于开头或结尾。如果它出现在中间，通常表示例程已被分为两部分。然而，为了使执行流程更简单，我没有在图中包含这种类型的操作。

在这一点上，我相信你理解这个概念。但是，请记住一件重要的事情：BREAK 语句还与另一种类型的控制流命令相关联。现在，我们将把讨论留到以后，一步一个脚印地进行。

现在，让我们查看另一个语句 — 可以出现在循环中的最后一个语句。然而，与我们到目前为止讨论的命令不同，下一条语句仅存在于循环中，使用时需要格外小心。

CONTINUE 语句

在循环中使用 CONTINUE 语句本身就存在风险，尤其是在 WHILE 或 DO-WHILE 循环中。这是因为使用此语句时意外创建无限循环的情况太常见了。尽管稍后将解释的 FOR 循环似乎更难成为无限循环，但它仍然可能发生。这通常是由于实现过程中的一个简单疏忽，需要使用 CONTINUE 命令。因此，无论何时需要在代码的任何部分使用或遇到此语句，都要保持警惕并格外小心。它总是与某种形式的循环相关联，但在处理 WHILE 和 DO-WHILE 循环时应特别注意。

考虑到误用此语句的潜在危险，让我们在这里采取稍微不同的方式来处理它。我们将首先了解遇到此语句时的执行流程。为此，我们将参考下图。

图 06

我们对 BREAK 和 RETURN 等其他语句给出的建议也适用于这里。然而，在这种特定情况下，建议在 IF 语句中使用 BREAK 或 RETURN 作为例程更为重要。正如您在图 06 中看到的，当使用 CONTINUE 时，循环例程内的任何内容都不会执行。与终止循环的其他语句不同，CONTINUE 使控制流立即返回到循环的开始。

因此，如果没有条件导致循环表达式的计算结果为 false，循环将不可避免地无限运行。这就是为什么在使用 CONTINUE 语句时必须格外小心。正是由于这个原因，许多编程语言不实现或不使用 GOTO 语句，因为可能会出现此类问题。但是，如果在正确的上下文中正确使用，CONTINUE 在许多情况下非常有用。但在使用它时，请始终保持冷静和非常专注。

为了证明涉及 CONTINUE 语句的粗心实现的潜在风险，让我们创建一个只会因某些外部事件而退出的代码。为此，我们将使用以下代码：

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
07. 
08.     Procedure_Loop();
09. 
10.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
11. }
12. //+------------------------------------------------------------------+
13. void Procedure_Loop(void)
14. {
15.     char info = 10;
16. 
17.     Print(__FUNCTION__, "  ", __LINE__, " : Info (", info, ")");
18.     
19.     while ((info) && (!TerminalInfoInteger(TERMINAL_KEYSTATE_ESCAPE)) && (!IsStopped()))
20.     {
21.         if (info) continue;
22. 
23.         info = info - 3;
24.                
25.         Print(__FUNCTION__, "  ", __LINE__, " : Info (", info, ")");
26. 
27.         if (info < -5) return;
28.     }
29.     Print(__FUNCTION__, "  ", __LINE__, " : Info (", info, ")");
30. }
31. //+------------------------------------------------------------------+

代码 07

在讨论代码 07 中发生了什么之前，让我们先看看执行它的结果。由于此代码在等待事件发生时将进入无限循环，因此我们不会使用静态图片。相反，我们将使用动画来展示我是如何终止应用程序的。您可以查看下面的动画：

动画 01

现在，亲爱的读者，请考虑以下内容。这只是因为我实现了一种退出我们正在创建的无限循环的方法。如果没有这个实现，我们将无限期地停留在那里，或者直到有人强行从 MetaTrader 5 中删除该应用程序。在任何其他情况下，应用程序都不会终止。鉴于这一警告和提醒，现在让我们仔细看看代码 07 中发生了什么。

由于这段代码是我们在本文中看到的其他示例的变体，因此我们可以专注于真正重要的部分。首先要注意的是，第 15 行中的变量被声明为允许 WHILE 循环运行，正如在循环开始的第 19 行所观察到的那样。下一个关键的观察结果是，我们有三个条件可以退出循环。第一种情况是当 info 变量变为 false 时。第二种是按下 ESC 键时。第三个是当你请求脚本结束时。如果没有第三个条件，MetaTrader 5 将尝试关闭脚本，直到成功。当这种情况发生时，终端中会出现不同的消息，如下图所示。

图 07

这将代表终止代码的最坏情况。然而，需要再次强调的是，图 07 中的这条消息只有在第三个条件（代码 07 中的第 19 行）缺失时才会出现。由于它存在，结果将与动画中观察到的结果相同，给人一种代码被正确终止的印象。

但这里的关键点是第 21 行。请注意，尽管存在检查循环中是否应该更改的 IF 语句，但 IF 语句中的例程仅由 CONTINUE 语句组成的事实迫使整个循环进入无限循环。这是因为 WHILE 循环例程的其他部分不会被执行。

但是，对同一代码的小更改可以降低风险。即使从 23 到 27 的代码行仍然永远不会被执行，一个例子是将代码 07 修改为类似代码 08 的代码，如下所示：

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
07. 
08.     Procedure_Loop();
09. 
10.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
11. }
12. //+------------------------------------------------------------------+
13. void Procedure_Loop(void)
14. {
15.     char info = 10;
16. 
17.     Print(__FUNCTION__, "  ", __LINE__, " : Info (", info, ")");
18.     
19.     while (((info = info - 3) > 0) && (!TerminalInfoInteger(TERMINAL_KEYSTATE_ESCAPE)) && (!IsStopped()))
20.     {
21.         if (info) continue;
22. 
23.         info = info - 3;
24.                
25.         Print(__FUNCTION__, "  ", __LINE__, " : Info (", info, ")");
26. 
27.         if (info < -5) return;
28.     }
29.     Print(__FUNCTION__, "  ", __LINE__, " : Info (", info, ")");
30. }
31. //+------------------------------------------------------------------+

代码 08

当我们执行代码 08 时，我们将在终端中看到与动画 01 中显示的不同的输出。如下所示：

图 08

如您所见，我们现在为变量 info 设置了不同的值。但这是怎样发生的呢？好吧，亲爱的读者，这是由于代码中的一个小变化 — 特别是在 WHILE 循环表达式的第一个条件的第 19 行。请注意，在这种特殊情况下，我们不再创建无限循环。然而，这并不能使循环例程的其余部分可执行。这是因为从深层次上讲，Procedure_Loop 可以概括为以下代码片段所示：

                   .
                   .
                   .
12//+------------------------------------------------------------------+
13void Procedure_Loop(void)
14{
15    char info = 10;
16
17    Print(__FUNCTION__, "  ", __LINE__, " : Info (", info, ")");
18    
19    while (((info = info - 3) > 0) && (!TerminalInfoInteger(TERMINAL_KEYSTATE_ESCAPE)) && (!IsStopped()));
20
21    Print(__FUNCTION__, " 29 : Info (", info, ")");
22}
23//+------------------------------------------------------------------+

片段 01

这是因为 IF 语句中的第 21 行存在 CONTINUE 命令，这导致该命令每次在循环内执行。这很有趣。但是，如果出于某种原因，我们没有使用 WHILE 循环，而是使用了 DO-WHILE 循环呢？那会发生什么？好吧，亲爱的读者，我们肯定会有一个非常有趣的场景，一个会吸引很多人的场景。根据您实现代码的方式，它可能会以非常复杂的方式运行。

因此，让我们尝试一个非常简单的版本，旨在展示在 DO WHILE 循环中使用 CONTINUE 命令时会发生什么。此示例可见于下面的代码 09：

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
07. 
08.     Procedure_Loop();
09. 
10.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
11. }
12. //+------------------------------------------------------------------+
13. void Procedure_Loop(void)
14. {
15.     char info = 10;
16.     ulong counter = 0;
17. 
18.     Print(__FUNCTION__, "  ", __LINE__, " : Info (", info, ")");
19.     
20.     do
21.     {
22.         Sleep(500);
23. 
24.         Print(__FUNCTION__, "  ", __LINE__, " : Counter (", counter = counter + 1, ")");
25. 
26.         if (info) continue;
27.               
28.         Print(__FUNCTION__, "  ", __LINE__, " : Info (", info, ")");
29. 
30.     }while ((info = info - 2) > 0);
31. 
32.     Print(__FUNCTION__, "  ", __LINE__, " : Info (", info, ")");
33. }
34. //+------------------------------------------------------------------+

代码 09

虽然您最初可能认为这里创建了一个无限循环，但由于本节前面的代码示例中演示的一个小细节，这种情况不会发生。但是，许多使用 DO WHILE 循环经验较少的程序员可能会认为，当执行第 26 行时，循环将返回到第 20 行。这种想法恰恰源于对 DO WHILE 循环中执行流程如何运作缺乏理解。我们在上一篇文章中介绍了执行流程。所以我不会在这里进一步详细说明。然而，当你研究这段代码时，一个事实将被证明：在代码 09 中看到的内容中，第 28 行永远不会被执行。这是因为第 26 行以及 DO WHILE 循环中执行流的操作方式。

为了证明这一点，我发现使用动画比提供图片更好。在我看来，这种方法对教学更有效，它允许你开始思考代码 09 的行为方式的原因。您可以查看下面的动画。密切关注并试着理解它是如何以及为什么以这种方式发生的。

动画 02

最后的探讨

在本文中，我尽一切努力尽可能简单明了地解释如何在循环中使用 RETURN、BREAK 和 CONTINUE 语句。虽然大部分内容集中在 WHILE 和 DO WHILE 循环的使用上，但这里演示的原理也适用于 FOR 循环，稍后将会解释。

然而，我亲爱的、有价值的读者，你必须花时间研究和实践本文所涵盖的内容。随着我们向更高级的编程水平迈进，需要对这些概念有深入的理解。随着事情变得越来越复杂，这里讨论的主题和概念将不再赘述。

因此，请充分利用附件中提供的代码示例。仔细研究它们，注意这三个命令（RETURN、BREAK 和 CONTINUE）如何影响应用程序执行期间的代码流。也就是说，我们下一篇文章再见。期待很快与您见面！