Introduction to Loops in R
Loops let R repeat a block of code once for every element in a sequence, every iteration of a counter, or until a condition changes, and R provides three loop constructs — for, while, and repeat — each suited to a different repetition pattern. Because R is an interpreted, vector-oriented language, explicit loops carry more per-iteration overhead than in compiled languages, which is why loops are often reserved for tasks that aren't naturally vectorizable, such as iterative simulations or file processing.
Cricket analogy: A fielding coach running catching drills has a player field 50 balls in a row, one throw per repetition, exactly like a for loop iterating through a fixed sequence of trials.
The for Loop
A for loop iterates over each element of a vector or list, most commonly written as for (i in seq_along(x)) so that i takes each valid index of x in turn, which is safer than for (i in 1:length(x)) because seq_along() correctly returns an empty sequence when x has zero elements. The loop variable is assigned invisibly and the loop itself returns NULL, so any results you want to keep must be stored into a pre-existing vector or list inside the loop body.
Cricket analogy: Scoring the ball-by-ball commentary of an over, a scorer processes deliveries 1 through 6 in strict order, updating the scoreboard after each ball — exactly how for (i in seq_along(deliveries)) processes each ball in turn.
sales_by_region <- list(north = c(120, 95, 130), south = c(80, 70), west = c(200, 150, 175, 90))
totals <- numeric(length(sales_by_region))
for (i in seq_along(sales_by_region)) {
totals[i] <- sum(sales_by_region[[i]])
}
names(totals) <- names(sales_by_region)
totals
# north south west
# 345 150 615while and repeat Loops
A while loop repeats its body only as long as a condition remains TRUE, checked before each iteration, which makes it appropriate when the number of repetitions isn't known in advance — for instance, iterating until a numerical algorithm converges. A repeat loop runs unconditionally and relies entirely on an internal break statement to exit, while next skips the remainder of the current iteration and jumps straight to the next one, both of which work identically inside for, while, and repeat.
Cricket analogy: A batsman keeps facing deliveries in a while-loop sense — while not out and overs remain, continue batting — and a wide ball is like next, skipping straight to the next legal delivery without ending the innings.
i <- 1
repeat {
if (i %% 2 == 0) {
i <- i + 1
next
}
print(i)
i <- i + 1
if (i > 10) break
}
j <- 1
while (j <= 5) {
print(j^2)
j <- j + 1
}Why R Loops Are Often Discouraged
R loops are frequently discouraged not because they're incorrect, but because growing a vector inside a loop with c() or by assigning past its current length forces R to reallocate and copy the entire vector on every iteration, turning what looks like linear work into quadratic time as the loop count increases. The idiomatic fix is to preallocate the result container at its final size before the loop starts — with something like numeric(n) or vector('list', n) — and then assign into indexed positions, which keeps memory allocation constant across iterations.
Cricket analogy: Building an innings scorecard by re-copying the entire card after every single run scored, rather than writing into a pre-printed scoresheet with all 50 overs already ruled out, wastes enormous effort as the innings goes on — just like growing a vector with c() each iteration.
When you don't know the final result size in advance, growing a list with result[[length(result) + 1]] <- x is still costly at scale; consider collecting results in a list built with lapply() instead, which R optimizes internally, or preallocate a generous upper bound and trim afterward.
Repeatedly using c(result, new_value) or result <- append(result, new_value) inside a for loop is one of the most common R performance mistakes — each call copies the whole existing vector, so a loop of 100,000 iterations can take minutes instead of milliseconds; always preallocate with vector('numeric', n) or numeric(n) and assign by index instead.
- for loops iterate over seq_along(x) so they safely handle zero-length inputs, unlike 1:length(x).
- while loops check their condition before each iteration; repeat loops run unconditionally and need an internal break.
- next skips to the following iteration; break exits the loop entirely, and both work in for, while, and repeat.
- Growing a vector with c() inside a loop reallocates memory every iteration, causing quadratic slowdown.
- Preallocating a result vector or list at its final size before the loop keeps performance close to linear.
- R loops carry more per-iteration overhead than compiled languages, so vectorized alternatives are often preferred for large data.
- A for loop itself returns NULL; results must be explicitly stored inside the loop body.
Practice what you learned
1. Why is for (i in seq_along(x)) generally preferred over for (i in 1:length(x))?
2. What is the main performance problem with writing result <- c(result, new_value) inside a for loop?
3. What is the key difference between while and repeat in R?
4. What does the next statement do inside a loop?
5. What is the recommended fix for slow vector-growing loops in R?
Was this page helpful?
You May Also Like
Conditionals in R
How R evaluates TRUE/FALSE logic to branch code with if/else, the vectorized ifelse(), and the multi-case switch() function.
Vectorized Operations in R
How R applies operations across entire vectors at once, including the recycling rule, logical indexing, and why vectorized code outperforms loops.
The apply Family of Functions
How R's apply family — lapply, sapply, apply, vapply, and mapply — replaces explicit loops with predictable, functional-style iteration.
Related Reading
Related Study Notes in Programming
Browse all study notesApache Spark Study Notes
Programming · 30 topics
ProgrammingApache Flink Study Notes
Programming · 30 topics
ProgrammingHadoop Study Notes
Programming · 30 topics
ProgrammingSnowflake Study Notes
Programming · 30 topics
ProgrammingApache Airflow Study Notes
Programming · 30 topics
Programmingdbt (Data Build Tool) Study Notes
Programming · 30 topics