Operadores abreviados de asignación

Estos operadores simplifican la escritura de expresiones, facilitando la creación de nuestro código. El resultado empleando operadores abreviados en una expresión, es el mismo que utilizando la sintaxis normal, pero con un pequeño ahorro en la escritura de código. Cuando pruebe el lector estos ejemplos, ejecute por separado la sintaxis normal, y después la abreviada, para evitar resultados inesperados.

Operadores de concatenación: &, +

Estos operadores permiten unir dos o más cadenas de caracteres para formar una única cadena. Se recomienda el uso de & para facilitar la legibilidad del código y evitar ambigüedades. El uso de + puede dar lugar a equívoco, ya que en muchas situaciones no sabremos a primera vista si se está realizando una suma o concatenación. Ver Código fuente 59.

Sub Main()
Dim CadResulta As String
Dim Nombre As String
CadResulta = "esto es " & "una prueba"
Console.WriteLine("Variable CadResulta: {0}", CadResulta)
Nombre = "Juan"
CadResulta = Nombre & " Almendro"
Console.WriteLine("Variable CadResulta: {0}", CadResulta)
Console.ReadLine()

End Sub

Código fuente 59

Resta: -

Efectúa una resta entre dos números, o cambia el signo de un número (de positivo a negativo, y viceversa). Ver Código fuente 58.

Sub Main()

Dim Resultado As Integer

Dim Valor As Integer

Dim OtroValor As Integer

' resta de números

Resultado = 100 - 75

' cambiar a signo negativo un número

Valor = -50

' volver a cambiar el signo de un número,

' estaba en negativo, con lo que vuelve

' a positivo

OtroValor = -Valor

End Sub

Código fuente 58

Suma: + (Part 2)

Si cambiamos a continuación la configuración a Option Strict On, la siguiente operación que antes se ejecutaba, ahora provocará un error. Ver Código fuente 56.

' suma de variables
Cadena = "15"
Valor = 20
CadenaResulta = Cadena + Valor ' error

Código fuente 56

Para solucionar el problema debemos convertir explícitamente todos los operandos al mismo tipo de datos. Observe el lector que en esta situación, no se realiza una suma, sino una concatenación. Ver Código fuente 57.


' suma de variables
Cadena = "15"
Valor = 20
CadenaResulta = Cadena + CStr(Valor) ' devuelve: "1520"

Código fuente 57

A pesar de que el operador + permite concatenar tipos String, se recomienda el uso del operador específico de concatenación &, que veremos más adelante.

Suma: + (Part 1)

En función del tipo de dato de los operandos, este operador realiza una suma de números o una concatenación de cadenas de caracteres. Puede producirse un error dependiendo del tipo de dato del operando y la configuración de Option Strict. El Código fuente 55 muestra algunos ejemplos de suma y concatenación, con la instrucción Option Strict Off.

Sub Main()

Dim Resultado As Double

Dim Cadena As String

Dim Valor As Integer

Dim Nombre As String

Dim CadenaResulta As String

' suma de números

Resultado = 12 + 7 ' devuelve: 19

Resultado = 450 + 130 ' devuelve: 580

' concatenación de cadenas

Cadena = "hola " + "amigos" ' devuelve: "hola amigos"

' suma de variables

Cadena = "15"

Valor = 20

CadenaResulta = Cadena + Valor ' devuelve: "35"

' operaciones incorrectas

Valor = 25

Nombre = "Alfredo"

CadenaResulta = Valor + Nombre ' error

Resultado = Valor + Nombre ' error

End Sub

Código fuente 55

Resto: Mod

Divide dos números y devuelve el módulo o resto de la división. Ver Código fuente 54.

Dim Resultado As Double

Resultado = 10 Mod 3 ' devuelve: 1

Resultado = 100 Mod 27 ' devuelve: 19

Resultado = 38 Mod 4 ' devuelve: 2

Código fuente 54

División entera: \

Divide dos números, devolviendo como resultado un valor numérico entero. Ver Código fuente 53.

Dim Resultado As Integer

Resultado = 50 \ 3 ' devuelve: 16

Resultado = 250 \ 4 ' devuelve: 62

Código fuente 53

División real: /

Divide dos números, devolviendo un resultado con precisión decimal. Ver Código fuente 52.


Dim Resultado As Double
Resultado = 50 / 3 ' devuelve: 16.6666666666667
Resultado = 250 / 4 ' devuelve: 62.5

Código fuente 52

Por norma general, el valor devuelto será de tipo Double,. No obstante, si uno de los operandos es de tipo Single, el resultado será de tipo Single. De igual manera, si los dos operandos son del tipo de dato Decimal, el resultado también será un valor Decimal.

Multiplicación: *

Multiplica dos números. En el caso de que alguno de los operandos sea un valor nulo, se usará como cero. Ver Código fuente 51.

Dim Resultado As Double
Dim DatoSinValor As Integer

Dim Indefinido As Object
Resultado = 25 * 5 ' devuelve: 125
' la variable DatoSinValor no ha sido
' asignada, por lo que contiene cero
Resultado = 50 * DatoSinValor ' devuelve: 0
' la variable Indefinido no ha sido
' asignada, por lo que contiene Nothing
Resultado = 25 * Indefinido ' devuelve: 0
Resultado = 24.8 * 5.98 ' devuelve: 148.304

Código fuente 51

Potenciación: ^

Eleva un número a determinada potencia. Debemos situar el número base a la izquierda de este operador, mientras que el exponente lo situaremos a la derecha. Podemos realizar varias potenciaciones al mismo tiempo y utilizar números negativos. El valor devuelto será de tipo Double. Ver Código fuente 50.

Dim Resultado As Double
Resultado = 12 ^ 5 ' devuelve: 248832
Resultado = 2 ^ 3 ^ 7 ' devuelve: 2097152
Resultado = (-4) ^ 2 ' devuelve: 16

Código fuente 50

Operadores aritméticos

Efectúan el conjunto habitual de operaciones matemáticas.

Operadores

Los operadores son aquellos elementos del lenguaje que nos permiten combinar variables, constantes, valores literales, instrucciones, etc., para obtener un valor numérico, lógico, de cadena, etc., como resultado. La combinación de operadores con variables, instrucciones, etc., se denomina expresión, mientras que a los elementos integrantes de una expresión y que no son operadores, se les denomina operandos. 

En función de la complejidad de la operación a realizar, o del tipo de operador utilizado, una expresión puede ser manipulada a su vez como un operando dentro de otra expresión de mayor nivel. Los operadores se clasifican en las categorías detalladas a continuación, según el tipo de expresión a construir.

Arrays multidimensionales - III

Empleando For...Next usaremos la función UBound( ) ya comentada antes, con la particularidad de que al emplearla para arrays multidimensionales, deberemos pasarle en el segundo parámetro el número de dimensión del que vamos a extraer valores. Veamos un ejemplo en el Código fuente 49.

Dim Articulos(2, 3) As String
Dim Contador1 As Integer
Dim Contador2 As Integer
Articulos(0, 0) = "mesa"
Articulos(0, 1) = "silla"
Articulos(0, 2) = "sofá"
Articulos(0, 3) = "estante"
Articulos(1, 0) = "monitor"
Articulos(1, 1) = "teclado"
Articulos(1, 2) = "impresora"
Articulos(1, 3) = "grabadora"
Articulos(2, 0) = "coche"
Articulos(2, 1) = "tren"
Articulos(2, 2) = "barco"
Articulos(2, 3) = "bicicleta"
For Contador1 = 0 To UBound(Articulos, 1)
Console.WriteLine("Dimensión actual del array: {0}", Contador1)
For Contador2 = 0 To UBound(Articulos, 2)
Console.WriteLine("----Valor del elemento: {0}", Articulos(Contador1,
Contador2))

Next
Next

Código fuente 49

Arrays multidimensionales - II

Como acabamos de ver en el esquema de la figura, el primer número en la declaración del array: 2, indica la cantidad de dimensiones que tiene el array, y el segundo: 3, indica la cantidad de elementos que tendrá cada dimensión; ya que los arrays comienzan por cero, en este ejemplo se crea un array de tres dimensiones, y cada una de esas dimensiones tendrá cuatro elementos. El Código fuente 48 muestra la forma de declarar y asignar valores a un array multidimensional de estas características

