blocks|key|3232764|text|在您的例子中，除了在for循环中少了一行代码之外，您不会获得太多好处。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3232765|但是，如果您像这样声明循环：|3232766|for(int+i+=+0;+i+<+x;+i%2B%2B)|code-block|syntax|javascript|3232767|您设法将i保持在循环的作用域内，而不是让它逃逸到代码的其余部分。|3232768|此外，在while循环中，变量声明、条件和增量位于3个不同的位置。使用for循环，所有内容都放在一个方便、易读的地方。|3232769|最后的想法：|BOLD|3232770|还有一个重要的注意事项。这两者之间存在语义上的差异。而循环，一般来说，意味着有无限的迭代次数。(即直到文件被read..no+(不管其中有多少行)，for循环应该有一个更确定的迭代次数。(循环遍历集合中的所有元素，我们可以根据集合的大小对其进行计数。)|3232771|entityMap^0|A|3|0|0|0|4|1|0|0|0|6|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@$9|Y|A|Z|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|10|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|11|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|12|8|@$9|13|A|14|B|C]]|D|@]|E|$]]|$1|O|3|P|5|6|7|15|8|@]|D|@]|E|$]]|$1|Q|3|R|5|6|7|16|8|@$9|17|A|18|B|S]]|D|@]|E|$]]|$1|T|3|U|5|6|7|19|8|@]|D|@]|E|$]]|$1|V|3|-4|5|6|7|1A|8|@]|D|@]|E|$]]]|W|$]]

In your case, you don't gain much besides one less line of code in the <code>for</code> loop.

However, if you declare the loop like so:

<pre><code>for(int i = 0; i &lt; x; i++)
</code></pre>

You manage to keep <code>i</code> within the scope of the loop, instead of letting it escape to the rest of the code.

Also, in a while loop, you have the variable declaration, the condition, and the increment in 3 different places. With the for loop, it is all in one convenient, easy-to-read place.

Last thought: 
One more important note. There is a semantic difference between the two. While loops, in general, are meant to have an indefinite number of iterations. (ie. until the file has been read..no matter how many lines are in it), and for loops should have a more definite number of iterations. (loop through all of the elements in a collection, which we can count based on the size of the collection.)

blocks|key|292501|text|选择for而不是while有一个原因:可读性。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|292502|通过使用for循环，您明确表示您的意图是执行某种类型的操作，这些操作需要初始化、“步骤”操作和完成条件。|292503|另一方面，对于while，您只是说您需要完成条件。|292504|entityMap^0|2|3|8|5|0|4|3|0|7|5|0^^$0|@$1|2|3|4|5|6|7|L|8|@$9|M|A|N|B|C]|$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|T|8|@$9|U|A|V|B|C]]|D|@]|E|$]]|$1|J|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|K|$]]

There is one reason to choose <code>for</code> over <code>while</code>: Readability.

By using a <code>for</code> loop, you're expressly saying your intent is to perform some type of operating that requires an initialization, a "step" operation, and a completion condition.

With <code>while</code>, on the other hand, you're only saying you need the completion condition.

blocks|key|295732|text|当我不一定需要计数器时，我使用'while‘，例如，当你正在读取一个文件，并且你正在等待访问EOF时。在这种情况下，'for‘可能不是最好的选择。当你遍历数组中的项时，我更喜欢使用'for‘，因为它能更好地表达意图。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|295733|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I use 'while' when I don't necessarily need a counter, for example when you are reading from a file and you are waiting to reach EOF. In this case 'for' may not be the best alternative. When you are going through items on an array I'd rather use 'for' because it conveys intent better.

blocks|key|295142|text|for()和while()循环之间一个值得注意的区别是，while()循环中的"continue“语句将分支到循环的顶部，而for()循环中的语句将分支到for()子句的第三部分，即条件后面的部分，通常用于转移变量。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|295143|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

The one notable difference between a for() and while() loop is that a "continue" statement in a while() loop will branch to the top of the loop, while one in a for() loop will branch to the third part of the for() clause [the one after the condition, usually used to bump variables].

