Año nuevo, entrega nueva... je, je, no te
preocupes que no será así en las próximas... por tanto no tendrás que
esperar un año para ver el contenido de la entrega 6... (o casi, ya que desde
la anterior han pasado casi TRES meses... que se dice pronto... con razón se
hace uno viejo y ni te enteras... en fin...)
Te recomiendo que le eches un vistacillo al
Glosario, ya que he añadido cosas nuevas y
ampliado otras.
Como te comenté en la entrega anterior, vamos
a seguir con el tema de las variables.
Empezaremos con la parte más sencilla de lo que te tengo preparado para esta
quinta entrega:
Declarar varias variables en una misma
línea:
¿Que significa eso de declarar varias
variables en una misma línea?
Pues eso... declarar varias variables en una misma línea, o lo que es lo mismo,
con una misma instrucción Dim.
Por ejemplo, esta línea declara dos variables
del tipo Integer:
Dim a, b As
Integer
Pero esta otra, también:
Dim c As
Integer, d As
Integer
¿Cual es la diferencia?
Evidentemente que en la segunda línea indicamos dos veces el tipo de datos de
cada una de las variables, mientras que en la primera sólo lo especificamos una
vez.
Antes de entrar en detalles, apúntate esto:
Podemos declarar más de una variable en una instrucción DIM, si las variables
las separamos con una coma.
Es decir, hay que poner una coma entre cada variable que declaremos en la misma
línea y opcionalmente el tipo de datos... bueno, opcionalmente,
opcionalmente... no... ya que después de la última variable si que debemos
indicar el tipo de datos que tendrán todas las variables de esa línea... o casi,
según veremos un poco más abajo.
Declarar varios tipos de variables en una
misma línea:
Por supuesto que esta no es la única forma de
declarar varias variables en una misma línea, ya que puede ser que queramos
declarar variables de distintos tipos. En ese caso, hay que indicar junto a cada
variable el tipo de datos que queramos que tenga.
Mejor lo veremos con un ejemplo:
Dim i As
Integer, s As
String
En este caso, tenemos dos variables de dos
tipos distintos, cada una con su As tipo correspondiente, pero separadas
por una coma.
Pero si lo que pretendemos es que el que lea
nuestro código se "caliente" el coco intentando entenderlo... (por
decir algo), podemos complicar aún más la cosa:
Dim j, k As
Integer, s1, Nombre As
String, d1 As
Decimal
En esta ocasión, las variables j y k
son del tipo Integer, las variables s1 y Nombre del tipo String
y por último la variable d1 es de tipo Decimal.
Tipo de dato por defecto de las variables:
Si has tratado con alguna versión anterior de
Visual Basic, incluso del BASIC de MS-DOS, también estaba permitido hacer las
declaraciones de esa forma, pero en el caso de que no se indicara
explícitamente el tipo de datos, el Basic le asignaba el tipo de datos por
defecto.
En el caso de las versiones de MS-DOS y el VB1, el tipo de datos era Single, en
las versiones anteriores a vb.NET el tipo de datos predeterminado era Variant y,
si la cosa siguiera igual que en las versiones anteriores, (por suerte ya no es
así), en vb.NET, el tipo de datos sería Object. Aunque... si sólo declaras
una variable con Dim y no especificas el tipo (y tampoco sigues mis
recomendaciones), el tipo asignado será ese: Object.
En las declaraciones con las versiones anteriores al vb.NET existían unas
excepciones para que el tipo de datos predeterminado no fuese el que el
"compilador" imponía, pero no vamos a entrar en detalles, ya que no
vienen al caso y lo único que conseguiría sería complicarte la vida... aunque
si quieres saber a qué me refiero... échale un vistazo al Curso Básico de VB que
tengo en mis páginas (el Guille siempre aprovecha
cualquier ocasión para hacer publicidad).
Sigamos viendo cómo actuaría el vb.NET en el
caso de que hagamos algo como esto:
Dim z
Si no me has hecho caso... o se te ha olvidado poner lo de Option Strict On,
esa declaración sería válida y el tipo de datos de la variable z sería Object, es decir, seria lo mismo que hacer esto otro:
Dim z As
Object
Pero si, por otro lado, tienes puesto el Option
Strict en On, el vb.NET te diría que "nones", que eso no está
permitido.
Realmente nos mostraría un mensaje como este:
Option Strict requiere que todas las declaraciones de variables tengan una cláusula
'As'.
Con lo cual tendríamos que especificar el tipo
de datos que "realmente" queremos que tenga esa variable.
Como puedes comprobar... nos puede venir bien que de vez en cuando nos avisen de
que no estamos haciendo las cosas como debiéramos...
Una cosa que no está permitida al declarar
varias variables usando sólo un As Tipo, es la asignación de un valor
predeterminado.
Ya vimos en la entrega anterior de que
podíamos hacer esto para asignar el valor 15 a la variable N:
Dim N As
Integer = 15
Pero lo que no podemos hacer es declarar, por
ejemplo, dos variables de tipo Integer y "pretender" asignarle a una
de ellas un valor predeterminado (o inicial), por ejemplo:
Dim p, q As
Integer = 1
Eso daría el error: No se permite la inicialización explícita con varios
declaradores.
Por tanto deberíamos hacerlo de esta otra
forma:
Dim p As
Integer, q As
Integer = 1
O de esta otra:
Dim p1 As
Integer = 12, q1 As
Integer = 1
Aunque esto otro si que podemos hacerlo:
Dim n1 As
Integer = 12, n2, n3
As Integer
Es decir, si asignamos un valor al declarar una
variable, éste debe estar "explícitamente" declarado con un As Tipo
= valor.
Por tanto, esto otro también se puede hacer:
Dim n4 As
Integer = 12, n5, n6
As Integer,
n7 As Integer
= 9
Ya que las variables n5 y n6 se declaran con un
tipo de datos, pero no se asigna un valor inicial.
Por supuesto los tipos usados no tienen porque ser del mismo tipo:
Dim h1 As
Integer = 25, m1, m2
As Long,
s3 As String
= "Hola", d2, d3 As
Decimal
Pero... la recomendación es que no compliques
las declaraciones de las variables de esa forma...
Procura usar Dims diferentes para diferentes declaraciones, si no quieres
declarar cada variable con un Dim, al menos usa un Dim para cada tipo de
variable.
Por ejemplo el ultimo ejemplo quedaría más legible de esta otra forma:
Dim h1 As
Integer = 25
Dim m1, m2 As
Long
Dim s3 As
String =
"Hola"
Dim d2, d3 As
Decimal
Además de que es más "legible", es
más fácil de comprobar...
Ahora vamos a pasar a otro de los temas
propuestos para esta entrega:
La visibilidad (o alcance) de las variables:
¿Que significa eso de visibilidad (o alcance)
de una variable?
¿Quiere decir que al escribir una variable, ésta desaparezca de la vista?
A la última pregunta, la respuesta es: NO...
salvo que escribas con tinta invisible... 8-)
A la primera pregunta... es a la que debo dar respuesta, ya que de eso se
trata... ¿o no? pues eso...
Aunque la verdad es que a estas alturas del
curso, no sé si debería explicarlo... pero bueno, ya que está dicho...
apliquémonos el parche y vamos a ver cómo me defiendo... (eso,
que algunas veces por hablar de más, te pasan estas cosas...)
Si tienes el Visual Studio y has creado algún
proyecto, por ejemplo una aplicación de consola. Habrás visto que el código
que se crea es el siguiente:
Module Module1
Sub Main()
End Sub
End Module
Es decir, se crea un módulo llamado Module1 y un
procedimiento llamado Sub Main, que por otro lado es el que sirve como punto de
entrada al programa... aunque de esto aún no debes preocuparte y dejarlo
estar... ya te explicaré de que va todo esto... Por ahora sólo debes saber que
los procedimientos Sub son como instrucciones y cuando se usan en otras partes del
programa, se ejecuta el código que haya en su interior...
Lo que nos interesa es saber que hay dos "espacios" diferentes en los
que poder insertar las declaraciones de las variables:
Después de Module Module1 o después de Sub Main.
El código insertado entre Module y End Module, se dice que es
código a nivel de módulo, en este caso el único código posible es el de
declaraciones de variables o procedimientos.
El código insertado dentro del Sub y End Sub, se dice que es
código a nivel de procedimiento, en esta ocasión podemos poner lo que
queramos, además de declaraciones de variables.
Pues bien.
Si declaramos una variable a nivel de módulo, dicha variable estará disponible
en "todo" el módulo, incluido los procedimientos que pudiera haber
dentro del módulo.
Por otro lado, las variables declaradas dentro de un procedimiento, sólo serán
visibles dentro de ese procedimiento, es decir que fuera del
procedimiento no se tiene conocimiento de la existencia de dichas variables.
Veamos un pequeño ejemplo con dos
procedimientos:
Option Strict On
Module Module1
' Variable declarada a nivel de módulo
Dim n As Integer = 15
Sub Main()
' Variable declarada a nivel de procedimiento
Dim i As Long = 10
'
' Esto mostrará que n vale 15
Console.WriteLine("El valor de n es: {0}", n)
Console.WriteLine("El valor de i es: {0}", i)
Console.ReadLine()
End Sub
Sub Prueba()
' Esto mostrará que n vale 15
Console.WriteLine("El valor de n es: {0}", n)
' Esta línea dará error, ya que la variable i no está declarada
Console.WriteLine("El valor de i es: {0}", i)
Console.ReadLine()
End Sub
End Module
Te explico un poco:
Este módulo contiene dos procedimientos de tipo Sub, (los SUBs son como las
instrucciones, realizan una tarea, pero no devuelven un valor como lo harían
las funciones y las propiedades) (Guille, eso ya está
explicado en el Glosario, ¿es que pretendes que la entrega sea más larga?).
La variable n la hemos declarado a nivel de módulo, por tanto estará
visible en todo el módulo y por todos los procedimientos de ese módulo.
Dentro del procedimiento Main, hemos declarado la variable i, ésta sólo
estará disponible dentro de ese procedimiento.
Por eso al intentar usarla en el procedimiento Prueba, el vb.NET nos da un error
diciendo que la variable no está declarada.
Y a pesar de que está declarada, lo está pero sólo para lo que haya dentro
del procedimiento Main, por tanto en Prueba no se sabe que existe una variable
llamada i.
(je, je... seguro que ni tú, Guille, te has enterado de lo
que has explicado... Que sí, que es mu fácil... si
la variable i... ¡VALEEEE! que yo si que me
he enterado... así que calla y sigue, que ya queda poco)
Variables que ocultan a otras variables:
Ahora vamos a complicar la cosa un poquito
más:
Veamos el código y después te explico.
Option Strict On
Module Module1
' Variable declarada a nivel de módulo
Dim n As Integer = 15
Sub Main()
'
Console.WriteLine("El valor de n Main es: {0}", n)
'
Console.ReadLine()
End Sub
Sub Prueba()
Dim n As Long = 9547
'
Console.WriteLine("El valor de n en Prueba es: {0}", n)
'
Console.ReadLine()
End Sub
End Module
Este ejemplo me sirve para que compruebes que
una variable de nivel "superior" puede ser eclipsada por otra de un
nivel "inferior".
La variable n declarada a nivel de módulo estará visible en todos los
procedimientos del módulo, pero al declarar otra variable, también llamada n,
dentro del procedimiento Prueba, ésta última "eclipsa" a la variable
que se declaró a nivel de módulo y se usa la variable "local" en
lugar de la "global". Aunque sólo dentro del procedimiento Prueba, ya
que en el procedimiento Main si que se ve el valor de la variable declarada a
nivel de módulo, por la sencilla razón de que no hay ninguna variable
declarada dentro de Main con el mismo nombre. (elemental
mi querido Guille, algunas veces me sorprende tu lógica aplastante)
Una vez visto esto, podemos afirmar que:
Cuando se declara una variable dentro de un procedimiento, (Sub, función o
propiedad), esa variable "eclipsa" (u oculta) a otras variables que,
teniendo el mismo nombre, pudieran existir a nivel de módulo o a un nivel
"superior".
Por supuesto, si declaramos una variable dentro
de un procedimiento y no existe ninguna otra variable que tenga ese mismo
nombre, no ocultará nada... se supone que entiendes que esto es aplicable sólo
cuando existen variables con el mismo nombre. (lo dicho:
este Guille tiene una lógica aplastante... en fin...)
Las variables declaradas dentro de un
procedimiento se dicen que son "locales" a ese procedimiento y por
tanto sólo visibles (o accesibles) dentro del procedimiento en el que se ha
declarado.
En otra ocasión veremos más cosas sobre la
visibilidad de las variables y cómo podemos ampliar la "cobertura" o
el campo de visibilidad, para que puedan ser vistas en otros sitios... pero eso
en otra ocasión. (sí, déjalo ya, que es tarde y los Reyes
Magos nos van a pillar levantados...)
En la próxima entrega veremos más cosas, pero
será referente a lo que ya vimos en la entrega anterior, respecto a las
decisiones lógicas con IF/THEN y seguramente veremos cómo hacer bucles (o lo
que es lo mismo, hacer que una variable tome valores de forma automática y por
un número determinado de veces) y otras cosillas que a la larga nos serán de
utilidad en la mayoría de los programas.
Sólo me queda hacerte, (como espero que sea la
norma en todas las entregas), un "pequeño"
resumen de lo que hemos visto en esta entrega:
-Definición de varias variables de un mismo tipo con un sólo AS TIPO
-Cómo definir más de una variable con una misma instrucción DIM y poder
asignarle un valor inicial.
-Cómo definir más de una variable de diferentes tipos con una misma
instrucción DIM.
-Alcance o visibilidad de las variables a nivel de módulo o procedimiento y
-Cómo se pueden "ocultar" variables con el mismo nombre declaradas en
distintas partes del módulo.
Y esto es todo por hoy... mañana más...
(aunque viniendo del Guille, es una forma de hablar, no te lo tomes al pie de la letra...)
Nos vemos.
Guillermo
Nerja, 6 de Enero de 2002