Dim Articulos(2, 3) As String
Articulos(0, 0) = "mesa"
Articulos(0, 1) = "silla"
Articulos(0, 2) = "sofá"
Articulos(0, 3) = "estante"
Articulos(1, 0) = "monitor"
Articulos(1, 1) = "teclado"
Articulos(1, 2) = "impresora"
Articulos(1, 3) = "grabadora"
Articulos(2, 0) = "coche"
Articulos(2, 1) = "tren"
Articulos(2, 2) = "barco"
Articulos(2, 3) = "bicicleta"

Código fuente 48

Para recorrer los elementos de un array multidimensional utilizaremos los bucles For...Next o For Each...Next, que se explicarán en un tema más adelante. La diferencia entre utilizar una u otra técnica para manipular el contenido del array, reside en que con For...Next tenemos un mayor control de los elementos a manipular, mientras que con For Each...Next, al implementar internamente el proceso, irá tomando las primeras posiciones de cada una de las dimensiones del array, después las segundas, y así sucesivamente.

Arrays multidimensionales - I

Según el modo en que se organizan los valores en sus elementos, un array se puede clasificar en los siguientes tipos:
• Unidimensionales. Se trata de aquel array que tiene una única lista de valores, también denominada dimensión. Es el tipo de array con el que hemos trabajado hasta el momento.
• Multidimensionales. Consiste en un array que dispone de más de una lista de valores o dimensión.
Los arrays multidimensionales se representan en forma de tabla, con filas y columnas, tal y como muestra la Figura 64.

Figura 64. Representación gráfica de un array multidimensional.

Recorrer un array

Para recorrer todos los elementos de un array emplearemos la estructura de control For...Next, que ejecuta un bloque de código un número determinado de veces, y la función del lenguaje UBound( ), que devuelve el número correspondiente al índice superior del array pasado como parámetro. Ver Código fuente 47.

Sub Main()

' crear un array y rellenarlo con valores

Dim Nombres(3) As String

Nombres(0) = "Ana"

Nombres(1) = "Pedro"

Nombres(2) = "Antonio"

Nombres(3) = "Laura"

' recorrer el array y mostrar el contenido

' de cada uno de sus elementos

Dim Contador As Integer

For Contador = 0 To UBound(Nombres)

Console.WriteLine("Posición del array: {0}, valor: {1}", _

Contador, Nombres(Contador))

Next

Console.ReadLine()

End Sub

Código fuente 47

La estructura For...Next será explicada con más detalle en el apartado dedicado a las estructuras de control del lenguaje.

Modificación de tamaño

En función de si la cantidad de elementos de un array puede ser cambiada, los arrays se clasifican en los siguientes tipos: 

• Estáticos. Son aquellos que tienen un tamaño fijo y no se pueden modificar. 

• Dinámicos. Son aquellos cuya cantidad de elementos puede ser ampliada o reducida. 

En VB.NET todos los arrays son de tipo dinámico Para modificar el tamaño o número de elementos de un array, emplearemos la instrucción ReDim, seguida del array a modificar y el nuevo tamaño. En el Código fuente 45, modificamos el tamaño de un array, añadiéndole dos elementos.

' array con 4 elementos: de 0 a 3
Dim Nombres(3) As String
' asignar valores al array
Nombres(0) = "Ana"
Nombres(1) = "Pedro"
Nombres(2) = "Antonio"
Nombres(3) = "Laura"
' ampliamos el array con 6 elementos: de 0 a 5
ReDim Nombres(5)

Código fuente 45

ReDim no toma el array existente y modifica su número de elementos, sino que internamente crea un nuevo array con el número de elementos indicado, por lo que se pierden los valores del array previo. Para solucionar este inconveniente, debemos utilizar junto a ReDim, la palabra clave Preserve. Con ello, los valores existentes en el array a modificar son conservados. Ver Código fuente 46.

' ampliamos el array con 6 elementos: de 0 a 5
' y los valores de los elementos que hubiera, son conservados
ReDim Preserve Nombres(5)

Código fuente 46

Asignación y obtención de valores

Para asignar y obtener valores de los elementos de un array, actuaremos igual que para una variable normal, pero empleando además el índice entre paréntesis junto al nombre de la variable, para indicar qué posición queremos manipular. Ver Código fuente 44.

Sub Main()

' array con 4 elementos: de 0 a 3

Dim Nombres(3) As String

' asignar valores al array

Nombres(0) = "Ana"

Nombres(1) = "Pedro"

Nombres(2) = "Antonio"

Nombres(3) = "Laura"

' obtener valores de un array

Dim ValorA As String

Dim ValorB As String

ValorA = Nombres(1) ' Pedro

ValorB = Nombres(3) ' Laura

' mostrar los valores obtenidos del array

Console.WriteLine("Variables: ValorA --> {0}, ValorB --> {1}", ValorA, ValorB)

Console.ReadLine()

End Sub

Código fuente 44

Declaración - II

Al declarar un array, todos sus valores son del mismo tipo de dato. Si necesitamos que dichos valores sean de tipos diferentes, debemos declarar el array como tipo Object, ya que al ser este el tipo de dato genérico en el entorno de .NET, nos permitirá asignar valores de distintos tipos al array.

Figura 63. Declaración de un array.

Declaración - I

Para declarar un array actuaremos prácticamente igual que para declarar una variable normal, con la diferencia de que utilizaremos los paréntesis junto al nombre de la variable, para indicar que se trata de un array, y opcionalmente, dentro de los paréntesis, indicaremos el número de elementos de que inicialmente va a constar el array. 

También es posible, asignar valores a los elementos en el mismo momento de su declaración. Debemos tener en cuenta a la hora de establecer el número de elementos, que el primer índice de un array es el cero, por lo que al ser creado, el número real de elementos en un array será el especificado en la declaración más uno. La Figura 63 muestra un esquema de la declaración de un array. A continuación vemos unos ejemplos de creación de arrays en el Código fuente 43.

Sub Main()
' array sin elementos
Dim Colores() As String
' array con 4 elementos vacíos: de 0 a 3
Dim Nombres(3) As String
' array con 3 elementos, cuyos valores asignamos
' en el momento de la declaración del array
Dim Frutas() As String = {"Manzana", "Naranja", "Pera"}

End Sub

Código fuente 43

Arrays

Como se indicó en la descripción general de los componentes del lenguaje, un array es un tipo de dato compuesto, formado por un conjunto de elementos del mismo tipo de dato, al que se le asigna un identificador para poder reconocerlo en el código del programa. También se les denomina matriz o vector, aunque en este texto emplearemos el término array de forma genérica.
A cada elemento del array se accede mediante un índice, que indica el número de posición que ocupa dicho elemento dentro del array. Si tuviéramos que representar un array gráficamente, podríamos hacerlo mediante un conjunto de casillas, en cada una de las cuales se encontraría un elemento del array. Cada casilla tendría un número (índice) que identificaría de forma única su posición. Ver Figura 62.

Figura 62. Representación gráfica de un array.

En este apartado vamos a realizar una introducción a los arrays y su uso de forma básica. Puesto que los tipos de datos pueden ser tratados al mismo tiempo como objetos en el lenguaje VB.NET, cubriremos algunos aspectos avanzados sobre arrays al llegar a la programación con objetos.

Depuración del código en ejecución II

Para ejecutar el programa en modo de depuración pulsaremos [F8], o seleccionaremos el menú Depurar + Ir a instrucciones. Cualquiera de estas acciones iniciarán el programa dentro del contexto del depurador, deteniendo la ejecución en la primera línea de código ejecutable, destacada en color amarillo. La línea marcada en amarillo es la que está a punto de ejecutarse; para ejecutarla y pasar a la siguiente línea pulsaremos de nuevo [F8], y así sucesivamente hasta llegar a la última línea del programa, donde el depurador finalizará la ejecución. Podemos ver de forma inmediata el valor de una variable simplemente situando el cursor del ratón sobre ella, lo que mostrará el contenido en una viñeta informativa. Ver Figura 60

Figura 60. Visualizando el contenido de una variable durante la depuración.

Podemos también ver con detalle el valor que van adquiriendo las variables a lo largo de la ejecución, abriendo la ventana Locales del depurador, mediante el menú Depurar + Ventanas + Locales, o pulsando [CTRL + ALT + V, L]. Ver Figura 61.

Figura 61. Ventana Locales del depurador.

Si en cualquier momento queremos continuar la ejecución normal del programa sin seguir usando el depurador pulsaremos [F5].

