Page 96
Image_1184_0
Instrucción leer e instrucción guardar. Introducción a archivos con VB.
__rendered_path__3
INSTRUCCIÓN LEER E INSTRUCCIÓN GUARDAR. INTRODUCCIÓN A ARCHIVOS CON VB.
__rendered_path__15
Advertencia: una manipulación incorrecta de ficheros puede dar lugar a la pérdida de datos, al
__rendered_path__16
malfuncionamiento de programas o a fallos del sistema operativo del ordenador. Es necesario disponer
__rendered_path__12__rendered_path__15
de copias de seguridad de toda información que se considere importante.
__rendered_path__17
__rendered_path__17
Guardar datos a un disco o recuperar los datos previamente guardados son procesos fundamentales en
__rendered_path__18
cualquier lenguaje informático. La importancia del almacenamiento de contenidos es obvia: envío de
__rendered_path__20
información a otros usuarios, posponer el trabajo varios días o semanas sin tener que introducir
__rendered_path__20
manualmente los datos de nuevo, acceso a información almacenada en sistemas remotos, etc. Incluso
__rendered_path__21
para desarrollos de software de relativamente corta longitud resulta relevante la gestión de datos, por
__rendered_path__15__rendered_path__23
ahorrar una cantidad de tiempo considerable.
__rendered_path__16__rendered_path__23
Ficheros y bases de datos constituyen un cuerpo de conocimiento de cierta complejidad y extensión.
__rendered_path__15
Por motivos de espacio no vamos a hacer más que una breve introducción a ellos.
Podemos pensar en los ficheros o archivos de forma análoga a lo que sería un archivo físico: un lugar
donde hay información almacenada. Ahora bien, eso no nos dice cómo se encuentra esa información: si
está ordenada (alfabéticamente, de mayor a menor, en impresos con campos predefinidos), si son
datos de un tipo o de varios tipos (numéricos, tipo texto, mezcla de tipos de datos...), si se leen usando
alguna clave de interpretación (una partitura no se lee igual que un texto), etc. Todo esto es relevante y
por ello normalmente sabremos qué tipo de datos contiene el fichero y cómo están ordenados antes de
acceder a él. No es lo mismo guardar "3246" como número tipo Integer que como cadena de
caracteres. Un tipo Integer ocupa 2 bytes y tiene una "clave" para su lectura, mientras que como
caracteres cada cifra ocupa un byte y se lee como si de texto se tratara.
Un asunto a considerar es si la información está contenida en campos de longitud predefinida.
Consideremos un archivo donde se almacenan los nombres, números de DNI y año de nacimiento de 3
personas. Podemos considerar diferentes casos:
a) Existen campos de longitud predefinida, que pueden carecer de información por no estar disponible.
Nombre: Alfredo
Nombre: Pedro
González A
p
aricio
Nombre: Ramón
González Pérez
__rendered_path__92__rendered_path__93
DNI: 79555444
DNI:
DNI: 79666444
__rendered_path__95__rendered_path__96__rendered_path__92__rendered_path__93
Año de nacimiento:
Año de nacimiento:
Año de nacimiento:
__rendered_path__95__rendered_path__96__rendered_path__92__rendered_path__93
1975
1966
1981
__rendered_path__98__rendered_path__99__rendered_path__95__rendered_path__96
__rendered_path__98__rendered_path__99
__rendered_path__98__rendered_path__99
__rendered_path__85
En el fichero físico la información la guardamos en hojas preimpresas donde cada apartado tiene una
__rendered_path__86
longitud disponible para escribir en él. En el fichero informático la información la guardamos en
__rendered_path__1__rendered_path__85__rendered_path__86__rendered_path__85__rendered_path__86
© 2006-2029 aprenderaprogramar.com

Page 97
Image_1184_0
Instrucción leer e instrucción guardar. Introducción a archivos con VB.
__rendered_path__3
registros (un registro equivale a una hoja del fichero físico), constando cada registro de 3 campos
(campo "Nombre", campo "DNI" y campo "Año de nacimiento"). Los campos serían por ejemplo:
Nombre: tipo texto 25 caracteres de longitud.
DNI: tipo entero largo (Long).
Año de nacimiento: tipo entero (Integer).
Cada registro ocupa 25 + 4 +2 = 29 bytes. Si tenemos tres registros el fichero ocupa 29 * 3 = 87 bytes,
independientemente de que los datos realmente existan o no, ya que el espacio se encuentra
disponible para albergar un dato.
b) La información no está en campos de longitud predefinida.
Pedro González Aparicio. 1966.
Alfredo Pérez Pérez. 79555444. 1975.
Ramón González Pérez. 79666444.
1981.
__rendered_path__67
__rendered_path__68
En el fichero físico la información la guardamos en hojas donde escribimos los datos disponibles para
cada persona. En el fichero informático la información la guardamos en líneas (cada línea equivale a la
información disponible de una persona) sabiendo que cada línea puede tener información de uno o
varios aspectos (nombre, DNI y edad) y una longitud variable.
No sabemos cuántos bytes nos ocupa cada línea ni cuántos bytes nos ocupa el fichero. No sabemos en
qué posición se encuentra una información dada porque no tenemos referencias de situación. Ante
ello, optamos por hacer una lectura tipo "texto" en la que un número de 8 cifras nos va a requerir 8
bytes frente a los 4 bytes que supondrían como tipo Long.
__rendered_path__1
© 2006-2029 aprenderaprogramar.com

