Loops in Lua
Lua provides four loop constructs: the pre-tested while loop, the post-tested repeat...until loop, the numeric for loop for counting over a range, and the generic for loop for iterating with an iterator function such as pairs or ipairs. Choosing the right one depends on whether the number of iterations is known ahead of time and whether the loop body must run at least once.
Cricket analogy: A bowler's over is a fixed count loop, six deliveries, done, much like Lua's numeric for loop, while a rain delay is a while loop that keeps checking the weather until conditions clear.
The while and repeat...until Loops
while cond do ... end checks its condition before every iteration, so if cond starts out false, the body never runs at all. repeat ... until cond checks its condition after the body executes, guaranteeing at least one pass, and — unlike while — locals declared inside the body remain visible in the until condition itself, since the body and the condition share the same scope.
Cricket analogy: A while loop is like checking if there's daylight left before starting a new over, if not, play stops before it begins, while repeat...until is like bowling the over first and only then checking if bad light has set in.
The Numeric for Loop
The numeric for loop, for i = start, stop, step do ... end, counts from start to stop inclusive, using step as the increment (which defaults to 1 and can be negative to count down). Each pass through the loop binds a brand-new local copy of the control variable rather than reusing one shared variable, which matters when the loop body creates closures that reference it.
Cricket analogy: A numeric for i = 1, 6 do loop mirrors bowling exactly six balls in an over, incrementing the delivery count by 1 each time, and just as each ball is a fresh delivery, Lua creates a fresh local i for every iteration.
Each pass through a Lua for loop creates a brand-new local copy of the control variable. This means closures created inside the loop body (for example, functions stored in a table) each capture their own iteration's value rather than sharing one final value — a common gotcha in languages like older JavaScript that used var.
The Generic for Loop: pairs and ipairs
The generic for loop, for var1, var2 in iterator do ... end, drives an iterator function across a collection. ipairs(t) walks the integer keys 1, 2, 3, ... in strict order and stops at the first nil, making it the right choice for array-like sequences. pairs(t) visits every key in the table, including string keys, but makes no guarantee about the order in which they are visited.
Cricket analogy: ipairs(battingOrder) walks the batting lineup strictly in order, 1, 2, 3, the way overs are bowled sequentially, while pairs(playerStats) visits every player's stats in no guaranteed order, like reading random entries from a scorecard.
-- numeric for loop
for i = 1, 5 do
print("Iteration " .. i)
end
-- generic for loop over a table
local fruits = {"apple", "banana", "cherry"}
for index, value in ipairs(fruits) do
print(index, value)
end
local scores = {alice = 90, bob = 85}
for key, value in pairs(scores) do
print(key, value)
end
-- while and repeat...until
local n = 5
while n > 0 do
print(n)
n = n - 1
end
repeat
print("runs at least once")
until true
-- break, and simulating "continue" with if
for i = 1, 10 do
if i % 2 == 0 then
-- "continue": skip even numbers
else
print(i)
end
if i == 7 then
break
end
endbreak, and the Absence of continue
break immediately exits the nearest enclosing loop, exactly like in C or JavaScript. Lua, however, has no continue keyword to skip straight to the next iteration. The idiomatic workaround is to invert the skip condition and wrap the remaining loop body in an if, or, in Lua 5.2 and later, to goto a ::continue:: label placed at the end of the loop body.
Cricket analogy: A captain declaring the innings the moment the target is reached is exactly break, the over stops immediately, but Lua has no single-word way to say 'skip this ball and bowl the next,' so you nest the rest of the loop body in an if.
Lua has no continue keyword. The idiomatic workaround is to invert the skip condition and wrap the rest of the loop body in an if, or, for more complex cases, use goto continue ... ::continue:: (Lua 5.2+) to jump straight to the end of the loop body.
- Lua has four loop forms: while cond do...end, repeat...until cond, the numeric for i=start,stop,step do...end, and the generic for k,v in iterator do...end.
- while tests its condition before each iteration; repeat...until tests after, so its body always runs at least once.
- The numeric for loop's step defaults to 1 and can be negative to count down; each iteration gets a fresh local control variable.
- ipairs iterates array-like sequences in strict index order 1..n and stops at the first nil; pairs visits all keys in an unspecified order.
- break exits the nearest enclosing loop immediately; Lua has no continue keyword, so skipping an iteration is done with an if guard or a goto.
- goto and ::label:: (Lua 5.2+) can jump to the end of a loop body to emulate continue.
Practice what you learned
1. Which loop guarantees its body runs at least once?
2. What does ipairs do differently from pairs?
3. What keyword does Lua use to skip the rest of a loop iteration and continue with the next one?
4. In `for i = 10, 1, -2 do print(i) end`, what is printed first?
5. What happens to the loop control variable i across iterations of a numeric for loop regarding closures?
Was this page helpful?
You May Also Like
Conditionals in Lua
Learn how Lua's if/elseif/else statement works, why only nil and false are falsy, and how to replace long conditional chains with idiomatic and/or expressions or table-based dispatch.
Functions in Lua
Learn how to define and call Lua functions, treat them as first-class values, use colon syntax for methods, and understand local vs global function scope.
Closures in Lua
Understand how Lua closures capture upvalues by reference, how to use them for private state and per-iteration loop callbacks, and common closure-based patterns like memoization.
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