Pascal - Manejo de archivos

Pascal trata un archivo como una secuencia de componentes, que deben ser de tipo uniforme. El tipo de archivo está determinado por el tipo de componentes. El tipo de datos de archivo se define como:

type
file-name = file of base-type;

Donde, el tipo base indica el tipo de los componentes del archivo. El tipo base podría ser cualquier cosa como, entero, real, booleano, enumerado, subrango, registro, matrices y conjuntos, excepto otro tipo de archivo. Las variables de un tipo de archivo se crean usando la declaración var -

var
f1, f2,...: file-name;

A continuación se muestran algunos ejemplos de cómo definir algunos tipos de archivos y variables de archivos:

type
   rfile = file of real;
   ifile = file of integer;
   bfile = file of boolean;
   datafile = file of record
   arrfile = file of array[1..4] of integer;

var
   marks: arrfile;
   studentdata: datafile;
   rainfalldata: rfile;
   tempdata: ifile;
   choices: bfile;

Crear y escribir en un archivo

Escribamos un programa que cree un archivo de datos para los registros de los estudiantes. Crearía un archivo llamado Students.dat y escribiría los datos de un estudiante en él.

program DataFiles;
type
   StudentRecord = Record
      s_name: String;
      s_addr: String;
      s_batchcode: String;
   end;

var
   Student: StudentRecord;
   f: file of StudentRecord;

begin
   Assign(f,'students.dat');
   Rewrite(f);
   Student.s_name := 'John Smith';
   Student.s_addr := 'United States of America';
   Student.s_batchcode := 'Computer Science';
   Write(f,Student);
   Close(f);
end.

Cuando se compila y ejecuta, el programa crea un archivo llamado Students.dat en el directorio de trabajo. Puede abrir el archivo con un editor de texto, como un bloc de notas, para ver los datos de John Smith.

Leer de un archivo

Acabamos de crear y escribir en un archivo llamado Students.dat. Ahora, escriba un programa que lea los datos del estudiante del archivo:

program DataFiles;
type
   StudentRecord = Record
      s_name: String;
      s_addr: String;
      s_batchcode: String;
   end;

var
   Student: StudentRecord;
   f: file of StudentRecord;

begin
   assign(f, 'students.dat');
   reset(f); 
   while not eof(f) do
   
   begin
      read(f,Student);
      writeln('Name: ',Student.s_name);
      writeln('Address: ',Student.s_addr);
      writeln('Batch Code: ', Student.s_batchcode);
   end;
   
   close(f);
end.

Cuando se compila y ejecuta el código anterior, produce el siguiente resultado:

Name: John Smith
Address: United States of America
Batch Code: Computer Science

Archivos como parámetro de subprograma

Pascal permite que las variables de archivo se utilicen como parámetros en subprogramas estándar y definidos por el usuario. El siguiente ejemplo ilustra este concepto. El programa crea un archivo llamado rain.txt y almacena algunos datos de lluvia. A continuación, abre el archivo, lee los datos y calcula la precipitación media.

Tenga en cuenta que, if you use a file parameter with subprograms, it must be declared as a var parameter.

program addFiledata;
const
   MAX = 4;
type
   raindata = file of real;

var
   rainfile: raindata;
   filename: string;
procedure writedata(var f: raindata);

var
   data: real;
   i: integer;

begin
   rewrite(f, sizeof(data));
   for i:=1 to MAX do
   
   begin
      writeln('Enter rainfall data: ');
      readln(data);
      write(f, data);
   end;
   
   close(f);
end;

procedure computeAverage(var x: raindata);
var
   d, sum: real;
   average: real;

begin
   reset(x);
   sum:= 0.0;
   while not eof(x) do
   
   begin
      read(x, d);
      sum := sum + d;
   end;
   
   average := sum/MAX;
   close(x);
   writeln('Average Rainfall: ', average:7:2);
end;

begin
   writeln('Enter the File Name: ');
   readln(filename);
   assign(rainfile, filename);
   writedata(rainfile);
   computeAverage(rainfile);
end.

Cuando se compila y ejecuta el código anterior, produce el siguiente resultado:

