table.remove (_Table, [_Index,] )
Entfernt einen numerischen Eintrag aus dem Table _Table am Index _Index (standardmäßig Größe des Tables, also den letzten) und gibt den Wert des entfernten Eintrags zurück. Falls auf den Index _Index noch weitere Einträge folgen, werden deren Indizes um 1 reduziert, um die entstandene Lücke wieder zu schließen.

Einfaches Beispiel, bei dem aus einem Table einige Einträge entfernt werden:

-- Initialisiere Table mit irgendwelchen Werten darin
MyTable = {5, "Hallo Welt", "6,50", 42, true}
 
-- Lösche nun den letzten Eintrag (da kein Index angegeben)
MyValue = table.remove(MyTable)
 
print("Gelöschter Wert: " .. tostring(MyValue)) -- true
 
for Index, Value in ipairs(MyTable) do
    print(Index .. ": " .. tostring(Value))
end
-- 1: 5
-- 2: Hallo Welt
-- 3: 6,50
-- 4: 42
 
-- Gebe nun einen ganz bestimmten Index an, an dem ein Wert gelöscht werden soll
-- Die Werte dahinter werden aufrücken, um die Lücke zu schließen
MyValue = table.remove(MyTable, 2)
 
print("Gelöschter Wert: " .. tostring(MyValue)) -- "Hallo Welt"
 
for Index, Value in ipairs(MyTable) do
    print(Index .. ": " .. tostring(Value))
end
-- 1: 5
-- 2: 6,50
-- 3: 42

Wenn du innerhalb einer Schleife numerische Einträge aus einem Table entfernen möchtest, muss diese Schleife das Table rückwärts durchlaufen! Das hat folgenden Grund: Wenn mit table.remove Einträge aus einer Liste gelöscht werden, rücken die Einträge dahinter nach, um die entstandene Lücke zu füllen (die nachfolgenden Indizes werden also alle um 1 reduziert). Würden wir wie gewohnt vorwärts iterieren und ein Element an Stelle i löschen, würde das darauf folgende Element auf Stelle i vorrücken. Da die Iteration aber bei i+1 weiter geht, hätten wir dadurch ein Element übersprungen. Rückwärts kann das nicht passieren, da das Element an Index i-1 von table.remove nicht beeinflusst wird.

Wir geben darum ein Beispiel, wie ein Table „gefiltert“ werden kann, indem nacheinander Werte daraus entfernt werden, die ein bestimmtes Kriterium erfüllen. Anschaulich soll das am Sieb des Eratosthenes gezeigt werden. Dadurch werden wir ein Table erhalten, das bis zu einem gegebenen Maximalwert alle Primzahlen enthält:

MaxNumber = 100
 
-- Das Table, das zum Schluss nur noch Primzahlen enthalten soll, wird mit allen Zahlen
-- von 2 bis MaxNumber initialisiert
-- siehe auch table.insert
Primes = {}
for i = 2, MaxNumber do
    table.insert(Primes, i)
end
 
PrimeIndex = 1
-- So lange, bis wir am Ende der Liste ankommen...
while PrimeIndex < table.getn(Primes) do
    -- ... werden alle Zahlen entfernt, die ein Vielfaches der Zahl am PrimeIndex sind
    -- Beachte die rückwärtszählende Schleife
    for i = table.getn(Primes), 1, -1 do
        -- Entferne die Zahl, wenn sie größer als die betrachtete Zahl ist und ein ganzzahliges
        -- Vielfaches ist
        if (Primes[i] > Primes[PrimeIndex]) and (math.mod(Primes[i], Primes[PrimeIndex]) == 0) then
            table.remove(Primes, i)
        end
    end
    PrimeIndex = PrimeIndex + 1
end

Hinweis: Das oben ist keine effiziente Implementierung vom Sieb des Eratosthenes und dient nur als Beispiel.

Für ein Weiteres Beispiel siehe den Artikel zu table.insert.

Verwendete Funktionen:

• tostring (_Value)
• table.insert (_Table, [_Index,] _Value)
• math.mod (_a, _b)