Ciclo for in Lua

Il ciclo for in Lua e’ una delle strutture di controllo piu’ utilizzate per ripetere un blocco di codice. Lua offre due varianti del ciclo for: il for numerico e il for generico. In questa guida esploreremo entrambe le forme, le differenze tra pairs e ipairs, il break e i cicli nidificati.

For Numerico

Il for numerico permette di iterare su un intervallo di valori numerici. La sintassi e’ la seguente:

for variabile = inizio, fine, passo do
    -- blocco di codice
end

inizio: il valore iniziale della variabile contatore.
fine: il valore finale (incluso) fino al quale iterare.
passo: il valore di incremento o decremento ad ogni iterazione (opzionale, di default e’ 1).

Ecco un esempio che stampa i numeri da 1 a 5:

for i = 1, 5 do
    print(i)
end
-- Output: 1, 2, 3, 4, 5

Se si vuole specificare un passo diverso, ad esempio contare di 2 in 2:

for i = 0, 10, 2 do
    print(i)
end
-- Output: 0, 2, 4, 6, 8, 10

E’ possibile anche contare al contrario utilizzando un passo negativo:

for i = 10, 1, -1 do
    print(i)
end
-- Output: 10, 9, 8, 7, 6, 5, 4, 3, 2, 1

La variabile contatore del for numerico e’ locale al ciclo: non esiste al di fuori del blocco for..end.

For Generico

Il for generico permette di iterare attraverso gli elementi di una tabella utilizzando una funzione iteratore. Le due funzioni iteratore piu’ comuni sono pairs e ipairs.

Iterare con `ipairs`

La funzione ipairs itera sugli elementi di una tabella con indici numerici consecutivi, partendo da 1 e fermandosi al primo valore nil:

local frutti = {"mela", "banana", "arancia", "uva"}

for indice, valore in ipairs(frutti) do
    print(indice, valore)
end
-- Output:
-- 1    mela
-- 2    banana
-- 3    arancia
-- 4    uva

Iterare con `pairs`

La funzione pairs itera su tutte le coppie chiave-valore di una tabella, incluse quelle con chiavi non numeriche. L’ordine di iterazione non e’ garantito per le chiavi non numeriche:

local persona = {
    nome = "Marco",
    eta = 30,
    citta = "Roma"
}

for chiave, valore in pairs(persona) do
    print(chiave .. " = " .. tostring(valore))
end
-- Output (ordine non garantito):
-- nome = Marco
-- eta = 30
-- citta = Roma

Differenza tra `ipairs` e `pairs`

Questa distinzione e’ fondamentale in Lua:

ipairs: itera solo sugli indici numerici consecutivi a partire da 1. Si ferma al primo nil. Mantiene l’ordine.
pairs: itera su tutte le chiavi della tabella (numeriche e stringa). L’ordine non e’ garantito per le chiavi stringa.

Ecco un esempio che evidenzia la differenza:

local tabella = {
    [1] = "primo",
    [2] = "secondo",
    [4] = "quarto",     -- indice 3 mancante
    nome = "test"
}

print("-- Con ipairs --")
for i, v in ipairs(tabella) do
    print(i, v)
end
-- Output:
-- 1    primo
-- 2    secondo
-- (si ferma perche' l'indice 3 e' nil)

print("-- Con pairs --")
for k, v in pairs(tabella) do
    print(k, v)
end
-- Output (ordine non garantito):
-- 1    primo
-- 2    secondo
-- 4    quarto
-- nome  test

Istruzione `break`

L’istruzione break permette di uscire immediatamente dal ciclo corrente:

for i = 1, 100 do
    if i > 5 then
        break
    end
    print(i)
end
-- Output: 1, 2, 3, 4, 5

Si puo’ usare break anche con il for generico per cercare un elemento in una tabella:

local numeri = {10, 25, 37, 42, 58}
local cercato = 37
local trovato = false

for i, v in ipairs(numeri) do
    if v == cercato then
        trovato = true
        print("Trovato " .. cercato .. " alla posizione " .. i)
        break
    end
end

if not trovato then
    print("Elemento non trovato")
end

Cicli For Nidificati

E’ possibile inserire un ciclo for all’interno di un altro per gestire strutture dati multidimensionali o operazioni complesse:

-- Tavola pitagorica 5x5
for riga = 1, 5 do
    local linea = ""
    for colonna = 1, 5 do
        linea = linea .. string.format("%4d", riga * colonna)
    end
    print(linea)
end

Un altro esempio pratico con tabelle nidificate:

local classi = {
    {nome = "Classe A", studenti = {"Anna", "Bruno", "Carlo"}},
    {nome = "Classe B", studenti = {"Diana", "Elena", "Franco"}},
}

for _, classe in ipairs(classi) do
    print(classe.nome .. ":")
    for i, studente in ipairs(classe.studenti) do
        print("  " .. i .. ". " .. studente)
    end
end

Esempio Pratico: Filtrare Elementi

Un uso comune del ciclo for e’ filtrare gli elementi di una tabella:

local numeri = {3, 7, 12, 5, 18, 2, 9, 15}
local pari = {}

for _, n in ipairs(numeri) do
    if n % 2 == 0 then
        table.insert(pari, n)
    end
end

print("Numeri pari trovati:")
for _, n in ipairs(pari) do
    print(n)
end
-- Output: 12, 18, 2

Conclusioni

Il ciclo for in Lua e’ uno strumento versatile e potente. Il for numerico e’ ideale per iterazioni su intervalli definiti, mentre il for generico con pairs e ipairs permette di attraversare le tabelle in modo efficace. Comprendere la differenza tra pairs e ipairs e’ essenziale per scrivere codice Lua corretto e prevedibile. L’uso di break e dei cicli nidificati amplia ulteriormente le possibilita’ di controllo del flusso di esecuzione.

For Numerico

For Generico

Iterare con ipairs

Iterare con pairs

Differenza tra ipairs e pairs

Istruzione break