Comment puis-je obtenir le nombre de clés dans une table de hachage en Lua?

Question

myTable = {}
myTable["foo"] = 12
myTable["bar"] = "blah"
print(#myTable) -- this prints 0

Dois-je réellement avoir à parcourir les éléments du tableau pour obtenir le nombre de clés?

numItems = 0
for k,v in pairs(myTable) do
    numItems = numItems + 1
end
print(numItems) -- this prints 2

Answer 1

J'ai expérimenté avec à la fois le n ° de l'opérateur et de la table.getn(). J'ai pensé à table.getn() serait de faire ce que tu voulais, mais il s'avère que c'est de retourner la même valeur que #, à savoir 0. Il semble que les dictionnaires insérer néant espaces réservés que nécessaire.

Boucler sur les touches et compter semble que la seule façon d'obtenir la taille du dictionnaire.

Answer 2

La longueur d'un tableau t est un entier quelconque indice n tel que t[n] n'est pas nul et t[n+1] est nulle; de plus, si t[1] est nulle, n peut être égal à zéro. Pour un réseau régulier, avec les non-néant valeurs de 1 à un n, sa longueur est exactement ce que n, l'indice de la dernière valeur. Si le tableau a des "trous" (c'est nul les valeurs entre autres la non-néant valeurs), puis le #t peut être l'un des indices qui précède directement une valeur nulle (qui est, il peut considérer cette valeur nil comme la fin du tableau). donc seul moyen d'obtenir la longueur est d'itérer sur elle.

Answer 3

Hormis une itération à travers les clés manuellement, il est simple de garder automatiquement la trace via metamethods. Considérant que vous ne voulez probablement pas à garder une trace de chaque table que vous faites, vous pouvez simplement écrire une fonction qui vous permettra de convertir n'importe quelle table dans une clé dénombrable de l'objet. La suite n'est pas parfait, mais je pense qu'il serait d'illustrer ce point:

function CountedTable(x)
  assert(type(x) == 'table', 'bad parameter #1: must be table')

  local mt = {}
  -- `keys`  will represent the number of non integral indexes
  -- `indxs` will represent the number of integral indexes
  -- `all`   will represent the number of both 
  local keys, indxs, all = 0, 0, 0

  -- Do an initial count of current assets in table. 
  for k, v in pairs(x) do
    if (type(k) == 'number') and (k == math.floor(k)) then indxs = indxs + 1
    else keys = keys + 1 end

    all = all + 1
  end

  -- By using `__nexindex`, any time a new key is added, it will automatically be
  -- tracked.
  mt.__newindex = function(t, k, v)
    if (type(k) == 'number') and (k == math.floor(k)) then indxs = indxs + 1
    else keys = keys + 1 end

    all = all + 1
    t[k] = v
  end

  -- This allows us to have fields to access these datacounts, but won't count as
  -- actual keys or indexes.
  mt.__index = function(t, k)
    if k == 'keyCount' then return keys 
    elseif k == 'indexCount' then return indxs 
    elseif k == 'totalCount' then return all end
  end

  return setmetatable(x, mt)
end

Des exemples d'utilisation de ce seraient les suivantes:

-- Note `36.35433` would NOT be counted as an integral index.
local foo = CountedTable { 1, 2, 3, 4, [36.35433] = 36.35433, [54] = 54 }
local bar = CountedTable { x = 23, y = 43, z = 334, [true] = true }
local foobar = CountedTable { 1, 2, 3, x = 'x', [true] = true, [64] = 64 }

print(foo.indexCount)    --> 5
print(bar.keyCount)      --> 4
print(foobar.totalCount) --> 6

Live De Travail Exemple

Espérons que cela a aidé! :)

Answer 4

Lua table magasins que sépare deux parties : une partie de hachage et un tableau de la partie, le len de l'opérateur ne traitent que de la matrice de la partie, le sens de la valeur indexée par un certain nombre de valeur, plus l'utilisation de règles mentionnées ci-dessous, de sorte que vous n'avez pas le choix pour le comptage "hash" valeur dont vous avez besoin pour effectuer une itération sur la table avec les paires() fonction.