Lua metatabla (Metatable)
En las tablas de Lua podemos acceder a la clave (key) correspondiente para obtener el valor (value), pero no podemos realizar operaciones entre dos tablas (como sumarlas).
Por lo tanto, Lua proporciona metatablas (Metatable) que nos permiten cambiar el comportamiento de las tablas; cada comportamiento está asociado a un metamétodo correspondiente.
Por ejemplo, con las metatablas podemos definir cómo Lua calcula la operación de suma a+b de dos tablas.
Cuando Lua intenta sumar dos tablas, primero verifica si una de ellas tiene una metatabla, y luego verifica si hay un campo llamado__addSi se encuentra el campo, se invoca el valor correspondiente.__addEstos campos, cuyo valor correspondiente (a menudo una función o una tabla), son los "metamétodos".
Hay dos funciones muy importantes para manejar metatablas:
- setmetatable(table,metatable):Establece la metatabla (metatable) para la tabla especificada; si existe la clave __metatable en la metatabla, setmetatable fallará.
- getmetatable(table):Devuelve la metatabla (metatable) del objeto.
El siguiente ejemplo demuestra cómo establecer una metatabla para la tabla especificada:
mymetatable = {} -- metatabla
setmetatable(mytable,mymetatable) -- establecer mymetatable como la metatabla de mytable
El código anterior también se puede escribir en una sola línea:
mytable = setmetatable({},{})
A continuación se muestra cómo devolver la metatabla del objeto:
getmetatable(mytable) -- 这会返回 mymetatable
Metamétodo __index
Esta es la clave más utilizada en las metatablas.
Cuando accedes a una tabla mediante una clave, si esa clave no tiene valor, Lua buscará la clave __index en la metatabla de esa tabla (suponiendo que tenga metatabla). Si __index contiene una tabla, Lua buscará la clave correspondiente en esa tabla.
Podemos verlo entrando al modo interactivo con el comando lua:
Lua 5.3.0 Copyright (C) 1994-2015 Lua.org, PUC-Rio
> other = { foo = 3 }
> t = setmetatable({}, { __index = other })
> t.foo
3
> t.bar
nil
Si __index contiene una función, Lua invocará esa función, y la tabla y la clave se pasarán como argumentos a la función.
El metamétodo __index verifica si el elemento existe en la tabla; si no existe, devuelve nil; si existe, __index devuelve el resultado.
Ejemplo
__index = function(mytable, key)
if key == "key2" then
return "metatablevalue"
else
return nil
end
end
})
print(mytable.key1,mytable.key2)
El resultado de salida del ejemplo es:
value1 metatablevalue
Análisis del ejemplo:
La tabla mytable se asigna como{key1 = "value1"}。
mytable tiene una metatabla establecida, y el metamétodo es __index.
Busca key1 en la tabla mytable; si la encuentra, devuelve ese elemento; si no, continúa.
Busca key2 en la tabla mytable; si la encuentra, devuelve metatablevalue; si no, continúa.
Determina si la metatabla tiene el método __index; si __index es una función, la invoca.
Dentro del metamétodo se verifica si se pasó el argumento de la clave "key2" (mytable.key2 ya está establecido); si se pasa el parámetro "key2", devuelve "metatablevalue"; de lo contrario, devuelve el valor de la clave correspondiente en mytable.
Podemos simplificar el código anterior escribiéndolo así:
print(mytable.key1,mytable.key2)
Resumen
Las reglas de Lua al buscar un elemento en una tabla son, en realidad, los siguientes 3 pasos:
- 1. Buscar en la tabla; si se encuentra, devolver ese elemento; si no, continuar.
- 2. Determinar si la tabla tiene una metatabla; si no tiene metatabla, devolver nil; si tiene, continuar.
- 3. Determinar si la metatabla tiene el método __index; si __index es nil, devolver nil; si __index es una tabla, repetir los pasos 1, 2 y 3; si __index es una función, devolver el valor de retorno de esa función.
Esta parte del contenido proviene del autor Huanzi: https://blog.csdn.net/xocoder/article/details/9028347
Metamétodo __newindex
El metamétodo __newindex se usa para actualizar la tabla, mientras que __index se usa para acceder a la tabla.
Cuando asignas un valor a un índice inexistente de una tabla, el intérprete buscará el metamétodo __newindex: si existe, invocará esa función sin realizar la asignación.
El siguiente ejemplo demuestra la aplicación del metamétodo __newindex:
Ejemplo
mytable = setmetatable({key1 = "value1"}, { __newindex = mymetatable })
print(mytable.key1)
mytable.newkey = "nuevo valor 2"
print(mytable.newkey,mymetatable.newkey)
mytable.key1 = "nuevo valor 1"
print(mytable.key1,mymetatable.key1)
El resultado de salida de la ejecución del ejemplo anterior es:
value1 nil 新值2 新值1 nil
En el ejemplo anterior, la tabla tiene el metamétodo __newindex; al asignar un valor a la nueva clave de índice (newkey) (mytable.newkey = "nuevo valor 2"), se invoca el metamétodo y no se realiza la asignación. Sin embargo, si se asigna a una clave de índice existente (key1), sí se realiza la asignación y no se invoca el metamétodo __newindex.
El siguiente ejemplo usa la función rawset para actualizar la tabla:
Ejemplo
__newindex = function(mytable, key, value)
rawset(mytable, key, "\""..value.."\"")
end
})
mytable.key1 = "new value"
mytable.key2 = 4
print(mytable.key1,mytable.key2)
El resultado de salida de la ejecución del ejemplo anterior es:
new value "4"
Agregar operadores a las tablas
El siguiente ejemplo demuestra la operación de suma de dos tablas:
Ejemplo
function table_maxn(t)
local mn = 0
for k, _ in pairs(t) do
if type(k) == "number" and k > mn then
mn = k
end
end
return mn
end
-- Operación de suma de dos tablas
mytable = setmetatable({ 1, 2, 3 }, {
__add = function(mytable, newtable)
local max_key_mytable = table_maxn(mytable)
for i = 1, table_maxn(newtable) do
table.insert(mytable, max_key_mytable + i, newtable[i])
end
return mytable
end
})
secondtable = {4, 5, 6}
mytable = mytable + secondtable
for k, v in ipairs(mytable) do
print(k, v)
end
El resultado de salida de la ejecución del ejemplo anterior es:
1 1 2 2 3 3 4 4 5 5 6 6
La clave __add está incluida en la metatabla y realiza la operación de suma. La lista de operaciones correspondientes en la tabla es la siguiente: (Nota:__son dos guiones bajos)
| Patrón | Descripción |
|---|---|
| __add | Operador correspondiente '+'. |
| __sub | Operador correspondiente '-'. |
| __mul | Operador correspondiente '*'. |
| __div | Operador correspondiente '/'. |
| __mod | Operador correspondiente '%'. |
| __unm | Operador correspondiente '-'. |
| __concat | Operador correspondiente '..'. |
| __eq | Operador correspondiente '=='. |
| __lt | Operador correspondiente '<'. |
| __le | Operador correspondiente '<='. |
Metamétodo __call
El metamétodo __call se invoca cuando Lua llama a un valor. El siguiente ejemplo demuestra cómo calcular la suma de los elementos de una tabla:
Ejemplo
-- Función personalizada table_maxn para calcular el mayor valor de clave en la tabla, es decir, calcular el número de elementos de la tabla
function table_maxn(t)
local mn = 0
for k, v in pairs(t) do
if mn < k then
mn = k
end
end
return mn
end
-- Definir el metamétodo __call
mytable = setmetatable({10}, {
__call = function(mytable, newtable)
sum = 0
for i = 1, table_maxn(mytable) do
sum = sum + mytable[i]
end
for i = 1, table_maxn(newtable) do
sum = sum + newtable[i]
end
return sum
end
})
newtable = {10,20,30}
print(mytable(newtable))
El resultado de salida de la ejecución del ejemplo anterior es:
70
Metamétodo __tostring
El metamétodo __tostring se utiliza para modificar el comportamiento de salida de la tabla. En el siguiente ejemplo, personalizamos el contenido de salida de la tabla:
Ejemplo
__tostring = function(mytable)
sum = 0
for k, v in pairs(mytable) do
sum = sum + v
end
return "La suma de todos los elementos de la tabla es " .. sum
end
})
print(mytable)
El resultado de salida de la ejecución del ejemplo anterior es:
表所有元素的和为 60
De este artículo podemos aprender que las metatablas pueden simplificar muy bien la funcionalidad de nuestro código, por lo que comprender las metatablas de Lua nos permite escribir código Lua más simple y excelente.
Otras extensiones