Loop Condition Evaluation

loop condition evaluation

In general, if you would for example change the value of "dim" inside your loop, it would be re-evaluated every time. But since that is not the case in your example, a decent compiler would optimize your code and you wouldn't see any difference in performance.

for loop condition evaluation

getElementsByTagName() returns an object containing a live HTMLCollection. This is updated whenever you update the dom. In your for loop, after every iteration, the length property is evaluated again on the current dom.

Because you are adding divs to the dom, this loop will run forever.

The reason this works with a _temp variable is because you only evaluate the length of the HTMLCollection once.

I think the best solution would be to evaluate the length beforehand, just like your last example.

Is the condition in the for loop evaluated in every loop?

It's better to define the constant like this :

for(var i = 0, end = a + b; i < end; ++i)

---

Optimization way

You can write your loop like this :

for(var i = a + b; i--;)

This is for me the more optimized but i is descending and not ascending

---

More example

A simple example to understand. If you create your loop like this :

for(var i = 0; i < array.length; ++i) { 
   array.push('value'); // infinite loop
}

array.length is evaluated on every iteration and you can create an infinite loop with array.push().

Does a for loop re-evaluate the functions in its body in each iteration?

For Java:

for (int i=0; i<myList.size(); i++){}

The condition is evaluated during each loop iteration; so there is a slight performance gain by moving that call to size() in front of the loop.

But in Java you should prefer the for-each

for (Whatever thingy : list)

notation anyway (where possible).

You can read about in the Java language spec, chapter 14.14.1.

In Python, are conditions in a loop re-evaluated before a new iteration is executed?

The documentation about The for statement is clear about this:

The for statement is used to iterate over the elements of a sequence (such as a string, tuple or list) or other
iterable object:

for_stmt ::= "for" target_list "in" expression_list ":" suite
["else" ":" suite]

The expression list is evaluated once; it should yield an iterable object. An iterator is created for
the result of the expression_list. The suite is then executed once for
each item provided by the iterator, in the order returned by the
iterator.

[emphasis mine]

So, in your case, range(0,len(list)) will only be evaluated once.

while loop condition evaluation

&& is a short circuit (or short hand) operator. It will evaluate first condition and if condition is true then only will evaluate second condition.

So if my condition is conditon1 && condition2, it will evaluate condition2 if and only if condition1 is true.

So in your case, it will evaluate not null condition (curr != null) and if it fails then it wont evaluate the other one and hence no NullPointerException and hence you see while loop exiting gracefully.

Is the condition in a for loop evaluated each iteration?

Yes Count will be evaluated on every single pass. The reason why is that it's possible for the collection to be modified during the execution of a loop. Given the loop structure the variable i should represent a valid index into the collection during an iteration. If the check was not done on every loop then this is not provably true. Example case

for ( int i = 0; i < collection.Count; i++ ) {
  collection.Clear();
}

The one exception to this rule is looping over an array where the constraint is the Length.

for ( int i = 0; i < someArray.Length; i++ ) {
  // Code
}

The CLR JIT will special case this type of loop, in certain circumstances, since the length of an array can't change. In those cases, bounds checking will only occur once.

Reference: http://blogs.msdn.com/brada/archive/2005/04/23/411321.aspx

Condition evaluation in loops?

length will be evaluated every time you go via the loop, however since length is constant time (O(1)) it doesn't make much difference and adding a variable for storing this value will probably have a negligible effect with a small hit on code readability (as well as breaking the code if the string is ever changed).

Java for Loop evaluation

Yes, it will logically evaluate the whole of the middle operand on every iteration of the loop. In cases where the JIT knows better, of course, it can do clever things (even potentially removing the array bounds check within the loop, based on the loop conditions).

Note that for types that the JIT doesn't know about, it may not be able to optimize specifically like this - but may still inline things like fetching the size() of an ArrayList<T>.

Finally, I generally prefer the enhanced for loop for readability:

for (int value : tenBig) {
    ...
}

Of course, that's assuming you don't need the index for other reasons.

---

Related Topics