Lua Academy · Lección

Herencia simple con encadenamiento de __index

Establezca una clase principal como __index de una metatabla para heredar métodos.

Herencia simple con encadenamiento de __index es una lección gratuita de Lua Academy en CoddyKit. Esta es la lección 1 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.

Cadena de prototipos

La herencia simple funciona estableciendo __index de la clase hija en la clase padre. Cuando no se encuentra un método en la hija, Lua lo busca en el padre. Así se crea una cadena de prototipos.

local Base={}
Base.__index=Base
function Base.new() return setmetatable({},Base) end
function Base:greet() print("Hello from Base") end

local Child={}
Child.__index=Child
setmetatable(Child,{__index=Base})  -- Child inherits Base

function Child.new() return setmetatable({},Child) end

local c=Child.new()
c:greet()  -- Hello from Base (inherited)

Orden de resolución de métodos

Al llamar a un método sobre una instancia: (1) se busca en la tabla de la instancia, (2) se busca en Child (mediante __index), (3) se busca en Base (mediante el __index de la metatabla de Child). Gana la primera coincidencia.

local Base={}
Base.__index=Base
function Base:who() print("I am Base") end

local Child={}
Child.__index=Child
setmetatable(Child,{__index=Base})
function Child:who() print("I am Child") end  -- override

local b=setmetatable({},Base)
local c=setmetatable({},Child)
b:who()  -- I am Base
c:who()  -- I am Child (overrides)

Herencia de constructores

Las clases hijas pueden reutilizar los constructores de los padres llamándolos, o definir los suyos propios para ampliar la inicialización del padre.

local Animal={}
Animal.__index=Animal
function Animal.new(name,sound)
  return setmetatable({name=name,sound=sound},Animal)
end
function Animal:speak() print(self.name..": "..self.sound) end

local Dog={}
Dog.__index=Dog
setmetatable(Dog,{__index=Animal})

function Dog.new(name)
  local self = Animal.new(name,"Woof")
  return setmetatable(self,Dog)
end
function Dog:fetch(item) print(self.name.." fetches "..item) end

local d=Dog.new("Rex")
d:speak(); d:fetch("ball")

Comprobar la ascendencia

Recorra la cadena de metatablas para comprobar si la clase de un objeto hereda de una base determinada. Así funciona instanceof en Lua.

local function instanceof(obj, cls)
  local mt = getmetatable(obj)
  while mt do
    if mt == cls then return true end
    mt = getmetatable(mt)
  end
  return false
end

Llamada al padre

Llame a la versión del padre de un método sobrescrito accediendo directamente a ella mediante la tabla de la clase padre.

local Base={}
Base.__index=Base
function Base:init(x) self.x=x end
function Base:value() return self.x end

local Child={}
Child.__index=Child
setmetatable(Child,{__index=Base})
function Child:init(x,y)
  Base.init(self,x)  -- call parent
  self.y=y
end
function Child:value() return Base.value(self)+self.y end

local c=setmetatable({},Child)
c:init(3,4)
print(c:value())  -- 7

Cadena profunda

Construya una jerarquía de tres niveles: A → B → C. La búsqueda de métodos recorre toda la cadena hasta encontrarlo.

local A={}
A.__index=A
function A:aMethod() print("A method") end

local B={}
B.__index=B
setmetatable(B,{__index=A})
function B:bMethod() print("B method") end

local C={}
C.__index=C
setmetatable(C,{__index=B})

local c=setmetatable({},C)
c:bMethod()  -- from B
c:aMethod()  -- from A

Sobrescritura de campos

Una instancia puede sobrescribir campos de nivel de clase estableciéndolos directamente. El campo de la clase no cambia: solo queda oculto para esa instancia.

local Creature={}
Creature.__index=Creature
Creature.hp=100
Creature.speed=10

function Creature.new()
  return setmetatable({},Creature)
end

local fast=Creature.new()
fast.speed=20  -- override for this instance

local normal=Creature.new()

print(fast.speed,normal.speed,Creature.speed)  -- 20  10  10

Herencia a nivel de clase

Establecer setmetatable(Child, {__index=Parent}) hace que las búsquedas a nivel de clase continúen en el padre. Esto significa que Child.classMethod() encuentra los métodos de la clase padre si no se han sobrescrito.

local Vehicle={}
Vehicle.__index=Vehicle
Vehicle.maxSpeed=120
function Vehicle.describe() print("Vehicle") end

local Car={}
Car.__index=Car
setmetatable(Car,{__index=Vehicle})

Car.describe()  -- Vehicle (inherited class method)
print(Car.maxSpeed)  -- 120 (inherited class field)

Cadena de inicialización

Para lograr una inicialización correcta, los constructores hijos llaman a los constructores padres para garantizar que el estado del padre quede configurado. Encadene la inicialización a lo largo de la jerarquía.

local Base={}
Base.__index=Base
function Base:_init(name) self.name=name end

local Mid={}
Mid.__index=Mid
setmetatable(Mid,{__index=Base})
function Mid:_init(name,level)
  Base._init(self,name)
  self.level=level
end

local Top={}
Top.__index=Top
setmetatable(Top,{__index=Mid})
function Top.new(name,level,role)
  local self=setmetatable({},Top)
  Mid._init(self,name,level)
  self.role=role
  return self
end

local t=Top.new("Alice",5,"admin")
print(t.name,t.level,t.role)

Clases base abstractas

Cree una clase base con métodos no implementados que produzcan errores. Las subclases deben sobrescribir estos métodos. Esto impone contratos de interfaz en el sistema de tipos dinámico de Lua.

local Serializer={}
Serializer.__index=Serializer
function Serializer:encode(data)
  error(self._type.." must implement encode()",2)
end
function Serializer:decode(str)
  error(self._type.." must implement decode()",2)
end

local JSONSerializer={_type="JSON"}
setmetatable(JSONSerializer,{__index=Serializer})
function JSONSerializer:encode(data)
  return "{"..tostring(data.key).."}"
end

local j=setmetatable({_type="JSON"},JSONSerializer)
print(j:encode({key="val"}))

Pregunta sobre herencia

¿Qué permite la herencia simple en Lua?

Repaso: herencia simple

Establezca setmetatable(Child, {__index = Parent}) para heredar métodos. La cadena __index proporciona delegación automática. Sobrescriba definiendo métodos en Child; llame explícitamente al padre con Parent.method(self).

Preguntas frecuentes

¿La lección «Herencia simple con encadenamiento de __index» es gratis?

Sí — el texto completo de «Herencia simple con encadenamiento de __index» 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 «Herencia simple con encadenamiento de __index»?

Establezca una clase principal como __index de una metatabla para heredar mé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 1 de 4.

¿Cuánto tiempo toma la lección «Herencia simple con encadenamiento de __index»?

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

Herencia simple con encadenamiento de __index
Llamada a métodos de la clase principal con super
Patrones mixin
Sobrescritura y polimorfismo

← Volver a Lua Academy