Tabeller som arrays
Opret og manipulér 1-indekserede arrays med table.insert og table.remove.
Tabeller som arrays er en gratis Lua Academy-lektion på CoddyKit. Dette er lektion 1 af 4. Du kan læse alle 3 lektioner i dette læringsspor gratis i deres fulde længde — derefter låser CoddyKit PRO alle lektioner op samt praktiske øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Den er en del af læringsforløbet i Lua Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Lua Academy-kurset indeholder 4 lektioner i alt.
1-baserede arrays
Lua-arrays er tabeller med fortløbende heltalsnøgler, der starter ved 1. Det adskiller sig fra de fleste sprog, som starter ved 0. Konventionen gælder overalt i Lua — alle standardbiblioteksfunktioner antager 1-baseret indeksering. Adgang uden for grænserne returnerer nil, ikke en fejl.
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 og table.remove
table.insert(t, val) tilføjer et element til slutningen. table.insert(t, pos, val) indsætter på en bestemt position og forskyder elementerne mod højre. table.remove(t, pos) fjerner elementet på pos (standard: det sidste), forskyder elementerne mod venstre og returnerer den fjernede værdi.
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]) -- insertedStak med tabeller
En Lua-tabel fungerer perfekt som en stak. Brug table.insert til at lægge på stakken og table.remove til at tage af stakken. Begge operationer arbejder som standard fra slutningen af tabellen, hvilket giver amortiseret O(1)-tid.
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) -- 1Kø med tabeller
En kø (FIFO) kan implementeres med en tabel, men table.remove(t, 1) har O(n)-kompleksitet, fordi alle elementer forskydes. Brug to pointere (indekser for hoved og hale) til køer med høje krav til ydeevnen, så du undgår forskydningen.
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ængdeoperatoren #
Operatoren # returnerer en tabels "grænse": et indeks i, hvor t[i] ~= nil og t[i+1] == nil. For sekvenser uden huller er dette lig med arrayets længde. Ved huller (nil i midten) giver # udefinerede resultater — brug table.pack, eller hold selv styr på længden.
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 10Udsniting af arrays
Lua har ingen indbygget slice-funktion, men du kan udtrække et under-array med table.move (Lua 5.3+) eller en manuel løkke. table.move(a1, f, e, t, a2) kopierer elementer fra a1[f..e] til a2 med start på position 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 40Vend et array om
Vend en tabel på stedet ved at bytte elementer fra begge ender ind mod midten. Det er en klassisk algoritme, som fungerer på alle Lua-arrays uden ekstra hukommelse.
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 1Sammenkædning af arrays
Hvis du vil samle to arrays i ét, skal du gennemløbe det andet og tilføje dets elementer. table.move gør dette effektivt i Lua 5.3+. Resultatet er en ny tabel, der indeholder alle elementerne fra begge arrays i rækkefølge.
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 6Fladgøring af indlejrede arrays
Fladgør et indlejret array rekursivt: Hvis et element er en tabel, kalder du funktionen rekursivt på det; ellers føjer du det til resultatet. Dette er en naturlig anvendelse af rekursiv gennemgang af tabeller.
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 som mængde
Du kan implementere en mængde ved hjælp af en tabel, hvor værdierne er nøgler, og værdien er true. Kontrol af, om et element findes i mængden, tager O(1). Når du opretter en mængde fra et array, fjernes duplikater. Konvertér den tilbage til et array ved at gennemløbe den med 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 9Hurtigt tjek
Hvad gør table.remove(t), når den kaldes med kun ét argument?
Opsamling: Tabeller som arrays
Opsummering:
- Lua-arrays er tabeller med indekser, der starter ved 1
table.insert/table.removebruges til at tilføje/fjerne elementer i enderne#tgiver længden for sekvenser uden huller- Stak: indsæt/fjern fra slutningen (O(1))
- Kø: brug en peger til starten og en til slutningen for at undgå forskydning på O(n)
- Brug en tabel som mængde til opslag på O(1)
Lær Lua med en AI-underviser — gratis
Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.
- Kurser
- 40
- Lektioner
- 159
Ofte stillede spørgsmål
Er lektionen “Tabeller som arrays” gratis?
Ja — alle 3 lektioner i læringssporet Lua Academy, inklusive “Tabeller som arrays”, kan læses gratis i deres fulde længde her på webstedet. Derefter låser CoddyKit PRO alle lektioner op samt interaktive øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Lua Academy-kurset indeholder 4 lektioner i alt.
Hvad lærer jeg i “Tabeller som arrays”?
Opret og manipulér 1-indekserede arrays med table.insert og table.remove. Du øver dig i Lua Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.
Skal jeg have erfaring for at begynde på Lua Academy?
Der kræves ingen tidligere erfaring. Lua Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 1 af 4.
Hvor lang tid tager lektionen “Tabeller som arrays”?
De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.
Kan jeg skrive og køre kode i denne Lua Academy-lektion?
Ja. Alle Lua Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.
Alle lektioner i dette kursus
- Tabeller som arrays
- Tabeller som ordbøger
- Iteration gennem tabeller med pairs og ipairs
- Indlejrede tabeller og strukturerede data