0Pricing
Lua Academy · Lezione

Tabelle come dizionari

Utilizzi chiavi stringa e miste per memorizzare coppie chiave-valore.

Tabelle come dizionari è una lezione Lua Academy gratuita su CoddyKit. Questa è la lezione 2 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.

Chiavi stringa

Le tabelle con chiavi stringa funzionano come dizionari (hash map). Acceda ai campi usando la notazione con il punto t.key (per identificatori validi) oppure la notazione con parentesi quadre t["key"] (per qualsiasi stringa). Le due forme sono equivalenti; la notazione con parentesi quadre supporta chiavi dinamiche.

local user = {}
user.name = "Alice"
user["age"] = 30
user.role = "admin"

print(user.name)        -- Alice
print(user["age"])      -- 30

local field = "role"
print(user[field])      -- admin (dynamic key)

Literals di tabella

I dizionari possono essere inizializzati con un literal di tabella usando la sintassi key = value. Questo è il modo più comune per creare record in Lua. È possibile combinare voci nello stile degli array e voci nello stile dei dizionari nello stesso literal.

local config = {
  host = "localhost",
  port = 3306,
  database = "myapp",
  debug = false,
  tags = {"web", "api"},  -- nested array
}

print(config.host)        -- localhost
print(config.port)        -- 3306
print(config.tags[1])     -- web

Conteggio con i dizionari

Un caso d'uso classico dei dizionari è il conteggio delle frequenze. Iteri su un elenco, usando ogni elemento come chiave e incrementando il conteggio. Verifichi la presenza di nil prima di incrementare: usi count[word] or 0 come valore iniziale.

local words = {"lua","is","fast","lua","is","lua"}
local freq = {}

for _, w in ipairs(words) do
  freq[w] = (freq[w] or 0) + 1
end

for word, count in pairs(freq) do
  print(word, count)
end
-- lua 3, is 2, fast 1

Raggruppamento con i dizionari

Per raggruppare i dati in base a una proprietà, iteri sull'elenco e usi la chiave di raggruppamento per aggiungere gli elementi a un elenco contenuto in un dizionario. Questo è l'equivalente Lua di GROUP BY in SQL o del pattern defaultdict di Python.

local people = {
  {name="Alice", dept="eng"},
  {name="Bob",   dept="hr"},
  {name="Carol", dept="eng"},
  {name="Dave",  dept="hr"},
}
local groups = {}

for _, p in ipairs(people) do
  local d = p.dept
  groups[d] = groups[d] or {}
  groups[d][#groups[d]+1] = p.name
end

print(table.concat(groups.eng, ", "))  -- Alice, Carol

Verifica dell'esistenza di una chiave

Verifichi se una chiave esiste confrontando il suo valore con nil. Faccia attenzione: se il valore memorizzato in una chiave è nil, la chiave viene considerata assente. Per indicare la presenza, memorizzi true come valore invece di nil.

local cache = {result=42, mode="fast"}

if cache.result ~= nil then
  print("cached:", cache.result)  -- 42
end

-- Key not present:
if cache.timeout == nil then
  print("no timeout set")
end

-- Membership set pattern
local allowed = {admin=true, editor=true}
if allowed["admin"] then
  print("access granted")
end

Eliminazione delle chiavi

Imposti una chiave della tabella su nil per rimuoverla. La coppia chiave-valore scompare e il garbage collector può recuperare la memoria del valore. In questo modo non è possibile eliminare una variabile locale: solo le voci di una tabella.

local session = {token="abc123", user="Alice", expires=3600}
print(session.token)   -- abc123

session.token = nil
print(session.token)   -- nil (removed)

-- Count remaining keys
local count = 0
for _ in pairs(session) do count = count + 1 end
print(count)   -- 2

Unione di dizionari

Unisca due tabelle iterando sulla prima e copiandone le voci nella seconda. Se entrambe hanno la stessa chiave, prevale il valore della seconda tabella. Questo è l'equivalente Lua di Object.assign di JavaScript.

local defaults = {color="blue", size=12, bold=false}
local overrides = {color="red", italic=true}

local function merge(base, over)
  local result = {}
  for k, v in pairs(base) do result[k] = v end
  for k, v in pairs(over) do result[k] = v end
  return result
end

local opts = merge(defaults, overrides)
print(opts.color, opts.size, opts.italic)  -- red 12 true

Qualsiasi tipo di chiave

Le chiavi delle tabelle possono essere qualsiasi valore diverso da nil e da NaN: stringhe, numeri, booleani, funzioni e persino altre tabelle. Le chiavi intere e quelle stringa vengono memorizzate internamente in modo diverso, ma sono accessibili nello stesso modo con la notazione tra parentesi quadre.

local t = {}
local function myKey() end

t["string"] = 1
t[42] = 2
t[true] = 3
t[myKey] = 4

print(t["string"])  -- 1
print(t[42])        -- 2
print(t[true])      -- 3
print(t[myKey])     -- 4

Iterazione ordinata

pairs() di Lua non garantisce l'ordine di iterazione. Per iterare in un ordine definito, raccolga le chiavi in un array, lo ordini e quindi esegua l'iterazione.

local scores = {Alice=95, Bob=87, Carol=91, Dave=78}

local names = {}
for name in pairs(scores) do
  names[#names+1] = name
end
table.sort(names)

for _, name in ipairs(names) do
  print(name, scores[name])
end
-- Alice 95, Bob 87, Carol 91, Dave 78 (sorted)

Pattern dei valori predefiniti

Un pattern utile consiste nell'usare una tabella di "valori predefiniti" tramite una metatabella con __index. Quando una chiave non viene trovata nella tabella principale, Lua la cerca nella tabella dei valori predefiniti. Ciò consente di creare una configurazione a livelli senza eseguire un'unione.

local defaults = {timeout=30, retries=3, verbose=false}
local config = {timeout=60}

setmetatable(config, {__index = defaults})

print(config.timeout)  -- 60  (overridden)
print(config.retries)  -- 3   (from defaults)
print(config.verbose)  -- false (from defaults)

Verifica rapida

Come si rimuove la chiave "x" dalla tabella t in Lua?

Riepilogo: le tabelle come dizionari

Punti chiave:

  • Notazione con il punto e con le parentesi quadre: t.key == t["key"]
  • Qualsiasi valore diverso da nil e da NaN può essere una chiave
  • Impostare una chiave su nil per eliminarla
  • Conteggio delle frequenze: t[k] = (t[k] or 0) + 1
  • Iterazione ordinata: raccogliere le chiavi → ordinarle → iterare
  • Usare una metatabella __index per i valori predefiniti

Domande Frequenti

La lezione «Tabelle come dizionari» è gratuita?

Sì — il testo completo di «Tabelle come dizionari» è 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 «Tabelle come dizionari»?

Utilizzi chiavi stringa e miste per memorizzare coppie chiave-valore. 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 2 di 4.

Quanto tempo richiede la lezione «Tabelle come dizionari»?

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. Tabelle come array
  2. Tabelle come dizionari
  3. Iterazione delle tabelle con pairs e ipairs
  4. Tabelle annidate e dati strutturati
← Torna a Lua Academy