En primer lugar el código, siempre que sea posible y haya en el listado de
etiquetas Geshi, el lenguaje para el mismo, procede colocarlo dentro de tales etiquetas... para que resulte cómodo leer y mantenga al menos el formato de la indentación.
O manualmente... (quitando los espacios se convierte en las etiquetas BBcode)
[ code = vb ] tu código aquí
[ / code ]Line input, lee una linea entera es decir hasta que encuentre un salto d elínea, sea la cantidad de bytes que sea. Por lo que solo resulta indicado en ciertas situaciones:
- Se pretende leer texto, por tanto leer cada vez una línes es adecuado, porque a priori, nos e conoce el tamaño de cada línea.
- Los datos están fuertemente formateados. En tal caso, el usuario se supone conocer correctamente la estructura y la forma de 'desguazar' (parse), dicha línea en las variables que proceda.
- Cualquier otra situación, pero solo cuando hay un único dato en cada línea (que no requiere un parsingm ás allá de la asignación).
Luego,
Line input, lee 'string', cadenas de texto... de ahí el error que te arroja, puesto que tu (seguramente) intentas volcarlo en un tipo integer.
Antes de eso, con input es más procedente cuando se conoce muy bien el formato que compone el fichero y éste tiene (o puede tener) distintos tipos...
Así algo como:
Dim numVertices as byte
Dim Vertices() as single
dim canal as integer
dim Ruta as string
' Abrir el fichero...
ruta = "tu ruta al fichero deseado..."
canal = Freefile
open ruta for input as #canal
' leer datos
input #canal,,numVertices
if (numVertices >0)
redim vertices(0 to numVertices-1)
input #canal,, vertices
else
'... algún mensaje de error si procede...
end if
close #canal
Que viene a decir... primero se lee la cantidad de vertices que es un byte (es decir un valor entre 1 y 255) y la siguiente lectura leerá, tantos valores de tipo single como indique...
Esto es porque hay un formato reconocido para el fichero que se conoce, y por tanto se aplicó al escribir y eél mismo es adecuado para leer.
No puedes escribir 10 bytes y luego pretender leer 12.
Las variables Azar, Azar1... y 'contador' están declarados como 'integer', luego por cada uno se leen 2 bytes.
EOF, detectará correctamente el final del fichero, siempre que una lectura cumpla una de estas dos condiciones:
A - se lee 1 único byte cada vez en el bucle.
B - Se leen los bytes que sean, pero congruentes al tamaño. Esto es, si se guardaron 60 bytes, puedo leer en cada ciclo, 2, o en cada ciclo 3, o en cada ciclo, 4 o en cada ciclo, 5, 10, 12, 15, 20, 30, 60... porque todos ellos son submúltiplos de 60
Si el fichero tiene 60 bytes y en cada ciclo se leen 7 bytes, al llegar al 8º ciclo, he leído 56 bytes (7*8), luego en el siguiente ciclo, al intentar leer 7 bytes, puésto que solo restan 60-56 = 4, saltará el error...
En el caso 'A', solo interesa cuando se sepa que es precisamente así como se quiere leer byte a byte, porque el tipo de datos de destino son bytes, o bien cuando es uno mismo quien procederá a componer el tipo que proceda. Ahora leer byte a byte es lento.
En el caso 'B', interesa cuando uno tiene que leer datos de forma más o menos compleja, aunque si hay un 'patrón' sería mejor crear una estrcutura (type), y leer con una sola variable todo el contenido d ela estructura, es decir 'record a record'...
Cierto problema con 'input' es que es 'exigente, es decir requiere que la lista de variables leída estén en el mismo orden y sean del mismo tipo que se escribieron, es decir si fueras a leer un entero donde se escribió una cadena, el entero devolvería 0.
Es más conveniente, para evitar ciertas complejidades para quienes no se leen nada de documentación leer y escribir en 'binary' mode... ya que lee y escribe bytes al tipo que lee, no guarda ninguna info del tipo que se guarda, luego es perfectamente sencillo guardar un tipo long (4 bytes) y luego leerlo como bytes, como integer como byte e integer, como long, incluso como cadena.
'....
dim k as long, j as integer, i as byte, b as boolean, s as string, ib() as byte
' Escribimos un valor de tipo long = 4 bytes.
Open ruta for binary as #canal
k = 1145323841
put #canal,,k
debug.print "Escrito el tipo long con valor: " & cstr(k)
close #canal
' Leemos un tipo long = 4 bytes.
k= 0
canal = freefile
open ruta for binary as #canal
get #canal,, k
debug.print "Leido el tipo long con valor: " & cstr(k)
close #canal
debug.print
' Leemos un tipo integer 2 veces (2+2)=4 bytes.
canal = freefile
open ruta for binary as #canal
get #canal,, j
debug.print "Leido el tipo integer con valor: " & cstr(j)
get #canal,, j
debug.print "Leido otrol tipo integer con valor: " & cstr(j)
close #canal
debug.print
' Leemos un tipo integer y byte 2 veces (2+1+1)=4 bytes.
canal = freefile
open ruta for binary as #canal
get #canal,, j
debug.print "Leido el tipo integer con valor: " & cstr(j)
get #canal,, i
debug.print "Leido el tipo byte con valor: " & cstr(i)
get #canal,, i
debug.print "Leido otro tipo byte con valor: " & cstr(i)
close #canal
debug.print
' Leemos un tipo integer y byte 2 veces (2+1+1)=4 bytes.
canal = freefile
open ruta for binary as #canal
get #canal,, j
debug.print "Leido el tipo integer con valor: " & cstr(j)
get #canal,, i
debug.print "Leido el tipo byte con valor: " & cstr(i)
get #canal,, i
debug.print "Leido otro tipo byte con valor: " & cstr(i)
close #canal
debug.print
' Leemos un tipo integer y boolean (2+2)=4 bytes.
canal = freefile
open ruta for binary as #canal
get #canal,, j
debug.print "Leido el tipo integer con valor: " & cstr(j)
get #canal,, b
debug.print "Leido el tipo boolean con valor: " & cstr(b)
close #canal
debug.print
' Leemos los mismos, al revés tipo boolean e integer (2+2)=4 bytes.
canal = freefile
open ruta for binary as #canal
get #canal,, b
debug.print "Leido el tipo boolean con valor: " & cstr(b)
get #canal,, j
debug.print "Leido el tipo integer con valor: " & cstr(j)
close #canal
debug.print
' Leemos un tipo byte a byte, 4 veces (1+1+1+1)=4 bytes.
canal = freefile
open ruta for binary as #canal
get #canal,, i
debug.print "Leido el tipo byte con valor: " & cstr(i)
get #canal,, i
debug.print "Leido otro byte con valor: " & cstr(i)
get #canal,, i
debug.print "Leido otro byte con valor: " & cstr(i)
get #canal,, i
debug.print "Leido otro byte con valor: " & cstr(i)
close #canal
debug.print
' Leemos un tipo byte y 3 más en un array (1+1+1+1)=4 bytes.
canal = freefile
open ruta for binary as #canal
get #canal,, i
debug.print "Leido el tipo byte con valor: " & cstr(i)
redim ib(0 to 2) ' dimensionar el array a un tamaño igual o menor a lo que reste en el fichero.
get #canal,, ib
debug.print "Leido un array de 3 bytes con valores: ", cstr(ib(0)), cstr(ib(1)), cstr(ib(2))
close #canal
debug.print
' Leemos un tipo string de 3 caracteres (1+1+1+1)=4 bytes.
canal = freefile
open ruta for binary as #canal
s= space$(4) ' dimensionar el string... si no es un string nulo ""
get #canal,, i
debug.print "Leido el tipo byte con valor: " & cstr(i)
redim ib(0 to 2)
get #canal,, ib
debug.print "Leido un array de 3 bytes con valores: ", cstr(ib(0)), cstr(ib(1)), cstr(ib(2))
close #canal
debug.print
Nota que cada vez hemos abierto y cerrado el fichero... no es estrictamente necesario, bastaría con reposicionar el curso de lectura al comienzo:
el acceso aleatorio a un fichero en modo binario, es reposicionando el cursor donde convenga
Seek(canal), 1 ' reposiciona el curso al comienzo del fichero.
Seek(canal),( lof(canal) -20) ' reposiciona el curso al final del fichero, -20 bytes, dará error si esa posición sale negativa (el fichero tiene menos de 20 bytes)
También se puede preguntar por la posición actual... por ejemplo para guardarla, leer datos y volver a ese mismo punto por segunda vez.
k = Seek(canal)
Es posible tener más de un cursor apuntando al mismo fichero... uno podría estar leyendo de una cabecera de datos, mientras el otro canal apunta a los datos que el registor leído en la cebecera indicare (probablemente previo cálculo)
canal1 = freefile
open ruta for binary as #canal1
canal2 = freefile
open ruta for binary as #canal2
Nota también que es preferible usar la sentencia 'freefile' para obtener un canal libre, que usar una constante directamente... cuando peres con proyectos de cierta complejidad, no puedes tener control de 'números', Freefile devuelve siempre un canal no usado que se asigna a una variable, que identifica únivocamente al fichero concreto... si además la variable tiene un nombre más específico, mejor: canalPrecios (por ejemplo, para un fichero cuyo contenido son precios), canalClientes (por ejemplo para un fichero cuyo contenido son registros con los datos de clientes)
Nota que en modo binario, se lee un solo dato (variable) cada vez... input, permite leer una lista, es parte de lo que determina si usar un modo u otro, pero es muy dependiente del modo en que se escribió.
... en cualquier caso, acude a la documentación de VB6, que es muy completa, lleva el cursor al keyword del lenguaje de tu interés y pulsa 'F1', la ayuda aparece siempre pulsando la tecla de función: 'F1', pero si está encima de un keyword, busca el mismo... y la propia documentación suele contener ejemplos.
Hay que practicar, pero lo correcto es aprender documentándose. Practicar sin documentación, supone emplear 20 veces más de tiempo para aprender, algo que leyendo unos párrafos, se aprende en 15 minutos y se practca en 1 hora... con solo práctica puedes dedicarle días, y todavía surgirán errores y dudas que uno no termina de comprender y es seguro, que quedarán lagunas...(detalles que jamás se llega a conocer).
Autor
En línea
