Loops in Lua

Analogy categoryAnalogies

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.

lua

-- 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
end

break, 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.