# Sentencias ## Reglas generales - **Una sentencia por línea**, sin `;` ni otro terminador. - Las sentencias **distinguen mayúsculas**: todas las palabras reservadas van en minúsculas (`if`, no `If`). - Toda sentencia **empieza con un identificador**. Por eso `1, a -> l` o `"x" + a` sueltos son errores de sintaxis. - Una función no se puede llamar como sentencia suelta: use `do f(x)` o `call f(x)`, o asigne su resultado. - Los bloques van entre `{ }`; la llave de apertura puede ir en la misma línea o en la siguiente. ## Control de flujo ### if, else if, else Como en C, pero **sin paréntesis obligatorios** alrededor de la condición (se permiten: `if (a > 0)` funciona igual). ```dkl clasifica :: n { if n < 0 { return "negativo" } else if n == 0 { return "cero" } else if n < 10 { return "chico" } else { return "grande" } } do print(clasifica(-5)) do print(clasifica(0)) do print(clasifica(3)) do print(clasifica(30)) s = "x" if s == "x" && not(isset("noexiste")) { do print("una línea también funciona") } ``` ```text negativo cero chico grande una línea también funciona ``` ### switch, case, default Cada `case` se compara en orden con el valor del `switch` (números o cadenas) y se ejecuta si es igual. Sin `break`, el `switch` **sigue comparando** los `case` siguientes y ejecuta solo los que coinciden: no ejecuta el cuerpo del siguiente como en C. Al terminar los `case`, continúa con lo que haya después de ellos dentro del `switch`. `break` termina el `switch`. `default` se ejecuta si ningún `case` anterior a él coincidió: póngalo al final. El valor del `case` debe ser del mismo tipo que el del `switch` (`"1"` contra `1` da `Tipos no coinciden`). ```dkl prueba :: n { switch n { case 1 { do print(" case 1, sin break") } case 2 { do print(" case 2, con break") break } default { do print(" default, sin break") } do print(" después de los case") } return 0 } for i = 1; i <= 3 { do print("n=" + str(i)) do prueba(i) } tipo = "json" switch tipo { case "xml" { do print("es xml") break } case "json" { do print("es json") break } } ``` ```text n=1 case 1, sin break después de los case n=2 case 2, con break n=3 default, sin break después de los case es json ``` Escriba `break` al final de cada `case`: así el `switch` no sigue comparando ni ejecuta el código que haya después de los `case`. Si dos `case` tienen el mismo valor, se ejecutan los dos (ejemplo en [Comportamientos no obvios](/es/devkron/2.0/lenguaje/rarezas.md)). En 2.0, un `case` o `default` fuera de un `switch` informa `La sentencia 'case' debe estar dentro de un bloque 'switch'` (en 1.x decía `Stack empty.`), y un error en la expresión del `switch` muestra el error real. ### return - En una función, termina la función y devuelve el valor indicado. Sin valor, o si la función termina sin `return`, devuelve **0**. - En el cuerpo principal, termina el programa. - `ret` es sinónimo de `return`. ```dkl diez :: { return 10 } nada :: { return } do print(diez()) do print(nada()) do print("antes") if 1 { return } do print("nunca") ``` ```text 10 0 antes ``` ### break Sale del ciclo (`while`, `for`, `repeat`) o del `switch` más cercano. No existe `continue`: use `if`/`else` dentro del ciclo. ### do y call Llaman a una función descartando su resultado. Son equivalentes (`call` es un alias de `do`). ```dkl @n = 0 inc :: v { @n = @n + v return @n } do inc(1) call inc(10) do print(@n) ``` ```text 11 ``` ## Ciclos ### while Repite el bloque mientras la condición sea verdadera. ```dkl n = 1 while n < 100 { n = n * 3 } do print(n) i = 0 while 1 { i = i + 1 if mod(i, 7) == 0 { break } } do print(i) ``` ```text 243 7 ``` ### repeat Repite el bloque las veces que indica la expresión. La cantidad se **vuelve a evaluar en cada vuelta**: si el bloque cambia una variable de la expresión, cambia el número de repeticiones (con `veces = 2` y el bloque poniendo `veces = 5`, se repite 5 veces). Si necesita un número fijo, copie el valor a una variable que el bloque no cambie. `break` sale del `repeat`. ```dkl c = 0 repeat 5 { c = c + 2 } do print(c) veces = 2 repeat veces + 1 { do print("r") } repeat 0 { do print("nunca") } ``` ```text 10 r r r ``` ### for ```text for variable = inicio; condición for variable = inicio; condición; incremento ``` - El incremento es **opcional**; si se omite, la variable avanza de uno en uno. - El incremento se escribe como **expresión**, no como asignación: `i+2`, `j-3`, `x+0.25`, `y*10`. Escribir `i=i+1` da `Operador inválido`. - No lleva paréntesis. - Al terminar, la variable conserva el último valor (el que hizo falsa la condición). ```dkl for i = 0; i < 3 { do print("i=" + str(i)) } for a = 1; a < 10; a+2 { do print("a=" + str(a)) } for j = 10; j > 0; j-4 { do print("j=" + str(j)) } for x = 0; x < 1; x+0.25 { do print("x=" + str(x)) } for y = 1; y <= 1000; y*10 { do print("y=" + str(y)) } do print("final i=" + str(i)) ``` ```text i=0 i=1 i=2 a=1 a=3 a=5 a=7 a=9 j=10 j=6 j=2 x=0 x=0.25 x=0.50 x=0.75 y=1 y=10 y=100 y=1000 final i=3 ``` Un `for` muy común: recorrer una lista. ```dkl ref partidas = from.json("[{\"cant\":3,\"precio\":19.99},{\"cant\":1,\"precio\":1500}]") subtotal = 0 for i = 0; i < list.count(partidas) { ref p = list.obj(partidas, i) subtotal = subtotal + @@(p, "#cant") * @@(p, "#precio") } do print(subtotal) ``` ```text 1559.97 ``` ### foreach DKL no tiene una sentencia `foreach`; `functions.dkh` trae **funciones abiertas** que se usan con [`go`](/es/devkron/2.0/lenguaje/imperativo/funciones.md) y exponen el índice, la clave y el valor: | Función | Recorre | Expone | |---|---|---| | `foreach.fstr(registro)` | campos de un registro, valor como cadena | `index`, `key`, `value` | | `foreach.fnum(registro)` | campos de un registro, valor como número | `index`, `key`, `value` | | `foreach.fobj(registro)` | campos de un registro, valor como objeto | `index`, `key`, `value` | | `foreach.lstr(lista)` | elementos de una lista, como cadena | `index`, `value` | | `foreach.lnum(lista)` | elementos de una lista, como número | `index`, `value` | | `foreach.lobj(lista)` | elementos de una lista, como objeto | `index`, `value` | ```dkl new r { @"uno": "1" @"dos": "2" } go foreach.fstr(index:i, key:k, value:v) with(r) { do print(str(i) + " " + k + "=" + v) } ref n = from.json("[1.5, 2.5, 3]") total = 0 go foreach.lnum(value:v) with(n) { total = total + v } do print(total) ref objs = from.json("[{\"n\":\"x\"},{\"n\":\"y\"}]") go foreach.lobj(index:i, value:o) with(objs) { do print(str(i) + " " + @@(o, "n")) } ``` ```text 0 uno=1 1 dos=2 7.0 0 x 1 y ``` `index:i` significa "la variable expuesta `index` se llama `i` dentro del bloque". Las reglas completas de los bloques `go` (ámbito, alias, `return`, `break`) están en [Funciones abiertas](/es/devkron/2.0/lenguaje/imperativo/funciones-abiertas.md), y los recorridos más comunes (filtrar, transformar, agrupar) en [Recetas de colecciones](/es/devkron/2.0/lenguaje/imperativo/recetas-de-colecciones.md). ## Asignación ### Variables de valor: = ```dkl variable = expresión ``` ### Texto largo: text `text variable { … }` asigna a una variable la concatenación de las cadenas del bloque. Las marcas `#<…>` **no** se evalúan aquí; páselo por `ftext()` si las necesita. **Cuidado:** cada cadena del bloque se recorta (se quitan los espacios y saltos de línea al inicio y al final), así que el separador entre partes se pierde. Deje los espacios **dentro** de cada cadena o escriba todo en una sola cadena de varias líneas: ```dkl cliente = "Ana" text partes { "select id, nombre " "from clientes" } do print(partes) text sql { "select id, nombre from clientes where nombre = '#'" } do print(ftext(sql)) ``` ```text select id, nombrefrom clientes select id, nombre from clientes where nombre = 'Ana' ``` ### Variables de referencia: ref = y ref : ```dkl ref variable = expresión_que_devuelve_un_objeto ref variable : expresión_que_devuelve_un_objeto ``` - `ref v = …` **suelta** lo que tuviera `v` y la apunta al nuevo objeto. Otras variables que apuntaban al objeto anterior no cambian. - `ref v : …` **reutiliza la misma entrada** de la tabla de objetos: todas las variables que compartían la referencia de `v` pasan a ver el nuevo objeto. - Si `v` no existía, `=` y `:` son equivalentes. ```dkl new a { @"v": "A" } new b { @"v": "B" } ref x = a ref y = x ref x = b do print("con = : y sigue en " + to.json(y)) ref p = a ref q = p ref p : b do print("con : : q ahora ve " + to.json(q)) ``` ```text con = : y sigue en {"v":"A"} con : : q ahora ve {"v":"B"} ``` En la práctica use `ref v = …`; `ref v : …` sirve cuando quiere cambiar el objeto al que apuntan varias variables a la vez. La asignación de campos de registros (`r<"campo">: valor`, `:=`, `>>`, `<<`) está en [Registros](/es/devkron/2.0/lenguaje/imperativo/registros.md), y la de listas (`->`, `<-`) en [Listas y tablas](/es/devkron/2.0/lenguaje/imperativo/listas-y-tablas.md). ## Referencias a funciones: point y that `point variable to función` guarda en una variable una referencia a una función definida por el programador; `that` la llama. | Forma | Qué hace | |---|---| | `that vf` | llama a la función sin argumentos | | `that vf(argumentos)` | llama con argumentos | | `that vf(argumentos) -> r` | asigna el resultado (número o cadena) a `r` | | `that vf(argumentos) ->* r` | asigna el resultado como **referencia** (la función devuelve un objeto) | ```dkl doble :: x { return x * 2 } crea :: nombre { new r { @"nombre": nombre } return r } point f to doble that f(21) -> r do print(r) point g to crea that g("Ana") ->* o do print(to.json(o)) ``` ```text 42 {"nombre":"Ana"} ``` Sirve para elegir en ejecución qué función usar (un manejador por tipo de documento, por ejemplo). El marco CRUD-L lo usa para elegir la vista de éxito o de error (`@success_view`, `@fail_view`). En `point … to` escriba el nombre **completo** de la función: los `alias` no valen ahí. `that` sin nada más tiene otro significado dentro de una función abierta: vea [Funciones abiertas](/es/devkron/2.0/lenguaje/imperativo/funciones-abiertas.md). `that` no admite llamadas en sus argumentos: `that f(abs(x)) -> r` da `Función: thatf no reconocida o no registrada`; calcule antes el valor en una variable. Más usos de las referencias a funciones (como parámetro, en listas y registros, como valor de retorno) en [Funciones anidadas y referencias](/es/devkron/2.0/lenguaje/imperativo/funciones-anidadas-y-referencias.md). ## Inclusión en ejecución: include La sentencia `include` carga y ejecuta un archivo solo si la ejecución pasa por ella. El archivo se analiza como un documento propio (necesita `#include "dkli.dkh"`, `#!` y un único nodo raíz), corre en el ámbito de quien lo incluye y un `return` dentro de él sale de la función que hizo el `include`. Vea [Organización del programa](/es/devkron/2.0/lenguaje/imperativo/organizacion.md). ## Excepciones `exception { … }` y `exception handler { … }`: vea [Excepciones](/es/devkron/2.0/lenguaje/imperativo/excepciones.md).