Acceso
a ficheros aleatorios
|
Realizamos
programas para la gestión de empresas. Empresas medianas y
pequeñas. Programas de contabilidad, cartera de pedidos
clientes proveedores, facturación control de albaranes,
tesorería cartera de cobros y pagos y estadísticas.
Nuestro
agradecimiento a todos los que por unas causas o por otras
visitan nuestra web. Gestión de empresas PYMES. Curso de
programación de Visual Basic.
|
Habrás notado que ya no aparecen
los links al principio de esta entrega, ello se debe a que he
añadido una nueva página, desde la cual puedes linkar con todas
las entregas, además de poder ver una lista de las
"palabras" tratadas en todas las entregas aparecidas, así
como en que entrega(s) apareció esa palabra, no es nada
"preciso", pero intentaré ir "depurándolas".
La intención es que puedas saber de un vistazo en que entrega se ha
tratado y... espero hacerlo pronto, en cual de ellas es en la que se
ha explicado, porque una cosa es que se use la palabra y otra
diferente que se explique...
Como digo, es sólo un primer
intento, que espero ir mejorando, para que te sea fácil encontrar
la palabra o tema que te interesa.
Decirte que esa lista la he
"sacado" con una utilidad, que seguramente pondré pronto
en mis páginas y que trata de mostrar cada una de las
"palabras" que aparecen en los ficheros que se procesen...
además de esa utilidad, he tenido que ir leyéndome cada una de las
palabras y tomando nota, por lo tanto alguna se me ha podido
escapar...
Bueno, ya vale... vamos al tema de
la presente entrega:
Los ficheros aleatorios (Random)
Pues eso, ahora le toca el turno a
los ficheros aleatorios. Ya te comenté que este tipo de fichero se
suele usar cuando todos los datos que incluye tienen la misma
longitud. Normalmente a cada uno de los datos guardados se les llama
registro. Todos los registros tienen la misma longitud, o al menos
deberían tenerla... no, no es una contradicción, pero si quieres
que funcione bien, deben ser iguales, porque el sistema que usa el
VB para acceder a cada uno de los registros es una simple
operación:
Posición_Actual = (Número_Registro -1) *
Tamaño_del_Registro + 1
Pero no te asustes... tú no tienes que hacer ningún cálculo... de
eso se encarga el Visual Basic.
Para acceder a los datos de los
ficheros abiertos como Random, vienen como anillo al dedo, (si es
que el anillo te encaja bien), los tipos definidos por el usuario,
aunque cualquier cadena serviría para esta tarea.
Antes de empezar a manejar ficheros
de acceso aleatorio, es importante planear lo que vamos a almacenar
en ellos; siempre se debe planear, pero en esta ocasión es un poco
más importante, más que nada porque, como ya he dicho, tenemos la
obligación de saber la longitud de los datos, (al menos de cada uno
de los registros), a almacenar. Ya que esa longitud, (la de cada
registro), debemos especificarla a la hora de abrir el fichero.
Un pequeño detalle antes de
continuar, cuando abrimos un fichero secuencial para lectura
(Input), el Visual Basic o el sistema operativo, sólo nos permite
leer datos de ese fichero, es decir: no podemos leer y escribir al
mismo tiempo. Igualmente ocurre cuando lo abrimos para escritura
(Output), sólo que en esta ocasión sólo podemos escribir y no
leer. Sin embargo, con los ficheros abiertos como aleatorios
(Random) o binarios (Binary), una vez que el fichero esté abierto,
podemos leer o escribir indistintamente. Alguna ventaja teniamos que
tener... no iban a ser todo "obligaciones".
Sigamos con lo nuestro...
Veamos cómo, por fin, usar estos
ficheros:
Para verlo... nada mejor que con un ejemplo:
Primero definimos un tipo de datos,
en este caso vamos a guardar el nombre, edad y la cuenta de email de
unos colegas, por tanto emplearemos un tipo definido con estos tres
campos, veamos:
Private Type t_colegas
Nombre As String * 30
Edad As Integer
email As String * 50
End Type
Declaramos una variable de este
"nuevo" tipo de datos, que será la que usaremos para
acceder al fichero:
Dim unColega As t_colegas
Y abrimos el fichero:
Open "miscolegas.dat" For Random As nFic Len = Len(unColega)
El Len(unColega),
le está indicando al VB que la longitud de cada registro es la que
tenga ese tipo de datos.
No siempre hay que hacerlo así, podríamos asignar a una variable
esa longitud y usarla para abrir el fichero:
lenColega = Len(unColega)
Open "miscolegas.dat" For Random As nFic Len = lenColega
Lo que quiero dejar claro es que al
Visual Basic no le importa con qué variable accedemos al fichero,
sino que longitud tendrá esa variable, o si lo prefieres, cual
será la longitud de cada registro.
Por tanto, si sabemos que nuestro tipo de datos, (o lo que es lo
mismo: cada registro), tiene 82 bytes de longitud, podríamos usar
un string con esa longitud para acceder al fichero en cuestión y...
¡Toc, toc!
¡¡¡Guille!!!
¿Sí?
¿No
crees que te estás precipitando?
¿Yo? ¿Por qué?
Porque
estás hablando de acceder así o asao a los datos y aún no has
explicado cómo leer o escribir esos datos...
Pues... sí... es cierto... je...
Si no fuera por el otro Guille...
en fin...
Esto..., cuando quieras leer el
contenido de un registro en particular del fichero abierto, usa esta
instrucción:
Get #canal, num_registro,
variable_de_datos
Para escribir usa esta otra:
Put #canal, num_registro,
variable_de_datos
Es decir GET para
leer y PUT para escribir, en esto los ingleses lo
tienen más fácil, ya que al menos a ellos esas dos palabras tienen
algo de sentido...
Después de cualquiera de estas instrucciones se indica el número
de fichero (#canal), seguido por el número de
registro al que queremos acceder, (num_registro), y
por último la variable, (variable_de_datos), que
usamos para leer, (GET), los datos del disco o
almacenarlos en él (PUT)
Un detalle que tienes que tener
siempre presente al definir un tipo de datos para acceder a los
ficheros aleatorios: asegurate de que todas las cadenas contenidas
en ese tipo, sean de longitud fija; lo mismo si dentro del tipo usas
arrays, estos deben ser de índices constantes, es decir que estén
definidos al crear el tipo.
Todas estas "precauciones" se consiguen con datos
"estáticos", es decir que permanecen sin cambios, al
menos en lo que a tamaño se refiere. Los "dinámicos" son
los que pueden cambiar "dinámicamente" de tamaño.
Aclaremos estos puntos antes de continuar.
Una variable declarada de esta
forma:
Dim cadenaEstatica As String * 50
Siempre tendrá 50 caracteres, incluso si hacemos esta asignación:
cadenaEstatica = ""
Con esto no eliminamos las 50 celdas de memoria, sino que la
rellenamos de espacios...
Prueba con este código:
Crea un nuevo proyecto y añade esto en el Form_Load:
Private Sub Form_Load()
Dim cadenaEstatica As String * 50
Show
cadenaEstatica = "Hola"
Print cadenaEstatica & "Pepe"
cadenaEstatica = ""
Print cadenaEstatica & "Pepe"
Print
Print "Longitud de la cadena:"; Len(cadenaEstatica)
Print "Asc(cadenaEstatica) ="; Asc(cadenaEstatica)
End Sub
El resultado sería este:
Es decir que una cadena estática
(o de longitud fija), siempre tendrá el número de caracteres que
le indicamos al declararla.
Sin embargo una cadena dinámica sólo tendrá los caracteres que le
asignemos.
Prueba este código:
Private Sub Form_Load()
Dim cadenaDinamica As String
Show
cadenaDinamica = "Hola"
Print cadenaDinamica & "Pepe"
cadenaDinamica = ""
Print cadenaDinamica & "Pepe"
Print
Print "Longitud de la cadena:"; Len(cadenaDinamica)
Print "Asc(cadenaDinamica) ="; Asc(cadenaDinamica)
End Sub
Habrás obtenido algo parecido a
esto:
O sea "Illegal Function
Call", este error lo da al intentar conseguir el código ASCII
de la cadena... pero como la cadena está vacía... pues no hay nada
que obtener, por tanto: ¡¡¡Error al canto!!!
Aparte del error, te puedes fijar que "HolaPepe" sale
junto y que la longitud de la variable es cero.
Cuando asignamos una cadena vacía a un string dinámico, lo dejamos
"seco", es decir sin nada en el interior...
Lo mismo ocurre con los arrays, ya
sean de caracteres o numéricos.
Los estáticos siempre conservan el número de elementos, incluso
cuando se eliminan, (al menos eso es lo que parece), con Erase.
Aunque esto ya lo vimos, no está de más recordarlo: Al
"eliminar" con Erase un array dinámico,
lo eliminamos de la memoria, pero en los estáticos, simplemente
ponemos el contenido a cero, (o a cadenas vacías si son de cadenas
dinámicas).
Pruébalo:
Dim arrayEstaticoInteger(1 To 10) As Integer
Dim arrayEstaticoString(1 To 5) As String
Dim arrayDinamicoInteger() As Integer
Dim arrayDinamicoString() As String
Cuando se declaran los arrays con
el número de elementos que va a contener, siempre con constantes,
estos arrays son estáticos, porque siempre contendrán ese número
de elementos.
Sin embargo los dinámicos, se declaran sin decirles cuantos
elementos van a contener y después se usa Redim o Redim
Preserve para cambiar el número de elementos.
Veamos un ejemplo de un tipo
definido con un array estático:
Private Type t_colegas2
Nombre As String * 30
Edad As Integer
email(1 To 3) As String * 50
End Type
Aquí hemos definido un
"campo" email con un array de tres elementos.
Recuerda que aunque los tipos
definidos permitan tanto cadenas de longitud variable como arrays
dinámicos, si ese tipo se va a usar para acceder a datos de un
fichero aleatorio, su longitud siempre tiene que ser fija y
coincidir con la longitud que se indicó a la hora de abrir ese
fichero... si no tienes esta "precaución"... no
accederás con "fiabilidad" a los datos contenidos en ese
fichero... después no digas que no te advertí...
De todas formas, vamos a
comprobarlo...
Escribe este código en un form:
'Este código en las declaraciones del form
Option Explicit
Private Type t_colegas
Nombre As String * 30
Edad As Integer
email As String * 50
End Type
Dim unColega As t_colegas
Private Type t_colegaDinamico
Nombre As String
Edad As Integer
email As String
End Type
Dim unColegaDinamico As t_colegaDinamico
Private Sub Form_Load()
Dim nFic As Integer
nFic = FreeFile
Open "miscolegas.dat" For Random As nFic Len = Len(unColega)
'Asignamos los datos
With unColega
.Nombre = "Pepe"
.Edad = 22
.email = "pepe22@mundo.net"
End With
Put #nFic, 1, unColega
'ahora lo hacemos con el colega dinámico
With unColegaDinamico
.Nombre = unColega.Nombre
.Edad = unColega.Edad
.email = unColega.email
End With
'Aquí dará error:
Put #nFic, 2, unColegaDinamico
Close
End Sub
Ejecuta el programa y te
encontrarás con un "bonito" error número: 59 Bad Record
Length o La longitud de registro es incorrecta, si usas la versión
castellana del Visual Basic. Lo que nos quiere decir este error es
que no puedes grabar datos de una longitud diferente a la
especificada a la hora de abrir el fichero.
Pero... ¿por qué? si,
aparentemente, la longitud es la misma...
Pues eso, que sólo es en apariencia... si en la ventana
"Inmediato" escribes esto, saldrás de dudas:
Print len(uncolega); len(uncolegadinamico)
El resultado será este:
82 10
En el primer caso, el del
coleguilla normal, la longitud es la esperada: 82
Pero en nuestro amigo dinámico, la longitud es 10,
independientemente de que "en teoría" tenga almacenados
esos 82 caracteres del "estático". Lo que ocurre es que
al ser dinámico, el contenido de las variables de caracteres se
almacenan en otro sitio y lo único que hay en esas variables es un
"puntero" a la dirección de memoria en la que están los
datos almacenados... al menos ahora sabemos que una variable de
cadena de caracteres tiene una longitud de 4 bytes... creo que eso
ya lo vimos en la entrega número dos o tres... dónde hablamos de
lo que ocupa cada variable... los enteros (Integer) ocupan 2 bytes,
independientemente de cómo esté declarada la variable... lo mismo
ocurre con los otros datos numéricos.
Como te decía, si sabemos que la
longitud del registro es de 82 caracteres, podemos definir una
cadena de esa longitud y usarla para acceder a los datos.
Probemos esto otro:
Dim unaCadena As String * 82
'...
unaCadena = "Prueba de una cadena"
Put #nFic, 2, unaCadena
'...
Ahora si que funcionará.
Pero si esa variable está definida como String normal, no
funcionará...
Resumiendo: para
acceder a los registros de un fichero abierto como Random, las
variables usadas deben tener definida la longitud igual que el
tamaño especificado a la hora de abrirlo.
Un poco de complicación: Vamos a
ver un ejemplo, "ilustrativo" más que práctico.
Ya he comentado que con una cadena de longitud fija podemos acceder
a un registro. Ahora comprobarás lo "cómodo" que es usar
los tipos definidos. Pero este ejemplo lo pongo para que sepas cómo
se almacenan los datos numéricos en una cadena que se va a usar
para guardar datos en un fichero de acceso aleatorio.
Hemos "comprobado" que un Integer se almacena en dos
bytes... por tanto lo que se guarda en el disco es precisamente eso:
dos bytes. Cuando se usa un tipo definido, no te tienes que
preocupar de cómo se almacena, simplemente asignas el valor a la
variable numérica y del resto se ocupa el VB.
Viendo el ejemplo anterior, es
fácil almacenar un entero, si usamos un tipo definido, pero ¿cómo
lo haremos si la variable en la que se almacenará los datos es una
cadena de longitud fija?
Para ello debemos "desglosar" los datos en distintas
partes:
Para el Nombre usaremos los primeros 30 bytes de la cadena, para la
edad los dos siguientes, es decir: bytes 31 y 32, para el email
desde la posición 33 hasta la 82, o sea desde la 33 con 50 bytes de
longitud.
Si escribes esto:
Dim unaCadena As String * 82
Dim elNombre As String * 30
Dim laEdad As String * 2
Dim elEmail As String * 50
Dim nFic As Integer
Dim unaCadena As String * 82
Show
nFic = FreeFile
Open "miscolegas.dat" For Random As nFic Len = Len(unColega)
elNombre = "Pepe de 23 años"
laEdad = 23
elEmail = "Pepe23@mundo.net"
unaCadena = elNombre & laEdad & elEmail
Put #nFic, 2, unaCadena
Close nFic
No conseguirás el resultado
esperado... en lugar de 23 años, tendrá: ¡¡¡ 13106 !!! Dudo
mucho que llegue a conseguir esa edad... ni aún siendo un gnomo...
Si queremos guardar un número debemos convertirlo antes... el
problema es que "NO HAY FUNCIONES DE CONVERSIÓN"
Antes si que las había... cuando digo antes, me refiero al Basic
del MS-DOS.
Para cada tipo de dato numérico existían un par de funciones, una
para convertir el número en una cadena y el otro para convertir la
cadena en un número...
Y no me estoy refiriendo a las funciones que convierten los números
en letras y las cadenas en números... aunque pueda parecerte una
contradicción... no es lo mismo convertir un número en una cadena
normal que en una cadena para almacenar en el disco como si de un
número se tratase...
A saber, STR o CSTR convierten un
número en una cadena, es decir que si el número es 23, lo
convierten en "23" en el caso de CSTR y en " 23"
si se usa STR, fíjate en el espacio que hay antes del 2 en el
segundo caso.
Pero cuando se debe convertir un número en una cadena de 2 bytes...
la cosa cambia...
Y no te confundas... no pienses que si usas CSTR lo tienes
solucionado... porque en el ejemplo este de "23" está
claro... pero y si el número es 1998? Tendríamos una cadena de 4
caracteres...
Como te decía, en los tiempos del
MS-DOS, existían las funciones MKI$ y CVI para convertir los
números enteros; MKL$ y CVL para los enteros largos, MKS$ y CVS
para los "singles" y MKD$ y CVD para los Double. No
busques estas funciones... porque no están...
Aunque podemos fabricárnoslas... pero, como no es plan de
"romperse" el coco con una chorradilla de estas... sólo
vamos a usar el ejemplo de los números enteros.
¿Cómo se usarían?
En el ejemplo anterior haríamos esto:
elNombre = "Pepe de 23 años"
laEdad = Mki(23)
elEmail = "Pepe23@mundo.net"
unaCadena = elNombre & laEdad & elEmail
Put #nFic, 2, unaCadena
La función se haría así:
Private Function Mki(ByVal unInteger As Integer) As String
Dim sLoByte As String
Dim sHiByte As String
Dim iChar As Integer
iChar = unInteger \ 256
sHiByte = Chr$(iChar)
iChar = unInteger Mod 256
sLoByte = Chr$(iChar)
'Devolvemos el valor
Mki = sLoByte & sHiByte
End Function
Que complicación ¿verdad?
Pues como estas... muchas más... pero eso antes, en el MS-DOS...
desde que hay "mogollón" de espacio de almacenamiento...
he perdido de vista muchas de estas cosas de "manejo" de
números a "bajo nivel"...
Pero antes había que ahorrar cuantos bytes se pudieran...
La cuestión es que se divide el
número en dos partes, la alta que se consigue dividiendo el entero
entre 256 y la baja, que es el resto que queda... después de
haberlo dividido por 256... que de eso es de lo que se encarga el
MOD...
Después se convierten esos valores en dos bytes usando el CHR$...
se unen... y sin necesidad de agitarlo... conseguimos el
"batido" que queremos... por tanto, lo asignamos al valor
que devolverá la función... (recuerda que una función devuelve un
valor cuando se asigna ese valor a su nombre...)
Bien... un lío... ¿verdad?
Pues ahora más líos...
¿Cómo se asigna esto al revés? Es decir: ¿Cómo se convierte una
cadena de 2 bytes en un entero?
Con los tipos definidos no hay que hacer nada... ya sabes, que hace
la conversión automáticamente.
Pero si usamos una cadena de longitud fija... ya es otro cantar...
Vamos a ver la declaración de la
función "equivalente" al CVI del viejo Basic del MS-DOS:
Private Function Cvi(ByVal unaCadena As String) As Integer
Dim sLoByte As String
Dim sHiByte As String
sLoByte = Left$(unaCadena, 1)
sHiByte = Right$(unaCadena, 1)
'Devolvemos el valor
Cvi = Asc(sLoByte) + Asc(sHiByte) * 256
End Function
No voy a entrar en detalles, así
que paso a un ejemplo "completo" para ver estos
resultados.
Si vas a comprobar cómo "trabajan" alguna de estas
funciones usando "puntos de interrupción", es decir que
quieres que el VB se detenga en una línea determinada, (para ello
deberás posicionarte en la línea, que no debe ser un comentario, y
pulsar F9, al llegar a esa línea el Visual se detiene), deberás
cambiar la propiedad Autoredraw del form y ponerla a TRUE, de esta
forma el contenido del Form (el que se imprime dentro del
Form_Load), se mantiene...
'Esto escribelo en el Form_Load
Dim nFic As Integer
Dim unaCadena As String * 82
Dim laEdad23 As Integer
Show
laEdad23 = 23
nFic = FreeFile
Open "miscolegas.dat" For Random As nFic Len = Len(unColega)
'Asignamos los datos
With unColega
.Nombre = "Pepe"
.Edad = 22
.email = "pepe22@mundo.net"
End With
Put #nFic, 1, unColega
Dim elNombre As String * 30
Dim laEdad As String * 2
Dim elEmail As String * 50
elNombre = "Pepe de 23 años"
laEdad = Mki(laEdad23)
elEmail = "Pepe23@mundo.net"
unaCadena = elNombre & laEdad & elEmail
Put #nFic, 2, unaCadena
Get #nFic, 1, unColega
With unColega
Print
Print "Colega 1:"
Print .Nombre
Print .Edad
Print .email
End With
'Si se lee así, no hay problemas
Get #nFic, 2, unColega
With unColega
Print
Print "Colega 2:"
Print .Nombre
Print .Edad
Print .email
End With
'De esta manera está la cosa más complicada...
Get #nFic, 2, unaCadena
Print
Print "Colega 2:"
Print Mid$(unaCadena, 1, 30)
Print Cvi(Mid$(unaCadena, 31, 2))
Print Mid$(unaCadena, 33, 50)
Observa que aunque el segundo dato
se haya guardado usando una cadena de longitud fija, (unaCadena), se
puede leer tanto con un tipo definido, si es de la misma longitud,
claro, como con la cadena de longitud fija.
El problema es que tenemos que "desglosar" el contenido de
esa cadena... Recuerda que te comenté que cada uno de los
"campos" del registro ocupa un espacio determinado... o
sea que tienen una longitud fija... por eso hay que usar el Mid$,
para tomar cada uno de los "trozos" de esa cadena.
El Mid$ funciona de la siguiente
forma:
Mid$ (cadena, posición_de_inicio, numero_de_caracteres)
Lo que significa que devolverá el número de caracteres indicados
por numero_de_caracteres empezando por la
posición: posición_de_inicio. En caso de que no
se especifique el número de caracteres, devolverá toda la cadena
desde la posición indicada hasta el final de la misma.
Y ya que estamos con estas
funciones... voy a explicarte las dos usadas en la función CVI:
Left$ y Right$
El Left$ toma de una cadena los caracteres que se le indiquen,
empezando por la izquierda.
Right$ hace lo mismo, pero empieza a contar desde la derecha.
Unos ejemplos:
Left$("Hola Mundo", 4) devolverá "Hola",
es decir los 4 primeros caracteres.
Right$("Hola
Mundo", 4) devolverá "undo",
porque son los cuatro caracteres que hay a la derecha...
El Left$ se puede sustituir por
Mid$ de la siguiente forma:
Mid$("Hola Mundo", 1, 4) es decir:
empezando por el primer caracter, dame cuatro...
Sin embargo esto otro:
Mid$("Hola Mundo", 4) nos dará: "a
Mundo", o lo que es lo mismo: desde la posición
cuarta, todo lo que haya en la cadena.
Y si quieres imprimir cada uno de
los caracteres de una cadena, prueba esto:
Dim i As Integer
Dim unaCadena As String
unaCadena = "Hola Mundo"
For i = 1 To Len(unaCadena)
Print Mid$(unaCadena, i, 1)
Next
Lo que se hace aquí es un bucle
para cada uno de los caracteres de la cadena, esto se sabe con LEN,
que devuelve la longitud de una cadena y con el Mid$, vamos tomando
todos los caracteres de uno en uno. Ya que le decimos que nos
muestre el caracter que está en la posición i...
sólo muestra uno, porque esa es la cantidad que le indicamos que
nos devuelva...
¡UF! Creo que algunas veces se me
va la olla... y se me olvidan cosas que... creyendo que he
explicado... las uso...
En fin... la cuestión es que ahora sabes unas instrucciones
nuevas...
Y ya que estamos...
Veamos cómo se puede usar también MID$, lo que ocurre es que esta
"función" también es una "instrucción", al
igual que ocurría con INPUT, según se use delante o detrás del
signo igual, se convierte en función o en instrucción.
Ya sabes que una función devuelve
un valor y se puede usar en una expresión, pero una instrucción
"hace" algo y no devuelve ningún valor ni se puede usar
en una expresión.
En el ejemplo de guardar los
registros, se usaron tres variables para almacenar los datos en el
fichero:
Dim elNombre As String * 30
Dim laEdad As String * 2
Dim elEmail As String * 50
elNombre = "Pepe de 23 años"
laEdad = Mki(laEdad23)
elEmail = "Pepe23@mundo.net"
unaCadena = elNombre & laEdad & elEmail
Put #nFic, 2, unaCadena
Pues esto mismo se puede hacer de
esta otra forma:
Mid$(unaCadena, 1, 30) = "Prueba de una cadena"
Mid$(unaCadena, 31, 2) = Mki(laEdad23)
Mid$(unaCadena, 33, 50) = "pepe23@mundo.net"
Put #nFic, 2, unaCadena
Es decir, al igual que la función
con el mismo nombre, la instrucción MID$ sustituye en
"unaCadena" los caracteres indicados por el inicio y la
longitud por los que están después del signo igual...
Creo que me he pasado... bueno,
esto al final viene bien... ya que así tenemos otra entrega
"medio" preparada... ya que de la que tenía prevista de 7
páginas "manuscritas" sólo he usado 2 y poco más...
Para completar esta
"extraña" entrega... extraña por "no
prevista"... vamos a "rematarla" con unos ejercicios,
que en este caso serán de manejo de cadenas con las funciones que
acabamos de ver...
Los ejercicios:
1- Haz que se muestren los
caracteres de una cadena al revés.
Por ejemplo, si la cadena es "Hola Mundo", se deberá
imprimir: "odnuM aloH"
Que es útil si queremos hacer carteles para que se vean al derecho
al mirar por el retrovisor del coche... (por decir algo)
2- Usando esta misma
cadena, es decir "Hola Mundo", divídela en las dos
palabras.
Se supone que deberá servirte para cualquier frase, así que no
hagas nada "fijo".
Lo que tienes que hacer es devolver en una cadena todos los
caracteres hasta el primer espacio y el resto en otra cadena.
Para esto, si quieres, puedes usar el Left$ y el Mid$... al menos
para la primera palabra.
Y ya está... no te voy a complicar
más la vida... que ya vendrán complicaciones posteriores.
Pulsando en
este link tienes las soluciones.
Para terminar, sólo pedirte
disculpas por haberme/haberte "liado"... pero... eso es lo
que hay... 8-)
Y como no es plan de perder la
costumbre de pedirte que hagas un comentario de la entrega que acaba
de terminar... aquí tienes el
link para que me hagas saber que te ha parecido...
A estas alturas no tendría que recordarte que ese link
sólo es para hacer comentarios de esta entrega o del curso en
general... así que no te voy a decir que no aproveches el
link para hacerme consultas...
Nos vemos.
