Возможности метатаблиц в Lua на примере реализации классов
В Lua ООП нет. И оно, в общем-то и не нужно: удобной модульности и функций первого класса достаточно для реализации многих вещей. На этом можно было бы и закончить, но пост не про это. В данном случае я распишу работу с метатаблицами, где в качестве примера шаг за шагом будет реализовываться системка по работе с классами в несколько таком python-стиле. Для понимания нужен хотя бы основной базис языка: таблицы, upvalues.Вариант влобНачать можно с самого простого примера: local Obj = {} function Obj.spam () print 'Hello world' end
--[[ Аналогично можно написать и так: local Obj = { spam = function () print 'Hello world' end, } ]]
Obj.spam ()
-- Hello world Мы получили таблицу с одним ключом, значением которого является функция. Однако внутри самой Obj.spam нельзя получить ссылку на сам Obj (кроме как по имени за счет upvalue), потому что пока нет никаких this/self и т.п. внутри функции.
Мы можем «реализовать» это сами:
local Obj = {} function Obj.spam (self) print (self) end
Obj.spam (Obj) или предоставить это lua: local Obj = {} function Obj.spam (self) print (self) end
function Obj: spam2() print (self) end
Obj: spam () — эквивалентно Obj['spam'](Obj), т.е. не просто вызов метода, а сначала получение поля по имени, а затем его вызов, как функции. Obj: spam2() Obj.spam (Obj)
-- table: 0×417c7d58 — table: 0×417c7d58 — table: 0×417c7d58 Результатом работы будет одна и та же ссылка, т.к. все три self одинаковы.Явное использование a: b вместо a.b (a) можно использовать, при желании, для визуального разграничения методов класса Obj.foo (cls) и методов инстанции a.foo (self).
Наивный вариант конструктора мог бы выглядеть так:
local Obj = { var = 0, }
function Obj: new (val) self: set (val or 0) return self end
function Obj: set (val) self.var = val end
function Obj: print () print (self.var) end
local a = Obj: new (42) a: print () local b = Obj: new (100500) b: print () a: print ()
-- 42 — 100500 — 100500 Происходит переиспользование одной и той таблицы, что приводит к замене a.var внутри b.set. Для разделения нужно выдавать в new новую таблицу:
local Obj = { var = 0, }
function Obj: set (val) self.var = val end
function Obj: print () print (self.var) end
function Obj: new (val) — каждый раз создаем новую таблицу local inst = {} — добавляем в эту таблицу все, что есть в Obj for k, v in pairs (self) do inst[k] = v end
inst.new = nil — для запрета создания инстанций из инстанций. можно и оставить :)
inst: set (val or 0) return inst end
local a = Obj: new (42) a: print () local b = Obj: new (100500) b: print () a: print ()
-- 42 — 100500 — 42 Это работает, но уж больно криво, да и нужно повторять каждый раз.Метатаблицы В Lua для каждой таблицы (и userdata, но сейчас не про них речь) можно задавать метатаблицу, описывающую поведение данной таблицы в особенных случаях. Такими случаями могут быть использование в арифметике (перегрузка операторов), конкатенация как строк и т.д. В качестве небольшого примера перегрузки операторов и приведения к строке: local mt = { __add = function (op1, op2) local op1 = type (op1) == 'table' and op1.val or op1 local op2 = type (op2) == 'table' and op2.val or op2
return op1 + op2 end,
__tostring = function (self) return tostring (self.val) end, }
local T = { val = 0,
new = function (self) local inst = {} for k, v in pairs (self) do inst[k] = v end
— метатаблица не является явным полем таблицы, ее нужно назначать явно setmetatable (inst, getmetatable (self))
return inst end, }
setmetatable (T, mt)
local a = T: new () a.val = 2 local b = T: new () b.val = 3
print (a) print (b)
print (a + b) print (a + 10) print (100 + b)
-- 2 — 3 — 5 — 12 — 103 В данном случае нас интересует ключ __index, используемый при обращении к не существующему ключу таблицы, который внутри lua используется следующим образом:
Если значением ключа является функция, то та вызывается с передачей ей таблицы и искомого ключа. Результат работы функции используется как значение ключа. Повторное обращение по этому же ключу вновь вызывает функцию (никакого «кеширования»); Если значением ключа является другая таблица, то ключ ищется в ней. Если ключ не находится, то у данной таблицы рекурсивно проверяется ее метатаблица, и так далее. Самый настоящий We need to go deeper. Такой подход позволяет отделить описание класса от создания его экземпляра:
local T = {}
local T_mt = { __index = T, — если у таблицы нет ключа, то следует посмотреть в другой таблице }
function T.create () — setmetatable возвращает свой первый параметр в качестве результата return setmetatable ({}, T_mt) end
function T: set (val) self.val = val or 0 end
function T: print () print (self.val) end
local a = T.create () a: set (42) local b = T.create () b: set (100500)
a: print () b: print () a: print ()
-- поле инстанции a.foo = 7 print (a.foo) print (b.foo)
-- поле класса T.bar = 7 print (a.bar) print (b.bar) Получаемые a и b являются пустыми таблицами, не имеющими ключей new, set и print. Данные методы хранятся в общей таблице T. При таком подходе вызов a: print () на самом деле разворачивается в (только итоговая ветвь исполения):
getmetatable (a).__index.print (a) Внутри lua это выполняется очень быстро.При необходимости получить значение только из таблицы, не задействуя магию метатаблиц, можно заменить a.bar на rawget (a, 'bar') / rawset (a, 'bar', value).
В качестве дополнительной приятной мелочи можно реализовать более привычный синтаксис конструкторов:
local T = {}
setmetatable (T, { __call = function (cls) return cls.create () end, })
-- Все! Теперь вместо T.create () можно писать просто T (): local a = T () local b = T () Развитие идеи Теперь можно попробовать собрать все это воедино в общий генератор классов, который будет выглядеть так: local OOP = {}
function OOP.class (struct) — магия return cls — возвращаем класс, не инстанцию end
-- создаем класс из описания публичных полей и методов инстанции local A = OOP.class { val = 0,
set = function (self, val) self.val = val or 0 end,
print = function (self) print (self.val) end, }
-- создаем и используем local a = A: create () a: print () a: set (42) a: print () Реализация в данном объеме весьма простая:
function OOP.class (struct) local struct = struct or {}
local cls = {}
local function _create_instance () local inst = {}
for k, v in pairs (struct) do inst[k] = v end
inst.__class = cls
return inst end
setmetatable (cls, { __index = { create = _create_instance, — метод класса, не инстанции }, __call = function (cls) return cls: create () — сахар синтаксиса конструктора end, })
return cls end Всего и делов-то.Для методов класса можно сохранить ссылку на класс внутри таблицы инстанции и вопользоватся ей в последствии:
— … local function _create_instance () local inst = {} — … inst.__class = cls — … end — …
A.clsMeth = function (cls) print ('Hello') end — …
a.__class: clsMeth () — a.clsMeth () не доступно Гораздо интереснее ситуация с наследованием. Пока разберем единичное:
— метод исключительно ради красивого синтаксиса. необходимости в нем нет function OOP.subclass (parent) return function (struct) return OOP.class (struct, parent) end end
local A = OOP.class { — … }
local B = OOP.subclass (A) { — B является потомком A welcome = function (self) print ('Welcome!') self: print () — вызов метода потомка как своего end, }
local b = B () b: print () b: set (100500) b: welcome () Для реализации нужно внести не так уж и много правок: function OOP.class (struct, parent) — 1. передаем данные по родителю local struct = struct or {}
local cls = {}
local function _create_instance () local base = parent and parent: create () or nil — 2. при создании инстанции создаем ее предка
local inst = {}
— 3. берем из родителя все его публичные поля if base then for k, v in pairs (base) do inst[k] = v end end
for k, v in pairs (struct) do inst[k] = v end
inst.__class = cls
return inst end
setmetatable (cls, { __index = setmetatable ( — 4. метатаблица получает собственную метатабалицу { create = _create_instance, }, { — если чего нет у текущего класса, то ищем у предка __index = function (_, key) if parent then return parent[key] end end, } ), __call = function (cls) return cls: create () end, })
return cls end Для создания собственных явных конструкторов опишем метод new и будем его вызывать при создании инстанции:
— … setmetatable (cls, { — … __call = function (cls, …) local inst = cls: create ()
— если есть конструктор — вызываем его local new = inst.new if new then new (inst, …) end
return inst end, }) — …
local A = OOP.class { new = function (self, text) text = text or '' print ('Hello ' … text) end, }
local B = OOP.subclass (A) { }
A ('world') B ('traveler')
-- Hello world — Hello traveler Автоматического вызова конструктора (да и вообще любого другого метода) предка мы не реализовывали, соотвественно local B = OOP.subclass (A) { new = function (self, text) print ('B says ' … tostring (text)) end, }
B ('spam') не приведет к вызову A.new. Для этого опять нужно лишь внести небольшое дополнение в логику работы, реализовыв метод инстанции super:) local B = OOP.subclass (A) { new = function (self, text) print ('B says ' … tostring (text)) self: super ('from B') end, } — …
local function super_func (self, …) local frame = debug.getinfo (2) local mt = getmetatable (self) assert (mt and mt.__base, 'There are no super method')
local func = mt.__base[frame.name] return func and func (self, …) or nil end
-- … local function _create_instance () — …
— вместо явного объявления inst.super выносим метод в метатаблицу, чтобы он не выглядел как частью структуры. --, но это позволяет объявить одноименный метод/поле. — можно добавить проверку имени при обходе pairs (struct), если необходимо., но от a.super = x это не спасет. local inst = setmetatable ({}, { __base = base, __index = { super = super_func, }, }) — … super вызывается без указания имени вызываемого метода. Для его получения используется модуль debug.Если не хочется его использовать (или lua запущена без него), то можно явно передавать имя метода.debug.getinfo () используется для получения краткой информации о запрошенном уровне стека: 0 — текущий (super_func), 1 — уровень, где вызвали super_func, … Нам нужно имя функции, из которой была вызвана super, т.е. поле name второго уровня стека.Теперь можно вызывать любые родительские методы, не только конструктор :)Для реализации private полей и методов можно использовать подход на основе соглашения об именовании как в python, или воспользоваться истинным сокрытием через область видимости модуля, или вообще через upvalues:
local A = OOP.class ((function ()
— нет прямого доступа из потомка local function private (self, txt) print ('Hello from ' … txt) end
return { val = 0,
public = function (self) private (self, 'public') end, } end)()) Ну тут вариантов много. Меня вполне устраивает вариант с соглашением по именованию.Вот такие возможности предоставляют метатаблицы в Lua. Если вы смогли это все прочитать, то, видимо, написано было не зря.
Полный и чуть более навороченный вариант реализации можно увидеть тут.
