Tables als arrays
Maak arrays met indexering vanaf 1 en bewerk ze met table.insert en table.remove
Tables als arrays is een gratis Lua Academy-les op CoddyKit. Dit is les 1 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Lua Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Lua Academy bevat in totaal 4 lessen.
Arrays met index vanaf 1
Lua-arrays zijn tabellen met opeenvolgende gehele sleutels die beginnen bij 1. Dit verschilt van de meeste talen, die beginnen bij 0. Deze conventie is universeel in Lua — alle functies uit de standaardbibliotheek gaan uit van indexering vanaf 1. Toegang buiten de grenzen retourneert nil en geen fout.
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 en table.remove
table.insert(t, val) voegt een element aan het einde toe. table.insert(t, pos, val) voegt een element op een positie in en schuift de elementen naar rechts. table.remove(t, pos) verwijdert het element op pos (standaard: het laatste element), schuift de elementen naar links en retourneert de verwijderde waarde.
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 met tabellen
Een Lua-tabel is een uitstekende stack. Gebruik table.insert om elementen op de stack te plaatsen en table.remove om ze eraf te halen. Beide bewerkingen werken standaard aan het einde van de tabel, waardoor ze een geamortiseerde tijdcomplexiteit van O(1) hebben.
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) -- 1Wachtrij met tabellen
Je kunt een wachtrij (FIFO) implementeren met een tabel, maar table.remove(t, 1) heeft O(n)-complexiteit omdat alle elementen worden verschoven. Gebruik voor snelle wachtrijen twee pointers (indexen voor de kop en staart) om verschuiven te voorkomen.
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()) -- bDe lengteoperator #
De operator # retourneert de "grens" van een tabel: een index i waarvoor t[i] ~= nil en t[i+1] == nil geldt. Voor reeksen zonder gaten is dit gelijk aan de arraylengte. Bij gaten (nil in het midden) levert # ongedefinieerde resultaten op — gebruik table.pack of houd de lengte handmatig bij.
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 10Arrays uitsnijden
Lua heeft geen ingebouwde slice, maar je kunt een subarray ophalen met table.move (Lua 5.3+) of een handmatige lus. table.move(a1, f, e, t, a2) kopieert elementen uit a1[f..e] naar a2, vanaf positie 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 40Een array omkeren
Keer een tabel ter plekke om door elementen vanaf beide uiteinden naar het midden toe om te wisselen. Dit is een klassiek algoritme dat op elke Lua-array werkt zonder extra geheugen.
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 1Arrays samenvoegen
Als je twee arrays tot één wilt samenvoegen, loop je over de tweede array en voeg je de elementen aan het einde toe. table.move doet dit efficiënt in Lua 5.3+. Het resultaat is een nieuwe tabel met alle elementen uit beide arrays in de juiste volgorde.
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 6Geneste arrays afvlakken
Vlak een geneste array recursief af: als een element een tabel is, roep je de functie opnieuw aan; anders voeg je het element toe aan het resultaat. Dit is een natuurlijke toepassing van recursief doorlopen van tabellen.
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 als verzameling
Je kunt een verzameling implementeren met een tabel waarin de waarden de sleutels zijn en de waarde true is. Controleren of een element in de verzameling zit, kost O(1). Een verzameling maken van een array verwijdert dubbele waarden. Zet de verzameling weer om naar een array door met pairs te itereren.
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 9Korte controle
Wat doet table.remove(t) als je de functie met slechts één argument aanroept?
Samenvatting: tabellen als arrays
Samenvatting:
- Lua-arrays zijn tabellen met indexen vanaf 1
table.insert/table.removevoor toevoegen/verwijderen aan het einde#tgeeft de lengte voor reeksen zonder gaten- Stapel: toevoegen/verwijderen aan het einde (O(1))
- Wachtrij: gebruik een verwijzer naar het begin en het einde om verschuiven in O(n) te voorkomen
- Gebruik een tabel als verzameling voor controles in O(1) of een element aanwezig is
Leer Lua met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 40
- Lessen
- 159
Veelgestelde vragen
Is de les “Tables als arrays” gratis?
Ja — je kunt hier op het web alle 3 lessen van het leerpad Lua Academy, waaronder “Tables als arrays”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Lua Academy bevat in totaal 4 lessen.
Wat leer ik in “Tables als arrays”?
Maak arrays met indexering vanaf 1 en bewerk ze met table.insert en table.remove Je oefent met Lua Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met Lua Academy te beginnen?
Ervaring vooraf is niet nodig. Lua Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 1 van 4.
Hoe lang duurt de les “Tables als arrays”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over Lua Academy?
Ja. Elke les over Lua Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- Tables als arrays
- Tables als woordenboeken
- Tables doorlopen met pairs en ipairs
- Geneste tables en gestructureerde gegevens