Page 98
Image_1184_0
Instrucción leer e instrucción guardar. Introducción a archivos con VB.
__rendered_path__3
c) La información no está en campos de longitud predefinida pero se dispone de información referente
a su ubicación.
Alfredo Pérez Pérez
Pedro González Aparicio
Ramón González Pérez
79555444
1975
1966
79666444
1981
Página 1 líneas 1 a 3
Página 2 líneas 1 a 2
Página 3 líneas 1 a 3
__rendered_path__76
__rendered_path__77
En el fichero físico la información la guardamos en hojas indexadas, donde cada dato dispone de un
__rendered_path__76
localizador. Por ejemplo, en la página 3 línea 3 encontramos el dato correspondiente al año de
__rendered_path__77
nacimiento de Ramón González. En el fichero informático la información la guardamos por bytes,
__rendered_path__105
sabiendo que cada tipo de dato ocupa un número de bytes determinado. Así si guardamos Importe:
__rendered_path__77
3235, podríamos hacerlo ocupando 11 bytes desglosados en 9 bytes (uno por carácter, incluidos los
espacios) asociados a "Importe:" como tipo texto + 2 bytes (para un tipo Integer) asociados al número
3235.
También podríamos guardarlo todo como tipo texto ocupando 13 bytes.
Una vez guardada la información, podríamos recuperarla indicándole al ordenador: Extrae como tipo
texto los bytes comprendidos entre 1 y 9 y como número los bytes comprendidos entre 10 y 11.
Hemos tratado de introducir, a través de la analogía con un fichero físico, enfoques básicos para la
comprensión y gestión de ficheros informáticos. La problemática, como se comprenderá, es muy amplia
al intervenir numerosos factores (directorios, unidades de disco, sobreescritura de archivos, borrado
accidental de datos, etc.) y posibilidades (datos ordenados, parcialmente ordenados o desordenados,
diversidad de tipos de datos, tramos de ficheros con registros y campos, etc.).
Nosotros estudiaremos simplificadamente cómo podemos gestionar ficheros con Visual Basic.
Próxima entrega: CU00328A
Acceso al curso completo en aprenderaprogramar.com -- > Cursos, o en la dirección siguiente:
http://www.aprenderaprogramar.com/index.php?option=com_content&view=category&id=37&Itemid=61
__rendered_path__1__rendered_path__74
© 2006-2029 aprenderaprogramar.com

Page 99
Image_1219_0
Acceso a ficheros con Visual Basic. Acceso secuencial, aleatorio, binario.
__rendered_path__3
ACCESO A FICHEROS CON VISUAL BASIC. ACCESO SECUENCIAL, ALEATORIO, BINARIO
Visual Basic nos permite el acceso a ficheros a través de la instrucción Open. El acceso a un fichero
puede ser:
a) Acceso secuencial: orientado a su uso en archivos donde la información está dispuesta como tipo
texto.
b) Acceso aleatorio: orientado a su uso en archivos con datos contenidos en registros de longitud fija,
que a su vez pueden estar subdivididos en campos. Un campo puede contener un valor numérico o
ser tipo texto.
c) Acceso binario: permite guardar datos con el orden y estructura que se desee, siendo posible
acceder a ellos conociendo la posición (número de byte) en que se encuentran.
Al existir distintas formas de acceso, se habla de "archivos secuenciales", "archivos aleatorios" y
"archivos binarios", aunque esta terminología debe tomarse con precaución. Es decir, un "archivo
binario" hace referencia a un archivo donde habitualmente guardamos y extraemos datos usando el
acceso binario. Sin embargo, podríamos usar este archivo con otro tipo de acceso. En resumen, un
archivo es "información" y la información puede reordenarse, cambiar, manipularse de distintas
maneras, etc. Usar un tipo de acceso en un momento dado no obliga a usarlo siempre, aunque así
pueda ser.
En la analogía fichero físico - fichero informático, las equivalencias aproximadas serían las de:
Archivo secuencial = La información no está en campos de longitud predefinida.
Archivo aleatorio = Existen campos de longitud predefinida, que pueden carecer de información por
no estar disponible.
Archivo binario = La información no está en campos de longitud predefinida pero se dispone de
información referente a su ubicación.
Repetimos que todo es lo suficientemente complejo como para que sea difícil dar definiciones exactas.
Nosotros vamos a estudiar únicamente una forma de extraer y guardar datos de un fichero secuencial a
través de instrucciones simples. El resto de instrucciones y posibilidades de acceso quedará indicado
con una lista de términos para que el lector profundice en ellos si más adelante lo estima oportuno.
Próxima entrega: CU00329A
Acceso al curso completo en aprenderaprogramar.com -- > Cursos, o en la dirección siguiente:
http://www.aprenderaprogramar.com/index.php?option=com_content&view=category&id=37&Itemid=61
__rendered_path__1
© 2006-2029 aprenderaprogramar.com