Depuración del código en ejecución I

A continuación haremos clic en el elemento Mi perfil, situado en la parte izquierda de esta ventana. Esta opción nos permite configurar las características del tipo de programador que va a trabajar con el IDE, como las combinaciones de teclado, ayuda, etc. En nuestro caso particular, en la lista desplegable Combinación de teclado seleccionaremos Visual Basic 6, para que las combinaciones de teclas se adapten a las del programador de Visual Basic, el resto de opciones podemos dejar las que hay por defecto. Ver Figura 59.

Figura 59. Configuración del perfil del programador en el IDE.

Una vez configurado nuestro perfil de trabajo, sigamos con las cuestiones referentes al depurador. Un depurador nos permite introducirnos dentro del código de nuestro programa durante la ejecución del mismo, para observar qué es lo que está ocurriendo: ejecutar línea a línea el programa, observar el valor de las variables, etc., aspectos todos ellos fundamentales para el seguimiento de errores y fallos en la lógica de la aplicación. VS.NET dispone de un excelente depurador; del que describiremos a continuación sus elementos más básicos, para que el lector pueda realizar un seguimiento más preciso de lo que sucede durante la ejecución de su aplicación.

Introducción a los arrays. Operadores

Depuración del código en ejecución 

Para comprobar el resultado de los ejemplos realizados hasta el momento hemos utilizado la salida a consola. Sin embargo esto no es suficiente información para el programador a la hora de desarrollar una aplicación. 

Un lenguaje o entorno de programación ha de proporcionar al programador utilidades que le permitan comprobar cómo se ejecuta el código de la aplicación línea por línea, información sobre el contenido de las variables, expresiones, puntos de interrupción en la ejecución, etc. Al conjunto de todas estas técnicas o utilidades que debe aportar el lenguaje se le denomina depurador. 

El entorno de Visual Studio .NET aporta un depurador muy completo, del que vamos a mostrar en este apartado algunas de sus funcionalidades básicas, dejando para un tema posterior un estudio más completo de esta herramienta. 

Ya que algunas características del depurador y de otros elementos se realizan mediante combinaciones de teclado, es recomendable configurar el IDE al perfil de programador más adecuado, o con el que nos encontremos más cómodos.

Para configurar el perfil del usuario de VS.NET debemos situarnos en la pestaña correspondiente a la página de inicio del IDE (Start). Si hemos cerrado esta ventana o pestaña podemos abrirla de nuevo muy fácilmente mediante la opción de menú del IDE Ayuda + Mostrar página de inicio. Ver Figura 58.

Figura 58. Pestaña Página de inicio en la ventana principal del IDE.

Constantes - III

En el anterior ejemplo, realizamos el descuento utilizando directamente el valor a descontar. Si en un momento dado, necesitamos cambiar dicho valor de descuento, tendremos que recorrer todo el código e ir cambiando en aquellos lugares donde se realice esta operación. Empleando una constante para el descuento, y utilizando dicha constante en todos aquellos puntos del código en donde necesitemos aplicar un descuento, cuando debamos modificar el descuento, sólo necesitaremos hacerlo en la línea en la que declaramos la constante. Ver Código fuente 42.

Sub Main()
' crear constante para calcular descuento
Const DESCUENTO As Integer = 100
' venta de productos
Dim Importe As Double
Dim TotalVenta As Double
Console.WriteLine("Introducir importe de la venta")
Importe = Console.ReadLine()
' aplicar descuento sobre la venta, atención al uso de la constante
TotalVenta = Importe - DESCUENTO
Console.WriteLine("El importe de la venta es: {0}", TotalVenta)
Console.WriteLine()
' .............
' .............
' .............
' factura de mercancías
Dim PrecioArt As Double
Dim TotalFactura As Double
Console.WriteLine("Introducir precio del artículo")

PrecioArt = Console.ReadLine()
' aplicar descuento a la factura, atención al uso de la constante
TotalFactura = PrecioArt - DESCUENTO
Console.WriteLine("El total de la factura es: {0}", TotalFactura)
Console.WriteLine()
' .............
' .............
' .............
Console.ReadLine()
End Sub

Código fuente 42

Constantes - II

Supongamos como ejemplo, que hemos escrito un programa en el que se realiza una venta de productos y se confeccionan facturas. En ambas situaciones debemos aplicar un descuento sobre el total resultante. Ver Código fuente 41.

Sub Main()
' venta de productos

Dim Importe As Double
Dim TotalVenta As Double
Console.WriteLine("Introducir importe de la venta")
Importe = Console.ReadLine()
' aplicar descuento sobre la venta
TotalVenta = Importe - 100
Console.WriteLine("El importe de la venta es: {0}", TotalVenta)
Console.WriteLine()
' .............
' .............
' .............
' factura de mercancías
Dim PrecioArt As Double
Dim TotalFactura As Double
Console.WriteLine("Introducir precio del artículo")
PrecioArt = Console.ReadLine()
' aplicar descuento a la factura
TotalFactura = PrecioArt - 100
Console.WriteLine("El total de la factura es: {0}", TotalFactura)
Console.WriteLine()
' .............
' .............
' .............
Console.ReadLine()
End Sub

Código fuente 41

Constantes - I

Al igual que las variables, una constante es un elemento del lenguaje que guarda un valor, pero que en este caso y como su propio nombre indica, dicho valor será permanente a lo largo de la ejecución del programa, no pudiendo ser modificado. Para declarar una constante, debemos utilizar la palabra clave Const, debiendo al mismo tiempo establecer el tipo de dato y asignarle valor. Ver Código fuente 40.

Sub Main()
Const Color As String = "Azul"
Const ValorMoneda As Double = 120.48
End Sub

Código fuente 40

La tipificación de una constante se rige, al igual que las variables, por la configuración que tengamos establecida para la instrucción Option Strict. Si intentamos asignar un valor a una constante después de su asignación inicial, el IDE nos subrayará la línea con un aviso de error de escritura, y se producirá igualmente un error si intentamos ejecutar el programa. Ver Figura 57

Figura 57. No es posible asignar valores a constantes después de su creación.

La ventaja del uso de constantes reside en que podemos tener un valor asociado a una constante a lo largo de nuestro código para efectuar diversas operaciones. Si por cualquier circunstancia, dicho valor debe cambiarse, sólo tendremos que hacerlo en el lugar donde declaramos la constante.

Grabación del código modificado

Cuando editamos el código fuente de nuestro programa, es conveniente cada cierto tiempo, cuanto más frecuente, mejor, grabar a disco el archivo o archivos de código modificados. 

Para ello podemos elegir la opción de menú del IDE Archivo + Guardar NombreFichero o la combinación de teclas [CONTROL + S]. Esta costumbre nos puede ahorrar serios disgustos en el caso de un apagón imprevisto del equipo cuando estamos en plena modificación de un programa y no hemos guardado los cambios realizados. 

De forma automática, el IDE graba los archivos del programa a disco cada vez que ejecutamos el proyecto, lo cual también supone una gran ayuda.

Avisos del IDE sobre errores en el código

Al declarar una variable con un nombre incorrecto, o si se produce otro tipo de error en la escritura del código, el propio IDE se encarga de avisarnos que existe un problema subrayando el fragmento de código conflictivo y mostrando una viñeta informativa al situar sobre dicho código el cursor. Ver Figura 56.

Figura 56. Código con errores subrayado por el IDE.

Estos avisos constituyen una gran ayuda, ya que permiten al programador observar problemas en la escritura del código, antes incluso de ejecutar el programa. 

Existen multitud de avisos de muy diversa naturaleza, teniendo en cuenta que la tónica general consiste en que el código problemático quedará subrayado por el IDE hasta que no modifiquemos la línea en cuestión y la escribamos correctamente.

Tipificación obligatoria - III

Si queremos que no se produzcan errores de conversión en el anterior código fuente, tendremos que emplear las funciones de conversión de tipo, o el objeto Convert, que proporciona el lenguaje. En este caso utilizaremos CInt( ), a la que pasamos un valor numérico como parámetro, y devuelve un tipo numérico Integer; y CStr( ), que convierte a String el valor que pasemos como parámetro. Consulte el lector el conjunto de funciones de conversión en la documentación de .NET Framework para una descripción detallada. Veamos el resultado en el Código fuente 39.

