Lua Academy · Lección

Metamétodos aritméticos

Sobrecargue +, -, *, / y otros operadores mediante metamétodos.

Metamétodos aritméticos es una lección gratuita de Lua Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Lua Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Lua Academy incluye 4 lecciones en total.

Nombres de los metamétodos

Lua define metamétodos para todos los operadores aritméticos. Cuando Lua encuentra una operación aritmética sobre una tabla, busca el metamétodo correspondiente en la metatabla de la tabla. Si ambos operandos son tablas, Lua comprueba primero la metatabla del operando izquierdo.

-- Operator -> Metamethod
-- a + b    -> __add
-- a - b    -> __sub
-- a * b    -> __mul
-- a / b    -> __div
-- a % b    -> __mod
-- a ^ b    -> __pow
-- a // b   -> __idiv
-- -a       -> __unm (unary minus)
-- #a       -> __len
print("Metamethods defined for all Lua operators")

__add para sumar vectores

Defina __add en una tabla de vectores para admitir +. El metamétodo recibe dos operandos y devuelve un valor nuevo. Ambos operandos pueden ser tablas o uno de ellos puede ser un número; su metamétodo debe gestionar ambos casos.

local Vec = {}
Vec.__index = Vec

Vec.__add = function(a, b)
  return setmetatable({x=a.x+b.x, y=a.y+b.y}, Vec)
end

Vec.__tostring = function(v)
  return string.format("Vec(%g,%g)", v.x, v.y)
end

function Vec.new(x,y) return setmetatable({x=x,y=y},Vec) end

local v1 = Vec.new(1,2)
local v2 = Vec.new(3,4)
print(tostring(v1 + v2))   -- Vec(4,6)

sub mul __div

Defina __sub, __mul y __div de forma similar. Para la multiplicación, gestione los casos tabla*tabla y tabla*número comprobando los tipos de los operandos dentro del metamétodo.

local Vec = {}
Vec.__index = Vec
local function V(x,y) return setmetatable({x=x,y=y},Vec) end
Vec.__sub = function(a,b) return V(a.x-b.x, a.y-b.y) end
Vec.__mul = function(a,b)
  if type(a)=="number" then return V(a*b.x, a*b.y)
  elseif type(b)=="number" then return V(a.x*b, a.y*b)
  else return a.x*b.x + a.y*b.y  -- dot product
  end
end
Vec.__tostring=function(v) return "("..v.x..","..v.y..")" end

local v = V(3,4)
print(tostring(v * 2))    -- (6,8)
print(tostring(V(1,0) - V(0,1)))  -- (1,-1)

__unm: menos unario

__unm es el metamétodo del menos unario, que se invoca cuando Lua evalúa -obj. Recibe el operando (el mismo valor dos veces, por coherencia) y devuelve el valor negado.

local Vec = {}
Vec.__index = Vec
local function V(x,y) return setmetatable({x=x,y=y},Vec) end
Vec.__unm = function(a) return V(-a.x, -a.y) end
Vec.__tostring = function(v)
  return string.format("(%g,%g)", v.x, v.y)
end

local v = V(3, -4)
print(tostring(-v))    -- (-3,4)
print(tostring(-(-v))) -- (3,-4)

__len para longitudes personalizadas

__len se llama cuando se evalúa #obj sobre una tabla que no tiene una secuencia entera sin interrupciones. Defínalo para devolver una «longitud» significativa en tipos personalizados, como conjuntos, colas o contenedores ponderados.

local Bag = {}
Bag.__index = Bag
Bag.__len = function(b) return b._count end

function Bag.new()
  return setmetatable({_count=0, _items={}}, Bag)
end
function Bag:add(item, qty)
  self._items[item] = (self._items[item] or 0) + (qty or 1)
  self._count = self._count + (qty or 1)
end