blocks|key|3018772|text|作为一名教师，我一直在以各种形式思考这一点；我的建议总是归结为|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3018773|3018774|for-loops是用于计数的。向上计数，计数down.|unordered-list-item|offset|length|style|CODE|3018775|while+/+do-while构造适用于所有其他条件。c!=EOF、diff<0.02等。迭代器/枚举器是非常适合for循环的计数器。|3018776|3018777|也就是说，你的int=0;+while(+...+)在我眼里很难看。|3018778|entityMap^0|0|0|0|3|0|0|5|8|8|S|6|Z|9|0|0|7|J|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|R|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|S|8|@$F|T|G|U|H|I]]|9|@]|A|$]]|$1|J|3|K|5|E|7|V|8|@$F|W|G|X|H|I]|$F|Y|G|Z|H|I]|$F|10|G|11|H|I]|$F|12|G|13|H|I]]|9|@]|A|$]]|$1|L|3|-4|5|6|7|14|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|15|8|@$F|16|G|17|H|I]]|9|@]|A|$]]|$1|O|3|-4|5|6|7|18|8|@]|9|@]|A|$]]]|P|$]]

As a teacher I have been pondering this in various shapes and forms; my suggestion always boils down to

<ul>
<li><code>for</code>-loops are for counting. counting up, counting down.</li>
<li><code>while</code> / <code>do-while</code> constructs are for all other conditions. <code>c!=EOF</code>, <code>diff&lt;0.02</code>, etc.
Iterators/Enumerators are counters very suitable for for-loops.</li>
</ul>

i.e. your <code>int=0; while( ... )</code> is hideous to my eyes.

blocks|key|295871|text|为什么选择可口可乐而不是百事可乐？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|295872|在WHILE和FOR循环之间，您可以互换使用它们。要成为一个纯粹主义者，你可以根据条件的性质做出决定。如果您正在执行基于计数的循环，那么FOR循环将是最有意义的。|295873|for(+cur+=+0;+cur+<+myList.Length;+cur%2B%2B+){
++++doSomething(+myList[cur]+);
}|code-block|syntax|javascript|295874|如果您正在执行基于逻辑的循环，那么WHILE将是最干净的实现|295875|Iterator+i+=+myObject.getIterator();
while(+i.hasNext()+){
++++doSomething(+i.next()+);
}|295876|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Why choose Coke over Pepsi?

Between a WHILE and FOR loop, you can use them interchangeably. To be a purist, you could make your decision base on the nature of the conditions. If you're performing a count-based loop, then a FOR loop would make the most sense.

<pre><code>for( cur = 0; cur &lt; myList.Length; cur++ ){
 doSomething( myList[cur] );
}
</code></pre>

If you're performing a logic-based loop, then a WHILE would make for the cleanest implementation

<pre><code>Iterator i = myObject.getIterator();
while( i.hasNext() ){
 doSomething( i.next() );
}
</code></pre>

blocks|key|3018587|text|正如您所说，原因是语义和美学上的，而不是性能(它们的编译代码往往非常相似)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3018588|也就是说，在具有已知迭代次数的循环中，for通常是常见的，而while意味着条件不一定与您在循环中所做的事情相关，或者您在开始时不知道会有多少次迭代。|offset|length|style|CODE|3018589|entityMap^0|0|J|3|U|5|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@$D|L|E|M|F|G]|$D|N|E|O|F|G]]|9|@]|A|$]]|$1|H|3|-4|5|6|7|P|8|@]|9|@]|A|$]]]|I|$]]

As you say, the reasons are semantical and aesthetical, rather than performance (their compiled code tends to be very similar).

That said, <code>for</code> is usual in cycles which have a known number of iterations, whereas <code>while</code> implies that the condition isn't necessarily correlated to what you're doing inside the cycle, or that you don't know at the beginning how many iterations there will be.

blocks|key|3233210|text|一般来说，我总是更喜欢for循环，即使在循环与计数无关的情况下也是如此，因为它将循环的维护定位在一个位置。当其他人决定添加/修改循环时，如果他们使用FOR循环，进行修改的人通常可以确信，只要他们不弄乱FOR表达式中的项，他们就不会中断循环中的迭代。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3233211|然而，像while循环这样的东西需要程序员完整地解析循环体，并了解它是如何迭代的，以确保他们在进行更改时保持循环维护代码不变并以正确的顺序进行。|3233212|因此，我只在只需要FOR的中间部分的情况下才使用WHILE。|3233213|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

Generally, I always prefer for loops, even for cases where the loop has nothing to do with counting, because it localizes maintenance of the loop in a single location. When someone else comes along and decides to add/modify the loop, if they are using a FOR loop, the person doing the modification can generally be confident that, so long as they don't mess with items inside the FOR expression(s), they aren't going to break iteration in the loop.

However, something like a while loop requires the programmer to parse the loop body completely, and understand how it iterates, to make sure they keep loop maintenance code unmodified and in the correct order when they make changes.