Enter the File Name:
rainfall.txt
Enter rainfall data:
34
Enter rainfall data:
45
Enter rainfall data:
56
Enter rainfall data:
78
Average Rainfall: 53.25

Archivos de texto

Un archivo de texto, en Pascal, consta de líneas de caracteres donde cada línea termina con un marcador de fin de línea. Puede declarar y definir archivos como:

type
file-name = text;

La diferencia entre un archivo normal de caracteres y un archivo de texto es que un archivo de texto se divide en líneas, cada una terminada por un marcador especial de final de línea, insertado automáticamente por el sistema. El siguiente ejemplo crea y escribe en un archivo de texto llamado contact.txt -

program exText;
var
   filename, data: string;
   myfile: text;

begin
   writeln('Enter the file name: ');
   readln(filename);
   
   assign(myfile, filename);
   rewrite(myfile);
   
   writeln(myfile, 'Note to Students: ');
   writeln(myfile, 'For details information on Pascal Programming');
   writeln(myfile, 'Contact: Tutorials Point');
   writeln('Completed writing'); 
   
   close(myfile);
end.

Cuando se compila y ejecuta el código anterior, produce el siguiente resultado:

Enter the file name:
contact.txt 
Completed writing

Agregar a un archivo

Agregar a un archivo significa escribir en un archivo existente que ya tiene algunos datos sin sobrescribir el archivo. El siguiente programa ilustra esto:

program exAppendfile;
var
   myfile: text;
   info: string;

begin
   assign(myfile, 'contact.txt');
   append(myfile);
   
   writeln('Contact Details');
   writeln('[email protected]');
   close(myfile);
   
   (* let us read from this file *)
   assign(myfile, 'contact.txt');
   reset(myfile);
   while not eof(myfile) do
   
   begin
      readln(myfile, info);
      writeln(info);
   end;
   close(myfile);
end.

Cuando se compila y ejecuta el código anterior, produce el siguiente resultado:

Contact Details
[email protected]
Note to Students:
For details information on Pascal Programming
Contact: Tutorials Point

Funciones de manejo de archivos

Free Pascal proporciona las siguientes funciones / procedimientos para el manejo de archivos:

No Señor. Nombre y descripción de la función
1

procedure Append(var t: Text);

Abre un archivo en modo anexar
2

procedure Assign(out f: file; const Name:);

Asigna un nombre a un archivo
3

procedure Assign(out f: file; p: PChar);

Asigna un nombre a un archivo
4

procedure Assign(out f: file; c: Char);

Asigna un nombre a un archivo
5

procedure Assign(out f: TypedFile; const Name:);

Asigna un nombre a un archivo
6

procedure Assign(out f: TypedFile; p: PChar);

Asigna un nombre a un archivo
7

procedure Assign(out f: TypedFile; c: Char);

Asigna un nombre a un archivo
8

procedure Assign(out t: Text; const s:);

Asigna un nombre a un archivo
9

procedure Assign(out t: Text; p: PChar);

Asigna un nombre a un archivo
10

procedure Assign(out t: Text; c: Char);

Asigna un nombre a un archivo
11

procedure BlockRead(var f: file; var Buf; count: Int64; var Result: Int64);

Lee datos de un archivo a la memoria
12

procedure BlockRead(var f: file; var Buf; count: LongInt; var Result: LongInt);

Lee datos de un archivo a la memoria
13

procedure BlockRead(var f: file; var Buf; count: Cardinal; var Result: Cardinal);

Lee datos de un archivo a la memoria
14

procedure BlockRead(var f: file; var Buf; count: Word; var Result: Word);

Lee datos de un archivo a la memoria
15

procedure BlockRead(var f: file; var Buf; count: Word; var Result: Integer);

Lee datos de un archivo a la memoria
dieciséis

procedure BlockRead(var f: file; var Buf; count: Int64);

Lee datos de un archivo a la memoria
17

procedure BlockWrite(var f: file; const Buf; Count: Int64; var Result: Int64);

Escribe datos de la memoria en un archivo
18

procedure BlockWrite(var f: file; const Buf; Count: LongInt; var Result: LongInt);

Escribe datos de la memoria en un archivo
19

