Lua Academy · Lección

La función error()

Genere errores con error() y comprenda los niveles y mensajes de error.

La función error() 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.

Lanzar errores

error(message, level) lanza un error de Lua. La ejecución se detiene y el error se propaga por la pila de llamadas hasta que lo captura pcall o xpcall, o hasta que termina el programa. El mensaje puede ser cualquier valor: cadena, tabla o número.

local function divide(a, b)
  if b == 0 then
    error("division by zero")
  end
  return a / b
end

print(divide(10, 2))    -- 5.0
-- divide(10, 0)        -- ERROR: division by zero

Niveles de error

El segundo argumento de error() controla dónde se informa del error. El nivel 1 (predeterminado) señala la propia llamada a error(). El nivel 2 señala a quien realizó la llamada. El nivel 0 no añade información de posición. Use el nivel 2 en las funciones de biblioteca para señalar el código del usuario como origen del error.

local function assertPositive(n, name)
  if n <= 0 then
    error((name or "value") .. " must be positive, got " .. n, 2)
    -- level 2: blame the caller, not this function
  end
  return n
end

local function compute(x)
  assertPositive(x, "x")   -- error points here if x <= 0
  return math.sqrt(x)
end

compute(-5)  -- error: "x must be positive, got -5" at compute() call

Errores con objetos tabla

Pasar una tabla como valor del error permite que quien realiza la llamada inspeccione información estructurada del error: código de error, mensaje y contexto. Esto es más informativo que una cadena simple y permite gestionar los errores mediante programación.

local function openDB(host, port)
  if port < 1 or port > 65535 then
    error({code="INVALID_PORT", port=port,
           msg="port out of range: " .. port})
  end
  -- ... connect
  return {host=host, port=port}
end

local ok, err = pcall(openDB, "localhost", -1)
if not ok and type(err) == "table" then
  print("Code:", err.code)    -- INVALID_PORT
  print("Port:", err.port)    -- -1
  print("Msg:", err.msg)
end

assert() como abreviatura

assert(v, msg) equivale a if not v then error(msg, 2) end; return v, .... Es una forma idiomática de comprobar precondiciones. Si v es verdadero, assert devuelve todos sus argumentos (lo que resulta útil para encadenar llamadas).

local function sqrt(n)
  assert(type(n) == "number", "expected number, got " .. type(n))
  assert(n >= 0, "sqrt of negative: " .. n)
  return math.sqrt(n)
end

print(sqrt(16))    -- 4.0
print(sqrt(2))     -- 1.4142...
-- sqrt("hi")      -- ERROR: expected number, got string

error() frente a return nil,err

Hay dos convenciones para indicar un fallo: error() (estilo de excepciones) o return nil, msg (estilo funcional). Use error() para condiciones realmente inesperadas (errores de programación o incumplimientos del contrato). Use nil, msg para fallos esperados (archivo no encontrado o tiempo de espera agotado de la red).

-- Exception style (programming error)
local function mustExist(t, key)
  local v = t[key]
  if v == nil then error("required key missing: " .. key, 2) end
  return v
end

-- Functional style (expected failure)
local function findUser(id)
  -- ... database query
  return nil, "user not found"  -- expected: user may not exist
end

Errores en metamétodos

Los errores pueden lanzarse dentro de metamétodos. Si un metamétodo produce un error, este se propaga al código que desencadenó la operación (por ejemplo, una expresión aritmética). Proteja siempre los metamétodos frente a entradas no válidas.

local SafeDiv = {}
SafeDiv.__index = SafeDiv

SafeDiv.__div = function(a, b)
  if b.value == 0 then
    error("SafeDiv: division by zero", 2)
  end
  return SafeDiv.new(a.value / b.value)
end

function SafeDiv.new(v)
  return setmetatable({value=v}, SafeDiv)
end

local a = SafeDiv.new(10)
local b = SafeDiv.new(0)
local ok, err = pcall(function() return a / b end)
print(ok, err)

Tipos de error personalizados

Cree una función auxiliar para construir objetos de error tipados. Incluya una etiqueta de tipo para que quienes llamen puedan distinguir entre distintos tipos de errores y gestionarlos adecuadamente.

local function newError(kind, msg, extra)
  return setmetatable(
    {kind=kind, message=msg, extra=extra},
    {__tostring = function(e)
      return "[" .. e.kind .. "] " .. e.message
    end}
  )
end

local E = {
  notFound = function(name) return newError("NOT_FOUND","not found: "..name) end,
  badInput = function(msg)  return newError("BAD_INPUT", msg) end,
}

local ok, err = pcall(error, E.notFound("config.json"))
if not ok then print(err.kind, err.message) end

Propagación de errores

Cuando una función llama a otra que produce un error, este se propaga automáticamente por la pila de llamadas. No necesita volver a lanzarlo: simplemente no lo capture. Capture los errores únicamente en el nivel en el que pueda gestionarlos o notificarlos de forma significativa.

local function step3() error("step3 failed") end
local function step2() step3() end
local function step1() step2() end

local ok, err = pcall(step1)
if not ok then
  -- err includes the source location
  print("Caught at top level:", err)
end
-- Error: input:1: step3 failed

Traza de la pila con debug.traceback

Un error() simple proporciona una sola línea de contexto. Para obtener una traza completa de la pila, use debug.traceback(msg) como valor del error. Normalmente esto se hace en un controlador de xpcall.

local function buggy()
  local t = nil
  return t.field   -- nil indexing: error
end

local ok, err = xpcall(buggy, function(e)
  return debug.traceback(e, 2)  -- full stack trace
end)

if not ok then
  print(err)  -- full traceback
end

Volver a lanzar errores

A veces se captura un error para añadir contexto y después se vuelve a lanzar. Use error(err, 0) (nivel 0) al volver a lanzar un error de tipo cadena, para evitar añadir otro prefijo de ubicación a un mensaje que ya está formateado.

local function loadAndParse(path)
  local ok, err = pcall(function()
    local f = io.open(path, "r")
    if not f then error("cannot open: " .. path) end
    local content = f:read("a")
    f:close()
    return content
  end)
  if not ok then
    error("loadAndParse failed: " .. err, 0)  -- re-raise with context
  end
end

local ok2, msg = pcall(loadAndParse, "missing.txt")
print(ok2, msg)

Comprobación rápida

¿Qué significa el nivel 2 en error("msg", 2)?

Resumen: error()

Resumen:

error(msg, level) — lanza un error; el nivel 2 responsabiliza a quien llama
Use tablas para representar errores estructurados con tipo y contexto
assert(v, msg) — comprobación idiomática de precondiciones
Use error() para errores de programación; devuelva nil+err para fallos esperados
Vuelva a lanzar con error(err, 0) para conservar el formato del mensaje

Preguntas frecuentes

¿La lección «La función error()» es gratis?

Sí — el texto completo de «La función error()» 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 «La función error()»?

Genere errores con error() y comprenda los niveles y mensajes de error. 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 «La función error()»?

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