0Pricing
Lua Academy · Lektion

Tabellen als Arrays

Erstellen und bearbeiten Sie bei 1 beginnende Arrays mit table.insert und table.remove

Tabellen als Arrays ist eine kostenlose Lua Academy-Lektion auf CoddyKit. Dies ist Lektion 1 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.

Arrays mit Index ab 1

Lua-Arrays sind Tabellen mit aufeinanderfolgenden ganzzahligen Schlüsseln, die bei 1 beginnen. Das unterscheidet sie von den meisten Programmiersprachen, die bei 0 beginnen. Diese Konvention gilt überall in Lua — alle Funktionen der Standardbibliothek setzen eine Indizierung ab 1 voraus. Der Zugriff außerhalb der Grenzen gibt nil statt eines Fehlers zurück.

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 und table.remove

table.insert(t, val) hängt ein Element am Ende an. table.insert(t, pos, val) fügt es an einer Position ein und verschiebt die Elemente nach rechts. table.remove(t, pos) entfernt das Element an pos (standardmäßig das letzte), verschiebt die Elemente nach links und gibt den entfernten Wert zurück.

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

Stack mit Tabellen

Eine Lua-Tabelle eignet sich hervorragend als Stack. Verwenden Sie table.insert zum Ablegen und table.remove zum Entnehmen. Beide Operationen arbeiten standardmäßig am Ende der Tabelle und haben dadurch amortisiert eine Laufzeit von 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)               -- 1

Warteschlange mit Tabellen

Eine Warteschlange (FIFO) lässt sich mit einer Tabelle implementieren, aber table.remove(t, 1) hat die Laufzeit O(n), da alle Elemente verschoben werden. Für leistungsfähige Warteschlangen verwenden Sie zwei Zeiger (Kopf- und Schwanzindex), um das Verschieben zu vermeiden.

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

Der Längenoperator #

Der Operator # gibt die „Grenze“ einer Tabelle zurück: einen Index i, für den t[i] ~= nil und t[i+1] == nil gilt. Bei Sequenzen ohne Lücken entspricht dieser Wert der Array-Länge. Bei Lücken (nil in der Mitte) liefert # undefinierte Ergebnisse — verwenden Sie table.pack oder verwalten Sie die Länge manuell.

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 10

Arrays ausschneiden

Lua verfügt über keinen eingebauten Slice, aber Sie können mit table.move (Lua 5.3+) oder einer manuellen Schleife ein Teilarray extrahieren. table.move(a1, f, e, t, a2) kopiert Elemente aus a1[f..e] nach a2, beginnend an der 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  40

Ein Array umkehren

Kehren Sie eine Tabelle direkt um, indem Sie Elemente von beiden Enden zur Mitte hin vertauschen. Dieser klassische Algorithmus funktioniert bei jedem Lua-Array ohne zusätzlichen Speicher.

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 1

Arrays verketten

Um zwei Arrays zu einem zusammenzuführen, iterieren Sie über das zweite Array und hängen seine Elemente an. table.move erledigt dies in Lua 5.3+ effizient. Das Ergebnis ist eine neue Tabelle, die alle Elemente beider Arrays in der ursprünglichen Reihenfolge enthält.

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 6

Verschachtelte Arrays abflachen

Flachen Sie ein verschachteltes Array rekursiv ab: Wenn ein Element eine Tabelle ist, rufen Sie die Funktion für diese Tabelle erneut auf; andernfalls fügen Sie es dem Ergebnis hinzu. Dies ist eine natürliche Anwendung der rekursiven Tabellendurchläufe.

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

Array als Set

Sie können ein Set mithilfe einer Tabelle implementieren, in der die Werte als Schlüssel dienen und der zugehörige Wert true ist. Die Prüfung der Set-Zugehörigkeit hat O(1). Beim Erstellen eines Sets aus einem Array werden doppelte Werte entfernt. Wandeln Sie es wieder in ein Array um, indem Sie mit pairs darüber iterieren.

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 9

Schnelltest

Was bewirkt table.remove(t), wenn es nur mit einem Argument aufgerufen wird?

Rückblick: Tabellen als Arrays

Zusammenfassung:

  • Lua-Arrays sind bei 1 beginnende Tabellen
  • table.insert/table.remove für Push/Pop
  • #t liefert die Länge für Sequenzen ohne Lücken
  • Stack: Einfügen/Entfernen am Ende (O(1))
  • Queue: Verwenden Sie Zeiger auf Anfang und Ende, um eine Verschiebung mit O(n) zu vermeiden
  • Verwenden Sie Tabellen als Sets für Mitgliedschaftsprüfungen mit O(1)

Häufig gestellte Fragen

Ist die Lektion „Tabellen als Arrays“ kostenlos?

Ja — der vollständige Text von „Tabellen als Arrays“ 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 „Tabellen als Arrays“?

Erstellen und bearbeiten Sie bei 1 beginnende Arrays mit table.insert und table.remove 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 1 von 4.

Wie lange dauert die Lektion „Tabellen als Arrays“?

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