local bag = Bag.new()
bag:add("apple", 3)
bag:add("banana", 2)
print(#bag)   -- 5

mod y pow

__mod gestiona el operador %; __pow gestiona ^. Son menos comunes, pero resultan útiles para tipos numéricos personalizados, como enteros grandes, fracciones u objetos de aritmética modular.

local Modular = {}
Modular.__index = Modular
local M = 1000000007

local function mod(n)
  return setmetatable({n = n % M}, Modular)
end

Modular.__add = function(a,b) return mod(a.n + b.n) end
Modular.__mul = function(a,b) return mod(a.n * b.n) end
Modular.__pow = function(a,b)
  local r, base, exp = mod(1), a, b
  while exp > 0 do
    if exp%2==1 then r = r*base end
    base = base*base; exp = math.floor(exp/2)
  end
  return r
end

print((mod(2) ^ 30).n)   -- 73741817 (2^30 mod 1e9+7)

__concat

__concat se activa mediante el operador .. cuando al menos uno de los operandos tiene este metamétodo. Esto permite definir la concatenación para tipos personalizados o crear DSL fluidos.

local Builder = {}
Builder.__index = Builder
Builder.__concat = function(a, b)
  local result = {}
  for _, v in ipairs(a._parts) do result[#result+1] = v end
  if type(b) == "string" then result[#result+1] = b
  else for _, v in ipairs(b._parts) do result[#result+1] = v end end
  return setmetatable({_parts=result}, Builder)
end
Builder.build = function(b) return table.concat(b._parts) end

local function S(s) return setmetatable({_parts={s}},Builder) end
print((S("Hello") .. ", " .. S("World") .. "!"):build())

Metamétodos de comparación

__eq define == para tablas (solo se llama cuando ambos operandos tienen la misma metatabla). __lt define <; __le define <=. Nota: ~= usa __eq; > usa __lt con los argumentos invertidos; >= usa __le.

local Vec = {}
Vec.__index = Vec
local function V(x,y) return setmetatable({x=x,y=y},Vec) end

Vec.__eq = function(a,b) return a.x==b.x and a.y==b.y end
Vec.__lt = function(a,b)
  return (a.x^2+a.y^2) < (b.x^2+b.y^2)  -- by magnitude
end

print(V(1,2) == V(1,2))  -- true
print(V(1,2) == V(1,3))  -- false
print(V(1,0) < V(2,0))   -- true (1 < 2)

Encadenar metamétodos

Como los metamétodos devuelven valores (normalmente tablas nuevas), las operaciones se pueden encadenar de forma natural. Cada operador devuelve un objeto nuevo y el operador siguiente utiliza ese resultado. Esto permite crear expresiones aritméticas fluidas con tipos personalizados.

local Vec = {}
Vec.__index = Vec
local function V(x,y) return setmetatable({x=x,y=y},Vec) end
Vec.__add = function(a,b) return V(a.x+b.x,a.y+b.y) end
Vec.__mul = function(a,b)
  if type(b)=="number" then return V(a.x*b,a.y*b) end
  return V(a.x*b.x+a.y*b.y, 0)   -- simplified
end
Vec.__tostring=function(v) return "("..v.x..","..v.y..")" end

local result = V(1,0) + V(0,1) * 3
print(tostring(result))   -- (1,3)

Operaciones con tipos mixtos

Cuando escribe vec * 2, el operando izquierdo es la tabla. Cuando escribe 2 * vec, el operando izquierdo es un número (sin metamétodo), por lo que Lua comprueba la metatabla del operando derecho en busca de __mul. Gestione ambos órdenes en su metamétodo.

local Vec = {}
Vec.__index = Vec
local function V(x,y) return setmetatable({x=x,y=y},Vec) end
Vec.__tostring = function(v) return "("..v.x..","..v.y..")" end

Vec.__mul = function(a, b)
  if type(a) == "number" then
    return V(a*b.x, a*b.y)   -- scalar * vec
  elseif type(b) == "number" then
    return V(a.x*b, a.y*b)   -- vec * scalar
  end
  return a.x*b.x + a.y*b.y  -- dot product
end

print(tostring(V(1,2) * 3))  -- (3,6)
print(tostring(3 * V(1,2)))  -- (3,6)

Comprobación rápida

¿Qué metamétodo se activa mediante -myTable?

Repaso: metamétodos aritméticos

Resumen:

__add __sub __mul __div __mod __pow __idiv: aritmética binaria
__unm: menos unario; __len: operador #
__concat: operador ..
__eq __lt __le: operadores de comparación
Gestione los tipos mixtos (número/tabla) dentro de los metamétodos

Preguntas frecuentes

¿La lección «Metamétodos aritméticos» es gratis?

Sí — el texto completo de «Metamétodos aritméticos» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Lua Academy, actualiza a CoddyKit PRO. El curso de Lua Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Metamétodos aritméticos»?

Sobrecargue +, -, *, / y otros operadores mediante metamétodos. Practicas Lua Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Lua Academy?

No se requiere experiencia previa. Lua Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «Metamétodos aritméticos»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Lua Academy?

Sí. Cada lección de Lua Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Lua Academy