Ξ  Ampliar / reducir el margen  el Guille, la Web del Visual Basic, C#, .NET y más...
índice del curso de VB .NET

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

Entrega número cuatro, (27/Oct/2001)
Publicada el 27/Oct/2001
Revisada el 24/Dic/2002

 

Como te dije en la entrega anterior de este curso de iniciación a la programación con Visual Basic .NET, en esta ocasión vamos a ver qué es eso de una variable y algunos otros conceptos que necesitarás para poder tomarte esto de programar con vb.NET un poco más en serio... bueno, tampoco hace falta que sea demasiado en serio, simplemente que te enteres de las cosas y sobre todo que sepas aplicarlas en el momento en que sea oportuno o necesario... (que bien ta quedao ezo Guille)

 

Variables, constantes y otros conceptos relacionados

El concepto o descripción de lo que es una variable es fácil de asimilar, si es que has estudiado en el colegio, al menos hace unos diez años o más, ya se explicaba, pero hace 25 ó 30 años, por poner una cifra, a mi no me lo explicaron... o lo mismo el "profe" lo explicó, pero yo estaría pensando en las altabacas de Rio Seco, (otras cosas)... como siempre... que lo que es prestar atención en clase, no era lo mío... (así te va Guille), en fin... no tomes malos ejemplos y aplícate... al menos en esta "clase", en las otras... de ti depende... no te voy a echar el sermón de que debes estudiar para que en el futuro... eso lo dejo para otros...

A lo que vamos... el concepto de constante, ya lo vimos hace un par de entregas, una constante es algo que permanece inalterable, por eso se llama constante, porque siempre es constante: inalterable, siempre es lo mismo...
Sin embargo una variable puede alterarse, es decir, se le puede cambiar el valor que tiene... por eso se llama variable, como el estado anímico que algunas veces tenemos, hoy estamos de buenas y mañana lo mismo tenemos los cables cruzados y no hay Dios que nos pueda dirigir la palabra... en fin... con una tila se suele solucionar... pero... no es de eso de lo que se trata cuando hablamos de variables en esto de la programación, ya sea en vb.NET o en cualquier otro lenguaje.

Las variables son "nombres" que pueden contener un valor, ya sea de tipo numérico como de cualquier otro tipo.
Esos nombres son convenciones que nosotros usamos para facilitarnos las cosas, ya que para los ordenadores, (o computadores, según te guste o estés acostumbrado a llamarlos), una variable es una dirección de memoria en la que se guarda un valor o un objeto, te vuelvo a recordar por enésima vez que en .NET todo es un objeto.

Existen distintos tipos de valores que se pueden asignar a una variable, por ejemplo, se puede tener un valor numérico o se puede tener un valor de tipo alfanumérico o de cadena, (string para los que inventaron esto de los lenguajes de programación), pero en cualquier caso, la forma de hacerlo siempre es de la misma forma... al menos en .NET ya no hay las distinciones que antes había en las versiones anteriores de Visual Basic... no voy a entrar en detalles, pero si has trabajado anteriormente en VB con objetos, sabrás de que estoy hablando.

Por ejemplo si queremos guardar el número 10 en una variable, haremos algo como esto:

i = 10

En este caso i es la variable, mientras que 10 sería una constante, (10 siempre vale 10), la cual se asigna a esa "posición" de memoria a la que llamamos i, para facilitarnos las cosas... ya que, realmente no nos interesa saber dónde se guarda ese valor, lo único que nos interesa es saber que se guarda en algún lado para en cualquier ocasión poder volver a usarlo.

Pensarás, que tal y como están las cosas, i también vale 10, por tanto ¿por qué no es una constante? por la sencilla razón de que podemos alterar su valor, por ejemplo, si en cualquier ocasión posterior hacemos esto: i = 25, el valor de la variable i cambiará, de forma que el valor anterior se esfumará y el que se almacenará será el nuevo.

También podemos aplicar expresiones al asignar una variable, una expresión es algo así como un cálculo que queremos hacer, por ejemplo: i = x * 25, en este caso x * 25 se dice que es una expresión, cuyo resultado, (el resultante de multiplicar lo que vale la variable x por la constante 25), se almacenará en la variable i.
Si x vale 3, (es decir el valor de la variable x es tres), el resultado de multiplicarlo por 25, se guardará en la variable i, es decir i valdrá 75.

Pero no es suficiente saber qué es una variable, lo importante es saber cómo decirle al vb.NET que queremos usar un espacio de memoria para almacenar un valor, ya sea numérico, de cadena o de cualquier otro tipo.

