应该使用< 或在 for 循环中 <=

Question

Closed. This question is opinion-based. It is not currently accepting answers.

---

想要改进这个问题？更新问题，以便可以通过编辑这篇文章用事实和引文来回答它。

4 年前已关闭。

Answer 1

第一个更惯用。 特别是，它指示（从 0 开始的意义上）迭代次数。 当使用基于 1 的东西（例如 JDBC、IIRC）时，我可能会想使用 <=。 所以：

for (int i=0; i < count; i++) // For 0-based APIs

for (int i=1; i <= count; i++) // For 1-based APIs

我预计实际代码中的性能差异不会太小。

Answer 2

这两个循环都迭代 7 次。 我想说的是带有 7 的那个更具可读性/更清晰，除非你对另一个有充分的理由。

Answer 3

我记得当我们在大学进行 8086 组装时，它的性能更高：

for (int i = 6; i > -1; i--)

因为有一个 JNS 操作，表示无符号则跳转。 使用这个意味着在每个周期之后没有内存查找来获取比较值，也没有比较。 如今，大多数编译器都会优化寄存器的使用，因此内存问题不再重要，但您仍然会得到不需要的比较。

顺便说一下，在循环中放入 7 或 6 会引入“幻数”。 为了更好的可读性，您应该使用带有意图显示名称的常量。 像这样：

const int NUMBER_OF_CARS = 7;
for (int i = 0; i < NUMBER_OF_CARS; i++)

编辑：人们没有得到汇编的东西，所以显然需要一个更完整的例子：

如果我们做 for (i = 0; i <= 10; i++) 你需要这样做：

    mov esi, 0
loopStartLabel:
                ; Do some stuff
    inc esi
                ; Note cmp command on next line
    cmp esi, 10
    jle exitLoopLabel
    jmp loopStartLabel
exitLoopLabel:

如果我们做 for (int i = 10; i > -1; i--) 那么你可以摆脱这个：

    mov esi, 10
loopStartLabel:
                ; Do some stuff
    dec esi
                ; Note no cmp command on next line
    jns exitLoopLabel
    jmp loopStartLabel
exitLoopLabel:

我刚刚检查过，微软的 C++ 编译器没有做这个优化，但如果你这样做了：

for (int i = 10; i >= 0; i--) 

所以道德是如果你使用Microsoft C++†，升序或降序没有区别，要获得快速循环，您应该使用：

for (int i = 10; i >= 0; i--)

而不是其中任何一个：

for (int i = 10; i > -1; i--)
for (int i = 0; i <= 10; i++)

但坦率地说，获得“for (int i = 0; i <= 10; i++)”的可读性通常比缺少一个处理器命令重要得多。

† 其他编译器可能会做不同的事情。

Answer 4

我总是使用 < array.length 因为它比 <= array.length-1 更容易阅读。

还具有< 7 并且鉴于您知道它从 0 索引开始，因此直观地可以看出该数字是迭代次数。

Answer 5

从优化的角度来看，这并不重要。

从代码风格的角度来看，我更喜欢 < 。 原因：

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

比 <还> 更具可读性

for ( int i = 0; i <= array.size() -1; i++ )

。 立即给出迭代次数。

另一票投给了< 是你可以防止很多意外的差一错误。

Answer 6

@Chris，您关于 .NET 中 .Length 成本高昂的说法实际上是不正确的，对于简单类型而言，情况恰恰相反。

int len = somearray.Length;
for(i = 0; i < len; i++)
{
  somearray[i].something();
}

实际上比

for(i = 0; i < somearray.Length; i++)
{
  somearray[i].something();
}

后者慢，是运行时优化的情况。 由于运行时可以保证 i 是数组的有效索引，因此不会进行边界检查。 在前者中，运行时不能保证 i 在循环之前没有被修改，并强制对每个索引查找的数组进行边界检查。

Answer 7

在性能方面，它没有产生任何有效的差异。 因此，我会使用在您正在解决的问题的背景下更容易理解的内容。

Answer 8

