4 Loops and Repetition

The structure of reliable repetition

A loop repeats a block of statements to process data, display patterns, validate input, or calculate a result. Reliable loop design has three connected parts:

• Initialization establishes the starting state.

• Condition determines whether another iteration should occur.

• Progress or update changes the state so the condition can eventually become false.

For example, a counter initialized to $1$ can be tested against $5$, used by the loop body, and then increased after each pass. After the value becomes $6$, the condition $\text{count} \leq 5$ is false and the loop ends.

When reviewing any loop, ask three questions: What is the initial state? What must be true for one more iteration? Which update moves the state toward stopping?

Takeaway: Repetition is safe only when the starting state, stopping test, and progress update work together.

Choosing the right loop

Choose the loop form according to what controls the repetition.

• Use a for loop for a known or countable range. Its traditional sequence is initialization once, condition test, body execution, update, and another condition test.

• Use a while loop when repetition depends on a condition or event and the number of passes is not known in advance. Because the condition is tested first, its body may execute zero times.

• Use a do...while loop when the body must execute before validation. This is useful for menus and input prompts because the condition is checked after the first attempt.

For arrays, use a for...of loop when each value is needed but its index is not. Use an indexed loop when the position is required. In JavaScript, for...in is intended for enumerable property names of objects, whereas for...of iterates values from iterable objects such as arrays.

A useful selection rule is:

1. Identify whether the repeated set is a numeric range, a collection, or an unknown sequence.

2. Decide whether the number of repetitions is known.

3. Decide whether at least one execution is required.

4. Choose the form that expresses those facts most directly.

Takeaway: Match the loop to the source of repetition: countable range, collection values, condition-controlled work, or guaranteed first execution.

Core loop patterns

Many loop algorithms fit a small number of patterns.

Counting events

A counter records a specific event rather than merely counting loop passes. For example, while examining values from $1$ through $20$, a counter can increase only when a value satisfies the evenness test. The loop-control variable changes on every pass, but the counter changes only for matching values.

Counters may also move downward or use a step other than $1$. A countdown from $10$ to $0$ can update by $-2$, provided the condition and update point in the same direction.

Combining values

An accumulator combines information across iterations. A sum normally starts at $0$, and a product normally starts at $1$. The accumulator must be initialized before the loop; declaring or resetting it inside the loop erases the previous result.

For scores $72$, $85$, $91$, and $68$, the sum is $316$, and the average is $316 \div 4 = 79$. The accumulator changes on every iteration.

Searching

A search pattern examines values until a target is found or the data ends. A position initialized to $-1$ can mean “not found.” When the target is found, break avoids unnecessary remaining work.

Filtering

A filtering pattern keeps or processes only values that satisfy a condition. For example, from the temperatures $68$, $91$, $74$, $102$, and $65$, retaining values at most $100$ produces $68$, $91$, $74$, and $65$. continue can skip the rest of an iteration for a value that should not be processed.

Takeaway: Before writing a loop, identify whether it counts events, combines values, searches for a match, or filters data.

Control flow and nested loops

A break statement exits the nearest enclosing loop immediately. A continue statement skips the remaining statements in the current iteration and proceeds to the next one. Neither statement changes the meaning of the loop's condition, so the surrounding control flow still needs to be checked.

These statements are useful but can hide progress problems. In a while loop, if an if branch executes continue before the progress update, the loop may revisit the same state forever. Put the update where every relevant path reaches it, or restructure the condition and body so progress is explicit.

Nested repetition adds another layer of control. In a nested loop, the inner loop completes all of its iterations for each outer-loop iteration. If the outer loop runs about $n$ times and the inner loop also runs about $n$ times, the body may execute about $n^2$ times. A grid with three rows and four columns therefore executes its inner body $3 \times 4 = 12$ times.

For pairwise comparisons, starting the inner index after the outer index allows each unordered pair to be considered once. For values $2$, $4$, and $6$, the pairs are $(2,4)$, $(2,6)$, and $(4,6)$, not both orders of each pair.

Takeaway: Track which loop each control statement affects, and estimate nested work by counting inner executions for every outer execution.

Termination and debugging infinite loops

A loop terminates when its condition becomes false or a control statement exits it. To verify termination, identify a progress variable and explain how its value moves toward the stopping condition.

For example, if a variable begins at $1$ and doubles while it is less than $100$, the values move through $1$, $2$, $4$, and so on until the condition fails. The update makes progress toward the boundary.

Common causes of nontermination include:

• The progress variable is never updated.

• The wrong variable is updated.

• The update moves away from the boundary, such as incrementing when the loop must decrement.

• The condition can never become false.

• The progress variable is reset inside the loop.

• continue skips an update in a while loop.

An intentional never-ending event loop still needs a deliberate exit mechanism or management by the surrounding system. For ordinary loops, state the stopping rule in plain language before implementing it.

Takeaway: Every terminating loop needs a reachable stopping condition and a progress update that moves toward it.

Tracing, boundaries, and a design process

Tracing means recording important variables after each iteration. Consider a total initialized to $0$ and updated by adding $i$ for $i=1$, $2$, $3$, and $4$:

• After the first iteration, the total is $1$.

• After the second, it is $3$.

• After the third, it is $6$.

• After the fourth, it is $10$.

The update then makes $i=5$, so the test $i \leq 4$ fails.

Tracing is especially effective for finding an off-by-one error. A loop beginning at $0$ and continuing while $i < 5$ visits $0$, $1$, $2$, $3$, and $4$. A loop beginning at $1$ and continuing while $i \leq 5$ visits $1$, $2$, $3$, $4$, and $5$. Both execute five times, but the ranges differ. The first form is common for JavaScript array indexes because arrays begin at index $0$.

For a new loop, use this process:

1. Describe one iteration in plain language.

2. Identify the repeated set.

3. Choose the loop form.

4. Name counters, accumulators, indexes, flags, and current values.

5. Initialize state before the loop.

6. Write the stopping boundary precisely.

7. Check progress on every path, including paths with if, continue, or early exits.

8. Test an empty collection, one item, boundary values, and a nonmatching value.

9. Trace a small example by hand.

When finding a maximum, handle an empty array first. For a nonempty array, initialize the current largest value with the first element, inspect the remaining elements, and replace the current value whenever a larger one appears. This avoids using a nonexistent element as the initial result.

Takeaway: Trace state changes and test boundaries before trusting a loop’s output.