Para que vayas entrando en calor, te diré que las cadenas de caracteres (o valores alfanuméricos) se representan por algo que está contenido dentro de comillas dobles: "hola" sería una constante de cadena, ya que "hola" será siempre "hola", lo mismo que el número 10 siempre vale 10.
Para asignar esa constante de caracteres a una variable, se haría algo como esto:
s = "Hola"
De esta forma, la variable s contiene el valor constante "Hola".
Podemos cambiar el valor de s, asignándole un nuevo valor: s = "adiós", pero no podemos cambiar el valor de "Hola", ya que si lo cambiamos dejará de ser "Hola" y se convertirá en otra cosa...

Como ya te he dicho, existen distintos tipos de datos que vb.NET maneja, para que podamos usar una variable para almacenar cualquiera de esos tipos, tenemos que decirle al VB que "reserve" espacio en la memoria para poder guardarlo.
Esto se consigue mediante la "declaración de variables", es necesario, aunque no obligatorio, declarar las variables según el tipo de datos que va a almacenar.
Por ejemplo, en el caso anterior, la variable i era de tipo numérico y la variable s era de tipo cadena. Esas variables habría que declararlas de la siguiente forma: (después veremos otras formas de declarar las variables numéricas)

Dim i As Integer
Dim s As String

Con esto le estamos diciendo al vb.NET que reserve espacio en su memoria para guardar un valor de tipo Integer, (numérico), en la variable i y que en la variable s vamos a guardar valores de cadena de caracteres.

Antes de seguir con esta "retahíla" de conceptos, vamos a ver cuales son los tipos de datos que .NET soporta y esas cosillas, así veremos los tipos de variables que podemos tener en nuestros programas.

La siguiente tabla te muestra algunos de ellos y los valores mínimos y máximos que puede contener, así como el tamaño que ocupa en memoria; también te comento algunas otras cosas, que aunque ahora no te parezcan "aclaratorios", en un futuro si que lo serán, como por ejemplo a que tipo de datos se puede convertir sin recibir un mensaje overflow, (o los que se aceptan usando Option Strict), que signo se puede usar para "aclarar" el tipo de datos que representa, e incluso que signo se puede usar con variables para que el VB sepa el tipo de datos que es... (aunque esto último no es recomendable, lo muestro para que lo sepas):

Tipos de datos de Visual Basic.NET y su equivalente en el Common Language Runtime (CLR)

Tipo de Visual Basic Tipo en CLR
(Framework)
Espacio de memoria que ocupa Valores que se pueden almacenar
y comentarios
Boolean System.Boolean 2 bytes Un valor verdadero o falso.
Valores: True o False.

En VB se pueden representar por -1 o 0, en CLR serán 1 y 0, aunque no es recomendable usar valores numéricos, es preferible usar siempre True o False.
Dim b As Boolean = True

Byte System.Byte 1 byte Un valor positivo, sin signo, para contener datos binarios.
Valores: de 0 a 255

Puede convertirse a: Short, Integer, Long, Single, Double o Decimal sin recibir overflow
Dim b As Byte = 129

Char System.Char 2 bytes Un carácter Unicode.
Valores: de 0 a 65535 (sin signo).

No se puede convertir directamente a tipo numérico.
Para indicar que una constante de cadena, realmente es un Char, usar la letra C después de la cadena:
Dim c As Char = "N"c

Date System.DateTime 8 bytes Una fecha.
Valores: desde las 0:00:00 del 1 de Enero del 0001 hasta las 23:59:59 del 31 de Diciembre del 9999.

Las fechas deben representarse entre almohadillas # y por lo habitual usando el formato norteamericano: #m-d-yyyy#
Dim d As Date = #10-27-2001#

Decimal System.Decimal 16 bytes Un número decimal.
Valores:
de 0 a +/-79,228,162,514,264,337,593,543,950,335 sin decimales;
de 0 a +/-7.9228162514264337593543950335 con 28 lugares a la derecha del decimal;
el número más pequeño es:
+/-0.0000000000000000000000000001 (+/-1E-28).

En los literales se puede usar la letra D o el signo @ para indicar que el valor es Decimal.
Dim unDecimal As Decimal = 9223372036854775808D
Dim unDecimal2 As Decimal = 987654321.125@

Double System.Double 8 bytes Un número de coma flotante de doble precisión.
Valores:
de -1.79769313486231570E+308 a
-4.94065645841246544E-324 para valores negativos;
de 4.94065645841246544E-324 a 1.79769313486231570E+308 para valores positivos.

Se puede convertir a Decimal sin recibir un overflow.
Se puede usar como sufijo el signo almohadilla # o la letra R para representar un valor de doble precisión:
Dim unDoble As Double = 125897.0235R
Dim unDoble2 As Double = 987456.0125#

Integer System.Int32 4 bytes Un número entero (sin decimales)
Valores:
de -2,147,483,648 a 2,147,483,647.

Se puede convertir a Long, Single, Double o Decimal sin producir overflow.
Se puede usar la letra I o el signo % para indicar que es un número entero:
Dim unEntero As Integer = 250009I
Dim unEntero2 As Integer = 652000%

