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.
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: -
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.
Cadena = "15"
Valor = 20
CadenaResulta = Cadena + Valor ' error
Código fuente 56
' 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)
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
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: \
Dim Resultado As Integer
Resultado = 50 \ 3 ' devuelve: 16
Resultado = 250 \ 4 ' devuelve: 62
Código fuente 53
División real: /
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 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.
Resultado = 12 ^ 5 ' devuelve: 248832
Resultado = 2 ^ 3 ^ 7 ' devuelve: 2097152
Resultado = (-4) ^ 2 ' devuelve: 16
Código fuente 50
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 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
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
• 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
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
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.
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.
' 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
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
 |
| 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.
' 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
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. |
Depuración del código en ejecución II
 |
| Figura 60. Visualizando el contenido de una variable durante la depuración. |
 |
| Figura 61. Ventana Locales del depurador. |
Depuración del código en ejecución I
 |
| 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.
' 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.
' 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.
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. |
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
 |
| 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.
' 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.
' 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
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
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.
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.
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.
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.
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 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.
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.
' 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
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.
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. |
Visualizar información en la consola - II
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.
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.
' 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.
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( ).
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.
===========================
#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
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.
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
 |
| 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
 |
| 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 |