procedure BlockWrite(var f: file; const Buf; Count: Cardinal; var Result: Cardinal);

Escribe datos de la memoria en un archivo
20

procedure BlockWrite(var f: file; const Buf; Count: Word; var Result: Word);

Escribe datos de la memoria en un archivo
21

procedure BlockWrite(var f: file; const Buf; Count: Word; var Result: Integer);

Escribe datos de la memoria en un archivo
22

procedure BlockWrite(var f: file; const Buf; Count: LongInt);

Escribe datos de la memoria en un archivo
23

procedure Close(var f: file);

Cierra un archivo
24

procedure Close(var t: Text);

Cierra un archivo
25

function EOF(var f: file):Boolean;

Comprueba el final del archivo
26

function EOF(var t: Text):Boolean;

Comprueba el final del archivo
27

function EOF: Boolean;

Comprueba el final del archivo
28

function EOLn(var t: Text):Boolean;

Comprueba el final de la línea
29

function EOLn: Boolean;

Comprueba el final de la línea
30

procedure Erase(var f: file);

Elimina archivo del disco
31

procedure Erase(var t: Text);

Elimina archivo del disco
32

function FilePos( var f: file):Int64;

Posición en archivo
33

function FileSize(var f: file):Int64;

Tamaño de archivo
34

procedure Flush(var t: Text);

Escribe búferes de archivos en el disco
35

function IOResult: Word;

Devuelve el resultado de la última operación de E / S del archivo
36

procedure Read(var F: Text; Args: Arguments);

Lee de archivo a variable
37

procedure Read(Args: Arguments);

Lee de archivo a variable
38

procedure ReadLn(var F: Text; Args: Arguments);

Lee del archivo a la variable y pasa a la siguiente línea
39

procedure ReadLn(Args: Arguments);

Lee del archivo a la variable y pasa a la siguiente línea
40

procedure Rename(var f: file; const s:);

Cambia el nombre del archivo en el disco
41

procedure Rename(var f: file; p: PChar);

Cambia el nombre del archivo en el disco
42

procedure Rename(var f: file; c: Char);

Cambia el nombre del archivo en el disco
43

procedure Rename(var t: Text; const s);

Cambiar el nombre del archivo en el disco
44

procedure Rename(var t: Text; p: PChar);

Cambia el nombre del archivo en el disco
45

procedure Rename( var t: Text; c: Char);

Cambia el nombre del archivo en el disco
46

procedure Reset(var f: file; l: LongInt);

Abre archivo para lectura
47

procedure Reset(var f: file);

Abre archivo para lectura
48

procedure Reset(var f: TypedFile);

Abre archivo para lectura
49

procedure Reset(var t: Text);

Abre archivo para lectura
50

procedure Rewrite(var f: file; l: LongInt);

Abre archivo para escritura
51

procedure Rewrite(var f: file);

Abre archivo para escritura
52

procedure Rewrite(var f: TypedFile);

Abre archivo para escritura
53

procedure Rewrite(var t: Text);

Abre archivo para escritura
54

procedure Seek(var f: file; Pos: Int64);

Establece la posición del archivo
55

function SeekEOF(var t: Text):Boolean;

Establece la posición del archivo al final del archivo
56

function SeekEOF: Boolean;

Establece la posición del archivo al final del archivo
57

function SeekEOLn(var t: Text):Boolean;

Establece la posición del archivo al final de la línea
58

function SeekEOLn: Boolean;

Establece la posición del archivo al final de la línea
59

procedure SetTextBuf(var f: Text; var Buf);

Establece el tamaño del búfer de archivo
60

procedure SetTextBuf(var f: Text; var Buf; Size: SizeInt);

Establece el tamaño del búfer de archivo
61

procedure Truncate(var F: file);

Truncar el archivo en la posición
62

procedure Write(Args: Arguments);

Escribe variable en archivo
63

procedure Write(var F: Text; Args: Arguments);

Escribir variable en archivo
64

procedure Writeln(Args: Arguments);

Escribe una variable en un archivo y agrega una nueva línea
sesenta y cinco

procedure WriteLn(var F: Text; Args: Arguments);

Escribe una variable en un archivo y agrega una nueva línea