Long
(entero largo)
System.Int64 8 bytes Un entero largo (o grande)
Valores:
de -9,223,372,036,854,775,808 a 9,223,372,036,854,775,807.

Se puede convertir a Single, Double o Decimal sin producir overflow.
Se puede usar la letra L o el signo & para indicar que es un número Long:
Dim unLong As Long = 12345678L
Dim unLong2 As Long = 1234567890&

Object System.Object (class) 4 bytes Cualquier tipo se puede almacenar en una variable de tipo Object.
Todos los datos que se manejan en .NET están basados en el tipo Object.
Short
(entero corto)
System.Int16 2 bytes Un entero corto (sin decimales)
Valores:
de -32,768 a 32,767.

Se puede convertir a: Integer, Long, Single, Double o Decimal sin producir un overflow.
Se puede usar la letra S para indicar que es un número entero corto:
Dim unShort As Short = 32000S

Single System.Single 4 bytes Número de coma flotante de precisión simple.
Valores:
de -3.4028235E+38 a -1.401298E-45 para valores negativos;
de 1.401298E-45 a 3.4028235E+38 para valores positivos.

Se puede convertir a: Double o Decimal sin producir overflow.
Se pueden usar la letra F y el símbolo ! para indicar que es un número Single:
Dim unSingle As Single = 987.125F
Dim unSingle2 As Single = 65478.6547!

String
(cadenas de longitud variable)
System.String (clase) Depende de la plataforma Una cadena de caracteres Unicode.
Valores:
de 0 to aproximadamente 2 billones (2^31) de caracteres Unicode.

Se puede usar el símbolo $ para indicar que una variable es un String.

Tipos definidos por el usuario
(estructuras)
(heradada de  System.ValueType) Depende de la plataforma Cada miembro de la estructura tiene su rango, dependiendo del tipo de dato que representa.

 

En la tabla anterior tienes los tipos de datos que podemos usar en vb.NET y por tanto, de los que podemos declarar variables.
Por ejemplo, si queremos tener una variable en la que guardaremos números enteros, (sin decimales), los cuales sabemos que no serán mayores de 32767 ni menores de -32768, podemos usar el tipo Short:
Dim unShort As Short
Después podemos asignar el valor correspondiente:
unShort = 15000

Sobre la necesidad u obligatoriedad de declarar las variables:

He de aclarar que el Visual Basic no "obliga" a que se declaren todas las variables que vayamos a usar.
Existe una instrucción, (Option Explicit), que gracias a las fuerzas de la Naturaleza, (por no decir gracias a Dios, que hay mucho ateo por ahí suelto), ahora viene puesta por defecto; la cual si que obliga a que declaremos las variables, pero si quitamos esa instrucción, entonces podemos hacer perrerías y declarar las variables si nos da la gana, etc...
¡Que bien! estarás diciendo... ¡la libertad total!
¡Pues no! tanto anarquismo no es bueno... porque después te acostumbras y ¿que pasa? palos vienen, palos van... y no me refiero a palos físicos... sino a los palos que te dará el programa por no haber sido un poco más "conservador"... (espero que tantos símiles políticos no te alteren...)

La cuestión es que siempre debes declarar las variables, e incluso te diría más: siempre debes declarar las variables del tipo que quieres que dicha variable contenga, lo resalto porque esto te evitará quebraderos de cabeza... ¡créeme!
Ya que, puedes declarar variables sin tipo específico:
Dim unaVariable
que en realidad es como si la hubieses declarado del tipo Object, (As Object), por tanto aceptará cualquier tipo de datos, pero esto, acuérdate de lo que te digo, no es una buena práctica.

Si quieres llevarte bien conmigo, declara siempre las variables.

De todas formas, voy a decirte cómo hacer que no tengas que declarar las variables, por si eres masoquista y te gusta sufrir... de camino, también te voy a decir dónde está la otra opción que te pido encarecidamente que siempre uses, me refiero a la opción Option Strict, ésta opción, si se activa, se indica con Option Strict On, obligará a que los tipos de datos que uses sean del tipo adecuado, de esta forma, aunque es un verdadero "peñazo", (por no decir coñazo, ya que a algunos les puede parecer improcedente), hará que las cosas las hagas o las programes cómo debes... seguramente acabarás dejando esa opción en el valor que el vb.NET trae por defecto... valor que no creo que cambien en la versión definitiva del Visual Studio .NET, cosa que me agradaría un montón... (en este caso no se si el masoca soy yo, ya que usando Option Strict On es más complicado hacer las conversiones entre tipos diferentes de datos, pero...)
Por ejemplo, con el Option Strict On no podemos hacer esto:
Dim unChar As Char = "N", ya que "N" es una constante del tipo String.
El compilador de Visual Basic nos diría algo así:
Option Strict no permite la conversión entre Char y String

Ahora veremos algunos ejemplos.
Primero vamos a ver dónde se puede cambiar esas opciones, así como alguna otra más, que en su momento también veremos.

