El constructor :new()

Parte de la sección Object Oriented Programming del Journey de Lua de Coddy — lección 8 de 70.

Crear objetos manualmente —crear una tabla vacía, configurar su metatabla, vincular __index— se vuelve repetitivo. La solución estándar es definir un método constructor :new() directamente en la clase que maneje todo esto por ti.

Aquí está el patrón:

local Dog = {}
Dog.__index = Dog

function Dog:new()
    local instance = {}
    setmetatable(instance, self)
    return instance
end

function Dog:bark()
    print("Woof!")
end

Analicemos qué sucede dentro de :new(). Primero, creamos una tabla vacía llamada instance. Luego, establecemos su metatabla a self—que es Dog cuando llamamos a Dog:new().

Dado que Dog.__index apunta a Dog mismo, la instancia puede encontrar todos los métodos definidos en Dog. Finalmente, devolvemos el nuevo objeto.

Observa la línea Dog.__index = Dog fuera del constructor. Este es un atajo común: en lugar de crear una metatabla separada, la tabla de la clase sirve tanto de prototipo como de metatabla.

Ahora la creación de objetos es limpia y consistente:

local myDog = Dog:new()
myDog:bark()  -- Salida: Woof!

Cada clase que crees seguirá esta misma estructura. El constructor :new() se convierte en el único lugar donde ocurre la creación de objetos, haciendo que tu código sea organizado y predecible.

Desafío

Fácil

Vamos a construir una clase Cat utilizando el patrón de constructor estándar que acabas de aprender. Organizarás tu código en dos archivos para practicar la estructura adecuada de módulos.

Crearás:

Cat.lua: Define tu clase Cat con el patrón de constructor completo. Tu clase debe incluir:
- La tabla de la clase con __index apuntando a sí misma
- Un constructor :new() que cree una instancia, establezca su metatabla y la devuelva
- Un método :meow() que imprima el sonido del gato
Devuelve la tabla de la clase al final del archivo.
main.lua: Requiere tu módulo Cat y utiliza el constructor para crear una instancia de gato. Luego llama a su método para verificar que todo esté vinculado correctamente.

Recibirás una entrada: el número de veces que tu gato debe maullar.

Tu método :meow() debe imprimir exactamente:

Meow!

En tu archivo principal, crea un gato usando Cat:new() y llama a :meow() el número de veces especificado.

Por ejemplo, si la entrada es 3, la salida debería ser:

Meow!
Meow!
Meow!

Hoja de referencia

Para crear una clase con un constructor en Lua, define un método :new() que cree instancias:

local ClassName = {}
ClassName.__index = ClassName

function ClassName:new()
    local instance = {}
    setmetatable(instance, self)
    return instance
end

function ClassName:method()
    -- method implementation
end

El campo __index apunta a la propia clase, permitiendo que las instancias accedan a los métodos definidos en la tabla de la clase.

Dentro de :new():

Crea una tabla vacía para la instancia
Establece su metatabla a self (la clase)
Devuelve la nueva instancia

Crea objetos utilizando el constructor:

local obj = ClassName:new()
obj:method()

Pruébalo tú mismo

-- Requerir el módulo Cat
local Cat = require('Cat')

-- Leer entrada: número de veces a maullar
local times = tonumber(io.read())

-- TODO: Crear una instancia de gato usando Cat:new()

-- TODO: Llamar al método :meow() el número de veces especificado