Therefore, I only use WHILE in cases where I only effectively need the middle part of the FOR.

blocks|key|3018568|text|它们在功能上是相同的，但是，可以说for循环不太容易出错，因为所有的循环功能都在一起。如果有几行代码分隔了i的声明、while声明和索引迭代器，那么您可能会忘记它的用法，或者对它的使用方式感到困惑。当然，这都是主观的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3018569|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

They are functionally identical, however, it can be argued that the for loop is less error prone, because all of the loop functionality is right there together. if you have several lines separating the declaration of i, the while declaration, and the index iterator, you could forget, or be confused by how it is used. This is all subjective of course.

blocks|key|295810|text|它们通常会编译成相同的最终结果。大多数情况下，我更喜欢for+s或for-each。写作|type|unstyled|depth|inlineStyleRanges|entityRanges|data|295811|for+(;x<5;x%2B%2B){+
++++//do+work+
}+|code-block|syntax|javascript|295812|并不是那么险恶，但写作|295813|while(x<5){
++++x%2B%2B
++++//do+work
}|295814|而不是|295815|while(x<5){
++++//do+work
++++x%2B%2B
}|295816|可能会使一些人感到困惑，并导致off-by-one错误。|295817|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|W|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

They'll usually compile to the same end result. I prefer for's or for-each most of the time. Writing 

<pre><code>for (;x&lt;5;x++){ 
 //do work 
} 
</code></pre>

isn't so sinister, but writing

<pre><code>while(x&lt;5){
 x++
 //do work
}
</code></pre>

instead of 

<pre><code>while(x&lt;5){
 //do work
 x++
}
</code></pre>

could confuse some people and cause off-by-one errors.