Para acceder a las propiedades del proyecto, debes seleccionar el proyecto en la ventana del explorador de proyectos, una vez seleccionado, puedes usar el botón derecho del ratón y del menú que te muestra, seleccionar Propiedades... o bien, en el menú Proyecto, seleccionar Propiedades... (recuerda que si no está seleccionado el proyecto en el explorador de proyectos, ese menú no mostrará la opción de Propiedades).
Te mostrará una ventana de configuración, con varias opciones, selecciona Build del panel izquierdo y en el derecho te mostrará lo mismo que en la figura 1:


Figura 1

Estos son los valores que yo te recomiendo. También te los recomiendan otros muchos programadores, a los cuales parece ser que Microsoft no tiene tan en cuenta como dice... en fin...

Lo del Option Compare dependerá, de si quieres que las cadenas se comparen diferenciando las mayúsculas de las minúsculas o no.
Con el valor Binary se diferencian las mayúsculas de las minúsculas y con el otro valor: Text, no se hace ningún tipo de distinción, cosa que en algunas ocasiones puede resultar útil, pero que mediante código se puede solventar.

Por tanto, te pido, te ruego, te suplico, (hasta me pongo de rodillas si es necesario, para que me hagas caso), que siempre tengas asignado el valor ON tanto en Option Explicit como en Option Strict.
Gracias.

Después de las recomendaciones y súplicas, a las que espero que hagas caso, sigamos con esto de las declaraciones de las variables, e incluso de las constantes, ya que también podemos declarar constantes.

Las variables se pueden declarar de dos formas, aunque básicamente es lo mismo:
1.- Declarando la variable y dejando que VB asigne el valor por defecto.
2.- Declarando la variable y asignándole el valor inicial que queramos que tenga.

Por defecto, cuando no se asigna un valor a una variable, éstas contendrán los siguientes valores, dependiendo del tipo de datos que sea:
- Las variables numéricas tendrán un valor CERO.
- Las cadenas de caracteres una cadena vacía: ""
- Las variables Boolean un valor False (recuerda que False y CERO es lo mismo)
- Las variable de tipo Objeto tendrán un valor Nothing, es decir nada, un valor nulo.

Por ejemplo:
Dim i As Integer
Tendrá un valor inicial de 0

Pero si queremos que inicialmente valga 15, podemos hacerlo de cualquiera de estas dos formas:

1.)
Dim i As Integer
i = 15

2.)
Dim i As Integer = 15

Esta segunda forma es exclusiva de la versión .NET de Visual Basic, (también de otros lenguajes, pero es algo nuevo para los que tratamos con VB).
Mientras que la forma mostrada en el punto 1.) es la forma clásica, (la única que se puede usar en las versiones anteriores de VB)

Las constantes se declaran de la misma forma que la indicada en el punto 2.), ya que no se podrían declarar como lo mostrado en el punto 1.), por la sencilla razón de que a una constante no se le puede volver a asignar ningún otro valor, ya que si no, no serían constantes, sino variables.
Por ejemplo:
Const n As Integer = 15

¿Qué ventajas tiene usar constantes en lugar de usar el valor directamente?
Pues que, hay ocasiones en las que dicho valor se repite en un montón de sitios, y si por una casualidad decidimos que en lugar de tener el valor 15, queremos que tenga el 22, por ejemplo, siempre será más fácil cambiar el valor que se le asigna a la constante en la declaración, que tener que buscar los sitios en los que usamos dicho valor y cambiarlos, con la posibilidad de que se nos olvide o pasemos por alto alguno y entonces habremos "metido la pata", (por no decir jodido la marrana, por aquello de que... ¡Guille!, que ya sabemos que no quieres herir la sensibilidad de nadie, así que... lo mejor es que evites decir esas palabras malsonantes...)

Para declarar una constante de tipo String, lo haremos de esta forma:
Const s As String = "Hola"

De igual manera, para declarar una variable de tipo String y que contenga un valor, lo haremos de esta forma:
Dim Nombre As String = "Guillermo"

Es decir, en las variables usaremos la palabra DIM, mientras que en las constantes usaremos CONST.
Después veremos algunas variantes de esto, aunque para declarar constantes, siempre hay que usar Const.

Podemos usar cualquier constante o variable en las expresiones, (¿recuerdas lo que es una expresión?), e incluso, podemos usar el resultado de esa expresión para asignar un valor a una variable.

Por ejemplo:
Dim x As Integer = 25
Dim i As Integer

i = x * 2

En este caso, se evalúa el resultado de la expresión, (lo que hay a la derecha del signo igual), y el resultado de la misma, se asigna a la variable que estará a la izquierda del signo igual.

Incluso podemos hacer cosas como esta:

i = i + 15

