# Cadenas y textos Funciones de `functions.dkh` para recortar, buscar, reemplazar, rellenar y formatear cadenas; para comparar contra listas de palabras; para convertir listas `clave=valor` en registros, y para armar textos largos en un búfer. Las posiciones son **base cero**. `toupper`/`tolower` y las comparaciones usan reglas invariantes (no dependen del idioma del servidor). `format` es la única que usa la cultura de presentación. ## Recortar y extraer | Función | Devuelve | Ejemplo con `s = "cadena_simple"` | |---|---|---| | `trim(cad)` | Sin espacios en blanco al inicio y al final | `trim(" hola ")` → `hola` | | `ltrim(cad)` | Sin espacios al inicio | `ltrim(" hola ")` → `hola ` | | `rtrim(cad)` | Sin espacios al final | `rtrim(" hola ")` → ` hola` | | `left(cad, n)` | La cadena **a partir** de la posición `n` (omite los primeros `n` caracteres) | `left(s, 3)` → `ena_simple` | | `right(cad, n)` | Los últimos `n` caracteres | `right(s, 3)` → `ple` | | `substring(cad, inicio, longitud)` | `longitud` caracteres desde `inicio` | `substring(s, 3, 4)` → `ena_` | | `lremove(cad, n)` | Los primeros `n` caracteres (quita desde la posición `n` hasta el final) | `lremove(s, 5)` → `caden` | | `remove(cad, inicio, longitud)` | La cadena sin `longitud` caracteres desde `inicio` | `remove(s, 3, 4)` → `cadsimple` | | `rremove(cad, n)` | La cadena sin los últimos `n` caracteres | `rremove(s, 5)` → `cadena_s` | | `cut(cad, n)` | La cadena recortada a `n` caracteres como máximo; completa si es más corta; `""` si está vacía | `cut("Descripción larga", 11)` → `Descripción` | | `length(cad)` | Número de caracteres | `length(s)` → 13 | > Ojo con los nombres: `left` **no** devuelve los primeros caracteres (para eso use `substring(cad, 0, n)` o `lremove(cad, n)`), y `lremove` **no** quita los primeros caracteres. Se conservan así por compatibilidad. `substring`, `left`, `right`, `remove` y `rremove` lanzan una excepción si las posiciones salen de la cadena; para truncar sin riesgo use `cut`. ## Buscar y comparar | Función | Devuelve | |---|---| | `contains(cad, subcad)` | `@true` si `cad` contiene `subcad` (distingue mayúsculas) | | `findstrex(cad, subcad, sensible)` | Posición de `subcad` en `cad`, o -1. Con `sensible` = `@true` distingue mayúsculas | | `findstr(cad, subcad)` | Igual que `findstrex(cad, subcad, @false)`: posición sin distinguir mayúsculas, o -1 | | `isany(caracter, cadena)` | `@true` si el primer carácter de `caracter` es alguno de los de `cadena` | | `containschar(cad, caracteres)` | `@true` si `cad` contiene alguno de los `caracteres` | | `containsword(cad, palabras)` | `@true` si `cad` contiene alguna de las `palabras` separadas por comas (como subcadena, distingue mayúsculas) | | `isanyword(cad, palabras)` | `@true` si `cad` **es** alguna de las `palabras` separadas por comas (sin espacios alrededor y sin distinguir mayúsculas) | ## Transformar | Función | Devuelve | |---|---| | `toupper(cad)` / `tolower(cad)` | En mayúsculas / minúsculas (incluye acentos y ñ) | | `replace(cad, buscar, reemplazo)` | Todas las apariciones de `buscar` reemplazadas | | `ranychars(cad, caracteres, c)` | Cada carácter de `caracteres` que aparezca en `cad` reemplazado por `c` | | `ranydiffchars(cad, caracteres, c)` | Cada carácter de `cad` que **no** esté en `caracteres` reemplazado por `c` | | `padleft(cad, tam, c)` | La cadena alineada a la derecha y rellenada **a la izquierda** con `c` hasta `tam` caracteres (no recorta si es más larga) | | `padright(cad, tam, c)` | Rellenada **a la derecha** con `c` hasta `tam` caracteres | | `split(cad, separador)` | Lista de subcadenas; el separador es un solo carácter (se usa el primero) | | `format(número, formato)` | El número con un formato de .NET (`N2`, `C`, `P1`, `000000`, `#,0.00`) | **`format` es para mostrar, no para datos.** Usa la cultura de presentación del servidor (`-culture es-MX`, la llave `culture` de `fastcgi.json`, `DEVKRON_CULTURE` o la del sistema): con la cultura invariante `format(1234.5, "C")` da `¤1,234.50` y con `es-MX` da `$1,234.50`; en `es-CO` usa coma decimal. No vuelva a leer con `parse.num` un texto producido por `format`: en un servidor con coma decimal el resultado es 0. Para datos (SQL, JSON, archivos) use `str(n)`. ## Ejemplo ```dkl #include "dkli.dkh" #! program "cadenas" { #include "functions.dkh" #include "serialize.dkh" s = "cadena_simple" do print("[" + trim(" hola ") + "][" + ltrim(" hola ") + "][" + rtrim(" hola ") + "]") do print(left(s, 3)) do print(right(s, 3)) do print(substring(s, 3, 4)) do print(lremove(s, 5)) do print(remove(s, 3, 4)) do print(rremove(s, 5)) do print(length(s)) do print(toupper("ñandú") + " " + tolower("ÁRBOL")) do print(to.json(split("a,b,,c", ","))) do print(replace(s, "simple", "doble")) do print("[" + padleft("42", 6, "0") + "][" + padright("42", 6, "-") + "]") do print(contains(s, "_")) do print(contains(s, "X")) do print(findstrex("Factura FAC-10", "fac", @true)) do print(findstrex("Factura FAC-10", "fac", @false)) do print(findstr("Factura FAC-10", "FAC")) do print(findstr("Factura", "xyz")) do print(ranychars("a-b_c d", "-_ ", ".")) do print(ranydiffchars("Tel: (961) 123-45", "0123456789", "*")) do print(cut("Descripción larga", 11)) do print(cut("corta", 20)) do print(format(1234567.891, "N2")) do print(format(0.256, "P1")) do print(format(42, "000000")) do print(isany("b", "abc")) do print(isany("z", "abc")) do print(containschar("hola@ejemplo.com", "@#")) do print(containsword("pago con tarjeta de crédito", "efectivo,tarjeta")) do print(isanyword(" SI ", "si,no")) do print(isanyword("tal vez", "si,no")) } ``` ```text [hola][hola ][ hola] ena_simple ple ena_ caden cadsimple cadena_s 13 ÑANDÚ árbol ["a","b","","c"] cadena_doble [000042][42----] 1 0 -1 0 0 -1 a.b.c.d ******961**123*45 Descripción corta 1,234,567.89 25.6 % 000042 1 0 1 1 1 0 ``` `findstrex("Factura FAC-10", "fac", @false)` da 0 porque, sin distinguir mayúsculas, la primera coincidencia es "**Fac**tura". El texto exacto de algunos formatos (`P1` da `25.6 %` o `25.6%`) depende de la versión de ICU del sistema operativo. ## Argumentos clave/valor: from.args y from.argsn `from.args(lista, separador)` convierte una lista de cadenas `clave=valor` en un registro; `from.argsn(lista, separador, numéricas)` además convierte a número las claves listadas en `numéricas` (separadas por comas; un valor no numérico queda en 0). El separador es un solo carácter (`""` equivale a `:`); un elemento sin separador queda como clave con valor vacío. Estas funciones necesitan una lista de **cadenas de .NET**, como la que devuelve la línea de comandos. Las listas que arma DKL (`split`, `list.create`, `from.json`) son listas de objetos y dan error: ```text {1} Error en 'from.args. (Debe proporcionar una lista de argumentos en un objeto IEnumerableException has been thrown by the target of an invocation.) [reporte.dkl][Ln= 13] ``` En la práctica se usan a través de `commandline` y `commandlinen`, que leen los argumentos del programa (ver [Archivos y carpetas](/es/devkron/2.0/bibliotecas/motor/functions/archivos.md)). Para partir una cadena propia `clave=valor`, use `split` y recórrala. ## Búfer de texto: text.* Concatenar miles de cadenas con `+` es lento. Un búfer de texto (basado en `StringBuilder`) acumula el texto y lo entrega al final: | Función | Qué hace | |---|---| | `text.create()` | Devuelve un búfer vacío (use `ref`) | | `text.echo(búfer, cad)` | Agrega `cad` | | `text.say(búfer, cad)` | Agrega `cad` y un salto de línea | | `text.get(búfer)` | Devuelve todo el texto acumulado | | `text.clear(búfer)` | Vacía el búfer | ```dkl #include "dkli.dkh" #! program "texto" { #include "functions.dkh" ref buf = text.create() do text.echo(buf, "Folio: ") do text.say(buf, "A-100") do text.say(buf, "Total: 300") do print(text.get(buf)) do text.clear(buf) do print("[" + text.get(buf) + "]") } ``` ```text Folio: A-100 Total: 300 [] ``` Para armar un CSV o un reporte, use un ciclo con `text.say` y al final `file.wtext(ruta, text.get(buf))`. ## Errores típicos - `Index and length must refer to a location within the string.` - **Causa:** `substring`/`remove` con posiciones fuera de la cadena. - **Solución:** use `cut`, o compare con `length`. - `startIndex ('-3') must be a non-negative value.` (en `substring`, línea de `functions.dkh`) - **Causa:** `right(cad, n)` con `n` mayor que la longitud. - **Solución:** compare con `length` antes. - `Debe proporcionar una lista de argumentos en un objeto IEnumerable` - **Causa:** `from.args` con una lista de DKL. - **Solución:** use `commandline` o `split`. - Un total formateado vuelve como 0 al leerlo. - **Causa:** `parse.num(format(…))` en un servidor con coma decimal. - **Solución:** use `str(n)` para datos. [Regresar a functions.dkh](/es/devkron/2.0/bibliotecas/motor/functions/)