# Registros: field, record, @ y @@ Un **registro** es la estructura de datos de DKL: un conjunto de campos con nombre que pueden guardar cadenas, números u otros objetos (registros, listas, tablas, fechas). Lo devuelven `new`, `record.create()`, `from.json`, `dbr.rec`, `dbr.get`, `row.get` y muchas otras funciones. Esta página documenta las funciones de `functions.dkh` para leerlos, modificarlos y copiarlos. - Los nombres de campo **no distinguen mayúsculas**. - Donde se pide `campo` se acepta una **ruta** `"campo/campo/campo"` para llegar a registros anidados. - Un campo que guarda un objeto se asigna con `*`: `r<"cliente*">: otro_registro`. ## Leer campos: field.* | Función | Devuelve | Si el campo no existe | |---|---|---| | `field.str(registro, campo)` | El valor como cadena (convierte si es número) | Excepción `No se encontró la llave proporcionada` | | `field.num(registro, campo)` | El valor como número (convierte si es cadena numérica) | Excepción | | `field.obj(registro, campo)` | Una referencia al objeto del campo (use `ref`) | Excepción | | `field.dstr(registro, campo, default)` | El valor como cadena | `default`; también si el campo vale nulo | | `field.dnum(registro, campo, default)` | El valor como número | `default`; también si vale nulo | | `field.dobj(registro, campo, default)` | Una referencia al objeto | La referencia `default` (puede ser `@null`); también si vale nulo | | `field.exist(registro, campo)` | `@true` (1) si el campo existe, aunque valga nulo | 0 | | `field.typeof(registro, campo)` | 1 cadena (o fecha), 2 número, 3 objeto, 0 no existe | 0 | | `field.remove(registro, campo)` | `@true` si lo eliminó | 0 (no es error) | Use las versiones `d…` (con valor predeterminado) cuando el campo es opcional, por ejemplo al leer el cuerpo JSON de una petición; use `field.str`/`field.num` cuando el campo es obligatorio y quiere que falte un dato sea un error. ```dkl #include "dkli.dkh" #! program "registros" { #include "functions.dkh" #include "serialize.dkh" new cliente { @"nombre": "Juan" @"rfc": "XAXX010101000" @"saldo": 1250.5 member @"domicilio" { @"ciudad": "Tuxtla Gutiérrez" @"cp": "29000" } } do print(field.str(cliente, "nombre")) do print(field.num(cliente, "saldo") * 2) do print(field.str(cliente, "domicilio/ciudad")) ref dom = field.obj(cliente, "domicilio") do print(to.json(dom)) do print(field.exist(cliente, "rfc")) do print(field.exist(cliente, "telefono")) do print(field.exist(cliente, "domicilio/cp")) do print(field.typeof(cliente, "nombre")) do print(field.typeof(cliente, "saldo")) do print(field.typeof(cliente, "domicilio")) do print(field.typeof(cliente, "telefono")) do print(field.dstr(cliente, "telefono", "sin teléfono")) do print(field.dnum(cliente, "limite", 5000)) ref vacio = field.dobj(cliente, "facturacion", @null) do print(isnull(vacio)) do print(field.remove(cliente, "rfc")) do print(field.remove(cliente, "rfc")) do print(to.json(cliente)) do print(field.str(cliente, "telefono")) exception { do print(last_error()) do clear_exceptions() } } ``` ```text Juan 2501.0 Tuxtla Gutiérrez {"ciudad":"Tuxtla Gutiérrez","cp":"29000"} 1 0 1 1 2 3 0 sin teléfono 5000 1 1 0 {"nombre":"Juan","saldo":1250.5,"domicilio":{"ciudad":"Tuxtla Gutiérrez","cp":"29000"}} {1} Error en 'field.str. (No se encontró la llave proporcionadaException has been thrown by the target of an invocation.) [registros.dkl][Ln= 37] ``` Detalles: - `field.typeof` devuelve 1 también para campos de fecha (`DateTime`). Sobre un campo que **existe pero vale nulo** (por ejemplo `{"z": null}` leído con `from.json`) lanza `Object reference not set to an instance of an object`; compruebe antes con `field.dobj(r, "z", @null)` e `isnull`. - Si un tramo intermedio de la ruta no es un registro (`"partidas/0/cantidad"` cuando `partidas` es una lista), `field.*` lanza `No es un record`. Para listas use `field.obj` y luego `list.obj`. - El número de línea de los mensajes (`[Ln= n]`) puede no coincidir exactamente con la sentencia; tómelo como referencia aproximada. ## Crear, copiar y limpiar: record.* | Función | Qué hace | |---|---| | `record.create()` | Devuelve un registro vacío | | `record.copy(origen, campos)` | Devuelve un registro nuevo con los campos indicados (separados por comas). `"*"` copia todos. Un campo que no existe se copia con valor nulo | | `record.copyex(origen, destino, campos, delimitador, alias, delimitador_alias)` | Copia los `campos` (separados por `delimitador`) a `destino` y lo devuelve; si `destino` es `@null` crea un registro nuevo. `alias` renombra: pares `origen:nuevo` separados por `delimitador`, con `delimitador_alias` entre los dos nombres. Delimitadores vacíos valen `,` y `:` | | `record.copyexin(origen, destino, campos, delimitador, alias, delimitador_alias)` | Igual que `record.copyex`; es el nombre con el que la usa `record.copy` internamente | | `record.caseinsensitive(registro)` | Devuelve una copia del registro con nombres de campo insensibles a mayúsculas. Los registros de DKL ya lo son, así que casi nunca hace falta; sirve para diccionarios que llegan de una extensión .NET | | `record.clear(registro)` | Elimina todos los campos del registro | > `record.copyex` recibe **seis** argumentos, el segundo es el registro de destino (o `@null`). La documentación 1.x mostraba una firma de cinco argumentos que nunca funcionó: tanto en 1.x como en 2.0 da `Parameter count mismatch.` ```dkl #include "dkli.dkh" #! program "record" { #include "functions.dkh" #include "serialize.dkh" new pedido { @"folio": "A-100" @"cliente": "Juan" @"total": 300 @"notas": "urgente" } ref r1 = record.copy(pedido, "folio,total") do print(to.json(r1)) ref r2 = record.copy(pedido, "*") do print(to.json(r2)) ref r3 = record.copyex(pedido, @null, "folio,total", ",", "folio:id,total:importe", ":") do print(to.json(r3)) ref r4 = record.copyex(pedido, @null, "folio|cliente", "|", "", "") do print(to.json(r4)) new destino { @"origen": "web" } ref r5 = record.copyexin(pedido, destino, "folio,total", ",", "", "") do print(to.json(destino)) ref r6 = record.copy(pedido, "folio,inexistente") do print(to.json(r6)) ref nuevo = record.create() nuevo<"a">: 1 do print(to.json(nuevo)) ref ci = record.caseinsensitive(pedido) do print(field.str(ci, "FOLIO")) do print(field.str(pedido, "FOLIO")) do record.clear(pedido) do print(to.json(pedido)) } ``` ```text {"folio":"A-100","total":300} {"folio":"A-100","cliente":"Juan","total":300,"notas":"urgente"} {"id":"A-100","importe":300} {"folio":"A-100","cliente":"Juan"} {"origen":"web","folio":"A-100","total":300} {"folio":"A-100","inexistente":null} {"a":1} A-100 A-100 {} ``` Uso típico: `record.copy(entrada, "nombre,email,telefono")` para quedarse solo con los campos permitidos de un JSON recibido antes de pasarlo a `dbr.insert`. ## Acceso rápido: @, @@ y el registro de contexto `functions.dkh` define funciones cortas para leer campos con prefijo de tipo: | Función | Qué hace | |---|---| | `@@(registro, ruta)` | Lee el campo `ruta` de `registro`. Prefijo `$` (opcional) cadena, `#` número, `&` referencia. Si el campo **no existe** devuelve `""`, o 0 con `#`/`&`, **sin error** | | `@(ruta)` | Igual que `@@`, pero sobre el registro de contexto `@__context` | | `@set(campo, valor)` | Asigna `campo` en `@__context` (lo crea si no existe). En 1.x siempre fallaba; en 2.0 funciona | | `@@set(registro, campo, valor)` | Asigna `campo` en `registro` | | `@context.begin(registro)` | Hace de `registro` el nuevo `@__context` y guarda el anterior en su campo `__parent`. Con `@null` crea un registro nuevo | | `@context.end()` | Regresa `@__context` al registro anterior | | `@count(objeto)` | Filas de una tabla o elementos de una lista; 0 para otra cosa | | `@item(objeto, i)` | Referencia a la fila `i` de una tabla (como registro) o al elemento `i` de una lista; `@null` si no se puede | `@@` es la forma más usada en aplicaciones web para leer parámetros: `@@(@http_context, "request/get/folio")`. ```dkl #include "dkli.dkh" #! program "contexto" { #include "functions.dkh" #include "serialize.dkh" new persona { @"nombre": "Juan" @"apellidos": "Pérez López" @"edad": 38 member @"conyuge" { @"nombre": "Lupita" } } do print(@@(persona, "nombre") + " " + @@(persona, "$apellidos")) do print(@@(persona, "#edad") + 1) ref c = @@(persona, "&conyuge") do print(to.json(c)) do print(@@(persona, "conyuge/nombre")) do print("[" + @@(persona, "telefono") + "] " + str(@@(persona, "#hijos"))) ref @__context = persona do print(@("nombre") + " tiene " + str(@("#edad"))) do @context.begin(@null) do @set("folio", "A-100") do @set("total", 300) do print(to.json(@__context)) do @context.end() do print(@("nombre")) new r2 {} do @@set(r2, "clave", "X1") do print(to.json(r2)) ref l = list.of("a", "b") do print(@count(l)) do print(@item(l, 1)) exception { do print(last_error()) do clear_exceptions() } new item0 { @"k": 1 } ref l2 = list.create() do list.add(l2, item0) ref x = @item(l2, 0) do print(to.json(x)) do print(@count(persona)) } ``` ```text Juan Pérez López 39 {"nombre":"Lupita"} Lupita [] 0 Juan tiene 38 {"__parent":{"nombre":"Juan","apellidos":"Pérez López","edad":38,"conyuge":{"nombre":"Lupita"}},"folio":"A-100","total":300} Juan {"clave":"X1"} 2 14 {"k":1} 0 ``` `@item` devuelve una **referencia**: con una lista de cadenas, imprimirla muestra el índice del objeto (el `14` de arriba), no la cadena. Úsela con listas de registros y tablas; para cadenas use `list.str`. ## Errores típicos | Mensaje | Causa | Solución | |---|---|---| | `No se encontró la llave proporcionada` | `field.str`/`field.num`/`field.obj` de un campo que no existe | Use `field.dstr`/`field.dnum`/`field.dobj` o `field.exist` | | `No es un record` | Un tramo de la ruta no es un registro (es lista o cadena) | Llegue al nivel con `field.obj` y siga con `list.obj` | | `El objeto recibido no puede ser nulo.` | El primer argumento es `@null` | Verifique con `isnull` antes de leer | | `Parameter count mismatch.` en `record.copyex` | Llamada con cinco argumentos | Agregue el destino (`@null`) como segundo argumento | | `Función: context.begin no reconocida` | Falta la `@` del nombre | `@context.begin`, `@context.end` | [Regresar a functions.dkh](/es/devkron/2.0/bibliotecas/motor/functions/)