blocks|key|295846|text|在编程的早期，流行的数据结构是线性数组(又称向量)，重复的模式是遍历和使用数组的每个元素。这种情况非常常见，以至于语言为这种模式包含了一种特定的语法:+for循环。除了这个历史遗产之外，你可以使用while循环(好吧，现在对于像F#这样的函数式语言，你更愿意使用List.map或List.fold+;-)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|295847|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

In the early times of programming a prevalent data structure was the linear array (aka vector) and a repeating pattern was to traverse and use each element of the array. So usual was this scenario that the languages included a specific syntax for this pattern: the for loop. Aside from this historical heritage you could use the while loop all right (well nowadays with functional languages like F# you'd rather use List.map or List.fold ;-)

blocks|key|3232920|text|这主要是可读性的问题。通常，当您具有要迭代的已定义范围的值时，请使用for循环。当你不进行迭代，或者不知道退出条件何时为真时，使用while循环。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3232921|从java的角度来看，我发现for循环对于集合来说非常方便：|3232922|for+(Object+o+:+objects){
++++o.process();
}|code-block|syntax|javascript|3232923|比以下代码更容易阅读：|3232924|int+i=0;
while(i+<+objects.size()){
++++objects.get(i).process();
++++i%2B%2B;
}|3232925|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

It's mostly an issue of readability. Generally, use for loops when you have a defined range of values to iterate over. Use while loops when you aren't iterating, or don't know when your exit condition will be true.

From a java perspective, I find for loops very handy for collections:

<pre><code>for (Object o : objects){
 o.process();
}
</code></pre>

is a lot easier to read than:

<pre><code>int i=0;
while(i &lt; objects.size()){
 objects.get(i).process();
 i++;
}
</code></pre>

blocks|key|3018881|text|在像Pascal这样的语言中，for和while结构有不同的应用。您可以用Pascal编写一个for循环，如下所示：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3018882|for+i+:=+1+to+5+do
begin
{+some+code+here+}
end|code-block|syntax|javascript|3018883|因此，您显式声明i递增1。这里没有显式指定的终止条件。因此，您只能在知道循环将在实际循环执行开始之前运行一定的预定次数的地方使用for循环。另一方面，您可以在while循环的情况下指定显式终止条件。|3018884|i:=0;
while+(i<>5)+do
begin
{+some+code+here+}
i:=i%2B1;
end|3018885|因此，while循环要灵活得多。后来开发C时，虽然支持for和while，但for结构的含义发生了变化，您可以使用布尔运算符添加显式终止条件。因此，在C和类C语言中，while和for的功能是相同的，因此它更多地成为一个可读性问题，而不是可用性问题。|3018886|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

In a language like Pascal, for and while constructs had different applications. You would write a for loop in Pascal as follows:

<pre><code>for i := 1 to 5 do
begin
{ some code here }
end
</code></pre>

So you explicitly state that i is incremented by 1. There is no termination condition explicitly specified over here. Thus you could use a for loop only in places where you know the loop will run for certain pre-determined number of times before the actual loop execution starts. On the other hand, you can specify an explicit termination condition in the case of a while loop.

<pre><code>i:=0;
while (i&lt;&gt;5) do
begin
{ some code here }
i:=i+1;
end
</code></pre>

Thus a while loop is much more flexible. Later on when C was developed, although for and while were supported, the meaning of the for construct changed and you could add in explicit termination conditions using boolean operators. Thus, the power of while and for in C and C-like languages is same and thus it becomes more of a readability issue than a usability issue.

blocks|key|3233259|text|浏览一下其他(非常好的)答案，有一点我看不出来。(如果它真的成功了，我错过了，并道歉。)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3233260|我将给你两个看起来语义相同的代码片段。|3233261|代码片段#1：|3233262|for+(int+a+=+0;+a+<+arr.length;+a%2B%2B)+{
++/*+do+some+work+here+*/
}|code-block|syntax|javascript|3233263|代码片段#2：|3233264|int+b+=+0;
while+(b+<+arr.length)+{
++//+do+work
++b%2B%2B;
}|3233265|他们看起来做的是一样的事，对吧？现在，让我们为每个代码片段添加一行代码，让我们看看会发生什么：|3233266|代码片段#3：|3233267|for+(int+c+=+0;+c+<+arr.length;+c%2B%2B)+{
++/*+do+some+work+here+*/
}
printf("%25d\n",+c);|3233268|代码片段#4：|3233269|int+d+=+0;
while+(d+<+arr.length)+{
++//+do+work
++d%2B%2B;
}
printf("%25d\n",+d);|3233270|因此，当我编译一个嵌入了这四个片段的垃圾文件时(加上一些胶水使arr.length有意义)，我得到了以下错误：|3233271|$+clang+junk.c
junk.c:20:17:+error:+use+of+undeclared+identifier+'c'
++++++++printf("%25d\n",+c);
+++++++++++++++++++++++%5E
1+diagnostic+generated.|3233272|事实证明，使用for循环可以为虚拟计数器变量提供更多的局部性，等等。这为您在重用变量名方面提供了更大的回旋余地，而不会发生冲突(尽管代价是增加了潜在的阴影)。|offset|length|style|CODE|3233273|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0|7|3|0^^$0|@$1|2|3|4|5|6|7|1A|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1B|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|1C|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|1D|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|1E|8|@]|9|@]|A|$]]|$1|M|3|N|5|H|7|1F|8|@]|9|@]|A|$I|J]]|$1|O|3|P|5|6|7|1G|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1H|8|@]|9|@]|A|$]]|$1|S|3|T|5|H|7|1I|8|@]|9|@]|A|$I|J]]|$1|U|3|V|5|6|7|1J|8|@]|9|@]|A|$]]|$1|W|3|X|5|H|7|1K|8|@]|9|@]|A|$I|J]]|$1|Y|3|Z|5|6|7|1L|8|@]|9|@]|A|$]]|$1|10|3|11|5|H|7|1M|8|@]|9|@]|A|$I|J]]|$1|12|3|13|5|6|7|1N|8|@$14|1O|15|1P|16|17]]|9|@]|A|$]]|$1|18|3|-4|5|6|7|1Q|8|@]|9|@]|A|$]]]|19|$]]

Glancing over the other (very good) answers, there's a point I didn't see getting made. (If it did get made I missed it and apologize.)

I'm going to give you two snippets of seemingly semantically identical code.

Snippet #1:

<pre><code>for (int a = 0; a &lt; arr.length; a++) {
 /* do some work here */
}
</code></pre>

Snippet #2:

<pre><code>int b = 0;
while (b &lt; arr.length) {
 // do work
 b++;
}
</code></pre>

They look like they do the same thing, right? Now let me add one single line to each snippet and let's see what happens:

Snippet #3:

<pre><code>for (int c = 0; c &lt; arr.length; c++) {
 /* do some work here */
}
printf("%d\n", c);
</code></pre>

Snippet #4:

<pre><code>int d = 0;
while (d &lt; arr.length) {
 // do work
 d++;
}
printf("%d\n", d);
</code></pre>

So when I compile a junk file with those four snippets embedded (plus some glue to have arr.length mean something) I get the following error:

<pre><code>$ clang junk.c
junk.c:20:17: error: use of undeclared identifier 'c'
 printf("%d\n", c);
 ^
