Lua table.sort()排序

table.sort (table [, comp]) 对给定的table进行排序。

特别注意：

1. table中不能有nil

table.sort是排序函数，它要求要排序的目标table的必须是从1到n连续的，即中间不能有nil。

2. 重写的comp比较函数，两个值相等时不能return true

此外，当比较函数没有写的时候，table.sort默认按照lua里面的排序规则升序排序；当额外写了比较函数时，相当于用你额外写的比较函数重载了lua中自带的，当两个数相等的时候，比较函数一定要返回false！如果两个值相等都,排序函数返回true时则会报错 invalid order function for sortin

排序测试代码参考

print("---按照元素a大小排序 ---升序")
table.sort(
    ta,
    function(Fa, Fb)
        if Fa == nil or Fb == nil then
            return false
        end
        ---: 符号<:代表升序排序，符号>:代表降序排序。这就有一个特别要注意的问题，当两个数相等的时候，比较函数一定要返回false！
        return Fa.a < Fb.a
    end
)

排序测试：

--------------------------------------------------------
--------------------------------------------------------
--- 测试排序

---TableAux：tabel转字符串的脚本，文中已经给出
local TablaAux = require "TableAux"

local ta = {
    {a = 22, b = 1},
    {a = 100, b = 2},
    {a = 99, b = 3},
    {a = 44, b = 4},
    {a = 44, b = 5},
    {a = 44, b = 6},
    {a = 65, b = 7},
    {a = 78, b = 8},
    {a = 19, b = 9},
    {a = 22, b = 10},
    {a = 62, b = 11}
}

print("---输出tabal")
print(TablaAux.TableToString(ta))

print("---按照元素a大小排序 ---升序")
table.sort(
    ta,
    function(Fa, Fb)
        if Fa == nil or Fb == nil then
            return false
        end
        ---: 符号<:代表升序排序，符号>:代表降序排序。这就有一个特别要注意的问题，当两个数相等的时候，比较函数一定要返回false！
        return Fa.a < Fb.a
    end
)
print(TablaAux.TableToString(ta))

print("---按照元素a大小排序，如果相等按照元素b大小排序 ---升序")
table.sort(
    ta,
    function(Fa, Fb)
        if Fa == nil or Fb == nil then
            return false
        end
        ---: 符号<:代表升序排序，符号>:代表降序排序。这就有一个特别要注意的问题，当两个数相等的时候，比较函数一定要返回false！
        if Fa.a == Fb.a then
            return Fa.b < Fb.b
        else
            return Fa.a < Fb.a
        end
    end
)
print(TablaAux.TableToString(ta))

查看排序结果：

---输出tabal
{
[1] = 
    {
    ["a"] = 22, 
    ["b"] = 1,  
    },
[2] = 
    {
    ["a"] = 100,
    ["b"] = 2,  
    },
[3] = 
    {
    ["a"] = 99,
    ["b"] = 3,
    },
[4] =
    {
    ["a"] = 44,
    ["b"] = 4,
    },
[5] =
    {
    ["a"] = 44,
    ["b"] = 5,
    },
[6] =
    {
    ["a"] = 44,
    ["b"] = 6,
    },
[7] =
    {
    ["a"] = 65,
    ["b"] = 7,
    },
[8] =
    {
    ["a"] = 78,
    ["b"] = 8,
    },
[9] =
    {
    ["a"] = 19,
    ["b"] = 9,
    },
[10] =
    {
    ["a"] = 22,
    ["b"] = 10,
    },
[11] =
    {
    ["a"] = 62,
    ["b"] = 11,
    },
}
---按照元素a大小排序---升序

{
[1] =
    {
    ["a"] = 19,
    ["b"] = 9,
    },
[2] =
    {
    ["a"] = 22,
    ["b"] = 10,
    },
[3] =
    {
    ["a"] = 22,
    ["b"] = 1,
    },
[4] =
    {
    ["a"] = 44,
    ["b"] = 5,
    },
[5] =
    {
    ["a"] = 44,
    ["b"] = 6,
    },
[6] =
    {
    ["a"] = 44,
    ["b"] = 4,
    },
[7] =
    {
    ["a"] = 62,
    ["b"] = 11,
    },
[8] =
    {
    ["a"] = 65,
    ["b"] = 7,
    },
[9] =
    {
    ["a"] = 78,
    ["b"] = 8,
    },
[10] =
    {
    ["a"] = 99,
    ["b"] = 3,
    },
[11] =
    {
    ["a"] = 100,
    ["b"] = 2,
    },
}
---按照元素a大小排序，如果相等按照元素b大小排序---升序

{
[1] =
    {
    ["a"] = 19,
    ["b"] = 9,
    },
[2] =
    {
    ["a"] = 22,
    ["b"] = 1,
    },
[3] =
    {
    ["a"] = 22,
    ["b"] = 10,
    },
[4] =
    {
    ["a"] = 44,
    ["b"] = 4,
    },
[5] =
    {
    ["a"] = 44,
    ["b"] = 5,
    },
[6] =
    {
    ["a"] = 44,
    ["b"] = 6,
    },
[7] =
    {
    ["a"] = 62,
    ["b"] = 11,
    },
[8] =
    {
    ["a"] = 65,
    ["b"] = 7,
    },
[9] =
    {
    ["a"] = 78,
    ["b"] = 8,
    },
[10] =
    {
    ["a"] = 99,
    ["b"] = 3,
    },
[11] =
    {
    ["a"] = 100,
    ["b"] = 2,
    },
}

table 转字符串 : TableAux

---@class table 的辅助
local TableAux = {}
local self = TableAux

---------------- table转字符串 ----------------
local function PrintSpace(p, count)
    for ii = 1, count do
        p("    ")
    end
end

local function PrintTable2(o, f, b, deep)
    p = f or io.write
    b = b or false

    if type(f) ~= "function" and f ~= nil then
        p(string.format("expected second argument %s is a function", tostring(f)))
    end
    if type(b) ~= "boolean" and b ~= nil then
        p(string.format("expected third argument %s is a boolean", tostring(b)))
    end

    if type(o) == "number" or type(o) == "function" or type(o) == "boolean" or type(o) == "nil" then
        p(tostring(o))
    elseif type(o) == "string" then
        p(string.format("%q", o))
    elseif type(o) == "table" then
        p("\n")
        PrintSpace(p, deep)
        p("{\n")
        for k, v in pairs(o) do
            PrintSpace(p, deep)
            if b then
                p("[")
            end
            PrintTable2(k, p, b, deep + 1)
            if b then
                p("]")
            end
            p(" = ")
            PrintTable2(v, p, b, deep + 1)
            p(",\n")
        end
        PrintSpace(p, deep)
        p("}")
    end
end

--- table转字符串 用于调试输出
--- @return string
function TableAux.TableToString(t)
    local printTabStr = ""
    PrintTable2(
        t,
        function(str)
            printTabStr = printTabStr .. str
        end,
        true,
        0
    )
    if printTabStr == "" then
    --print("LuaUtil.PrintTable printTabStr is nil")
    end
    return printTabStr
    --print(printTabStr)
end
---------------- table转字符串 ----------------

--- 获取table元素个数
--- @return number
function TableAux.TableCount(t)
    local num = 0
    if type(t) == "table" then
        for k, v in pairs(t) do
            num = num + 1
        end
    end
    return num
end

-- _G.TableAux = TableAux
return TableAux