Page 100
Image_1247_0
Open, Close, Freefile. Write# y Input#. Ejemplos de uso.
__rendered_path__4
OPERAR CON FICHEROS
Es frecuente necesitar guardar información en ficheros o recuperar información desde ficheros con
Visual Basic. La forma de hacerlo en general es “ Abrir -- > Operar -- > Cerrar”, pero la sintaxis concreta
a utilizar depende de la versión de Visual Basic que estemos empleando:
Para las versiones menos recientes de Visual Basic: describimos a continuación cómo debe procederse.
Para las versiones más recientes de Visual Basic: consulta la entrega CU00329A-2 de este curso
(http://www.aprenderaprogramar.com/index.php?option=com_content&view=category&id=37&Itemid=61).
__rendered_path__22
Nos vamos a centrar en describir de forma práctica como podemos operar con ficheros con el
propósito de generar programas que nos permitan ver aplicaciones algorítmicas interesantes. No vamos
a explicar todas las posibles formas de operar con ficheros ni todas las instrucciones relacionadas.
OPEN, CLOSE, FREEFILE. INSTRUCCIONES WRITE# Y INPUT#. EJEMPLOS DE USO.
Para manipular información de un fichero, por ejemplo guardar datos en él o leer datos desde él, lo
primero que hemos de hacer es abrir el fichero. El proceso a seguir es:
Abrir el fichero Manipular datos (extraer, guardar, modificar, etc.) Cerrar el fichero
Open Manipular datos Close
A su vez, cada vez que accedemos a un fichero usamos un número como identificador. Podemos
considerar que el identificador es una línea de teléfono o canal entre el ordenador y el fichero. Así, para
establecer una llamada (abrir un fichero) tenemos que buscar una línea que esté libre. El número de
líneas es grande, pero no infinito. Por tanto, podemos abrir muchos archivos al mismo tiempo, pero no
todos los que queramos.
La sintaxis que emplearemos será la siguiente:
__rendered_path__74
Open [ruta de acceso] For [tipo de acceso] As [número de archivo]
__rendered_path__73__rendered_path__76
·
__rendered_path__65__rendered_path__75
·
__rendered_path__65__rendered_path__73
·
__rendered_path__65
Close
__rendered_path__64__rendered_path__65
__rendered_path__65
Open: es la instrucción que da lugar a la apertura del fichero.
__rendered_path__1__rendered_path__77__rendered_path__74__rendered_path__77__rendered_path__76
© 2006-2029 aprenderaprogramar.com

Page 101
Image_1247_0
Open, Close, Freefile. Write# y Input#. Ejemplos de uso.
__rendered_path__4
Ruta de acceso: es la ruta del archivo que queremos abrir para manipular. Se entiende que dicho
archivo se encuentra en una unidad de disco (por ejemplo C:\problema3.dat corresponde al fichero
problema3.dat que se encuentra en la unidad de disco C:). Si el archivo no existe al tratar de abrirlo
para escribir datos será creado automáticamente, pero si tratamos de abrirlo para extraer datos
aparecerá el mensaje “Error 53: Archivo no encontrado”.
For [tipo de acceso]: indica qué acceso utilizamos para manipular el fichero. Vamos a considerar
únicamente ficheros secuenciales, con lo que el tipo de acceso podrá ser Output (para escribir datos en
ficheros, eliminando la información previa que pudiera existir), Append (para escribir datos,
conservando la información previa contenida en el fichero) ó Input (para leer datos contenidos en un
fichero).
As [número de archivo]: indicará el "número de línea" que vamos a emplear para la comunicación.
Estableceremos un número de línea utilizando la función FreeFile, que devuelve un tipo Integer que
indica el siguiente canal disponible para usar un Open.
Close: da lugar al cierre del fichero y a que el número de archivo o línea de comunicación quede libre
para una posterior ocasión.
Concretando la escritura nos quedamos con:
a) Escritura de datos en archivo secuencial (no conserva información contenida en archivo).
Image_1273_0
Canal = Freefile
Open "C:\misdatos.dat" For Output As Canal
·
·
·
Close
Image_1272_0
b) Escritura de datos en archivo secuencial (conserva información contenida en archivo).
__rendered_path__77
Image_1271_0
Canal = Freefile
Open "C:\misdatos.dat" For Append As Canal
·
·
·
Close
Image_1270_0
c) Lectura de datos de un archivo secuencial.
__rendered_path__86
Image_1269_0
Canal = Freefile
Open "C:\misdatos.dat" For Input As Canal
·
·
·
Close
__rendered_path__1Image_1272_0__rendered_path__94
© 2006-2029 aprenderaprogramar.com

