How can I view the contents of this table?

To expand on iiiGodRoblox's answer

Arrays and dictionaries usually cannot be printed in a human readable format if just printed to console or tostringed.

tostring(table t) will return some weird string that we know is table: some hexadecimal number, but that doesn't really give a lot of information about the table, sure it's nice that we can print it but it's not really too useful to use right now.

For us to actually view and inspect an array or dictionary, we can either use some that returns the table as a string or __tostring metamethod.

How To Implement

If you're bored of reading and just want an easy solution, you can use

local function DumpTable(t)
    local str = {}
    for Index, Value in pairs(t) do
        table.insert(str, tostring(Value))
    end
    return "{" .. table.concat(str, ", ") .. "}"
end

It's not necessarily the best solution, but it works and it's simple enough to understand at a glance.

If you're curious for more information, you can keep on reading.

There's an obvious problem with the code above, it doesn't support nested tables; let's say we have a table structured as such

{
    Hello = "World",
    Programmed = {
        "To"
        "Work"
    },
    And = {
        Not = "to",
        Feel = true
    }
}

What our code above might output would be something along the lines of {World, table: 0xBAADF00D, table: 0xFFFFFF} Yeah, it prints it out but now we're back to our original problem, it's printing table: hex again.

What we can do is have some kind of recursive implementation that checks the type of Value and if it's a table, then dump that table

The code may fall something along the lines like

local function DumpTable(t)
    local str = {}
    for Index, Value in pairs(t) do
        if type(Value) == "table" then
            table.insert(str, DumpTable(Value))
        else
            table.insert(str, tostring(Value))
        end
    end
    return "{" .. table.concat(str, ", ") .. "}"
end

If we inspect the code, we can see that it'll handle tables inside tables and tables inside those tables correctly.

Self referential tables

This should be enough for most people, but what if you're really eccentric and have something like

local a = {}
local b = {a}
a[1] = a

Now, at first, this may seem to work, its just tables inside tables but now this presents another problem: self-referential tables

This is what our little function will do

DumpTable(a)
    -> __index(a, 1) = b
    -> DumpTable(b)
        -> __index(b, 1) = a
        -> DumpTable(a)
            -> __index(a, 1) = b
            -> DumpTable(b)
            ... forever

Now that's a problem, it just keeps on dumping a and b! This will go on infinitely and will cause a stack overflow which isn't good for both us and the computer.

What we can do to solve this is keep track of the tables that we already turned into strings, if it hasn't then do whatever we usually do, else just return tostring(t)

local function DumpTable(t, Printed)
    Printed = Printed or {}
    if Printed[t] then
        return tostring(t) --this is where we stop self-referential tables
    end
    Printed[t] = true
    local str = {}
    for Index, Value in pairs(t) do
        if type(Value) == "table" then
            table.insert(str, DumpTable(Value, Printed))
        else
            table.insert(str, tostring(Value))
        end
    end
    return "{" .. table.concat(str, ", ") .. "}"
end

Now, this is what our function will do with the table a and b problem:

DumpTable(a, {})
    -> __index(a, 1) = b
    -> DumpTable(b, Printed)
        ->__index(b, 1) = a
        -> DumpTable(a, Printed)
            -> a is in Printed, return tostring(a)
        -> return "{" .. tostring(a) .. "}"
    ->return "{{" .. tostring(a) .. "}}

DumpTable(a) == "{{" .. tostring(a) .. "}}"

This may seem not that useful but that's just because it isn't necessarily the best example; however, it clearly illustrates that, yes, it can handle self-referential tables while not having a stroke and dying.

Of course, this doesn't solve all our problems, it shows strings as String rather than "String", which isn't optimal and while yes it works with both arrays and dictionaries, dictionary support isn't exactly the best as it doesn't include the index. Using what you learned in this answer, try extending our code to work and solve these little problems.

If you want to use existing code to inspect tables, you can use Kikito's inspect.lua or my own table.FormatValue

Well you could see the content of the table by using a for loop like the following

local tab = {'a','b','c','d',...}
for i,v in pairs(tab) do
    print(i,v)
end