Lua
Metatable

Składnia

• [[local] mt =] getmetatable ( t ) -> pobierz powiązany metatable dla „ t ”
• [[lokalny] t =] setmetatable ( t , mt ) -> ustaw metatable dla „ t ” na „ mt ” i zwraca „ t ”

Parametry

Uwagi

Tworzenie i wykorzystanie metatabli

Metatable definiuje zestaw operacji, które zmieniają zachowanie obiektu lua. Metatable to zwykły stół, który jest używany w specjalny sposób.

local meta = { } -- create a table for use as metatable

-- a metatable can change the behaviour of many things
-- here we modify the 'tostring' operation:
-- this fields should be a function with one argument.
-- it gets called with the respective object and should return a string
meta.__tostring = function (object)
    return string.format("{ %d, %d }", object.x, object.y)
end

-- create an object
local point = { x = 13, y = -2 }
-- set the metatable
setmetatable(point, meta)

-- since 'print' calls 'tostring', we can use it directly:
print(point) -- prints '{ 13, -2 }'

Używanie tabel jako metametod

Niektóre metody nie muszą być funkcjami. Najważniejszym przykładem tego jest __index __index. Może to być również tabela, która jest następnie używana jako wyszukiwanie. Jest to dość powszechnie stosowane w tworzeniu klas w lua. Tutaj tabela (często sama metatable) służy do przechowywania wszystkich operacji (metod) klasy:

local meta = {}
-- set the __index method to the metatable.
-- Note that this can't be done in the constructor!
meta.__index = meta

function create_new(name)
    local self = { name = name }
    setmetatable(self, meta)
    return self
end

-- define a print function, which is stored in the metatable
function meta.print(self)
    print(self.name)
end

local obj = create_new("Hello from object")
obj:print()

Garbage collector - metoda __gc

local meta =
{
    __gc = function(self)
        print("destroying self: " .. self.name)
    end
}

local t = setmetatable({ name = "outer" }, meta)
do
    local t = { name = "inner" }
    setmetatable(t, meta)
end

Więcej metod

Istnieje wiele innych metod, niektóre z nich są arytmetyczne (np. Dodawanie, odejmowanie, mnożenie), są operacje bitowe (i, lub xor, shift), porównywanie (<,>), a także operacje typu podstawowego, takie jak == i # (równość i długość). Zbudujmy klasę, która obsługuje wiele z tych operacji: wezwanie do racjonalnej arytmetyki. Chociaż jest to bardzo podstawowe, pokazuje pomysł.

local meta = {
    -- string representation
    __tostring = function(self)
        return string.format("%s/%s", self.num, self.den)
    end,
    -- addition of two rationals
    __add = function(self, rhs)
        local num = self.num * rhs.den + rhs.num * self.den
        local den = self.den * rhs.den
        return new_rational(num, den)
    end,
    -- equality
    __eq = function(self, rhs)
        return self.num == rhs.num and self.den == rhs.den
    end
}

-- a function for the creation of new rationals
function new_rational(num, den)
    local self = { num = num, den = den }
    setmetatable(self, meta)

    return self
end

local r1 = new_rational(1, 2)
print(r1) -- 1/2

local r2 = new_rational(1, 3)
print(r1 + r2) -- 5/6

local r3 = new_rational(1, 2)
print(r1 == r3) -- true
-- this would be the behaviour if we hadn't implemented the __eq metamethod.
-- this compares the actual tables, which are different
print(rawequal(r1, r3)) -- false

Spraw, by tabele można było wywoływać

Istnieje metametoda o nazwie __call , która określa zachowanie obiektu podczas używania go jako funkcji, np. object() . Można to wykorzystać do tworzenia obiektów funkcyjnych:

-- create the metatable with a __call metamethod
local meta = {
    __call = function(self)
        self.i = self.i + 1
    end,
    -- to view the results
    __tostring = function(self)
        return tostring(self.i)
    end
}

function new_counter(start)
    local self = { i = start }
    setmetatable(self, meta)
    return self
end

-- create a counter
local c = new_counter(1)
print(c) --> 1
-- call -> count up
c()
print(c) --> 2

Metametoda jest wywoływana z odpowiednim obiektem, wszystkie pozostałe argumenty są następnie przekazywane do funkcji:

local meta = {
    __call = function(self, ...)
        print(self.prepend, ...)
    end
}

local self = { prepend = "printer:" }
setmetatable(self, meta)

self("foo", "bar", "baz")

Indeksowanie tabel

