Curso de iniciación a la programación con Visual Basic .NET

Entrega número cinco, (06/Ene/2002)
Publicada el 06/Ene/2002
Revisada el 24/Dic/2002

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