Comment vider une table sur la console?

109

J'ai du mal à afficher le contenu d'une table qui contient des tables imbriquées (n-deep). Je voudrais simplement le vider sur std ou sur la console via une printdéclaration ou quelque chose de rapide et sale, mais je ne peux pas comprendre comment. Je cherche l'équivalent approximatif que j'obtiendrais lors de l'impression d'un NSDictionaryutilisant gdb.

Falaise
la source

Réponses:

56

N'hésitez pas à parcourir le Wiki Lua sur la sérialisation des tables . Il répertorie plusieurs façons de vider une table sur la console.

Il vous suffit de choisir celui qui vous convient le mieux. Il y a plusieurs façons de le faire, mais je finis généralement par utiliser celle de Penlight :

> t = { a = { b = { c = "Hello world!", 1 }, 2, d = { 3 } } }
> require 'pl.pretty'.dump(t)
{
  a = {
    d = {
      3
    },
    b = {
      c = "Hello world!",
      1
    },
    2
  }
}
Michal Kottman
la source
6
Question idiote et encore plus débutante: comment puis-je installer une extension comme pl.pretty? Ce serait bien si je pouvais simplement faire quelque chose comme une installation de gemme sans avoir à dérouler des boules de goudron et à trouver l'endroit idéal sur mon HD pour situer les choses. Existe-t-il un "do-it-this-way" rapide / indolore?
Cliff
1
Dah, j'aurais dû regarder la page d'accueil avant de poster ce dernier commentaire! L'installation n'est pas aussi rapide / indolore que je l'espérais mais pas trop mal.
Cliff
la lampe-stylo met en lumière ce que je cherchais!
Cliff
7
@Cliff luarocks pour installer penlight
vagabond
101

Je sais que cette question a déjà été marquée comme réponse, mais permettez-moi de brancher ma propre bibliothèque ici. Il s'appelle inspect.lua, et vous pouvez le trouver ici:

https://github.com/kikito/inspect.lua

C'est juste un seul fichier que vous pouvez exiger de n'importe quel autre fichier. Il renvoie une fonction qui transforme toute valeur Lua en une chaîne lisible par l'homme:

local inspect = require('inspect')