1 diagnostic generated.
</code></pre>

Using the <code>for</code> loop, it turns out, allows you to provide more locality to your dummy counter variables, etc. This gives you greater leeway in reusing variable names without chance of collision (albeit at the expense of increasing potential shadowing).

blocks|key|295853|text|通常，while循环和for循环之间的区别与语法有关，与性能无关。也就是说，看起来这个问题已经在Java中得到了解决：Java+for+loop+vs.+while+loop.+Performance+difference?|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|295854|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/1165457/java-for-loop-vs-while-loop-performance-difference^0|1N|1H|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

Generally, the difference between a while loop and for loop is syntax and not performance related. That said, it looks like this question was already addressed for Java: <a href="https://stackoverflow.com/questions/1165457/java-for-loop-vs-while-loop-performance-difference">Java for loop vs. while loop. Performance difference?</a>

blocks|key|297852|text|可读性。从老的VB6天的到，每当我看到我想哭的时候。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|297853|在某些情况下，循环是很好用的。在返回true/false的对象上调用一个函数，但在该对象内部迭代值。|297854|C#中的DataReader示例：|297855|List<string>+strings+=+new+List<string>();
while(DataReader.Read())
{
++strings.Add(DataReader["foo"].ToString());
}|code-block|syntax|javascript|297856|for循环允许您将工作封装在一个函数中，从而提供更好的内存管理。此外，如果您的while循环中存在错误，它可能会陷入一个失控的循环，威胁到所有的生命：|297857|bool+keepGoing+=+true;
while(keepgoing)
{
+++try
+++{
+++++//something+here+that+causes+exception,+fails+to+set+keepGoing+=+false;
+++++keepGoing+=+false;
+++}
+++catch(Exception)
+++{
++++//Do+something,+but+forget+to+set+keepGoing.
++++//maybe+there+is+always+an+exception...
+++}

}|297858|我也认为这只是一种常规做法。就像在建筑中一样。你用钉子把屋顶单位钉在立柱上。你“可以”使用螺丝，他们会做同样的工作，但这不是常见的做法。|297859|没有人说这是错误的，我们只是说“请在同龄人的压力下放弃，以保持编码世界的正常运行”。|297860|entityMap^0|C|1|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|11|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|12|8|@]|D|@]|E|$]]|$1|J|3|K|5|L|7|13|8|@]|D|@]|E|$M|N]]|$1|O|3|P|5|6|7|14|8|@]|D|@]|E|$]]|$1|Q|3|R|5|L|7|15|8|@]|D|@]|E|$M|N]]|$1|S|3|T|5|6|7|16|8|@]|D|@]|E|$]]|$1|U|3|V|5|6|7|17|8|@]|D|@]|E|$]]|$1|W|3|-4|5|6|7|18|8|@]|D|@]|E|$]]]|X|$]]

Readability. And from the old VB 6 days of wend whenever I see a while I want to cry.

There are some cases while loops are good to use. Calling a function on an object that returns true/false but iterates a value inside that object.

Example being a DataReader in C#:

<pre><code>List&lt;string&gt; strings = new List&lt;string&gt;();
while(DataReader.Read())
{
 strings.Add(DataReader["foo"].ToString());
}
</code></pre>

A for loop allows you to encapsulate your work within a function, which gives better memory management. Also, if there is an error in your while loop, it could spiral into an out of control loop that threatens all life:

<pre><code>bool keepGoing = true;
while(keepgoing)
{
 try
 {
 //something here that causes exception, fails to set keepGoing = false;
 keepGoing = false;
 }
 catch(Exception)
 {
 //Do something, but forget to set keepGoing.
 //maybe there is always an exception...
 }

}
</code></pre>

I also think it's just general practice. Much like in construction. You use nails for putting roofing flats onto the studs. You "could" use screws, they would do the same job, but it's just not common practice.

No one is saying it's wrong, we're just saying "please fold under the pressure of your peers to keep the coding world functioning".

