# Registros Un **registro** (o estructura) es un objeto con campos nombrados: el equivalente de un objeto JSON. Es el tipo de dato central en DKL: los datos de un formulario, el renglón de una consulta, la respuesta de un servicio y `@http_context` son registros. Internamente es un `Dictionary` de .NET **que no distingue mayúsculas** en los nombres de campo. Cualquier objeto de .NET que implemente `IDictionary` se puede tratar como registro. ## Crear: new y using - `new r { … }` crea un registro nuevo en la variable de referencia `r`. - `using r { … }` usa el registro `r` si existe y lo crea si no. ```dkl new r { @"campo1": "datos del campo1" otro_campo := "datos del otro campo" } using r { @"campo2": "datos del campo2" campo3 := 19 } do print(to.json(r)) using nuevo { @"k": "v" } do print(to.json(nuevo)) ``` ```text {"campo1":"datos del campo1","otro_campo":"datos del otro campo","campo2":"datos del campo2","campo3":19} {"k":"v"} ``` `new x {}` crea un registro vacío; también `ref x = record.create()`. **Cada campo va en su propia línea.** `@"a":1 @"b":2` en una línea da `Se esperaba un operador` al ejecutar (aunque `-parse` no marque error). ## Campos Dentro de `new`, `using` o `member`, un campo se escribe de dos formas: | Forma | Uso | |---|---| | `@"nombre": valor` | Cualquier nombre (con espacios, puntos, guiones). Valor: número, cadena o expresión. | | `nombre := valor` | Operador **morsa**: más corto, para nombres que son identificadores válidos. | | `@"nombre*": objeto` | El campo guarda un **objeto** (registro, lista). El `*` final lo indica. | ```dkl ref l = list.of("x") new cliente { @"nombre": "Ana" @"saldo inicial": 1500.50 edad := 30 ciudad := "Tuxtla" @"etiquetas*": l } do print(to.json(cliente)) ``` ```text {"nombre":"Ana","saldo inicial":1500.50,"edad":30,"ciudad":"Tuxtla","etiquetas":["x"]} ``` Sin el `*`, `@"etiquetas": l` guardaría el **índice** del objeto (un número), no la lista. El operador morsa no puede asignar objetos **dentro** del bloque del registro; use `@"campo*": objeto`. ## Registros dentro de registros: member y new member - `new member @"nombre" { … }` crea el campo como un registro nuevo (si ya existía, lo **reemplaza**). - `member @"nombre" { … }` usa el registro del campo si existe (agrega o cambia campos) y lo crea si no. ```dkl new r { new member @"a" { @"campo": "valor" } } using r { member @"a" { @"campo2": "valor2" } new member @"b" { @"x": 1 } @"top": "t" } do print(to.json(r)) using r { new member @"a" { @"solo": "esto" } } do print(to.json(r)) ``` ```text {"a":{"campo":"valor","campo2":"valor2"},"b":{"x":1},"top":"t"} {"a":{"solo":"esto"},"b":{"x":1},"top":"t"} ``` `member "nombre"` (sin `@`) también es válido. ## Leer y escribir campos con rutas < > Fuera del bloque del registro, use `registro<"ruta">`. La ruta separa niveles con `/`, y puede ser una expresión. ```dkl new cliente { @"nombre": "Pedro" new member @"conyuge" { @"nombre": "María" @"edad": 29 } } n : cliente<"nombre"> nc : cliente<"conyuge/nombre"> do print(n + " y " + nc) cliente<"nombre">: "Pablo" campo = "conyuge/nombre" cliente: "Lucía" cliente<"conyuge/ciudad">: "Tuxtla" do print(to.json(cliente)) cliente<"direccion/ciudad">: "Tuxtla" ``` ```text Pedro y María {"nombre":"Pablo","conyuge":{"nombre":"Luc\u00EDa","edad":29,"ciudad":"Tuxtla"}} {1} The given key 'direccion' was not present in the dictionary. [ejemplo.dkl][Ln= 24] ``` La última línea falla porque el registro intermedio `direccion` no existe: una ruta crea el campo final, no los niveles de en medio. | Sintaxis | Qué hace | |---|---| | `v : r<"ruta">` | lee el campo en la variable `v` (la crea con el tipo del valor) | | `r<"ruta">: valor` | escribe el campo; el último nivel se crea si no existe, pero los **intermedios deben existir** (si no: `The given key 'direccion' was not present in the dictionary`; créelos antes con `member`) | | `r<"ruta*">: objeto` | escribe un objeto en el campo | | `o : r<"&ruta">` | lee un **objeto** del campo; `o` queda como referencia (no hace falta `ref`) | `r<"…">` es una **sentencia**, no una expresión: `y = r<"nombre"> + "!"` da `Tipos no coinciden`. En expresiones use `@@` o la notación de punto. ## Leer en expresiones: @@ y la notación de punto `@@(registro, "ruta")` devuelve el valor de un campo dentro de cualquier expresión. Un prefijo en la ruta indica el tipo que espera: | Ruta | Devuelve | |---|---| | `"campo"` o `"$campo"` | cadena (`""` si no existe) | | `"#campo"` | número (0 si no existe) | | `"&campo"` | objeto (referencia nula si no existe) | | `"a/b/c"` | campo anidado | La **notación de punto** (`r.campo.sub`) es la forma corta para leer en expresiones, y `r.campo := valor` para escribir. ```dkl new p { @"nombre": "Juan" @"apellidos": "Pérez" @"saldo": 12.5 new member @"pareja" { @"edad": 30 } } do print(@@(p, "nombre") + " " + p.apellidos) do print(@@(p, "#saldo") * 2) do print(@@(p, "#pareja/edad") + 1) do print("[" + @@(p, "noexiste") + "]") do print(@@(p, "#noexiste")) ref sub = @@(p, "&pareja") do print(to.json(sub)) p.pareja.edad := 29 p.ciudad := "Tuxtla" do print(to.json(p)) new hijo { @"n": 1 } p.hijo := ref hijo do print(to.json(p.hijo)) ``` ```text Juan Pérez 25.0 31 [] 0 {"edad":30} {"nombre":"Juan","apellidos":"P\u00E9rez","saldo":12.5,"pareja":{"edad":29},"ciudad":"Tuxtla"} {"n":1} ``` Observe: - `to.json` escapa los caracteres no ASCII (`Pérez` sale como `P\u00E9rez`); es JSON válido. - `p.hijo := ref hijo` asigna un objeto con la morsa **fuera** del bloque del registro; equivale a `p<"hijo*">: hijo`. - Los nombres de campo no distinguen mayúsculas: `@@(p, "NOMBRE")` es lo mismo que `@@(p, "nombre")`, y escribir `p<"NOMBRE">: "x"` conserva la escritura original de la clave. - `@@set(registro, "ruta", valor)` escribe un campo desde una expresión (útil dentro de `do`). - El prefijo `#` (y `$`, `&`) indica el tipo al **leer** con `@@`; al escribir no se usa: `r<"#" + k>: v` crea una llave llamada `#…`. Para escribir un campo de nombre calculado use `r: v`. `functions.dkh` también trae `field.*` (`field.str`, `field.num`, `field.dstr`, `field.exist`, `field.remove`…) y `record.*` (`record.copy`, `record.clear`…). Vea [Bibliotecas](/es/devkron/2.0/bibliotecas/). `field.str` y `field.num` fallan si el campo no existe (`No se encontró la llave proporcionada`); para datos externos use `field.dstr`, `field.dnum`, `field.dobj` o pregunte antes con `field.exist`. La notación de punto también sirve en condiciones y en el lado derecho de una asignación (`o.total := o.total + iva`, `if o.cliente.limite > 0`), y 2.0 agrega otras formas cortas: vea [Formas cortas para registros y listas](/es/devkron/2.0/lenguaje/novedades-2.0/formas-cortas.md). ### Contexto implícito: @( ) y @set `@("ruta")` lee un campo del registro global `@__context`, y `@set("campo", valor)` lo escribe (creando `@__context` si no existe). En 1.x `@set` siempre fallaba (`Variable 'isset' no definida`); en 2.0 funciona. ```dkl do @set("cliente", "Ana") do @set("total", 3) do print(@("cliente")) do print(@("#total") + 1) do print(to.json(@__context)) ``` ```text Ana 4 {"cliente":"Ana","total":3} ``` ## Estructurar y desestructurar: >> y << - `a, b >> r` crea (o completa) el registro `r` con un campo por variable, con el mismo nombre. - `a, b << r` crea (o asigna) las variables `a`, `b` con los campos del mismo nombre de `r`. La flecha apunta hacia donde van los datos; las variables siempre van a la izquierda. ```dkl nombre = "Juan" edad = 28 nombre, edad >> persona do print(to.json(persona)) new otra { @"ciudad": "Tuxtla" @"cp": 29000 new member @"geo" { @"lat": 16.75 } } ciudad, cp, geo << otra do print(ciudad + " " + str(cp)) do print(to.json(geo)) do print(to.json(geo)) ``` ```text {"nombre":"Juan","edad":28} Tuxtla 29000 {"lat":16.75} {"lat":16.75} ``` Reglas: - Con `>>`, cada campo se llama como la variable **tal como se escribió** (`Ciudad >> p` crea el campo `Ciudad`; una global `@g` crea el campo `g`). Una variable de referencia guarda el mismo objeto (no una copia). - Con `<<`, una variable **nueva** toma el tipo del campo; una **existente** conserva su tipo (una numérica acepta `"12"` pero no `"abc"`). - Si falta un campo: `No existe el miembro 'b' en el registro indicado` (las variables anteriores ya se asignaron). - `>>` y `<<` solo trabajan con **registros**. Para listas, 2.0 agrega las [flechas `->` y `<-`](/es/devkron/2.0/lenguaje/novedades-2.0/flechas-de-listas.md). - **Corregido en 2.0:** en 1.x, un objeto sacado con `<<` se perdía después de la siguiente llamada (`to.json(geo)` daba `null` la segunda vez). En 2.0 se conserva, como muestra el ejemplo. Casos que conviene evitar (se comportan igual que en 1.x): `nada >> r` con una variable inexistente o `a+1 >> r` con una expresión dan `Object reference not set to an instance of an object`; `w >> r.sub` no navega: crea una variable llamada literalmente `r.sub`. ## Bloques de datos $$ (2.0) En 2.0 un registro completo, con listas y registros anidados, se puede escribir con notación JSON dentro de `new`/`using`/`member`: ```dkl precio = 150.5 new pedido {$$ "cliente": "Juan", "partidas": [{"producto": "P-01", "cantidad": 2, "precio": precio}], "pagado": false $$} do print(to.json(pedido)) ``` ```text {"cliente":"Juan","partidas":[{"producto":"P-01","cantidad":2,"precio":150.5}],"pagado":false} ``` Vea [Bloques de datos `$$`](/es/devkron/2.0/lenguaje/novedades-2.0/bloques-de-datos.md).