Con esto, estamos indicándoles al VB que: calcula lo que actualmente vale la variable i, súmale el valor 15 y el resultado de esa suma, lo guardas en la variable i.
Por tanto, suponiendo que i valiese 50, después de esta asignación, su valor será 65, (es decir 50 que valía antes más 15 que le sumamos).

Esto último se llama incrementar una variable, y el vb.NET tiene su propio operador para estos casos, es decir cuando lo que asignamos a una variable es lo que ya había antes más el resultado de una expresión:

i += 15

Aunque también se pueden usar: *=, /=, -=, etcétera, dependiendo de la operación que queramos hacer con el valor que ya tuviera la variable.

Por tanto i = i * 2, es lo mismo que i *= 2

Por supuesto, podemos usar cualquier tipo de expresión, siempre y cuando el resultado esté dentro de los soportados por esa variable:
i += 25 + (n * 2)

Es decir, no podemos asignar a una variable de tipo numérico el resultado de una expresión alfanumérica:
i += "10 * 25"

Ya que "10 * 25" es una constante de tipo cadena, no una expresión que multiplica 10 por 25.
Al estar entre comillas dobles se convierte automáticamente en una constante de cadena y deja de ser una expresión numérica.

Y si tenemos Option Stric On, tampoco podríamos usar números que no fuesen del tipo Integer:
i += 25 * 3.1416

Ya que el VB se quejará... aunque para solventar estos inconvenientes existen unas funciones de conversión, que sirven para pasar datos de un tipo a otro.

No vamos a profundizar, pero para que sepas que haciendo las cosas como se deben hacer... casi todo es posible, aunque lo que esté escrito dentro de comillas dobles o esté contenido en una variable de cadena no se evalúa... lo más que podemos hacer es convertir esa cadena en un valor numérico, en el caso de "10 * 25", el resultado de convertirlo en valor numérico será 10, ya que todo lo que hay después del 10, no se evalúa... simplemente ¡porque no es un número! son letras, que tienen el "aspecto" de operadores, pero que no es el operador de multiplicar, sino el símbolo *.

Por tanto, esto: i = Val("10 * 25")
es lo mismo que esto otro: i = Val("10")

En este caso, usamos la función Val para convertir una cadena en un número, pero ese número es del tipo Double y si tenemos Option Strict On, no nos dejará convertirlo en un Integer... así de "estricto" es el Option Strict.

Para solucionarlo, usaremos la función CType:
i = CType(Val("10 * 25"), Integer)
Con esto le estamos diciendo al VB que primero convierta la cadena en un número mediante la función Val, (que devuelve un número de tipo Double), después le decimos que ese número Double lo convierta en un valor Integer.

También podríamos hacerlo de esta otra forma:
i = CInt(Val("10 * 25"))

Pero cuidado con los valores que se evalúan, ya que si el valor que se quiere asignar no "cabe" en la variable a la que lo asignamos, nos dará un error de overflow... es decir que el número que queremos asignar es más grande de los que ese tipo de datos puede soportar... para solucionar esto, habrá que usar un tipo de datos que soporte valores mayores... a eso es a lo que me refería con lo de la conversión a otros tipos sin producir overflow de la tabla anterior.

Por ejemplo:
i = CInt(Val("25987278547875"))
dará error, porque el número ese que está dentro de las comillas es demasiado grande para almacenarlo en una variable de tipo Integer.

Veamos un resumen de las distintas funciones de conversión de tipos y algunos ejemplos:
(estos están tomados de la ayuda de Visual Basic .NET)

Nombre de la función Tipo de datos que devuelve Valores del argumento "expresion"
CBool(expresion) Boolean Cualquier valor de cadena o expresión numérica.
CByte(expresion) Byte de 0 a 255; las fracciones se redondean.
CChar(expresion) Char Cualquier expresión de cadena; los valores deben ser de 0 a 65535.
CDate(expresion) Date Cualquier representación válida de una fecha o una hora.
CDbl(expresion) Double Cualquier valor Duoble, ver la tabla anterior para los valores posibles.
CDec(expresion) Decimal Cualquier valor Decimal, ver la tabla anterior para los valores posibles.
CInt(expresion) Integer Cualquier valor Integer, ver la tabla anterior para los valores posibles, las fracciones se redondean.
CLng(expresion) Long Cualquier valor Long, ver la tabla anterior para los valores posibles, las fracciones se redondean.
CObj(expresion) Object Cualquier expresión válida.
CShort(expresion) Short Cualquier valor Short, ver la tabla anterior para los valores posibles, las fracciones se redondean.
CSng(expresion) Single Cualquier valor Single, ver la tabla anterior para los valores posibles.
CStr(expresion) String Depende del tipo de datos de la expresión.
    -
Nota:
Todos los objetos de vb.NET tienen unos métodos para realizar conversiones a otros tipos, al menos de número a cadena, ya que tienen la propiedad .ToString que devuelve una representación en formato cadena del número en cuestión (igual que CStr).
-
CType(expresion, Tipo) El indicado en el segundo parámetro Cualquier tipo de datos
     
