# Cultura: leer invariante, mostrar con la cultura del servidor La **cultura** decide cómo se escriben los números y las fechas: separador decimal, separador de miles, símbolo de moneda, nombres de meses y días. Devkron 2.0 separa dos usos que en 1.x estaban mezclados, y eso hace que un programa dé el mismo resultado en cualquier servidor. Esta página explica la regla, cómo configurar la cultura y qué revisar al migrar. ## La regla - Todo lo que **lee o serializa** datos es **invariante** (punto decimal, nombres de mes en inglés), sin importar `LANG`/`LC_ALL` ni la configuración regional del servidor. - Lo que **muestra** (funciones de formato) usa la **cultura de presentación**, que por omisión es la del sistema operativo, como en 1.x. ## Por qué cambió En 1.x todo dependía de la cultura del proceso. En un servidor con coma decimal (es-CO, es-VE, es-ES) el literal `1.5` se leía como `15`, `val("2.25")` como `225`, y `format` formateaba números ya mal leídos: el mismo programa daba resultados distintos según el servidor. En 2.0 la lectura nunca depende del servidor, y la presentación sigue viéndose "en español" donde se configure. ## Qué es lectura y qué es presentación | Siempre invariante (lectura y serialización) | Usa la cultura de presentación | |---|---| | literales numéricos (`1.5`) | `format(n, fmt)` | | `val`, `str` | `date_str(d, fmt)` / `dt2str` | | número → texto en concatenación y en marcas `#` **sin** formato | `ndatetime.tostr(n, fmt)` | | `parse.num`, `field.num`, `cell.*`, `table.*`, `from.args` | marcas **con** formato `#` (en `ftext`, plantillas y texto declarativo) | | `str2dt` (nombres de mes en inglés), `ndatetime.fromstr` | `set format: "…"` (se ve en las marcas `#`) | | `to.json` / `from.json` | `ToString()`, `ToString(fmt)`, `ToShortDateString()`… de `System.DateTime` y `ToString(fmt)` de números mapeados con `_map_function` | | parámetros y lecturas de `dbr` | | | `toupper` / `tolower` y comparaciones | | | conversión de argumentos al llamar funciones externas mapeadas con `_map_function` | | ## Ejemplos En un servidor es-MX (`dkl ejemplo.dkl -culture es-MX`): ```dkl #include "dkli.dkh" #! program "ejemplo" { #include "functions.dkh" #include "serialize.dkh" n = 1234567.891 ref d = str2dt("2026-10-23 17:05:30") do print(n) do print("texto " + str(n)) do print(format(n, "N2")) do print(format(n, "C")) do print(date_str(d, "dddd dd 'de' MMMM yyyy")) do print(date_str(d, "d")) do print(ndatetime.tostr(20261023, "dddd dd MMMM yyyy")) do print(ftext("# / #")) do print(val("2.25") + 1) do print(parse.num("1,234.5")) do print(to.json(from.json("{\"x\": 1.5}"))) } ``` ```text 1234567.891 texto 1234567.891 1,234,567.89 $1,234,567.89 viernes 23 de octubre 2026 23/10/2026 viernes 23 octubre 2026 1,234,567.89 / 1234567.891 3.25 1234.5 {"x":1.5} ``` El mismo tipo de programa en un servidor es-CO (`-culture es-CO`): la presentación cambia, la lectura no. En 1.x `val("2.25") + 1` daba `226` y `1.5 * 2` daba `30`: ```dkl #include "dkli.dkh" #! program "ejemplo" { #include "functions.dkh" n = 1234567.891 ref d = str2dt("2026-10-23 17:05:30") do print(n) do print(format(n, "N2")) do print(format(n, "C")) do print(date_str(d, "dddd dd 'de' MMMM yyyy")) do print(ftext("# / #")) do print(val("2.25") + 1) do print(1.5 * 2) } ``` ```text 1234567.891 1.234.567,89 $ 1.234.567,89 viernes 23 de octubre 2026 1.234.567,89 / 1234567.891 3.25 3.0 ``` Con la cultura invariante (un servidor sin `LANG`, como un contenedor), `format` y `date_str` salen en inglés y la moneda con `¤`: ```text 1,234,567.89 ¤1,234,567.89 Friday 23 October 2026 10/23/2026 ``` El texto exacto de algunos formatos depende de la versión de ICU del sistema operativo, igual que en 1.x (por ejemplo `P1` da `25.6 %` o `25.6%`, y `tt` da `p. m.` o `p.m.`). Los ejemplos de esta página se ejecutaron en Ubuntu 24.04. `toupper`/`tolower` usan reglas invariantes: en una cultura turca `i` ya no se convierte en `İ`. ## Configurar la cultura de presentación De mayor a menor precedencia: | Nivel | Cómo | Alcance | |---|---|---| | 1. explícita | `dkl programa.dkl -culture es-MX` (o `-culture:es-MX`) | consola | | | llave `"culture": "es-MX"` de `fastcgi.json` (gana a `-culture:` de `devkron_args`) | todas las peticiones FastCGI | | | `-culture:es-MX` dentro de `devkron_args` de `fastcgi.json` | FastCGI | | 2. entorno | variable `DEVKRON_CULTURE=es-MX` | consola y FastCGI | | 3. sistema | cultura del sistema operativo al arrancar (`LANG`/`LC_ALL` en Linux; configuración regional del usuario del proceso en Windows) | todo | - `"invariant"` o `""` fuerzan la cultura invariante; `C` y `POSIX` también. - Se aceptan nombres POSIX: `es_MX.UTF-8` equivale a `es-MX`. - Un nombre que no es una cultura conocida (`xx-ZZ`) se **ignora** y manda el siguiente nivel. Con `DEVKRON_CULTURE=es-MX` y `-culture xx-ZZ`, `format(1234.5, "C")` da `$1,234.50`. - La cultura se toma al **empezar** cada ejecución (cada petición FastCGI) y no cambia durante ella. No hay una sentencia para cambiarla desde un programa. - En Windows la cultura del sistema **no** sale de `LANG`: es la del usuario con que corre el servicio. Para no depender de eso, fije `culture` en `fastcgi.json`. **Recomendación para servidores de producción**: fije la cultura en la configuración, en lugar de depender del sistema operativo: `"culture": "es-MX"` en `fastcgi.json` y `DEVKRON_CULTURE=es-MX` en el entorno de las tareas de consola (o `-culture es-MX` en su línea de comandos). Use la cultura del país de sus usuarios (`es-CO`, `es-VE`…). ## Riesgo al migrar: formatear y volver a leer En 1.x, en un servidor es-CO o es-ES, `format` producía comas **y** la lectura las "deshacía" porque también usaba la cultura del servidor. En 2.0 la lectura es invariante: si un programa arma un número con `format` (o con una marca con formato, o una fecha con `date_str` y `tt`/`MMM`/`dddd`) y luego lo lee con `parse.num`/`val`, o lo manda como dato en SQL o JSON, **el viaje de ida y vuelta se rompe** en servidores con coma decimal. Este patrón aparece en reportes reales: los totales se arman con el formato `#,0.00` y se vuelven a leer con `parse.num`. En un servidor es-CO o es-ES dan **0** (`-culture es-CO`): ```dkl #include "dkli.dkh" #! program "ejemplo" { #include "functions.dkh" // Patrón de algunos reportes: formatear y volver a leer importe = 1234567.89 texto = format(importe, "#,0.00") total = parse.num(texto) do print("texto: " + texto) do print("total: " + str(total)) // Corrección: para datos, str(); format() solo para mostrar total = parse.num(str(importe)) do print("total: " + str(total)) } ``` ```text texto: 1.234.567,89 total: 0 total: 1234567.89 ``` En es-MX y con cultura invariante **no cambia nada** (el separador decimal ya era el punto). Las fechas con `yyyy-MM-dd HH:mm:ss` tampoco cambian en culturas es-*; sí cambian `tt`, `MMM`/`MMMM`, `ddd`/`dddd`, `d` y `G`. ### Qué hacer 1. **Para datos use `str(x)`** (o `ndatetime` / `yyyy-MM-dd` para fechas); `format` solo para lo que ve una persona. 2. Busque en su código `parse.num(format(`, `val(format(`, `parse.num(` sobre textos formateados, y formatos con separadores (`N2`, `#,0.00`, `C`, `P`) que terminen en SQL, JSON o archivos: ```bash grep -rnE 'parse\.num\(format\(|val\(format\(' /opt/devkron/web ``` 3. Si no puede corregir el código a tiempo, fije en ese servidor `"culture": "es-MX"` (o `"invariant"`): la lectura y la escritura vuelven a coincidir, a costa de mostrar con punto decimal. ## Para extensiones .NET Cada ejecución corre con `CultureInfo.CurrentCulture` = invariante en su hilo: una función mapeada de una extensión que llame `ToString()` o `decimal.Parse` sin `IFormatProvider` obtiene el resultado invariante. Las funciones de presentación de la tabla de arriba reciben la cultura de presentación de forma explícita. Una sobrecarga mapeada que ya recibe un `IFormatProvider` no se toca.