# Listas: list.* Las listas no son una estructura nativa de DKL: son objetos .NET (`List`) que se manejan con estas funciones. Las devuelven `list.create()`, `split`, `from.json` de un arreglo, `dbr.list`, `list.files` y los bloques de datos `$$ … $$`. Tienen **índice base cero** y pueden mezclar cadenas, números, nulos y objetos. Devkron 2.0 conserva las funciones `list.*` de 1.x sin cambios y agrega funciones nuevas con **altas tipadas** e **índices negativos** (`-1` es el último elemento). ## Funciones de 1.x | Función | Devuelve | Qué hace | |---|---|---| | `list.create()` | Lista nueva | Crea una lista vacía | | `list.create_from_fields(registro)` | Lista de cadenas | Los nombres de los campos de un registro | | `list.count(lista)` | Número | Cantidad de elementos; -1 si la lista es `@null` | | `list.add(lista, objeto)` | Número de elementos | Agrega un **objeto** al final (ver advertencia) | | `list.ins(lista, i, objeto)` | Número de elementos | Inserta un objeto en la posición `i` | | `list.set(lista, i, objeto)` | `i` | Reemplaza el elemento `i` | | `list.obj(lista, i)` | Referencia | El elemento `i` como objeto (use `ref`) | | `list.str(lista, i)` | Cadena | El elemento `i` como cadena | | `list.num(lista, i)` | Número | El elemento `i` como número | | `list.del(lista, i)` | Número de elementos | Elimina el elemento `i` | | `list.clear(lista)` | — | Elimina todos los elementos | > **`list.add`, `list.ins` y `list.set` solo reciben objetos.** Si les pasa un número o una cadena que es un número entero, DKL lo interpreta como el índice interno de un objeto y agrega ese objeto: `list.add(l, "3")` agrega `{}`, no `"3"`. Para cadenas y números use `list.addstr`, `list.addnum`, `list.insstr`, `list.setnum`, etc. (abajo). ```dkl #include "dkli.dkh" #! program "listas" { #include "functions.dkh" #include "serialize.dkh" ref l = list.create() new p1 { @"sku": "P-01" } new p2 { @"sku": "P-02" } do print(list.add(l, p1)) do print(list.add(l, p2)) do print(list.count(l)) ref primero = list.obj(l, 0) do print(field.str(primero, "sku")) new p0 { @"sku": "P-00" } do print(list.ins(l, 0, p0)) new p9 { @"sku": "P-09" } do print(list.set(l, 2, p9)) do print(to.json(l)) do print(list.del(l, 1)) do print(to.json(l)) ref nombres = split("ana,beto,carla", ",") do print(list.str(nombres, 1)) ref nums = from.json("[10, 20.5]") do print(list.num(nums, 1) + 1) new reg { @"uno": 1 @"dos": 2 } ref campos = list.create_from_fields(reg) do print(to.json(campos)) do list.clear(l) do print(list.count(l)) do print(list.obj(l, 5)) exception { do print(last_error()) do clear_exceptions() } } ``` ```text 1 2 2 P-01 3 2 [{"sku":"P-00"},{"sku":"P-01"},{"sku":"P-09"}] 2 [{"sku":"P-00"},{"sku":"P-09"}] beto 21.5 ["uno","dos"] 0 {1} Error en 'list.obj. (Index was out of range. Must be non-negative and less than the size of the collection. (Parameter 'index')Exception has been thrown by the target of an invocation.) [listas.dkl][Ln= 47] ``` ## Funciones nuevas de 2.0 Todas trabajan sobre las mismas listas. Aceptan **índices negativos** (`-1` último, `-2` penúltimo); en las inserciones, `-1` o la cantidad de elementos significan "al final". Un índice fuera de rango, una lista nula o un objeto que no es lista dan un error con el nombre de la función. | Función | Devuelve | Qué hace | |---|---|---| | `list.addstr(l, cadena)` | Número de elementos | Agrega una cadena (`"3"` sigue siendo cadena) | | `list.addnum(l, número)` | Número de elementos | Agrega un número | | `list.addobj(l, ref)` | Número de elementos | Agrega un objeto; una cadena o un número es error | | `list.addnull(l)` | Número de elementos | Agrega un nulo | | `list.insstr(l, i, cadena)` | Número de elementos | Inserta una cadena en `i` | | `list.insnum(l, i, número)` | Número de elementos | Inserta un número en `i` | | `list.insobj(l, i, ref)` | Número de elementos | Inserta un objeto en `i` | | `list.setstr(l, i, cadena)` | Número de elementos | Reemplaza el elemento `i` por una cadena | | `list.setnum(l, i, número)` | Número de elementos | Reemplaza el elemento `i` por un número | | `list.atstr(l, i)` | Cadena | Elemento `i` | | `list.atnum(l, i)` | Número | Elemento `i` | | `list.atobj(l, i)` | Objeto (use `ref`) | Elemento `i` | | `list.get(l, i)` | Cadena, número u objeto | Según el tipo del elemento; nulo si es nulo. Para objetos use `ref` | | `list.type(l, i)` | Número | 0 nulo, 1 cadena, 2 número, 3 objeto (como `vartype`) | | `list.remove(l, i)` | Número de elementos | Quita el elemento `i` | | `list.merge(destino, origen)` | Elementos del destino | Agrega al final de `destino` los elementos de `origen` (copia superficial) | | `list.copy(l)` | Lista nueva | Copia superficial: los objetos anidados se comparten | | `list.slice(l, desde, cuantos)` | Lista nueva | `cuantos` elementos desde `desde` (admite negativo); `cuantos` se recorta al final; `cuantos` negativo = hasta el final | | `list.join(l, separador)` | Cadena | Los elementos unidos por `separador` (números con punto decimal) | | `list.split(texto, separador)` | Lista de cadenas | Como `split` | | `list.indexstr(l, cadena)` | Posición o -1 | Primera cadena igual | | `list.indexnum(l, número)` | Posición o -1 | Primer número igual | | `list.of(a, b, …)` | Lista nueva | Hasta 16 valores; cadenas y números conservan su tipo. Una variable `ref` llega como su índice: para objetos use `list.addobj` | ```dkl #include "dkli.dkh" #! program "listas2" { #include "functions.dkh" #include "serialize.dkh" ref folios = list.create() do list.addstr(folios, "A-1") do list.addstr(folios, "A-2") do list.addnum(folios, 3) do list.addnull(folios) new extra { @"folio": "A-4" } do list.addobj(folios, extra) do print(to.json(folios)) do print(list.atstr(folios, 0) + " " + list.atstr(folios, -4)) do print(list.atnum(folios, 2) * 10) ref ultimo = list.atobj(folios, -1) do print(field.str(ultimo, "folio")) do print(str(list.type(folios, 0)) + str(list.type(folios, 2)) + str(list.type(folios, 3)) + str(list.type(folios, 4))) x = list.get(folios, 1) do print(x) do print(list.remove(folios, -1)) do print(list.remove(folios, -1)) do print(to.json(folios)) do list.insstr(folios, 0, "A-0") do list.insnum(folios, -1, 99) do list.insobj(folios, 1, extra) do list.setstr(folios, 0, "INICIO") do list.setnum(folios, -1, 100) do print(to.json(folios)) ref otra = list.of("x", "y") do print(list.merge(otra, list.of(1, 2))) ref copia = list.copy(otra) do print(to.json(list.slice(copia, 1, 2))) do print(list.join(copia, ";")) ref partes = list.split("2026-10-27", "-") do print(to.json(partes)) do print(list.indexstr(partes, "10")) do print(list.indexnum(copia, 2)) do print(list.indexstr(partes, "99")) } ``` ```text ["A-1","A-2",3,null,{"folio":"A-4"}] A-1 A-2 30 A-4 1203 A-2 4 3 ["A-1","A-2",3] ["INICIO",{"folio":"A-4"},"A-1","A-2",3,100] 4 ["y",1] x;y;1;2 ["2026","10","27"] 1 3 -1 ``` Las listas también se arman con la sintaxis nueva de 2.0: flechas (`a, b -> lista`, `lista -> a, b`) y bloques de datos (`new l {$$ "a", 1 $$}`), descritos en la referencia del lenguaje. ## Recorrer una lista Con un ciclo `for` y `list.count`: ```dkl ref l = split("ana,beto", ",") for i=0; i 0` | | `list.addobj: se esperaba una referencia a un objeto.` | Cadena o número a `list.addobj` | `list.addstr` / `list.addnum` | | `list.addstr: el objeto no es una lista.` | Se pasó un registro u otro objeto | Use una lista | | La lista de `list.of` trae un número donde iba un registro | Las referencias llegan como índice | `list.addobj` o flechas | [Regresar a functions.dkh](/es/devkron/2.0/bibliotecas/motor/functions/)