Page 102
Image_1247_0
Open, Close, Freefile. Write# y Input#. Ejemplos de uso.
__rendered_path__4
Ya tenemos definido cómo abrimos y cerramos la comunicación con un archivo. Ahora tenemos que ver
cómo manipulamos los datos. Para ello nos valemos de las instrucciones Write# y Input#. Existen
distintas variantes para el uso de estas instrucciones. Vamos a considerar únicamente el caso de
escritura y extracción de una variable por línea. La sintaxis que emplearemos será:
a) Para escribir en el fichero:
__rendered_path__26
Write #[Número de archivo], [Dato a escribir]
__rendered_path__22__rendered_path__25__rendered_path__28
__rendered_path__23__rendered_path__27
El dato a escribir puede ser un texto entrecomillado, un valor numérico o una variable numérica o tipo
__rendered_path__25
texto.
__rendered_path__29
__rendered_path__26
b) Para extraer datos del fichero:
__rendered_path__29
Input #[Número de archivo], [Nombre de variable]
__rendered_path__28
El nombre de variable ha de corresponder a una variable tipo texto o tipo numérico que habremos
__rendered_path__38__rendered_path__25__rendered_path__41
declarado previamente. Es ideal saber qué tipo de dato contiene el fichero para hacer una extracción
__rendered_path__39__rendered_path__42__rendered_path__28
usando una variable adecuada. Si no dispusiéramos de esta información podríamos usar variables tipo
__rendered_path__25
Variant, pero no es lo más deseable.
__rendered_path__29
Consideremos un programa a modo de ejemplo (ver el código incluido a continuación al mismo tiempo
__rendered_path__41
que se leen las explicaciones):
__rendered_path__29
El código comienza con la declaración de las variables que van a intervenir en el programa. Se asignan
__rendered_path__28
valores a las variables Encabezado (tipo texto) y Dato(1), (2) y (3) (tipo Integer). El valor de Canal se
establece a través de FreeFile, con lo que hay una asignación automática de "línea de comunicación". A
continuación se abre el archivo C:\misdatos.dat (en caso de que no existiera previamente el archivo es
creado) para escritura (Output). A través de Write# se escriben cuatro líneas y se cierra la
comunicación.
Se vuelve a abrir comunicación para lectura de datos (Input), se asignan los datos a las variables
Textoextraido y Datoextraido(1), (2) y (3) y se cierra la comunicación.
__rendered_path__1
© 2006-2029 aprenderaprogramar.com

Page 103
Open, Close, Freefile. Write#
La información extraída del archivo se
Si abrimos directamente el archivo
que apreciamos es el siguiente:
© 2006-2029 aprenderaprogramar.com
__rendered_path__4
Image_1247_0
y Input#. Ejemplos de uso.
Image_1285_0
Rem Curso Visual Basic aprenderaprogramar.com
Option Explicit
Dim Canal%, i%
Dim Encabezado As String
Dim Dato(3) As Integer
Dim Datoextraido(3) As Integer
Dim Textoextraido As String
Private Sub Form_Load()
Show
Encabezado = "Datos de pesos en kgs"
Dato(1) = 322
Dato(2) = 112
Dato(3) = 567
Canal = FreeFile
Open "C:\misdatos.dat" For Output As Canal
Write #Canal, "Datos de pesos en kgs"
Write #Canal, Dato(1)
Write #Canal, Dato(2)
Write #Canal, Dato(3)
Close Canal
Canal = FreeFile
Open "C:\misdatos.dat" For Input As Canal
Input #Canal, Textoextraido
Input #Canal, Datoextraido(1)
Input #Canal, Datoextraido(2)
Input #Canal, Datoextraido(3)
Close Canal
Label1.Alignment = 2
Label1.FontBold = True
Label1 = vbCrLf & Textoextraido & vbCrLf & vbCrLf
For i = 1 To 3
Label1 = Label1 & Datoextraido(i) & vbCrLf
Next i
Image_1270_0
muestra en pantalla, donde aparece:
__rendered_path__38__rendered_path__48
Datos de pesos en kgs.
__rendered_path__39
__rendered_path__31__rendered_path__38
322
__rendered_path__33
112
__rendered_path__33
567
__rendered_path__1__rendered_path__30__rendered_path__33__rendered_path__33__rendered_path__40__rendered_path__41__rendered_path__40__rendered_path__38
C:\misdatos.dat con un visor como el bloc de notas, el contenido

