Un registro
(record) es un tipo de datos
estructurado denominado (dato record) que consta de un
conjunto de elementos que pueden ser del mismo tipo o de tipos
diferentes.
Formato
Type Tipo – dato = record Lista de identificador 1 : tipo 1; Lista de identificador 2 : tipo 2 ; .Lista de identificador n : tipo n; End; |
Tipo – dato : nombre de la estructura o
dato registro
Lista de identificador : lista de uno o más
nombres de campos separados por comas
Tipo: puede ser cualquier tipo de dato
estándar
Declaración de un registro cuyos campos son:
nombre, edad, domicilio, salario.
Type
Empleado = record
Nombre : string [30];
Edad : integer;
Domicilio : string [30];
Salario : real:
End;
Fecha = record
Mes : ( Enero, Febrero, Marzo, Abril, Mayo,
Junio,
Julio, Agosto, Septiembre, Octubre,
Noviembre y Diciembre);
Día : 1..31;
Año : 1900 .. 2000;
Estas declaraciones han creado un tipo de datos llamado
empleado – con cuatro campos: nombre, edad, domicilio, salario, – y otro
denominado fecha con tres campos: día, mes y
año
Variables de Tipo Registro
Tras utilizar la declaración tupe se ha creado un
tipo de dato registro, pero no se ha creado una variable de ese
tipo. Esto se consigue con la designación
Var.
Formato
Var Nombrereg : Nombretipo |
Nombretipo : Es el mismo que el utilizado en la
correspondiente declaración type
Nombrereg : Nombre de una variable en particular del
registro
Ejemplo
Var
Nacimiento: Fecha;
Trabajador : empleado;
Las variables
nacimiento y trabajador tienen la estructura
especificada en la declaración del tipo de registro
empleado y fecha y se representan gráficamente en la
siguiente figura
Variable Empleado
Gabriel |
19 |
Centro |
125685 |
Nombre
Edad
Domicilio
Salario
01 |
10 |
1984 |
Variable Fecha
Mes
Día
Año
Campos
Los componentes de un registro se denominan
campos. Cada campo tiene un nombre llamado
identificador de Campo, que es algún identificador
elegido por el programador cuando se declara el tipo de registro
y algún tipo que se especifica cuando se declara el tipo
de dato record.
Acceso a los campos de registro
Se puede acceder a cada campo de registro directamente
utilizando un asignador o selector de campo de la
forma
Nombre.Reg: Nombre del Campo
Los datos mostrados anteriormente Empleado y Fecha
mediante una secuencia de sentencias de
asignación:
Empleado. Nombre : = Gabriel
Empleado. Edad : = 19
Empleado. Domicilio : = Centro
Empleado. Salario : = 125685
Una vez que los datos están almacenados en un
registro se pueden manipular de igual forma que otros datos de
la
memoria.
Write ( Empleado. Nombre) visualiza a Gabriel
La sentencia with
La tarea de el selector de campo completo cada vez que
se referencia un campo se un registro es tedioso, sobre todo si
el número de campos es grande.
La sentencia with permite referenciar el nombre
del registro en su cabecera y posteriormente para llamar
algún campo solo se necesita el nombre del campo y no el
del selector de campo completo, con el nombre del
registro
Formato
With Variable Registro do
Begin
Sentencia que hacen referencia a campos de las variables del
registro
End;
Variables Registro: nombre o nombres de registros
Sentencias: relacionadas con los campos
Ejemplos
1. Considere las siguientes declaraciones
Tupe
Prueba = record
F1 : integer;
F2 : string [8];
Var
X : prueba;
Un modo de asignar valores a un
registro y luego visualizarlo es con with el cual puede
ser:
With x do
Begin
F1 : 20;
F2 : (‘gabriel’);
End;
Writeln (x.F1, x.F2);
2. with empleado do
writeln ( nombre) equivale a writeln
(empleado.nombre);
Precauciones en el uso de la sentencia
With
Aunque la sentencia with es muy útil para reducir
la longitud de las sentencias de un programa que
manipulan componentes de un registro, también puede
reducir la claridad de las sentencias y producir
ambigüedades. En particular deberá tener especial
cuidado cuando incluya más de una variable registro en una
sentencia with, ya que se puede producir ambigüedad
aparente. Pascal siempre
utiliza la variable registro más
próxima.
Ejemplo
Type
Empleado : record
Nombre : string [20];
Edad : integer;
Empresa : string[30];
End;
Var
Socio : Empleado;
Jefe : Trabajador;
Deducciones : real;
Begin
with socio do
Begin
Readln (Nombre);
Neto : =Salario – Deducciones;
Writeln (Empresa);
End;
Nombre y Empresa
referencian a la variable Socio, mientras que Salario se refiere
a la variable Jefe
Registros Anidados
En los casos anteriores todos los campos de los
registros eran tipos de datos
simples, cadenas o arrays. Es posible declarar un tipo de
registro con campos que sean otros registros. Un registro con uno
o mas campos que son tipo registro se llama registro
jerárquico o registro anidado.
- Los campos que componen un registro pueden tener
cualquier tipo y, en particular, pueden ser
registros.
Ejemplo
TYPE
Tipo Cadena20 = array[1..20] of char;
Tipo Cadena10 = array[1..10] of char;
Fecha = record
Mes : TipoCadena10;
Dia : 1..31;
Año : 1900..2000
End;
Registro Personal =
RECORD
Nombre : Tipo Cadena20;
Nacimiento : Fecha;
Edad, Dependientes : integer;
Sueldo Hora : real
End;
Var
Empleado : Registro Personal;
Para acceder a los campos que se encuentran dentro de un
registro anidado (o registro jerárquico) se
añade el identificador de campo detrás del selector
del registro interno. Por ejemplo, Empleado.Nacimiento.Mes se
refiere al primer campo del registro interno de tipo
Fecha.
Arrays de Registros
Los registros simples se utilizan raramente por si
mismos. En general se agrupan en conjuntos
conocidos como arrays de registros. Por ejemplo, si se dispone un
registro que contiene los datos relativos a un archivo de un
stock de almacén.
Type
Itemstock = record
Nombre : string[30];
Numero : integer;
Precio : real;
End;
Tornillo |
Nombre
1492 |
Nuevo
25.000 |
Precio
Si el inventario
dispone de 100 artículos y se desean procesar
adecuadamente se puede utilizar un array de 100 elementos;
mediante la declaración siguiente se definen los elementos
del conjunto.
Type
Lista = array [ 1..100] of itemstock,
Var
Inventario : lista
Merced a esta declaraciones puede acceder a cada
registro a través de los campos de cada registro.
Así, por ejemplo, la lista completa del inventario se
puede leer con el siguiente segmento del programa:
For i : = 1 to 100 do
Begin
Writeln (‘ el siguiente elemento es’
‘);
LeerRegistro (inventario [i]);
End;
El procedimiento
LeerRegistro debe permitir leer los datos de cada registro
definido por el índice I
Procedure LeerRegistro (var item :
itemstock);
Var
I: integer;
Begin
Writeln(‘ introduzca el nombre’);
Readln (itrem.nombre);
Writeln(‘ introduzca número de
stock’);
Readln (itrem.número);
Writeln(‘ introduzca precio);
Readln (itrem.precio);
End;
El proceso de
registros del array es similar al tratamiento, ya conocido, de
elementos de un array con la peculiaridad de ser tipos compuestos
(registros) en lugar de ser tipos simples.
Inventario [ 2 ]. Nombre
Campo del registro
Índice del elemento del array
Array de registros de tipo stock
Ejemplo
Escribir mediante registros el siguiente problema
relativo a control de
exámenes de un curso escolar:
Program Control
Exámenes;
Const
NumEstudiantes = 4;
NumAsignaturas = 4;
Type
IndiceEstudiantes = 1. . NumEstudiantes;
IndiceAsignaturas = 1. . NumAsignaturas;
Estudiante = record
Asignaturas : array [ IndiceAsignaturas] of
real;
Media : real;
End;
BoletinNotas = array [ IndiceEstudiantes] of
Estudiantes;
Var
Boletin : BoletinNotas;
Procedure LeerNotas (var B : boletinNotas);
Var
E : IndiceEstudiantes;
I : IndiceAsignaturas;
Begin
For i. = 1 to numestudiantes do
Begin
Writeln (‘ introduzca las NumAsignaturas: 1
,’ calificaciones’);
Writeln (‘ del estudiante numero ‘, E:
1,’ en una línea’);
For I: = 1 to NumAsignaturas do
Read ( B[ E .asiganturas [ I ] );
Readln {salto de linea para las notas de otro
estudiante}
End;
End;
Procedure MediasEstudiante (var B:
BoletínNotas);
Var
E : ÍndiceEstudiantes;
I : IndiceAsignaturas;
Suma : real;
Begin
For I : = 1 to NumEstudiantes do
Begin
Suma : = 0;
For I : = 1 to NumAsignaturas do
Suma : = suma + B[ E ] . Asignaturas [ I ];
B [ E ] . Media : = suma / NumAsignaturas;
End;
End;
Procedure Resultados ( var B :
BoletínNotas);
Var
E : IndiceEstudiantes;
I : IndiceAsignaturas;
Begin
Writeln (‘ estudiante ‘, ‘ media
’ : 10 , ‘ Notas Asignaturas ’ :
41);
For E : = 1 to NumEstudiantes do
Begin
Writeln (‘ E : 6 , B [ E ] . media : 13.1 ,
‘ ’ : 10 );
For I : = 1 to NumAsignaturas do
Writeln( B[ E . asignaturas [ I ] : 10:1 );
Writeln
End
End;
Begin { programa principal }
LeerNotas (Boletin);
MediasEstudiante (Boletin);
Resultados (Boletin);
End;
Ordenación de un array de
registros
Sabiendo ya la serie de métodos de
ordenación relativos a conjuntos de
datos (arrays) de tipos simples: enteros, char, string, etc..
Estos métodos
son aplicables de igual modo a la ordenación de arrays de
registros. Como ya sabemos uno de los métodos de
ordenación más factible es el método de
la burbuja, sin embargo es de hacer notar que el método de
la burbuja tiene algunas desventajas pero dicho método ha
sido mejorado por lo cual utilizaremos el método de la
burbuja mejorado para poder
aplicarlo al tema que estamos viendo.
Consideremos lo siguiente. Un array de registro de 100
empleados. En el programa principal existirán las
siguientes condiciones:
Const
Max = 100;
Type
Cad1 = string [ 30 ];
Cad2 = string [ 30 ];
Empleado = record;
Nombre : cad1;
Numss : cad2;
Salario : real;
ListaEmpleados = array [ 1.. max] of empleado
;
Var
Lista : Empleado;
Ordenación por Burbuja Mejorado
{BurbujaMejorado. Procedimiento
para ordenar un arry de registros en orden ascendente por nombre
parámetros variable
L : array de registros de empleados parámetro por
valor
N: números de registros del array}
Procedure BurbujaMejorado (Var L: ListaEmpleados; N:
Integer);
Var
I,J: Integer;
Aux : Empleado
Ordenado : Boolean;
Begin
I : = 1;
Repeat
Ordenado : = True;
For J : = 1 To N – 1 Do
If L [ J ]. Nombre > L [ J + 1 ]. Nombre
Then
Begin
Aux : = Lista [ J ];
Lista [ J ] : = Lista [ J + 1 ];
Lista [ J + 1 ] : = Aux ;
Ordenado : = False
End; {If}
I : = I + 1 ;
Until Ordenado Or ( I > N – 1 )
End; { BurbujaMejorado }
Ordenación por Selección
Procedure Selección
(Var L: ListaEmpleados; N: Integer ),
Var
I, J: Integer
Aux. Empleado ;
Begin
For I : = 1 To N – 1 Do
For J : = I + 1 To N Do
If L [ I ]. Nombre > L [ J ] . Nombre Then
Begin
Aux : = Lista [ I ];
Lista[ J ]: = Lista [ J ] ;
Lista [ J ] : = Aux,
End { If Y For }
End; {Seleccion }
Ordenación Por Inserción
Procedure Inserción (Var L : Listaempleados ; N :
Integer);
Var
I , J : Integer;
Aux: Empleado;
Encontrado : Boolean;
Begin
Aux : = Lista [ J ];
I : = J – 1;
Encontrado : = False;
While ( I > = 1) And Not Encontrado Do
If Aux.Nombre < L [ 1 ] . Nombre Then
Begin
Lista [I + 1 ] : = Lista [ I ];
I : = I – 1 ;
End;
Else Encontrado : = True;
L [ I + 1 ] : = Aux;
End {For}
End; {Insercion}
Un archivo es una
estructura de daros consistente en una secuencia de elementos o
componentes llamados registros, todos del mismo tipo, ya sea
simple o estructurado. A diferencia de los arrays un archivo
puede almacenarse en un dispositivo auxiliar disco, cintas, etc..
de forma que los datos obtenidos durante y después del
procesamiento ni se pierdan.
Un archivo o fichero (file) es una colección de
información (datos relacionados entre si )
localizada o almacenada como una unidad en alguna parte de
la
computadora. Esta colección de datos sirve para
entrada y salida a la computadora y
se manejan con un programa. En contraste con los arrays y
registros, el tamaño de esta colección no es fijo.
Y esta limitado solo por la cantidad de memoria
secundaria del disco o cinta disponible. Es decir los archivos son
dinámicos: en un registro se deben identificar los campos,
el número de elementos de un array y el número de
elementos de una cadena , y son estructuras
estáticas; en los archivos no se
requieren tamaños predeterminados. Eso significa que se
pueden hacer archivos de datos más grandes o más
pequeños según se necesiten.
Los archivos no están limitados por la memoria de
su computadora,
donde están contenidas las estructuras de
datos. En teoría
se dispone de una unidad de disco de 20 MB, podría alojar
un archivo de datos de igual tamaño, incluso con memoria de 128 KB
o 640 KB, típicos de las computadoras
actuales
Cada archivo es referenciado por un identificador (su
nombre) .
Tipos de Archivos
Los elementos de un archivo pueden ser de cualquier
tipo, simple o estructurado, excepto un tipo de archivo (file)o
cualquier tipo estructurado con un componente tipo
archivo.
Los principales tipos son:
- archivo de entrada: una colección de datos
localizado en un dispositivo de entrada - archivo de salida : un colección de información visualizada por la
computadora - archivo de programa: un programa codificado en un
lenguaje
especifico y localizado o almacenado en un dispositivo de
almacenamiento
En Turbo Pascal
existen 3 tipos de archivos los cuales son:
- archivos tipeados (tipificados) o con tipo (file
of. ) (acceso aleatorio) - no tipeados (no tipificados) o sin tipo
(file) - archivos secuenciales o archivos de texto
Tipos de acceso a un archivo
Existen dos modalidades para acceder a un archivo de
datos : acceso secuencial y acceso directo o aleatorio. El acceso
secuencial exige elemento a elemento, es necesario una
exploración secuencial comenzando desde el primer
elemento. El acceso directo permite procesar o acceder a un
elemento determinado haciendo una referencia directamente por su
posición en el soporte de almacenamiento.
Pascal estándar sólo admite el acceso secuencial,
pero Turbo Pascal
permite el acceso directo.
Los Archivos Tipeados (Con Tipo):
también llamados archivos binarios,
contienen datos de tipo simple o estructurado, tales como
integer, real , record, etc., excepto otro tipo de archivos. Los
archivos con tipos están estructurados en elementos o
registros (record) cuyo tipo puede ser cualquiera. A los
elementos de estos archivos se accede directamente, al no
situarse éstos en posiciones físicamente
consecutivas, sino en posiciones lógicas. Esta es la
razón por la cual se les denomina archivos de acceso
aleatorio o directo. Los elementos de los archivos aleatorios son
de igual tamaño y el término acceso directo
significa que es posible acceder directamente a un elemento con
solo especificar su posición. Declaración y
asignación de archivos La declaración de un archivo
con tipo se efectúa con la ayuda de las palabras
reservadas file of. El procedimiento de asignación es
idéntico al utilizado anteriormente.
Ejemplo:
Type
datos = record
clave : integer;
nombre : string[30];
puesto : string[20];
sueldo : real;
estado : boolean;
{true activo,false baja lógica}
end;
Var
archivo:file of datos;
Begin
Assign(archivo,'empleado.dat');
Archivos Sin Tipo
Todos los archivos utilizados hasta ahora suponen
algún tipo de estructura. Si no se conoce la estructura
del registro se debe utilizar un archivo sin tipo. Los archivos
sin tipo son canales de E/S de bajo nivel, principalmente
utilizados para acceso directo a cualquier archivo de disco con
independencia
del tipo y estructura. Cualquier archivo de disco puede ser
declarado como sin tipo. Turbo Pascal permite tratar un archivo
como una serie de bloques sin necesidad de conocer el tipo de
datos que contiene.
Archivos de Acceso Secuencial (Con
Tipo)
Dependiendo de la manera en que se accedan los registros
de un archivo, se le clasifica como secuencial o como directo. En
el caso de los archivos de acceso secuencial, para tener acceso
al registro localizado en la posición N, se deben haber
accedido los N-1 registros previos, en un orden secuencial.
Cuando se tienen pocos registros en un archivo, o que los
registros son pequeños, la diferencia entre los tiempos de
acceso de forma secuencial y directa puede no ser perceptible
para el usuario; sin embargo, la diferencia viene a ser
significativa cuando se manejan archivos con grandes cantidades
de información. La forma de manejar los archivos de acceso
secuencial es más sencilla en la mayoría de los
lenguajes de
programación, por lo que su estudio se antepone al de
los archivos de acceso directo. El manejo secuencial de un
archivo es recomendable cuando se deben procesar todos o la
mayoría de los registros, como por ejemplo en los casos de
una nómina
de empleados o en la elaboración de reportes
contables.
Tratamiento de Archivos desde Turbo
Pascal
El Turbo Pascal permite manipular archivos y directorios
en disco de modo similar al sistema
operativo MS-DOS.
Pudiéndose realizar las siguientes operaciones con
archivos y directorios:
Erase(nomvararchivo)
Rename(nomvararchivo,'nombrenuevoarchivo')
Chdir (directorio)
Mkdir (directorio)
Rmdir (directorio)
Getdir(unidad,camino)
Unidad = 0 unidad de arranque
Unidad = 1 A:
Unidad = 2 B:
Unidad = 3 C:
Camino contiene el directorio actual.
Gestión de archivos
La siguiente tabla recopila todos los procedimientos y
funciones
estándar para el tratamiento y manipulación de
archivos en turbo pascal
Assign
Éste procedimiento realiza la operación de
asignar un archivo mediante una correspondencia entre una
variable tipo archivo con un archivo externo situado en un
disco.
Formato
Formato :assign (f,nombre)
f nombre interno del archivo por el que se conoce el
archivo dentro del programa(por ejemplo, el utilizado en la
declaración
nombre: nombre externo con el que se conoce el archivo
por el sistema operativo
(por ejemplo : 'a:program4.pas'); es una cadena que se define
como una constante en el programa o bien una variable cuyo
valor se lee
interactivamente; puede ser una unidad:nombre.extensión o
bien la ruta completa a un archivo.
Ejemplo :
Const
ruta ='c:tplista.pas';
Var
ArchText : Text;
ArchBin : File;
Begin
assign (ArchText,ruta);
assign (ArchBin,'alumnos.dbf')
ChDir
Formato: ChDir(s)
Cambia el subdirectorio actual al especificado por la
variable de cadena s.
Ejemplo (asignación del archivo lista.pas ubicado
en c:tplista.pas)
Var
ArchText : Text;
Begin
ChDir('C:tp');
assign (ArchText,'lista.pas');
CLOSE
Éste procedimiento nos permite cerrar los
archivos después que han sido utilizados, si los archivos
no son
cerrados se perderán los datos que se encuentran
en la memoria auxiliar.
Formato : Close (f)
F : Variable de archivo.
Ejemplo:
Var
ArchText : Text;
Begin
assign (ArchText,'c:tplista.pas');
rewrite(ArchText);
close(ArchText);
Erase
Éste procedimiento nos permite borrar un archivo,
el archivo a borrar no debe estar abierto. Para borrar un archivo
se debe realizar lo siguiente :
1. Asignar el archivo externo a una variable de
archivo.
2. Llamar al procedimiento erase
Formato: Erase(s)
Borra (elimina) un archivo cuya ruta de acceso
está especificada por s.
Ejemplo:
Var
ArchText : Text;
Begin
assign (ArchText,'c:tplista.pas');
erase(ArchText);
GetDir
Formato : GetDir(i,s)
Busca el nombre del subdirectorio actual. El primer
parámetro i es un entero que representa la unidad : i=0
(unidad de disco actual, por defecto), i=1 (unidad A), i=2
(unidad B), etc. Después de la llamada, la variable de
cadena s contiene el subdirectorio actual de esa
unidad.
Ejemplo:
Var
s:string[80];
Begin
ChDir('c:tp');
GetDir(0,s);
WriteLn(s); {Resulta c:tp}
MkDir
Formato:
MkDir(s)
Crea un nuevo subdirectorio de nombre s.
Ejemplo:
Begin
MkDir('C:nuevo');
Rename
Éste procedimiento renombra (cambia el nombre) un
archivo externo. Para renombrar un archivo se debe
hacer los siguiente :
1. Asignar un archivo a la variable archivo
2. Llamar al procedimiento rename
Formato: Rename(f,nombre_archivo)
f variable de archivo
nombre_archivo nuevo nombre del archivo
Ejemplo :
Var
ArchText : Text;
Begin
Assign (ArchText,'viejo.pas');
Rename (ArchText,'nuevo.pas');
Reset
Éste procedimiento abre un archivo existente para
una operación de lectura. Si se
intenta llamar a Reset y el archivo especificado no existe, se
producirá un error de E/S (entrada/salida).
Formato : Reset(f)
f variable de tipo archivo
Ejemplo:
Var
ArchText : Text;
Begin
Assign (ArchText,'lista.pas');
Reset(ArchText);
Rewrite
Crea y abre un nuevo archivo. Si el archivo ya existe,
Rewrite borra su contenido; en caso contrario, el archivo queda
abierto para una operación de escritura.
Formato: Rewrite(f)
f variable de archivo
Ejemplo:
Var
ArchText : Text;
Begin
Assign (ArchText,'lista.pas');
Rewrite(ArchText);
RmDir
Elimina el subdirectorio de nombre s.
Formato RmDir(s)
Ejemplo
Begin
RmDir('C:nuevo');
Append
El procedimiento Append abre un archivo existente para
añadir datos al final del mismo.
Formato: Append(f)
f variable de archivo de texto que debe
haber sido asociada con un archivo externo por medio de
Assign.
Si el archivo no existe, se produce un error; y si ya
estaba abierto, primero se cierra y luego se reabre.
Ejemplo:
Var
ArchText : Text;
Begin
Assign (ArchText,'lista.pas');
Rewrite(ArchText);
WriteLn(ArchText,'Primera línea');
Close(ArchText);
Append(ArchText);
WriteLn(ArchText,'Agrega esto al
último');
Close(ArchText)
end.
Flush
El procedimiento Flush vacía el buffer de
un archivo de texto abierto para salida. Cuando un archivo de
texto es abierto para escritura
usando Rewrite o Append, la llamada a Flush llenará el
buffer asociado al archivo. Esto garantiza que todos los
carácteres escritos en el archivo en ese tiempo sean
escritos en el archivo externo. Flush no afecta los archivos
abiertos para entrada. Usando la directiva {$I}, IOResult
devuelve 0 si esta operación fue realizada con éxito
de lo contrario retonará un código
de error.
Formato: Flush(f)
f variable de archivo
Ejemplo:
Var
ArchText : Text;
Begin
Assign (ArchText,'lista.pas');
Rewrite(ArchText);
WriteLn(ArchText,'Primera línea');
WriteLn(ArchText,'Segunda línea');
Flush(ArchText);
WriteLn(ArchText,'tercera línea');
WriteLn(ArchText,'Agrega esto al
último');
Close(ArchText)
end.
Read
El procedimiento Read se utiliza para la lectura de
datos situados en un archivo de tipo texto.
Formato: Read(f,v1,v2,..)
f variable de archivo de texto
v1,v2,… variable de tipo char, integer, real o
string
Ejemplo:
Var
ArchText : Text;
datos : string[20];
Begin
Assign(ArchText,'lista.pas');
Reset(ArchText);
Read(ArchText,datos);
WriteLn(ArchText,datos);
Close(ArchText)
End.
ReadLn
EL procedimiento ReadLn se utiliza para la lectura de
datos situados en un archivo de tipo texto. A diferencia de Read,
ReadLn salta al principio de la siguiente línea del
archivo. Este salto de línea se produce cuando se han
asignado valores a la
lista de varibles del procedimiento; en caso contrario, el
procedimiento hace caso omiso del control de línea y sigue
asignando información.
Formato: ReadLn(f,v1,v2,..)
f variable de archivo de texto
v1,v2,… variable de tipo char,integer,
real o string
Ejemplo:
Var
ArchText : Text;
datos : string[20];
Begin
Assign (ArchText,'lista.pas');
Reset(ArchText);
ReadLn(ArchText,datos);
WriteLn(ArchText,datos);
Close(ArchText)
End.
SetTextBuf
El procedimiento SetTextBuf asigna un buffer de
entrada/salida a un archivo de texto. SetTextBuffer podría
nunca ser usado en la apertura de un archivo, aunque éste
puede ser llamado inmediatamente después de Reset,
Rewrite, y Append. Si se invoca a SetTextBuf en una apertura de
archivo las operaciones de
entrada/salida son tomadas por éste procedimiento, y se
pueden perder datos como resultado de el cambio de
buffer.
formato : SetTextBuf(f,buffer)
Ejemplo:
Var
ArchText: Text;
Ch: Char;
buffer: array[1..4096] of Char; { buffer de
4K}
Begin
Assign(ArchText,'memoria.txt');
{Se utiliza un buffer grande para lecturas más
rápidas}
SetTextBuf(ArchText,buffer);
Reset(ArchText); {Visualiza el archivo en la
pantalla}
while not Eof(ArchText) do
Begin
Read(ArchText,Ch);
Write(Ch)
End;
Close(ArchText)
end.
Write
EL procedimiento Write sirve para escribir datos en un
archivo.
Formato: Write(f,v1,v2,…)
f variable de tipo archivo
v1,v2,… variables de tipo de datos
Ejemplo:
Var
ArchText : Text;
Begin
Assign (ArchText,'nuevo.txt');
Rewrite(ArchText);
Write(ArchText,'Está es la primera
línea.');
Write(ArchText,'Fin del texto.');
Close(ArchText)
End.
El contenido del archivo será : Está es la
primera línea. Fin del texto.
WriteLn
EL procedimiento WriteLn sirve para escribir datos en un
archivo. A diferencia de Write, WriteLn incluye un salto de
línea para separar el texto.
Formato: WriteLn(f,v1,v2,…)
f variable de tipo archivo
v1,v2,… variables de tipo de datos
Ejemplo:
Var
ArchText : Text;
Begin
Assign (ArchText,'nuevo.txt');
Rewrite(ArchText);
WriteLn(ArchText,'Está es la primera
línea.');
WriteLn(ArchText,'Fin del texto.');
Close(ArchText)
end.
El contenido del archivo será :
Está es la primera línea. Fin del
texto.
BlockRead
Transfiere un bloque de datos de un archivo sin tipo
hacia un buffer.
Formato:
BlockRead(arch,buffer,bloques,resul)
arch archivo sin tipo
buffer variable de cualquier tipo delongitud suficiente
para acogerlos datos transferidos
bloques expresión que corresponde al
número de bloques de 128 bytes a transferir.
resul parámetro opcional que indica el
número de bloques que Se leyeron o escribieron
realmente.
BlockWrite
Transfiere un buffer de datos hacia un archivo sin
tipo.
Formato:
BlockWrite(arch,buffer,bloques,resul)
Arch: archivo sin tipo
buffer variable de cualquier tipo de longitud suficiente
para acoger los datos transferidos
bloques expresión que corresponde al
número de bloques de 128 bytes a transferir.
Resul: parámetro opcional que indica el
número de bloques que se leyeron o escribieron
realmente.
Ejemplo:
Program CopiadeArchivos;
Var
fuente,destino : file; {archivo sin tipo}
buffer : array[1..512] of byte;
leidos : integer;
Begin
Assign(fuente,'original.txt');
Assign(destino,'copia.txt');
Reset(fuente,1);
Rewrite(destino,1);
BlockRead(fuente,buffer,SizeOf(buffer),leidos);
while leidos>0 do
Begin
BlockWrite(destino,buffer,SizeOf(buffer),leidos);
BlockRead(fuente,buffer,SizeOf(buffer),leidos)
end
close(fuente);
close(destino)
end.
Eof
La función
eof(end of file), fin de archivo, devuelve el estado de
un archivo. Es una función de
tipo lógico que indica si el fin de archivo se ha
encontrado; devuelve true si se encontró, false en casi
contrario.
Formato: Eof(f)
f variable de archivo
Ejemplo:
Var
ArchText: Text;
Ch: Char;
Begin
Assign(ArchText,'memoria.txt');
Reset(ArchText); {Visualiza el archivo en la
pantalla}
while not Eof(ArchText) do
Begin
Read(ArchText,Ch);
Write(Ch)
end;
Close(ArchText)
end.
Eoln
La función Eoln devuelve el estado de fin
de línea de un archivo. Es una función de tipo
lógico. Devuelve true si la posición actual del
archivo (puntero) esta en la marca de fin de
línea, o bien si Eof(f) es true, el caso contrario
devuelve false.
Formato: Eoln(f)
f variable de archivo de texto
Var
car :char;
ArchText:text;
Begin
Clrscr;
Assign(ArchText,'nuevo.txt');
Reset(ArchText);
{muestra sola la
primera línea}
While not(Eoln(ArchText)) do
Begin
Read(ArchText,car);
Write(car)
end
end.
SeekEof
Retorna el estado de
fin de archivo. Es una función de tipo lógico.
Sólo para archivos de texto. Si la posición actual
del puntero de archivo se encuentra en la marca de fin de
archivo devuelve true, de lo contrario retorna false. SeekEof es
una función que avanza siempre al siguiente carácter,
ignorando por completo los espacios en blanco.
Formato: SeekEof(f)
f variable de archivo de texto
Ejemplo:
Var
car :char;
ArchText:text;
Begin
Clrscr;
Assign(ArchText,'nuevo.txt');
Reset(ArchText);
{muestra el
contenido del archivo}
While not(SeekEof(ArchText)) do
Begin
Read(ArchText,car);
Write(car)
End
end.
SeekEoln
Retorna el estado de fin
de línea. Es una función de tipo lógico.
Sólo para archivos de texto. Si la posición actual
del puntero de archivo se encuentra en la marca de fin de
línea devuelve true, de lo contrario retorna false.
SeekEoln es una función que avanza siempre al siguiente
carácter, ignorando por completo los
espacios en blanco.
Formato: SeekEoln(f)
f variable de archivo de texto
Ejemplo:
Var
car :char;
ArchText:text;
Begin
Clrscr;
Assign(ArchText,'nuevo.txt');
Reset(ArchText);
{muestra el contenido del archivo}
While not(SeekEoln(ArchText)) do
Begin
Read(ArchText,car);
Write(car)
end;
Close(ArchText)
end.
IOResult
Es una función que devuelve un número
entero que indica el código
del error de la última operación de E/S; si el
valor de
retorno es cero, esto nos indica que la operación se ha
desarrollado sin problema.
Formato: IOResult
Ejemplo:
Var
ArchText:text;
Nerror :integer;
Begin
Clrscr;
Assign(ArchText,'nuevo.txt');
{SI-}
Reset(ArchText);
Nerror:=IOResult;
{SI+}
if Nerror<>0 then
WriteLn('Código de error # ',Nerror)
else
Close(ArchText)
end.
FilePos
Está función devuelve la posición
actual del archivo (número de registro), en forma de un
entero largo (longint).
Formato: FilePos (f)
f variable de tipo archivo
Notas :
1. Devuelve 0 si esta al principio del
archivo.
2. Es igual a FileSize(f) si el puntero de
posición del archivo esta al final del archivo.
FileSize
Está función devuelve el tamaño
actual del archivo(número de registros existentes en el
archivo). Si el archivo esta vacío devuelve
cero.
Formato: FileSize(f)
f variable de tipo archivo
Seek
Sitúa el puntero de posición del archivo
en el número de registro correspondiente.
Formato: Seek(f,numreg)
f nombre de archivo (no de tipo text) numreg
número de posición del registro, el primer registro
es cero; si numreg es menor que 0 o mayor que n (para un archivo
de n registros), se producirán resultados
impredecibles.
Ejemplo:
Seek(empleados,FileSize(empleados));
{está sentencia posiciona el puntero al final del
archivo}
Truncate
Está función trunca (corta, mutila) un
archivo a partir de la posición actual del puntero del
archivo.
Formato: Truncate(f)
f varible de tipo archivo
Si Truncate se ha ejecutado con éxito
IOResult tendrá un valor de cero. El archivo debe estar
abierto. Truncate no trabaja en archivos de texto.
Ejemplo:
Var
f: file of integer;
i,j: integer;
Begin
Assign(f,'prueba.int');
Rewrite(f);
For i := 1 to 5 do
Write(f,i);
Writeln('Archivo antes de ser truncado :');
Reset(f);
while not Eof(f) do
Begin
Read(f,i);
Writeln(i)
end;
Reset(f);
For i := 1 to 3 do
Read(f,j); { lectura de 3
registros }
Truncate(f); { Trunca el archivo a partir de aquí
}
Writeln;
Writeln('Archivo después de ser
truncado:');
Reset(f);
while not Eof(f) do
Begin
Read(f,i);
Writeln(i)
end;
Close(f);
end.
Registros
www.Lip.Uns.Edu.Ar/Pci/Registros%20en%20pascal.Pdf
Informática 131 (Sim)
www.Umsanet.Edu.Bo/Programacion/
Inf_131(Page_Web)/4.Htm
Arreglos de registros
148.202.148.5/Cursos/Cc102/Int_Programacion/
Moduloiv/Tema4_4.Htm
Turbo Pascal Versiones 5.5, 6.0 y7.0
Autor Joyanes
Registros y Archivos
www.terra.es/personal2/cesar.zm/diez.htm
Realizado por
Gabriel Dugarte
República Bolivariana de Venezuela
Ministerio de Educación, Cultura y
Deportes
Instituto Universitario de la Frontera
(IUFRONT)
San Cristóbal / Estado Táchira