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:

mytable = {}                          -- tabla ordinaria
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
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

mytable = setmetatable({key1 = "value1"}, {
  __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í:

mytable = setmetatable({key1 = "value1"}, { __index = { key2 = "metatablevalue" } })
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

mymetatable = {}
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

mytable = setmetatable({key1 = "value1"}, {
    __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

-- Función personalizada table_maxn para calcular el valor máximo de clave en la tabla, es decir, devuelve el mayor valor de clave de la tabla
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ónDescripción
__addOperador correspondiente '+'.
__subOperador correspondiente '-'.
__mulOperador correspondiente '*'.
__divOperador correspondiente '/'.
__modOperador correspondiente '%'.
__unmOperador correspondiente '-'.
__concatOperador correspondiente '..'.
__eqOperador correspondiente '=='.
__ltOperador correspondiente '<'.
__leOperador 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

-- Calcular el valor máximo de la tabla; table.maxn ya no está disponible en versiones superiores a Lua 5.2
-- 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

mytable = setmetatable({ 10, 20, 30 }, {
  __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