# Formas cortas de 2.0 para registros y listas Devkron 2.0 permite escribir con menos palabras lo que en 1.x requería `ref`, `list.obj`, `@@` y `field.*`. Todo lo de esta página es aditivo: la forma clásica sigue funcionando. Un programa que use estas formas no corre en Devkron 1.x. ## Acceso con punto en expresiones `o.campo` y `o.a.b` se leen en cualquier expresión, también en condiciones. `o.campo := valor` escribe (la "morsa" fuera de un bloque `new`/`using`), y `o.hijo := ref objeto` guarda un objeto: ```dkl ref o = from.json('{"total":100,"cliente":{"nombre":"Ana","limite":500}}') iva = 16 o.total := o.total + iva if o.total > 110 && o.cliente.limite >= o.total { do print("cliente " + o.cliente.nombre + " puede comprar " + str(o.total)) } o.cliente.nombre := "Ana López" new envio { @"ciudad": "Tuxtla" } o.envio := ref envio do print(to.json(o)) ``` ```text cliente Ana puede comprar 116 {"total":116,"cliente":{"nombre":"Ana L\u00F3pez","limite":500},"envio":{"ciudad":"Tuxtla"}} ``` La ruta `o<"campo">` sigue siendo una **sentencia** (para escribir): en una expresión use el punto o `@@`. ## Sacar elementos de una lista: `x <- l` `x <- l` saca el primer elemento sin `ref` ni `list.obj`; `l -> a, b` saca los primeros en varias variables; `a, b -> l` anexa. Detalle completo en [Flechas de listas](/es/devkron/2.0/lenguaje/novedades-2.0/flechas-de-listas.md). ```dkl ref pedidos = from.json('[{"total":100},{"total":50}]') o <- pedidos using o { total := @@(o, "#total") * 1.16 } total << o do print(str(total) + " " + to.json(pedidos)) ``` ```text 116.00 [{"total":116.00},{"total":50}] ``` `using o { … }` trabaja sobre el mismo objeto que está en la lista, y `total << o` copia el campo a una variable. ## Bloques de datos `$$ … $$` Para construir registros y listas con notación JSON y expresiones DKL. Exigen comas entre elementos; sin ellas el error aparece al ejecutar. Ver [Bloques de datos](/es/devkron/2.0/lenguaje/novedades-2.0/bloques-de-datos.md). ```dkl precio = 100 new r {$$ "subtotal": precio, "iva": precio * 0.16, "partidas": [{"sku": "A1", "cant": 2}], $$} do print(to.json(r)) ``` ```text {"subtotal":100,"iva":16.00,"partidas":[{"sku":"A1","cant":2}]} ``` ## Recorridos con `foreach` y flechas El bloque de un `go` corre en el ámbito de quien llama: puede acumular en variables propias con flechas. Es la base de las [recetas de colecciones](/es/devkron/2.0/lenguaje/imperativo/recetas-de-colecciones.md). ```dkl ref l = from.json('[3, 8, 1, 12]') umbral = 5 total = 0 go foreach.lnum(value:v) with(l) { x = v if x > umbral { x -> grandes } x * 2 -> dobles total = total + x } do print(to.json(grandes) + " " + to.json(dobles) + " " + str(total)) ``` ```text [8,12] [6,16,2,24] 24 ``` El alias (`v`) se copia a una variable local (`x`) antes de usarlo con una flecha: ver [Funciones abiertas](/es/devkron/2.0/lenguaje/imperativo/funciones-abiertas.md). ## Equivalencias | Antes (1.x) | Forma corta (2.0) | |---|---| | `t = @@(o, "#total")` | `t = o.total` | | `o<"total">: @@(o, "#total") + iva` | `o.total := o.total + iva` | | `n = @@(o, "cliente/nombre")` | `n = o.cliente.nombre` | | `ref p = list.obj(l, 0)` | `p <- l` | | `ref a = list.obj(l, 0)` y `ref b = list.obj(l, 1)` | `l -> a, b` | | `do list.addstr(l, s)` y `do list.addnum(l, n)` | `s, n -> l` | | varias líneas `@"k": v` | `{$$ "k": v, … $$}` |