Page 104
Image_1247_0
Open, Close, Freefile. Write# y Input#. Ejemplos de uso.
__rendered_path__4
__rendered_path__16
"Datos de pesos en kgs."
__rendered_path__17
322
__rendered_path__9__rendered_path__16
112
__rendered_path__11
567
__rendered_path__8__rendered_path__13
La escritura mediante Write# de valores tipo texto queda delimitada por un entrecomillado que es
__rendered_path__13
eliminado en el momento de la extracción.
__rendered_path__18
__rendered_path__19
El tamaño del archivo es de 40 bytes desglosados en:
__rendered_path__18
23 bytes al texto de la primera línea.
__rendered_path__16
2 bytes al salto de línea y retorno de carro de la primera línea.
3 bytes a la segunda línea.
2 bytes al salto de línea y retorno de carro de la segunda línea.
3 bytes a la tercera línea.
2 bytes al salto de línea y retorno de carro de la tercera línea.
3 bytes a la cuarta línea.
2 bytes al salto de línea y retorno de carro de la cuarta línea.
Se comprueba lo indicado en relación al acceso secuencial: a pesar de guardar variables tipo Integer, el
espacio ocupado no es el correspondiente a este tipo de variables (2 bytes) sino el equivalente a que
fueran un texto en el archivo (1 byte por carácter).
__rendered_path__16
Ex isten numerosos términos para el manejo de ficheros que no vamos a abordar.
__rendered_path__76
Algunos términos tienen distinto significado o efecto en función del tipo de acceso a fichero
__rendered_path__74__rendered_path__16
que se utilice o en función de la versión de Visual Basic que se utilice.
__rendered_path__77
La señal de Final de Archivo (EOF) nos resultará útil para ex traer datos desde un archivo hasta llegar al
__rendered_path__77
final del mismo (punto donde finalizan los datos) la estudiaremos en el apartado correspondiente a
__rendered_path__78__rendered_path__103__rendered_path__104__rendered_path__105
"Herramientas de programación con Visual Basic".
__rendered_path__81__rendered_path__106
__rendered_path__81
__rendered_path__82
__rendered_path__84
Próxima entrega: CU00329A-2 y CU00330A
__rendered_path__84
Acceso al curso completo en aprenderaprogramar.com -- > Cursos, o en la dirección siguiente:
__rendered_path__78
http://www.aprenderaprogramar.com/index.php?option=com_content&view=category&id=37&Itemid=61
__rendered_path__1__rendered_path__81__rendered_path__81__rendered_path__78__rendered_path__81__rendered_path__81__rendered_path__87__rendered_path__16__rendered_path__76__rendered_path__16__rendered_path__90__rendered_path__90__rendered_path__101__rendered_path__107__rendered_path__108__rendered_path__109__rendered_path__110
© 2006-2029 aprenderaprogramar.com

Page 105
Image_1304_0
StreamWriter y StreamReader. Write y Read. Ejemplos.
__rendered_path__4
OPERAR CON FICHEROS
Es frecuente necesitar guardar información en ficheros o recuperar información desde ficheros con
Visual Basic. La forma de hacerlo en general es “ Abrir -- > Operar -- > Cerrar”, pero la sintaxis concreta
a utilizar depende de la versión de Visual Basic que estemos empleando:
Para las versiones menos recientes de Visual Basic: consulta la entrega CU00329A-1 de este curso
(http://www.aprenderaprogramar.com/index.php?option=com_content&view=category&id=37&Itemid=61)
__rendered_path__20
Para las versiones más recientes de Visual Basic: describimos a continuación cómo debe procederse.
Nos vamos a centrar en describir de forma práctica como podemos operar con ficheros con el
propósito de generar programas que nos permitan ver aplicaciones algorítmicas interesantes. No vamos
a explicar todas las posibles formas de operar con ficheros ni todas las instrucciones relacionadas.
ABRIR UN FICHERO PARA ESCRIBIR EN ÉL
Para manipular información de un fichero, en concreto para guardar datos en él, lo primero que hemos
de hacer es abrir el fichero. El proceso a seguir es:
Abrir el fichero --> Manipular datos (borrar lo existente y escribir, o añadir a continuación de lo
existente) --> Cerrar el fichero
Open --> Manipular datos --> Close
La sintaxis que emplearemos será la siguiente:
__rendered_path__63
Dim nombreInterno As New System.IO.StreamWriter("RutaDelFichero", TrueoFalse)
__rendered_path__62__rendered_path__65
·
__rendered_path__54__rendered_path__64
·
__rendered_path__54__rendered_path__62
·
__rendered_path__54
nombreInterno.Close()
__rendered_path__53__rendered_path__54
nombreInterno: es el nombre que queramos darle a la representación interna que va a usar el
__rendered_path__54
programa del fichero. No es el nombre del fichero propiamente dicho, sino un nombre elegido por
__rendered_path__66
nosotros para referirnos al fichero.
__rendered_path__63
System.IO.StreamWriter: es el tipo de objeto que el programa va a usar internamente para guardar la
__rendered_path__66
información asociada a un fichero que se abre para escritura (write).
__rendered_path__65
RutaDelFichero:
indica
la
ruta
en
que
se
localiza
el
fichero.
Por
ejemplo
“C:\Users\Lenovo\Desktop\misdatosnet.dat” es una ruta. Si no especificamos una ruta completa sino
una ruta como “misdatosnet.dat” el fichero se guardará en el directorio por defecto que esté
empleando Visual Basic.
__rendered_path__1
© 2006-2029 aprenderaprogramar.com

Page 106
Image_1304_0
StreamWriter y StreamReader. Write y Read. Ejemplos.
__rendered_path__4
TrueoFalse: valor booleano donde especificamos si queremos tener activada (True) la identificación del
juego de caracteres con que está codificado el archivo, o no tenerla activada (False). Nosotros
mantendremos este parámetro como False.
Dim NombreInterno As New…: es la sintaxis con la que creamos el objeto que representa a nuestro
fichero.
Concretando la escritura damos a continuación ejemplos prácticos:
a) Escritura de datos en archivo secuencial (creará el archivo si no existe).
Image_1318_0
Dim myFileToWrite As New System.IO.StreamWriter("C:\Users\Asus\Desktop\misdatosnet.dat", False)
·
·
·
myFileToWrite.Close()
Image_1317_0
__rendered_path__66
ABRIR UN FICHERO PARA LEER INFORMACIÓN DESDE ÉL
Para extraer información de un fichero, en concreto para recuperar datos desde él, lo primero que
hemos de hacer es abrir el fichero. El proceso a seguir es:
Abrir el fichero --> Manipular datos (extraer información existente) --> Cerrar el fichero
Open --> Manipular datos --> Close
La sintaxis que emplearemos será la siguiente:
__rendered_path__44
Dim nombreInterno As New System.IO.StreamReader("RutaDelFichero", TrueoFalse)
__rendered_path__43__rendered_path__46
·
__rendered_path__36__rendered_path__45
·
__rendered_path__36__rendered_path__43
·
__rendered_path__36
nombreInterno.Close()
__rendered_path__35__rendered_path__36
nombreInterno: es el nombre que queramos darle a la representación interna que va a usar el
__rendered_path__36
programa del fichero. No es el nombre del fichero propiamente dicho, sino un nombre elegido por
__rendered_path__47
nosotros para referirnos al fichero.
__rendered_path__44
System.IO.StreamReader: es el tipo de objeto que el programa va a usar internamente para guardar la
__rendered_path__47
información asociada a un fichero que se abre para extracción de datos (lectura, read).
__rendered_path__46
RutaDelFichero:
indica
la
ruta
en
que
se
localiza
el
fichero.
Por
ejemplo
“C:\Users\Lenovo\Desktop\misdatosnet.dat” es una ruta. Si no especificamos una ruta completa sino
una ruta como “misdatosnet.dat” el fichero se guardará en el directorio por defecto que esté
empleando Visual Basic.
__rendered_path__1
© 2006-2029 aprenderaprogramar.com

