0Pricing
Lua Academy · Lektion

Verschachtelte Tabellen und strukturierte Daten

Erstellen Sie verschachtelte Strukturen und greifen Sie auf tief liegende Felder zu

Verschachtelte Tabellen und strukturierte Daten ist eine kostenlose Lua Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Lua Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Lua Academy-Kurs umfasst insgesamt 4 Lektionen.

Grundlagen verschachtelter Tabellen

Tabellen können andere Tabellen als Werte enthalten und dadurch Strukturen mit beliebiger Verschachtelungstiefe bilden. Greifen Sie auf verschachtelte Felder zu, indem Sie Punkte oder Klammern verketten. Fehlende Zwischentabellen führen zu Fehlern – stellen Sie vor dem Zugriff auf tiefe Felder immer sicher, dass die übergeordneten Tabellen vorhanden sind.

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

Sicherer Zugriff auf tiefe Felder

Der Zugriff auf ein Feld eines nil-Werts führt zum Absturz mit „attempt to index a nil value“. Sichern Sie den Zugriff mit dem Kurzschlussverhalten von and ab: t and t.a and t.a.b. In manchen Codebasen gibt es eine Hilfsfunktion get(t, ...), die eine Kette von Schlüsseln sicher durchläuft.

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 aus Records

Ein häufiges Muster ist ein Array aus Tabellen (Records). Jedes Element ist eine Tabelle mit benannten Feldern. Iterieren Sie mit ipairs und greifen Sie über den Namen auf die Felder zu. Dies entspricht in Lua einem Array aus Objekten oder einer Liste aus 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

Verschachtelte Tabellen dynamisch erstellen

Erstellen Sie verschachtelte Strukturen schrittweise, indem Sie innere Tabellen nach Bedarf anlegen. Initialisieren Sie eine Tabelle immer, bevor Sie etwas in sie einfügen. Ein häufiger Fehler besteht darin, die innere Tabelle nicht zuerst zu erstellen und anschließend zu versuchen, auf nil zuzugreifen.

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

Tabelle als JSON-ähnliche Konfiguration

Lua-Tabellen werden häufig für Konfigurationsdateien verwendet, ähnlich wie JSON oder YAML. Die Datei gibt eine Tabelle zurück, und die Anwendung lädt sie mit dofile() oder require(). Verschachtelte Tabellen stellen verschachtelte Konfigurationsabschnitte dar.

-- 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

Graph als Adjazenzliste

Stellen Sie einen Graphen als Tabelle aus Tabellen dar: Jeder Schlüssel ist ein Knoten, und sein Wert ist eine Liste von Nachbarn. Diese Darstellung als Adjazenzliste ist für dünn besetzte Graphen speichereffizient und lässt sich in Lua einfach verarbeiten.

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

Verschachtelte Felder ändern

Ändern Sie verschachtelte Felder, indem Sie auf die übergeordnete Tabelle zugreifen und dem Schlüssel einen Wert zuweisen. Da Tabellen als Referenzen übergeben werden, kann jede Funktion, die eine Tabelle erhält, deren Inhalt direkt ändern – der Aufrufer sieht die Änderungen.

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

Verschachtelte Tabellen serialisieren

Das Umwandeln einer verschachtelten Tabelle in einen String ist für Debugging oder Protokollierung nützlich. Ein einfacher rekursiver Serializer verarbeitet beliebige Verschachtelungstiefen, unterstützt jedoch keine Zyklen (Zirkelverweise).

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))

Dünn besetzte Matrizen

Eine naiv gespeicherte zweidimensionale Matrix verschwendet bei großen dünn besetzten Eingaben Speicher. Speichern Sie nur Einträge ungleich null in einer verschachtelten Tabelle: matrix[row][col] = value. So lassen sich riesige Matrizen effizient darstellen, wenn die meisten Werte null sind.

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)

Prüfung auf tiefe Gleichheit

Tabellen werden mit == anhand ihrer Referenz verglichen, nicht anhand ihres Werts. Um verschachtelte Tabellen strukturell zu vergleichen, schreiben Sie eine rekursive Gleichheitsfunktion, die jedes Schlüssel-Wert-Paar vergleicht und bei verschachtelten Tabellen rekursiv fortfährt.

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

Schnelltest

Was passiert, wenn Sie auf t.a.b zugreifen und t.a nil ist?

Rückblick: Verschachtelte Tabellen

Zusammenfassung:

  • Tabellen können beliebig verschachtelt werden: t.a.b.c
  • Sichern Sie den Zugriff auf tiefe Felder ab: t and t.a and t.a.b
  • Tabellen sind Referenztypen – Funktionen ändern sie direkt
  • Array aus Records: {{name=...},{name=...}}
  • Dünn besetzte Matrix: verschachtelte Tabellen für hohe Speichereffizienz
  • Tiefe Gleichheit erfordert einen rekursiven Vergleich

Häufig gestellte Fragen

Ist die Lektion „Verschachtelte Tabellen und strukturierte Daten“ kostenlos?

Ja — der vollständige Text von „Verschachtelte Tabellen und strukturierte Daten“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Lua Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Lua Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Verschachtelte Tabellen und strukturierte Daten“?

Erstellen Sie verschachtelte Strukturen und greifen Sie auf tief liegende Felder zu Du übst Lua Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Lua Academy zu starten?

Keine Vorkenntnisse erforderlich. Lua Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „Verschachtelte Tabellen und strukturierte Daten“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Lua Academy-Lektion Code schreiben und ausführen?

Ja. Jede Lua Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Tabellen als Arrays
  2. Tabellen als Wörterbücher
  3. Tabellen mit pairs und ipairs durchlaufen
  4. Verschachtelte Tabellen und strukturierte Daten
← Zurück zu Lua Academy