# Excepciones Cuando ocurre un error (división entre cero, variable inexistente, `rise_error`, una función de biblioteca que falla…), DKL interrumpe la ejecución y la conduce al **bloque `exception` más cercano**. Si no hay ninguno, el programa termina, imprime el mensaje y `dkl` sale con código 1. ## El bloque exception ```text exception { // código que se ejecuta si ocurrió un error } ``` - Se escribe **después** del código que protege, en el mismo bloque (función o programa). - Si no hubo error, el bloque se salta. - Si hubo error, se ejecuta el bloque y luego la ejecución **continúa con lo que sigue al bloque**. - `exception handler { … }` es la misma sentencia con otro nombre. ```dkl calcula :: x { r = 10 / x exception { do print("error: " + last_error()) do clear_exceptions() return -1 } return r } do print(calcula(2)) do print(calcula(0)) do print("fin") ``` ```text 5 error: {1} Error en expresión: Attempted to divide by zero. [ejemplo.dkl][Ln= 9] -1 fin ``` Lo que está entre el error y el bloque `exception` no se ejecuta: ```dkl sigue :: { do rise_error(9, "primero") do print("no se imprime") exception handler { do print("manejador: " + str(last_error_code())) do clear_exceptions() } do print("después del manejador") return 2 } do print(sigue()) ``` ```text manejador: 9 después del manejador 2 ``` Un bloque `exception` **antes** del código no lo protege: el bloque se salta (no había error todavía) y el error posterior no tiene quien lo atienda. ## La pila de excepciones Cada error se guarda en una pila del intérprete. Dentro del manejador: | Función | Qué hace | |---|---| | `last_error()` | Mensaje del último error (`""` si no hay). | | `last_error_code()` | Código numérico del último error (-1 si no hay). | | `pop_exception()` | Saca el último error de la pila; devuelve 1 si había uno, 0 si no. | | `clear_exceptions()` | Vacía la pila. | | `rise_error(código, mensaje)` | Lanza un error propio. | | `errordet(0\|1)` | Mensajes sin (0) o con (1) el detalle `{código}`, archivo y línea. | **Limpie la pila** (`clear_exceptions()` o `pop_exception()`) en el manejador cuando el error ya está atendido. Si no, el error sigue en la pila y `last_error()` / `last_error_code()` lo seguirán devolviendo más adelante, aunque ya no tenga que ver con lo que esté revisando. (Un error atendido sin limpiar no hace fallar el programa: `dkl` termina con código 0.) **Límite de la pila (2.0.2)**: la pila guarda las **100** excepciones más recientes; al pasar de 100 se descartan las más antiguas. `last_error()` y `last_error_code()` siguen dando la última. Hasta 2.0.1 (y en 1.x) los errores atendidos sin limpiar se acumulaban sin límite: un proceso de larga duración (por ejemplo, una tarea de `cron` que atrapa errores en un ciclo sin limpiarlos) crecía en memoria sin fin. Aun con el límite, limpie la pila en el manejador. ## Lanzar errores propios: rise_error ```dkl valida :: &r { if trim(field.dstr(r, "clave", "")) == "" { do rise_error(400, "La clave es obligatoria") } r<"clave">: toupper(trim(field.dstr(r, "clave", ""))) return r } ref ok = from.json("{\"clave\":\" abc-01 \"}") ref r1 = valida(ok) do print(to.json(r1)) ref vacia = from.json("{\"clave\":\" \"}") ref r2 = valida(vacia) exception { do print("Error " + str(last_error_code()) + ": " + last_error()) do clear_exceptions() } ``` ```text {"clave":"ABC-01"} Error 400: {400} La clave es obligatoria[Ln= 11] ``` Use códigos propios con significado (por ejemplo, los de HTTP: 400, 404, 409) para que quien atienda el error pueda decidir qué responder. ## Relanzar Un manejador puede atender parte del problema y volver a lanzarlo, por ejemplo para agregar contexto: ```dkl interna :: { do rise_error(77, "desde interna") } externa :: { do interna() exception { codigo = last_error_code() mensaje = last_error() do rise_error(codigo, "envuelto: " + mensaje) } } principal :: { do externa() exception { do print("final: " + str(last_error_code()) + " " + last_error()) do clear_exceptions() } } do principal() do print("ok") ``` ```text final: 77 {77} envuelto: {77} desde interna[Ln= 9][Ln= 18] ok ``` ## Errores dentro de ciclos Un manejador dentro del cuerpo de la función atiende cada llamada; el ciclo sigue: ```dkl procesa :: n { if mod(n, 2) == 0 { do rise_error(100 + n, "par " + str(n)) } return n exception { do print("err " + last_error()) do clear_exceptions() return 0 - n } } for i = 1; i <= 4 { do print(procesa(i)) } ``` ```text 1 err {102} par 2[Ln= 11] -2 3 err {104} par 4[Ln= 11] -4 ``` ## Formato de los mensajes ```text {código} mensaje [archivo][Ln= línea] ``` - `{1}` es el código de los errores del motor (expresiones, variables, funciones de biblioteca); los de `rise_error` llevan su propio código. - `{1xx}` son errores de sintaxis (al analizar): `{100}` símbolo no esperado, `{109}` elemento incompleto, `{131}` directiva inválida, `{132}` bloque `$$` mal formado, `{9999}` archivo de `#include` no encontrado. Estos no se pueden capturar: el programa no llega a ejecutarse. - Los errores de funciones .NET llegan envueltos: `Error en 'list.str. (… mensaje real …Exception has been thrown by the target of an invocation.)`. - El número de línea puede estar **desfasado** unas líneas por comentarios, líneas en blanco o bloques entre llaves; revise también las anteriores. Vea [Números de línea en los errores](/es/devkron/2.0/lenguaje/numeros-de-linea.md). `errordet(0)` quita el código, archivo y línea del mensaje (útil para mostrarlo a un usuario); `errordet(1)` lo restaura: ```dkl do errordet(0) do rise_error(3, "Mensaje para el usuario") exception { do print(last_error()) do clear_exceptions() } do errordet(1) do rise_error(3, "Mensaje para el usuario") exception { do print(last_error()) do clear_exceptions() } ``` ```text Mensaje para el usuario {3} Mensaje para el usuario[Ln= 15] ``` En 2.0, en un servidor FastCGI, `errordet()` vale solo para esa ejecución (en 1.x afectaba a todo el proceso). ## Errores en un servidor web Un error no atendido en una página hace que el controlador estándar responda la página de error (`@http_500`). En 2.0 esa respuesta llega al navegador con estado **500** (en 1.x llegaba con 200). Si un `fetch` o AJAX esperaba siempre 200, revise su manejo de errores. Vea [Desarrollo web](/es/devkron/2.0/marcos/). ## Errores más comunes Vea [Errores frecuentes](/es/devkron/2.0/lenguaje/errores-frecuentes.md).