Sub Main()
' ahora es obligatorio establecer
' el tipo de dato a todas las variables
Dim Valor As Integer
Dim TotalGeneral As Double
Dim Dato As String
TotalGeneral = 500
Valor = CInt(TotalGeneral) ' conversión de tipos
Dato = CStr(TotalGeneral) ' conversión de tipos
End Sub

Código fuente 39

Establecer Option Strict On requiere un mayor trabajo por parte del programador, ya que ha de ser más cuidadoso y escribir un código más correcto y preciso, lo cual es muy conveniente. Sin embargo, ya que la opción por defecto en este sentido es Option Strict Off, los ejemplos realizados a lo largo de este texto se ajustarán en este particular a dicha configuración, con ello ganamos en comodidad, ya que evitaremos la obligación de realizar conversiones de tipos en muy diversas situaciones.

Tipificación obligatoria - II

Si configuramos a nivel de fichero de código, escribiremos esta instrucción al comienzo del fichero con el modificador oportuno. Consulte el lector el anterior apartado para un mayor detalle sobre el acceso a esta ventana de propiedades del proyecto. En el ejemplo del Código fuente 38, establecemos Option Strict On a nivel de fichero de código, y a partir de ese momento, no podremos asignar un tipo de dato Double a un Integer, o un valor numérico a una variable String, por exponer un par de casos de los más comunes. El código erróneo será marcado por el IDE como un error de sintaxis, e igualmente se producirá un error si intentamos ejecutar el programa.

Figura 55. Configuración de Option Strict a nivel de proyecto.

Option Strict On

Module Module1

Sub Main()

' ahora es obligatorio establecer

' el tipo de dato a todas las variables

Dim Valor As Integer

Dim TotalGeneral As Double

Dim Dato As String

TotalGeneral = 500

Valor = TotalGeneral ' error, no se permite la conversión implícita

Dato = TotalGeneral ' error, no se permite la conversión implícita

End Sub

End Module

Código fuente 38

Tipificación obligatoria - I

Cuando declaramos una variable, no es obligatorio por defecto, establecer un tipo de dato para la misma. Igualmente, al asignar por ejemplo, una variable numérica a una de cadena, se realizan automáticamente las oportunas conversiones de tipos, para transformar el número en una cadena de caracteres. Veamos un ejemplo en el Código fuente 37.

Sub Main()
' no es necesario tipificar la variable, tipificación implícita,
' la variable Valor se crea con el tipo Object

Dim Valor
' tipificación explícita
Dim Importe As Integer
Dim UnaCadena As String
' al asignar una fecha a la variable Valor,
' sigue siendo de tipo Object, pero detecta que
' se trata de una fecha y guarda internamente
' esta información como un subtipo Date
Valor = #8/20/2001#
Importe = 590
' no es necesario hacer una conversión de tipos previa
' para asignar un número a una variable de cadena,
' ya que se realiza una conversión implícita,
' la variable UnaCadena contiene la cadena "590"
UnaCadena = Importe
Console.WriteLine("Variable Valor: {0}", Valor)
Console.WriteLine("Variable Importe: {0}", Importe)
Console.WriteLine("Variable UnaCadena: {0}", UnaCadena)
Console.ReadLine()
End Sub

Código fuente 37

Como ya comentábamos en el apartado anterior, si no asignamos el tipo de dato adecuado al declarar una variable, .NET le asigna el tipo Object, lo que afecta negativamente al rendimiento de la aplicación. La instrucción Option Strict, junto a sus modificadores On/Off, nos permite establecer si en el momento de declarar variables, será obligatoria su tipificación. También supervisa la obligatoriedad de realizar una conversión de tipos al efectuar asignaciones entre variables, o de expresiones a variables.

• Option Strict On. Hace obligatoria la tipificación de variables y la conversión de tipos explícita.
  • Option Strict Off. Hace que no sea obligatoria la tipificación de variables. La conversión entre tipos distintos en asignaciones y expresiones es realizada automáticamente por el entorno. Opción por defecto. Podemos configurar Option Strict a nivel de proyecto y de fichero de código, de igual forma que con Option Explicit. En el caso de configurar a nivel de proyecto, deberemos abrir la ventana de propiedades del proyecto, y en su apartado Generar, establecer el valor correspondiente en la lista desplegable Option Strict. Ver Figura 55.

Option Explicit a nivel de fichero

Para establecer la declaración obligatoria a nivel de fichero, debemos situarnos al comienzo del fichero de código y escribir la instrucción Option Explicit con el modificador correspondiente. El Código fuente 36 muestra un ejemplo de cómo desactivar esta característica en el fichero de código actual.

' desactivar declaración obligatoria de variables
' ahora podemos, dentro de este fichero de código,
' escribir todas las variables sin declarar
Option Explicit Off
Module Module1
Sub Main()
Valor = "coche"
MiDato = 984
Console.WriteLine("Variable Valor: {0}", Valor)
Console.WriteLine("Variable MiDato: {0}", MiDato)
Console.ReadLine()
End Sub
End Module

Código fuente 36

Option Explicit a nivel de fichero, nos permite establecer el modo de declaración de variables sólo para ese fichero en el que lo utilizamos, independientemente del tipo de obligatoriedad en declaración de variables establecido de forma general para el proyecto. Podemos por ejemplo, tener establecido Option Explicit On para todo el proyecto, mientras que para un fichero determinado podemos no obligar a declarar variables escribiendo al comienzo del mismo Option Explicit Off. El hecho de tener Option Explicit Off no quiere decir que no podamos declarar variables, podemos, por supuesto declararlas, lo que sucede es que el compilador no generará un error al encontrar una variable sin declarar. El otro grave problema al no declarar variables proviene por la incidencia en el rendimiento de la aplicación. Cuando tenemos Option Explicit Off, el entorno de .NET por cada identificador que encuentre sin declarar, crea una nueva variable, y ya que desconoce qué tipo de dato querría utilizar el programador, opta por asignarle el más genérico: Object. Una excesiva e innecesaria proliferación de variables Object afectan al rendimiento del programa, ya que .NET Framework debe trabajar doblemente en la gestión de recursos utilizada por dichas variables. En el próximo apartado trataremos sobre la obligatoriedad a la hora de tipificar variables. Por todo lo anteriormente comentado, a pesar de la engañosa facilidad y flexibilidad de Option Explicit Off, nuestra recomendación es tener configurado siempre Option Explicit On a nivel de aplicación, nos ahorrará una gran cantidad de problemas.

Option Explicit a nivel de proyecto - II

Mucho más fácil que tener que declarar las variables ¿verdad?. Pues precisamente esta facilidad es uno de los graves problemas de no declarar variables. En un procedimiento de prueba con poco código, esto no supone una importante contrariedad. Sin embargo pensemos un momento, que en lugar de un pequeño procedimiento, se trata de una gran aplicación con muchas líneas de código, procedimientos, y cientos de variables. Al encontrarnos con una variable de esta forma, no sabremos si esa variable ya la hemos utilizado con anterioridad en el procedimiento, si ha sido pasada como parámetro al mismo, etc. Estas circunstancias provocan que nuestro código se vuelva complejo de interpretar, retrasando la escritura general de la aplicación. Si volvemos a activar Option Explicit On, inmediatamente sabremos que algo va mal, ya que toda variable no declarada, quedará subrayada por el IDE como un error de escritura. Las ventajas son evidentes.

Option Explicit a nivel de proyecto - I

Para establecer Option Explicit a nivel de proyecto, debemos abrir la ventana Explorador de soluciones, hacer clic en el nombre del proyecto, y a continuación pulsar el botón de propiedades en esa misma ventana. Esto mostrará la ventana de propiedades del proyecto, en cuyo panel izquierdo haremos clic sobre el elemento Generar. Finalmente abriremos la lista desplegable del elemento Option Explicit, seleccionaremos un valor (On, Off) y pulsaremos Aplicar y Aceptar. Ver Figura 54. Con la declaración obligatoria desactivada podríamos escribir código como el mostrado en el Código fuente 35

Sub Main()
Valor = "coche"

MiDato = 984
Console.WriteLine("Variable Valor: {0}", Valor)
Console.WriteLine("Variable MiDato: {0}", MiDato)
Console.ReadLine()
End Sub
Código fuente 35

Figura 54. Propiedades del proyecto para modificar la declaración obligatoria de variables.

Declaración obligatoria