Val(expresion) Double Una cadena de caracteres.
Fix(expresion) Depende del tipo de datos de la expresión Cualquier tipo de datos
Int(expresion) Depende del tipo de datos de la expresión Cualquier tipo de datos

Quiero hacer hincapié en las dos últimas funciones, sobre todo si ya has usado anteriormente el Visual Basic e incluso el Basic de MS-DOS, ya que por tradición esas dos funciones devolvían valores enteros de tipo Integer.
Ahora, a pesar de lo que la ayuda de VB.NET pueda decir, ya que en un sitio dice una cosa y en otro dice otra, Int y Fix devuelve un valor del mismo tipo que el que se indica en el parámetro o expresión, pero sin decimales.

Aunque si esos números son negativos, Fix devuelve el siguiente valor igual o mayor que el número indicado, mientras que Int lo hace con el primer número menor o igual...
Por ejemplo: Fix(-8.4) devuelve -8, mientras que Int(-8.4) devolverá -9.
En caso de que sean positivos, las dos funciones devuelven el mismo valor: Int(8.4) devuelve 8, lo mismo que Fix(8.4).

Haz pruebas por tu cuenta usando Option Strict On y Off, para que veas porqué algunas veces es conveniente dejarlo en On para que nos avise de que algunas operaciones que hacemos pueden no dar los resultados esperados.

 

Evaluar expresiones lógicas.

El siguiente tema del que vamos a tratar son las expresiones lógicas.
Es decir evaluar expresiones cuyo resultado pueda ser un valor verdadero o falso.

En la entrega anterior, vimos, aunque no te lo expliqué a fondo, las instrucciones IF / THEN...
Ahora si que te lo voy a explicar, aunque estas instrucciones se usan muy a menudo, lo que ahora no entiendas, lo comprenderás después de que lo repitamos hasta la saciedad, pero al menos te voy a dar una pequeña explicación para que sepas para que se usan y sobre todo cómo se usan.

Hay ocasiones en las que necesitaremos decidir que hacer dependiendo de algún condicionante, por ejemplo, en la entrega anterior teníamos que comprobar si la tecla que se había pulsado era la tecla Suprimir y si era así, hacer algo, en aquella ocasión, eliminar elementos de un ListBox.

Por tanto podemos decir que para tomar decisiones usaremos:

If <expresión a evaluar> Then <Lo que haya que hacer si la expresión evaluada devuelve Verdadero>

Esta es la forma más simple, ya que aquí lo que se hace es evaluar la expresión que se indica después de IF y si esa expresión devuelve un valor verdadero, (es decir es verdad), se ejecutan los comandos que haya después de THEN y si esa expresión no es cierta, se ejecuta lo que haya en la siguiente línea.

Eso mismo también se suele usar de esta otra forma:
If <expresión a evaluar> Then
    <Lo que haya que hacer si la expresión evaluada devuelve Verdadero>
End If
Que para el caso es lo mismo, con la diferencia de que resulta más claro de leer y que podemos usar más de una línea de código, con lo cual resulta más evidente el que podamos hacer más cosas...

Pero si también queremos hacer algo cuando la expresión NO se cumpla, podemos usar la palabra ELSE y a continuación el código que queremos usar cuando la expresión no se cumpla.

If <expresión a evaluar> Then <Lo que haya que hacer si la expresión evaluada devuelve Verdadero> Else <Lo que haya que hacer si no se cumple> (todo en una misma línea)

O mejor aún de esta otra forma, que además queda más claro y evidente lo que queremos hacer:

If <expresión a evaluar> Then
    <Lo que haya que hacer si la expresión evaluada devuelve Verdadero>
Else
    <Lo que haya que hacer si no se cumple>
End If

Después de Else podemos usar otro IF si así lo creemos conveniente, esto es útil cuando queremos comprobar más de una cosa y dependiendo del valor, hacer una cosa u otra:

If a = 10 Then
   ' Lo que sea que haya que hacer cuando a vale 10
ElseIf a = 15 Then
    ' Lo que haya que hacer cuando a vale 15
Else
    ' Lo que haya que hacer en caso de que a no valga ni 10 ni 15
End If
' Esto se ejecuta siempre después de haberse comprobado todo lo anterior.

Fíjate que en medio de cada If / Then he usado lo que se llama un comentario.
Los comentarios empiezan por una comilla simple (apóstrofe), en los comentarios podemos poner lo que queramos, con la seguridad de que no será tenido en cuenta por el Visual Basic.
Los comentarios sólo pueden ocupar una línea, salvo que dicha línea al final tenga el signo _ (subrayado bajo), lo cual indica al IDE que se quiere continuar en la siguiente línea.
Ese símbolo se puede llamar "continuador de línea" y lo podemos usar siempre que queramos, no sólo para los comentarios.

