# Listas y tablas ## Listas Una **lista** es una colección ordenada de valores (números, cadenas, registros, otras listas), como un arreglo JSON. Internamente es un `List` de .NET. Se manejan con variables `ref` y con las funciones `list.*` de `functions.dkh`. ### Crear ```dkl ref a = list.create() ref b = list.of("uno", 2, "tres") ref c = split("x;y;z", ";") ref d = from.json("[1, 2.5, \"tres\"]") new e {$$ 10, "pedro", 3.5 $$} do print(to.json(b) + " " + to.json(c) + " " + to.json(d) + " " + to.json(e)) ``` ```text ["uno",2,"tres"] ["x","y","z"] [1,2.5,"tres"] [10,"pedro",3.5] ``` `list.of` y los bloques `{$$ … $$}` son de 2.0. ### Agregar En 2.0 use las funciones **tipadas**: `list.addstr`, `list.addnum`, `list.addobj`, `list.addnull` (y sus versiones de inserción `list.insstr`, `list.insnum`, `list.insobj`). O las [flechas](/es/devkron/2.0/lenguaje/novedades-2.0/flechas-de-listas.md) `a, b -> lista`. ```dkl ref l = list.create() do list.addstr(l, "3") do list.addnum(l, 3) new r { @"k": 1 } do list.addobj(l, r) do list.addnull(l) total = 10 total, "fin" -> l do print(to.json(l)) ``` ```text ["3",3,{"k":1},null,10,"fin"] ``` **`list.add` espera un objeto.** Se conserva igual que en 1.x: con un número entero no agrega ese valor sino **el objeto cuyo índice es ese número** (sin error). Desde 2.0.4, una cadena (aunque sea numérica) o un número con decimales se agregan como valor. Úsela con variables `ref` y use `list.addnum`/`list.addstr` para valores: ```dkl ref l = list.create() do list.add(l, 3) do list.add(l, "3") do list.add(l, "hola") do list.addnum(l, 3) do print(to.json(l)) ``` ```text [{},"3","hola",3] ``` Hasta 2.0.3, `list.add(l, "3")` también agregaba el objeto 3 (`[{},{},"hola",3]`). ### Leer | Función | Devuelve | |---|---| | `list.count(l)` | número de elementos | | `list.str(l, i)` / `list.num(l, i)` / `list.obj(l, i)` | elemento `i` como cadena / número / objeto (desde 1.x) | | `list.atstr(l, i)` / `list.atnum(l, i)` / `list.atobj(l, i)` | ídem, con **índices negativos** (`-1` = el último) (2.0) | | `list.get(l, i)` | el elemento con su propio tipo (2.0) | | `list.type(l, i)` | 0 nulo, 1 cadena, 2 número, 3 objeto (2.0) | | `@count(l)` / `@item(l, i)` | cuenta y elemento (objeto) de una lista **o** de una tabla | ```dkl ref l = list.of("a", 2.5, "c") do print(list.count(l)) do print(list.str(l, 0)) do print(list.num(l, 1) * 2) do print(list.atstr(l, -1)) do print(list.type(l, 1)) x = list.get(l, 1) do print(x + 1) l -> primero, segundo do print(primero + " " + str(segundo)) ``` ```text 3 a 5.0 c 2 3.5 a 2.5 ``` Un índice fuera de rango es un error (`Index was out of range…` con `list.str`; `list.at: índice 5 fuera de rango (elementos: 3)` con las funciones de 2.0). ### Recorrer Con `for`: ```dkl ref productos = from.json("[{\"n\":\"Lápiz\",\"p\":5.5},{\"n\":\"Goma\",\"p\":3}]") for i = 0; i < list.count(productos) { ref p = list.obj(productos, i) do print(@@(p, "n") + ": " + format(@@(p, "#p"), "0.00")) } ``` ```text Lápiz: 5.50 Goma: 3.00 ``` O con las funciones abiertas `foreach.lstr`, `foreach.lnum` y `foreach.lobj` (vea [Sentencias](/es/devkron/2.0/lenguaje/imperativo/sentencias.md)). Filtrar, transformar, buscar, agrupar, sumar por llave, quitar duplicados y ordenar se escriben en pocas líneas: vea [Recetas de colecciones](/es/devkron/2.0/lenguaje/imperativo/recetas-de-colecciones.md) y, para ordenar e invertir, [listx.dkh](/es/devkron/2.0/bibliotecas/estandar/listx.md). ### Modificar | Función | Qué hace | |---|---| | `list.ins(l, i, obj)` / `list.set(l, i, obj)` / `list.del(l, i)` / `list.clear(l)` | insertar, reemplazar, borrar, vaciar (1.x) | | `list.insstr`, `list.insnum`, `list.insobj` | insertar con tipo, admite negativos (2.0) | | `list.setstr`, `list.setnum` | reemplazar con tipo (2.0) | | `list.remove(l, i)` | quitar, admite negativos (2.0) | | `list.merge`, `list.copy`, `list.slice`, `list.join`, `list.split`, `list.indexstr`, `list.indexnum` | combinar, copiar, rebanar, unir, dividir, buscar (2.0) | ```dkl ref l = list.of("uno", "dos", "tres") do list.insstr(l, 1, "insertado") do list.setstr(l, 0, "UNO") do list.remove(l, -1) do print(to.json(l)) do print(list.join(l, ", ")) do print(list.indexstr(l, "dos")) ``` ```text ["UNO","insertado","dos"] UNO, insertado, dos 2 ``` La referencia completa de cada función nueva, con ejemplos, está en [Funciones `list.*` de 2.0](/es/devkron/2.0/lenguaje/novedades-2.0/funciones-list.md); las de 1.x, en [Bibliotecas](/es/devkron/2.0/bibliotecas/). ### split `split(texto, separador)` divide una cadena y devuelve una lista de cadenas. Los vacíos se conservan. ```dkl ref p = split("a,b,,c", ",") do print(str(list.count(p)) + " " + to.json(p)) ref q = split("uno||dos", "||") do print(to.json(q)) ``` ```text 4 ["a","b","","c"] ["uno","","dos"] ``` ## Tablas Una **tabla** tiene columnas definidas por un registro modelo y renglones. Es lo que devuelven las consultas de `dbr`. Funciones principales: `table.create(modelo)`, `table.rows`, `table.cols`, `row.add`, `row.get`, `cell.str`/`cell.num` (por número de columna) y `cell.strc`/`cell.numc` (por nombre). ```dkl new modelo { @"id": 0 @"nombre": "" @"precio": 0 } ref t = table.create(modelo) new f1 { @"id": 1 @"nombre": "Lápiz" @"precio": 5.50 } new f2 { @"id": 2 @"nombre": "Goma" @"precio": 3 } do row.add(t, f1) do row.add(t, f2) do print(str(table.rows(t)) + " renglones, " + str(table.cols(t)) + " columnas") do print(cell.strc(t, 1, "nombre")) do print(cell.num(t, 0, 2) + cell.numc(t, 1, "precio")) do print(to.json(t)) ``` ```text 2 renglones, 3 columnas Goma 8.50 {"Table":[[1,"L\u00E1piz",5.50],[2,"Goma",3]]} ``` La referencia de `table.*`, `row.*`, `cell.*` y `col.*` está en [Bibliotecas](/es/devkron/2.0/bibliotecas/), y el acceso a bases de datos, en `dbr`.