# Comportamientos no obvios Reglas del lenguaje que suelen sorprender a quien viene de C, JavaScript o PHP. Todas se confirmaron con Devkron 2.0.2; casi todas vienen de 1.x y se conservan a propósito, porque hay código que depende de ellas. Los ejemplos que no empiezan con `#include` se ejecutan dentro de un `program` con `functions.dkh` y `serialize.dkh`. ## Control de flujo ### `switch` no "cae" al siguiente `case` Cada `case` se **compara** en orden. Sin `break`, el `switch` sigue comparando los `case` siguientes y ejecuta solo los que coinciden; no ejecuta el cuerpo del siguiente como en C. `default` corre si ningún `case` anterior a él coincidió. El valor del `case` debe ser del mismo tipo que el del `switch`. ```dkl nivel = 1 switch nivel { case 1 { do print("case 1") } case 2 { do print("case 2: no se ejecuta") } case 1 { do print("otro case 1: también coincide") } default { do print("default: no se ejecuta") } } ``` ```text case 1 otro case 1: también coincide ``` ### `repeat` vuelve a evaluar la cantidad en cada vuelta ```dkl veces = 2 n = 0 repeat veces { veces = 5 n = n + 1 } do print(n) ``` ```text 5 ``` Si necesita un número fijo de vueltas, copie el valor a una variable que el bloque no cambie. ### `&&` y `||` evalúan los dos lados No hay evaluación de cortocircuito: `if not(isnull(o)) && o.total > 0` falla igual cuando `o` es nula. Use `if` anidados. ```dkl marca:: { do print("se evaluó marca()") return 1 } if 0 && marca() { do print("no") } ``` ```text se evaluó marca() ``` ### No hay `continue`, `++`, `+=` ni `%` Use `if`/`else` dentro del ciclo, `a = a + 1` y `mod(a, b)`. En `for`, el incremento se escribe solo como expresión (`i+2`) o se omite si es de uno en uno. ## Funciones ### Valor de retorno por omisión: 0 Una función que no llega a un `return` devuelve 0. Si se esperaba una cadena, el error `Tipos no coinciden` aparece en la línea que la usa, no en la función. ### Un error dentro de una expresión deja la expresión con 0 Si una función falla dentro de una expresión, la expresión **continúa con 0** en lugar del valor de la función: la asignación se hace y las funciones incorporadas, como `print`, se ejecutan. Después, el error se atiende en el `exception` más cercano o termina el programa. ```dkl precio_con_iva::p { x = p / 0 return p * 1.16 } total = 100 total = precio_con_iva(total) + 1 exception { do print("total quedó en " + str(total)) do clear_exceptions() } ``` ```text total quedó en 1 ``` Por la misma razón, `do print(f())` puede imprimir `0` justo antes del mensaje de un error no manejado dentro de `f`. No confíe en el valor de una variable asignada en una sentencia que falló. ### Una función no ve las variables del programa Solo ve sus parámetros y las globales `@`. Usar una variable del programa dentro de una función es el error `Variable 'x' no definida en el contexto actual`. Las funciones anidadas tampoco ven las de la función padre y quedan en la tabla global de funciones (ver [Funciones anidadas y referencias](/es/devkron/2.0/lenguaje/imperativo/funciones-anidadas-y-referencias.md)). ### `that` y `go … with( )` no admiten llamadas en sus argumentos `that f(abs(x)) -> r` falla al ejecutar (`Función: thatf no reconocida o no registrada`) y `go f (…) with(list.of(1, 2))` es error de sintaxis 109. Calcule antes el valor en una variable. ### Bloques `go`: `return`, `break` y alias `return` dentro del bloque sale de la función que contiene el `go` (en el nivel principal, termina el programa); `break` rompe el ciclo de quien llama; asignar a un alias no cambia la función y crea una variable de quien llama. Ver [Funciones abiertas](/es/devkron/2.0/lenguaje/imperativo/funciones-abiertas.md). ## Variables y tipos ### `vartype` e `isset` reciben el nombre, no la variable ```dkl c = "x" do print(str(vartype("c")) + " " + str(isset("c")) + " " + str(vartype("no_existe"))) ``` ```text 1 1 -1 ``` ### Una variable que se sale de `min`/`max` queda en error La asignación fuera de rango lanza el error y deja la variable **en estado de error**: leerla vuelve a lanzar el mismo error (y `vartype` da -1) hasta que se le asigna un valor válido. ```dkl p = 0 { set max: 100 } p = 150 exception { do clear_exceptions() } do print(vartype("p")) p = 10 do print(p) ``` ```text -1 10 ``` ### Objetos que se vuelven números Un objeto convertido a valor es su **índice** en la tabla de objetos: - una función que devuelve un objeto, asignada a una variable sin `ref`; - `list.of(r)` con una variable `ref`, y `list.add(l, 3)` con un número entero: agrega el objeto 3 si existe, no el número (use `list.addnum`). Hasta 2.0.3 pasaba también con una cadena numérica (`"3"`) o un número con decimales (`1.5`); desde 2.0.4 esos se agregan como valor; - un campo de registro sin `*` (`r<"hijo">: obj` en lugar de `r<"hijo*">: obj`); - en un bloque `$$`, `f(x)` que devuelve un objeto (use `&f(x)`); - `cell.set` / `cell.setc` con un número: esperan un objeto y fallan (use `row.upd` con un registro). ## Cadenas, números y fechas ### `left(s, n)` devuelve la cadena desde la posición `n` ```dkl do print(left("abcdef", 2) + " " + cut("abcdef", 2) + " " + substring("abcdef", 0, 2)) ``` ```text cdef ab ab ``` Para los primeros `n` caracteres use `cut(s, n)` o `substring(s, 0, n)`. ### `ndatetime.*` ignoran la hora `ndatetime.tostr`, `ndatetime.add` y `ndatetime.diff` trabajan solo con la parte de fecha. Para horas use `date.*` de `time.dkh`. ```dkl do print(ndatetime.tostr(20261031.183000, "yyyy-MM-dd HH:mm") + " " + str(ndatetime.add(20261031.183000, 1, "d"))) ``` ```text 2026-10-31 00:00 20261101 ``` ### `round` es bancario `round(2.5, 0)` da 2 y `round(2.345, 2)` da 2.34. Para el redondeo comercial (la mitad se aleja de cero) use `num.round` de `text.dkh`. ### `text` recorta cada cadena La sentencia `text` quita los espacios del inicio y del final de cada cadena antes de unirlas: ```dkl text sql { "select id " "from clientes" } do print(sql) ``` ```text select idfrom clientes ``` ## Registros y listas ### `r<"campo">` es una sentencia, no una expresión `y = r<"nombre"> + "!"` da `Tipos no coinciden`. En expresiones use `r.nombre` o `@@(r, "nombre")`. ### El prefijo `#` es solo para leer `r: v` escribe un campo de nombre calculado. `r<"#" + k>: v` crea una llave que se llama literalmente `#…`. El `#` (y `$`, `&`) solo se usan al leer con `@@`. ### `field.str` falla si el campo no existe Para datos que vienen de afuera use `field.dstr`, `field.dnum` o `field.dobj` con un valor por omisión, o `field.exist` para preguntar. ### Los registros de `from.json` distinguen mayúsculas Los de `new` y de los bloques `$$` no. ### Hasta 2.0.2, una flecha sobre una referencia nula ocupaba la ranura nula compartida **En 2.0.3 ya no pasa.** `@@(r, "&campo_inexistente")` no devuelve una referencia nula nueva: devuelve 0, que como referencia apunta a la ranura de objetos compartida por las referencias nulas (la misma de `@null`). Hasta 2.0.2, si a esa referencia se le aplicaba una flecha (`x -> g`), la flecha creaba la lista **en esa ranura**: desde ese momento `@null` y toda lectura de un campo inexistente devolvían esa lista. Desde 2.0.3, `ref g = …` con un valor nulo le da a `g` su propia ranura nula, y la flecha (o `new`, `using`, un bloque `$$`) crea el objeto solo ahí. ```dkl new r {} x = 1 ref g = @@(r, "&a") x -> g new vacio {} ref z = @@(vacio, "&lo_que_sea") do print(str(isnull(@null)) + " " + to.json(z) + " " + str(field.exist(vacio, "lo_que_sea"))) ``` Con 2.0.3: ```text 1 null 0 ``` Con 2.0.2 y anteriores daba `0 [1] 0`. Para código que también deba correr en esas versiones, el patrón seguro sigue siendo preguntar con `field.exist` y crear la lista con `list.create()` antes de usar la flecha (ver [Recetas de colecciones](/es/devkron/2.0/lenguaje/imperativo/recetas-de-colecciones.md)). ### Un bloque `$$` sin comas falla al ejecutar El error (`Se esperaba un operador (bloque $$, línea n)`) aparece cuando se ejecuta el bloque, no al cargar: `-parse` no lo detecta. ### Sentencias que empiezan con un número o una cadena Toda sentencia empieza con un identificador: `1, 2 -> l` y `"x" -> l` son errores de sintaxis. La parte izquierda de una flecha termina en el primer `-` fuera de paréntesis: escriba `b, (a - 1) -> l`. ## Archivos incluidos y salida ### `include` (sin `#`) analiza el archivo aparte y lo ejecuta en el ámbito de quien incluye - El archivo es un documento propio: necesita `#include "dkli.dkh"`, `#!` y **un solo nodo raíz** (`codeblock { … }`). Sin eso da `Símbolo no esperado` o `No hay un elemento raíz`. Las funciones ya registradas por quien lo incluye sí están disponibles. - Corre en el ámbito de quien lo incluye: lee y cambia sus variables. - Un `return` dentro del archivo sale de la **función** que hizo el `include`. La directiva `#include` es distinta: inserta el texto al cargar y el archivo solo necesita empezar con `#!` si tiene código imperativo. ### `fxml()` necesita un elemento declarativo Devuelve (y quita de la salida) lo que produjo **el elemento declarativo que la contiene**. Llamada directamente dentro de `program` devuelve una cadena vacía. ## Servicios web ### `httpres.ok` y `httpres.fail` fijan HTTP 200 Para responder otro código con ese formato, llame `httpres.status(código)` **después**. En Devkron Edge estas dos funciones no existen: use `httpres.json` y `httpres.status`.