BotonMenu
BotonIndice

Visita : http://www.conoce3000.com
Paypal : https://www.paypal.me/conoce3000/1

PASCAL CON FREE PASCAL

PASCAL CON FREE PASCAL

PASCAL CON FREE PASCAL


9. ARCHIVOS.
9.3. ARCHIVOS DE TEXTO. (RUTINAS TRADICIONALES O ESTÁNDAR)
9. ARCHIVOS.
9.3. ARCHIVOS DE TEXTO. (RUTINAS TRADICIONALES O ESTÁNDAR)
9. ARCHIVOS.
9.3. ARCHIVOS DE TEXTO. (RUTINAS TRADICIONALES O ESTÁNDAR)

SIGUIENTE

SIGUIENTE

SIGUIENTE


‒ Archivos de texto. (Rutinas tradicionales o estándar)

Los archivos de texto son archivos que codifican sus bytes o contenidos con una determinada codificación de caracteres, siendo los más usados: ASCII, UTF8 y UTF16. El acceso a los archivos de texto son siempre secuenciales, sin considerar el dispositivo al que este asociado. [P]El compilador nos ofrece una serie de rutinas para trabajar con archivos de texto, la más importante es assign, este procedimiento nos permite asociar el nombre del archivo con un determinado flujo, después se debe usar la rutina reset, si queremos abrir el archivo sólo para lectura o rewrite para abrir el archivo para escritura borrando todo el contenido, si el archivo no existe la rutina rewrite lo creará.

El procedimiento assign usa dos parámetros el primero es una variable de tipo text, que se usará después con las rutinas reset y rewrite, u otras que así lo requieran, el segundo parámetro es el nombre del archivo, que en este caso será el nombre del archivo en disco. Assign nos permite sólo usar nombres de archivos en ASCCII o una de sus variantes ANSI, sólo en los sistemas operativos Windows, en los sistemas operativos Linux nos permite usar nombres de archivos en UTF8.

En el caso de sistemas operativos Windows, si se usa un nombre de archivo como: 手紙-01.txt (Carta-01.txt), el compilador lo compilará y no mostrará ninguna advertencia, el problema sucederá cuando se ejecute el programa y el administrador de caracteres convierta el nombre del archivo en algo como esto: ??-01.txt, reemplazando por signos de interrogación los caracteres no permitidos, y en los sistemas operativos Windows el signo de interrogación no se puede usar en el nombre de un archivo, ocasionando que el programa falle cuando intente acceder al archivo.

El nombre de un archivo puede incluir referencias a una subcarpeta, como por ejemplo: demo/demo.txt, que nos indica que el archivo se encuentra en la carpeta demo y que el nombre del archivo es demo.txt. No obstante, el hecho de poder incluir referencias a una subcarpeta en el nombre del archivo, no significa que la carpeta se creara cuando esta no exista.

El siguiente ejemplo nos muestra cómo crear un archivo de texto en UTF8, este usa unas directivas de compilación que pasare a explicar más adelante. Ejemplo:


Descargar
{$codepage utf8}

{$ifdef win32}
  Uses sysutils;
{$endif}
{$ifdef Unix}
  Uses sysutils,cwstring; 
{$endif}

Var Arch:text;
    NombreArch:Unicodestring;
    BOM:String[3];
    CadU:Unicodestring;
 
Begin

   NombreArch:='demo/Carta-01.txt';  

  {$ifdef Unix}   
   NombreArch:='demo/手紙-01.txt';  
  {$endif}   
  NombreArch:=SetDirSeparators(NombreArch);  
                                             
  BOM:=#$EF+#$BB+#$BF;   
  Assign(Arch,NombreArch);
  rewrite(Arch);
  Write(Arch,BOM);
  cadU:='ようこそ';  
  Writeln(Arch,utf8encode(cadU)); //Utf8encode no es necesario en Linux
  cadU:='환영';  
  Writeln(Arch,utf8encode(cadU)); //Utf8encode no es necesario en Linux
  cadU:='歡迎';  
  Writeln(Arch,utf8encode(cadU)); //Utf8encode no es necesario en Linux
  cadU:='добро пожаловать';  
  Writeln(Arch,utf8encode(cadU)); //Utf8encode no es necesario en Linux
  cadU:='Bienvenido';  
  Writeln(Arch,utf8encode(cadU)); //Utf8encode no es necesario en Linux
  close(Arch)
End.
Código fuente 4: Ejemplo de rewrite y archivo de texto UTF8.
Descargar

Las directivas de compilación {$ifdef win32}{$endif} y {$ifdef Unix}{$endif}, son directivas condicionales que le indican al compilador que parte del código fuente se compilará en determinada situación, la situación se especifica con las etiquetas win32 y Unix, que le indican al compilador lo siguiente: si el código fuente se compila en Windows se debe usar la unidad sysutils, pero si el código fuente se compila en Linux o Unix se deben usar las unidades sysutils y cwstring. La directiva {$ifdef Unix}{$endif}, se vuelve a usar más adelante en el programa para indicarle al compilador que compile la sentencia NombreArch:='手紙-01.txt', que nos permite usar el nombre de archivos Carta-01 escrito en japonés.

