Lua Academy · Les

Geneste tables en gestructureerde gegevens

Bouw geneste structuren en krijg toegang tot diep geneste velden

Les 4 van 412 stappen

Geneste tables en gestructureerde gegevens is een gratis Lua Academy-les op CoddyKit. Dit is les 4 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.

Basisprincipes van geneste tabellen

Tabellen kunnen andere tabellen als waarden bevatten, waardoor structuren met willekeurige diepte ontstaan. Benader geneste velden door punten of blokhaken te koppelen. Ontbrekende tussenliggende tabellen veroorzaken fouten — zorg er altijd voor dat bovenliggende tabellen bestaan voordat je diepe velden benadert.

local company = {
  name = "CoddyKit",
  address = {
    city = "Istanbul",
    country = "Turkey",
    zip = "34000"
  },
  employees = 25
}

print(company.name)            -- CoddyKit
print(company.address.city)    -- Istanbul
print(company["address"]["zip"]) -- 34000

Veilige diepe toegang

Een veld van een nil-waarde benaderen veroorzaakt de fout "attempt to index a nil value". Voorkom dit met kortsluiting via and: t and t.a and t.a.b. Sommige codebases definiëren een helper get(t, ...) die veilig een keten van sleutels doorloopt.

local function get(t, ...)
  local cur = t
  for _, key in ipairs({...}) do
    if type(cur) ~= "table" then return nil end
    cur = cur[key]
  end
  return cur
end

local data = {user = {profile = {age = 30}}}
print(get(data, "user", "profile", "age"))    -- 30
print(get(data, "user", "missing", "field"))  -- nil

Array met records

Een veelgebruikt patroon is een array van tabellen (records). Elk element is een tabel met benoemde velden. Itereer met ipairs en benader velden op naam. Dit is het Lua-equivalent van een array met objecten of een lijst met structs.

local users = {
  {id=1, name="Alice", score=95},
  {id=2, name="Bob",   score=87},
  {id=3, name="Carol", score=91},
}

for _, user in ipairs(users) do
  print(user.id, user.name, user.score)
end

Geneste tabellen dynamisch opbouwen

Bouw geneste structuren stapsgewijs op door binnenste tabellen te maken wanneer dat nodig is. Initialiseer altijd een tabel voordat je er iets aan toevoegt. Een veelgemaakte fout is vergeten eerst de binnenste tabel te maken en daarna te proberen nil te indexeren.

local tree = {}
tree.root = {value = 10}
tree.root.left = {value = 5}
tree.root.right = {value = 15}
tree.root.left.left = {value = 2}

print(tree.root.value)            -- 10
print(tree.root.left.value)       -- 5
print(tree.root.left.left.value)  -- 2

Tabel als JSON-achtige configuratie

Lua-tabellen worden vaak gebruikt voor configuratiebestanden, vergelijkbaar met JSON of YAML. Het bestand geeft een tabel terug en de toepassing laadt deze met dofile() of require(). Geneste tabellen stellen geneste configuratiesecties voor.

-- config.lua (returned table)
local config = {
  server = {
    host = "0.0.0.0",
    port = 8080,
    ssl  = false,
  },
  db = {
    host = "localhost",
    name = "appdb",
    pool_size = 10,
  },
  logging = { level = "info", file = "/var/log/app.log" }
}

print(config.server.port)      -- 8080
print(config.db.pool_size)    -- 10

Graaf als adjacentielijst

Stel een graaf voor als een tabel met tabellen: elke sleutel is een knoop en de waarde ervan is een lijst met buren. Deze voorstelling als adjacentielijst is geheugenefficiënt voor ijle grafen en eenvoudig te gebruiken in Lua.

local graph = {
  A = {"B", "C"},
  B = {"A", "D"},
  C = {"A", "D"},
  D = {"B", "C"},
}

