Hoe krijg ik het aantal items in een Lua-tabel?

Klinkt als een “laat me het voor je googlen”-vraag, maar op de een of andere manier kan ik het antwoord niet vinden. De Lua #-operator telt alleen items met integer-sleutels, en dat geldt ook voor table.getn:

tbl = {}
tbl["test"] = 47
tbl[1] = 48
print(#tbl, table.getn(tbl))   -- prints "1     1"
count = 0
for _ in pairs(tbl) do count = count + 1 end
print(count)            -- prints "2"

Hoe kom ik aan het aantal alleinzendingen zonder ze te tellen?

Antwoord 1, autoriteit 100%

Je hebt de oplossing al in de vraag — de enige manier is om de hele tabel te herhalen met pairs(..).

function tablelength(T)
  local count = 0
  for _ in pairs(T) do count = count + 1 end
  return count
end

Houd er rekening mee dat de definitie van de operator “#” iets ingewikkelder is dan dat. Laat me dat illustreren door deze tabel te nemen:

t = {1,2,3}
t[5] = 1
t[9] = 1

Volgens de handleiding zijn elk van3, 5 en 9 geldige resultaten voor #t. De enige verstandige manier om het te gebruiken is met arrays van één aaneengesloten deel zonder nulwaarden.

Antwoord 2, autoriteit 14%

U kunt een metatabel opzetten om het aantal items bij te houden, dit kan sneller zijn dan iteratie als deze informatie vaak nodig is.

Antwoord 3, autoriteit 3%

Er is één manier, maar die kan teleurstellend zijn: gebruik een extra variabele (of een van de velden van de tabel) om de telling op te slaan en verhoog deze elke keer dat u iets invoegt.

count = 0
tbl = {}
tbl["test"] = 47
count = count + 1
tbl[1] = 48
count = count + 1
print(count)   -- prints "2"

Er is geen andere manier, de operator # werkt alleen op array-achtige tabellen met opeenvolgende sleutels.

Antwoord 4

De gemakkelijkste manier die ik ken om het aantal items in een tabel te krijgen, is met ‘#’. #tableName krijgt het aantal vermeldingen zolang ze genummerd zijn:

tbl={
    [1]
    [2]
    [3]
    [4]
    [5]
}
print(#tbl)--prints the highest number in the table: 5

Helaas, als ze niet genummerd zijn, zal het niet werken.

Antwoord 5

Je zou de penlight-bibliotheekkunnen gebruiken. Dit heeft een functie sizedie de werkelijke grootte van de tafel geeft.

Het heeft veel van de functies geïmplementeerd die we nodig hebben tijdens het programmeren en missen in Lua.

Hier is het voorbeeld om het te gebruiken.

> tablex = require "pl.tablex"
> a = {}
> a[2] = 2
> a[3] = 3 
> a['blah'] = 24
> #a
0
> tablex.size(a)
3

Antwoord 6

local function CountedTable(x)
    assert(type(x) == 'table', 'bad parameter #1: must be table')
    local new_t = {}
    local mt = {}
    -- `all` will represent the number of both
    local all = 0
    for k, v in pairs(x) do
        all = all + 1
    end
    mt.__newindex = function(t, k, v)
        if v == nil then
            if rawget(x, k) ~= nil then
                all = all - 1
            end
        else
            if rawget(x, k) == nil then
                all = all + 1
            end
        end
        rawset(x, k, v)
    end
    mt.__index = function(t, k)
        if k == 'totalCount' then return all
        else return rawget(x, k) end
    end
    return setmetatable(new_t, mt)
end
local bar = CountedTable { x = 23, y = 43, z = 334, [true] = true }
assert(bar.totalCount == 4)
assert(bar.x == 23)
bar.x = nil
assert(bar.totalCount == 3)
bar.x = nil
assert(bar.totalCount == 3)
bar.x = 24
bar.x = 25
assert(bar.x == 25)
assert(bar.totalCount == 4)

Antwoord 7

function GetTableLng(tbl)
  local getN = 0
  for n in pairs(tbl) do 
    getN = getN + 1 
  end
  return getN
end

je hebt gelijk. Er zijn geen andere manier om de tafel te krijgen

Antwoord 8

Het lijkt erop dat de elementen van de tabel worden toegevoegd door invoegmethode, wordt getn correct terug. Anders moeten we alle elementen tellen

mytable = {}
element1 = {version = 1.1}
element2 = {version = 1.2}
table.insert(mytable, element1)
table.insert(mytable, element2)
print(table.getn(mytable))

Het zal 2 correct afdrukken

Antwoord 9

Ik struikelde op deze thread en wil een andere optie plaatsen. Ik gebruik Luad Gegenereerd uit een blokcontroller, maar het werkt in wezen door waarden in de tabel te controleren en vervolgens op te komen welke waarde wordt gecontroleerd door 1. Uiteindelijk is de tabel op en de waarde in die index is nihil.

Trek dus 1 af van de index die een nul terugstuurde, en dat is de grootte van de tabel.

Ik heb een globale variabele voor tablesize die is ingesteld op het resultaat van deze telling.

function Check_Table_Size()
  local Count = 1
  local CurrentVal = (CueNames[tonumber(Count)])
  local repeating = true
  print(Count)
  while repeating == true do
    if CurrentVal ~= nil then
      Count = Count + 1
      CurrentVal = CueNames[tonumber(Count)]
     else
      repeating = false
      TableSize = Count - 1
    end
  end
  print(TableSize)
end