নেস্টেড টেবিল (এন-গভীর) থাকা কোনও টেবিলের সামগ্রীগুলি প্রদর্শন করতে আমার সমস্যা হচ্ছে। আমি এটি স্ট্যান্ড আউট বা কনসোলকে কোনও printবিবৃতি বা দ্রুত এবং ময়লা কিছু দিয়ে ফেলে দিতে চাই তবে কীভাবে তা আমি বুঝতে পারি না। আমি NSDictionaryজিডিবি ব্যবহার করে মুদ্রণের সময় যে মোটামুটি সমতুল্য পাই তা সন্ধান করছি ।
উত্তর:
টেবিল সিরিয়ালাইজেশনে লুয়া উইকি ব্রাউজ করতে নির্দ্বিধায় । এটি কনসোলে কোনও টেবিলটি কীভাবে ডাম্প করবে তার বিভিন্ন উপায় তালিকাভুক্ত করে।
কোনটি আপনার পক্ষে সবচেয়ে উপযুক্ত তা আপনাকে কেবল চয়ন করতে হবে। এটি করার অনেকগুলি উপায় রয়েছে তবে আমি সাধারণত পেনলাইট থেকে একটিটি ব্যবহার করে শেষ করি :
> t = { a = { b = { c = "Hello world!", 1 }, 2, d = { 3 } } }
> require 'pl.pretty'.dump(t)
{
a = {
d = {
3
},
b = {
c = "Hello world!",
1
},
2
}
}
আমি জানি এই প্রশ্নটি ইতিমধ্যে উত্তর হিসাবে চিহ্নিত হয়েছে, তবে আমাকে এখানে আমার নিজের লাইব্রেরি প্লাগ করতে দিন। একে ইন্সপেক্ট.লুয়া বলা হয় এবং আপনি এটি এখানে খুঁজে পেতে পারেন:
https://github.com/kikito/inspect.lua
এটি কেবল একটি একক ফাইল যা আপনার অন্য যে কোনও ফাইল থেকে প্রয়োজন হতে পারে। এটি এমন একটি ফাংশন দেয় যা কোনও লুয়া মানকে মানব-পঠনযোগ্য স্ট্রিংয়ে রূপান্তর করে:
local inspect = require('inspect')
print(inspect({1,2,3})) -- {1, 2, 3}
print(inspect({a=1,b=2})
-- {
-- a = 1
-- b = 2
-- }
এটি সাবটবেবলগুলি সঠিকভাবে প্রবেশ করে এবং "পুনরাবৃত্ত টেবিলগুলি" (তাদের নিজস্ব উল্লেখ থাকা সারণীগুলি) সঠিকভাবে পরিচালনা করে, তাই এটি অসীম লুপগুলিতে যায় না। এটি একটি বুদ্ধিমান উপায়ে মানগুলি বাছাই করে। এটি মেটাটেটেবল তথ্যও প্রিন্ট করে।
শুভেচ্ছা সহ!
luarocks install inspect
আমি এটি একটি দরকারী খুঁজে পেয়েছি। কারণ পুনরাবৃত্তি যদি এটি নেস্টেড টেবিলগুলিও মুদ্রণ করতে পারে। এটি আউটপুটে সবচেয়ে সুন্দর বিন্যাস দেয় না তবে এ জাতীয় সাধারণ ফাংশনটির জন্য এটি ডিবাগিংয়ের জন্য বীট করা শক্ত।
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যেমন
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))নিম্নলিখিত আউটপুট উত্পাদন করে:
লোক: {[1] = {["ঠিকানা"] = 16 লং স্ট্রিট, ["ফোন"] = 123456, ["নাম"] = ফ্রেড,}, [2] = {["ঠিকানা"] = 16 লং স্ট্রিট , ["ফোন"] = 123456, ["নাম"] = উইলমা,}, [3] = {["ঠিকানা"] = 17 লং স্ট্রিট, ["ফোন"] = 123457, ["নাম"] = বার্নে, },}
এটি পাওয়া গেছে:
-- 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এখান থেকে https://gist.github.com/riPoint/4270799
আমার জন্য বেশ ভাল কাজ করে ...
বেশিরভাগ খাঁটি লুয়া প্রিন্ট টেবিল ফাংশন যা আমি দেখেছি গভীর পুনরাবৃত্তিতে সমস্যা আছে এবং যখন খুব গভীর হয় তখন স্ট্যাকের ওভারফ্লো হতে থাকে। এই মুদ্রণ সারণী ফাংশন যা আমি লিখেছি তাতে এই সমস্যা নেই। এটি কনকাটেন্টেশন পরিচালনা করার পদ্ধতিটির কারণে এটি সত্যিই বড় টেবিলগুলি পরিচালনা করতে সক্ষম হওয়া উচিত। আমার এই ক্রিয়াকলাপের ব্যক্তিগত ব্যবহারে, এটি প্রায় এক সেকেন্ডে ফাইল করতে 63৩ কে লাইন আউটপুট করে।
আউটপুটটি লুয়া সিনট্যাক্সও রাখে এবং কেবল সংখ্যা, বুলিয়ান, স্ট্রিং এবং টেবিলের ডেটা ধরণের ফর্ম্যাট করার অনুমতি দিতে পরিবর্তিত হলে আউটপুটটি ফাইল করে সহজেই ধ্রুব স্টোরেজ করার জন্য স্ক্রিপ্টটি সহজেই সংশোধন করা যায়।
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এখানে একটি উদাহরণ:
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)আউটপুট:
{
[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'
}
}tabফাংশন overcomplicated হয়। এটি মূলত কেবল string.repeat('\t', amt)তবে কম পারফরম্যান্ট।
পূর্বে উল্লিখিত হিসাবে, আপনি এটি লিখতে হবে। আমার নম্র সংস্করণটি এখানে:
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উদাহরণ:
local mytbl = { ['1']="a", 2, 3, b="c", t={d=1} }
tprint(mytbl)আউটপুট (লুয়া 5.0):
table[1] = 2
table[2] = 3
table["1"] = "a"
table["t"]["d"] = 1
table["b"] = "c"table.tostringএর metehod metalua আসলে খুব সম্পূর্ণ। এটি নেস্টেড টেবিলগুলির সাথে সম্পর্কিত হয়, ইনডেন্টেশন স্তরটি পরিবর্তনযোগ্য, ... দেখুন https://github.com/fab13n/metalua/blob/master/src/lib/metalua/table2.lua
এটি আমার সংস্করণ যা টেবিল এবং ইউজারডাটা বাদ দিয়ে সমর্থন করে
-- 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এটি একটি উদাহরণ
t = {
location = {
x = 10,
y = 20
},
size = {
width = 100000000,
height = 1000,
},
name = "Sidney",
test = {
hi = "lol",
},
anotherone = {
1,
2,
3
}
}
table.print(t, { "test" })ছাপে:
### 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 ###লক্ষ্য করুন যে মূলটি ব্যতিক্রমগুলি সরিয়ে দেয় না
JSON হিসাবে ফর্ম্যাট করুন (আপনি পরে আইডিইতে "সুন্দর করতে" পারেন):
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ব্যবহার:
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"}বিটিডাব্লু, আমি আরও কয়েকটি সমাধান লিখেছি: খুব দ্রুত একটি, এবং একটি বিশেষ চরিত্র সহ পালাতে পেরেছে: https://github.com/vn971/ ব্রেকফাস্ট_ json_encode
আপনার নিজের কোড করতে হবে আমি ভীত। আমি এটি লিখেছি এবং এটি আপনার কিছুটা কাজে লাগতে পারে
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)..'}');
endsortকরুন table.sort... local sort = table.sortকোডটি কোথা থেকে নেওয়া হয়েছে অবশ্যই হবে।
sortএকটি অনুলিপি table.sort, strrepহয় string.rep, strmatchহয় string.matchইত্যাদি আমাকে যদি আরও আছে যাক এবং আমি আমার উত্তর পরিবর্তন করব।
--~ 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))হাই লোক, আমি একটি সিপল কোড লিখেছিলাম যা খাঁটি লুয়ায় এটি করে, এতে একটি বাগ রয়েছে (তালিকার শেষ উপাদানটির পরে কোমা লিখুন) তবে কীভাবে আমি প্রোটোটাইপ হিসাবে এটি দ্রুত লিখেছি তা আপনাকে এটির সাথে খাপ খাইয়ে দেব চাহিদা.
অন্য সংস্করণ যুক্ত করা হচ্ছে। এটি একসাথে ইউজারডাটাতেও পুনরাবৃত্তি করার চেষ্টা করে।
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আমি একটি টেবিলের বিষয়বস্তু মুদ্রণের জন্য আমার নিজের ফাংশনটি ব্যবহার করি তবে এটি আপনার পরিবেশে কতটা ভাল অনুবাদ করে তা নিশ্চিত নয়:
---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আমি বিনীতভাবে কিছুটা আলুন্ডাইও কোডটি সংশোধন করেছি:
-- 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তারপর:
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))দেয়:
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
}
}