blocks|key|295200|text|只需选择一个，然后在整个项目中复制、粘贴/调整它。更少的决策，更少的打字，更快的编码。性能差异可以忽略不计。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|295201|我也不赞成贾斯汀把i放在循环的范围内，我也在循环之外使用了var+aL+=+array.length。然后在for循环构造函数中使用i和aL，这样就不会在每次命中时重新计算数组的长度(以及一次又一次的var创建；)。又是否定的。性能真的很好(见我答案的第一部分)，除非你有非常大的数组。如果你碰巧知道前面的数组长度，首先用它的固定长度初始化它(在糟糕的浏览器上对内存分配略有帮助;)，如果这是客户端，并且你有很多数据)。|offset|length|style|CODE|295202|js示例|295203|<script>
var+i=0;
var+myArray+=+["D","R","Y"];//literal+style+will+do+for+now;)
var+aL=myArray.length;+//or+use+3+if+known+upfront
for(i;i<aL;i%2B%2B){/*always+do+DRY+things+here*/}
</script>|code-block|syntax|javascript|295204|还要确保在满足某个条件时，问问自己“我还需要完成整个循环吗？”如果没有，别忘了尽可能早地跳出这个循环。|295205|entityMap^0|0|9|1|T|L|1I|3|1U|1|1W|2|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@$D|U|E|V|F|G]|$D|W|E|X|F|G]|$D|Y|E|Z|F|G]|$D|10|E|11|F|G]|$D|12|E|13|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|14|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|15|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|16|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|17|8|@]|9|@]|A|$]]]|R|$]]

Just decide on one and then copy and paste / adjust it throughout your projects. Less decisions, less typing, faster coding. Negligible performance difference.

Also I am not with Justin keeping <code>i</code> in the scope of the loop, AND I use 
<code>var aL = array.length</code> outside the loop too. Then use <code>i</code> and <code>aL</code> within the <code>for</code> loop constructor so you are not recalculating the length of the array on each hit (along with a var creation over and over ;)). Again neg. performance really (see first bit of my answer), unless you have very big arrays flying around. If you happen to know the array length upfront initiate it with its fixed length first (slight help with memory allocation on crappy browsers ;) if this is client side and you have a lot of data).

<h3>js example</h3>

<pre><code>&lt;script&gt;
var i=0;
var myArray = ["D","R","Y"];//literal style will do for now;)
var aL=myArray.length; //or use 3 if known upfront
for(i;i&lt;aL;i++){/*always do DRY things here*/}
&lt;/script&gt;
</code></pre>

also ensure when a condition is met, ask yourself "do I still need to complete the whole loop?" If not don't forget to break out of the loop as early as you can.

blocks|key|297902|text|for和while循环之间存在语义差异。对于for循环，迭代次数是预先定义的，而对于while循环，则不是必需的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|297903|一些语言(例如Ada)通过使for循环计数器成为循环体中的常量来强制执行此操作。因此，这样说是非法的，例如：|297904|for+i+in+values'range+loop
+++...
+++i+:=+i+%2B+1;+++--+this+is+illegal,+as+i+is+a+constant+within+the+loop+body
end+if;|code-block|syntax|javascript|297905|然而，这种语义差异对于大多数语言来说并不是那么明显，因为它们不会将for循环计数器视为常量。|297906|entityMap^0|0|3|4|5|M|3|16|5|0|E|3|0|0|X|3|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]|$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Z|8|@$9|10|A|11|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|12|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|13|8|@$9|14|A|15|B|C]]|D|@]|E|$]]|$1|O|3|-4|5|6|7|16|8|@]|D|@]|E|$]]]|P|$]]

There is a semantic difference between <code>for</code> and <code>while</code> loops. With <code>for</code> loops, the number of iterations is pre-defined, whereas with <code>while</code> loops it is not necessary.

Some languages (such as Ada) enforce this, by making the <code>for</code> loop counter a constant within the loop body. Hence it would be illegal to say, for example:

<pre><code>for i in values'range loop
 ...
 i := i + 1; -- this is illegal, as i is a constant within the loop body
end if;
</code></pre>

This semantic difference, however, is not so clear with most languages, which do not treat the <code>for</code> loop counter as a constant.

blocks|key|298015|text|相关琐事：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|298016|在谷歌的新Go+language中，他们决定不包括while语句。相反，它们允许您编写只包含condition子句的+statement。因此，相当于|offset|length|298017|while+(a+<+b)+{+...+}|code-block|syntax|javascript|298018|是很简单的|298019|for+a+<+b+{+...+}|298020|entityMap|0|LINK|mutability|MUTABLE|url|http://golang.org/|1|http://golang.org/doc/go_spec.html#For_statements^0|0|5|B|0|1M|A|1|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Z|8|@]|9|@$D|10|E|11|1|12]|$D|13|E|14|1|15]]|A|$]]|$1|F|3|G|5|H|7|16|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|17|8|@]|9|@]|A|$]]|$1|M|3|N|5|H|7|18|8|@]|9|@]|A|$I|J]]|$1|O|3|-4|5|6|7|19|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]|W|$5|R|S|T|A|$U|X]]]]