Los comentarios también se pueden hacer con la palabra reservada Rem, pero eso es algo que ya nadie usa.

Sigamos con el If.
Si tenemos el Option Strict On, la expresión que se use después de If debe devolver un valor del tipo Boolean, es decir, debe dar como resultado un valor True o False.
Si Option Strict está en Off, el VB lo "convertirá" en un valor True o False, pero no te acostumbres a que VB haga las cosas medio-automáticas, ya que en ocasiones puede ser que ese automatismo no de como resultado lo que nosotros "creíamos" que iba a dar...

De todas formas, cuando el Visual Basic se encuentra con algo como esto:
If i > 25 Then
Lo que hace es evaluar la expresión y al comprobar si el valor de i es mayor de 25 y en caso de que así sea, devolverá un valor True y si resulta que i no es mayor de 25, devolverá False.
A continuación se comprueba ese valor devuelto por la expresión y si es verdadero (True) se hace lo que esté después del Then y si es falso (False), se hará lo que esté después del Else, (si es que hay algún Else...)

La expresión que se indica después de IF puede ser una expresión "compuesta", es decir se pueden indicar más de una expresión, pero para ello hay que usar algunos de los operadores lógicos, tales como AND, OR o NOT.

Por ejemplo si queremos comprobar si el valor de i es mayor que 200 o es igual a 150, haríamos algo así:
If i > 200 Or i = 150 Then

Pero si lo que queremos es que el valor de i sea mayor que 200 y menor de 500, habría que usar AND:
If i > 200 And i < 500 Then

Por último, si queremos que la condición se cumpla cuando i NO sea igual a 100:
If Not i = 100 Then
Aunque esto mismo podríamos haberlo hecho de esta otra forma:
If i <> 100 Then

Con AND se cumple la verdad si las dos expresiones son verdaderas.
Con Or se cumple si cualquiera de las expresiones es verdadera.
Por supuesto, podemos usar expresiones en las que se mezclen AND y OR, aunque en estos casos es recomendable el uso de paréntesis para separar las expresiones "dudosas".

Por ejemplo:
If A = 100 Or B > 50 And x = n * 2 Then

¿Que quiere decir esto?
¿Que pasa si A es igual a 100 pero B es menor de 50, y x es igual a n * 2?
Que se cumple, igual que si x no fuese igual a n * 2, pero si A no vale 100, sólo se cumpliría si B fuese mayor de 50.
Es decir, la última expresión sólo se tiene en cuenta si A no vale 100 y B es mayor de 50.
Por tanto quedaría más claro de esta otra forma:
If A = 100 Or (B > 50 And x = n * 2) Then

Aunque si nuestra intención era otra, podíamos haberlo escrito de esta otra forma:
If (A = 100 Or B > 50) And x = n * 2 Then
En cuyo caso sólo se cumplirá cuando A sea 100 o B mayor de 50, pero SIEMPRE x debe ser igual a n * 2

Es decir, usa los paréntesis dependiendo de lo que realmente quieras comprobar...

De todas formas, he de aclararte, sobre todo si has usado versiones anteriores de Basic, que en vb.NET las expresiones se van evaluando de izquierda a derecha y se van descartando según se van encontrando cosas que "cumplan" lo que allí se comprueba.
Antes se evaluaban todas las expresiones, (con las posibles consecuencias que podían tener si alguna de ellas contenía una función que hacía algún tipo de cálculo largo y al final resultaba que no era necesario haberlo calculado...) y después se empezaba a descartar posibilidades...

Ya que estamos, decirte que los símbolos que podemos usar para efectuar comparaciones, son estos:
= igual
< menor que
> mayor que
<= menor o igual
>= mayor o igual
<> distinto
Seguramente ya lo sabías, pero... nunca está de más.

Para terminar, decirte que las expresiones que se pueden usar con el IF pueden ser tanto numéricas como alfanuméricas o de cadena, ya que también puede ser conveniente saber si el contendido de la cadena s es mayor que la palabra "hola", aunque en este tipo de expresiones, se evalúa tal y como si se fuese a clasificar... es decir "ahora" será menor que "hola", ya que si lo clasificáramos, tendríamos que la letra A está antes que la H.
Aquí también juega un poco el Option Compare Binary ya que, como te dije, se hacen distinciones de mayúsculas y minúsculas, aunque a la hora de clasificar (u ordenar), las minúsculas están después de las mayúsculas, por tanto "Amigo" será menor que "amigo" si es que tenemos puesto el Option Compare Binary.
Pero serán iguales si está puesto el Option Compare Text.

Si quieres hacer algunas pruebas, recuerda que puedes crear un proyecto del tipo Consola y usar el Console.WriteLine para mostrar cosas en la pantalla, aunque debes acordarte al final de poner un Console.ReadLine para que la pantalla se quede visible hasta que pulses Intro.

