35 / Avanzado

Manejo de Errores

Nyx ofrece try/catch para errores recuperables y panic para los irrecuperables. panic(msg) lanza un error de tipo string que se puede capturar: termina el programa a menos que sea capturado dentro de un bloque try circundante. throw es un alias deprecado de panic, y nyx vet lo marca.

35-error-handling.nxFuente →
// Manejo de errores: try/catch con panic (throw es un alias deprecado de panic)

fn dividir(a: int, b: int) -> int {
    if b == 0 {
        panic("division por cero: denominador es 0")
    }
    return a / b
}

fn main() -> int {
    // Capturar un panic explícito
    var resultado: String = ""
    try {
        let r: int = dividir(10, 0)
        resultado = int_to_string(r)
    } catch(e: String) {
        resultado = "Error capturado: " + e
    }
    print(resultado)

    // try normal (sin error)
    var ok: String = ""
    try {
        let r: int = dividir(20, 4)
        ok = "resultado: " + int_to_string(r)
    } catch(e: String) {
        ok = "inesperado: " + e
    }
    print(ok)

    // Capturar panic
    var panic_msg: String = ""
    try {
        panic("algo salio muy mal")
    } catch(e: String) {
        panic_msg = "panic atrapado: " + e
    }
    print(panic_msg)

    // try anidado
    var externo: String = ""
    try {
        try {
            panic("error interno")
        } catch(e: String) {
            externo = "manejado: " + e
        }
    } catch(e: String) {
        externo = "no deberia llegar aqui"
    }
    print(externo)

    return 0
}
Salidastdout
Error capturado: division por cero: denominador es 0
resultado: 5
panic atrapado: algo salio muy mal
manejado: error interno

Cómo funciona

panic(msg) lanza un error que desenrolla la pila hasta la cláusula catch más cercana que lo envuelve. El valor capturado e tiene tipo String, correspondiéndose con lo que se le pasó a panic. Cuando no ocurre ningún error, el bloque catch se omite por completo, así que la llamada dividir(20, 4) va directo a su resultado.

panic señala una condición irrecuperable — por defecto aborta el proceso, pero también se puede capturar con try/catch cuando la recuperación es genuinamente posible. Esto lo hace útil para aserciones durante el desarrollo que pueden envolverse en tests.

Los bloques try anidados permiten manejar los errores internos localmente sin propagarlos a los manejadores externos. En el último ejemplo, el catch interno maneja "error interno" por completo, así que nunca se llega al catch externo.