Una parte muy importante al trabajar con programas es el guardar el trabajo realizado en un archivo para su posterior recuperación, edición, etc.
Visual Basic 6.0 permite guardar los archivos en un disco. Los archivos podrán ser de tres tipos:

• Secuenciales
• De Acceso Aleatorio
• Binarios

Los archivos secuenciales son aquellos en los que se tiene acceso comenzando desde el principio. No se puede tener acceso a una parte sin haber pasado antes por las anteriores. Un ejemplo de este tipo de archivo son los archivos de texto. Están escritos en caracteres ASCII y se pueden leer con el Block de Notas.
Los archivos de Acceso Aleatorio graban los datos tal como están escritos en la memoria y no son legibles por el Block de Notas. Los datos se guardan en registros y se puede tener acceso a cualquier registro directamente. Con este tipo de archivos se puede crear una base de datos simple, sin embargo, tiene la limitación de que los registros deben tener el mismo tamaño.
Los archivos Binarios son iguales a los de Acceso Aleatorio con la diferencia de que el acceso no es por registros sino por Bytes; es muy poco utilizado.
Todos los archivos deben abrirse para trabajar con ellos (y es aquí donde se define el tipo de archivo) y deben cerrarse luego de terminado el trabajo.

 

Archivos Secuenciales.

La sintaxis para abrir un archivo de tipo secuencial dependerá de lo que se desee hacer con él; si se quiere leer o escribir. No se podrá entonces leer un archivo abierto para escritura ni escribir en un archivo abierto para lectura. Para abrir un archivo para lectura la sentencia será la siguiente:

Open archivo For Input As #nFich

Donde archivo es una cadena de caracteres con la ruta y el nombre del archivo a abrir y nFich es un número que identifica al fichero.
La sentencia para cerrar un archivo abierto, para cualquier tipo de archivo será la misma:

Close #nFich

Si se escribe esta sentencia sin el argumento #nFich se cerrarán todos los archivos abiertos.
Lo siguiente es leer los caracteres de un archivo abierto y para ello se utilizan determinadas funciones. La función Input lee determinada cantidad de caracteres, la cual tiene la siguiente sintaxis:

Input(caracteres,#nFich)

Donde caracteres es la cantidad de caracteres a leer. Una aclaración con respecto a los caracteres. Un salto de línea está determinado por la sucesión de dos caracteres no imprimibles que en código ASCII tienen los códigos 13 y 10, y la constante de Visual Basic para esta sucesión es vbCrLf; por tanto, esta función tomará un salto de línea como dos caracteres.
Si se quiere leer todo el contenido de un archivo se puede utilizar la función Input de la siguiente forma:

Input(LOF(nFich),#nFich)

Otra función importante es la función Line Input, la cual lee toda una línea (una línea termina con un salto de línea, o sea, con vbCrLf). La sintaxis de esta función es:

Line Input #nFich, variable

Donde variable es una variable donde se almacenará la línea leída.
Si se quiere leer todo un archivo utilizando esta función, la sentencia puede ser la siguiente:

While Not EOF(nFich)
Line Input #nFich, variable1
variable2=variable2 & variable1
Wend

Variable2 contendrá todo el fichero al salir del bucle While. También puede utilizarse en lugar de una variable la propiedad Caption de una etiqueta o la propiedad Text de una caja de textp, por ejemplo.

Para escribir en un archivo secuencial se debe abrir el archivo para escritura y hay dos modos de apertura; el primero es:

Open archivo For Output As #nFich

Este modo de apertura reemplaza con la nueva escritura toda la escritura anterior. La segunda forma añade al final del archivo la nueva escritura, y la sentencia es:

Open archivo For Append As #nFich

Si el archivo existe se abre el archivo, si no existe se crea uno. Esto es válido para ambos modos de apertura y para los archivos de Acceso Aleatorio y Binario, pero si se intenta abrir un archivo que no existe en modo de lectura (For Input) se generará un error en tiempo de ejecución (Error 53).

Para escribir en archivos secuenciales se utiliza la instrucción Write, la cual separa los datos mediante el carácter (,); su sintaxis es la siguiente:

Write #nFich, dato1; dato2; dato3...

Donde dato1, dato2, dato3... son datos o variables con los datos a escribir. Se puede leer luego el fichero con la función Input.
Otra instrucción para la escritura en archivos es la instrucción Print, la cual tiene la siguiente sintaxis:

Print #nFich, Spc(n); texto

Donde Spc(n) es un argumento opcional que permite ingresar espacios antes de escribir y n el número de espacios, texto es el texto que se desea escribir. Se puede leer normalmente con las funciones Input y Line Input.

Archivos de Acceso Aleatorio.

Este tipo de archivos no son legibles por el Block de Notas, a diferencia de los secuenciales ya que no contienen caracteres ASCII.
Se abren de la misma forma tanto para lectura como para escritura y si no existen se crean. La sintaxis para la apertura de este tipo es:

Open archivo For Random As #nFich Len=tamaño

Este modo de apertura tiene un argumento: Len. En él se especifica el tamaño de cada registro. Un registro consiste en una serie de datos los cuales se pueden almacenar en una variable y aquí se puede aprovechar las estructuras o tipos definidos por el usuario para crear una base de datos.
Supóngase una estructura declarada de la siguiente forma en un módulo estándar:

Public Type persona
apellido as String*10
documento as Long
End Type

Cada registro almacenará una variable de tipo persona; una variable de este tipo ocupará 18 bytes (4+10 bytes + 4 bytes), por tanto la sentencia sería:

Open archivo For Random As #nFich Len=18

También puede emplearse alternativamente otra expresión. Supóngase declarada la variable Gabriel de tipo persona, la sentencia puede ser también:

Open archivo For Random As #nFich Len=Len(Gabriel)

Las funciones para leer y escribir en este tipo de archivos son las funciones Get y Put.
La función Get lee un registro y guarda lo leído en una variable. La sintaxis de esta función es la siguiente:

Get #nFich, registro, variable

Donde registro es el número del registro a leer y variable es la variable donde se almacenará el registro leído.
La función Put escribe un registro, si el registro existe lo reemplaza. Su sintaxis es la siguiente:

Put #nFich, registro, variable

Donde registro es el número del registro que se escribirá (o reemplazará) y variable es la variable que contiene el dato a escribir en el registro.

Archivos Binarios.

Se trabajan de la misma forma que los archivos de Acceso Aleatorio y se leen y escriben con las funciones Get y Put, pero en vez de acceder a los datos por registros se accede por bytes. Este sistema de trabajo no es usual.
La sintaxis para abrir un archivo de este tipo es:

Open archivo For Binary As #nFich Len=tamaño

Funciones de trabajo con archivos.

Hay varias funciones para trabajar con archivos. Algunas se han utilizado y se explican a continuación junto con otras no vistas.

• LOF: devuelve el tamaño de un archivo abierto (en bytes). Devuelve un entero de tipo Long. Su sintaxis es:
  LOF(nFich)
• FileLen: devuelve un entero de tipo Long con el tamaño en bytes de un archivo no abierto. Su sintaxis es:
  FileLen(archivo)
• EOF: devuelve un valor booleano que indica si se llegó al final de un archivo (True) o no (False). Su sintaxis es:
  EOF(nFich)
• LOC: devuelve un entero de tipo Long con la posición en un archivo abierto. Si es secuencial, la ubicación del último carácter leído y si es de Acceso Aleatorio, el último registro leído. Su sintaxis es:
  LOC(nFich)
• FileCopy: este procedimiento permite copiar archivos. Tiene por argumentos origen y destino, los cuales son el archivo a copiar (y su ruta) y el archivo de destino (y su ruta). Su sintaxis es:
  FileCopy origen destino
• Kill: este procedimiento elimina archivos. archivo es una cadena de caracteres con la ruta y el nombre del archivo a eliminar.
  Kill archivo
• MkDir: crea un directorio o subdirectorio. Su sintaxis es:
  MkDir directorio
• RmDir: elimina un directorio o subdirectorio. Su sintaxis es:
  RmDir carpeta
• FileDateTime: devuelve un valor de tipo Variant (Date) con la fecha y hora en que un archivo fue creado o modificado por última vez. Su sintaxis es:
  FileDateTime(archivo)

Ejemplo

Crea un nuevo proyecto estándar, añade un módulo estándar y coloca los siguientes controles en el formulario:

Control	Propiedad	Valor
Form	Name	frmArch
Label	Name	lblDocu
" "	Caption
Label	Name	lblApell
" "	Caption
Label	Name	lblEdad
" "	Caption	Registros
" "	Caption
Label	Name	lblEspa
" "	Caption	0
TextBox	Name	txtIngr
" "	Text
" "	Index	0, 1, 2
CommandButton	Name	cmdBusc
" "	Caption	&Buscar
CommandButton	Name	cmdIngr
" "	Caption	&Ingresar

Escribe en el módulo estándar a siguiente estructura:

Public Type Persona
documento as Long
apellido as String*12
nacimiento as Date
End Type

En la ventana de código del formulario escribe el siguiente código:

Option Explicit
Dim pers as Persona, regs as Integer, x as Byte

Private Sub Form_Load()
Open "c:WindowsTempdatbase.tmp" For Random As #1 Len=24:lblEspa.Caption=LOF(1)
End Sub

Private Sub cmdBusc_Click()
If txtIngr(0).Text="" Then
Exit Sub
Else:regs=LOF(1)24
For x=1 To regs
Get #1,x,pers
If txtIngr(0).Text=pers.documento Then
lblDocu.Caption=pers.documento:lblApell.Caption=pers.apellido
lblEdad.Caption=pers.nacimiento:Exit For
End If
Next x
End Sub

Private Sub cmdIngr_Click()
If Len(txtIngr.Text>0) And isDate(txtIngr(2).Text)=True Then
pers.documento=txtIngr(0).Text:pers.apellido=txtIngr(1).Text:pers.nacimiento=txtIngr(2).Text
regs=LOF(1)24+1:Put #1,regs,pers:lblEspa.Caption=LOF(1)
End If
End Sub

Pulse F5 para probar la aplicación.