How can I avoid an infinite loop with a `while` condition?

Check two things: what makes the condition false, and whether the loop body changes something that can make that happen. JavaScript evaluates the condition before each pass. If it is true, the body runs; if false, execution continues after the loop. [S1]

For a counter loop, the counter needs a starting value, a limit in the condition, and an update inside the body. Here is a bounded example:

let count = 0;

while (count < 5) {
  console.log(count);
  count += 1;
}

The stopping condition is count < 5 becoming false. This example prints 0 through 4. After the fifth pass, count is 5, so the next condition check fails and the loop ends.

Sure. The loop checks count < 5 before each pass. Initially, count is 0, so the comparison is true. The body runs and adds 1. The next check uses the new value, and the same pattern continues.

The values at the start of the passes are 0, 1, 2, 3, and 4. Each pass moves the counter closer to 5. After the pass that starts with 4, the update makes count equal to 5. The next check is 5 < 5, which is false, so there is no sixth pass. A bounded counter loop like this terminates because its update lets the counter reach the point where its condition is false. [S1]

If you remove count += 1, the value stays at 0. Since 0 < 5 remains true, the loop keeps taking passes without getting nearer to its stopping point. The same risk applies if an update moves the counter the wrong way, such as subtracting 1 while the condition is count < 5.

When debugging, trace the values used by the condition at the start of a few passes. Ask whether the body changes those values and whether the changes move toward making the condition false. A condition that depends on a value the body never changes may stay true indefinitely. [S1]

Write the loop in this order: initialize, test, do the work, update. Then state the stopping point in a sentence. For the example, that sentence is: “Stop when count reaches 5.” Check that the initial value does not already make the condition false, unless zero passes are intended, and that the update actually moves toward the stopping point.

You can also make a tiny trace on paper: record the counter value at the start of each pass, apply the update, and check the condition again. If the values repeat or head away from the limit, revise the condition or update. This check helps with counter loops; it does not establish that every possible while loop will terminate. The key is to inspect the particular state and condition your code uses.