# Errores frecuentes al programar en DKL Errores comunes al escribir programas en Devkron 2.0, con el mensaje que producen y la forma correcta. Todos los mensajes son la salida real del motor. ## Un archivo incluido empieza en modo declarativo Un archivo insertado con `#include` se interpreta desde el contexto **declarativo**, aunque el programa principal esté en modo imperativo. Si el archivo contiene funciones o código, debe empezar con `#!`: ```dkl module "Utilerías de ejemplo:util" { saludo :: nombre { return "Hola, " + nombre } } ``` ```dkl #include "dkli.dkh" #! program "include-sin-bang" { #include "functions.dkh" #include "lib/sin_bang.dkh" do print(util.saludo("Ana")) } ``` ```text {1} Error en expresión: Función: util.saludo no reconocida o no registrada [ejemplo.dkl][Ln= 7] ``` Corrección: la primera línea de `lib/sin_bang.dkh` debe ser `#!`. ## La sentencia include en modo declarativo La sentencia `include "archivo"` (sin `#`) solo se ejecuta en contexto imperativo. Escrita dentro de un elemento declarativo, no hace nada: aparece en la salida como un elemento. ```dkl #include "dkli.dkh" #! codeblock "parte" { do print("parte ejecutada") } ``` ```dkl #include "dkli.dkh" #! program "include-declarativo" { #include "functions.dkh" #$ pagina { include "lib/parte.dkl" } } ``` ```text ``` Corrección: anteponga `#!` (y regrese con `#$` si sigue HTML): ```dkl #$ pagina { #! include "lib/parte.dkl" #$ } ``` ## Las bibliotecas van después de dkli.dkh y dentro del nodo raíz ```dkl #include "functions.dkh" #include "dkli.dkh" #! program "orden-incorrecto" { do print(trim(" x ")) } ``` ```text {109} Error de sintaxis [/opt/devkron/functions.dkh] [109] - Definición de elemento incompleta, falta: (), declaración de atributos o elementos hijo[Ln= 3] ``` El orden correcto es `#include "dkli.dkh"`, `#!`, `program "…" {` y adentro `#include "functions.dkh"`. ## Los dos puntos en la descripción de module definen un espacio de nombres En `module "descripción:espacio.de.nombres"`, lo que sigue a `:` es el espacio de nombres y se antepone al nombre de las funciones. `module "utilerías: lectura"` hace que la función `saludo` se llame ` lectura.saludo`, y llamarla como `saludo(...)` fuera del bloque produce `Función: saludo no reconocida o no registrada`. - Si solo quiere una descripción, no use `:` en medio, o póngalo al final: `module "Utilerías de ejemplo:"`. - Si quiere un espacio de nombres, llame a las funciones con el nombre completo: `util.saludo("Ana")` para `module "Utilerías:util"`. `dump_functions()` muestra el nombre completo con que quedó registrada cada función. ## Función no reconocida: se llamó antes de declararla ```dkl do print(total(2)) total :: n { return n * 10 } ``` ```text {1} Error en expresión: Función: total no reconocida o no registrada [ejemplo.dkl][Ln= 7] ``` Las funciones deben declararse antes del código que las llama. Ponga las funciones (o los `#include` de sus bibliotecas) al principio. ## "Tipos no coinciden" Un número y una cadena no se mezclan en ninguna operación: ```dkl total = 15 do print("Total: " + total) ``` ```text {1} Error en expresión: Tipos no coinciden [ejemplo.dkl][Ln= 8] ``` Corrección: `"Total: " + str(total)`. Lo mismo con `"5" == 5`: compare `val("5") == 5` o `"5" == str(5)`. ### Una función que devolvió 0 Si una función no ejecuta ningún `return`, devuelve `0`. Cuando se esperaba una cadena, el error aparece después, al usar el resultado: ```dkl nombre.cliente :: id { if id > 0 { return "Cliente " + str(id) } } do print("Nombre: " + nombre.cliente(0)) ``` ```text {1} Error en expresión: Tipos no coinciden [ejemplo.dkl][Ln= 11] ``` Asegúrese de que todas las rutas de la función devuelvan un valor del tipo esperado. ### Una variable que ya tenía otro tipo ```dkl folio = 0 folio = "A-15" ``` ```text {1} La variable 'folio' ya fué inicializada con un tipo diferente al de la asignación [ejemplo.dkl][Ln= 8] ``` DKL es de tipado estático: use otra variable, o declare `folio = ""` desde el principio. ### Leer un campo con < > dentro de una expresión `r<"campo">` es una sentencia de asignación, no una expresión: ```dkl new r { @"nombre": "Ana" } saludo = "Hola " + r<"nombre"> ``` ```text {1} Error en expresión: Tipos no coinciden [ejemplo.dkl][Ln= 8] ``` En expresiones use `@@(r, "nombre")` o `r.nombre`. ## El número de línea de un error puede estar desfasado El número de línea que informa un error puede no coincidir con la línea del problema: los comentarios, las líneas en blanco y los bloques entre llaves pueden desplazarlo. En este ejemplo el error está en la línea 11 (`return x / 0`) y el motor informa la 9: ```dkl #include "dkli.dkh" #! program "lineas" { #include "functions.dkh" /* Este comentario ocupa tres líneas */ calcula :: x { return x / 0 } r = calcula(5) } ``` ```text {1} Error en expresión: Attempted to divide by zero. [ejemplo.dkl][Ln= 9] ``` Revise también las líneas cercanas a la indicada. Dentro de un bloque `$$`, el mensaje trae además la línea del bloque (`(bloque $$, línea 36)`), que también puede desfasarse en archivos con saltos LF y líneas en blanco. Las causas y cómo leer el número están en [Números de línea en los errores](/es/devkron/2.0/lenguaje/numeros-de-linea.md); `dkl-debug` da la línea real (vea [Depuración](/es/devkron/2.0/instalacion/depuracion.md)). ## El incremento del for Si el incremento es de uno en uno, no se escribe. Si es distinto, se escribe **solo la expresión** (`a+2`), no una asignación: ```dkl for i = 0; i < 3; i = i + 1 { do print(i) } ``` ```text 0 {1} Error en expresión: Operador inválido [ejemplo.dkl][Ln= 10] ``` Correcto: `for i = 0; i < 3` o `for i = 0; i < 3; i+1`. ## No hay -x, %, !, += ni ; | Escrito | Mensaje | Corrección | |---|---|---| | `-n` | `Símbolo inválido` | `0 - n` | | `a % b` | `Operador inválido` | `mod(a, b)` | | `!activo` | `Símbolo inválido` | `not(activo)` | | `a += 1` | `{100} Símbolo no esperado` | `a = a + 1` | | `x = 1;` | `Falta una expresión a la derecha del operador ';'` | sin `;` | | `"a" < "b"` | `Operación de cadenas inválida` | compare con `==`/`!=` o con funciones de cadena | | `1.5e3` | `Se esperaba un operador` | `1500` | Los paréntesis alrededor de la condición de `if` o `while` no son necesarios, pero se permiten: `if (a > 0)` funciona igual que `if a > 0`. ## Una función suelta como sentencia ```dkl print("hola") ``` ```text {111} Error de sintaxis [/home/usuario/ejemplos/ejemplo.dkl] [111] - Se ha indicado una lista de valores de atributos por orden, pero no hay una definición del elemento[Ln= 7] ``` Sin `do`, la línea se toma como un elemento declarativo con atributos por orden. Use `do print("hola")` o `call print("hola")`. Lo mismo con sentencias que empiezan con algo que no es un identificador: `1, a -> l` da `{100} Símbolo no esperado`. ## list.add espera un objeto `list.add(lista, valor)` agrega una **referencia**. Con un número o una cadena numérica no agrega el valor: agrega el objeto cuyo índice es ese número, sin ningún error, y el JSON resultante sale mal. ```dkl ref l = list.create() do list.add(l, "3") do list.add(l, "hola") do print(to.json(l)) ref bien = list.create() do list.addstr(bien, "3") do list.addnum(bien, 3) do print(to.json(bien)) ``` ```text [{},"hola"] ["3",3] ``` En 2.0 use `list.addstr`, `list.addnum`, `list.addobj` o las flechas (`a, b -> l`). (En 1.x la alternativa era `list.add(l, from.json('"33"'))`, que sigue funcionando.) ## Un objeto guardado como número Una expresión que devuelve un objeto vale su **índice** en la tabla de objetos. Si guarda un objeto en un campo sin `*`, queda un número: ```dkl ref l = list.of("x") new r { @"lista": l @"lista_bien*": l } do print(to.json(r)) ``` ```text {"lista":8,"lista_bien":["x"]} ``` Use `@"campo*": objeto`, `r<"campo*">: objeto`, `r.campo := ref objeto` o un bloque `$$` (`{$$ "campo": l $$}`). ## Un miembro por línea en los registros Cada miembro de `new`, `using` o `member` va en su propia línea: ```dkl new r { @"a":1 @"b":2 } ``` ```text {1} Error en expresión: Se esperaba un operador [ejemplo.dkl][Ln= 9] ``` `-parse` no marca este error: solo aparece al ejecutar. ## Rutas con niveles que no existen `r<"a/b">: valor` crea `b`, pero no `a`: ```dkl new cliente { @"nombre": "Ana" } cliente<"direccion/ciudad">: "Tuxtla" ``` ```text {1} The given key 'direccion' was not present in the dictionary. [ejemplo.dkl][Ln= 8] ``` Cree antes el nivel con `using cliente { member @"direccion" { @"ciudad": "Tuxtla" } }`. ## Un elemento declarativo vacío necesita llaves `br` o `br()` solos son errores; escriba `br{}`. Un elemento con atributos y sin contenido no necesita llaves: `input(type="text" name="q")`. ## Un elemento en contexto imperativo ```dkl div{ "hola" } ``` ```text {1} Sentencia no válida o declaración de elemento en contexto de interpretación. [ejemplo.dkl][Ln= 7] ``` Anteponga `#$` para imprimir el elemento. Vea [Contextos](/es/devkron/2.0/lenguaje/declarativo/contextos.md). ## #def siempre lleva la lista de atributos por orden Si usa atributos predeterminados, la lista de atributos por orden no se puede omitir: ```dkl #def emisor "cfdi:Emisor" (Rfc="XAXX010101000") raiz { emisor{} } ``` ```text {100} Error de sintaxis [/home/usuario/ejemplos/ejemplo.dkl] [100] - Símbolo no esperado[Ln= 1] ``` Correcto: `#def emisor (Rfc, Nombre) "cfdi:Emisor" (Rfc="XAXX010101000" Nombre="")`. Vea [Directivas](/es/devkron/2.0/lenguaje/declarativo/directivas.md). ## format usa el formato de cadenas de C# El segundo argumento de `format(número, formato)` es una cadena de formato numérico de .NET: ```dkl do print(format(1234.5, "0.00")) do print(format(1234.5, "#,#.#")) do print(format(1234567.891, "N2")) ``` ```text 1234.50 1,234.5 1,234,567.89 ``` En 2.0 `format` usa la cultura de presentación del servidor o la configurada; no vuelva a leer con `val` un número formateado. ## Validar la sintaxis con -parse `dkl archivo.dkl -parse` revisa la sintaxis sin ejecutar la parte imperativa. **En 2.0 termina con código 1 si hay un error de sintaxis** (en 1.x siempre terminaba con 0), así que basta revisar el código de salida: ```bash if ! ./dkl miprograma.dkl -parse -hide-log > /dev/null; then echo "Hay errores de sintaxis" fi ``` `-parse` no detecta errores que solo aparecen al ejecutar (tipos, funciones inexistentes, miembros en la misma línea, incremento del `for`): pruebe también ejecutando el programa. ## Errores de lo nuevo de 2.0 | Situación | Mensaje | Corrección | |---|---|---| | `x = $$ 1, 2 $$` | `Operador inválido` | Los bloques `$$` solo van dentro de `new`/`using`/`member`: `new x {$$ 1, 2 $$}`. | | `{$$ "a": 1 // nota $$}` en una línea | `{132} … Bloque $$ sin terminar` | El `//` se come el `$$`; use `/* nota */` o cierre en otra línea. | | `using lista {$$ {"i": 4} $$}` | `using 'lista': la variable contiene una lista y el bloque $$ describe un registro…` | Encierre el registro en `[ ]`. | | Un bloque `$$` con `"clave": f(x)` donde `f` devuelve un objeto | sale un número | Use `&f(x)`. | | `vacia -> t` para sacar un elemento | anexa `vacia` a `t` | Para sacar uno use `elemento <- lista`. | | `l -> a, b, c` con 2 elementos | `La lista 'l' tiene 2 elemento(s) y se indicaron 3 variables` | Revise `list.count(l)` antes. | | `a-1, b -> l` | error de sintaxis | `b, (a-1) -> l` | | `#include "x.dkh" with "plantilla"` | `{131} … usaba las plantillas GT, que se retiraron en Devkron 2.0` | `ftext(file.rtext("plantilla"))`. | | Una licencia de 1.x | el servidor queda en modo demo | Instale una licencia emitida para 2.0. | | Un programa con sintaxis 2.0 en un servidor 1.x | `Sentencia no válida…` o error de sintaxis | Actualice el servidor o no use la sintaxis nueva. | ## Otros tropiezos | Situación | Qué pasa | Corrección | |---|---|---| | La sentencia `include` de un archivo sin `#include "dkli.dkh"`, `#!` y nodo raíz | Error de sintaxis del archivo incluido | El archivo de un `include` en ejecución es un documento propio: agréguele las tres cosas. | | `that f(g(x)) -> r` | `Función: thatf no reconocida o no registrada` | Calcule `g(x)` antes, en una variable. | | `go f (…) with(g(x))` | `{109}` error de sintaxis | Igual: el argumento en una variable. | | `alias -> lista` dentro de un bloque `go` | `La variable mapeada no está disponible` | Copie el alias a una variable local y use esa. | | `left(s, n)` para los primeros `n` caracteres | Devuelve la cadena **desde** la posición `n` | Use `substring(s, 0, n)`. | | `ndatetime.tostr(f, "… HH:mm")` | La hora sale `00:00` | `ndatetime.*` trabajan solo con la fecha; para horas use [time.dkh](/es/devkron/2.0/bibliotecas/estandar/time.md). | Más reglas que sorprenden, con ejemplos, en [Comportamientos no obvios](/es/devkron/2.0/lenguaje/rarezas.md). ## En un servidor web - Una página con un error no atendido responde con estado **500** en 2.0 (en 1.x con 200). Si un `fetch` o AJAX solo revisaba el cuerpo, ahora entra a la rama de error. - `response/http_status` ahora sí tiene efecto: un 404 que el programa fijaba "de adorno" en 1.x ahora llega al navegador. Vea [Desarrollo web](/es/devkron/2.0/marcos/).