List 在Lua列表中搜索项目

如果我有这样的项目列表：

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

如何检查“橙色”是否在此列表中

在Python中，我可以做到：

if "orange" in items:
    # do something

---

Lua中是否有一个等价物？

您可以使用以下类似集合的内容：

然后，您可以将列表放入集合并测试成员资格：

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

---

Lua表更像Python字典，而不是列表。您创建的表本质上是一个基于1的索引字符串数组。使用任何标准搜索算法查找数组中是否有值。另一种方法是将值存储为表键，如Jon Ericson的post的set实现所示。

使用以下表示法：

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

---

您亲眼看到了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

---

使用元表的解决方案排序

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

---

这是我用来检查数据是否在数组中的函数。

这是一个瑞士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

参数能说明问题

元表

参数也允许您搜索元表

keys

参数使函数在列表中查找键。当然，这在Lua中是没有用的（您可以只做

fruits[key]

），但是再加上

recursive

和

metatables

，它就变得很方便了

---

returnBool

参数是一个安全保护，当您的表中有

false

作为表中的键时（是的，这是可能的：

fruits={false=“apple”}

）

您可以使用此解决方案：

items = { 'a', 'b' }
for k,v in pairs(items) do 
 if v == 'a' then 
  --do something
 else 
  --do something
 end
end

或

---

按照您的意愿编写，但直接在列表上迭代要比生成pairs（）或ipairs（）更快

发现橙色

---

找不到汽车

可以使用一个简单的功能：

• 如果在表中找不到该项，则返回nil
• 如果在表中找到项，则返回项的索引

上述代码的输出将是

3
nil

---

这是在Lua中创建一组（纯数学意义上）事物的最佳方法。好极了！然而，由于它没有顺序的概念，如果列表顺序很重要的话，它不一定能回答“在Lua列表中搜索一个项目？”这个一般性问题。这让人感觉更加优雅。只是用它创建了一个表，看起来像

{thingIAmLookingFor:true，secondThingIAmLookingFor:true}

这是一个很好的答案，但它没有解决这个问题的一般问题：任意字符串列表怎么样？Python中items中的“橙色”对应的

，不需要构建自己的专用列表。有没有Lua方法可以获取任何字符串列表并以这种方式重建它？@CalculatorFeline一些键（有数字、空格、重音…）需要括号表示法。e、 g.：
localitems={[42]=true，['foo-bar']=true，['href\']=true}
。实际上，不带括号的符号是一种合成糖（通常在Lua中）。您可能会感兴趣。这与
localworkingtable={}workingtable[123]=true workingtable[456]=true如果workingtable[456]那么。。。结束
虽然这段代码可能会解决问题，但一个好的答案也应该解释代码的作用以及它是如何帮助的。
function table.find(t,value)
    if t and type(t)=="table" and value then
        for _, v in ipairs (t) do
            if v == value then
                return true;
            end
        end
        return false;
    end
    return false;
end

items = { 'a', 'b' }
for k,v in pairs(items) do 
 if v == 'a' then 
  --do something
 else 
  --do something
 end
end


items = {'a', 'b'}
for k,v in pairs(items) do 
  while v do
    if v == 'a' then 
      return found
    else 
      break
    end
  end 
 end 
return nothing

#! /usr/bin/env lua

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

local function locate( table, value )
    for i = 1, #table do
        if table[i] == value then print( value ..' found' ) return true end
    end
    print( value ..' not found' ) return false
end

locate( items, 'orange' )
locate( items, 'car' )

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

local function search_value (tbl, val)
    for i = 1, #tbl do
        if tbl[i] == val then
            return i
        end
    end
    return nil
end

print(search_value(items, "pear"))
print(search_value(items, "cherry"))

3
nil