Sorting Lua：按颜色排序的自定义迭代器？

我想创建一个自定义迭代器，该迭代器将根据此表中的颜色和数值进行排序：

t1 = {{"green", 1},{"red", 3},{"green", 2},{"yellow", 5},{"red", 4}}

for i, v in ipairs(t1) do
     Note(i," ",v[1]," ",v[2])
end

现在，这将输出：

1 green 1
2 red 3
3 green 2
4 yellow 5
5 red 4

我期望的输出是：

4 yellow 5
3 green 2
1 green 1
5 red 4
2 red 3

我可以用自定义迭代器实现这一点吗

编辑：我本来想做这样的事情，但我似乎无法解决：

function sort_colours(t) -- sort table
    local T = { }
    for i, v in ipairs(t) do
        T[#T + 1] = { i = i, v = v }
    end

    local order = {yellow = 1, green = 2, red = 3} -- desired order for colors
table.sort(T, function(a, b)
    -- since you seem to want large-to-small when colors are the same,
    -- use b[2] < a[2] comparison
    if a[1] == b[1] then return b[2] < a[2] end
    return order[a[1]] < order[b[1]]
  end)
    for i = 1, #T do
        T[i] = T[i].i
    end
        local i = 0
    return function() -- iterator function
        i = i + 1
        if T[i] then
            return T[i], t[T[i]]
        end
    end
end

local t1 = {{"green", 1},{"red", 3},{"green", 2},{"yellow", 5},{"red", 4}}

for k, v in sort_colours(t1) do print(k, v[1], v[2]) end

函数排序\u颜色（t）--排序表
局部T={}
对于ipairs（t）do中的i，v
T[#T+1]={i=i，v=v}
结束
局部顺序={yellow=1，green=2，red=3}--所需的颜色顺序
表.排序（T，函数（a，b）
--因为当颜色相同时，你似乎想要从大到小，
--使用b[2]

您可以按所需顺序保留表格，并在使用标准的

ipairs

进行迭代之前使用该表格：

local t1 = {{"green", 1},{"red", 3},{"green", 2},{"yellow", 5},{"red", 4}}
local order = {yellow = 1, green = 2, red = 3} -- desired order for colors
table.sort(t1, function(a, b)
    -- since you seem to want large-to-small when colors are the same,
    -- use b[2] < a[2] comparison
    if a[1] == b[1] then return b[2] < a[2] end
    return order[a[1]] < order[b[1]]
  end)
for k, v in ipairs(t1) do print(k, v[1], v[2]) end -- show the result

---

您可以按所需顺序保留一个表，并在使用标准的

ipairs

进行迭代之前使用该表：

local t1 = {{"green", 1},{"red", 3},{"green", 2},{"yellow", 5},{"red", 4}}
local order = {yellow = 1, green = 2, red = 3} -- desired order for colors
table.sort(t1, function(a, b)
    -- since you seem to want large-to-small when colors are the same,
    -- use b[2] < a[2] comparison
    if a[1] == b[1] then return b[2] < a[2] end
    return order[a[1]] < order[b[1]]
  end)
for k, v in ipairs(t1) do print(k, v[1], v[2]) end -- show the result

---

你的尝试非常接近。您只需记住，比较函数中的

a

和

b

参数到

表中。sort

指的是

T

数组中的元素，它们有

i

和

v

字段（而

v

字段包含您实际要比较的值）：

只要原始数组在迭代过程中不发生变化，这两种方法的工作原理是相同的。如果确实如此（因为您添加/删除了元素，或者因为涉及了行为不好的

\u索引

元方法），那么第一种方法更容易预测，因为它可以处理数据的快照

对于样本数据，两种情况下的输出相同：

4   yellow  5
3   green   2
1   green   1
5   red 4
2   red 3

---

你的尝试非常接近。您只需记住，比较函数中的

a

和

b

参数到

表中。sort

指的是

T

数组中的元素，它们有

i

和

v

字段（而

v

字段包含您实际要比较的值）：

只要原始数组在迭代过程中不发生变化，这两种方法的工作原理是相同的。如果确实如此（因为您添加/删除了元素，或者因为涉及了行为不好的

\u索引

元方法），那么第一种方法更容易预测，因为它可以处理数据的快照

对于样本数据，两种情况下的输出相同：

4   yellow  5
3   green   2
1   green   1
5   red 4
2   red 3

---

在不知道代码的原因或如何实现它的情况下，我制作了一个迭代器，它应该在大部分时间都能工作。除非你使用克隆真的很奇怪，就像siffiejoe在评论中指出的那样

我的方法是创建表的克隆并对其排序，然后返回一个迭代器，以便您可以在泛型中调用它：

t1 = {{"green", 1},{"red", 3},{"green", 2},{"yellow", 5},{"red", 4}}

function ByColor(t,order)
   local order = order or {yellow=1,green=2,red=3}
   local nt = {table.unpack(t)}
   table.sort(nt, function(a,b)
      order[a[1]] < order[b[1]] or order[a[1]] == order[b[1]] and a[2] > b[2]
   end)
   local helper = 1
   return function(ti,v)
      local nxt = nt[helper]
      helper = helper + 1
      for i,v in ipairs(t) do
         if v == nxt then
            return i,nxt
         end
      end
      return nil
   end
end

for i,v in ByColor(t1) do
   print(i,v[1],v[2])
end

t1={{“绿色”，1}，{“红色”，3}，{“绿色”，2}，{“黄色”，5}，{“红色”，4}
函数按颜色（t，顺序）
局部顺序=顺序或{黄色=1，绿色=2，红色=3}
本地nt={table.unpack（t）}
表.排序（nt，函数（a，b）
订单[a[1]<订单[b[1]]或订单[a[1]==订单[b[1]]和订单[2]>b[2]
(完)
本地助手=1
返回函数（ti，v）
本地nxt=nt[helper]
helper=helper+1
对于ipairs（t）do中的i，v
如果v==nxt，那么
返回i，nxt
结束
结束
归零
结束
结束
对于i，v，在ByColor（t1）do中
打印（i，v[1]，v[2]）
结束

---

它返回表中的实际索引，并为顺序提供可选参数，假设您要从黄色/绿色/红色切换。

在不知道代码的原因或如何实现代码的情况下，我制作了一个迭代器，该迭代器大部分时间都可以工作。除非你使用克隆真的很奇怪，就像siffiejoe在评论中指出的那样

我的方法是创建表的克隆并对其排序，然后返回一个迭代器，以便您可以在泛型中调用它：

t1 = {{"green", 1},{"red", 3},{"green", 2},{"yellow", 5},{"red", 4}}

function ByColor(t,order)
   local order = order or {yellow=1,green=2,red=3}
   local nt = {table.unpack(t)}
   table.sort(nt, function(a,b)
      order[a[1]] < order[b[1]] or order[a[1]] == order[b[1]] and a[2] > b[2]
   end)
   local helper = 1
   return function(ti,v)
      local nxt = nt[helper]
      helper = helper + 1
      for i,v in ipairs(t) do
         if v == nxt then
            return i,nxt
         end
      end
      return nil
   end
end

for i,v in ByColor(t1) do
   print(i,v[1],v[2])
end

t1={{“绿色”，1}，{“红色”，3}，{“绿色”，2}，{“黄色”，5}，{“红色”，4}
函数按颜色（t，顺序）
局部顺序=顺序或{黄色=1，绿色=2，红色=3}
本地nt={table.unpack（t）}
表.排序（nt，函数（a，b）
订单[a[1]<订单[b[1]]或订单[a[1]==订单[b[1]]和订单[2]>b[2]
(完)
本地助手=1
返回函数（ti，v）
本地nxt=nt[helper]
helper=helper+1
对于ipairs（t）do中的i，v
如果v==nxt，那么
返回i，nxt
结束
结束
归零
结束
结束
对于i，v，在ByColor（t1）do中
打印（i，v[1]，v[2]）
结束

---

它返回表中的实际索引，并为顺序提供可选参数，假设您要从黄色/绿色/红色切换。

有没有一种方法可以做到这一点，而不会改变表的索引方式？有没有一种方法可以做到这一点，而不会改变表的索引方式？为什么在绿色/红色之前是黄色？为什么先绿后红？我很难理解那部分背后的逻辑，可能是吧。但首先是什么颜色？我喜欢红色：）它应该像一个红绿灯！为什么绿色/红色之前是黄色？为什么先绿后红？我很难理解那部分背后的逻辑，可能是吧。但首先是什么颜色？我喜欢红色：）它应该像一个红绿灯！对表进行排序，然后通过

next

对其进行迭代没有多大意义，因为

next

不能保证特定的顺序。此外，如果原始表中存在相同的元素，则计算原始索引的方法也将失败（例如，尝试

t1[#t1+1]=t1[3]

。并且您非常喜欢

{tabl]