我更喜欢：

for (int i = 0; i < 7; i++)

我认为这更容易翻译为“迭代循环 7 次”。

我不确定对性能的影响 - 我怀疑任何差异都会被编译掉。

Answer 9

在 C++ 中，我更喜欢使用 !=，它可用于所有 STL 容器。 并非所有 STL 容器迭代器都无法比较。

Answer 10

在 Java 1.5 中，您可以

for (int i: myArray) {
    ...
}

对数组情况执行此操作，无需担心。

Answer 11

我不认为有性能差异。 不过，第二种形式肯定更具可读性，您不必在心里减一即可找到最后的迭代编号。

编辑：我看到其他人不同意。 就我个人而言，我喜欢查看循环结构中的实际索引号。 也许是因为它更让人想起 Perl 的 0..6 语法，我知道它相当于 (0,1,2,3,4,5,6)。 如果我看到 7，我必须检查它旁边的运算符，看看实际上永远不会到达索引 7。

Answer 12

我会说使用“< 7”版本，因为这是大多数人都会阅读的内容 - 因此，如果人们浏览您的代码，他们可能会错误地解释它。

我不会担心“<”是否存在 比“<=”更快，只是为了可读性。

如果您确实想提高速度，请考虑以下事项：

for (int i = 0; i < this->GetCount(); i++)
{
  // Do something
}

要提高性能，您可以稍微重新安排它：

const int count = this->GetCount();
for (int i = 0; i < count; ++i)
{
  // Do something
}

注意从循环中删除 GetCount() （因为它将在每个循环中查询）以及 " i++”到“++i”。

Answer 13

Edsger Dijkstra 早在 1982 年就此事写过一篇文章他主张 lower <= i < < 上：

存在一个最小的自然数。 排除下界（如 b）和 d）中那样，迫使从最小自然数开始的子序列将下界纳入非自然数领域。 这很难看，所以对于下界，我们更喜欢 a) 和 c) 中的 ≤。 现在考虑从最小自然数开始的子序列：当序列收缩为空时，包含上限将迫使后者变得不自然。 这很难看，所以对于上限，我们更喜欢 < 如 a) 和 d) 中所示。 我们的结论是约定 a) 是首选。

Answer 14

首先，不要使用 6 或 7。

更好用：

int numberOfDays = 7;
for (int day = 0; day < numberOfDays ; day++){

}

在这种情况下，它比使用更好

for (int day = 0; day <= numberOfDays  - 1; day++){

}

甚至更好（Java / C#）：

for(int day = 0; day < dayArray.Length; i++){

}

甚至更好（C#）

foreach (int day in days){// day : days in Java

}

反向循环确实更快，但因为它更难阅读（如果不是）由你由其他程序员），最好避免 in。尤其是在 C#、Java 中......

Answer 15

我同意大家的说法，在这种情况下 7 是有意义的，但我想补充一点，在 6 很重要的情况下，假设你想明确表示你只对第 6 个索引以下的对象起作用，那么<= 更好，因为它使 6 更容易看到。

Answer 16

早在大学时，我就记得这两个操作在 CPU 上的计算时间相似。 当然，我们是在装配层面上谈论的。

然而，如果你谈论的是 C# 或 Java，我真的不认为其中一个会比另一个更快，你获得的几纳秒很可能不值得你引入任何混乱。

就我个人而言，我会编写从业务实现的角度来看有意义的代码，并确保它易于阅读。

Answer 17

这直接属于“让错误代码看起来错误”类别。

在从零开始的索引语言中，例如 Java 或 C#，人们习惯于 index index 的变体。 计数条件。 因此，利用这种事实上的约定将使相差一的错误更加明显。

关于性能：任何值得其内存占用的优秀编译器都应该不会出现问题。

Answer 18

顺便说一句，当循环遍历 .Net 中的数组或其他集合时，我发现

foreach (string item in myarray)
{
    System.Console.WriteLine(item);
}

它比数字 for 循环更具可读性。 当然，这假设循环代码中未使用实际计数器 Int 本身。 不知道性能是否有变化。

