Lua Generic For Loop

The generic for loop in Lua is a powerful and flexible tool that allows you to iterate through collections, such as tables, strings, and other user-defined sequences. Unlike the numeric for loop, which is limited to iterating over numerical ranges, the generic for loop in Lua uses iterators to traverse different data structures, making it an essential feature for developers working with complex data.

What is the Lua Generic For Loop?

The generic for loop is an iteration control structure in Lua that uses iterators to traverse various types of data structures like tables and strings. It is called "generic" because it is not limited to numeric ranges but can be applied to any collection that provides an iterator function.

Syntax

for var1, var2, ..., varN in iterator_function(state, ...) do
    -- body of the loop
end

• iterator_function: A function that returns values for each iteration. Common iterators include pairs(), ipairs(), and string.gmatch().
• variable1, variable2, ...: The variables that receive the values returned by the iterator.

How the Lua Generic For Loop Works

In the generic for loop, the iterator function provides the data, and the loop body runs for each element in the collection. Here’s how the loop operates:

1. The iterator function is called.
2. It returns values for each iteration.
3. The loop executes the code block using those values.
4. The loop continues until the iterator function finishes, i.e., there’s no more data to iterate over.

Practical Lua Loop Examples with Built-in Iterators

1. Iterating Through Lua Tables with pairs()

The pairs() function is used to iterate over all key-value pairs in a table. It’s useful when the table contains keys that are not consecutive integers.​

local person = {name = "Ali", age = 25, job = "Developer"}

for key, value in pairs(person) do
    print(key .. ": " .. value)
end

Output

name: Ali  
age: 25  
job: Developer  

2. Iterating Through Array-like Lua Tables with ipairs()

The ipairs() function is used to iterate over arrays or tables with consecutive integer keys starting from 1. It ensures the iteration maintains the order.

local fruits = {"Apple", "Banana", "Orange"}

for index, fruit in ipairs(fruits) do
    print(index .. ": " .. fruit)
end

Output

1: Apple  
2: Banana  
3: Orange  

3. Iterating Through Lua Strings with string.gmatch()

The string.gmatch() function allows you to iterate over the substrings of a string, based on a pattern.

local text = "Lua is awesome"

for word in string.gmatch(text, "%a+") do
    print(word)
end

Output

Lua  
is  
awesome  

Creating Custom Lua Iterators

Lua allows you to create custom iterators to suit specific iteration needs. A custom iterator is typically implemented as a function that maintains its state between calls, allowing it to produce a sequence of values.

1. Lua Number Generator

You can create a custom iterator to generate a sequence of numbers. This can be useful for scenarios like generating random numbers or implementing a custom counting logic.

local function numberGenerator(start, stop)
    return function()
        start = start + 1
        if start <= stop then
            return start
        end
    end
end

for num in numberGenerator(1, 5) do
    print(num)
end

Output

1
2
3

2. Lua String Character Iterator

Creating an iterator to traverse each character of a string is a great way to efficiently handle string data.

local function stringIterator(str)
    local index = 0
    return function()
        index = index + 1
        if index <= #str then
            return str:sub(index, index)
        end
    end
end

for char in stringIterator("Hello") do
    print(char)
end

Output

H  
e  
l  
l  
o  

Difference Between Numeric for and Generic for Loop

Common Use Cases of the Lua Generic For Loop

The generic for loop is versatile and can be used in various real-world scenarios:

• Processing table data: Iterate through tables to filter, transform, or print records (e.g., user data).
• Custom data structures: Traverse linked lists, trees, or graphs using custom iterators.
• Special iteration patterns: Reverse table order, skip elements, or implement step-based traversal.
• Text parsing: Extract words, CSV fields, or HTML tags with string.gmatch().