在for循环内，如果可能，是否应该将中断条件移到条件字段中？[关闭]

有时我需要循环，需要这样的中断：

for(int i=0;i<array.length;i++){
    //some other code
    if(condition){
        break;
    }
}

我对写作感到不舒服

if(condition){
    break;
}

因为它消耗3行代码。我发现循环可以重写为：

                                   ↓
for(int i=0;i<array.length && !condition;i++){
    //some other code
}

所以我的问题是，如果可能的话，将条件移至条件字段以减少代码行是否是一种好习惯？

您提供的这两个示例在功能上并不等效。在原始版本中，条件测试是在“其他代码”部分之后进行的，而在修改版本中，条件测试是在循环体的开头进行的。

绝不能仅出于减少行数的目的而重写代码。显然，以这种方式工作时，这是一个不错的好处，但是绝对不要以可读性或正确性为代价。

我不赞成“它消耗3行代码”这样的说法是不好的。毕竟，您可以将其编写为：

if (condition) break;

只消耗一行

如果if出现在循环的一半，那么它当然必须作为单独的测试存在。但是，如果此测试出现在块的末尾，则说明您创建了一个循环，该循环在循环的两端均具有继续测试，这可能会增加代码的复杂性。但是请注意，有时if (condition)只有在执行该块之后，才可以进行测试。

但是假设情况并非如此，可以采用其他方法：

for(int i=0;i<array.length && !condition;i++){
    //some other code
}

退出条件保持在一起，可以简化操作（特别是如果“ 其他一些代码 ”很长的话）。

当然，这里没有正确的答案。因此，请注意该语言的习惯用法，您团队的编码约定等。但是总的来说，当在功能上可行时，我会采用单一测试方法。

这种问题几乎一直在引发编程之初就引发了争论。把我的帽子成环，我会去用的版本break条件和这里的原因（这种特定的情况下）：

该for环就是那里的循环来指定迭代值。在其中编码中断条件只会使IMO的逻辑混乱。

有了单独的分隔break符，可以很清楚地知道，在正常处理期间，这些值与for循环中指定的一样，并且应该继续进行处理，除非出现条件。

作为背景知识，我开始编写a break，然后将条件放入for循环中多年（在一位杰出的程序员的指导下），然后又返回到该break样式，因为它感觉更简洁了（这是该样式中的主流样式）。我正在使用的各种代码主题）。

这是一天结束时的另一场圣战-有人说你永远不要人为地打破循环，否则这不是真正的循环。做任何您认为容易理解的事情（包括您自己和他人）。如果真的想减少击键，那么在周末去打高尔夫球吧-可选啤酒。

for循环是迭代某件事¹ -他们不只是笑，let's-拉一些，随机的东西，来自该体和放了他们，在半实物头-这三个词语具有非常具体含义：

• 第一个是初始化迭代器。它可以是索引，指针，迭代对象或其他任何对象-只要用于迭代。
• 第二个是检查我们是否到达终点。
• 第三是用于推进迭代器。

这个想法是将迭代处理（如何迭代）与循环内的逻辑（每次迭代做什么）分开。许多语言通常都有一个for-each循环，可以使您免于迭代的细节，但是即使您的语言没有该构造，或者即使您的语言无法使用该构造，也应限制循环头迭代处理。

因此，您需要问自己-有关迭代处理或循环内逻辑的条件是？很有可能，这与循环内的逻辑有关-因此应在循环内而不是在标头中对其进行检查。

¹与其他循环相反，这些循环“等待”某些事情发生。一for/ foreach循环应该有一个项目的“清单”，反覆的概念-即使该列表是懒惰的或无限的或抽象的。

我建议将版本与一起使用if (condition)。它更具可读性，更易于调试。编写3行额外的代码不会打断您的手指，但会让下一个人更容易理解您的代码。

如果要遍历应跳过某些元素的集合，则建议使用新选项：

• 迭代之前过滤您的收藏集

Java和C＃都使这项工作相对琐碎。如果C ++有一种方法可以使花哨的迭代器跳过某些不适用的元素，我不会感到惊讶。但这只是在您选择的语言支持的情况下才是真正的选择，而使用的原因break是因为是否处理某个元素存在一定的条件。

否则，有充分的理由使您的条件成为for循环的一部分-假设它的初始评估是正确的。

• 更容易看到循环何时提前结束

我已经编写了代码，其中您的for循环需要几百行，其中包含多个条件和一些复杂的数学运算。您遇到的问题是：

• break 逻辑中隐藏的命令很难找到，有时令人惊讶
• 调试需要逐步遍历循环的每一步，以真正了解正在发生的事情
• 许多代码没有可轻松实现的可重构，也没有单元测试来帮助重写后的功能等同