Related trivia:

In Google's new <a href="http://golang.org/" rel="nofollow">Go language</a>, they have decided not to include the while statement. Instead they allow you to write a <a href="http://golang.org/doc/go_spec.html#For_statements" rel="nofollow">for statement</a> that only has the condition clause. So the equivalent of 

<pre><code>while (a &lt; b) { ... }
</code></pre>

is simply

<pre><code>for a &lt; b { ... }
</code></pre>

blocks|key|3233391|text|简单地说：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3233392|“for”循环往往用于迭代使用。您需要迭代数组，出于各种原因，您需要数字1到100+(或其他范围)。|3233393|“while”循环往往是条件循环。你想继续做一些事情，直到一个条件是假的。假设您有一个名为“toast”的类，并且您想要烹调吐司直到它被烤好，您将拥有类似于以下内容：|3233394|while+(!toast.isToasted)+cook(toast);|offset|length|style|CODE|3233395|你可以总是(我想不出一个例子你不能)把for循环写成while循环，而while循环写成for循环，但是选择哪一个最好，通常归结到我上面的几点。|3233396|entityMap^0|0|0|0|0|11|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|S|8|@$H|T|I|U|J|K]]|9|@]|A|$]]|$1|L|3|M|5|6|7|V|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|O|$]]

Simply put:

A 'for' loop tends to be used for iterational use. You need to iterate through an array, you need the numbers 1 through 100 (or other ranges) for various reasons.

A 'while' loop tends to be a conditional loop. You want to keep doing something until a contition is false. Assuming you have a class called 'Toast' and you wanted to cook the toast until it is toasted, you would have something like the following:

<code>while (!toast.isToasted) cook(toast);</code>

You can most always (I can't think of an example where you can't) write a for loop as a while loop and a while loop as a for loop, but picking the one which best first the situation usually comes down to my above points.

blocks|key|296072|text|可读性是一个非常重要的点，但它是双向的。我会将for循环转换为while循环-即使我使用的是计数器变量，或者使用for是“自然”的-当它更具可读性时也是如此。当你在for的三个部分或多个计数器中的任何一个中有一个长的或复杂的表达式时，这是很常见的(这与复杂有关)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|296073|在几种语言中，Knuth's+loop-and-a-half作为带break的无限循环也比for循环工作得更好。|offset|length|296074|然而，有一个非常重要的语义差异：|296075|for+(int+i+=+0;+i+<+arr.length;+i%2B%2B)+{
++if+(filter(arr[i]))+continue;
++use(arr[i]);
}

int+i+=+0;
while+(i+<+arr.length)+{
++if+(filter(arr[i]))+continue;
++use(arr[i]);
++i%2B%2B;
}|code-block|syntax|javascript|296076|entityMap|0|LINK|mutability|MUTABLE|url|http://www.google.com/search?q=%2522loop%2Band%2Ba%2Bhalf%2522%2Bknuth^0|0|7|N|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@]|9|@$D|W|E|X|1|Y]]|A|$]]|$1|F|3|G|5|6|7|Z|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|10|8|@]|9|@]|A|$K|L]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|T]]]]

Readability is a very important point, but it works both ways. I'll convert a for-loop to a while-loop—even when I'm using a counter variable or it would otherwise be "natural" to use for—when it's more readable that way. This is common when you have a long or complex expression in any of for's three parts or multiple counters (which is related to being complex).

<a href="http://www.google.com/search?q=%22loop+and+a+half%22+knuth" rel="nofollow">Knuth's loop-and-a-half</a> also works better, in several languages, as an infinite loop with a break, rather than a for-loop.

However, there is a very important semantic difference:

<pre><code>for (int i = 0; i &lt; arr.length; i++) {
 if (filter(arr[i])) continue;
 use(arr[i]);
}

int i = 0;
while (i &lt; arr.length) {
 if (filter(arr[i])) continue;
 use(arr[i]);
 i++;
}
</code></pre>

blocks|key|292513|text|在适当的时候使用for-loop。while解决方案有语法上的缺陷(它更长)，并且您必须在循环内的任何continue调用之前检查i是否已递增。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|292514|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Use for-loop when it's appropriate. The while solution has syntactic drawbacks (it's longer) and you have to check that you increment i before any continue call within the loop.

blocks|key|297717|text|首选项。对我来说，所有循环逻辑都内置于For语句中，因此您不必声明计数器变量或在实际循环中执行递增/递减操作。此外，您还可以在for语句的本地声明计数器/索引。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|297718|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Preference. For me all the looping logic is built into the for statement so you do not have to declare the counter variable or do the increment/decrement stuff in the actual loop. Also, the you can declare the counter/index local to the for statement.

