1. Acceso a Ficheros¶
1.1. ¿De qué va este tema?¶
En este curso aprendemos a construir la primera persistencia de una aplicación: conservar datos en ficheros y poder intercambiarlos con otros sistemas.
Gestionar la persistencia en ficheros, creando, leyendo y escribiendo ficheros y directorios mediante la forma de acceso adecuada.
Representar y transformar datos, utilizando formatos de intercambio como CSV y JSON sin pérdida de información.
Diseñar un acceso robusto al almacenamiento, tratando errores y separando la persistencia de la lógica de dominio.
El tema tiene una dedicación estimada de 28 horas.
Punto de partida: programación orientada a objetos y tratamiento básico de excepciones. Prepara GitHub con Práctica 0-A. Primeros pasos con Git y GitHub (0-A) y el entorno con Práctica 0-C. Entorno de desarrollo con Codespaces (0-C); si ya los dominas, comprueba las operaciones sin repetir una entrega.
Caso práctico del módulo
Esta unidad forma parte del caso transversal de gestión de FCT.
Ejemplos para experimentar
Cada clase enlaza código ejecutable bajo ud01/ejemplos/. La
guía de ejecución indica el comando, el
cambio propuesto y qué comprobar. En ud01/para_jugar/ tienes el
laboratorio completo de empresas.
Experimenta desde tu copia privada en Codespaces o en local.
Esta experimentación es formativa, no otra entrega. El
entorno común de AD prepara las
herramientas; Maven compila y ejecuta Java. Tú conservas el código fuente,
no los archivos generados.
1.2. Clases¶
Los ejercicios de clase son formativos y no calificables. Primero comprende el concepto; después predice el resultado, ejecuta el ejemplo del repositorio, cambia una cosa y comprueba qué ocurre. Las lecturas y vídeos de apoyo sirven para aclarar los conceptos indicados; no hace falta recorrer íntegramente cada recurso. Java es la referencia de la aplicación y Python permite observar rápidamente operaciones y formatos. No necesitas repetir cada actividad en ambos lenguajes. Las ideas son las mismas; cambian las llamadas de cada biblioteca.
1.2.1. Rutas, ficheros y directorios¶
El sistema de archivos (filesystem) es la parte del sistema operativo que organiza y almacena la información de forma persistente:
Organiza los datos en una jerarquía de directorios (carpetas) y archivos
Cada archivo tiene un nombre y una ubicación dentro de esa jerarquía
El sistema operativo controla quién puede acceder a cada recurso
Una ruta (path) indica dónde se encuentra un archivo o directorio:
Ruta absoluta: parte de la raíz del sistema (p. ej.
/home/alumno/datos)Ruta relativa: parte del directorio de trabajo actual (p. ej.
datos)El separador de directorios depende del sistema (
/en Linux,\en Windows)
Distinguimos dos tipos de recursos:
Archivo: unidad de almacenamiento con contenido (texto, imagen, etc.)
Directorio: contenedor de archivos y de otros directorios
Ambos tienen metadatos: nombre, tamaño, fechas de creación/modificación y permisos
Los permisos controlan el acceso:
Lectura, escritura y ejecución
En sistemas POSIX se asignan al propietario, a un grupo y al resto; otros sistemas pueden usar listas de control de acceso
En un directorio, ejecutar significa poder atravesarlo, no lanzar un programa
Intentar acceder sin permiso provoca un error
Operaciones básicas sobre el sistema de archivos:
Crear archivos y directorios
Listar el contenido de un directorio
Copiar, mover y renombrar
Eliminar archivos y directorios
Comprobar existencia y tipo cuando sea necesario; el estado puede cambiar entre la comprobación y la operación, por lo que también hay que tratar errores
Para leer y ejecutar: sistema de archivos (Wikipedia), especialmente sus ejemplos de rutas Unix/Windows; Path y Files en Java y pathlib en Python. Compara Rutas.java con rutas.py: crea el árbol y repite la operación.
Vídeo de apoyo: rutas y operaciones del sistema
Corey Schafer, OS Module (Python, inglés). Observa directorio de trabajo,
listado y creación. El vídeo usa os; contrasta esas operaciones con
pathlib en nuestro ejemplo.
Actividad
En Rutas o rutas.py, predice dónde apunta fct/empresas.json.
Ejecuta desde la raíz de tu repositorio y contrasta con el directorio de trabajo.
Añade un ciclo al árbol y repite su creación. ¿Aparece dos veces?
Clasifica también ../empresas y C:\fct\alumnos como rutas relativas
o absolutas, indicando el sistema donde las interpretas.
Comprobación razonada
Desde /home/alumno, el ejemplo apunta a
/home/alumno/fct/empresas.json. Crear otra vez un directorio existente
con las opciones del ejemplo no lo duplica. ../empresas es relativa.
La ruta C:\fct\alumnos es absoluta en
Windows; su interpretación no se traslada directamente a Linux.
Permisos y existencia se comprueban en el entorno donde se ejecuta.
Actividad
Localiza en el mismo ejemplo las operaciones de copia, movimiento y borrado. Cambia el nombre de la copia y predice el árbol final antes de ejecutar. ¿Copiar y mover conservan ambos el nombre original?
Comprobación razonada
Copiar conserva el origen; mover cambia su ubicación o nombre.
Tras borrar la copia queda renombrado.txt, junto a los directorios.
El ejemplo limpia su carpeta temporal al terminar.
1.2.2. Elegir cómo acceder a un fichero¶
Según el contenido, un fichero puede ser:
Texto: secuencia de caracteres legibles (un convenio, un listado)
Binario: secuencia de bytes sin interpretación textual (un PDF, una imagen)
Un mismo archivo puede interpretarse de varias formas; la elección depende de lo que queramos hacer con él
La diferencia entre byte y carácter es clave:
El bit es la unidad mínima; un byte agrupa 8 bits
Un carácter (letra, número, símbolo) puede ocupar uno o varios bytes
La codificación es la regla que asocia caracteres a bytes (ASCII, UTF-8, ISO-8859-1, …)
Leer un texto con la codificación equivocada puede producir caracteres incorrectos o una excepción, según los bytes y el tratamiento de errores
Un flujo (stream) es una secuencia ordenada de datos que se lee o escribe:
Flujo de entrada: para leer (del archivo a la aplicación)
Flujo de salida: para escribir (de la aplicación al archivo)
Los flujos pueden trabajar con bytes o con caracteres
Según cómo recorremos el archivo, el acceso puede ser:
Secuencial: se lee o escribe en orden, de principio a fin
Aleatorio: se salta directamente a una posición concreta
Con registros de tamaño fijo, posición = número de registro × bytes por registro
En texto UTF-8, contar caracteres no permite calcular directamente posiciones en bytes
Criterios para elegir la forma de acceso:
¿El contenido es texto o binario?
¿Necesito leerlo entero o solo una parte?
¿Los registros tienen tamaño fijo o variable?
¿Qué codificación de caracteres debo usar?
Lectura de apoyo: qué es una codificación (W3C). Basta con los apartados que relacionan caracteres y bytes.
Para leer y ejecutar: el ejemplo de la ñ en
UTF-8 (Wikipedia). Comprueba las medidas
con Acceso.java
y acceso.py.
En Java, String.length() cuenta unidades UTF-16; no equivale siempre al
número de puntos de código. Cambia una letra por un emoji y observa la diferencia.
Texto |
Puntos de código Unicode |
Bytes en UTF-8 |
Unidades UTF-16 ( |
|---|---|---|---|
|
1 |
1 |
1 |
|
1 |
2 |
1 |
|
1 |
4 |
2 |
En estos tres ejemplos cada símbolo corresponde a un punto de código. No siempre ocurre así: un símbolo percibido como una unidad puede combinar varios puntos de código. Para calcular posiciones en un fichero importan los bytes de su representación, no la longitud visual del texto.
Vídeo de apoyo: caracteres, Unicode y UTF-8
Computerphile, Characters, Symbols and the Unicode Miracle, con Tom Scott (inglés). Distingue el número que identifica un carácter de los bytes que se usan para representarlo.
Pregunta para observar: ¿por qué una letra no tiene necesariamente el mismo tamaño en todas las codificaciones? Después comprueba la tabla con los ejemplos Java o Python; no necesitas memorizar las reglas binarias de UTF-8.
Actividad
Ejecuta Acceso o acceso.py y sustituye una letra por un emoji.
Predice caracteres y bytes. Localiza el salto al registro O03 y cambia
la posición para leer O02. ¿Serviría ese cálculo para nombres de longitud variable?
Comprobación razonada
cañón tiene cinco puntos de código y siete bytes en UTF-8. La
posición del cuarto registro (índice 3) de 16 bytes es 48 bytes.
En el flujo de registros de cuatro bytes, O02 empieza en el byte 4.
El acceso por posición necesita conocer
la representación: no basta contar las letras de un registro variable.
1.2.3. Leer y escribir con flujos¶
Para trabajar con un fichero hay que seguir un ciclo:
Abrir el flujo (indicando si es para leer o escribir)
Leer o escribir los datos
Cerrar el flujo para liberar los recursos
La lectura con flujos se hace de forma secuencial:
Se lee hasta llegar al fin de archivo (EOF, end of file)
Hay que distinguir un archivo vacío de uno truncado (cortado a medias)
La lectura puede hacerse línea a línea o carácter a carácter
La escritura tiene distintos modos:
Crear un fichero nuevo, reemplazar el contenido existente o rechazar la operación si ya existe: son opciones distintas
Anexar (append): se añade al final sin borrar lo anterior
Elegir mal el modo puede perder datos ya guardados
El cierre de recursos es obligatorio:
Un flujo abierto ocupa recursos del sistema
Si no se cierra, puede bloquear el archivo o agotar los recursos
Se garantiza con una construcción de gestión de recursos, como
withen Python o try-with-resources en Java
Comprobación de ida y vuelta:
Guardar un conjunto de datos y volver a leerlo debe dar el mismo resultado
Es la forma más sencilla de verificar que la escritura fue correcta
Hay que prestar atención a los caracteres no ASCII (acentos, ñ, …)
Para leer y ejecutar: lectura y escritura en Python y try-with-resources en Java. Compara Flujos.java y flujos.py; cambia anexado por reemplazo.
Vídeo de apoyo: leer, escribir y cerrar
Corey Schafer, File Objects (Python, inglés). Fíjate en los modos de
apertura y en with. Predice qué datos desaparecen al usar escritura
en lugar de anexado.
Actividad
Ejecuta Flujos o flujos.py. Cambia APPEND por
TRUNCATE_EXISTING en Java, o "a" por "w" en Python.
Predice qué nombres conservará el archivo. Localiza dónde se cierra la lectura.
Comprobación razonada
Con anexado aparecen los cuatro estudiantes; con reemplazo solo queda Estudiante D. El recurso se cierra al salir de su bloque. Leer un flujo vacío alcanza el fin inmediatamente; un documento truncado puede contener texto pero fallar al interpretarlo. Cerrar el flujo no valida su contenido.
1.2.4. Representar datos en CSV y JSON¶
CSV (valores separados por comas) es un formato tabular plano:
Cada registro es una fila; puede ocupar varias líneas físicas si un campo entrecomillado contiene saltos de línea
Los campos se separan por un delimitador (coma, punto y coma, …)
Los campos con delimitadores o saltos de línea se protegen con comillas; una comilla dentro de un campo se representa habitualmente duplicándola
Es sencillo, pero no representa jerarquías (todo es una tabla plana)
JSON (JavaScript Object Notation) es un formato jerárquico:
Objetos: conjunto de pares clave-valor entre llaves
{ }Arrays: listas ordenadas de valores entre corchetes
[ ]Tipos: texto, número, booleano, nulo, objeto y array
Permite anidar estructuras (una empresa con su lista de tutores)
Serializar y deserializar:
Serializar: convertir datos en memoria a una representación almacenable (texto o binario); deserializar reconstruye los datos
El parser reconoce la sintaxis; el binding vincula esos datos con objetos del lenguaje. No reconstruye automáticamente cualquier clase
Parsear (leer la sintaxis) no es lo mismo que validar (comprobar que los datos tienen sentido para el negocio)
Elección del formato:
CSV: datos tabulares simples, compatibles con hojas de cálculo
JSON: estructuras con relaciones y anidamiento
Ambos son texto plano y legibles por personas
Consulta los esquemas visuales de JSON: objeto, array y valor. Para CSV, fija siempre delimitador, comillas, codificación y presencia de cabecera; un
splitno sustituye a un parser.
Para leer y ejecutar: los ejemplos de CSV (Wikipedia) y los tipos de JSON (Wikipedia). Para las llamadas concretas, consulta csv de Python y Apache Commons CSV. Ejecuta Formatos.java o formatos.py y explica por qué el delimitador del nombre no produce otra columna.
Vídeos de apoyo: CSV y JSON
Corey Schafer (Python, inglés). En CSV observa cabecera y delimitador;
en JSON distingue load/dump de loads/dumps. Selecciona el
vídeo del formato que necesites reforzar.
Actividad
Ejecuta JsonObjetos.
Añade un tutor a muestra() y comprueba que se recupera desde el fichero.
Identifica los cuatro pasos: objeto, texto JSON, archivo y objeto recuperado.
¿Por qué pueden tener los mismos valores sin ser la misma instancia?
Comprobación razonada
Jackson serializa con writeValueAsString y reconstruye el tipo indicado
con readValue(texto, Empresa.class). Los record del ejemplo comparan
sus valores con equals; == compara identidad. El binding necesita
conocer la estructura; no comprueba por sí solo las reglas FCT.
Escribir un CSV exige acordar columnas, delimitador y codificación. La biblioteca se ocupa de comillas y escapes; la aplicación decide qué valores colocar en cada columna. Un registro puede ocupar varias líneas físicas.
Actividad
Ejecuta CsvEscritura.
Añade un registro con un nombre que contenga ;, comillas y un salto de línea.
Compara el texto del fichero con los valores recuperados por el lector.
Comprobación razonada
CSVPrinter.printRecord escribe un registro y protege sus campos.
El lector recupera los valores originales. Contar líneas o usar split
no permite interpretar correctamente este caso.
1.2.5. Transformar datos y reconocer pérdidas¶
Para convertir entre formatos se usa un modelo intermedio:
Se lee el formato de origen y se construye un objeto en memoria
Ese objeto se escribe en el formato de destino
El objeto actúa como puente entre los dos formatos
La conversión puede perder información:
Al aplanar una jerarquía se cambia la estructura; los datos pueden conservarse mediante varias tablas CSV e identificadores relacionados
Algunos tipos no tienen equivalente en el formato de destino
Hay que declarar qué se pierde y decidir si es aceptable
Una conversión reproducible:
Dado el mismo origen, produce siempre el mismo destino
Se puede verificar comparando los campos y valores conservados
Cambiar la extensión de un archivo no es convertirlo
El mismo dato, varias representaciones. Esta empresa tiene dos tutores. Compara qué puedes reconstruir con cada representación:
{
"id": "E01",
"nombre": "Empresa A",
"tutores": [
{"id": "T01", "nombre": "Tutor A"},
{"id": "T02", "nombre": "Tutor B"}
]
}
El array conserva los tutores dentro de la empresa.
empresas.csv:
id;nombre
E01;Empresa A
tutores.csv:
id;nombre;empresa_id;orden
T01;Tutor A;E01;0
T02;Tutor B;E01;1
empresa_id permite reconstruir la relación; orden conserva la
posición en la lista. Hay que acordar cómo interpretar ambos archivos.
Una empresa sin tutores aparece solo en empresas.csv.
id;nombre
E01;Empresa A
Es una proyección: conserva la empresa, pero omite sus tutores. No permite reconstruir el dato original completo. La pérdida procede de seleccionar menos información, no de una imposibilidad de relacionar CSV.
La comparación conserva los datos del modelo mostrado, no cualquier detalle textual de los documentos. Es un ejemplo conceptual: no añade otro entregable ni cambia el CSV de asignaciones definido en la práctica FCT.
Otro formato que encontraremos: XML también es texto estructurado, mediante
etiquetas y atributos, por ejemplo <empresa id="E01">Empresa A</empresa>.
Su lectura, escritura y tratamiento se desarrollarán en la última unidad.
Actividad
Ejecuta Conversion.java o conversion.py. Añade un tutor al origen y predice si cambia el CSV de resumen. Identifica el modelo intermedio y explica qué necesitarías exportar para recuperar también los tutores.
Comprobación razonada
El modelo intermedio es la empresa recuperada. El resumen solo selecciona
ID y nombre: añadir tutores no cambia sus columnas. Para conservarlos
podríamos usar otra tabla relacionada por empresa_id y guardar su orden.
Cambiar una extensión no realiza ninguna de estas operaciones.
1.2.6. Validación y recuperación ante errores¶
Los errores al trabajar con ficheros pueden ser de varios tipos:
De acceso: el archivo no existe o no hay permisos
De sintaxis: el contenido no respeta el formato esperado
De datos: los valores no son válidos para el negocio
Ante un error hay dos estrategias:
Propagar el error: dejar que lo trate una capa superior
Tratar el error: capturarlo y decidir cómo recuperarse
Cada capa debe decidir qué errores le corresponden
La liberación de recursos debe garantizarse siempre:
Tanto si la operación tiene éxito como si falla
El bloque finally o try-with-resources lo aseguran
Un error a mitad de escritura puede dejar el archivo a medias
La escritura segura evita perder datos:
Validar los datos y serializarlos antes de escribir
Escribir en un archivo temporal y cerrarlo antes de reemplazar el destino mediante una operación atómica cuando el sistema de archivos la soporte
El temporal debe estar en el mismo sistema de archivos. Esto evita ver un fichero a medias, pero no equivale a transacciones entre varios ficheros
Distinguir los tres resultados posibles:
Éxito: la operación se completó
Fracaso: la operación no se realizó
Operación incompleta: se realizó a medias (el caso más peligroso)
En la práctica FCT, la validación comprueba el estado antes de serializarlo; no se relee el temporal para validarlo. El recorrido es este:
Validar el estado en memoria.
Serializar los datos válidos.
Escribir y cerrar un temporal junto al destino.
Reemplazar el destino atómicamente.
Notificar el guardado correcto.
Se limpia el temporal y se comunica el error. Se conserva el fichero anterior y no se emite una notificación de éxito. El destino no se sustituye por datos a medias.
La segunda tarjeta destaca el fallo controlado previo al reemplazo. Si la serialización falla, tampoco se modifica el destino. Si el sistema no soporta el movimiento atómico, la implementación propaga el error, sin sustituirlo silenciosamente por una escritura directa. No se prometen transacciones entre varios ficheros ni recuperación ante cualquier caída o corte de alimentación.
Para leer y ejecutar: excepciones en Python y las condiciones de Files.move en Java. Ejecuta Errores.java y errores.py; explica por qué el contenido anterior sigue disponible tras el fallo.
Vídeo de apoyo: tratar excepciones
Corey Schafer, Try/Except Blocks (Python, inglés). Localiza qué excepciones
se capturan y para qué sirve finally. El ejemplo del repositorio añade
la comprobación del estado del fichero, no solo un mensaje de error.
Actividad
Ejecuta Errores o errores.py. Predice qué contenido conserva el archivo
tras el fallo controlado. Desactiva solo ese fallo y repite.
Clasifica además fichero inexistente, JSON truncado y fecha final anterior
a la inicial como errores de acceso, sintaxis o datos.
Comprobación razonada
Con fallo permanece anterior; con éxito se escribe nuevo.
Ausencia es acceso; truncado, sintaxis; fechas incoherentes, datos.
finally limpia el temporal; no deshace automáticamente bytes ya escritos.
1.2.7. Un componente de persistencia¶
Un componente es una pieza de software reutilizable e independiente:
Ofrece una funcionalidad concreta (en nuestro caso, guardar y recuperar datos)
Se puede usar desde distintas partes de la aplicación
Oculta los detalles de su implementación interna
El contrato (interfaz) define qué hace el componente:
Las operaciones que ofrece (guardar, listar, buscar, eliminar)
Es independiente de cómo se implementan
Permite sustituir una implementación por otra sin tocar el resto
La implementación es la clase concreta que cumple el contrato:
En esta unidad, guarda los datos en ficheros
En unidades posteriores, los guardará en bases de datos
El resto de la aplicación no necesita saberlo
Las propiedades configuran el componente:
Por ejemplo, la ruta donde se guardan los datos o el formato usado
Se establecen al crear el componente o mediante métodos de configuración
Los eventos permiten notificar cambios:
El componente avisa cuando ocurre algo relevante (p. ej. datos guardados)
Otras partes de la aplicación pueden reaccionar a ese aviso
Un evento no es una excepción: informa, no interrumpe
Esa es su finalidad, no una garantía del lenguaje: el código que recibe una notificación también podría lanzar una excepción. En la práctica FCT, el notificador debe terminar sin lanzarla. Como se ejecuta después de guardar, un fallo suyo no desharía el almacenamiento ya realizado.
Herramientas de desarrollo del componente:
Editor/IDE para escribir y depurar; compilador o intérprete para ejecutar
Bibliotecas de formatos para parsear y serializar sin crear analizadores propios
Pruebas para comprobar el contrato y herramienta de empaquetado para distribuirlo
Control de versiones para conservar cambios; las herramientas concretas se preparan en el entorno de la práctica amplia
Para leer y ejecutar: interfaz en programación (Wikipedia). Compara Componente.java y componente.py: ambos usan una implementación en memoria para estudiar el contrato antes de persistir en disco.
En la práctica FCT se separan dos responsabilidades. ServicioFct ofrece
las operaciones sobre empresas, estudiantes y asignaciones; el contrato
AlmacenFct solo define guardar(Estado) y recuperar().
RepositorioJson implementa ese contrato. Por tanto, no tienes que añadir
buscar o eliminar a AlmacenFct para reproducir el pequeño ejemplo
de esta clase: el servicio resuelve esas operaciones usando el almacén.
Actividad
Ejecuta Componente o componente.py y busca un identificador ausente.
Después abre AlmacenFct
y ServicioFct.
¿Quién filtra estudiantes y quién guarda el estado? Localiza la ruta configurable
y el aviso de éxito en el laboratorio.
Comprobación razonada
La búsqueda ausente devuelve Optional.empty() en Java o None en Python.
Un fallo de acceso es otra situación. En FCT, el servicio filtra estudiantes;
el almacén guarda y recupera estados. La ruta configura dónde persiste y
la notificación solo se emite después de guardar correctamente.
1.2.8. Probar y documentar la persistencia¶
Las pruebas verifican que el componente funciona:
Casos normales: la operación habitual con datos válidos
Casos límite: archivo vacío, un solo registro, muchos registros
Casos de error: archivo inexistente, sin permisos, datos inválidos
Las pruebas deben aislar sus datos (usar directorios temporales)
Una prueba debe ser reproducible:
Define el resultado esperado antes de ejecutarla
Cualquier persona puede ejecutarla y obtener el mismo resultado
Una prueba que no comprueba nada no sirve
La documentación hace el componente utilizable:
Describe el contrato (qué operaciones ofrece)
Explica la configuración (qué propiedades hay que establecer)
Documenta los errores que puede lanzar
Incluye un ejemplo de uso mínimo
El empaquetado permite distribuir el componente:
Se distribuye un módulo o paquete (p. ej. un JAR) y se declaran sus dependencias; no todos los paquetes contienen esas dependencias dentro
Otro proyecto puede incluirlo y usarlo sin ver su código interno
Sin datos no significa sin fichero. En el contrato de la práctica FCT, estas situaciones tienen resultados diferentes:
Situación |
Resultado esperado |
|---|---|
Fichero inexistente |
Error de acceso; no se inventa un estado vacío. |
Fichero de cero bytes |
Error de lectura del documento JSON: no contiene un valor JSON válido. |
JSON mal formado, por ejemplo |
Error de sintaxis; no se devuelve una colección vacía como éxito. |
Estado vacío válido, guardado con |
Recuperación correcta de un estado sin entidades. |
Un JSON sintácticamente correcto tampoco garantiza un estado válido: debe
cumplir la estructura esperada y las reglas del dominio. {}, por ejemplo,
no sustituye al estado vacío definido por el contrato.
Para leer y ejecutar: prueba unitaria (Wikipedia) y JUnit, guía de usuario. Ejecuta las pruebas de formatos y las pruebas de flujos y reemplazo siguiendo la guía. Las primeras releen JSON y CSV; las segundas comprueban texto y escritura segura. Para unir las ideas, abre el laboratorio de empresas, con recorrido Java y alternativa Python.
Vídeo de apoyo: una prueba con expectativa
Corey Schafer, Unit Testing (Python, inglés). Observa cómo una expectativa incorrecta provoca un fallo. Después distingue una igualdad en memoria de nuestra relectura desde disco.
Actividad
En FormatosTest, cambia la expectativa de igualdad de valores JSON por
identidad (assertSame). Ejecuta, interpreta el fallo y restaura la prueba.
Ejecuta después el laboratorio. Anota un resultado normal y uno de error,
con el comando para repetirlos. ¿Qué archivo demuestra que se leyó desde disco?
Comprobación razonada
La deserialización crea otra instancia, aunque sus valores coincidan.
El laboratorio recupera empresas.json con un componente nuevo y
conserva sus bytes ante el fallo controlado. La documentación debe permitir
repetirlo: comando, ruta, resultado esperado y resultado observado.
Test de autoevaluación
Realiza el test interactivo de autoevaluación. Es repetible y no tiene calificación.
Actividad final integradora
Aplica lo aprendido en la práctica de persistencia en ficheros del caso FCT.