-- BFS from A
local visited = {A=true}
local queue = {"A"}
while #queue > 0 do
  local node = table.remove(queue, 1)
  io.write(node .. " ")
  for _, neighbor in ipairs(graph[node]) do
    if not visited[neighbor] then
      visited[neighbor] = true
      queue[#queue+1] = neighbor
    end
  end
end
print()  -- A B C D

Geneste velden wijzigen

Wijzig geneste velden door de bovenliggende tabel te benaderen en de sleutel een waarde toe te wijzen. Omdat tabellen als verwijzingen worden doorgegeven, kan elke functie die een tabel ontvangt de inhoud ervan direct wijzigen — de aanroeper ziet de wijzigingen.

local player = {name="Hero", stats={hp=100, mp=50, atk=20}}

local function takeDamage(p, dmg)
  p.stats.hp = math.max(0, p.stats.hp - dmg)
end

takeDamage(player, 35)
print(player.stats.hp)   -- 65

player.stats.atk = player.stats.atk + 5
print(player.stats.atk)  -- 25

Geneste tabellen serialiseren

Een geneste tabel omzetten naar een tekenreeks is nuttig voor foutopsporing of logging. Een eenvoudige recursieve serializer kan elke diepte verwerken, maar geen cycli (kringverwijzingen).

local function serialize(val, indent)
  indent = indent or 0
  local pad = string.rep("  ", indent)
  if type(val) ~= "table" then
    return tostring(val)
  end
  local parts = {"{"}
  for k, v in pairs(val) do
    parts[#parts+1] = pad.."  "..tostring(k).."="..serialize(v,indent+1)
  end
  parts[#parts+1] = pad.."}"
  return table.concat(parts, "\n")
end
local data = {x=1, nested={y=2, z=3}}
print(serialize(data))

IJle matrices

Een tweedimensionale matrix die op de gewone manier wordt opgeslagen, verspilt geheugen bij grote ijle invoer. Sla alleen niet-nullelementen op in een geneste tabel: matrix[row][col] = value. Zo kun je enorme matrices efficiënt voorstellen wanneer de meeste waarden nul zijn.

local function newMatrix()
  return setmetatable({}, {__index=function(t,k)
    local row = {}
    rawset(t, k, row)
    return row
  end})
end

local m = newMatrix()
m[1][1] = 5
m[3][7] = 12
m[100][200] = 99

print(m[1][1])    -- 5
print(m[3][7])    -- 12
print(m[2][5])    -- nil (sparse: no value)

Diepe gelijkheidscontrole

Tabellen worden met == vergeleken op basis van verwijzing, niet op basis van waarde. Als je geneste tabellen structureel wilt vergelijken, schrijf je een recursieve gelijkheidsfunctie die elk sleutel-waardepaar vergelijkt en voor geneste tabellen opnieuw wordt aangeroepen.

local function deepEqual(a, b)
  if type(a) ~= type(b) then return false end
  if type(a) ~= "table" then return a == b end
  for k, v in pairs(a) do
    if not deepEqual(v, b[k]) then return false end
  end
  for k in pairs(b) do
    if a[k] == nil then return false end
  end
  return true
end
print(deepEqual({1,{2,3}},{1,{2,3}}))  -- true
print(deepEqual({1,{2,3}},{1,{2,4}}))  -- false

Korte controle

Wat gebeurt er wanneer je t.a.b benadert en t.a nil is?

Beantwoord dit in de interactieve les

Samenvatting: geneste tabellen

Samenvatting:

Tabellen kunnen willekeurig diep worden genest: t.a.b.c
Bescherm diepe toegang: t and t.a and t.a.b
Tabellen zijn verwijzingstypen — functies wijzigen ze direct
Array met records: {{name=...},{name=...}}
IJle matrix: geneste tabellen voor geheugenefficiëntie
Voor diepe gelijkheid is een recursieve vergelijking nodig

Gratis beginnen

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

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Geneste tables en gestructureerde gegevens” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad Lua Academy, waaronder “Geneste tables en gestructureerde gegevens”, 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 “Geneste tables en gestructureerde gegevens”?

Bouw geneste structuren en krijg toegang tot diep geneste velden 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 4 van 4.

Hoe lang duurt de les “Geneste tables en gestructureerde gegevens”?

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

← Terug naar Lua Academy