# Utilidades: conversión, iteración y variables globales Funciones de `functions.dkh` para convertir texto a número o booleano sin errores, para recorrer registros y listas con la sentencia `go`, y las variables globales que define el encabezado. ## Convertir texto: parse.* y field.parse.* | Función | Devuelve | |---|---| | `parse.bool(texto)` | `@true` si el texto (sin espacios y en minúsculas) es `yes`, `y`, `sí`, `si`, `s`, `ok`, `on`, `true`, `verdadero`, `v`, `verdad`, `correcto`, `positivo` o `+`, o si es un número distinto de 0; si no, `@false` (nunca lanza error) | | `parse.num(texto)` | El número; 0 si el texto no es numérico (nunca lanza error). Acepta separador de miles con coma y siempre punto decimal | | `field.parse.dbool(registro, campo, default)` | `parse.bool` del campo; si no existe usa `default` | | `field.parse.dnum(registro, campo, default)` | `parse.num` del campo; si no existe usa `default` | Son útiles para leer parámetros de una petición web o de un archivo de configuración, donde todo llega como texto: ```dkl #include "dkli.dkh" #! program "parse" { #include "functions.dkh" do print(parse.bool("Sí")) do print(parse.bool("ok")) do print(parse.bool("2")) do print(parse.bool("no")) do print(parse.bool("abc")) do print(parse.num("1,234.5")) do print(parse.num("12abc")) new cfg { @"activo": "true" @"dias": "15" } do print(field.parse.dbool(cfg, "activo", @false)) do print(field.parse.dbool(cfg, "falta", @true)) do print(field.parse.dnum(cfg, "dias", 0) * 2) do print(field.parse.dnum(cfg, "falta", 30)) } ``` ```text 1 1 1 0 0 1234.5 0 1 1 30 30 ``` En Devkron 2.0 `parse.num` lee igual en cualquier servidor (cultura invariante): `"1.5"` es uno y medio también en un servidor es-CO. No lo use para leer texto producido por `format` (ver [Cadenas](/es/devkron/2.0/bibliotecas/motor/functions/cadenas.md)). ## Recorrer registros y listas: foreach.* Son **funciones abiertas**: se llaman con `go` y ejecutan el bloque que se escribe a continuación una vez por elemento, con variables expuestas que usted renombra. | Función | Recorre | Variables expuestas | |---|---|---| | `foreach.fstr` | Los campos de un registro, valores como cadena | `index`, `key`, `value` | | `foreach.fnum` | Los campos de un registro, valores como número | `index`, `key`, `value` | | `foreach.fobj` | Los campos de un registro, valores como referencia | `index`, `key`, `value` | | `foreach.lstr` | Una lista, elementos como cadena | `index`, `value` | | `foreach.lnum` | Una lista, elementos como número | `index`, `value` | | `foreach.lobj` | Una lista, elementos como referencia | `index`, `value` | Sintaxis: `go foreach.lstr(index:i, value:v) with(lista) { … }`. Solo declare las variables que use; `with` recibe una **variable** (no una llamada a función). ```dkl #include "dkli.dkh" #! program "foreach" { #include "functions.dkh" #include "serialize.dkh" new registro { @"nombre": "Juan" @"apellido1": "López" @"edad": 38 } go foreach.fstr(index:i, key:k, value:v) with(registro) { do print(str(i) + " " + k + "=" + v) } new totales { @"enero": 100.5 @"febrero": 200 } suma = 0 go foreach.fnum(value:n) with(totales) { suma = suma + n } do print(suma) ref pedido = from.json("{\"cliente\":{\"id\":7},\"envio\":{\"id\":3}}") go foreach.fobj(key:k, value:o) with(pedido) { do print(k + " -> " + str(field.num(o, "id"))) } ref nombres = list.of("Uno", "Dos", "Tres") go foreach.lstr(index:i, value:v) with(nombres) { do print(str(i) + ": " + v) } ref precios = list.of(10, 20.5) go foreach.lnum(value:p) with(precios) { do print(p * 1.16) } ref partidas = from.json("[{\"sku\":\"P-01\"},{\"sku\":\"P-02\"}]") go foreach.lobj(index:i, value:p) with(partidas) { do print(str(i) + " " + field.str(p, "sku")) } } ``` ```text 0 nombre=Juan 1 apellido1=López 2 edad=38 300.5 cliente -> 7 envio -> 3 0: Uno 1: Dos 2: Tres 11.60 23.780 0 P-01 1 P-02 ``` `foreach.lnum` y `foreach.lstr` no exponen `key` (la documentación 1.x lo listaba): solo `index` y `value`. ## Variables globales `functions.dkh` define estas variables al incluirse. **Constantes** | Variable | Valor | Uso | |---|---|---| | `@true` | 1 | Comparaciones y argumentos booleanos: `if activo == @true` | | `@false` | 0 | | **Plantillas de variables.** Se usan entre corchetes al declarar una variable para restringir sus valores: | Plantilla | Restricción | |---|---| | `@bool` | Solo 0 o 1; redondea a entero | | `@int` | Redondea a entero | | `@number` | Número sin restricción | | `@positive` | Mínimo 0 | | `@negative` | Máximo 0 | | `@string` | Cadena | ```dkl #include "dkli.dkh" #! program "tipos" { #include "functions.dkh" cantidad[@int] = 10 cantidad = 3.7 do print(cantidad) nombre[@string] = "Ana" do print(nombre) activo[@bool] = 1 activo = 0 do print(activo) activo = 5 exception { do print(last_error()) do clear_exceptions() } saldo[@positive] = 100 saldo = -1 exception { do print(last_error()) do clear_exceptions() } do print(@true + @false) } ``` ```text 4 Ana 0 {1} El valor está por encima del máximo [tipos.dkl][Ln= 14] {1} El valor está por debajo del mínimo [tipos.dkl][Ln= 21] 1 ``` **Configuración** | Variable | Valor inicial | Uso | |---|---|---| | `@exec_timeout` | 180000 | Milisegundos que `exec` espera a que termine el proceso | | `@__context` | (no existe hasta usarse) | Registro de contexto de `@`, `@set`, `@context.begin` (ver [Registros](/es/devkron/2.0/bibliotecas/motor/functions/registros.md)) | | `@lib_functions` | | Referencia a `Devkron.Functions.dll`; la usa el propio encabezado | ## Errores típicos | Mensaje | Causa | Solución | |---|---|---| | `El valor está por encima del máximo` / `por debajo del mínimo` | Se asignó a una variable con plantilla un valor fuera de rango | Valide antes de asignar | | `Definición de elemento incompleta` en una línea `go … with(…)` | Se pasó una llamada a función a `with` | Guarde el resultado en una variable `ref` | | `parse.num` devuelve 0 con un número válido | El texto trae coma decimal (`1,5`) | Reemplace la coma o pida el dato con punto | [Regresar a functions.dkh](/es/devkron/2.0/bibliotecas/motor/functions/)