Es obligatorio, por defecto, la declaración de todas las variables que vayamos a utilizar en el código. En el caso de que intentemos utilizar una variable no declarada, se producirá un error. La declaración de variables proporciona una mayor claridad al código, ya que de esta forma, sabremos en todo momento si un determinado identificador corresponde a una variable de nuestro procedimiento, de un parámetro, etc. Mediante la instrucción Option Explicit, y sus modificadores On/Off, podemos requerir o no la declaración de variables dentro del programa. 

• Option Explicit On. Hace obligatoria la declaración de variables. Opción por defecto. 

• Option Explicit Off. Hace que no sea obligatoria la declaración de variables. Podemos aplicar esta instrucción para que tenga efecto a nivel de proyecto y a nivel de fichero de código.

Valor inicial - II

Por otro lado podemos, inversamente, inicializar una variable que ya tiene valor, asignándole la palabra clave Nothing; con ello, la variable pasa a tener el valor por defecto o inicial. Ver el Código fuente 34.

Sub Main()

Dim Valor As String

Dim FhActual As Date

Dim ValorLogico As Boolean

' asignar valores a variables

Valor = "mesa"

FhActual = "10/8/2001"

ValorLogico = True

' inicializar variables

Valor = Nothing

FhActual = Nothing

ValorLogico = Nothing

' mostrar variables en la consola

Console.WriteLine("Variable Valor: {0}", Valor)

Console.WriteLine("Variable FhActual: {0}", FhActual)

Console.WriteLine("Variable ValorLogico: {0}", ValorLogico)

Console.ReadLine()

End Sub

Código fuente 34

Valor inicial - I

Toda variable declarada toma un valor inicial por defecto, a no ser que realicemos una asignación de valor en el mismo momento de la declaración. A continuación se muestran algunos valores de inicio en función del tipo de dato que tenga la variable: 

• Numérico. Cero ( 0 ). 

• Cadena de caracteres. Cadena vacía ( "" ). 

• Fecha. 01/01/0001 0:00:00. 

• Lógico. Falso (False). 

• Objeto. Valor nulo (Nothing). 

El Código fuente 33 muestra un ejemplo de valores iniciales.

Sub Main()
Dim ImporteFac As Integer
Dim Valor As String
Dim FhActual As Date
Dim FhNueva As Date
Dim ValorLogico As Boolean
Dim UnObjeto As Object
' mostrar variables en la consola
Console.WriteLine("Variable ImporteFac: {0}", ImporteFac)
Console.WriteLine("Variable Valor: {0}", Valor)
Console.WriteLine("Variable FhActual: {0}", FhActual)
Console.WriteLine("Variable FhNueva: {0}", FhNueva)
Console.WriteLine("Variable ValorLogico: {0}", ValorLogico)
Console.WriteLine("Variable UnObjeto: {0}", UnObjeto)
Console.ReadLine()
End Sub
Código fuente 33

Asignación de valor - II

• Tipos lógicos. Las variables de este tipo sólo pueden tener el valor True (Verdadero) o False (Falso). Además de asignar valores de la forma que acabamos de explicar, podemos asignar el contenido de una variable a otra, o el resultado de una expresión a una variable, como veremos más adelante en el apartado dedicado a operadores. El Código fuente 31 muestra unos ejemplos de asignación a variables, que después visualizamos en la consola.

Module Module1
Sub Main()
Dim ImporteFac As Integer
Dim Precio As Double
Dim Valor As String
Dim Letra As Char
Dim FhActual As Date
Dim FhNueva As Date
Dim FhCompletaUno As Date
Dim FhCompletaDos As Date
Dim FhHora As Date
Dim Correcto As Boolean
ImporteFac = 875
Precio = 50.75
Valor = "mesa"
Letra = "A"c
FhActual = #5/20/2001# ' mes/día/año
FhNueva = "25/10/2001" ' dia/mes/año
FhCompletaUno = #10/18/2001 9:30:00 AM#
FhCompletaDos = "7/11/2001 14:22:00"
FhHora = #5:40:00 PM#
Dim NuevaCadena As String
NuevaCadena = Valor ' asignar una variable a otra
Correcto = True
' mostrar variables en la consola
Console.WriteLine("Variable ImporteFac: {0}", ImporteFac)
Console.WriteLine("Variable Precio: {0}", Precio)
Console.WriteLine("Variable Valor: {0}", Valor)
Console.WriteLine("Variable Letra: {0}", Letra)
Console.WriteLine("Variable FhActual: {0}", FhActual)
Console.WriteLine("Variable FhNueva: {0}", FhNueva)
Console.WriteLine("Variable FhCompletaUno: {0}", FhCompletaUno)
Console.WriteLine("Variable FhCompletaDos: {0}", FhCompletaDos)
Console.WriteLine("Variable FhHora: {0}", FhHora)
Console.WriteLine("Variable NuevaCadena: {0}", NuevaCadena)
Console.WriteLine("Variable Correcto: {0}", Correcto)
Console.ReadLine()
End Sub
End Module

Código fuente 31

Otra cualidad destacable en este apartado de asignación de valores, reside en que podemos declarar una variable y asignarle valor en la misma línea de código, como vemos en el Código fuente 32.


Dim Valor As String = "mesa"
Dim ImporteFac As Integer = 875
Código fuente 32

Asignación de valor - I

Para asignar un valor a una variable utilizaremos el operador de asignación: el signo igual ( = ), situando a su izquierda la variable a asignar, y a su derecha el valor. Ver Código fuente 29.

Dim Cuenta As Integer
Cuenta = 875

Código fuente 29

Según el tipo de dato de la variable, puede ser necesario el uso de delimitadores para encerrar el valor que vamos a asignar.

  • Tipos numéricos. Las variables de tipos de datos numéricos no necesitan delimitadores, se asigna directamente el número correspondiente. Si necesitamos especificar decimales, utilizaremos el punto ( . ) como carácter separador para los decimales 