print(inspect({1,2,3})) -- {1, 2, 3}
print(inspect({a=1,b=2})
-- {
--   a = 1
--   b = 2
-- }

Il indente correctement les sous-tables et gère correctement les «tables récursives» (tables qui contiennent des références à elles-mêmes), afin de ne pas entrer dans des boucles infinies. Il trie les valeurs de manière sensée. Il imprime également des informations métatable.

Cordialement!

kikito
la source
Vous devriez peut-être ajouter votre bibliothèque au Wiki Lua . Je vois que votre bibliothèque imprime également des métatables, ce que les autres bibliothèques ne font pas.
Michal Kottman
Le fait est que inspect.lua ne rentre pas vraiment dans la catégorie "sérialisation". Le texte qu'il renvoie n'est pas un code Lua valide; il est censé être utilisé pour le débogage / lecture humaine. Je suppose que je pourrais ajouter un petit lien à la fin ou quelque chose comme ça.
kikito
1
Ajout d'inspect.lua au wiki.
kikito
Veuillez mettre ceci sur luarocks
Hack-R
3
@ Hack-R c'est sur luarocks:luarocks install inspect
kikito
86

J'ai trouvé celui-ci utile. Parce que si la récursivité, il peut également imprimer des tables imbriquées. Cela ne donne pas le plus joli formatage dans la sortie, mais pour une fonction aussi simple, il est difficile de battre pour le débogage.

function dump(o)
   if type(o) == 'table' then
      local s = '{ '
      for k,v in pairs(o) do
         if type(k) ~= 'number' then k = '"'..k..'"' end
         s = s .. '['..k..'] = ' .. dump(v) .. ','
      end
      return s .. '} '
   else
      return tostring(o)
   end
end

par exemple

local people = {
   {
      name = "Fred",
      address = "16 Long Street",
      phone = "123456"
   },

   {
      name = "Wilma",
      address = "16 Long Street",
      phone = "123456"
   },

   {
      name = "Barney",
      address = "17 Long Street",
      phone = "123457"
   }

}

print("People:", dump(people))

Produit la sortie suivante:

Personnes: {[1] = {["address"] = 16 Long Street, ["phone"] = 123456, ["name"] = Fred,}, [2] = {["address"] = 16 Long Street , ["phone"] = 123456, ["name"] = Wilma,}, [3] = {["address"] = 17 Long Street, ["phone"] = 123457, ["name"] = Barney, },}

Mat
la source
1
Bravo pour partager quelque chose qui n'a pas besoin d'une bibliothèque externe.
Julian Knight
Sur une très grande table, votre fonction génère une erreur de stackoverflow
Herrgott
21

trouvé ceci:

-- Print contents of `tbl`, with indentation.
-- `indent` sets the initial level of indentation.
function tprint (tbl, indent)
  if not indent then indent = 0 end
  for k, v in pairs(tbl) do
    formatting = string.rep("  ", indent) .. k .. ": "
    if type(v) == "table" then
      print(formatting)
      tprint(v, indent+1)
    elseif type(v) == 'boolean' then
      print(formatting .. tostring(v))      
    else
      print(formatting .. v)
    end
  end
end

à partir d'ici https://gist.github.com/ripter/4270799

fonctionne plutôt bien pour moi ...

JCH2k
la source
19

La plupart des fonctions de table d'impression pure lua que j'ai vues ont un problème de récursivité profonde et ont tendance à provoquer un débordement de pile lorsqu'elles vont trop loin. Cette fonction de table d'impression que j'ai écrite n'a pas ce problème. Il devrait également être capable de gérer des tables très volumineuses en raison de la façon dont il gère la concaténation. Dans mon utilisation personnelle de cette fonction, il a généré 63k lignes dans un fichier en une seconde environ.

La sortie conserve également la syntaxe lua et le script peut facilement être modifié pour un stockage persistant simple en écrivant la sortie dans un fichier si elle est modifiée pour permettre uniquement le formatage des types de données nombre, booléen, chaîne et table.

function print_table(node)
    local cache, stack, output = {},{},{}
    local depth = 1
    local output_str = "{\n"

    while true do
        local size = 0
        for k,v in pairs(node) do
            size = size + 1
        end

        local cur_index = 1
        for k,v in pairs(node) do
            if (cache[node] == nil) or (cur_index >= cache[node]) then

                if (string.find(output_str,"}",output_str:len())) then
                    output_str = output_str .. ",\n"
                elseif not (string.find(output_str,"\n",output_str:len())) then
                    output_str = output_str .. "\n"
                end

                -- This is necessary for working with HUGE tables otherwise we run out of memory using concat on huge strings
                table.insert(output,output_str)
                output_str = ""

                local key
                if (type(k) == "number" or type(k) == "boolean") then
                    key = "["..tostring(k).."]"
                else
                    key = "['"..tostring(k).."']"
                end

                if (type(v) == "number" or type(v) == "boolean") then
                    output_str = output_str .. string.rep('\t',depth) .. key .. " = "..tostring(v)
                elseif (type(v) == "table") then
                    output_str = output_str .. string.rep('\t',depth) .. key .. " = {\n"
                    table.insert(stack,node)
                    table.insert(stack,v)
                    cache[node] = cur_index+1
                    break
                else
                    output_str = output_str .. string.rep('\t',depth) .. key .. " = '"..tostring(v).."'"
                end

                if (cur_index == size) then
                    output_str = output_str .. "\n" .. string.rep('\t',depth-1) .. "}"
                else
                    output_str = output_str .. ","
                end
            else
                -- close the table
                if (cur_index == size) then
                    output_str = output_str .. "\n" .. string.rep('\t',depth-1) .. "}"
                end
            end

            cur_index = cur_index + 1
        end

        if (size == 0) then
            output_str = output_str .. "\n" .. string.rep('\t',depth-1) .. "}"
        end

        if (#stack > 0) then
            node = stack[#stack]
            stack[#stack] = nil
            depth = cache[node] == nil and depth + 1 or depth - 1
        else
            break
        end
    end

    -- This is necessary for working with HUGE tables otherwise we run out of memory using concat on huge strings
    table.insert(output,output_str)
    output_str = table.concat(output)

    print(output_str)
end

Voici un exemple:

local t = {
    ["abe"] = {1,2,3,4,5},
    "string1",
    50,
    ["depth1"] = { ["depth2"] = { ["depth3"] = { ["depth4"] = { ["depth5"] = { ["depth6"] = { ["depth7"]= { ["depth8"] = { ["depth9"] = { ["depth10"] = {1000}, 900}, 800},700},600},500}, 400 }, 300}, 200}, 100},
    ["ted"] = {true,false,"some text"},
    "string2",
    [function() return end] = function() return end,
    75
}

print_table(t)

Production:

{
    [1] = 'string1',
    [2] = 50,
    [3] = 'string2',
    [4] = 75,
    ['abe'] = {
        [1] = 1,
        [2] = 2,
        [3] = 3,
        [4] = 4,
        [5] = 5
    },
    ['function: 06472B70'] = 'function: 06472A98',
    ['depth1'] = {
        [1] = 100,
        ['depth2'] = {
            [1] = 200,
            ['depth3'] = {
                [1] = 300,
                ['depth4'] = {
                    [1] = 400,
                    ['depth5'] = {
                        [1] = 500,
                        ['depth6'] = {
                            [1] = 600,
                            ['depth7'] = {
                                [1] = 700,
                                ['depth8'] = {
                                    [1] = 800,
                                    ['depth9'] = {
                                        [1] = 900,
                                        ['depth10'] = {
                                            [1] = 1000
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    },
    ['ted'] = {
        [1] = true,
        [2] = false,
        [3] = 'some text'
    }
}
Alundaio
la source
tabla fonction est trop compliquée. C'est fondamentalement juste string.repeat('\t', amt)mais beaucoup moins performant.
val dit Réintégrer Monica
6

Comme mentionné précédemment, vous devez l'écrire. Voici ma version humble: (une super basique)

function tprint (t, s)
    for k, v in pairs(t) do
        local kfmt = '["' .. tostring(k) ..'"]'
        if type(k) ~= 'string' then
            kfmt = '[' .. k .. ']'
        end
        local vfmt = '"'.. tostring(v) ..'"'
        if type(v) == 'table' then
            tprint(v, (s or '')..kfmt)
        else
            if type(v) ~= 'string' then
                vfmt = tostring(v)
            end
            print(type(t)..(s or '')..kfmt..' = '..vfmt)
        end
    end
end

exemple:

local mytbl = { ['1']="a", 2, 3, b="c", t={d=1} }
tprint(mytbl)

sortie (Lua 5.0):

table[1] = 2
table[2] = 3
table["1"] = "a"
table["t"]["d"] = 1
table["b"] = "c"
Totoka
la source
1
Très original! Je l'aime.
Jack Giffin
2

Ceci est ma version qui prend en charge l'exclusion des tables et des données utilisateur

-- Lua Table View by Elertan
table.print = function(t, exclusions)
    local nests = 0
    if not exclusions then exclusions = {} end
    local recurse = function(t, recurse, exclusions)
        indent = function()
            for i = 1, nests do
                io.write("    ")
            end
        end
        local excluded = function(key)
            for k,v in pairs(exclusions) do
                if v == key then
                    return true
                end
            end
            return false
        end
        local isFirst = true
        for k,v in pairs(t) do
            if isFirst then
                indent()
                print("|")
                isFirst = false
            end
            if type(v) == "table" and not excluded(k) then
                indent()
                print("|-> "..k..": "..type(v))
                nests = nests + 1
                recurse(v, recurse, exclusions)
            elseif excluded(k) then
                indent()
                print("|-> "..k..": "..type(v))
            elseif type(v) == "userdata" or type(v) == "function" then
                indent()
                print("|-> "..k..": "..type(v))
            elseif type(v) == "string" then
                indent()
                print("|-> "..k..": ".."\""..v.."\"")
            else
                indent()
                print("|-> "..k..": "..v)
            end
        end
        nests = nests - 1
    end

    nests = 0
    print("### START TABLE ###")
    for k,v in pairs(t) do
        print("root")
        if type(v) == "table" then
            print("|-> "..k..": "..type(v))
            nests = nests + 1
            recurse(v, recurse, exclusions)
        elseif type(v) == "userdata" or type(v) == "function" then
            print("|-> "..k..": "..type(v))
        elseif type(v) == "string" then
            print("|-> "..k..": ".."\""..v.."\"")
        else
            print("|-> "..k..": "..v)
        end
    end
    print("### END TABLE ###")
end

Ceci est un exemple

t = {
    location = {
       x = 10,
       y = 20
    },
    size = {
      width = 100000000,
      height = 1000,
    },
    name = "Sidney",
    test = {
        hi = "lol",
    },
    anotherone = {
        1, 
        2, 
        3
    }
}

table.print(t, { "test" })

Impressions:

   ### START TABLE ###
root
|-> size: table
    |
    |-> height: 1000
    |-> width: 100000000
root
|-> location: table
    |
    |-> y: 20
    |-> x: 10
root
|-> anotherone: table
    |
    |-> 1: 1
    |-> 2: 2
    |-> 3: 3
root
|-> test: table
    |
    |-> hi: "lol"
root
|-> name: "Sidney"
### END TABLE ###

Notez que la racine ne supprime pas les exclusions

Elertan
la source
2

Formater en JSON (vous pouvez "embellir" dans l'IDE plus tard):

local function format_any_value(obj, buffer)
    local _type = type(obj)
    if _type == "table" then
        buffer[#buffer + 1] = '{"'
        for key, value in next, obj, nil do
            buffer[#buffer + 1] = tostring(key) .. '":'
            format_any_value(value, buffer)
            buffer[#buffer + 1] = ',"'
        end
        buffer[#buffer] = '}' -- note the overwrite
    elseif _type == "string" then
        buffer[#buffer + 1] = '"' .. obj .. '"'
    elseif _type == "boolean" or _type == "number" then
        buffer[#buffer + 1] = tostring(obj)
    else
        buffer[#buffer + 1] = '"???' .. _type .. '???"'
    end
end

Usage:

local function format_as_json(obj)
    if obj == nil then return "null" else
        local buffer = {}
        format_any_value(obj, buffer)
        return table.concat(buffer)
    end
end

local function print_as_json(obj)
    print(_format_as_json(obj))
end

print_as_json {1, 2, 3}
print_as_json(nil)
print_as_json("string")
print_as_json {[1] = 1, [2] = 2, three = { { true } }, four = "four"}

BTW, j'ai également écrit plusieurs autres solutions: une très rapide et une avec des caractères spéciaux s'échappant: https://github.com/vn971/fast_json_encode

VasiliNovikov
la source
C'est en fait ce que je cherchais même si ce n'était pas spécifiquement ce que l'opératrice demandait. Merci pour une solution simple. Facilite l'utilisation dans les environnements Lua limités par l'espace comme NodeMCU.
Sawtaytoes
1

Vous devez le coder vous-même, j'en ai peur. J'ai écrit ceci, et cela peut vous être utile

function printtable(table, indent)

  indent = indent or 0;

  local keys = {};

  for k in pairs(table) do
    keys[#keys+1] = k;
    table.sort(keys, function(a, b)
      local ta, tb = type(a), type(b);
      if (ta ~= tb) then
        return ta < tb;
      else
        return a < b;
      end
    end);
  end

  print(string.rep('  ', indent)..'{');
  indent = indent + 1;
  for k, v in pairs(table) do

    local key = k;
    if (type(key) == 'string') then
      if not (string.match(key, '^[A-Za-z_][0-9A-Za-z_]*$')) then
        key = "['"..key.."']";
      end
    elseif (type(key) == 'number') then
      key = "["..key.."]";
    end

    if (type(v) == 'table') then
      if (next(v)) then
        printf("%s%s =", string.rep('  ', indent), tostring(key));
        printtable(v, indent);
      else
        printf("%s%s = {},", string.rep('  ', indent), tostring(key));
      end 
    elseif (type(v) == 'string') then
      printf("%s%s = %s,", string.rep('  ', indent), tostring(key), "'"..v.."'");
    else
      printf("%s%s = %s,", string.rep('  ', indent), tostring(key), tostring(v));
    end
  end
  indent = indent - 1;
  print(string.rep('  ', indent)..'}');
end
Borodine
la source
1
Merci d'avoir répondu. J'ai essayé ceci et j'obtiens: tentative d'appeler le 'tri' global (une valeur nulle)
Cliff
Changer sorten table.sort... Il doit y avoir un local sort = table.sortquelque part dans le code d'où cela a été pris.
Michal Kottman
Il faut être un peu imaginatif! Un certain nombre de symboles sont copiés de l'espace table de la bibliothèque vers _G pour plus de commodité. sortest une copie de table.sort, strrepest string.rep, strmatchest string.matchetc. Faites-moi savoir s'il y en a d'autres et je modifierai ma réponse.
Borodin
Je suis désolé, j'ai aussi un filet assez profond de tables car mes propres tentatives de récurer la structure ont rencontré un débordement de pile. (Sans jeu de mots!) Je me cognais la tête en essayant de dérouler ma récursion et d'utiliser des appels de queue appropriés, mais j'ai été frustré à quel point j'ai posté ici.
Cliff
Vous ne pouvez pas en général supprimer la récursivité d'une telle fonction, car elle n'est pas récursive de fin. Utilisez soit un Lua construit avec une pile plus grande, soit implémentez le même algorithme en utilisant une table Lua pour stocker la pile de récursivité.
Borodin
1
--~ print a table
function printTable(list, i)

    local listString = ''
--~ begin of the list so write the {
    if not i then
        listString = listString .. '{'
    end

    i = i or 1
    local element = list[i]

--~ it may be the end of the list
    if not element then
        return listString .. '}'
    end
--~ if the element is a list too call it recursively
    if(type(element) == 'table') then
        listString = listString .. printTable(element)
    else
        listString = listString .. element
    end

    return listString .. ', ' .. printTable(list, i + 1)

end


local table = {1, 2, 3, 4, 5, {'a', 'b'}, {'G', 'F'}}
print(printTable(table))

Salut mec, j'ai écrit un siple code qui fait cela en pure Lua, il a un bogue (écrire une virgule après le dernier élément de la liste) mais comment je l'ai écrit rapidement en tant que prototype, je vais vous le laisser l'adapter à votre Besoins.

Joqus
la source
1

Ajout d'une autre version. Celui-ci essaie également de parcourir les données utilisateur.

function inspect(o,indent)
    if indent == nil then indent = 0 end
    local indent_str = string.rep("    ", indent)
    local output_it = function(str)
        print(indent_str..str)
    end

    local length = 0

    local fu = function(k, v)
        length = length + 1
        if type(v) == "userdata" or type(v) == 'table' then
            output_it(indent_str.."["..k.."]")
            inspect(v, indent+1)
        else
            output_it(indent_str.."["..k.."] "..tostring(v))
        end
    end

    local loop_pairs = function()
        for k,v in pairs(o) do fu(k,v) end
    end

    local loop_metatable_pairs = function()
        for k,v in pairs(getmetatable(o)) do fu(k,v) end
    end

    if not pcall(loop_pairs) and not pcall(loop_metatable_pairs) then
        output_it(indent_str.."[[??]]")
    else
        if length == 0 then
            output_it(indent_str.."{}")
        end
    end
end
phil294
la source
1

J'utilise ma propre fonction pour imprimer le contenu d'un tableau mais je ne sais pas dans quelle mesure il se traduit dans votre environnement:

---A helper function to print a table's contents.
---@param tbl table @The table to print.
---@param depth number @The depth of sub-tables to traverse through and print.
---@param n number @Do NOT manually set this. This controls formatting through recursion.
function PrintTable(tbl, depth, n)
  n = n or 0;
  depth = depth or 5;

  if (depth == 0) then
      print(string.rep(' ', n).."...");
      return;
  end

  if (n == 0) then
      print(" ");
  end

  for key, value in pairs(tbl) do
      if (key and type(key) == "number" or type(key) == "string") then
          key = string.format("[\"%s\"]", key);

          if (type(value) == "table") then
              if (next(value)) then
                  print(string.rep(' ', n)..key.." = {");
                  PrintTable(value, depth - 1, n + 4);
                  print(string.rep(' ', n).."},");
              else
                  print(string.rep(' ', n)..key.." = {},");
              end
          else
              if (type(value) == "string") then
                  value = string.format("\"%s\"", value);
              else
                  value = tostring(value);
              end

              print(string.rep(' ', n)..key.." = "..value..",");
          end
      end
  end

  if (n == 0) then
      print(" ");
  end
end
Mayron
la source
-1

J'ai humblement modifié un peu le code Alundaio:

-- by Alundaio
-- KK modified 11/28/2019

function dump_table_to_string(node, tree, indentation)
    local cache, stack, output = {},{},{}
    local depth = 1


    if type(node) ~= "table" then
        return "only table type is supported, got " .. type(node)
    end

    if nil == indentation then indentation = 1 end

    local NEW_LINE = "\n"
    local TAB_CHAR = " "

    if nil == tree then
        NEW_LINE = "\n"
    elseif not tree then
        NEW_LINE = ""
        TAB_CHAR = ""
    end

    local output_str = "{" .. NEW_LINE

    while true do
        local size = 0
        for k,v in pairs(node) do
            size = size + 1
        end

        local cur_index = 1
        for k,v in pairs(node) do
            if (cache[node] == nil) or (cur_index >= cache[node]) then

                if (string.find(output_str,"}",output_str:len())) then
                    output_str = output_str .. "," .. NEW_LINE
                elseif not (string.find(output_str,NEW_LINE,output_str:len())) then
                    output_str = output_str .. NEW_LINE
                end

                -- This is necessary for working with HUGE tables otherwise we run out of memory using concat on huge strings
                table.insert(output,output_str)
                output_str = ""

                local key
                if (type(k) == "number" or type(k) == "boolean") then
                    key = "["..tostring(k).."]"
                else
                    key = "['"..tostring(k).."']"
                end

                if (type(v) == "number" or type(v) == "boolean") then
                    output_str = output_str .. string.rep(TAB_CHAR,depth*indentation) .. key .. " = "..tostring(v)
                elseif (type(v) == "table") then
                    output_str = output_str .. string.rep(TAB_CHAR,depth*indentation) .. key .. " = {" .. NEW_LINE
                    table.insert(stack,node)
                    table.insert(stack,v)
                    cache[node] = cur_index+1
                    break
                else
                    output_str = output_str .. string.rep(TAB_CHAR,depth*indentation) .. key .. " = '"..tostring(v).."'"
                end

                if (cur_index == size) then
                    output_str = output_str .. NEW_LINE .. string.rep(TAB_CHAR,(depth-1)*indentation) .. "}"
                else
                    output_str = output_str .. ","
                end
            else
                -- close the table
                if (cur_index == size) then
                    output_str = output_str .. NEW_LINE .. string.rep(TAB_CHAR,(depth-1)*indentation) .. "}"
                end
            end

            cur_index = cur_index + 1
        end

        if (size == 0) then
            output_str = output_str .. NEW_LINE .. string.rep(TAB_CHAR,(depth-1)*indentation) .. "}"
        end

        if (#stack > 0) then
            node = stack[#stack]
            stack[#stack] = nil
            depth = cache[node] == nil and depth + 1 or depth - 1
        else
            break
        end
    end

    -- This is necessary for working with HUGE tables otherwise we run out of memory using concat on huge strings
    table.insert(output,output_str)
    output_str = table.concat(output)

    return output_str

end

puis:

print(dump_table_to_string("AA", true,3))

print(dump_table_to_string({"AA","BB"}, true,3))

print(dump_table_to_string({"AA","BB"}))

print(dump_table_to_string({"AA","BB"},false))

print(dump_table_to_string({"AA","BB",{22,33}},true,2))

donne:

only table type is supported, got string

{
   [1] = 'AA',
   [2] = 'BB'
}

{
 [1] = 'AA',
 [2] = 'BB'
}

{[1] = 'AA',[2] = 'BB'}

{
  [1] = 'AA',
  [2] = 'BB',
  [3] = {
    [1] = 22,
    [2] = 33
  }
}
kris2k
la source