Comment obtenir le nombre d'entrées dans une table Lua?

Sonne comme un "let me google pour vous" question, mais de toute façon je ne peux pas trouver une réponse. Le Lua # opérateur ne prend en compte que les entrées avec entier clés, et ainsi de ne 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"

Comment puis-je obtenir le numéro de tous entrées sans les compter?

  • J'ai écrit un sérialiseur qui se souvient de chaque objet qu'il a vu, et la prochaine fois qu'il la voit, il émet un entier de référence à la place de l'objet. Le moyen naturel de le faire est d'écrire quelque chose comme dictionary[value] = #dictionary + 1, où # représente le nombre de tous les objets. Ce que je me demande pourquoi vous ne voulez pas que cela: dans tous les sane cas d'utilisation pour l' # (voir la réponse par kaizer.se), le nombre de tous les objets est exactement égal à ce # retourne déjà; il semble comme faire # compter tout ce qui est strictement une amélioration. Bien sûr, je suis un Lua débutant et peut-être à côté de la question.
  • Il n'est pas agréable de vous faire remettre en question le programmeur de la compétence en se demandant pourquoi il a besoin de faire quelque chose que toutes les langages de programmation ont une fonction simple pour.
  • Je ne remet pas en question a une personne de compétence. Je n'ai simplement jamais besoin de savoir combien d'entrées de la table a la.
  • Un autre exemple d'utilisation: récupérer beaucoup de données dans un tableau, où chaque élément de données est une chaîne unique d'identification. J'utilise cet identifiant comme la clé parce que je vais être à la recherche par la suite. Maintenant, je veux imprimer le nombre d'éléments de données traitées. Je dois tenir un comptoir et incrémenter manuellement pour chaque ligne. Certainement pas une grosse affaire, mais il est rare de ne pas être en mesure de dire quelque chose comme ceci sans compter, et depuis que vous avez demandé "pourquoi"... 🙂
  • Il n'est pas agréable de vous raconter l'une de Lua auteurs de langue que Lua n'est pas parmi les "raisonnable" des langages de programmation. 😉 BTW, je n'ai jamais nécessaire que l'information ainsi.
  • La table est le meilleur endroit pour conserver les informations sur l'objet courant comte, lorsqu'il est utilisé comme conteneur. Par exemple, lorsque la table est utilisée comme un Ensemble.
  • Je ne pense pas que j'ai jamais utilisé toutes les fonctionnalités d'une langue unique. Cela ne veut pas dire qu'ils ne sont pas utile à d'autres 🙂
  • Lua est mature et assez bien équilibré. Si il lui manque une fonctionnalité, cela signifie souvent que cette fonctionnalité serait la ruine de l'équilibre entre la simplicité, la flexibilité et la vitesse. Je pense que cette fonctionnalité.
  • Les threads sur Lua-l sur ce sujet sont innombrables. La plupart de la confusion de l'OMI provient du fait que Lua tables sont à la fois les tableaux et les tables de hachage, alors vous devez savoir. Contrairement à quelque chose comme JSON qui a séparé les représentations de chacun. Qui est le meilleur? Ni.
  • À mon avis, le # opérateur est juste mal définis. C'est donc facilement réparable: tout d'abord, faire # déterministe, et d'autre part, d'introduire un nouvel opérateur ou fonction pour obtenir le fameux comte. Fin de l'histoire... Pourquoi ont-ils pour être si têtu? 🙂
  • Pas sûr. Certes, il n'est pas le plus utile de l'opérateur, puisque vous avez à l'utiliser correctement pour être précis. Je suppose qu'il doit répondre à certains autres objectifs de la conception. Ce serait bien si il ne pourrait pas, au lieu de retourner des résultats non valides si
  • J'ai aussi eu un cas d'utilisation où j'ai besoin de savoir le nombre, dans ce cas j'ai besoin de savoir si il n'y a qu'un seul élément à gauche dans un tableau, dans ce cas, je la traiter différemment si il ya de nombreux éléments. Si la réponse est que nous les compter, c'est bien de bien; je suppose une fonction qui a eu la réponse nous aurait coûté la performance d'ailleurs (une telle fonctionnalité serait probablement besoin de lua pour tester la nouvelle et l'ancienne valeur de néant à chaque fois que nous avons établi un tableau de la valeur et ensuite mettre à jour un compteur en conséquence)
  • pour tester si il n'y a qu'une seule paire dans un tableau, utilisez next(t)~=nil and next(next(t))==nil.

InformationsquelleAutor Roman Starkov | 2010-04-24
  1. 110

    Vous avez déjà la solution de la question, le seul moyen est d'itérer l'ensemble de la table avec pairs(..).

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

    Aussi, notez que le "#" de l'opérateur définition est un peu plus compliqué que cela. Permettez-moi d'illustrer que la prise de cette table:

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

    Selon le manuel, tout de 3, 5 et 9 sont des résultats valides pour #t. La seule façon saine de l'utilisation, il est avec les tableaux d'une seule partie, sans nul valeurs.

    • Eh bien, il a dit "sans compter", mais il est possible, il n'y a pas d'autre moyen
    • J'ai encore le frisson à la mémoire de mon expérience avec Lua, quand j'ai réalisé que la valeur de retour d'un opérateur comme # n'est pas déterministe.
    • Oh, il est probable que déterministe. C'est exactement la même chose que lorsque le C standard laisse quelque peu à être mise en œuvre, les comportements définis. La raison, c'est comme cela, c'est que les différents réalisateurs pouvez choisir d'autres choix d'implémentation.
    • According to the manual, any of 3, 5 and 9 are valid results for #t. Selon le manuel, l'appel de # sur la non-séquences est undefined. Cela signifie que aucun résultat (-1, 3, 3.14, 5, 9) est valide.
    • Au sujet des résultats valides: u0b34a0f6ae est correct pour Lua 5.1, tandis que cubuspl42 est correct pour Lua 5.2. Dans les deux cas, la chose entière est complètement fou.
    • Le fait que # sur un non-séquence de ne pas générer une exception est juste l'une des choses qui rend l'utilisation de lua un peu comme couper vous-même à se sentir mieux.

    InformationsquelleAutor u0b34a0f6ae
  2. 19

    Vous pouvez définir un méta-table de suivre le nombre d'entrées, cela peut être plus rapide que l'itération si cette information est un besoin fréquemment.

    • Est-il un moyen pratique de gérer l'effacement des entrées avec cette méthode?
    • Malheureusement, il semble que l' __newindex fonction ne fait pas de feu sur le néant attributions, sauf si l'index n'existe pas, donc il semble que vous auriez à l'entonnoir d'entrée de l'enlèvement par le biais d'une fonction spéciale.
    • Vous devez stocker des données dans un tableau distinct (par exemple accessible amont pour __index et __ _ _ newindex). Puis les deux __index et __ _ _ newindex aurait le feu pour chaque accès à la table. Vous devriez vérifier si la performance est acceptable si.
    • Ah oui, et puis le prochain point d'achoppement: si vous proxy de la table, puis la normale itération par paires ne fonctionne pas. Ce sera possible pour résoudre en Lua 5.2, j'ai entendu.
    • Il y aurait de l' __paires et __ _ _ ipairs metamethods en 5.2... Si vous voulez le faire en 5.1, vous devez remplacer les paires() fonction avec votre propre. Mais c'est sans doute trop. 🙂
    InformationsquelleAutor ergosys
  3. 2

    Vous pouvez utiliser penlight bibliothèque. Cela a une fonction taille qui donne la taille réelle de la table.

    Il a mis en œuvre de nombreux de la fonction que l'on peut avoir besoin lors de la programmation et de disparus en Lua.

    Voici un exemple d'utilisation.

    > tablex = require "pl.tablex"
> a = {}
> a[2] = 2
> a[3] = 3 
> a['blah'] = 24

> #a
0

> tablex.size(a)
3
    InformationsquelleAutor Ramesh
  4. 1

    Il y a un moyen, mais il pourrait être décevant: utiliser une variable supplémentaire (ou celui de la table de champ) pour stocker le comte, et de l'augmenter à chaque fois que vous faites une insertion.

    count = 0
tbl = {}

tbl["test"] = 47
count = count + 1

tbl[1] = 48
count = count + 1

print(count)   -- prints "2"

    Il n'y a pas d'autre moyen, l'opérateur ne fonctionnera que sur le tableau-comme des tables avec des touches consécutives.

    • Cette opération peut être automatisée avec un proxy table et metamethods, comme indiqué par la ergosys réponse de
    • J'ai eu l'impression à partir de l'observation que l'proxytable/metamethods chose ne prend totalement en charge ce scénario, de sorte que je vais accepter ce qui est le meilleur moyen actuellement disponible.
    • Le comptage est la seule façon pour les tables, et en ajoutant des lignes lors de la création des tables est mieux qu'une fonction pour compter toutes les fois que vous besoin de les compter. Vous pouvez ajouter une touche à la fin avec la valeur définie pour le comte.
    InformationsquelleAutor kikito
  5. 1
    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)
    • Lors de la publication d'une réponse, il est recommandé de publier le montant minimal de code qui répond directement à une question, et expliquer comment le code répond à la question. Voir ici.
    • __newindex qu'à appeler lorsqu'une nouvelle clé de définir, donc il n'y a pas de possibilité d'appeler __newindex lorsque nous avons mis en nil à un existe clé.
    InformationsquelleAutor Sleepwom
  6. 1

    La façon la plus simple que je connaisse pour obtenir le nombre d'entrées dans une table par"#". #tableName obtient le nombre d'entrées en tant qu'ils sont numérotées:

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

    Malheureusement, si elles ne sont pas numérotées, il ne fonctionnera pas.

    InformationsquelleAutor Surge12
  7. -1

    semble que lorsque les éléments de la table est ajoutée par la méthode insert, getn sera de retour correctement. Sinon, nous devons compter tous les éléments

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

    Il permet d'imprimer 2 correctement

    InformationsquelleAutor Yongxin Zhang