blocks|key|3018797|text|For循环通常更容易并行化。由于程序可以预先知道将执行的迭代次数和迭代器在任何点的值，因此使用诸如OpenMP之类的API进行并行化是微不足道的。当然，如果您进入中断，继续，并手动更改迭代器，这一优势就消失了。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3018798|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

For loops are often easier to parallelize. Since the program can tell in advance the number of iterations that will be performed and the value of the iterator at any point, parallelization using an API such as OpenMP is trivial. Of course if you get into breaks, continues, and changing the iterator manually this advantage disappears.

blocks|key|3233290|text|因为后者可以是一行:+while+(%2B%2Bi+<+arr.length)+{+//+do+work+}|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3233291|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

because latter can be one liner: while (++i &lt; arr.length) { // do work }

blocks|key|3233300|text|原因之一是while的条件可以是字符串。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3233301|此外，如果我们将'+do‘添加到mix中，当我们希望操作至少运行一次而不考虑其当前状态时，可以使用do+while循环。|3233302|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

One reason is that a while's condition can be a string.

Also, if we add 'Do' to the mix, we can use a do while loop when we want the operation to run at least once regardless of its current state.

blocks|key|296048|text|这只是我的逻辑，当我们知道迭代的确切计数时，我们通常使用for循环，当我们通常想要检查condition.Then时，我们使用while循环，我们根据您的需求使用它们。否则，它们都表现出相同的行为。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|296049|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Its just my logic that we generally use for loop when we know the exact count of our itterations and we use a while loop when we generally want to check a condition.Then we use them according to ur requirments. Otherwise they both show same behaviour.

blocks|key|3233433|text|while循环，定义为|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3233434|while(condition)|code-block|syntax|javascript|3233435|表示此编程模式：|3233436|1:
if(!condition)+goto+2;
...
goto+1;
2:|3233437|而for循环定义为|3233438|for(var+i+=+seed;+condition;+operation)|3233439|表示此模式：|3233440|var+i+=+seed
1:
if(!condition)+goto+2;
...
operation;
goto+1;
2:|3233441|这两种模式都是如此常用，以至于它们都被命名并内置于语言中。|3233442|如果您需要定义一个计数器来控制您的循环，请使用for循环。如果不是，请使用while循环。|3233443|entityMap^0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|10|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|12|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|14|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|15|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|16|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|17|8|@]|9|@]|A|$]]|$1|W|3|-4|5|6|7|18|8|@]|9|@]|A|$]]]|X|$]]

A while loop, defined as

<pre><code>while(condition)
</code></pre>

represents this programming pattern:

<pre><code>1:
if(!condition) goto 2;
...
goto 1;
2:
</code></pre>

Whereas a for loop, defined as

<pre><code>for(var i = seed; condition; operation)
</code></pre>

represents this pattern:

<pre><code>var i = seed
1:
if(!condition) goto 2;
...
operation;
goto 1;
2:
</code></pre>

Both patterns are so commonly used that they have been named and built into languages.

If you need to define a counter to control your loop, use a for loop. If not, use a while loop.

<blockquote>
 Possible Duplicates: 
 <a href="https://stackoverflow.com/questions/99164/iterate-with-for-loop-or-while-loop">Iterate with for loop or while loop?</a> 
 <a href="https://stackoverflow.com/questions/2242646/loops-in-c-for-or-while-which-is-best">Loops in C - for() or while() - which is BEST?</a> 
</blockquote>



When should one use a <code>for</code> loop instead of a <code>while</code> loop? 

I think the following loops are identical, except for their syntax. If so, then why choose one over the other?

<pre><code>int i;
for (i = 0; i &lt; arr.length; i++) {
 // do work
}

int i = 0;
while (i &lt; arr.length) {
 // do work
 i++;
}
</code></pre>

Why use a for loop instead of a while loop?

数据结构

内存管理

Java

可能的重复项：什么时候应该使用for循环而不是while循环？我认为以下循环是相同的，除了它们的语法。如果是这样，那么为什么选择一个而不是另一个呢？int i;for (i = 0; i < arr.length; i++) { // do work}int i = 0;while (i < arr.length) { // do work i++;}

问为什么使用for循环而不是while循环？
EN

回答 28

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么使用for循环而不是while循环？EN

回答 28

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么使用for循环而不是while循环？
EN