Być może najważniejszym zastosowaniem metatabli jest możliwość zmiany indeksowania tabel. W tym celu należy wziąć pod uwagę dwa działania: czytanie treści i pisanie zawartości tabeli. Zauważ, że obie akcje są uruchamiane tylko wtedy, gdy odpowiedni klucz nie jest obecny w tabeli.

Czytanie

local meta = {}

-- to change the reading action, we need to set the '__index' method
-- it gets called with the corresponding table and the used key
-- this means that table[key] translates into meta.__index(table, key)
meta.__index = function(object, index)
    -- print a warning and return a dummy object
    print(string.format("the key '%s' is not present in object '%s'", index, object))
    return -1
end

-- create a testobject
local t = {}

-- set the metatable
setmetatable(t, meta)

print(t["foo"]) -- read a non-existent key, prints the message and returns -1

Może to być wykorzystane do zgłoszenia błędu podczas odczytu nieistniejącego klucza:

-- raise an error upon reading a non-existent key
meta.__index = function(object, index)
    error(string.format("the key '%s' is not present in object '%s'", index, object))
end

Pisanie

local meta = {}

-- to change the writing action, we need to set the '__newindex' method
-- it gets called with the corresponding table, the used key and the value
-- this means that table[key] = value translates into meta.__newindex(table, key, value)
meta.__newindex = function(object, index, value)
    print(string.format("writing the value '%s' to the object '%s' at the key '%s'",
                         value, object, index))
    --object[index] = value -- we can't do this, see below
end

-- create a testobject
local t = { }

-- set the metatable
setmetatable(t, meta)

-- write a key (this triggers the method)
t.foo = 42

Możesz teraz zadać sobie pytanie, jak rzeczywista wartość jest zapisana w tabeli. W tym przypadku tak nie jest. Problem polega na tym, że metody mogą wyzwalać metody, które powodują nieskończoną pętlę, a ściślej przepełnienie stosu. Jak więc możemy to rozwiązać? Rozwiązanie tego nazywa się dostępem do surowego stołu .

Dostęp do surowego stołu

Czasami nie chcesz uruchamiać metamod, ale tak naprawdę pisz lub czytaj dokładnie dany klucz, bez sprytnych funkcji otaczających dostęp. W tym celu lua zapewnia metody dostępu do tabeli surowej:

-- first, set up a metatable that allows no read/write access
local meta = {
    __index = function(object, index)
        -- raise an error
        error(string.format("the key '%s' is not present in object '%s'", index, object))
    end,
    __newindex = function(object, index, value)
        -- raise an error, this prevents any write access to the table
        error(string.format("you are not allowed to write the object '%s'", object))
    end
}

local t = { foo = "bar" }
setmetatable(t, meta)

-- both lines raise an error:
--print(t[1])
--t[1] = 42

-- we can now circumvent this problem by using raw access:
print(rawget(t, 1)) -- prints nil
rawset(t, 1, 42) -- ok

-- since the key 1 is now valid, we can use it in a normal manner:
print(t[1])

Dzięki temu możemy teraz przepisać wcześniejszą metodę __newindex , aby faktycznie zapisać wartość do tabeli:

meta.__newindex = function(object, index, value)
    print(string.format("writing the value '%s' to the object '%s' at the key '%s'",
                         value, object, index))
    rawset(object, index, value)
end

Symulowanie OOP

local Class = {} -- objects and classes will be tables
local __meta = {__index = Class}
-- ^ if an instance doesn't have a field, try indexing the class
function Class.new()
    -- return setmetatable({}, __meta) -- this is shorter and equivalent to:
    local new_instance = {}
    setmetatable(new_instance, __meta)
    return new_instance
end
function Class.print()
    print "I am an instance of 'class'"
end

local object = Class.new()
object.print() --> will print "I am an instance of 'class'"

Metody instancji można zapisać, przekazując obiekt jako pierwszy argument.

-- append to the above example
function Class.sayhello(self)
    print("hello, I am ", self)
end
object.sayhello(object) --> will print "hello, I am <table ID>"
object.sayhello() --> will print "hello, I am nil"

Jest na to trochę cukru syntaktycznego.

function Class:saybye(phrase)
    print("I am " .. self .. "\n" .. phrase)
end
object:saybye("c ya") --> will print "I am <table ID>
                      -->             c ya"

Możemy również dodać domyślne pola do klasy.

local Class = {health = 100}
local __meta = {__index = Class}

function Class.new() return setmetatable({}, __meta) end
local object = Class.new()
print(object.health) --> prints 100
Class.health = 50; print(object.health) --> prints 50
-- this should not be done, but it illustrates lua indexes "Class"
-- when "object" doesn't have a certain field
object.health = 200 -- This does NOT index Class
print(object.health) --> prints 200