WIKI - Mini World: CREATA

Meta tables in Lua are special tables that let you change how regular tables behave. Think of them as “rules” you can set to control what happens when you do certain actions with a table. The logic is very simple and not confusing at all.

Here is you have normal Table

regular_Table = {}
meta_rule = {} -- your rule here

Here is the Function to set Metatable

setmetatable(regular_Table, meta_rule)

Now Table regular_table is set it meta methods using rule in meta_rule. But in the example we did nothing to Table regular_table

Here are some common behaviors you can modify:

• Accessing a Non-Existent Key (__index)
• Setting a New Key-Value Pair (__newindex)
• Arithmetic Operations (__add, __sub, __mul, __div, __mod, __pow, __unm)
• Concatenation (__concat)
• Length Operator (__len)
• Equality Comparison (__eq)
• Less Than and Less Than or Equal Comparisons (__lt, __le)
• Function Call (__call)
• Table String Representation (__tostring)
• Table Garbage Collection (__gc)

Metatable are often used for framework or creating code that is reuseable.

You can define what happens when you try to access a key that does not exist in a table.

local myTable = {}
local meta = {
    __index = function(table, key)
        return "This key does not exist!"
    end
}
setmetatable(myTable, meta)
 
print(myTable.nonExistentKey)  -- Output: This key does not exist!

You can control the behavior when adding a new key-value pair to a table.

local myTable = {}
local meta = {
    __newindex = function(table, key, value)
        print("New key-value pair added:", key, value)
    end
}
setmetatable(myTable, meta)
 
myTable.newKey = "newValue"  -- Output: New key-value pair added: newKey newValue

You can define custom behaviors for arithmetic operations involving tables.

local table1 = {1, 2}
local table2 = {3, 4}
local meta = {
    __add = function(a, b)
        return {a[1] + b[1], a[2] + b[2]}
    end
}
setmetatable(table1, meta)
 
local result = table1 + table2
print(result[1], result[2])  -- Output: 4 6

You can define custom behavior for the concatenation of tables.

local table1 = {1, 2}
local table2 = {3, 4}
local meta = {
    __concat = function(a, b)
        return table.concat(a, ",") .. "," .. table.concat(b, ",")
    end
}
setmetatable(table1, meta)
 
local result = table1 .. table2
print(result)  -- Output: 1,2,3,4

You can define custom behavior for calculating the length of a table.

local myTable = {1, 2, 3}
local meta = {
    __len = function(t)
        return 42  -- Just an arbitrary value
    end
}
setmetatable(myTable, meta)
 
print(#myTable)  -- Output: 42

-- Example table
local myTable = {1, 2, 3, nil, 5, key1 = "value1", key2 = "value2"}
 
print(#myTable)  -- Output: 3
 
-- Metatable with __len metamethod
local meta = {
    __len = function(t)
        local count = 0
        for k, v in pairs(t) do
            if v ~= nil then
                count = count + 1
            end
        end
        return count
    end
}
 
-- Set metatable for myTable
setmetatable(myTable, meta)
 
-- Now, using the length operator (#) on myTable will invoke the __len metamethod
print(#myTable)  -- Output: 7

You can define custom behavior for comparing two tables for equality.

local table1 = {1, 2}
local table2 = {1, 2}
local meta = {
    __eq = function(a, b)
        return a[1] == b[1] and a[2] == b[2]
    end
}
setmetatable(table1, meta)
setmetatable(table2, meta)
 
print(table1 == table2)  -- Output: true

You can define custom behavior for comparing two tables using < and ⇐.

local table1 = {1}
local table2 = {2}
local meta = {
    __lt = function(a, b)
        return a[1] < b[1]
    end
}
setmetatable(table1, meta)
setmetatable(table2, meta)
 
print(table1 < table2)

You can make table behave like function

local myTable = {}
local meta = {
    __call = function(table, arg)
        return "Called with argument: " .. arg
    end
}
setmetatable(myTable, meta)
 
print(myTable("Hello"))  -- Output: Called with argument: Hello

You can define how a table is converted to a string.

local myTable = {1, 2, 3}
local meta = {
    __tostring = function(t)
        return "This is my custom table!"
    end
}
setmetatable(myTable, meta)
 
print(myTable)  -- Output: This is my custom table!

You can define custom behavior when a table is collected by the garbage collector.

local myTable = {}
local meta = {
    __gc = function(t)
        print("Table is being garbage collected")
    end
}
setmetatable(myTable, meta)
 
myTable = nil
collectgarbage()  -- Output: Table is being garbage collected