Para que el programa funcione adecuadamente la carpeta demo debe estar creada antes de ejecutar el programa en el mismo lugar en donde se encuentra el programa.

La función SetDirSeparators se encarga de remplazar los separadores de directorios, por el que se use actualmente en el sistema operativo en donde se compila el programa, es decir la línea de división /, es cambiada por la línea de división invertida \, si el programa se ejecuta en Linux.

Todo archivo de texto en UTF8, debe tener una marca de verificación que se conoce como BOM (Byte of Mark), que son la secuencia de caracteres #$EF, #$BB y #$BF. Para el BOM en este programa se usa un string de 3 caracteres.

Tal como se explico anteriormente, la función assign crea el flujo o nexo con el archivo, y la función rewrite crea o sobrescribe el archivo, pero para escribir dentro del archivo de texto o colocar contenido dentro del archivo de texto se usan las rutinas ya conocidas write y writeln.

Lo primero que se hace es colocar el BOM, para ello se usa la rutina write, colocando como primer parámetro la variable Arch, que se usa como nexo entre el archivo de texto. Al colocar en el archivo de texto el BOM, se usa write para no colocar un salto de línea. Lo que viene a continuación es colocar en el archivo la frase: ようこそ que significa Bienvenido en japonés, para ello se hace usando la rutina writeln, pero con la ayuda de la función utf8encode, que se encarga de expandir o convertir una cadena de caracteres en UTF16 a UTF8, recuerde que UnicodeString usa UTF16, pero sólo considera los caracteres BMP. El uso de utf8encode en Linux no es necesario ya que el administrador de caracteres se encargará de dicha tarea, pero en Windows si lo es ya que el administrador de caracteres lo convertirá al juego de caracteres que use el sistema operativo actualmente. Al final el programa cierra el archivo con el procedimiento close, el cerrar el archivo permitirá que el archivo esté disponible para ser usado por otro programa.

Para la lectura de un archivo de texto en UTF8, usaremos las siguientes rutinas: FileExists, reset y EOF. La primera es una función que nos permitirá saber si el archivo existe, reset nos permite abrir el archivo para su lectura, la función EOF es una función que nos devolverá el valor true cuando después de hacer varias lecturas se haya llegado al final del archivo, EOF significa "End Of File".

Para la lectura se usa el procedimiento readln, este nos permitirá leer del archivo una secuencia de caracteres hasta encontrar los caracteres que indican el final de línea de la secuencia de caracteres que se está leyendo. Ejemplo :


Descargar
{$codepage utf8}

{$ifdef win32}
  Uses sysutils;
{$endif}
{$ifdef Unix}
  Uses sysutils,cwstring; 
{$endif}

Var Arch:text;
    NombreArch:Unicodestring;
    BOM:String[3];
    CadU:Unicodestring;
    CadUtf8:Ansistring;
