Elemente während des Iterierens sicher aus einer Array-Tabelle entfernen

den Allgemeinen Fall von Iteration über ein array und entfernen zufällige Elemente aus der Mitte, während Sie weiterhin Durchlaufen

Verwenden Sie einfach table.remove. Allerdings, wenn Sie die Iteration von vorne nach hinten, beim entfernen des Elements N, das nächste element der iteration (N+1) verschoben wird, nach unten in die position. Wenn Sie erhöhen Ihre iteration (variabel, wie ipairs tut), Sie werden überspringen, dass element. Es gibt zwei Möglichkeiten, damit umzugehen.

Verwendung in diesem Beispiel Daten:

    input = { 'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p' }
    remove = { f=true, g=true, j=true, n=true, o=true, p=true }

Können wir entfernen input Elemente während der iteration durch:

1. Durchlaufen von hinten nach vorne.

   for i=#input,1,-1 do
       if remove[input[i]] then
           table.remove(input, i)
       end
   end

2. Steuerung der loop-variable manuell, so können wir überspringen Inkrementieren, wenn das entfernen eines Elements:

   local i=1
   while i <= #input do
       if remove[input[i]] then
           table.remove(input, i)
       else
           i = i + 1
       end
   end

Für nicht-array-Tabellen, die Sie Durchlaufen mit next oder pairs (die implementiert wird, in Bezug auf next) und legen Sie Artikel, die Sie wollen, entfernt zu nil.

InformationsquelleAutor der Antwort Mud

Versuchen, diese Funktion:

function ripairs(t)
    -- Try not to use break when using this function;
    -- it may cause the array to be left with empty slots
    local ci = 0
    local remove = function()
        t[ci] = nil
    end
    return function(t, i)
        --print("I", table.concat(array, ','))
        i = i+1
        ci = i
        local v = t[i]
        if v == nil then
            local rj = 0
            for ri = 1, i-1 do
                if t[ri] ~= nil then
                    rj = rj+1
                    t[rj] = t[ri]
                    --print("R", table.concat(array, ','))
                end
            end
            for ri = rj+1, i do
                t[ri] = nil
            end
            return
        end
        return i, v, remove
    end, t, ci
end

Es nicht table.remove, so sollte es O(N) Komplexität. Sie bewegen könnte, die remove Funktion in die for-generator entfernen Sie die Notwendigkeit für eine upvalue, aber das würde bedeuten, dass eine neue closure für jedes element... und es ist nicht eine praktische Frage.

Beispiel:

function math.isprime(n)
    for i = 2, n^(1/2) do
        if (n % i) == 0 then
            return false
        end
    end
    return true
end

array = {}
for i = 1, 500 do array[i] = i+10 end
print("S", table.concat(array, ','))
for i, v, remove in ripairs(array) do
    if not math.isprime(v) then
        remove()
    end
end
print("E", table.concat(array, ','))

Seien Sie vorsichtig, nicht zu verwenden break (oder anderweitig zu beenden, vorzeitig aus der Schleife), wie es verlassen werden Sie das array mit nil Elemente.

Wenn Sie wollen break bedeutet "abort" (wie in, nichts ist entfernt), Sie könnten dies tun:

function rtipairs(t, skip_marked)
    local ci = 0
    local tbr = {} -- "to be removed"
    local remove = function(i)
        tbr[i or ci] = true
    end
    return function(t, i)
        --print("I", table.concat(array, ','))
        local v
        repeat
            i = i+1
            v = t[i]
        until not v or not (skip_marked and tbr[i])
        ci = i
        if v == nil then
            local rj = 0
            for ri = 1, i-1 do
                if not tbr[ri] then
                    rj = rj+1
                    t[rj] = t[ri]
                    --print("R", table.concat(array, ','))
                end
            end
            for ri = rj+1, i do
                t[ri] = nil
            end
            return
        end
        return i, v, remove
    end, t, ci
end

Dies hat den Vorteil, dass Sie in der Lage zu stornieren, wird die gesamte Schleife keine Elemente entfernt werden, sowie die option zum überspringen über Elemente, die bereits als markiert "entfernt werden". Der Nachteil ist der Aufwand für eine neue Tabelle.

Ich hoffe, dass diese hilfreich für Sie sind.

InformationsquelleAutor der Antwort Deco

Ich auch empfohlen, vor der Verwendung die Tabelle.entfernen Sie aus performance-Gründen (das kann mehr oder weniger relevant für Ihre speziellen Fall).

Hier ist, was diese Art von Schleife in der Regel sieht aus wie bei mir:

local mylist_size = #mylist
local i = 1
while i <= mylist_size do
    local value = mylist[i]
    if value == 123 then
        mylist[i] = mylist[mylist_size]
        mylist[mylist_size] = nil
        mylist_size = mylist_size - 1
    else
        i = i + 1
    end
end

Beachten Sie, dass dies ändert die Reihenfolge der Elemente im array.

Wenn Sie möchten, beibehalten der Reihenfolge der Elemente können Sie dann die Tabelle.entfernen und ich mache es so:

local mylist_size = #mylist
local i = 1
while i <= mylist_size do
    local value = mylist[i]
    if value == 123 then
        table.remove(mylist, i)
    else
        i = i + 1
    end
end

InformationsquelleAutor der Antwort Srekel

Können Sie einen Funktor zu prüfen, für die Elemente, die entfernt werden müssen. Der zusätzliche Gewinn ist, dass es abgeschlossen ist in O(n), weil es keine Tabelle.entfernen

function table.iremove_if(t, f)
    local j = 0
    local i = 0
    while (i <= #f) do
        if (f(i, t[i])) then
            j = j + 1
        else
            i = i + 1
        end
        if (j > 0) then
            local ij = i + j
            if (ij > #f) then
                t[i] = nil
            else
                t[i] = t[ij]
            end
        end
    end
    return j > 0 and j or nil -- The number of deleted items, nil if 0
end

Verwendung:

table.iremove_if(myList, function(i,v) return v.name == name end)

In Ihrem Fall:

table.iremove_if(timestampedEvents, function(_,stamp)
    if (stamp[1] <= timestamp) then
        processEventData(stamp[2])
        return true
    end
end)

InformationsquelleAutor der Antwort Luc Bloom