Page 107
Image_1304_0
StreamWriter y StreamReader. Write y Read. Ejemplos.
__rendered_path__4
TrueoFalse: valor booleano donde especificamos si queremos tener activada (True) la identificación del
juego de caracteres con que está codificado el archivo, o no tenerla activada (False). Nosotros
mantendremos este parámetro como False.
Dim NombreInterno As New…: es la sintaxis con la que creamos el objeto que representa a nuestro
fichero.
Concretando la escritura damos a continuación ejemplos prácticos:
Lectura de datos en archivo secuencial (habrá un error si el archivo no existe).
Image_1328_0
Dim myFileToWrite As New System.IO.StreamWriter("C:\Users\Asus\Desktop\misdatosnet.dat", False)
·
·
·
myFileToWrite.Close()
Image_1327_0
__rendered_path__60
Ya tenemos definido cómo abrimos y cerramos la comunicación con un archivo. Ahora tenemos que ver
cómo manipulamos los datos.
ESCRITURA EN FICHEROS
Para escribir en ficheros disponemos de varias instrucciones o posibilidades. Vamos a explicar una
forma sencilla de escribir sobre ficheros, basadas en los métodos Write para escribir datos, o WriteLine,
para escribir datos línea a línea.
La sintaxis que emplearemos para escribir línea a línea en el fichero será:
__rendered_path__39
nombreInterno.WriteLine (datoAEscribir)
__rendered_path__35__rendered_path__38__rendered_path__41
Donde nombreInterno es el nombre interno que estamos usando en nuestro programa como
__rendered_path__36__rendered_path__40
representación simbólica del fichero y datoAEscribir es aquello que queremos escribir en el fichero
__rendered_path__38
(podrá ser un texto entrecomillado, o una variable alfanumérica o numérica. En el caso de una variable,
__rendered_path__42
en el fichero se escribirá el contenido de la variable).
__rendered_path__39
La sintaxis que emplearemos para escribir sin diferenciar líneas será:
__rendered_path__42
nombreInterno.Write (datoAEscribir)
__rendered_path__41
__rendered_path__1__rendered_path__53__rendered_path__54__rendered_path__38__rendered_path__39__rendered_path__40__rendered_path__38__rendered_path__41__rendered_path__56__rendered_path__39__rendered_path__56__rendered_path__41
© 2006-2029 aprenderaprogramar.com

