# Recetas de colecciones DKL no trae funciones `filter`, `map`, `find` o `group_by`: se escriben con lo que ya existe, en pocas líneas, combinando los iteradores `foreach.*` (funciones abiertas), las flechas de listas y el acceso con punto. Todas las recetas de esta página se ejecutaron con Devkron 2.0.2. Las recetas usan estos datos: ```text ref ventas = from.json('[{"cliente":"Ana","total":100},{"cliente":"Luis","total":50},{"cliente":"Ana","total":30},{"cliente":"Eva","total":70}]') ``` Dos reglas que hacen funcionar todo lo que sigue (detalle en [Funciones abiertas](/es/devkron/2.0/lenguaje/imperativo/funciones-abiertas.md)): - el bloque de un `go` corre en el ámbito de quien llama: acumula en sus variables; - el alias de un valor (`value:v`) no se usa directo con una flecha: se copia antes (`x = v` o `ref o = v`). ## filter, map, reduce y pluck ```dkl ref nums = from.json('[3, 8, 1, 12]') umbral = 5 total = 0 go foreach.lnum(value:v) with(nums) { x = v if x > umbral { x -> grandes } // filter x * 2 -> dobles // map total = total + x // reduce } do print(to.json(grandes) + " " + to.json(dobles) + " " + str(total)) ref clientes = from.json('[{"n":"Ana","saldo":0},{"n":"Luis","saldo":500},{"n":"Eva","saldo":20}]') go foreach.lobj(value:c) with(clientes) { ref o = c if o.saldo > 0 { o -> morosos } // filter de registros o.n -> nombres // pluck } do print(to.json(morosos)) do print(to.json(nombres)) ``` ```text [8,12] [6,16,2,24] 24 [{"n":"Luis","saldo":500},{"n":"Eva","saldo":20}] ["Ana","Luis","Eva"] ``` Si ningún elemento cumple, la lista del filter no se crea. Cuando el resultado se usa después, créela antes: `ref grandes = list.create()`. ## find, findindex y any `return` dentro del bloque de un `go` **sale de la función que contiene el `go`**. Por eso estas recetas van dentro de una función (en el nivel principal, ese `return` terminaría el programa). ```dkl ref ventas = from.json('[{"cliente":"Ana","total":100},{"cliente":"Luis","total":50},{"cliente":"Eva","total":70}]') primer_mayor::&lista, minimo { go foreach.lobj(index:i, value:x) with(lista) { ref o = x if o.total > minimo { return i } } return -1 } hay_cliente::&lista, nombre { go foreach.lobj(value:x) with(lista) { ref o = x if o.cliente == nombre { return 1 } } return 0 } i = primer_mayor(ventas, 60) // findindex ref p = list.obj(ventas, i) // find do print(str(i) + " " + to.json(p)) do print(primer_mayor(ventas, 500)) do print(str(hay_cliente(ventas, "Eva")) + " " + str(hay_cliente(ventas, "Zoe"))) // any ``` ```text 0 {"cliente":"Ana","total":100} -1 1 0 ``` ## group_by y sum_by ```dkl ref ventas = from.json('[{"cliente":"Ana","total":100},{"cliente":"Luis","total":50},{"cliente":"Ana","total":30},{"cliente":"Eva","total":70}]') new sumas {} new grupos {} go foreach.lobj(value:x) with(ventas) { ref o = x k = o.cliente sumas: @@(sumas, "#" + k) + o.total if not(field.exist(grupos, k)) { ref nueva = list.create() grupos: nueva } ref g = @@(grupos, "&" + k) o -> g } do print(to.json(sumas)) do print(to.json(grupos)) ``` ```text {"Ana":130,"Luis":50,"Eva":70} {"Ana":[{"cliente":"Ana","total":100},{"cliente":"Ana","total":30}],"Luis":[{"cliente":"Luis","total":50}],"Eva":[{"cliente":"Eva","total":70}]} ``` - Para **escribir** un campo de nombre calculado: `r: valor`. Para **leerlo** como número: `@@(r, "#" + k)`. El prefijo `#` es solo de lectura: `r<"#" + k>: valor` crea una llave que se llama literalmente `#Ana`. - Pregunte por el grupo con `field.exist(r, k)` y cree la lista explícitamente. Hasta 2.0.2, aplicar una flecha a una referencia obtenida de un campo que no existe (`ref g = @@(r, "&k")` seguido de `x -> g`) ocupaba la ranura nula compartida, de modo que `@null` y todas las lecturas de campos inexistentes devolvían después esa lista; en 2.0.3 ya no pasa, pero el patrón con `field.exist` funciona igual en todas las versiones (ver [Comportamientos no obvios](/es/devkron/2.0/lenguaje/rarezas.md)). ## distinct ```dkl ref ventas = from.json('[{"cliente":"Ana"},{"cliente":"Luis"},{"cliente":"Ana"},{"cliente":"Eva"}]') ref vistos = list.create() go foreach.lobj(value:x) with(ventas) { ref o = x c = o.cliente if list.indexstr(vistos, c) < 0 { c -> vistos } } do print(to.json(vistos)) ``` ```text ["Ana","Luis","Eva"] ``` Para números use `list.indexnum`. ## chunk (lotes) ```dkl ref ventas = list.of(1, 2, 3, 4, 5) ref lotes = list.create() n = list.count(ventas) for j=0; j lotes } do print(to.json(lotes)) ``` ```text [[1,2],[3,4],[5]] ``` ## Ordenar `listx.dkh` ordena **en su lugar** y devuelve la misma lista: ```dkl #include "dkli.dkh" #! program "ordenar" { #include "functions.dkh" #include "serialize.dkh" #include "listx.dkh" ref ventas = from.json('[{"cliente":"Ana","total":100},{"cliente":"Luis","total":50},{"cliente":"Eva","total":100}]') do list.sort_by(ventas, "total", @true) do print(to.json(ventas)) do print(to.json(list.sort(list.of("b", 10, "B", 2.5)))) do print(to.json(list.reverse(list.of(1, 2, 3)))) } ``` ```text [{"cliente":"Ana","total":100},{"cliente":"Eva","total":100},{"cliente":"Luis","total":50}] [2.5,10,"B","b"] [3,2,1] ``` `list.sort_by` es estable: con totales iguales, Ana y Eva conservan su orden original. ## Escribir su propio iterador Si un recorrido se repite mucho, conviértalo en una función abierta. Este `filtrar` recibe la decisión del bloque a través de una referencia expuesta: ```dkl filtrar::&lista { expose valor, resp new resp {} ref res = list.create() for i=0; i: 0 that if @@(resp, "#ok") { do list.addnum(res, valor) } } return res } ref nums = list.of(3, 8, 1, 12) go filtrar (valor:v, resp:r) with(nums) ->* grandes { r<"ok">: v > 5 } do print(to.json(grandes)) ``` ```text [8,12] ```