Comment vérifier si une table contient un élément de Lua?

Question

Y at-il une méthode pour vérifier si une table contient une valeur? J'ai ma propre fonction (naïve), mais je me demandais si quelque chose « officiel » existe pour cela? Ou quelque chose de plus efficace ...

function table.contains(table, element)
  for _, value in pairs(table) do
    if value == element then
      return true
    end
  end
  return false
end

Par ailleurs, la principale raison pour laquelle je suis à l'aide des fonctions est d'utiliser des tables comme des ensembles, soit sans éléments en double. Y at-il autre chose que je pourrais utiliser?

Answer 1

Vous pouvez mettre les valeurs que les clés de la table. Par exemple:

function addToSet(set, key)
    set[key] = true
end

function removeFromSet(set, key)
    set[key] = nil
end

function setContains(set, key)
    return set[key] ~= nil
end

Il y a un exemple plus riche en fonctionnalités .

Answer 2

Compte tenu de votre représentation, votre fonction est aussi efficace que l'on peut faire. Bien sûr, comme il est indiqué par d'autres (et telle qu'elle est pratiquée dans les langues plus que Lua), la solution à votre problème réel est de changer la représentation. Lorsque vous avez des tables et que vous voulez ensembles, vous tourner les tables en jeux en utilisant l'élément de jeu comme la clé et true la valeur. +1 à interjay.

Answer 3

Je ne peux pas penser à une autre façon de comparer les valeurs, mais si vous utilisez l'élément du jeu comme la clé, vous pouvez définir la valeur à autre chose que nul. Ensuite, vous obtenez rapidement sans avoir des recherches pour rechercher la table entière.

Answer 4

Je sais que c'est un ancien poste, mais je voulais ajouter quelque chose pour la postérité. La façon simple de traiter la question que vous avez à faire est une autre table, de la valeur à la clé.

à savoir

. vous avez 2 tables qui ont la même valeur, l'un pointant une direction, un autre pointant.

function addValue(key, value)
    if (value == nil) then
        removeKey(key)
        return
    end
    _primaryTable[key] = value
    _secodaryTable[value] = key
end

function removeKey(key)
    local value = _primaryTable[key]
    if (value == nil) then
        return
    end
    _primaryTable[key] = nil
    _secondaryTable[value] = nil
end

function getValue(key)
    return _primaryTable[key]
end

function containsValue(value)
    return _secondaryTable[value] ~= nil
end

Vous pouvez ensuite interroger la nouvelle table pour voir si elle a le « élément » clé. Cela évite la nécessité de parcourir toutes les valeurs de l'autre table.

S'il se avère que vous ne pouvez pas utiliser réellement le « élément » comme une clé, car ce n'est pas une chaîne par exemple, puis ajoutez une somme de contrôle ou tostring sur elle par exemple, puis l'utiliser comme clé.

Pourquoi voulez-vous faire? Si vos tables sont très grandes, la quantité de temps à itérer tous les éléments seront importants, qui vous empêche de le faire très souvent. La surcharge de la mémoire supplémentaire sera relativement faible, car il sera stocker 2 pointeurs vers le même objet, plutôt que 2 copies du même objet. Si vos tables sont très petites, alors il importe beaucoup moins, en fait, il peut même être plus rapide à itérer que d'avoir une autre carte recherche.

Le libellé de la question, mais suggère fortement que vous avez un grand nombre d'articles à traiter.