Page 108
Image_1304_0
StreamWriter y StreamReader. Write y Read. Ejemplos.
__rendered_path__4
EXTRAER DATOS DE FICHEROS
Para extraer información desde ficheros disponemos de varias instrucciones o posibilidades. Vamos a
explicar una forma sencilla de escribir sobre ficheros, basándonos en los métodos Read para leer datos
carácter a carácter, o ReadLine, para extraer el contenido de líneas completas.
La sintaxis que emplearemos para extraer línea a línea en el fichero será:
__rendered_path__20__rendered_path__21
variableDondeExtraemos = nombreInterno.ReadLine ()
__rendered_path__17__rendered_path__22__rendered_path__23
Donde variableDondeExtraemos es el nombre de la variable donde va a quedar almacenada la
__rendered_path__18__rendered_path__20
información contenida en la línea del fichero. Si sabemos el tipo de información contenida en el fichero
__rendered_path__24
podemos extraer al tipo de variable adecuada. Por ejemplo, un número entero podremos extraerlo a
__rendered_path__21
una variable Integer, o un texto a una variable tipo String. nombreInterno es el nombre interno que
__rendered_path__24
estamos usando en nuestro programa como representación simbólica del fichero. No siempre habrá
__rendered_path__23
que extraer el contenido a una variable. Por ejemplo podríamos escribir MsgBox (“Extraido “ &
nombreInterno.ReadLine(), o usarlo de diferentes maneras sin guardar la información en una variable.
No obstante, hemos preferido escribirlo de esta manera porque es el uso más habitual.
La sintaxis que emplearemos para extraer carácter a carácter será:
__rendered_path__46
variableDondeExtraemos = variableDondeExtraemos & chr(nombreInterno.Read ())
__rendered_path__43__rendered_path__20__rendered_path__23
El método Read nos devuelve el valor entero que representa el carácter extraído desde el fichero. Por
__rendered_path__44__rendered_path__47
ejemplo a la letra A le corresponde el número 65. Para obtener el carácter A desde el número
__rendered_path__20
correspondiente escribimos chr(65). En este caso la sintaxis que hemos indicado es para añadir a una
__rendered_path__24
variable tipo String un carácter extraido desde el fichero. Este no es la única forma posible de utilizar el
__rendered_path__46
método Read(), es sólo un ejemplo. Normalmente la extracción carácter a carácter irá combinada con el
__rendered_path__24
uso de bucles.
__rendered_path__23
Consideremos un programa a modo de ejemplo (ver el código indicado a continuación al mismo tiempo
que se lee la explicación):
El código comienza con la declaración de las variables que van a intervenir en el programa. Se asignan
valores a las variables Encabezado (tipo texto) y Dato(1), (2) y (3) (tipo Integer). A continuación se abre
el archivo en la ruta especificada (en caso de que no existiera previamente el archivo es creado) para
escritura (usamos un StreamWriter). A través del método WriteLine se escriben cuatro líneas y se cierra
la comunicación con el método Close().
Se vuelve a abrir comunicación para lectura de datos (usamos un StreamReader), se asignan los datos a
las variables Textoextraido y Datoextraido(1), (2) y (3) y se cierra la comunicación.
Ejecuta este programa (haz las adaptaciones que sean necesarias en lo relativo a la ruta en tu
computador o a la versión de Visual Basic que estés empleando) y comprueba que se crea el archivo
con el contenido esperado.
__rendered_path__1
© 2006-2029 aprenderaprogramar.com

Page 109
Image_1304_0
StreamWriter y StreamReader. Write y Read. Ejemplos.
__rendered_path__4
Image_1335_0
REM Curso Visual Basic aprenderaprogramar.com
Option Explicit On
Public Class Form1
Dim Encabezado As String
Dim Dato(3) As Integer
Dim Datoextraido(3) As Integer
Dim Textoextraido As String
Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles
MyBase.Load
Dim myFileToWrite As New
System.IO.StreamWriter("C:\Users\Toshiba\Desktop\misdatosnet.dat", False)
Encabezado = "Datos de pesos en kgs"
Dato(1) = 322
Dato(2) = 112
Dato(3) = 567
myFileToWrite.WriteLine(Encabezado & " (Ejemplo de operación con ficheros)")
myFileToWrite.WriteLine(Dato(1))
myFileToWrite.WriteLine(Dato(2))
myFileToWrite.WriteLine(Dato(3))
myFileToWrite.Close()
Dim myFileToRead As New
System.IO.StreamReader("C:\Users\Toshiba\Desktop\misdatosnet.dat", False)
Textoextraido = myFileToRead.ReadLine()
Datoextraido(1) = myFileToRead.ReadLine()
Datoextraido(2) = myFileToRead.ReadLine()
Datoextraido(3) = myFileToRead.ReadLine()
myFileToRead.Close()
Label1.Font = New Font("Arial", 12, FontStyle.Bold)
Label1.TextAlign = ContentAlignment.MiddleCenter
Label1.Text = vbCrLf & Textoextraido & vbCrLf & vbCrLf
For i = 1 To 3
Label1.Text = Label1.Text & Datoextraido(i) & vbCrLf
Next i
End Sub
End Class
Image_1317_0
__rendered_path__42
La información extraída del archivo se muestra en pantalla, donde aparece:
__rendered_path__20
Datos de pesos en kgs (Ejemplo de operación con ficheros)
__rendered_path__21
__rendered_path__13__rendered_path__20
322
__rendered_path__15
112
__rendered_path__15
567
__rendered_path__12__rendered_path__15
Si abrimos directamente el archivo misdatosnet.dat con un visor como el bloc de notas, el contenido
__rendered_path__15
que apreciamos es el siguiente:
__rendered_path__22
Datos de pesos en kgs (Ejemplo de operación con ficheros)
__rendered_path__23
322
__rendered_path__22
112
__rendered_path__20
567
__rendered_path__28__rendered_path__29__rendered_path__20
__rendered_path__1__rendered_path__31__rendered_path__33__rendered_path__33__rendered_path__36__rendered_path__20__rendered_path__37__rendered_path__38__rendered_path__37__rendered_path__20
© 2006-2029 aprenderaprogramar.com

Page 110
Image_1304_0
StreamWriter y StreamReader. Write y Read. Ejemplos.
__rendered_path__4
El tamaño del archivo es de 75 bytes desglosados de forma aproximada en:
58 bytes al texto de la primera línea.
2 bytes al salto de línea y retorno de carro de la primera línea.
3 bytes a la segunda línea.
2 bytes al salto de línea y retorno de carro de la segunda línea.
3 bytes a la tercera línea.
2 bytes al salto de línea y retorno de carro de la tercera línea.
3 bytes a la cuarta línea.
2 bytes al salto de línea y retorno de carro de la cuarta línea.
Se comprueba lo indicado en relación al acceso secuencial: a pesar de guardar variables tipo Integer, el
espacio ocupado no es el correspondiente a este tipo de variables (2 bytes) sino el equivalente a que
fueran un texto en el archivo (1 byte por carácter).
__rendered_path__56
Ex isten numerosos términos para el manejo de ficheros que no vamos a abordar.
__rendered_path__57
Algunos términos tienen distinto significado o efecto en función del tipo de acceso a fichero
__rendered_path__54__rendered_path__56
que se utilice o en función de la versión de Visual Basic que se utilice.
__rendered_path__58
La señal de Final de Archivo (EOF) nos resultará útil para ex traer datos desde un archivo hasta llegar al
__rendered_path__58
final del mismo (punto donde finalizan los datos) la estudiaremos en el apartado correspondiente a
__rendered_path__59__rendered_path__85__rendered_path__87__rendered_path__88
"Herramientas de programación con Visual Basic".
__rendered_path__62__rendered_path__86
__rendered_path__62
__rendered_path__63
__rendered_path__65
__rendered_path__65
Próxima entrega: CU00330A
__rendered_path__59
Acceso al curso completo en aprenderaprogramar.com -- > Cursos, o en la dirección siguiente:
__rendered_path__62
http://www.aprenderaprogramar.com/index.php?option=com_content&view=category&id=37&Itemid=61
__rendered_path__1__rendered_path__62__rendered_path__59__rendered_path__62__rendered_path__62__rendered_path__68__rendered_path__56__rendered_path__57__rendered_path__56__rendered_path__71__rendered_path__71__rendered_path__83__rendered_path__89__rendered_path__90__rendered_path__91__rendered_path__92
© 2006-2029 aprenderaprogramar.com

Page 111
Image_1357_0
Ejercicios ejemplo leer datos desde ficheros con Visual Basic.
__rendered_path__4
EJERCICIO Nº 1 EJEMPLO LEER FICHERO EN VISUAL BASIC Y HACER CÁLCULOS SENCILLOS.
Crear el código que dé respuesta al siguiente problema planteado: Un operario de una fábrica recibe
cada cierto tiempo un depósito cilíndrico de dimensiones variables, que debe llenar de aceite a través
de una toma con cierto caudal disponible. Se desea crear un programa que le indique cuánto tiempo
transcurrirá hasta el llenado del depósito. El caudal disponible se considera estable para los tiempos
que tardan los llenados de depósitos y se encuentra almacenado en un archivo del ordenador,
figurando el dato en litros por minuto.
Nota: considerar que el caudal disponible se encuentra en el archivo caudal.dat. Suponer que el archivo
caudal.dat se encuentra en la unidad de disco C: (o en aquella ruta que se prefiera), y que el valor de
caudal disponible en litros por minuto que proporciona es 112.
SOLUCIÓN
Antes de ejecutar el programa habremos creado el archivo caudal.dat que contendrá un número que
representa el valor de caudal.
El código a plantear será diferente según la versión de Visual Basic que estemos utilizando:
a) Para versiones menos recientes de Visual Basic: usaremos la gestión de ficheros basada en las
instrucciones Open, Write, Freefile, Write#, Input#, etc.
b) Para las versiones más recientes de Visual Basic usaremos la gestión de ficheros basada en
StreamReader, StreamWriter, Write, Read, WriteLine y ReadLine.
Nosotros vamos a exponer el código necesario tanto para versiones menos recientes como para
versiones más recientes de Visual Basic (aunque dependiendo de la versión de Visual Basic que estés
utilizando es posible que necesites hacer pequeñas adaptaciones).
Comenzaremos creando un nuevo proyecto al que añadiremos tres labels (los dos primeros para indicar
un mensaje de petición de datos de diámetro y altura y el tercero para mostrar resultados), dos textbox
para que el usuario introduzca los datos de diámetro y altura, y finalmente un botón que el usuario
deberá pulsar una vez introducidos los datos para obtener los resultados.
__rendered_path__1
© 2006-2029 aprenderaprogramar.com