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