Left alignment function of Lua language (handwriting)

One 、 Preface ：

lua The tabs of are still not strong enough , When a line is very big , It's all messed up behind . This language is not like python There are also rich libraries that can be called . Can't , Write one by hand .

Two 、 The code is as follows ：

The logic is simple , Is to traverse the data first , Record the maximum length of each column .
And then according to The maximum length of the front row - Specific data length Get the blank space you need to fill ;

--  Concatenate a two-dimensional array into a string in the form of left alignment and return 
function leftAlignString(data)
    local data2 = {
    }
    local colLenList ={
    }

    local len, vlen = #data[1]
    for i, v in ipairs(data) do
        data2[i] = {
    }
        for vi, vd in ipairs(v) do
            if type(vd) ~= "string" then
                vd = tostring(vd)
            end
            data2[i][#data2[i] + 1] = vd
            if vi ~= len then
                data2[i][#data2[i] + 1] = ""
                -- if i == 1then
                -- colLenList[vi] = math.max(colLenList[vi] or 0, #vd / 3 * 2 + 4)
                -- else
                    -- if #vd % 2 == 1 then
                    -- vlen = #vd + 1
                    -- else
                        vlen = #vd
                    -- end
                    colLenList[vi] = math.max(colLenList[vi] or 0, vlen + 2)
                -- end
            else
                data2[i][#data2[i] + 1] = "\n"
            end
        end
    end



    --  Fill in the blanks 
    function bEmpty(count)
        local str = ""
        local fourEmpty = " ";
        while count > 0 do 
            if count >= 4 then
                str = str .. fourEmpty
                count = count - 4
            else
                str = str .. " "
                count = count - 1
            end
        end
        return str
    end

    local empty = 0

    for i, v in ipairs(data2) do
        for k = 1, (len - 1) * 2 - 1, 2 do
            -- if i == 1 then
            -- -- print(v[k], k, colLenList[math.ceil(k / 2)], #v[k] / 3 * 2)
            -- data2[i][k + 1] = bEmpty(colLenList[math.ceil(k / 2)] - #v[k] / 3 * 2)
            -- else
                -- print(v[k], k, colLenList[math.ceil(k / 2)], #v[k])
            data2[i][k + 1] = bEmpty(colLenList[math.ceil(k / 2)] - #v[k])
            -- end
        end
        data2[i] = table.concat(v)
    end
    return table.concat(data2)
end


local data = {
    
    {
    "index", "itemID", "randValue", "changeWeight", "initWeight", "isCompenate", "compenateData"},
    {
    1,52301,357229,1000000,1000000,false,"{}"},
    {
    1,52301,357229,1000000,1044400000,false,"{}"},
    {
    1,52301,357229,100000440,1000000,false,"{}"},
    {
    1,52301,357444229,1000000,1000000,false,"{}"},
    {
    2,51302,502332,26000,1875, false, "{}"},
}

data2 = leftAlignString(data)
print(data2)

3、 ... and 、 ending

The logic is simple , It took a little time to write . Just use what you need
If this method is aligned with Chinese, there will still be some deviation , The comments in the code are Slightly correct the deviation Methods , If you cancel the comment, you can use .