在一个Lua列表中搜索项目

Question

如果我有项目的列表如下所示：

local items = { "apple", "orange", "pear", "banana" }

我

如何检查，如果“橙色”在这个名单？

在Python中我可以这样做：

if "orange" in items:
    # do something

是否有在Lua等效？

Answer 1

您可以使用像在Lua 一组从编程：

function Set (list)
  local set = {}
  for _, l in ipairs(list) do set[l] = true end
  return set
end

然后，你可以把你的列表中设置并测试成员：

local items = Set { "apple", "orange", "pear", "banana" }

if items["orange"] then
  -- do something
end

或者你也可以在列表中直接迭代：

local items = { "apple", "orange", "pear", "banana" }

for _,v in pairs(items) do
  if v == "orange" then
    -- do something
    break
  end
end

Answer 2

使用以下表示法来代替：

local items = { apple=true, orange=true, pear=true, banana=true }
if items.apple then
    ...
end

Answer 3

您所看到的第一手只有一个数据结构的Lua的缺点之一---你必须推出自己的。如果你坚持的Lua，你会逐渐积累的操纵在你喜欢做的事情的方式表函数库。我的库包括一个列表到集转换和更高的顺序列表的搜索功能：

function table.set(t) -- set of list
  local u = { }
  for _, v in ipairs(t) do u[v] = true end
  return u
end

function table.find(f, l) -- find element v of l satisfying f(v)
  for _, v in ipairs(l) do
    if f(v) then
      return v
    end
  end
  return nil
end

Answer 4

Lua中的表是更加紧密类似物Python字典而不是列表。你必须创建表基本上是字符串的基于1的索引数组。使用任何标准的搜索算法来找出一个值在数组中。另一种方法是将存储值作为表键，而不是如图所示的集执行乔恩埃里克森的讯息。

Answer 5

function valid(data, array)
 local valid = {}
 for i = 1, #array do
  valid[array[i]] = true
 end
 if valid[data] then
  return false
 else
  return true
 end
end

下面是我使用用于检查是否数据是在阵列中的功能。

Answer 6

排序的溶液中使用元表...

local function preparetable(t)
 setmetatable(t,{__newindex=function(self,k,v) rawset(self,v,true) end})
end

local workingtable={}
preparetable(workingtable)
table.insert(workingtable,123)
table.insert(workingtable,456)

if workingtable[456] then
...
end

Answer 7

这是可以使用瑞士armyknife功能：

function table.find(t, val, recursive, metatables, keys, returnBool)
    if (type(t) ~= "table") then
        return nil
    end

    local checked = {}
    local _findInTable
    local _checkValue
    _checkValue = function(v)
        if (not checked[v]) then
            if (v == val) then
                return v
            end
            if (recursive and type(v) == "table") then
                local r = _findInTable(v)
                if (r ~= nil) then
                    return r
                end
            end
            if (metatables) then
                local r = _checkValue(getmetatable(v))
                if (r ~= nil) then
                    return r
                end
            end
            checked[v] = true
        end
        return nil
    end
    _findInTable = function(t)
        for k,v in pairs(t) do
            local r = _checkValue(t, v)
            if (r ~= nil) then
                return r
            end
            if (keys) then
                r = _checkValue(t, k)
                if (r ~= nil) then
                    return r
                end
            end
        end
        return nil
    end

    local r = _findInTable(t)
    if (returnBool) then
        return r ~= nil
    end
    return r
end

如果一个值存在可以使用它来检查：

local myFruit = "apple"
if (table.find({"apple", "pear", "berry"}, myFruit)) then
    print(table.find({"apple", "pear", "berry"}, myFruit)) -- 1

您可以用它来找到问题的关键：

local fruits = {
    apple = {color="red"},
    pear = {color="green"},
}
local myFruit = fruits.apple
local fruitName = table.find(fruits, myFruit)
print(fruitName) -- "apple"

希望recursive参数是不言而喻的。

在metatables参数，可以搜索元表，以及

在keys参数使得函数查找列表中的密钥。当然，这将是无用的Lua中（你可以做fruits[key]），但recursive和metatables在一起，就成了方便。

在returnBool参数是一个安全守卫，因为当你有一个已经false为表中的一个键的表（是的，这是可能的：fruits = {false="apple"}）