Answer 19

写 i<7 有很多充分的理由。 将数字 7 放在迭代 7 次的循环中是很好的。 性能实际上是相同的。 几乎每个人都写 i<7。 如果您为了可读性而写作，请使用每个人都能立即识别的形式。

Answer 20

我一直更喜欢：

for ( int count = 7 ; count > 0 ; -- count )

Answer 21

养成使用<的习惯 当您迭代数组时，这将使您和读者保持一致。 大家有一个标准约定会更简单。 如果您使用的是基于 0 的数组的语言，则 < 是惯例。

几乎可以肯定，这比 << 之间的任何性能差异都更重要。 且<=。 首先以功能和可读性为目标，然后进行优化。

另一个注意事项是，最好养成执行 ++i 而不是 i++ 的习惯，因为获取和增量需要临时和增量，而获取则不需要。 对于整数，您的编译器可能会优化临时值，但如果您的迭代类型更复杂，则可能无法做到这一点。

Answer 22

不要使用魔法数字。

为什么是7？ （或 6 个）。

使用正确的符号来表示您要使用的数字...

在这种情况下，我认为最好使用

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

Answer 23

'<' 和 '<=' 运算符的性能成本完全相同。

'<' 运算符是标准的，并且在从零开始的循环中更易于阅读。

使用 ++i 而不是 i++ 可以提​​高 C++ 中的性能，但不能提高 C# 中的性能 - 我不了解 Java。

Answer 24

正如人们所观察到的，你提到的两种选择都没有区别。 为了证实这一点，我在 JavaScript 中做了一些简单的基准测试。

您可以在此处查看结果。 从中不清楚的是，如果我交换第一个和第二个测试的位置，这两个测试的结果交换，这显然是一个内存问题。 然而，第三个测试（我颠倒迭代顺序的测试）显然更快。

Answer 25

正如大家所说，即使对于数组之外的事物，也习惯使用 0 索引迭代器。 如果一切都从 0 开始并以 n-1 结束，并且下限始终为 <= 并且上限始终为 ><，在检查代码时您需要做的思考就少了很多。

Answer 26

很好的问题。 我的答案：使用类型 A ('<')

• 您可以清楚地看到您有多少次迭代 (7)。
• 两个端点之间的差异是范围的宽度
• 更少的字符使其更具可读性
• 您更常见的是元素总数 i i i i i i i i strlen(s) 而不是最后一个元素的索引，因此一致性很重要。

另一个问题是整个结构。 i 在其中出现 3 次，因此可能会输入错误。 for 循环结构表示如何做，而不是要做什么。 我建议采用这个：

BOOST_FOREACH(i, IntegerInterval(0,7))

这更清晰，编译成完全相同的asm指令等。如果你愿意，可以问我 IntegerInterval 的代码。

Answer 27

这么多答案......但我相信我有一些补充。

我的偏好是让文字数字清楚地显示“i”将在循环中采用什么值。 因此，在迭代从零开始的数组的情况下：

for (int i = 0; i <= array.Length - 1; ++i)

如果您只是循环，则不是迭代数组，从 1 数到 7 非常直观：

for (int i = 1; i <= 7; ++i)

可读性胜过性能，直到您对其进行分析（您可能不会这样做）在那之前不知道编译器或运行时将如何处理您的代码。

Answer 28

您也可以使用 != 代替。 这样，如果在初始化中出错，您将陷入无限循环，从而导致错误更早被注意到，并且它导致的任何问题都仅限于陷入循环中（而不是稍后出现问题并且找不到它）。

Answer 29

我认为两者都可以，但是当你选择了之后，就坚持其中一个。 如果你习惯使用<=，那么尽量不要使用< 反之亦然。

我更喜欢 <=，但在您使用从零开始的索引的情况下，我可能会尝试使用 <。 不过这都是个人喜好。

Answer 30

严格从逻辑角度来看，您必须认为 < count 比 <= count 更有效，因为 <= 也将测试相等性。