0Pricing
Lua Academy · Lezione

for generico e break

Utilizzi for generico con pairs/ipairs e controlli il flusso del ciclo con break.

for generico e break è una lezione Lua Academy gratuita su CoddyKit. Questa è la lezione 4 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.

Protocollo del for generico

Il ciclo for generico di Lua funziona con una funzione iteratrice. La sintassi è for vars in iter_func, state, init do. A ogni iterazione, Lua chiama iter_func(state, lastVar) e assegna i valori restituiti alle variabili vars. Il ciclo si arresta quando il primo valore restituito è nil.

-- Manual use of next() iterator
local t = {a=1, b=2, c=3}
local key, val = next(t, nil)   -- first entry
while key ~= nil do
  print(key, val)
  key, val = next(t, key)       -- advance
end

pairs() per tutte le chiavi

pairs(t) restituisce un iteratore che attraversa tutte le coppie chiave-valore di una tabella, incluse le chiavi stringa, le chiavi intere e le tabelle miste. L'ordine di iterazione delle chiavi non intere non è specificato (ordine hash). Sono incluse sia la parte array sia la parte hash.

local config = {
  host = "localhost",
  port = 8080,
  debug = true,
  [1] = "first",
}

for key, value in pairs(config) do
  print(key, value)
end
-- Prints all 4 entries in any order

ipairs() per le chiavi degli array

ipairs(t) itera sulle chiavi intere a partire da 1 e si arresta al primo valore nil. È sicuro, prevedibile e mantiene l'ordine. Utilizzi ipairs per le tabelle simili ad array quando l'ordine è importante e desidera arrestarsi al primo elemento mancante.

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

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

-- stops at first nil
local t = {10, 20, nil, 40}
for i, v in ipairs(t) do
  print(i, v)  -- only 1,10 and 2,20
end

Confronto tra pairs e ipairs

È importante sapere quale utilizzare: ipairs è destinato agli array sequenziali ordinati, mentre pairs è destinato ai dizionari o alle tabelle miste. ipairs si arresta al primo elemento nil mancante; pairs visita ogni chiave non nil. Per gli array puri, ipairs è la scelta più idiomatica.

local mixed = {10, 20, key="val", 30}

-- ipairs only sees array part in order
print("ipairs:")
for i, v in ipairs(mixed) do
  print(i, v)  -- 1:10, 2:20, 3:30
end

-- pairs sees everything
print("pairs:")
for k, v in pairs(mixed) do
  print(k, v)  -- 1:10, 2:20, 3:30, key:val
end

Iteratore personalizzato con closure

È possibile scrivere un iteratore personalizzato come closure. La funzione factory restituisce una closure con stato, che avanza la posizione a ogni chiamata. Quando non rimane più nulla da restituire, restituisce nil per arrestare il for generico.

local function range(from, to, step)
  step = step or 1
  local i = from - step
  return function()
    i = i + step
    if i <= to then return i end
  end
end

for n in range(1, 10, 2) do
  io.write(n .. " ")
end
print()  -- 1 3 5 7 9

string.gmatch come iteratore

string.gmatch(s, pattern) restituisce un iteratore su tutte le corrispondenze del pattern nella stringa s. Viene comunemente utilizzato per dividere stringhe, estrarre token o trovare tutte le occorrenze di un pattern.

local sentence = "the quick brown fox"

for word in string.gmatch(sentence, "%a+") do
  print(word)
end
-- the
-- quick
-- brown
-- fox

break nel for generico

È possibile uscire prima da un ciclo for generico utilizzando break. Questo è utile per le ricerche: si itera finché non viene trovata una corrispondenza, quindi si usa break. Dopo break, l'esecuzione continua con l'istruzione successiva a end.

local inventory = {
  {name="sword", damage=50},
  {name="shield", armor=30},
  {name="bow", damage=35},
}

local target = "shield"
for i, item in ipairs(inventory) do
  if item.name == target then
    print("Found at index", i)
    break
  end
end

Modifica delle tabelle durante l'iterazione

Non inserisca né rimuova mai chiavi da una tabella mentre itera con pairs(): il comportamento non è definito (alcune modifiche potrebbero essere rilevate, mentre altre potrebbero essere ignorate). Se deve modificare una tabella, raccolga le modifiche in un elenco temporaneo e le applichi dopo il ciclo.

local t = {a=1, b=2, c=3, d=4}
local toDelete = {}

-- Collect keys to delete
for k, v in pairs(t) do
  if v % 2 == 0 then
    toDelete[#toDelete+1] = k
  end
end

-- Delete after iteration
for _, k in ipairs(toDelete) do
  t[k] = nil
end
-- t = {a=1, c=3}

Schema di enumerazione

Quando sono necessari sia l'indice sia il valore, utilizzi ipairs, che fornisce entrambi. Quando servono solo i valori e l'indice non è importante, può utilizzare _ come nome convenzionale di variabile «non utilizzata» per l'indice.

local colors = {"red", "green", "blue"}

-- With index
for i, color in ipairs(colors) do
  print(i .. ": " .. color)
end

-- Ignore index with _
for _, color in ipairs(colors) do
  print(color)  -- just the values
end

next() direttamente

next(t, key) è la funzione di attraversamento sottostante. Restituisce la coppia chiave-valore successiva a key, oppure nil se non ce ne sono altre. next(t, nil) restituisce la prima voce. Può utilizzare next(t) ~= nil per verificare se una tabella non è vuota: è più veloce che contarne gli elementi.

local function isEmpty(t)
  return next(t) == nil
end

print(isEmpty({}))       -- true
print(isEmpty({1,2,3}))  -- false
print(isEmpty({a=1}))    -- false

Verifica rapida

Quale iteratore si arresta al primo elemento nil mancante in una tabella?

Riepilogo: for generico e break

Riepilogo:

  • pairs(t) — tutte le chiavi, in ordine qualsiasi
  • ipairs(t) — chiavi intere da 1 a n, ordinate, si arresta su nil
  • Iteratori personalizzati: restituiscono una closure che restituisce nil per arrestarsi
  • break consente di uscire prima dal ciclo
  • Non modifichi mai una tabella durante pairs; raccolga le modifiche e le applichi dopo
  • next(t) == nil — verifica rapida dell'assenza di elementi

Domande Frequenti

La lezione «for generico e break» è gratuita?

Sì — il testo completo di «for generico e break» è 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 «for generico e break»?

Utilizzi for generico con pairs/ipairs e controlli il flusso del ciclo con break. 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 4 di 4.

Quanto tempo richiede la lezione «for generico e break»?

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

  1. Istruzioni if, elseif ed else
  2. Cicli while e repeat-until
  3. Ciclo for numerico
  4. for generico e break
← Torna a Lua Academy