• Cadenas de caracteres. En este caso es preciso encerrar la cadena entre comillas dobles ( " ). 

• Tipo carácter simple. Al asignar un carácter a una variable de tipo Char debemos encerrarlo entre comillas dobles igual que hacemos con una cadena, situando además, la letra c junto al carácter, fuera de las comillas, aunque esto último no sería obligatorio. Veamos un ejemplo en el Código fuente 30.

Dim Letra As Char
Letra = "A"c
Letra = "A" ‘ <-- no es necesario el uso de c junto al carácter a asignar
Código fuente 30

• Fechas. Al asignar una fecha a una variable de este tipo, podemos encerrar dicho valor entre el signo de almohadilla ( # ) o comillas dobles ( " ). El formato de fecha a utilizar depende del delimitador. Cuando usemos almohadilla la fecha tendrá el formato Mes/Día/Año; mientras que cuando usemos comillas dobles el formato será Día/Mes/Año.Las fechas pueden contener además información horaria que especificaremos en el formato: Hora:Minutos:Segundos FranjaHoraria. En el caso de que no indiquemos la franja horaria (AM/PM), y si estamos utilizando el signo almohadilla como separador, el entorno insertará automáticamente los caracteres de franja horaria correspondientes.

Declaración múltiple en línea

En el caso de que tengamos que declarar más de una variable del mismo tipo, podemos declararlas todas en la misma línea, separando cada una con una coma, e indicando junto a cada variable el tipo de dato que va a tener; o bien, si especificamos el tipo de dato al final de la lista de variables, todas tendrán el mismo tipo de dato. Ver el Código fuente 28.

Dim Nombre As String, Cantidad As Integer, MiFecha As Date
Dim Importe, Totalizado, Precision As Integer
Código fuente 28

Tipificación - II

Si al declarar una variable no indicamos el tipo, por defecto tomará Object, que corresponde al tipo de datos genérico en el entorno de ejecución de .NET Framework, y que admite cualquier valor. Según la información que acabamos de ver, si declaramos una variable de tipo Byte e intentamos asignarle el valor 5899 se va a producir un error, ya que no se encuentra en el intervalo de valores permitidos para esa variable. Esto puede llevar al lector a preguntar: “¿por qué no utilizar siempre Object y poder usar cualquier valor?, o mejor ¿para qué necesitamos asignar tipo a las variables?”. 

El motivo de tipificar las variables reside en que cuando realizamos una declaración, el entorno de .NET debe reservar espacio en la memoria para los valores que pueda tomar la variable, como puede ver el lector en la tabla anterior, no requiere el mismo espacio en memoria una variable Byte que una Date. Si además, declaramos todas las variables como Object, los gastos de recursos del sistema serán mayores que si establecemos el tipo adecuado para cada una, ya que como .NET Framework no sabe el valor que puede tomar en cada ocasión la variable, debe realizar un trabajo extra de adecuación, consumiendo una mayor cantidad de recursos. Una correcta tipificación de las variables redundará en un mejor aprovechamiento de las capacidades del sistema y en un código más veloz en ejecución. Cuantos más programas se diseñen optimizando en este sentido, el sistema operativo ganará en rendimiento beneficiándose el conjunto de aplicaciones que estén en ejecución. VS.NET dispone de una ayuda al asignar el tipo a una variable, que nos muestra la lista de tipos disponibles para poder seleccionar uno sin tener que escribir nosotros el nombre. Al terminar de escribir la palabra As, aparecerá dicha lista, en la que pulsando las primeras letras del tipo a buscar, se irá situando en los más parecidos. Una vez encontrado, pulsaremos la tecla [INTRO] o [TAB] para tomarlo. Ver Figura 53.

Figura 53. Lista de tipos de datos al declarar una variable.

Tipificación - I

La tipificación de una variable es la operación por la cual, al declarar una variable, especificamos qué clase de valores o tipo de datos vamos a poder almacenar en dicha variable. En VB.NET utilizamos la palabra clave As seguida del nombre del tipo de datos, para establecer el tipo de una variable. Ver Código fuente 27.

Sub Main()
Dim Valor As String ' cadena de caracteres
Dim Cuenta As Integer ' numérico entero
Dim FhActual As Date ' fecha
End Sub
Código fuente 27

La Tabla 3 muestra la relación de tipos de datos disponibles en el lenguaje.

Tabla 3. Tipos de datos en VB.NET.

Lugar de la declaración

Podemos declarar variables en muy diversos lugares del código. El punto en el que declaremos una variable será determinante a la hora del ámbito o accesibilidad a esa variable desde otros puntos del programa. Por ahora, y ciñéndonos a la declaración de variables dentro de procedimientos, recomendamos declarar todas las variables en la cabecera o comienzo del procedimiento, para dar mayor claridad al mismo. Después de la declaración, escribiremos el resto de instrucciones del procedimiento.

Denominación

Como se comentaba en el apartado sobre identificadores, el nombre que podemos asignar a una variable tiene que seguir ciertas reglas: debe comenzar por letra, no puede ser una palabra reservada, ni incluir caracteres especiales del lenguaje. El Código fuente 26 nos muestra algunos ejemplos de declaraciones.

Sub Main()
' declaraciones correctas
Dim B
Dim Hola
Dim ABCD
Dim Nuevo10
Dim Es_otro
' declaraciones incorrectas
Dim 7Nuevo
Dim Avan+zar
Dim End ' nombre incorrecto
Dim Va-bien
End Sub

Código fuente 26

Como podemos comprobar en este fuente, y ya explicamos antes, incluimos comentarios en el código usando la comilla simple ( ' ), seguida del comentario correspondiente.

Declaración

La declaración de una variable es el proceso por el cual creamos e inicializamos una nueva variable en el programa. Para declarar una variable utilizaremos la palabra clave Dim, seguida del identificador o nombre que daremos a dicha variable. Ver Código fuente 25.


Sub Main()
Dim MiValor
End Sub
Código fuente 25

Variables

Una variable es aquel elemento dentro de un programa que guarda un valor; dicho valor podrá cambiar durante el funcionamiento del programa (de ahí el nombre de variable). El contenido de la variable no es otra cosa que una posición en la memoria del ordenador que almacena el valor, y debido a que la memoria es un medio de almacenamiento no permanente, al finalizar el programa el valor se perderá, por lo que el uso de variables se limita al tiempo de ejecución del programa. Para manejar y asignar nombre a una variable, emplearemos un identificador.

Obtener información de la consola

Para tomar el texto tecleado en el indicador de comandos de la ventana de la consola disponemos del método ReadLine( ), que devuelve una cadena que podemos pasar a una variable para su tratamiento posterior. Veamos un ejemplo en el Código fuente 24.

Module Module1
Sub Main()

Dim UnValor As String
Console.WriteLine("Escribir algo")
UnValor = Console.ReadLine()
Console.WriteLine("Hemos escrito el siguiente texto")
Console.WriteLine(UnValor)
End Sub
End Module

Código fuente 24

La Figura 52 muestra el resultado.

Figura 52. Obtención del texto escrito en la consola.

Visualizar información en la consola - III

La otra técnica consiste en utilizar parámetros sustituibles, indicando en la cadena los lugares en los que queramos que se incluyan el contenido de las variables que necesitemos. Por ejemplo, supongamos que en la cadena “Hola voy a un coche”, queremos insertar los valores “conducir” y “azul”, que están situados en variables, de modo que la cadena resultante sea: “Hola voy a conducir un coche azul”. 

Para solucionar este problema, en la cadena tenemos que incluir unos marcadores que indican que en ese punto vamos a sustituir el marcador por una variable, y además el número de orden de la variable, tal y como la vamos a situar al llamar al método WriteLine( ). 

Los marcadores son los símbolos de llaves utilizados de una forma similar a la siguiente: {0} Cuando llamamos a WriteLine( ) sabemos que le pasamos como parámetro el valor a mostrar, pero podemos pasar más parámetros separados por comas, como pueden ser variables; dichos parámetros serán utilizados para sustituirse en la cadena pasada como primer parámetro. 

La Figura 51 muestra un esquema del uso de este método.

Figura 51. Esquema de parámetros sustituibles al usar el objeto Console.

Podemos comprobar, que a continuación de la cadena pasada en WriteLine( ), la primera variable se sustituirá en el marcador {0}, la siguiente en el {1}, y así sucesivamente.

Visualizar información en la consola - II

Si al escribir un texto en la consola, queremos combinar una cadena de caracteres con el contenido de una variable, podemos optar por dos técnicas. Por un lado podemos concatenar (unir) la cadena a la variable mediante el operador de concatenación del lenguaje ( & ). Ver Código fuente 23.


Module Module1
Sub Main()
Dim UnValor As String
UnValor = "al parque"
Console.WriteLine("Vamos de paseo " & UnValor)
End Sub
End Module
Código fuente 23

El resultado se muestra en la Figura 50.

Figura 50. Concatenar valores al mostrarlos en la consola.

Visualizar información en la consola - I

Para escribir texto llamaremos al método Write( ) o WriteLine( ) del objeto Console. Como parámetros a estos métodos, es decir, entre los paréntesis que los acompañan, situaremos la información a mostrar: una cadena, variable o expresión. Veamos un ejemplo en el Código fuente 22.

Module Module1
Sub Main()
Dim UnValor As String
UnValor = "algo más de texto"
' esta cadena va en una línea
Console.WriteLine("Una línea de prueba")
' ahora mostramos una variable
Console.WriteLine(UnValor)
' las siguientes cadenas se ponen juntas
Console.Write("Coche")
Console.Write("Tren")
' aquí añadimos una línea en blanco
Console.WriteLine()
End Sub
End Module
Código fuente 22
La diferencia entre Write( ) y WriteLine( ) consiste en que mediante el primero, todas las llamadas que hagamos a ese método escriben el texto seguido, mientras que el último lo hace en líneas separadas. La Figura 49 muestra el resultado del anterior ejemplo.

Figura 49. Escritura de texto con el objeto Console.

Manejo de la consola del sistema

Antes de pasar a trabajar con los elementos del lenguaje vamos a dar unos breves apuntes sobre el objeto Console, que representa a una ventana MS-DOS, símbolo del sistema, o consola, como la denominaremos fundamentalmente en este texto. 

En el tema anterior ya tuvimos un primer contacto con la consola realizando nuestro primer programa, el conocido Hola mundo. Sin embargo, en este apartado vamos a dar unas indicaciones básicas de uso, ya que la consola será el elemento principal que utilizaremos para mostrar y obtener datos por pantalla. 

Debido a su sencillez de uso y rápida ejecución, la consola se convierte en el elemento ideal para realizar pruebas, y en nuestro caso, mostrar ejemplos. Aunque la consola es un objeto, no vamos a entrar aquí a describir en qué consisten los objetos ni su uso en profundidad, recomendamos al lector la consulta de los temas específicos sobre programación orientada a objetos del texto. 

De igual modo, los conceptos sobre variables, parámetros, concatenación, y demás aspectos del lenguaje que se utilizan en estos ejemplos introductorios a la consola, se explicarán más adelante en los apartados correspondientes a los elementos del lenguaje.

Indentación del código - II

Cuando queramos indentar una línea simplemente hemos de situarnos al comienzo de la misma y pulsar la tecla [TAB], para quitar tabulaciones pulsaremos [TAB + MAYÚS]. Como ya hemos indicado, el entorno de desarrollo de VS.NET por defecto indenta automáticamente el código según lo vamos escribiendo. Si queremos variar algún aspecto en cuanto a este comportamiento del editor, podemos configurar las características de indentación establecidas en el IDE seleccionando la opción de menú Herramentas + Opciones. Al abrir la ventana Opciones seleccionaremos la carpeta Editor de texto, y dentro de esta la carpeta Basic, que contendrá la configuración para el editor de texto correspondiente a este lenguaje. Haciendo clic en el elemento Tabulaciones se mostrarán las propiedades de indentado, que podemos modificar para adaptarlas a nuestras preferencias, tal y como vemos en la Figura 48.

Figura 48. Propiedades de indentado en el IDE de Visual Studio .NET.

Indentación del código - I

La indentación o sangría es una técnica para escribir el código de un programa, consistente en situar las líneas de código a diferentes niveles de tabulación o profundidad, de forma que se facilite su lectura al ser revisado. 

Al crear una aplicación con VS.NET, podemos comprobar como el propio editor de código fuente indenta el código según lo escribimos, siendo una práctica muy ligada a las estructuras de control, que veremos próximamente, ya que nos permite ver rápidamente las instrucciones contenidas dentro de estas estructuras y situarnos en las líneas necesarias. En el Código fuente 21 se muestran unas líneas en pseudocódigo que contienen estructuras y código dentro de las mismas, de forma que pueda comprobar el lector el modo en que se realiza la tabulación.

comienzo
' líneas con indentación al mismo nivel
instrucción1
instrucción2
' comienzo de estructura
EstructuraA <expresión>
' líneas indentadas a un nivel de profundidad
instrucciónA1
instrucciónA2
' comienza estructura anidada
EstructuraB <expresión>
' líneas indentadas a segundo nivel de profundidad
instrucciónB1
instrucciónB2
FinEstructuraB
' según salimos de las estructuras
' volvemos a subir niveles de indentación
instrucciónA3
instrucciónA4
FinEstructuraA
instrucción3
instrucción4
final
Código fuente 21

Comentarios

Es una buena costumbre incluir comentarios aclaratorios en el código del programa, que sirvan como documentación posterior a la hora de revisar el código para realizar una posible corrección debido a un mal funcionamiento, o porque tengamos que ampliar la funcionalidad del programa. En VB.NET se utiliza el carácter de comilla simple ( ' ) para poder escribir anotaciones dentro del código del programa. Una vez incluida la comilla, todo lo que vaya a continuación será tenido en cuenta como comentario y no como instrucciones ejecutables. Ver Código fuente 20.

Module Module1
Sub Main()
' vamos a comenzar a ver el código
instrucción1
instrucción2 ' este comentario va a continuación de una línea
' esta es la última instrucción
instrucción3
End Sub
End Module

Código fuente 20

Ubicación del código en el programa

El código de un programa se sitúa en rutinas de código o procedimientos, en los cuales escribimos las instrucciones necesarias para resolver un determinado problema. 

Dependiendo de la complejidad y la cantidad de situaciones a resolver, un programa tendrá un número determinado de procedimientos. Los procedimientos serán tratados con profundidad en un próximo tema, de momento basta saber que para declarar un procedimiento utilizaremos la palabra clave Sub, seguida del nombre del procedimiento, escribiendo a continuación las instrucciones necesarias y finalizando el procedimiento con End Sub, como vemos en el Código fuente 19, en el que creamos un procedimiento con el nombre Calcular( ).

Sub Calcular()
instrucción1
instrucción2
instrucción3
instrucción4
instrucción5
....
....
....
instrucción

End Sub
Código fuente 19

Cuando creamos una aplicación VB.NET de tipo consola usando VS.NET, es el propio IDE quién se encarga de crear por nosotros la estructura básica del programa: crea un archivo de código conteniendo un módulo que tiene el procedimiento de entrada, sólo falta el código del programador. Todos los elementos que componen una aplicación VB.NET, son organizados por VS.NET bajo el concepto de proyecto. Un proyecto aglutina los archivos de código de la aplicación, recursos, referencias a clases globales de la plataforma .NET, etc. Consulte el lector el tema dedicado a la implementación de programas en .NET para una descripción general de estos tipos de archivo. Para las pruebas de los siguientes apartados crearemos desde el IDE un nuevo proyecto de tipo consola.

Estructura de un programa

Como ya explicamos en el tema que describía la escritura de la primera aplicación en VB.NET, los elementos mínimos que debe tener toda aplicación escrita en este lenguaje (y en general, la mayoría de lenguajes) son un módulo de código, y un procedimiento de entrada o inicio del programa, que en VB.NET tendrá el nombre Main( ), todo ello contenido en un archivo de código con extensión .VB. En la Figura 47 podemos ver en un diagrama, la estructura en niveles de un programa. 

Si el programa a ejecutar es de pequeño tamaño, el procedimiento de entrada al mismo contendrá todo el código necesario. Sin embargo esta situación no es muy frecuente, lo habitual es que los programas tengan una cantidad de código considerable, que obligue a separarlo en diferentes rutinas. Por este motivo el procedimiento Main( ) contiene generalmente código para inicializar valores en el programa, y hacer llamadas a otros procedimientos entre los que está repartido el resto del código. Debido a que los próximos ejemplos mostrados en el texto estarán basados en programas sencillos, por el momento sólo precisaremos usar el procedimiento Main( ).

Figura 47. Estructura en niveles de los elementos de un programa en VB.NET.

Palabras reservadas

Son todos aquellos nombres que forman parte integrante del lenguaje de programación, como puedan ser instrucciones, estructuras de código, funciones propias del lenguaje, objetos, etc. Este tipo de palabras no las podemos utilizar como identificadores, debido a que son empleadas internamente por el lenguaje. Algunas palabras reservadas en Visual Basic .NET son: Dim, Sub, Function, Public, For, Integer.

Identificadores

Un identificador es un nombre que el programador asigna a ciertos elementos del programa, como variables, constantes, rutinas de código, etc., para poder reconocerlos durante el desarrollo del mismo. 

Dicho nombre debe comenzar por una letra y no puede ser una palabra reservada del lenguaje, ni contener caracteres especiales como operadores aritméticos, de relación, etc. 

Aunque podemos utilizar cualquiera de nuestra elección, es muy recomendable que el nombre del identificador esté relacionado con su contenido, de forma que durante la revisión del código del programa, sepamos rápidamente lo que contiene simplemente con ver su nombre.

Definidos por el programador

En esta categoría se encuentran la estructura (Structure), que consiste en un tipo especial de dato compuesto por varios de los tipos existentes en el lenguaje; y el tipo enumerado (Enum), consistente en una lista de valores numéricos a los que asociamos un descriptor literal. Ambos tipos nos permiten combinar un conjunto de datos de forma más compleja que los tipos compuestos. 

Tanto los tipos compuestos como los definidos por el usuario serán tratados más adelante con mayor profundidad, ya que es recomendable conocer algunos aspectos previos sobre el lenguaje antes de ahondar en estos tipos.

Compuestos

Un dato compuesto está formado por varios datos de tipo simple. Como ya hemos mencionado, una cadena es un dato compuesto (por datos simples de tipo carácter) aunque algunos lenguajes lo traten como simple. Como dato compuesto disponemos de los arrays o matrices, que son tablas de datos con un número fijo o variable de elementos.

Lógico

Un dato lógico es aquel que representa uno de dos valores posibles: Verdadero o Falso, indicándose estos valores en VB.NET como True y False respectivamente.

Fecha

Las fechas son tratadas también por el lenguaje como una unidad de información, ya que aunque puedan combinar números, letras y símbolos para su representación, internamente se almacenan con un valor numérico (entero largo o Long). 

Los delimitadores utilizados para las fechas son el símbolo de almohadilla ( # ), o las comillas dobles ( “ ). En función del delimitador que usemos para encerrar una fecha, se deberá especificar en primer lugar el mes o el día de dicha fecha, como vemos en el Código fuente 18.

Fecha: 25 de agosto de 2002
===========================
#8/25/2002# <-- primero el mes
“25/08/2002” <-- primero el día
Código fuente 18

Carácter

Un dato de tipo carácter está formado por un único elemento, que puede ser cualquier letra, símbolo o número, teniendo en cuenta que los números que son representados como caracteres no se pueden utilizar para realizar operaciones aritméticas. 

Para representar un dato de este tipo en un programa se utilizan los denominados delimitadores, entre los que se encierra el carácter correspondiente. Suelen ser habitualmente, y para la mayoría de los lenguajes de programación, los símbolos de comilla simple o doble, como se muestra a continuación en el Código fuente 16.

"a"
"?"
"4"
"+"
Código fuente 16

Cuando se desarrollan programas es muy frecuente agrupar varios datos de este tipo, formando lo que en programación se conoce como cadena de caracteres. Este aspecto puede resultar un tanto confuso, ya que una cadena es un dato compuesto y no simple, pero existen determinados lenguajes, VB.NET es uno de ellos, que nos permiten tratar las cadenas como datos de tipo simple. El Código fuente 17 muestra algunos ejemplos de datos de tipo cadena.


"el reloj marca las cinco"
"apagar el monitor antes de salir"
"el importe del ticket es: 5.000 ptas."
Código fuente 17

Numérico

Como su nombre indica, este tipo de dato contiene un número, que puede ser entero (sin parte decimal) o real (con parte decimal). El Código fuente 14 muestra algunos ejemplos de números enteros.


8
1000
415
-80
Código fuente 14

El Código fuente 15 muestra algunos ejemplos de números reales.

8.35
120.55
-28.42
Código fuente 15


Debido a la naturaleza de los ordenadores, hay que tener presente que para representar un número real en un programa, tal y como acabamos de observar, debemos utilizar como separador decimal el punto en lugar de la coma.

Simples

Un dato simple está formado por una sola unidad de información. Dependiendo del contenido de esa
información, los datos simples se dividen en los tipos numérico, carácter, fecha y lógico.

Datos

Los datos son la información que utiliza un programa para poder realizar operaciones. En función de la información que contengan, los datos se pueden clasificar en varios grupos: simples, compuestos y definidos por el programador.

El lenguaje. Elementos básicos

Componentes de un lenguaje de programación 

Un lenguaje de programación se compone de una serie de elementos que se utilizan para escribir las diferentes instrucciones y expresiones de que consta un programa. Además de los mencionados elementos, existen una serie de reglas para la construcción de expresiones, que son las encargadas de decidir si determinada línea o líneas de código están bien escritas, de forma que nuestro programa se ejecute correctamente. Al conjunto de normas establecidas para la correcta escritura del código en un lenguaje de programación se le denomina sintaxis. 

El objetivo de este texto se basa en explicar los conceptos y aspectos elementales de la programación, de modo que sean aplicables a la mayoría de los lenguajes, empleando Visual Basic .NET como lenguaje de programación modelo. 

También se examinarán características particulares de VB.NET, que ayudarán al lector que elija este lenguaje como herramienta de trabajo, a obtener un mayor partido de la misma. A continuación, y de forma esquemática, se muestran los elementos que la mayoría de los lenguajes de programación incluyen; todos ellos serán comentados con detalle en los próximos apartados y temas del texto.       

• Datos.
      o Simples.
      o Compuestos.
      o Definidos por el programador.

• Identificadores.
      o Variables.
      o Constantes.
      o Rutinas o procedimientos.
• Palabras reservadas.
      o Comandos (Instrucciones o sentencias).
      o Funciones propias del lenguaje.
      o Objetos propios del lenguaje.
• Operadores.
      o Aritméticos.
      o Relacionales.
      o Lógicos.
• Expresiones.
• Estructuras de control.
      o Selección.
      o Repetición.
• Contadores.
• Acumuladores.
• Interruptores.

El sistema de ayuda - II

En el caso de que no exista información para el elemento del que hemos solicitado ayuda, podemos situar el cursor sobre la pestaña desplegable Ayuda dinámica, situada en uno de los laterales del IDE. Esta pestaña se abrirá en el momento en que nos situemos sobre ella y a través de los botones de su barra de herramientas, podemos efectuar diversos tipos de búsqueda en la documentación del MSDN: a través de un índice, por palabra o combinación de palabras, etc. Ver la Figura 46.

Figura 46. Ventana de ayuda dinámica de Visual Studio .NET.

El sistema de ayuda - I

El MSDN (Microsoft Developer Network), o documentación de ayuda de la plataforma Microsoft .NET está accesible en todo momento desde el propio VS.NET. Se trata de un sistema de ayuda contextual, esto quiere decir que si invocamos la ayuda desde el lugar del IDE en el que nos encontremos, se intentará buscar un documento en la ayuda relacionado con ese lugar en el que estamos situados. Por ejemplo, si estamos situados en la ventana del editor de código, y el cursor se encuentra sobre la palabra clave Sub, al pulsar [F1] para solicitar ayuda, se abrirá una nueva pestaña en la ventana principal del IDE, correspondiente a la ayuda, y que nos mostrará la documentación existente sobre dicho elemento del código, como vemos en la Figura 45. 

Figura 45. Ayuda de Visual Studio .NET.

La estructura de archivos del proyecto

Cuando creamos un proyecto utilizando VS.NET, se genera en disco, partiendo de la ruta especificada en la ventana de creación del proyecto, una estructura de directorios que contiene los archivos que forman parte del proyecto. La Figura 44 muestra la estructura correspondiente al programa de ejemplo que acabamos de escribir.

Figura 44. Estructura de archivos de un proyecto escrito en VB.NET.

Si hacemos cambios en la ventana del editor de código, deberemos guardarlos en su archivo de código asociado pulsando [CTRL+S], o bien, si hemos modificado diferentes elementos, y queremos grabar todos los cambios a la vez, seleccionaremos la opción de menú del IDE Generar + Generar. Un proyecto VB.NET está compuesto por un conjunto de archivos de diverso tipo, algunos de los cuales relacionamos a continuación:

• VB. Código fuente escrito en lenguaje Visual Basic. 

• VBPROJ. Proyecto de VB. Contiene información sobre todos los elementos que forman parte de un proyecto: archivos de código, referencias, etc. 

• SLN. Solución. Una solución es el medio que utiliza VS.NET para agrupar varios proyectos escritos en el mismo o en diferentes lenguajes de los que integran la plataforma .NET. 

• VBPROJ.USER. Información sobre las opciones de usuario del proyecto. 

• EXE. Aplicación ejecutable. 

• PDB. Información sobre depuración de la aplicación Cuando escribimos un programa con VS.NET, en el directorio bin del proyecto se genera el archivo ejecutable, que contiene nuestra aplicación, y que en principio, es lo único que necesitamos para ejecutar el programa en cualquier otro equipo, que naturalmente, también tenga instalado la plataforma .

NET Framework. Ello nos evita problemas de instalación y ahorra tiempo en su distribución. Para abrir un proyecto dentro del IDE, el modo más rápido consiste en hacer doble clic sobre el archivo de proyecto o solución; esto abrirá VS.NET y cargará el proyecto-solución en el IDE, con lo que podremos comenzar a trabajar. Si tenemos ya abierto el IDE, podemos utilizar su opción de menú Archivo + Abrir + Proyecto, o bien Archivo + Abrir solución. De ambas formas se abrirá un cuadro de diálogo para seleccionar el proyecto o solución a cargar en el IDE para su edición.

El Explorador de soluciones

Una solución en VS.NET es un componente del IDE que actúa como contenedor de proyectos. Por defecto, cuando creamos un proyecto, se crea también una solución que lo contiene, con el mismo nombre del proyecto; podemos añadir más proyectos a la solución o dejarla como solución de proyecto único.

 La ventana del IDE Explorador de soluciones, nos permite una vista organizada de la solución actualmente abierta, con los proyectos que contiene, y los elementos, a su vez, que componen cada proyecto, fundamentalmente, el archivo MODULE1.VB, ya que el resto no necesitaremos modificarlos. 

La Figura 43 muestra esta ventana con los elementos del programa que estamos escribiendo.

Figura 43. Explorador de soluciones del IDE