While loops and termination.

A while loop repeats a block of code. It has a condition, written in parentheses after while, and a body: the block between the braces. Before each pass through the body, the program tests the condition. When the condition is true, the body runs once, and the program goes back to the test. When the condition is false, the loop ends, and the program continues with the line after the loop.

Each run of the body is called an iteration. Because the test comes first, a loop whose condition is false at the start runs its body zero times.

A while loop tests its condition before each pass; when the condition is false, even at the start, the program continues after the loop.

The condition is tested again before each pass, with the values the variables hold at that moment. The loop stops only when the condition becomes false. So the body must change something the condition reads, and change it toward false. In while (floor > 1), the condition reads floor, so every pass must lower floor.

When no pass changes what the condition reads, the condition stays true forever. This is an infinite loop: the program never reaches the line after it. Nothing reports an error; the program simply keeps running. In the stepper, a run that never ends stops after 240 recorded stops, with the message Stopped after 240 recorded stops.

A common way to get there is to change the wrong variable. Below, the body computes the next floor in below, but the condition reads floor. Without the line floor = below, below is 3 on every pass, and floor stays 4 forever.

Each pass must change something the loop condition reads, and move it toward false; otherwise the loop never stops.

When a while loop ends, its condition has just been tested and found false. So after the loop, the variable holds the first value that failed the test, not the last value the body used. Below, while (floor <= 6) counts floor up from 2, and after the loop floor is 7, a floor the lift never visited.

The stopping test also decides how many passes run. The lift should stop at floors 2, 3, 4, 5, and 6: five stops. With floor < 6, it stops four times, because the pass for floor 6 never runs. A loop that runs one pass too few or one too many has an off-by-one error. To check a stopping test, try two values: the last one that should run (6 must pass the test) and the first one that should not (7 must fail it).

Counting down works the same way, with the test turned around: a loop that lowers floor stops with > or >=. If you write < by mistake, as in while (floor < 1) with floor starting at 6, the test is false at once, and the body runs zero times.

After a while loop, the variable holds the first value that failed the condition. Check a stopping test with the last value that should run and the first that should not.

A while loop tests before the first pass. Sometimes there is nothing to test until the body has run once. A do-while loop runs its body first and tests its condition after each pass: do { … } while (condition);. So its body always runs at least once, even when the condition is false from the start.

In the lift below, people board at each floor, 200 kg at a time, until the load reaches 500 kg. The loop goes on while load < 500, so it ends at the first load of 500 or more.

Choose do-while only when one pass is always right. When zero passes can be right, such as boarding when nobody is waiting, use while.

A do-while loop runs its body before the first test, so the body always runs at least once.

A loop that walks through a list must stop at the end of the list, even when it has not found what it looks for. An array is a list of values in order, written [0, 0, 3, 0]. waiting[i] is the value at position i, counting from 0, and waiting.length is the number of values. Arrays, lists, and vectors covers lists in detail.

The loop below looks for the first floor where someone is waiting: waiting[i] is the number of people waiting on floor i. Its condition has two tests joined with &&: i < waiting.length && waiting[i] === 0. The first test is a guard, as in Short-circuit evaluation. When i reaches the end of the list, the guard is false, and && never computes waiting[i], which does not exist there. With the two tests swapped, the last test reads waiting[4]. In JavaScript that gives undefined, so the loop happens to stop, but it has read a value that does not exist.

After the loop, check which test ended it. When i is still less than the length, the loop stopped at a floor where someone is waiting. Otherwise i equals the length: nobody is waiting, and there is no value at position i to read.

Put the end-of-list test first in the loop condition, and after the loop, check which test ended it before reading at the position.

A loop that counts in decimal steps can miss its stopping value. As Floating-point numbers showed, adding 0.1 ten times gives 0.9999999999999999, not 1. The lift door below opens in steps of 0.1, from 0 (closed) to 1 (fully open).

With while (door < 1), the test after ten steps is 0.9999999999999999 < 1, which is true, so an eleventh step runs, and door ends at 1.0999999999999999. With while (door !== 1), it is worse: door goes past 1 without ever being equal to it, the condition never becomes false, and the loop never ends.

Count whole steps instead, and compute the decimal value from the count. tenths below goes 1, 2, 3, up to exactly 10, because whole numbers add without rounding. Then door is tenths / 10, which gives 1 at the end.

Do not end a loop by testing a floating-point value with === or !==. Count whole steps, and compute the decimal value from the count.

List the values the condition sees, one per pass, then the value that ends the loop. The next lesson, Function calls, shows how a program runs code that is written somewhere else.