Lua Academy · Lezione

Iterazione delle tabelle con pairs e ipairs

Attraversi le tabelle in modo sicuro usando pairs() e ipairs().

Iterazione delle tabelle con pairs e ipairs è una lezione Lua Academy gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Lua Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Lua Academy include 4 lezioni in totale.

ipairs: iterazione ordinata degli array

ipairs(t) esegue l'iterazione sulla sequenza di interi che inizia dall'indice 1, producendo coppie (index, value). Si interrompe al primo nil. È la scelta sicura e prevedibile per le tabelle simili ad array, quando l'ordine è importante.

local fruits = {"apple","banana","cherry"}

for i, fruit in ipairs(fruits) do
  print(i, fruit)
end
-- 1  apple
-- 2  banana
-- 3  cherry

pairs: tutte le chiavi

pairs(t) esegue l'iterazione su ogni coppia chiave-valore non nil della tabella, in un ordine non specificato. Internamente usa la funzione next(). Usi pairs per i dizionari, le tabelle miste o quando deve visitare tutte le chiavi indipendentemente dal tipo.

local info = {name="Lua", version=5.4, embedded=true}

for k, v in pairs(info) do
  print(k, v)
end
-- name  Lua
-- version  5.4
-- embedded  true  (order may vary)

Scegliere tra pairs e ipairs

Usi ipairs per gli array sequenziali (ordine garantito, interruzione al raggiungimento di nil). Usi pairs per i dizionari, le tabelle miste o quando servono tutte le chiavi. Usare pairs su un array funziona, ma non garantisce alcun ordine. Usare ipairs su un dizionario ignora le chiavi non intere.

local mixed = {10, 20, label="hello", 30}

-- ipairs: only sees 10, 20, 30 in order
for i, v in ipairs(mixed) do
  io.write(v .. " ")
end
print()  -- 10 20 30

-- pairs: sees everything
for k, v in pairs(mixed) do
  print(k, v)
end

Conteggio degli elementi

Per le sequenze, #t restituisce il conteggio. Per i dizionari, #t non è affidabile: iteri con pairs e conteggi manualmente. Questa è una distinzione importante che evita errori quando si lavora con tabelle miste o con chiavi stringa.

local arr = {10, 20, 30}
print("#arr:", #arr)        -- 3 (reliable)

local dict = {a=1, b=2, c=3}
print("#dict:", #dict)      -- 0 (unreliable for dicts!)

local count = 0
for _ in pairs(dict) do count = count + 1 end
print("count:", count)       -- 3

Modifica dei valori durante l'iterazione

È possibile aggiornare in sicurezza il valore di una chiave esistente durante un'iterazione con pairs. Tuttavia, aggiungere o rimuovere chiavi durante l'iterazione produce un comportamento non definito. Raccolga le modifiche e le applichi dopo il ciclo.

local prices = {apple=1.0, banana=0.5, cherry=2.0}

-- Safe: update existing values
for k, v in pairs(prices) do
  prices[k] = v * 1.1  -- 10% markup
end

for k, v in pairs(prices) do
  print(k, string.format("%.2f", v))
end

Raccolta delle chiavi

Un'operazione comune consiste nel raccogliere tutte le chiavi in un array ordinato per ottenere un output deterministico. Iteri con pairs per raccogliere le chiavi, quindi usi table.sort per ordinarle.

local config = {host="localhost", port=8080, debug=true}
local keys = {}

for k in pairs(config) do
  keys[#keys+1] = k
end
table.sort(keys)

for _, k in ipairs(keys) do
  print(k, "=", config[k])
end
-- debug = true
-- host = localhost
-- port = 8080

Iterazione di tabelle annidate

Per le tabelle annidate (tabelle di tabelle), combini due cicli: il ciclo esterno scorre il livello superiore, quello interno scorre ogni tabella annidata. Questo pattern gestisce qualsiasi profondità, usando la ricorsione per annidamenti davvero arbitrari.

local matrix = {
  {1,2,3},
  {4,5,6},
  {7,8,9},
}

for i, row in ipairs(matrix) do
  for j, val in ipairs(row) do
    io.write(string.format("%3d", val))
  end
  print()
end

Filtraggio con ipairs

Crei un elenco filtrato iterando con ipairs e aggiungendo gli elementi che soddisfano un predicato. Il risultato è un nuovo array contenente solo gli elementi corrispondenti.

local function filter(t, pred)
  local result = {}
  for _, v in ipairs(t) do
    if pred(v) then result[#result+1] = v end
  end
  return result
end

local nums = {1,2,3,4,5,6,7,8,9,10}
local evens = filter(nums, function(n) return n % 2 == 0 end)
print(table.concat(evens, " "))  -- 2 4 6 8 10

Mapping con ipairs

Applichi una trasformazione a ogni elemento: iteri e crei un nuovo array con i valori trasformati. Questo è l'equivalente Lua di map() nei linguaggi funzionali.

local function map(t, fn)
  local result = {}
  for i, v in ipairs(t) do
    result[i] = fn(v)
  end
  return result
end

local nums = {1, 2, 3, 4, 5}
local doubled = map(nums, function(n) return n * 2 end)
print(table.concat(doubled, " "))  -- 2 4 6 8 10

local words = {"hello","world"}
local upper = map(words, string.upper)
print(table.concat(upper, " "))    -- HELLO WORLD

pairs su iteratori personalizzati

È possibile rendere iterabile un oggetto personalizzato restituendo un iteratore e lo stato da una funzione. Il pattern rispecchia il funzionamento interno di pairs: restituisce next, t, nil. Allo stesso modo, la factory dell'iteratore restituisce una funzione e uno stato facoltativo.

local function values(t)
  local i = 0
  return function()
    i = i + 1
    return t[i]
  end
end

for v in values({"x","y","z"}) do
  print(v)
end
-- x
-- y
-- z

Verifica rapida

Quale affermazione su pairs() e ipairs() è vera?

Riepilogo: pairs e ipairs

Riepilogo:

ipairs: ordinato, chiavi intere a partire da 1, si interrompe a nil
pairs: tutte le chiavi, ordine qualsiasi, non si interrompe prematuramente
Usi pairs per i dizionari e ipairs per gli array
Non aggiunga né rimuova mai chiavi durante un'iterazione con pairs; aggiornare i valori esistenti è sicuro
Raccolga e ordini le chiavi per ottenere un output deterministico

Domande Frequenti

La lezione «Iterazione delle tabelle con pairs e ipairs» è gratuita?

Sì — il testo completo di «Iterazione delle tabelle con pairs e ipairs» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Lua Academy, passa a CoddyKit PRO. Il corso Lua Academy include 4 lezioni in totale.

Cosa imparerò in «Iterazione delle tabelle con pairs e ipairs»?

Attraversi le tabelle in modo sicuro usando pairs() e ipairs(). Eserciti Lua Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Lua Academy?

Non è richiesta alcuna esperienza precedente. Lua Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.

Quanto tempo richiede la lezione «Iterazione delle tabelle con pairs e ipairs»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Lua Academy?

Sì. Ogni lezione Lua Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

Tabelle come array
Tabelle come dizionari
Iterazione delle tabelle con pairs e ipairs
Tabelle annidate e dati strutturati

← Torna a Lua Academy