Nuestro programa anterior funciona muy bien, pero siempre que lo ejecutemos va a suceder lo mismo, borrará la pantalla y escribirá un rótulo que diga "Hola Mundo". Vamos a escribir un programa un poco más complicado que nos pregunte nuestro nombre y nos salude. El resultado (lo que se ve en pantalla al ejecutarlo) podría ser el siguiente:
¿Cómo te llamas? juanma Hola juanma
El programa borrará la pantalla (Esto lo vamos a hacer siempre para no confundirlo con lo anterior que pueda haber), nos preguntará por nuestro nombre, nos dejará escribirlo con el teclado y cuando lo hagamos lo guardará en "algún sitio", después escribirá "Hola " seguido de nuestro nombre que lo habrá sacado del "sitio" donde lo guardó antes.
Vamos a ver como será el código:
CLS INPUT "¿Cómo te llamas? ", nombre$ PRINT "hola "; nombre$
Ahora tenemos una instrucción nueva, INPUT, que lleva dos parámetros separados por una coma. Esta instrucción lo que hace es dejar al usuario del programa que escriba algo con el teclado y cuando pulse la tecla Enter lo guarda en memoria.
La primera parte "¿Cómo te llamas?" la escribe en pantalla tal como está para que el usuario sepa lo que se le pregunta.
La segunda parte es una Variable, es decir el nombre que le hemos puesta a un "trozo" de la memoria del ordenador dónde vamos a guardar lo que ha escrito el usuario y que le hemos llamado nombre$ para después poder localizarlo.
La siguiente instrucción, PRINT, es la misma que en el anterior programa. Lo que hace es escribir lo que lleva detrás. En esta ocasión va a escribir dos cosas, primero "Hola " con su espacio detrás tal como aparece dentro de las comillas, y a continuación todo seguido escribirá el valor que haya guardado en la variable nombre$. No escribirá Hola nombre$ porque nombre$ no está entre comillas.
Esto de las variables es una de las cosas más importantes de los lenguajes de programación. Los programas van a manejar datos que estarán grabados en la memoria del ordenador. Si no existieran las variables tendríamos que saber en que posición exacta los guardamos y después para recuperarlos habría que escribir los números de las direcciones de memoria y saber exactamente cuanto largo son los datos. Esto es muy complicado (Esto es lo que se hace en los Lenguajes Ensambladores), para hacerlo aquí más sencillo usaremos los nombres de variables y QBasic se encargará de ver en que lugar físico de la memoria mete la información y después de saber recuperarla cuando se la pidamos.
Nuestros programas van a poder trabajar con varios tipos de información, como son letras, números con o sin decimales, etc. Nuestro programa anterior usaba una variable de texto o de cadena de caracteres para almacenar nuestro nombre, pero en otros casos habrá que almacenar números más o menos grandes, por ejemplo.
Veamos ahora los tipos de datos que hay en QBasic.
| Nombre | Sufijo | Descripción | Mínimo y máximo |
| STRING | $ | Texto con cualquier carácter | 0 a 32767 caracteres |
| INTEGER | % | Números enteros | -32768 a 32767 |
| LONG | & | Números enteros más grandes | 2.147.483.647 a -2.147.483.648 |
| SINGLE | ! | Números con decimales | 2,8x1045 a -2,8x1045 |
| DOUBLE | # | Números con más decimales | 4,9x10324 a -4,9x10324 |
Vamos ahora a ver lo que significa esta tabla.
En QBasic las variables van a ser de uno de estos cinco tipos.
Si queremos almacenar palabras, nombres, fechas, horas, códigos postales, números de teléfono, DNIs, matrículas, etc. tendremos que usar una variable de tipo Cadena (STRING) cuyo nombre llevará al final el carácter $.
Para guardar números tendremos que usar alguno de los otros cuatro tipos de variables.
Si nuestros números no van a llevar decimales usaremos una variable de tipo entero (INTEGER) que ocupa poca memoria (2 bytes) y además el ordenador trabaja con ellas muy rápido.
Si los números enteros van a llegar a ser mayores de 32.767 tendremos que utilizar una variable de tipo Entero largo (LONG) en la que "caben" hasta números mayores que dos mil millones.
Si vamos a usar números reales (que pueden llevar decimales) tendremos que usar variables de precisión sencilla (SINGLE).
Para algún cálculo que necesite obtener resultados con muchos decimales usaremos las variables de doble precisión (DOUBLE) que son más lentas de manejar y ocupan más memoria que las anteriores.
Si intentamos guardar en una variable un valor más grande (o más pequeño si es negativo) de lo que permite su tipo de datos, se producirá un "Error de Tiempo de Ejecución" y el programa se parará.
Cada variable llevará un nombre que nosotros decidamos para usarla en nuestro programa. Tenemos que elegir nombres que no sean demasiado largos y que tengan algo que ver con lo que va a contener la variable.
Los nombres de variables deben cumplir estas condiciones:
Estos nombres de variable son válidos.
Estos otros nombres no son válidos
Hay que tener en cuenta que QBasic no distingue de mayúsculas y minúsculas, por lo tanto una variable que se llame nivel será la misma que Nivel, NIVEL o niVEL. De hecho cuando cambiemos las mayúsculas y minúsculas de una variable se cambiarán todas las que ya haya escritas en el resto del programa, es decir, si hemos escrito en un sitio puntos y después escribimos PuntoS en otro sitio, la anterior también se cambiará a PuntoS.
Por convenio los nombres de las variables se escriben todo en minúsculas para diferenciarlos visualmente de las Palabras Claves que se van poniendo en mayúsculas automáticamente. Si una variable lleva dos palabras se suele escribir la primera letra de la segunda palabra en mayúsculas para separar un poco, por ejemplo nombreJugador totalActivo o nuevoRegistro.
En las variables que deberían llevar la ñ hay varias formas: Para año se suele escribir cosas como ano, anno o anyo. De los acentos pasamos. En Visual Basic se pueden usar nombres de variables con ñ y acentos, pero en QBasic no.
En otros lenguajes de programación (la mayoría) hay que Declarar las variables al principio del programa. Esto significa escribir una instrucción que diga algo así como "Voy a usar una variable que se va a llamar nombre y va a ser de tipo cadena" y así con cada una de las variables que vayamos a usar en el programa.
En QBasic NO hace falta declarar las variables.
La primera vez que escribimos el nombre de una variable QBasic reserva en memoria el espacio para utilizarla y ya está disponible durante el resto del programa, pero ¿Cómo sabe QBasic del tipo que queremos que sea la variable?
En la tabla de tipos de datos había una columna que ponía Sufijo y que para cada tipo de datos tenía un símbolo distinto.
| Nombre | Sufijo |
| STRING | $ |
| INTEGER | % |
| LONG | & |
| SINGLE | ! |
| DOUBLE | # |
Para indicar el tipo escribiremos uno de estos sufijos detrás del nombre de la variable, por ejemplo si nombre va a contener texto escribiremos nombre$ (Como hicimos en el ejemplo). A esto se llama declaración implícita, ya que dentro del nombre va incluído el tipo de datos.
Ahora ¿Que pasa si escribimos en distintos sitios el mismo nombre de variable con distintos sufijos?, por ejemplo:
variable$ = "Esto es un texto" variable% = 2000 PRINT variable$ PRINT variable%
Lo que ocurrirá es que QBasic entiende que son dos variables completamente distintas, cada una de un tipo y nos da como resultado:
Esto es un texto 2000
Esto puede producir un Error de Lógica, es decir, el programa funciona perfectamente, pero a lo mejor no hace lo que esperábamos. Para evitar esto hay que poner a las variables nombres más descriptivos, y si en este caso de verdad queríamos dos variables es mejor ponerles nombres distintos para evitar confusiones.
También puede pasar que se nos olvide ponerle a una variable el sufijo de tipo, entonces QBasic la tratará como de tipo real de precisión sencilla, que es el tipo predeterminado. Para ver como se cambia el tipo predeterminado mira en la ayuda de QBasic la instrucción DEFINT y similares.
En la práctica a partir de ahora vamos a poner el sufijo $ a las variables de cadena y las demás las dejamos sin sufijo para que sean reales que admiten números muy grandes con o sin decimales. Si fuéramos a hacer programas muy depurados sería conveniente usar los otros tipos de variables cuando fuera necesario para que fueran más eficientes con el consumo de memoria.
Las variables al ser usadas la primera vez antes de asignarles (guardar en ellas) ningún valor contienen un texto de longitud cero si son de cadena o el número 0 si son de otro tipo. En otros lenguajes de programación esto no es así y contienen cualquier valor que hubiera en esa posición de memoria de otros programas que la hubieran usado antes, por lo que se pueden producir errores. Aquí no.
Lo último que queda es saber que el Tiempo de Vida de una variable es desde que se usa por primera vez (desde que se declara o se ejecuta la línea donde su nombre aparece por primera vez) hasta que el programa termina, después su valor se pierde. No podemos contar con que tengamos valores en memoria guardados de la vez anterior que ejecutamos el programa.
No tener que declarar las variables puede parecer una ventaja, pero por el contrario ES UN GRAVE INCONVENIENTE de QBasic.
El problema menos importante es que usaremos nuevas variables cada vez que queramos sin acordarnos de las anteriores que a lo mejor ya no volvemos a usar, y por lo tanto nuestros programas van a usar más memoria de la necesaria.
El problema más grave es que si en un sitio escribimos mal el nombre de una variable (o confundimos el sufijo de tipo) QBasic se creerá que estamos usando una nueva variable y nuestro programa seguirá funcionando como si nada, pero los cálculos no saldrán bien.
Veamos el siguiente ejemplo, otra vez el programa saludador con un error de este tipo:
cls input "¿Cómo te llamas? ", nombre$ print "hola "; nomber$
Una vez que lo ejecutemos podría pasar esto:
¿Cómo te llamas? Juanma Hola
No ha producido ningún error de Tiempo de Ejecución (No se ha parado y ha terminado correctamente), pero no nos ha saludado con nuestro nombre!!!
Nuestro nombre lo guardó en la variable nombre$ cuando lo escribimos, pero al respondernos ha escrito "Hola " y a continuación el valor de la variable nomber$ que es otra variable nueva distinta y que está vacía. Aquí es muy sencillo de ver lo que pasa, pero en un programa de mil líneas con cuarenta variables puede ser muy complicado incluso saber cual variable es la que hemos escrito mal.
Por esto hay que tener ESPECIAL CUIDADO en QBasic al escribir los nombres de las variables. En otros lenguajes las variables están declaradas al principio y si escribimos alguna mal nos da un error de compilación de tipo "Identificador desconocido" y en muchos casos hasta nos señala la línea donde está la variable mal escrita para que la corrijamos.
En QBasic la mayoría de las veces que el programa funciona bien pero no hace lo que queremos es que hemos escrito mal el nombre de alguna variable. Cuando tenemos nombres de variables largos un truco para ver si están bien escritos todos es buscar una variable que esté bien escrita seguro y poner la última letra en mayúsculas, por ejemplo si tenemos
identificador
lo cambiaríamos por
identificadoR
que para QBasic sigue siendo lo mismo, pero al hacerlo se cambiarán todas las variables con nombre identificador por identificadoR en todo el programa y si al dar un repaso rápido vemos que alguna acaba con r minúscula es que alguna letra está mal escrita y habrá que repasarla y corregir el error.
