For Loops in R: Syntax, seq_along, break, next and When Not to Loop

The Basic for Loop

A for loop in R runs a block of code once for each element of a vector or list. The loop variable takes each value in turn:

fruits <- c("apple", "banana", "cherry")

for (fruit in fruits) {
  print(fruit)
}

Three elements, three passes. There's no counter to set up and no condition to maintain - for (fruit in fruits) reads as "for each fruit in fruits", and that's exactly what it does. The same shape iterates over a list's elements, a sequence of numbers (for (i in 1:10)), or the names of anything via names().

Printing Inside a Loop Needs print() or cat()

At the console, typing x prints its value. Inside a loop body, it doesn't - auto-printing only happens at the top level, and a bare expression inside a loop is evaluated and thrown away:

for (n in 1:3) {
  n                       # evaluated, silently discarded
  cat("n is", n, "\n")    # this is what actually prints
}

So when a loop "does nothing", this is the first thing to check. Use print() for a quick look at any value, or cat() when you're composing a line of output yourself (remember the "\n" - cat() doesn't add one).

Looping Over Indices with seq_along()

Sometimes you need the position as well as the value - to write into another vector at the same index, or to print a numbered list. Loop over indices with seq_along():

prices <- c(9.99, 4.50, 12.00)

for (i in seq_along(prices)) {
  cat("Item", i, "costs", prices[i], "\n")
}

You will see for (i in 1:length(prices)) in older code, and it harbors a genuine bug. When the vector is empty, length() is 0, and 1:0 doesn't mean "no iterations" - the colon counts down:

empty <- numeric(0)

print(1:length(empty))   # 1 0  - two iterations against nothing!
print(seq_along(empty))  # integer(0) - zero iterations, as it should be

A loop over 1:length(empty) runs twice, indexing elements that don't exist (empty[1] is NA, and assignments create phantom entries). seq_along() returns an empty sequence for an empty vector, so the loop body simply never runs. Make seq_along() the habit; its sibling seq_len(n) does the same job when you have a count rather than a vector.

Collecting Results: Preallocate, Don't Grow

The natural first instinct for building up results looks like this:

squares <- c()
for (i in 1:10000) {
  squares <- c(squares, i^2)   # copies the ENTIRE vector every pass
}

It works, but every c(squares, ...) allocates a brand-new vector and copies all the old elements into it. By the end you've copied roughly 50 million numbers to produce 10,000. This growing-vector anti-pattern is the single biggest reason people call R loops slow.

The fix: create the result at full size first, then assign by index:

n <- 5
squares <- numeric(n)          # c(0, 0, 0, 0, 0), allocated once

for (i in seq_len(n)) {
  squares[i] <- i^2
}

print(squares)

For results that aren't numbers, the same idea applies with character(n), logical(n), or vector("list", n) for a list of arbitrary things. Preallocated loops are perfectly fast.

next and break

Two keywords steer a loop from inside its body: next abandons the current pass and jumps to the next element; break exits the loop entirely.

for (n in 1:10) {
  if (n %% 2 != 0) next   # skip odd numbers
  if (n > 8) break        # stop once past 8
  print(n)
}

This prints 2 4 6 8: odd values are skipped by next, and when 10 arrives, break ends the loop before printing. Use next to filter out cases early (it keeps the main body un-indented), and break when a loop has found what it was looking for and has no reason to continue.

Nested Loops

A loop body can contain another loop. The inner loop runs to completion for every single pass of the outer one - the classic demonstration is a multiplication table:

for (i in 1:3) {
  for (j in 1:3) {
    cat(sprintf("%2d ", i * j))
  }
  cat("\n")
}

For each row i, the inner loop walks all columns j, and the row's newline prints after the inner loop finishes. Nested loops are fine at two levels; at three or more, the body is usually asking to become a function, or the whole computation is asking to be an outer() or matrix operation.

Nesting also covers looping through a list of vectors - outer loop over the list, inner loop (or better, a vectorized call) over each element:

results <- list(alice = c(80, 91), bob = c(72, 65, 88))

for (name in names(results)) {
  cat(name, "average:", mean(results[[name]]), "\n")
}

Note there's no inner loop after all - mean() handles the whole inner vector in one call. That observation generalizes, which brings us to the honest part.

When Not to Loop

R is a vectorized language: its basic operations already work on whole vectors at once. A loop that transforms each element one at a time is often a longer way to write a one-liner:

prices <- c(100, 250, 40)

# The loop version
taxed <- numeric(length(prices))
for (i in seq_along(prices)) {
  taxed[i] <- prices[i] * 1.2
}
print(taxed)

# The vectorized version - same result
print(prices * 1.2)

Prefer the vectorized form whenever one exists - it's shorter, harder to get wrong, and faster. For applying a function across every element of a list, the apply family (sapply, lapply, vapply) plays the same role.

But don't cargo-cult this into "loops are bad." A loop is the right tool when iterations depend on previous ones (running state, simulations), when you're doing side effects like writing files, or simply when the loop is the version you and your readers understand at a glance. A clear loop beats a clever one-liner nobody can parse.

What You Take Away

• for (x in v) { ... } runs the body once per element - no counter bookkeeping.
• Inside a loop, print explicitly with print() or cat(); bare expressions are discarded.
• Loop over positions with seq_along(v), never 1:length(v) - the latter runs twice on an empty vector.
• Preallocate results with numeric(n) / vector("list", n) and assign by index; growing with c() copies everything every pass.
• next skips a pass, break exits; prefer vectorized operations when they exist, but don't fear a readable loop.

Next up: loops that run until something happens rather than once per element - while and repeat.