00:00:00
Buenas tardes, compañeros e ingenieros.
00:00:03
Estaremos hablando sobre operaciones
00:00:05
básicas de archivos, creación y
00:00:06
apertura. Estamos integrados por seis
00:00:09
participantes en los que cada uno de
00:00:10
nosotros hablaremos sobre conceptos
00:00:13
fundamentales y una demostración del
00:00:14
programa en sí. Continuando con la
00:00:17
diapositiva, la interacción con los
00:00:20
archivos es fundamental en la mayoría de
00:00:21
los programas, ya que como muestra en
00:00:24
imagen inferior, es un ejemplo de un
00:00:26
código en Cchart que lee datos de un
00:00:29
archivo mediante un file stream, que es
00:00:31
la deserialización de un objeto o la
00:00:34
reconstrucción de un objeto, en donde
00:00:36
tiene lo que son varias líneas de
00:00:39
comando, en donde podemos ver que la
00:00:41
primera es crucial para interactuar con
00:00:43
el archivo, el segundo es la que se
00:00:45
encarga de hacer la reconstrucción del
00:00:47
objeto y luego seguimos con el console
00:00:50
prite que normalmente tienen vienen
00:00:53
acompañados de una propiedad o los
00:00:56
campos donde implica tener lo que es un
00:00:58
ID y un name que por completo serían dos
00:01:02
propiedades. Y el último que es el
00:01:04
console WID en donde hace que la ventana
00:01:06
de la consola se mantenga abierta hasta
00:01:08
que el usuario presione cualquier tecla,
00:01:10
permitiendo ver la salida de lo que
00:01:13
contiene el console WR antes de que la
00:01:15
ventana se cierre automáticamente.
00:01:17
Creación de un archivo nuevo. Si se
00:01:20
especifica la creación de un archivo y
00:01:22
este no existe, el sistema operativo lo
00:01:25
crea en la ubicación especificada.
00:01:27
Si el archivo ya existe y se especifica
00:01:30
de un modo de la creación que implica
00:01:33
sobrescribir el contenido existente, por
00:01:36
ejemplo, F mod Craft, el contenido
00:01:40
anterior del archivo se truncará, se
00:01:42
eliminará y el archivo estará vacío.
00:01:45
Listo para recibir nuevos datos. Es
00:01:48
crucial manejar las obserciones que
00:01:50
pueden sugerir, como la falta de
00:01:52
permisos de escritura o una ruta de
00:01:55
archivo inválida.
00:01:58
Apertura de un archivo existente. Si se
00:02:01
especifica la apertura de un archivo y
00:02:04
este existe, el sistema operativo
00:02:07
establece una conexión con él,
00:02:10
permitiendo al programa leer o escribir
00:02:13
datos según el modo de apertura. Si se
00:02:16
intenta abrir un archivo que no existe
00:02:19
con modo que requiere que el archivo
00:02:22
exista, por ejemplo, file mode open, se
00:02:26
generará una excepción file no font
00:02:29
exception.
00:02:31
Al igual que con la creación, es
00:02:34
importante considerar permisos de acceso
00:02:38
al estado del archivo. Por ejemplo, si
00:02:42
se está siendo utilizado por otros
00:02:44
procesos.
00:02:46
Hola, buenas compañeros y licenciados.
00:02:50
El día de hoy yo le voy a yo les voy a
00:02:52
hablar sobre los modos de apertura y su
00:02:54
impacto. El modo de apertura define el
00:02:58
propósito en el que accede el archivo y
00:03:01
las operaciones permitidas sobre él.
00:03:05
Este, cuando un programa necesita leer,
00:03:08
escribir o modificar un archivo,
00:03:12
eh, digamos que, por ejemplo, un
00:03:14
documento de texto, una o una base de
00:03:16
datos, es necesario abrir ese archivo.
00:03:20
Para eso se utiliza un modo de apertura,
00:03:23
el cual indica al sistema cómo debe
00:03:25
tratar al archivo, si solo debe leerlo o
00:03:29
escribir sobre él, agregar contenido al
00:03:32
final, etcétera.
00:03:34
Bueno, eh este concepto la verdad que es
00:03:37
fundamental en programación, ya que
00:03:39
permite controlar con precisión qué se
00:03:42
hace con los archivos evitando errores
00:03:45
como pérdida de información, bloqueos o
00:03:48
alguna corrupción de datos.
00:03:50
Algunos de los modos de apertura más
00:03:52
comunes eh son los modos de apertur de
00:03:55
lectura, perdón, modo de escritura, modo
00:03:58
de agregar, este, leer y escribir, modo
00:04:02
de escribir y leer y modo de agregar y
00:04:05
leer. Y pues algunas consideraciones
00:04:08
importantes que debemos tener en cuenta
00:04:10
al usar el modo de apertura sería que
00:04:14
nos evite una pérdida de información, eh
00:04:17
nos ayude a verificar la existencia de
00:04:19
algún archivo, a controlar el flujo de
00:04:21
datos o incluso a cerrar el archivo o el
00:04:25
uso de sus codificaciones.
00:04:27
E igual cuando una aplicación o un
00:04:30
sistema interactúa con archivos, cada
00:04:32
acción debe ser perfectamente definida.
00:04:35
Este, igual eh el modo de apertura
00:04:38
asegura que nuestro programa eh no vaya
00:04:41
a borrar datos por error o a causar
00:04:44
problemas de lectura o escritura.
00:04:47
Igual sepa exactamente cómo comportarse
00:04:50
con el archivo y mantener la integridad
00:04:54
y seguridad de nuestra información.
00:04:57
Y en conclusión, el modo de apertura es
00:04:59
una herramienta muy esencial que todo
00:05:02
programador debe dominar para trabajar
00:05:05
con archivos de forma segura, eficiente
00:05:07
y profesional.
00:05:09
Igual elegir el modo correcto. Este nos
00:05:12
permite controlar el flujo de nuestra
00:05:15
información, igual prevenir graves
00:05:18
errores y desarrollar aplicaciones
00:05:21
confiables.
00:05:24
Modo de apertura y su impacto. El modo
00:05:27
de apertura, lectura escritura, red es
00:05:30
uno de los más versátiles y utilizados
00:05:34
cuando se trabaja con archivo, ya que
00:05:36
permite tanto la lectura como la
00:05:38
escritura de datos en el mismo archivo.
00:05:41
Ahora, esto significa que un programa
00:05:43
puede consultar información existente y
00:05:46
al mismo tiempo modificarla o agregar
00:05:49
nueva sin necesidad de cerrar y volver a
00:05:51
abrir el archivo en un modo distinto. El
00:05:54
comportamiento de este modo está
00:05:56
condicionado por dos factores clave. El
00:05:58
file mod que determina si el archivo se
00:06:01
crea, se abre o se sobreescribe y el
00:06:04
file access point r que concede el
00:06:07
permiso de acceso tú. Si el archivo ya
00:06:10
existe, el puntero de acceso se
00:06:12
posiciona al inicio del archivo, lo cual
00:06:14
permite que el contenido pueda ser leído
00:06:16
desde el principio o incluso
00:06:19
sobreescrito
00:06:20
dependiendo de las instrucciones del
00:06:22
programa. Si el archivo no existe, no se
00:06:26
eh se crea uno, perdón, nuevo,
00:06:28
generalmente vacío en el puntero al
00:06:30
inicio. Este modo es especialmente útil
00:06:33
en tareas como la edición de archivos de
00:06:35
configuración, eh actualización de
00:06:38
registros y el mantenimiento de archivos
00:06:40
temporales o como también la
00:06:42
manipulación de base de datos simples
00:06:44
basadas en texto. Ahora, por el otro
00:06:47
lado, existen otros modos y opciones que
00:06:49
ofrecen un control más granular, como lo
00:06:52
que sería la penetada
00:06:55
exclusivamente
00:06:56
para operaciones de escritura y se
00:07:00
caracteriza por todo su capacidad para
00:07:02
preservar todo el contenido anterior del
00:07:04
archivo. Cuando se abre un archivo en
00:07:07
nudo append, el puntero de de escritura
00:07:10
se posiciona automáticamente al final
00:07:12
del archivo, lo que garantiza que
00:07:14
cualquier dato nuevo se agregará después
00:07:16
del contenido existente sin tener que
00:07:19
sobreescribir. En caso de que el archivo
00:07:21
no exista, se creará uno nuevo. Y este
00:07:24
comportamiento lo convierte en una
00:07:26
opción ideal para almacenar información
00:07:28
continua como registros de eventos,
00:07:31
archivos de Lord, bitácoras, historiales
00:07:33
de transacciones o cualquier archivo que
00:07:35
necesite crecimiento constante sin
00:07:39
pérdida de la información previa.
00:07:41
Además, al no requerir que el archivo se
00:07:43
lea o procese desde el inicio, el modo
00:07:46
pen ofrecer mejoras entrendimiento en
00:07:49
situaciones donde solo se necesite
00:07:51
añadir datos rápidamente.
00:07:54
En conjunto, los modos de apertura,
00:07:55
lectura, escritura, red, right y
00:07:58
appenetap son fundamentales para una
00:08:01
gestión eficaz de archivos en
00:08:03
aplicaciones que requieren manipulación
00:08:05
dinámica y persistentes en los datos.
00:08:09
En este caso vamos a pasar con lo que ya
00:08:11
es el código del programa que estamos
00:08:13
ejecutando. Eh, pues en resumido, este
00:08:16
es un ejemplo en el que es un archivo
00:08:20
solo para lectura y luego pues intenta
00:08:22
escribir en el mismo y esto es lo que
00:08:24
nos va a generar va a ser un error. Eh,
00:08:27
pues vamos a empezar de
00:08:29
rápido con lo que es la definición de
00:08:31
este ejemplo. En este caso, nosotros
00:08:35
aquí usamos lo que es el file multipar
00:08:38
el archivo example. Así lo denominamos.
00:08:42
Luego el file accesso
00:08:46
se puede escribir en el archivo
00:08:49
y el string writer se carga, que es este
00:08:53
de acá, se encarga de escribir el
00:08:55
contenido del archivo. El bloque using
00:08:58
eh pues asegura que el archivo se cierra
00:09:00
automáticamente evitando problemas de lo
00:09:02
que es el acceso. En este caso, pues si
00:09:05
nosotros ejecutáramos este programa
00:09:07
hasta acá, lo que dice esto es un
00:09:09
archivo de prueba, eh no mostraría nada
00:09:12
en la consola porque no se incluye una
00:09:14
instrucción para imprimir texto en lo
00:09:17
que es la consola, eh, porque el código
00:09:20
en este caso nosotros lo dividimos en
00:09:22
parco. Entonces, para que pudiera en
00:09:25
este ejemplo, por ejemplo, que que
00:09:28
mostrara un texto al momento de
00:09:30
compilar, pues agregamos una línea más
00:09:32
abajo que es console.
00:09:35
Que es archivo creado y contenido
00:09:37
escrito correctamente, que pues entonces
00:09:39
esto sí viaja a la consola.
00:09:41
Una vez que nosotros le damos en
00:09:43
copilar, pues en efecto el texto
00:09:45
mostrado sería archivo creado y
00:09:48
contenido escrito correctamente, que es
00:09:49
el que escribimos anteriormente. Si no
00:09:51
estuviera esa línea, pues simplemente no
00:09:54
esía nada más. Okay, ya en este apartado
00:09:57
pues es la lectura y error al interar eh
00:10:00
pues lo que es escribir. Entonces
00:10:02
creamos este código relevante desde lo
00:10:05
que es la parte en esta parte de acá es
00:10:07
donde se intenta abrir el archivo solo
00:10:09
para lectura y luego pues para escribir.
00:10:11
Ahí se usa F mod Mood Open para abrir el
00:10:15
el archivo que definimos anteriormente
00:10:18
que es el example de texto. Lo usamos el
00:10:21
file access para que este es como que el
00:10:25
principal del código, que este es para
00:10:27
permitir solo la lectura del código.
00:10:31
Entonces se lee este contenido con
00:10:33
screen reader,
00:10:35
pero luego se intenta escribir en el
00:10:37
archivo cuando nosotros utilizamos
00:10:40
string writer.
00:10:42
Lo que genera esto es que va a causar un
00:10:44
error porque nuestro archivo solo tiene
00:10:47
permisos para lecturas que fue los que
00:10:48
nosotros definimos acá arriba. Pues en
00:10:51
este caso se captura lo que es esta
00:10:54
excepción y se muestra el mensaje de
00:10:56
error. En este caso vamos a ejecutar
00:11:00
este apartado para que podamos definir
00:11:02
eso. Entonces, en efecto, ya acá pues
00:11:05
este primer texto no es tan relevante,
00:11:08
pero contenido el archivo. Este es un
00:11:10
archivo de prueba porque si lo definimos
00:11:12
y genera el error. Error al interar
00:11:14
escribir en un archivo abierto solo para
00:11:16
la lectura. Screenam.
00:11:21
que no está permitido para la para la
00:11:23
estructura en este caso.
00:11:26
Okay, con esta parte pues ya llegamos a
00:11:28
lo que es la parte final de este código
00:11:30
que nosotros realizamos. Pues en este
00:11:33
apartado vamos con el modo appent.
00:11:36
Espero que lo esté pronunciando bien. En
00:11:39
este caso se utiliza filemood
00:11:43
append
00:11:45
que es cuando abre el archivo y coloca
00:11:48
el cursor al final. Luego se utiliza
00:11:51
filea access.Rite, WR, que esto es lo
00:11:53
que permite pues la escritura que ya
00:11:55
también nosotros lo habíamos definido al
00:11:56
inicio. Y pues el string writer que
00:12:00
escribe al final del archivo sin borrar
00:12:02
lo que es el contenido anterior. En este
00:12:05
caso vamos a ejecutar nuevamente lo que
00:12:07
es eh nuestro programa ya completo
00:12:11
y pues esto nos va a mostrar
00:12:13
adicionales, que es un archivo de prueba
00:12:16
y texto adicional en modo aprendido.
00:12:21
Y esto es lo que es el contenido del
00:12:23
archivo.
00:12:25
Y pues esto sería más que todo lo que
00:12:27
nosotros realizamos en este código. Pues
00:12:29
como conceptos clave pues tenemos el uso
00:12:31
del using que se usa para manejar
00:12:33
automáticamente los recursos de firing
00:12:36
writer. Asegura lo que es el archivo que
00:12:39
se cierre correctamente porque por
00:12:41
ejemplo si yo le doy enter el archivo ya
00:12:42
se cierra y evita fugas de memoria, pues
00:12:45
haciendo al código más eficiente. En
00:12:47
este caso, pues nosotros usamos
00:12:49
diferentes modos como create, open,
00:12:51
appen y permisos como read y write. Se
00:12:54
probó la lectura de archivos y ¿qué
00:12:55
sucede cuando se intenta abrir eh
00:12:57
perdón, cuando se intenta escribir sin
00:12:59
permiso que ya validamos anteriormente
00:13:01
que no permitía? Se mostró cómo agregar
00:13:04
contenido al final sin perder
00:13:06
información existente y se aplicaron por
00:13:08
los que son buenas prácticas con using
00:13:10
para cerrar correctamente lo que son los
00:13:12
archivos.
00:13:17
Buenas noches, licenciados y compañeros.
00:13:20
Yo les voy a hablar sobre las
00:13:21
conclusiones de las operaciones básicas.
00:13:24
En resumen, las operaciones básicas de
00:13:26
archivos como la creación y apertura son
00:13:30
la base fundamental para la persistencia
00:13:32
de datos. En la programación hemos
00:13:36
explorado como lo Film
00:13:39
definen la intención de cómo
00:13:41
interactuamos con el archivo.
00:13:43
Simultáneamente los F
00:13:47
determinan los permisos que tenemos
00:13:49
sobre ese archivo, garantizando la
00:13:52
seguridad y la integridad de la
00:13:54
información.
00:13:56
Dominar estos conceptos es esencial para
00:13:59
cualquier desarrollador, ya que nos
00:14:02
permite construir aplicaciones que
00:14:04
puedan almacenar y recuperar datos de
00:14:07
forma eficiente, independientemente de
00:14:10
si estamos guardando configuraciones
00:14:13
simples o gestionando sistemas de
00:14:15
información complejos. La correcta
00:14:18
implementación de estas operaciones,
00:14:20
especialmente el uso del bloque USIM
00:14:24
para asegurar el cierre de los recursos
00:14:27
es crucial para la robustez y la
00:14:30
fiabilidad de nuestros programas. Muchas
00:14:32
gracias por su atención. M.