Begin

   NombreArch:='demo/Carta-01.txt';  

  {$ifdef Unix}   
   NombreArch:='demo/手紙-01.txt';  
  {$endif}   
  NombreArch:=SetDirSeparators(NombreArch);  
  

  if FileExists(NombreArch) then
   Begin
     Assign(Arch,NombreArch);
     reset(Arch);
     Read(Arch,BOM);
     if (BOM=#$EF+#$BB+#$BF) then
       Begin
         While Not(EOF(Arch)) do
           Begin
             Readln(Arch,CadUtf8);
             CadU:=utf8decode(cadUtf8);
             Writeln(CadU)
           End;
       End;
     close(Arch)
   End;

End.
Código fuente 5: Ejemplo de reset y archivo de texto utf8.
Descargar

El programa anterior de ejemplo, tiene una serie de comprobaciones, primero verifica si el archivo existe con la función FileExist. Esta función sólo necesita el nombre del archivo y no es necesario crear un nexo o flujo con el procedimiento assign.

Si el archivo existe entonces usa reset para abrir el archivo y poder hacer lecturas con read o readln, la primera lectura que se hace al archivo es con read y se lee sólo los tres primeros caracteres, que es la longitud que tiene la variable BOM, read sólo lee los caracteres hasta llenar la variable que se usa para su lectura, a diferencia de readln, que lee los caracteres hasta encontrar la marca de fin de línea.

Luego se entra en un bucle While, que hará lecturas sucesivas hasta llegar al final del archivo, esto se logra con la función EOF, que constantemente se usará en el bucle para verificar si se llego al final del archivo. La función EOF siempre devolverá falso si no se llego al final del archivo, y esa es la razón por la que negamos el resultado de la función EOF, ya que el bucle while necesita de un valor verdadero para iterar o ejecutar el bucle.

La lectura de cada línea del archivo UTF8, se almacena en la variable Cadutf8 de tipo ansistring, esto es debido a que read y readln no se pueden usar con Unicodestring, después se asigna a la variable CadU de tipo Unicodestring pero usando la función utf8encode. La función utf8encode hace el proceso contrario a utf8decode, convierte una secuencia de caracteres en UTF8 a UTF16 (sólo BMP).

Dentro del bucle se usa Writeln, para mostrar el contenido de CadU por consola, obviamente en Windows se mostrarán algunos signos de interrogación. Si decide usar otro interprete de comandos que no sea el que viene con Windows por defecto, como por ejemplo Windows Power Shell, entonces la instrucción Writeln(CadU), se puede reemplazar por Writeln(utf8encode(CadU)), para poder mostrar los caracteres en utf8. Si no usamos la función utf8encode el administrador de caracteres usará el código de páginas regional que use Windows y no el código de páginas que use el intérprete de comandos que esté usando.

Reset abre un archivo de texto sólo para su lectura desde el inicio del mismo y rewrite abre un archivo de texto para su escritura, borrando todo su contenido; pero si necesitamos abrir un archivo de texto para añadirle más líneas de texto al final debemos usar el procedimiento Append. Este procedimiento prepara el archivo de texto para poder añadirle más líneas de texto al final. Ejemplo:


Descargar
{$codepage utf8}

{$ifdef win32}
  Uses sysutils;
{$endif}
{$ifdef Unix}
  Uses sysutils,cwstring; 
{$endif}

Var Arch:text;
    NombreArch:Unicodestring;
    BOM:String[3];
    CadU:Unicodestring;
    CadUtf8:Ansistring;
Begin

  NombreArch:='demo/Carta-01.txt';  

  {$ifdef Unix}   
   NombreArch:='demo/手紙-01.txt';  
  {$endif}   
  NombreArch:=SetDirSeparators(NombreArch);
  

  if FileExists(NombreArch) then
   Begin
     Assign(Arch,NombreArch);
     append(Arch); 
     CadU:='Última línea';
     Writeln(Arch,utf8encode(cadU)); 
     reset(Arch);
     Read(Arch,BOM);
     if (BOM=#$EF+#$BB+#$BF) then
       Begin
         While Not(EOF(Arch)) do
           Begin
             Readln(Arch,CadUtf8);
             CadU:=utf8decode(cadUtf8);
             Writeln(utf8encode(CadU))
           End;
       End;
     close(Arch)
   End;
End.
Código fuente 6: Ejemplo de append y archivo de texto utf8.
Descargar

Los archivos de texto usan unos caracteres para indicar el final de una línea, y estos difieren en cada sistema operativo que se esté usando. Es decir en Windows se usan los caracteres #$0D y #$0A y en Linux sólo el caracter #$0A. Si es necesario saber o usar un determinado final de línea, entonces se puede usar la constante LineEnding, que contiene los caracteres correctos cada vez que se compila un programa en determinado sistema operativo.

Muchas veces es necesario juntar todas las líneas de texto que se lean de un archivo en una sola variable, pero readln sólo hace una lectura de los caracteres de la línea ignorando los caracteres de fin de línea es decir el siguiente código:

While Not(EOF(Archtxt1)) do
  Begin
    Readln(Archtxt,cad1);
    cad2:=cad2+cad1
  End;
Write(Archtxt2,cad2);

Hará una lectura de todas las líneas del archivo de texto concatenándolas en cad2, pero sin los caracteres de fin de línea que se pueda encontrar, lo que significa que cuando se ejecute la instrucción Write(Archtxt2,cad2), este grabará todo el texto sin saltos de línea. El código más adecuado si es que queremos usar los caracteres de fin de línea sería el siguiente:

While Not(EOF(Archtxt1)) do
  Begin
    Readln(Archtxt,cad1);
    cad2:=cad2+cad1+LineEnding
  End;
Write(Archtxt2,cad2);



SIGUIENTE
SIGUIENTE
SIGUIENTE



 
‒ Comentarios y sugerencias.

Agradezco de antemano, todo comentario, sugerencia, y donativo (a través de Paypal me), que ayude a mejorar los contenidos educativos de Conoce 3000. Además, cualquier pregunta o duda que tengas lo puedes hacer por este medio. Pero, todo contenido que pueda resultar ofensivo, malicioso, racista, sexista, discriminatorio, obsceno, vulgar será eliminado.


Comments System WIDGET PACK






PORTADA |  INTERESANTE |  APUNTES |  LIBROS |  GALERIA


Creative Commons License


Todos los textos, imágenes y videos de Conoce3000 estan colocados bajo una licencia : Creative Commons Reconocimiento-NoComercial 3.0 Unported License.