在这种情况下，我会按照优先顺序推荐以下准则：

• 过滤集合以消除break可能的需要
• 使条件部分成为for循环条件
• break尽可能将条件句放在循环的顶部
• 添加多行注释以引起对中断及其原因的关注

这些准则始终受您代码正确性的约束。选择最能代表其意图并提高代码清晰度的选项。

我强烈建议您采取最少惊讶的方法，除非您在其他方面获得了重大收益。

人们在阅读单词时不会阅读每个字母，在阅读书时不会阅读每个单词-如果他们擅长阅读，他们会查看单词和句子的轮廓，并让大脑充满其余的内容。

因此，偶然的开发人员可能会认为这只是循环的标准，甚至不会去看：

for(int i=0;i<array.length&&!condition;i++)

如果无论如何都要使用该样式，我建议您更改零件，for(int i=0;i<并;i++)告诉读者这是循环的标准。

与if- 配合使用的另一个原因break是，您不能始终将for-condition 与您的方法配合使用。您必须使用if- break当中断条件太复杂而无法隐藏在一条for语句中时，或者依赖于只能在for循环内部访问的变量。

for(int i=0;i<array.length&&!((someWidth.X==17 && y < someWidth.x/2) || (y == someWidth.x/2 && someWidth.x == 18);i++)

因此，如果您决定使用if- break，则可以满足要求。但是，如果您决定使用for-condition，则必须同时使用if- break和for-condition。为保持一致，只要条件发生变化，就必须在for-condition和if- 之间来回移动break条件。

您的转换假设进入循环时condition对结果的求值true。在这种情况下，我们无法对此进行评论，因为它尚未定义。

在这里成功完成“减少代码行”操作后，您可以继续研究

for(int i=0;i<array.length;i++){
    // some other code
    if(condition){
        break;
    }
    // further code
}

并应用相同的变换，得出

for(int i=0;i<array.length && !condition;i++){
    // some other code
    // further code
}

这是无效的转换，因为您现在无条件执行further code以前没有的操作。

一种更安全的转换方案是提取some other code并评估condition一个单独的函数

bool evaluate_condition(int i) // This is an horrible name, but I have no context to improve it
{
     // some other code
     return condition;
}

for(int i=0;i<array.length && !evaluate_condition(i);i++){
    // further code
}

TL; DR在您的特定情况下尽一切可能做得最好

让我们来看这个例子：

for ( int i = 1; i < array.length; i++ ) 
{
    if(something) break;
    // perform operations
}

在这种情况下，如果something真为真，我们不希望for循环中的任何代码执行，因此将test something的条件移入条件字段是合理的。

for ( int i = 1; i < array.length && !something; i++ )

再根据是否something可以将其设置为true循环之前（而不是循环内部），这可能会更加清楚：

if(!something)
{
    for ( int i = 1; i < array.length; i++ )
    {...}
}

现在想象一下：

for ( int i = 1; i < array.length; i++ ) 
{
    // perform operations
    if(something) break;
    // perform more operations
}

我们在那里发送了一个非常明确的消息。如果something在处理数组时变为true，则此时放弃整个操作。为了将检查移至条件字段，您需要执行以下操作：

for ( int i = 1; i < array.length && !something; i++ ) 
{
    // perform operations
    if(!something)
    {
        // perform more operations
    }
}

可以说，“消息”变得混乱了，我们正在两个地方检查故障情况-如果故障情况发生变化而我们忘记了那些地方之一怎么办？

当然，for循环和条件还有更多不同的形状，它们都有自己的细微差别。

编写代码，使其读起来很简洁（这显然是主观的）。在一套严苛的编码准则之外，所有 “规则”都有例外。写出您认为最能代表决策的内容，并最大程度地减少将来犯错误的机会。

虽然它很吸引人，因为您在循环头中看到了所有条件，并且break可能在大型块中造成混淆，但for循环是大多数程序员期望在一定范围内循环的一种模式。

尤其是由于这样做，添加额外的中断条件可能会引起混乱，并且很难看出它在功能上是否等效。

通常，一个好选择是使用whileor do {} while循环检查两个条件，假设您的数组至少有一个元素。

int i=0
do {
    // some other code
    i++; 
} while(i < array.length && condition);

使用仅检查条件而不从循环头运行代码的循环，您可以很清楚地知道何时检查条件，什么是实际条件以及有副作用的代码。

这很糟糕，因为代码是供人类阅读的-非惯用语for循环常常使人难以理解，这意味着这些错误更有可能隐藏在此处，但是原始代码可能会得到改进，同时保留两者简短易读。

如果要在数组中查找值（提供的代码示例有些通用，但也可能是这种模式），则可以明确地尝试使用编程语言为此目的提供的功能。例如（伪代码，因为未指定编程语言，所以解决方案取决于特定语言）。

array.find(item -> item.valid)

这将明显缩短解决方案，同时简化您的代码，因为代码明确说明了您的需求。

我认为没有理由说您不应该这样做。

1. 这降低了可读性。
   
2. 输出可能不相同。但是，这可以通过do...while循环（而不是while）来完成，因为在执行某些代码后会检查条件。
   

但最重要的是，请考虑一下，

for(int i=0;i<array.length;i++){

    // Some other code
    if(condition1){
        break;
    }

    // Some more code
    if(condition1){
        break;
    }

    // Some even more code
}

现在，您可以通过将这些条件添加到该for条件中来真正实现它吗？

我认为删除break可以是一个好主意，但不能节省代码行。

不编写它的好处break是循环的后置条件是显而易见的。当您完成循环并执行程序的下一行时，循环条件i < array.length && !condition必须为false。因此，要么i大于或等于您的数组长度，要么condition为true。

在的版本中break，有一个隐藏的陷阱。循环条件表明，当您为每个有效的数组索引运行了一些其他代码时，循环终止，但是实际上有一条break语句可以在此之前终止循环，除非您查看循环代码，否则您将看不到该语句。非常小心。自动化的静态分析器（包括优化编译器）也可能难以推断出循环的后置条件。

这是Edgar Dijkstra撰写“ Goto被认为有害”的最初原因。这不是风格问题：中断循环使得很难正式地就程序状态进行推理。break;我一生中写了很多声明，成年后甚至写了一篇goto（打破对性能至关重要的内部循环的多个层次，然后继续搜索树的另一个分支）。但是，我比a更有可能return从循环中编写条件语句（该条件语句从不在循环后运行，因此无法将其后置条件弄糟）break。

后记

实际上，重构代码以提供相同的行为实际上可能需要更多的代码行。您的重构可能对某些其他特定代码有效，或者如果我们可以证明condition从错误开始。但是您的示例在一般情况下等效于：

if ( array.length > 0 ) {
  // Some other code.
}
for ( int i = 1; i < array.length && !condition; i++ ) {
  // Some other code.
}

如果其他代码不是单行代码，则可以将其移至某个函数以免重复自己，然后您几乎将循环重构为尾递归函数。

不过，我知道这不是您提出问题的重点，并且您一直在保持简单。

是的，但是您的语法是非常规的，因此很差（tm）

希望您的语言支持类似

while(condition) //condition being a condition which if true you want to continue looping
{
    do thing; //your conditionally executed code goes here
    i++; //you can use a counter if you want to reference array items in order of index
}

如果您担心过于复杂的for语句难以阅读，那绝对是一个有效的问题。浪费垂直空间也是一个问题（尽管不太重要）。

（个人而言，我不喜欢if语句必须始终带有花括号的规则，这在很大程度上浪费了垂直空间。请注意，问题是在浪费垂直空间。使用具有有意义的行的垂直空间应该不是问题。）

一种选择是将其拆分为多行。如果您使用的是for带有多个变量和条件的非常复杂的语句，这绝对是您应该做的。（对我来说，这是对垂直空间的更好利用，它会给尽可能多的行一些有意义的东西。）

for (
   int i = 0, j = 0;
   i < array.length && !condition;
   i++, j++
) {
   // stuff
}

更好的方法可能是尝试使用更具说明性和较少要求的形式。这取决于语言，或者您可能需要编写自己的函数来启用这种功能。这也取决于condition实际情况。大概它必须能够以某种方式进行更改，具体取决于数组中的内容。

array
.takeWhile(condition)  // condition can be item => bool or (item, index) => bool
.forEach(doSomething); // doSomething can be item => void or (item, index) => void

被遗忘的一件事：当我从循环中中断时（无论如何实现，都不做所有可能的迭代），通常不仅要退出循环，而且还要知道为什么会发生这种情况。例如，如果我寻找X，不仅会中断循环，而且还想知道X的位置和位置。

在那种情况下，让条件处于循环之外是很自然的。所以我开始

bool found = false;
size_t foundIndex;

在循环中，我将写

if (condition) {
    found = true;
    foundIndex = i;
    break;
}

与for循环

for (i = 0; i < something && ! found; ++i)

现在检查循环中的条件是很自然的。是否存在“ break”语句取决于要避免的循环中是否有进一步的处理。如果需要某些处理而不需要其他处理，则可能会有类似

if (! found) { ... }

您循环中的某处。