Por ejemplo podrías hacer estas comprobaciones y antes de ejecutar el programa intentar saber que es lo que haría.
(aunque también te dejo las pruebecillas que he hecho para explicarte todo esto... no fuese que metiera la pata...)

'
Dim unByte As Byte = 129
Dim unBoolean As Boolean = True
Dim unChar As Char = "N"c
'Dim unChar2 As Char = "B" ' (Con Option Strict On da error)
Dim unaFecha As Date = #10/27/2001#
Dim unDecimal As Decimal = 99912581258.125D
Dim unDecimal2 As Decimal = 9876543210123456@
Dim unDoble As Double = 125897.12045R
Dim unDoble2 As Double = 2457998778745.4512#
'Dim unInt As Integer = 24579987787456 ' (Con Option Strict On da error)
Dim unEntero As Integer = 250009I
Dim unEntero2 As Integer = 652000%
Dim unLong As Long = 123456789L
Dim unLong2 As Long = 987654&
Dim unShort As Short = 32000S
'
Const n As Integer = 15
'
Dim i As Integer

i = 10
i += 25 + (n * 2)
Console.WriteLine("(i=10, n=15), 'i += 25 + (n * 2)' es igual a: " & CStr(i))
i += CType(Val("10 * 25"), Integer)
'i = CInt(Val("25987278547875")) ' (dará error)
i = CInt(Val("25000"))
Console.WriteLine(i)
'
unDoble = Fix(unDoble2)
Console.WriteLine("unDoble = Fix(" & unDoble2.ToString & ") : " & unDoble.ToString)
unDoble2 = 2457998778745.665#
unDoble = CInt(unDoble2)
Console.WriteLine("unDoble = Int(" & unDoble2.ToString & ") : " & unDoble.ToString)
'unDoble = CInt(unDoble2)
'Console.WriteLine("unDoble = CInt(" & unDoble2.ToString & ") : " & unDoble.ToString)
'
unDoble = Fix(8.9)
Console.WriteLine("unDoble = Fix(8.9) : " & unDoble.ToString)
'
unDecimal = Fix(8.9D)
Console.WriteLine("unDecimal = Fix(8.9D) : " & unDecimal.ToString)
'
Console.WriteLine("i vale: " & CStr(i))
If i > 1500 Then
    Console.WriteLine("i es mayor de 1500")
End If
'
i = 200
Console.WriteLine("Se asigna el valor " & CStr(i) & " a i")
If i > 15 + n Then
    Console.WriteLine("i es mayor de 15 + n")
Else
    Console.WriteLine("i NO es mayor de 15 + n")
End If
'
If i > 200 Or i < 500 Then
    Console.WriteLine("el valor de i es mayor de 200 O menor de 500")
End If
If i > 100 And i < 500 Then
    Console.WriteLine("el valor de i es mayor de 100 Y menor de 500")
End If
If Not i = 100 Then
    Console.WriteLine("i NO vale 100")
End If

Dim a As Integer = 100
Dim b As Integer = 50
Dim x As Integer = n * 2 + 10
If a = 100 Or (b > 50 And x = n * 2) Then
    Console.WriteLine("SI: If a = 100 Or b > 50 And x = n * 2 Then")
End If

If "amigo" > "Amigo" Then
    Console.WriteLine("amigo > Amigo")
Else
    Console.WriteLine("amigo no es > Amigo")
End If

Console.ReadLine()


Y hasta aquí hemos llegado.
Espero que ya sepas qué es una variable, y que también sepas declararlas y asignarles valores "predeterminados" o lo que es lo mismo iniciarlas con un valor al declararlas, en lugar del valor que por defecto le asigna el VB.
También sabrás cómo tomar decisiones... aunque sea dentro del código de un programa...
Ahora estás preparado para "toparte" con cualquier tipo de datos de vb.NET y saber cuales son los valores máximos y mínimos que se les puede asignar, también sabes o al menos deberías saber qué funciones se pueden usar para convertir una variable de un tipo en otro distinto.
Igualmente sabrás que el Guille prefiere que uses el Option Strict On y que declares todas las variables con el tipo de datos que van a tener.
En fin... un montón de cosillas que a la larga te resultarán de utilidad.

En la próxima entrega veremos cómo declarar varias variables en una misma línea y veremos algo que no todo el mundo acaba por comprender... la "visibilidad" o ámbito de las variables... y algunas cosas más...

Pero eso, en la próxima entrega.

Nos vemos.
Guillermo
Nerja, 27 de Octubre de 2001


Haz tu donativo a este sitio con PayPal
 

Busca en este sitio con Google
 

La fecha/hora en el servidor es: 04/08/2021 20:15:37

La fecha actual GMT (UTC) es: 

©Guillermo 'guille' Som, 1996-2021

 

Has entrado usando el host: elguille.info
Puedes verlo también en: https://mundoprogramacion.com/net/cursovb.net/tutorvbnet04.aspx