Trabajando con archivos de texto y binarios (I)

Voy a mostrar a continuacin las distintas maneras que tenemos para crear, editar o
eliminar archivos de texto o binarios. Tambin aprenderemos a movermos por los
directorios y por dentro de los archivos obteniendo la informacin del sistema cuando sea
necesario.

CREANDO UN ARCHIVO DE TEXTO

Los pasos para crear un archivo son los siguientes:

1 Se crea una variable de tipo TextFile, la cual es un puntero a un archivo de texto.

2 Se utiliza la funcin AssignFile para asignar el puntero F al archivo de texto.

3 A continuacin abrimos el archivo en modo escritura mediante el procedimiento

Rewrite.

4 Escrimimos en el archivo mediante la funcin WriteLn.

5 Cerramos el archivo creado con el procedimiento CloseFile.

Vamos a crear un procedimiento para crear el archivo prueba.txt al lado de nuestro

programa:

procedure TFormulario.CrearArchivoTexto;
var
F: TextFile;
begin
AssignFile( F, ExtractFilePath( Application.ExeName ) + 'prueba.txt' );
Rewrite( F );
WriteLn( F, 'Esto es el contenido del archivo de texto.' );
CloseFile( F );
end;

MODIFICANDO UN ARCHIVO DE TEXTO

Cuando se utiliza la funcin Rewrite no comprueba si el archivo ya exista anteriormente,

lo que puede provocar que elimine la informacin anterior. Para prevenir esto lo que
hacemos es preguntar si ya existe el archivo y si es as entonces aadimos al contenido del
archivo mediante el procedimiento Append:

procedure TFormulario.AnadirArchivoTexto;
var
 F: TextFile;
sArchivo: string;
begin
sArchivo := ExtractFilePath( Application.ExeName ) + 'prueba.txt';
AssignFile( F, sArchivo );

if FileExists( sArchivo ) then

Append( F )
else
Rewrite( F );

WriteLn( F, 'Aadiendo informacin al archivo de texto.' );

CloseFile( F );
end;

ABRIENDO UN ARCHIVO DE TEXTO

Vamos a abrir el archivo de texto en modo lectura para volcar su contenido en un campo
memo del formulario. Para ello abrimos el archivo con el procedimiento Reset y leemos
cada lnea de texto mediante ReadLn:

procedure TFormulario.CargarArchivoTexto;
var F: TextFile;
sLinea: String;
begin
AssignFile( F, ExtractFilePath( Application.ExeName ) + 'prueba.txt' );
Reset( F );

while not Eof( F ) do

begin
ReadLn( F, sLinea );
Memo.Lines.Add( sLinea );
end;

CloseFile( F );
end;

El procedimiento ReadLn obliga a leer la lnea de texto dentro de una variable. Despus
incrementa automticamente el puntero F hasta la siguiente lnea de texto, siendo la
funcin Eof la que nos dice si ha llegado al final del archivo. Aunque en este caso lo ms
fcil sera utilizar la propiedad LoadFromFile del objeto memo:

Memo.Lines.LoadFromFile( ExtractFilePath( Application.ExeName ) + 'prueba.txt' );

ELIMINANDO UN ARCHIVO
La eliminacin de un archivo se hace con la funcin DeleteFile la cual est dentro de la
unidad SysUtils:

procedure TFormulario.EliminarArchivoTexto;
var sArchivo: String;
begin
sArchivo := ExtractFilePath( Application.ExeName ) + 'prueba.txt';
if FileExists( sArchivo ) then
DeleteFile( sArchivo );
end;

Todas estas funciones (Rewrite, Append, etc.) vienen del lenguaje estndar de Pascal, ya
que en Delphi hay maneras mucho ms sencillas de realizar estas tareas, como veremos
ms adelante.

Trabajando con archivos de texto y binarios (II)

Vamos a ver otra manera de manejar ficheros de texto utilizando algunas clases que lleva
Delphi para hacer nuestra labor mucho ms fcil.

Para ello utilizaremos la clase TFileStream que hereda de la clase TStream para manejar
flujos de datos, en este caso archivos. Una de las ventanas de utilizar FileStream en vez
de los clsicos mtodos de pascal tales como Rewrite, WriteLn, etc. es que controla
automticamente los buffer en disco segn el tamao de los mismos en Windows.

CREANDO UN ARCHIVO DE TEXTO USANDO LA CLASE TFILESTREAM

La clase TFileStream proporciona un mtodo rpido y flexible para el manejo de

archivos. Veamos como crear un archivo detexto:

procedure TFormulario.CrearArchivoStream;
var
F: TFileStream;
s: String;
begin
F := TFileStream.Create( ExtractFilePath( Application.ExeName ) + 'prueba.txt', fmCreate );
s := 'Aadiendo informacin al archivo de texto.' + #13 + #10;
F.Write( s[1], Length( s ) );
F.Free;
end;

El constructor Create de la clase TFileStream toma como primer parmetro la ruta del
archivo y como segundo parmetro el tipo de acceso. Los tipos de acceso son:
fmCreate -> Crea un nuevo archivo. Si el archivo ya existe lo sobrescribe.
fmOpenRead -> Abre el archivo en modo de solo lectura.
fmOpenWrite -> Abre el archivo en modo de escritura.
fmOpenReadWrite -> Abre el archivo en modo lectura/escritura.

Despus se graba la informacin mediante el mtodo Write el cual lee el contenido de un

buffer (puede ser texto o binario) pasando como segundo parmetro su longitud (Length).
Finalmente liberamos la clase con Free y el mismo objeto cierra automticamente el
archivo.

Le hemos pasado como primer parmetro s[1] porque es la direccin de memoria donde
comienza la variable s (los string empiezan por 1). Al final de la cadena le hemos metido
cambin los caracteres de retorno de carro para que pase a la siguiente lnea, ya que un
objeto FileStream lo trata todo como texto continuo.

Cuando la cantidad de informacin a mover es muy grande, ste metodo es mucho ms

rpido que utilizar el clasico Rewrite, WriteLn, etc. (a menos claro que creemos nuestro
buffer).

AADIENDO TEXTO A UN ARCHIVO CON FILESTREAM

Para aadir lneas a nuestro archivo creado anteriormente abrimos el archivo en modo
fmOpenWrite, nos vamos al final del archivo utilizando la propiedad Position y
aadimos el texto:

procedure TFPrincipal.AnadirArchivoStream;
var
F: TFileStream;
s: String;
begin
F := TFileStream.Create( ExtractFilePath( Application.ExeName ) + 'prueba.txt', fmOpenWrite
);
F.Position := F.Size;
s := 'Aadiendo informacin al archivo de texto.' + #13 + #10;
F.Write( s[1], Length( s ) );
F.Free;
end;

Si no se hubiese utilizado la propiedad Position habra machadado la informacin

introducida anteriormente. Podemos movernos a nuestro antojo con la propiedad Position
para guardar informacin en un fichero en cualquier sitio. Para irse al principio de un
archivo slo hay que hacer:
F.Position := 0;

LEYENDO LOS DATOS MEDIANTE FILESTREAM

El siguiente procedimiento lee el contenido del archivo en modo fmOpenRead en la

variable s que hace de buffer y posteriormente lo manda al memo:

procedure TFPrincipal.CargarArchivoStream;
var
F: TFileStream;
s: String;
begin
F := TFileStream.Create( ExtractFilePath( Application.ExeName ) + 'prueba.txt', fmOpenRead
);
SetLength( s, F.Size ); // *** Me faltaba esto, gracias por la correccin ***
F.Read( s[1], F.Size );
Memo.Text := s;
F.Free;
end;

Aunque en este caso no tenemos la flexibilidad que nos aportaban las funciones ReadLn
y WriteLn para archivos de texto.

BLOQUEANDO EL ARCHIVO A OTROS USUARIOS

Una de las cualidades de las que goza el objeto FileStream es la de bloquear el acceso a
otros usuarios mientras estamos trabajando con un archivo. La proteccin se realiza
cuando se abre el archivo. Por ejemplo, si queremos abrir el archivo en modo lectura
exclusivamente para nosotros hacemos:

F := TFileStream.Create( ExtractFilePath( Application.ExeName ) + 'prueba.txt', fmReadOnly or

fmShareExclusive );

Mediante el operador OR mezclamos las opciones de apertura con las opciones de

bloqueo. Las posibles opciones de bloqueo son:

fmShareCompat -> Permite compatibilizar la apertura con otro usuario o programa

fmShareExclusive -> Slo nosotros tenemos derecho acceso de lectura/escritura mientras este
abierto
fmShareDenyWrite -> Bloqueamos el archivo para que nadie pueda escribir salvo nosotros
fmShareDenyRead -> Bloqueamos el archivo para que nadie pueda leerlo salvo nosotros
fmShareDenyNone -> Permite la lectura/escritura por parte de otros usuarios.

Tambin se podran manipular archivos de texto facilmente mediante objetos TStringList

como vimos con anterioridad. Yo personalmente utilizo TStringList, objetos Memo o
RitchEdit ya que permiten una manipulacin del texto en memoria bastante flexible antes
de guardarla en disco.