# Variables ## Tipos de datos DKL es de **tipado estático**: una variable conserva para siempre el tipo de su primera asignación. Hay dos clases de variables. ### De valor: números y cadenas - **Números**: se guardan como `System.Decimal` de .NET (28 dígitos significativos, sin errores de punto flotante: `0.1 + 0.2 == 0.3` es cierto). - **Cadenas**: se guardan como `System.String`. - **Lógicos**: no hay un tipo aparte; `0` es falso y cualquier otro número es verdadero. Las comparaciones devuelven `1` o `0`. ### De referencia: objetos Los objetos (registros, listas, tablas, conexiones, objetos de .NET) se manejan con variables de **referencia**, declaradas con `ref`. Internamente una referencia es el índice del objeto en una tabla de objetos que vive mientras dura la ejecución; el motor cuenta las referencias y libera el objeto cuando ninguna variable apunta a él. ```dkl ref sb = _new("System.Text.StringBuilder") // objeto de .NET ref cliente = record.create() // registro vacío ref partidas = list.create() // lista vacía ``` Siempre que trabaje con objetos use `ref`. Una referencia es un número marcado como tal; técnicamente se puede copiar a una variable numérica, pero **no lo haga**: el objeto puede liberarse y el número dejaría de tener sentido. ## Declaración Una variable de valor se declara al asignarla por primera vez: ```dkl a = 1 b = "hola mundo" a = a + 1 c = a * 10 do print(a) do print(b + "!") do print(c) n = 5 n = "texto" ``` ```text 2 hola mundo! 20 {1} La variable 'n' ya fué inicializada con un tipo diferente al de la asignación [ejemplo.dkl][Ln= 15] ``` La última línea falla: `n` ya es numérica. Para convertir use `str()` y `val()`. ## Atributos de validación Una variable de valor puede llevar atributos que se validan en cada asignación. Van en un bloque `{ }` justo después de la primera asignación. Para números: | Atributo | Efecto | |---|---| | `set min: valor` | Valor mínimo; uno menor produce `El valor está por debajo del mínimo`. | | `set max: valor` | Valor máximo; uno mayor produce `El valor está por encima del máximo`. | | `set round: decimales` | Redondea automáticamente cada valor asignado. | | `set format: "formato"` | Formato con que la variable se inserta en marcas `#<…>` del contexto declarativo (formatos de .NET). | ```dkl porcentaje = 50 { set min: 0 set max: 100 } importe = 0 { set round: 2 } importe = 3.14159 do print(importe) total = 1234.5 { set format: "$ #,#.00" } do print(total) #$ nodo{ "#" } ``` ```text 3.14 1234.5 $ 1,234.50 ``` Observe que `format` no cambia `print(total)` ni `str(total)`: solo la inserción en marcas declarativas. Una asignación fuera de rango detiene el programa (o va al bloque `exception` más cercano): ```dkl porcentaje = 50 { set min: 0 set max: 100 } porcentaje = 150 do print("no llega") ``` ```text {1} El valor está por encima del máximo [ejemplo.dkl][Ln= 12] ``` Si el error se atiende en un bloque `exception`, la variable queda **en estado de error**: leerla vuelve a lanzar el error y `vartype` devuelve -1 hasta que se le asigne un valor válido. **Con cadenas no use `min` ni `max`.** La documentación 1.x decía que limitaban la cantidad de caracteres, pero el motor (1.x y 2.0) compara el valor numérico de la variable: `set min:` hace que toda asignación de cadena falle con `El valor está por debajo del mínimo`, y `set max:` no limita nada. Valide la longitud con `length()`: ```dkl nombre = "Lupita Lupita Lupita Lupita Lupita Lupita Lupita" if length(nombre) > 40 { nombre = substring(nombre, 0, 40) } do print(nombre + " (" + str(length(nombre)) + ")") ``` ```text Lupita Lupita Lupita Lupita Lupita Lupit (40) ``` Los atributos se escriben con dos puntos (`set format: "…"`). Sin ellos (`set format "…"`) es un error de sintaxis `{109}`. ## Plantillas de variables Una variable puede heredar los atributos y el valor inicial de otra con `nueva[plantilla]`: ```dkl precio = 100 { set min: 100 set max: 500 } a[precio] do print(a) c[precio] = 150 do print(c) c = 499 do print(c) ``` ```text 100 150 499 ``` `functions.dkh` trae plantillas listas: | Plantilla | Restricción | |---|---| | `@bool` | 0 a 1, sin decimales | | `@int` | redondea a 0 decimales | | `@positive` | mínimo 0 | | `@negative` | máximo 0 | | `@number` | número sin restricciones (valor 0) | | `@string` | cadena (valor `""`) | Y las constantes `@true` (1) y `@false` (0). ```dkl activo[@bool] activo = 1 k[@int] = 10 k = 3.7 p[@positive] = 5 do print(activo) do print(k) do print(p) do print(@true && @false) ``` ```text 1 4 5 0 ``` ## Variables globales Las variables cuyo nombre empieza con `@` son **globales**: existen en todo el programa, en todas las funciones y en los archivos incluidos. ```dkl @contador = 0 incrementa :: { @contador = @contador + 1 return @contador } do incrementa() do incrementa() do print(@contador) ``` ```text 2 ``` El motor y las bibliotecas crean algunas globales: `@null` (referencia nula), `@http_context` (en un servidor web), `@_run_settings` (configuración de la ejecución), `@true`, `@false`, `@bool`… Vea [Temas avanzados](/es/devkron/2.0/lenguaje/imperativo/temas-avanzados.md). ## Ámbitos | Ámbito | Dónde existe la variable | |---|---| | Global (`@nombre`) | En todo el programa, sus funciones y archivos incluidos. | | Principal | En el cuerpo del programa, fuera de las funciones (no dentro de ellas). | | De función | Solo dentro de la función que la declara, mientras se ejecuta. | ```dkl x = 100 prueba :: x { x = x + 1 y = 5 return x } do print(prueba(1)) do print(x) do print(isset("y")) z = 7 lee :: { return isset("z") } do print(lee()) ``` ```text 2 100 0 0 ``` La `x` de la función es su parámetro, distinta de la del programa; `y` no existe fuera de la función, y una función no ve las variables locales del programa (`lee()` da 0). Si la función usara `z` directamente (`return z`), sería el error `Variable 'z' no definida en el contexto actual`; un `do print(lee())` alcanza a imprimir `0` antes de que el error detenga el programa, porque la expresión continúa con 0 (vea [Comportamientos no obvios](/es/devkron/2.0/lenguaje/rarezas.md)). Para compartir datos use parámetros o globales. Los bloques `program`, `module` y `codeblock` **no** crean un ámbito aparte. Vea [Organización del programa](/es/devkron/2.0/lenguaje/imperativo/organizacion.md). ## Saber si una variable existe y de qué tipo es - `isset("nombre")` devuelve 1 si la variable existe. - `vartype("nombre")` devuelve 1 (cadena), 2 (número), 3 (referencia), 0 (nula) o -1 (no existe o está en estado de error por `min`/`max`). Ambas reciben el **nombre** como cadena. Vea [Funciones de sistema](/es/devkron/2.0/lenguaje/funciones-incorporadas/sistema.md). ## Variables con $ (2.0) En 2.0 un identificador puede empezar con `$`: `$total = 0`. `$total` y `total` son variables distintas. Vea [Novedades](/es/devkron/2.0/lenguaje/novedades-2.0/identificadores-dolar.md).