Tabelle come array
Crei e manipoli array indicizzati a partire da 1 con table.insert e table.remove.
Tabelle come array è una lezione Lua Academy gratuita su CoddyKit. Questa è la lezione 1 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.
Array indicizzati a partire da 1
Gli array Lua sono tabelle con chiavi intere consecutive che iniziano da 1. Questo differisce dalla maggior parte dei linguaggi, che iniziano da 0. La convenzione è universale in Lua: tutte le funzioni della libreria standard presuppongono un indicizzamento a partire da 1. L'accesso oltre i limiti restituisce nil, non un errore.
local colors = {"red", "green", "blue"}
print(colors[1]) -- red
print(colors[2]) -- green
print(colors[3]) -- blue
print(colors[0]) -- nil (no index 0)
print(#colors) -- 3 (length operator)table.insert e table.remove
table.insert(t, val) aggiunge un elemento alla fine. table.insert(t, pos, val) inserisce un elemento in una posizione, spostando a destra gli elementi successivi. table.remove(t, pos) rimuove l'elemento in pos (per impostazione predefinita, l'ultimo), sposta a sinistra gli elementi successivi e restituisce il valore rimosso.
local stack = {}
table.insert(stack, "first")
table.insert(stack, "second")
table.insert(stack, "third")
print(#stack) -- 3
table.insert(stack, 2, "inserted")
print(stack[2]) -- inserted
local removed = table.remove(stack, 1)
print(removed) -- first
print(stack[1]) -- insertedStack con le tabelle
Una tabella Lua è perfetta per implementare uno stack. Usare table.insert per inserire e table.remove per estrarre. Per impostazione predefinita, entrambe le operazioni agiscono sulla fine della tabella, offrendo un tempo ammortizzato O(1).
local stack = {}
-- Push
table.insert(stack, 10)
table.insert(stack, 20)
table.insert(stack, 30)
-- Pop
print(table.remove(stack)) -- 30
print(table.remove(stack)) -- 20
print(#stack) -- 1Coda con le tabelle
Una coda (FIFO) può essere implementata con una tabella, ma table.remove(t, 1) ha complessità O(n), perché sposta tutti gli elementi. Per code ad alte prestazioni, usare due puntatori, ovvero gli indici di testa e coda, per evitare gli spostamenti.
local head, tail = 1, 0
local queue = {}
local function enqueue(v)
tail = tail + 1
queue[tail] = v
end
local function dequeue()
if head > tail then return nil end
local v = queue[head]
queue[head] = nil
head = head + 1
return v
end
enqueue("a"); enqueue("b"); enqueue("c")
print(dequeue()) -- a
print(dequeue()) -- bL'operatore di lunghezza #
L'operatore # restituisce il "bordo" di una tabella: un indice i tale che t[i] ~= nil e t[i+1] == nil. Per le sequenze senza elementi mancanti, corrisponde alla lunghezza dell'array. In presenza di elementi mancanti, ovvero nil nel mezzo, # produce risultati non definiti: usare table.pack oppure tenere traccia manualmente della lunghezza.
local t = {10, 20, 30, 40, 50}
print(#t) -- 5
-- Safe for dense arrays
for i = #t, 1, -1 do
io.write(t[i] .. " ")
end
print() -- 50 40 30 20 10Suddividere gli array
Lua non dispone di uno slice integrato, ma è possibile estrarre un sottoarray con table.move (Lua 5.3+) o con un ciclo manuale. table.move(a1, f, e, t, a2) copia gli elementi da a1[f..e] in a2, a partire dalla posizione t.
local src = {10,20,30,40,50,60}
-- Manual slice
local function slice(t, from, to)
local result = {}
for i = from, to do
result[#result+1] = t[i]
end
return result
end
local sub = slice(src, 2, 4)
print(sub[1], sub[2], sub[3]) -- 20 30 40Invertire un array
Invertire una tabella sul posto scambiando gli elementi delle due estremità e procedendo verso il centro. È un algoritmo classico che funziona su qualsiasi array Lua senza memoria aggiuntiva.
local function reverse(t)
local n = #t
for i = 1, math.floor(n / 2) do
t[i], t[n - i + 1] = t[n - i + 1], t[i]
end
end
local arr = {1, 2, 3, 4, 5}
reverse(arr)
for _, v in ipairs(arr) do
io.write(v .. " ")
end
print() -- 5 4 3 2 1Concatenare array
Per unire due array in uno solo, iterare sul secondo e aggiungerne gli elementi. table.move esegue questa operazione in modo efficiente in Lua 5.3+. Il risultato è una nuova tabella che contiene in ordine tutti gli elementi di entrambi gli array.
local function concat(a, b)
local result = {}
for _, v in ipairs(a) do result[#result+1] = v end
for _, v in ipairs(b) do result[#result+1] = v end
return result
end
local merged = concat({1,2,3}, {4,5,6})
for i, v in ipairs(merged) do
io.write(v .. " ")
end
print() -- 1 2 3 4 5 6Appiattimento di array annidati
Appiattire ricorsivamente un array annidato: se un elemento è una tabella, richiamare la funzione ricorsivamente su di essa; altrimenti aggiungerlo al risultato. Questa è un'applicazione naturale dell'attraversamento ricorsivo delle tabelle.
local function flatten(t, result)
result = result or {}
for _, v in ipairs(t) do
if type(v) == "table" then
flatten(v, result)
else
result[#result+1] = v
end
end
return result
end
local nested = {1, {2, 3}, {4, {5, 6}}, 7}
local flat = flatten(nested)
print(table.concat(flat, ", ")) -- 1, 2, 3, 4, 5, 6, 7Array come insieme
È possibile implementare un insieme usando una tabella in cui i valori sono le chiavi e il valore associato è true. Il controllo dell'appartenenza all'insieme ha complessità O(1). Creare un insieme a partire da un array elimina i duplicati. Per riconvertirlo in un array, esegua un'iterazione con pairs.
local function toSet(arr)
local set = {}
for _, v in ipairs(arr) do set[v] = true end
return set
end
local nums = {3,1,4,1,5,9,2,6,5,3}
local set = toSet(nums)
local unique = {}
for k in pairs(set) do unique[#unique+1] = k end
table.sort(unique)
print(table.concat(unique, " ")) -- 1 2 3 4 5 6 9Verifica rapida
Che cosa fa table.remove(t) quando viene chiamato con un solo argomento?
Riepilogo: le tabelle come array
Riepilogo:
- Gli array Lua sono tabelle con indice a partire da 1
table.insert/table.removeper inserire/rimuovere elementi in coda#trestituisce la lunghezza per le sequenze senza buchi- Pila: inserimento/rimozione dalla fine (O(1))
- Coda: usi puntatori alla testa e alla coda per evitare lo spostamento O(n)
- Usi una tabella come insieme per controlli di appartenenza O(1)
Impara Lua con un tutor IA — gratis
Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.
- Corsi
- 40
- Lezioni
- 159
Domande Frequenti
La lezione «Tabelle come array» è gratuita?
Sì — il testo completo di «Tabelle come array» è 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 array»?
Crei e manipoli array indicizzati a partire da 1 con table.insert e table.remove. 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 1 di 4.
Quanto tempo richiede la lezione «Tabelle come array»?
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