BASIC

3. Introducción a las variables

Habíamos visto cómo escribir un texto que habíamos fijado nosotros mismos desde el programa. Pero lo habitual no es escribir valores fijos, sino el resultado de una cierta operación, un valor introducido por el usuario, etc. Para eso se emplean las llamadas "variables": una variable es un espacio de memoria en el que podremos guardar un cierto dato y al que podremos asignar un nombre. Este dato lo podremos modificar cuando queramos. Por ejemplo, podemos reservar un espacio de variable y llamarlo "X" y guardar en él un cierto valor, así

10 LET X = 2 
20 PRINT "X VALE:" 
30 PRINT X

(Fuente "0301.bas". Probado en GwBasic 2.02, Locomotive Basic de Amstrad CPC, Commodore 64 Basic V2, Msx Basic 2.1)

Como se ve, la orden LET es la que permite dar un valor a una cierta variable. Para mostrar en pantalla el valor de una variable, utilizamos la orden PRINT, pero indicando el nombre de la variable sin comillas. El resultado del programa anterior sería:

X VALE:  
2

Más adelante podemos modificar el valor de X nuevamente:

10 LET X = 2 
20 PRINT "X VALE:" ; X 
30 LET X = 5 
40 PRINT "AHORA X VALE:" ; X

(Fuente "0302.bas". Probado en GwBasic 2.02, Locomotive Basic de Amstrad CPC, Commodore 64 Basic V2, Msx Basic 2.1)

El resultado de este programa sería:

X VALE: 2  
AHORA X VALE: 5
```basic

Aquí hay otra novedad: hemos incluido en una misma orden PRINT un texto entre comillas y una variable (sin comillas), separados por **punto y coma**, para que se escriban en la misma línea.

La orden LET **no es obligatoria** en la mayoría de las versiones del lenguaje BASIC, de modo que muchos BASIC permitirían que el programa anterior se escribiese así:

```basic
10 X = 2
20 PRINT "X VALE:" ; X 
30 X = 5 
40 PRINT "AHORA X VALE:" ; X

(Fuente "0303.bas". Probado en GwBasic 2.02, Locomotive Basic de Amstrad CPC, Commodore 64 Basic V2)

Si queremos que sea el usuario el que introduzca un valor para una variable, se usa la orden INPUT, así:

10 INPUT X 
20 PRINT "EL VALOR TECLEADO ES: " ; X 
30 PRINT "SU CUADRADO ES:" ; X*X

(Fuente "0304.bas". Probado en GwBasic 2.02, Locomotive Basic de Amstrad CPC, Commodore 64 Basic V2, Msx Basic 2.1)

La orden INPUT mostrará una interrogación para avisarnos de que está esperando un valor. Por ejemplo, si el usuario introduce el valor 3, en pantalla aparecería lo siguiente:

?3  
EL VALOR TECLEADO ES: 3  
SU CUADRADO ES: 9

También podemos indicar en la orden INPUT un texto entre comillas, para que aparezca delante de la interrogación (no en todas las versiones de BASIC, pero sí en la mayoría):

10 INPUT "QUE NUMERO DESEA ELEVAR AL CUADRADO"; X 
20 PRINT "EL VALOR TECLEADO ES: " ; X 
30 PRINT "SU CUADRADO ES:" ; X*X

(Fuente "0305.bas". Probado en GwBasic 2.02, Locomotive Basic de Amstrad CPC, Commodore 64 Basic V2, Msx Basic 2.1)

En las versiones que no acepten este formato de INPUT, la alternativa amigable será usar un PRINT para avisar al usuario y luego el INPUT para leer datos:

10 PRINT "QUE NUMERO DESEA ELEVAR AL CUADRADO"; 
20 INPUT X
30 PRINT "EL VALOR TECLEADO ES: " ; X 
40 PRINT "SU CUADRADO ES:" ; X*X

(Fuente "0306.bas". Probado en GwBasic 2.02, Locomotive Basic de Amstrad CPC, Msx Basic 2.1)

En Basic256, el texto de INPUT se debe separar de la variable con una "coma", no con "punto y coma", y la interrogación no aparecerá automáticamente, así que el programa quedaría así:

INPUT "QUE NUMERO DESEA ELEVAR AL CUADRADO? ", X 
PRINT "EL VALOR TECLEADO ES: " ; 
PRINT X 
PRINT "SU CUADRADO ES: " ; 
PRINT X*X

(Fuente "0307.bas". Probado en Basic256)

Ejercicio propuesto 3.1: Crea un programa que te pida dos números y muestre su suma

Hasta ahora sólo hemos usado una variable llamada X, pero este no es un nombre demasiado claro. Normalmente nos interesará tener nombres de variables más significativos. Puede ocurrir que alguna versión de BASIC antigua sólo permita nombres de variables formados por una única letra, pero lo habitual es que permitan nombres bastante largos:

10 PRIMERAVARIABLE = 20 
20 SEGUNDAVARIABLE = 55 
30 RESULTADO = PRIMERAVARIABLE * SEGUNDAVARIABLE 
40 PRINT "RESULTADO VALE:" ; RESULTADO

(Fuente "0308.bas". Probado en GwBasic 2.02, Locomotive Basic de Amstrad CPC, Commodore 64 Basic V2, Msx Basic 2.1)

En la gran mayoría de versiones del lenguaje BASIC, serán válidos nombres de variables que empiecen por una letra y después contengan letras o números (y en algún caso, algún otro símbolo, como el signo de subrayado). No podrán contener espacios, caracteres internacionales (letras acentuadas, eñes, etc.), ni casi ningún signo de puntuación (puntos, comas, etc.). Algunos símbolos especiales podrán aparecer al final del nombre de una variable, y tendrán un cierto significado, pero eso lo veremos un poco más adelante...

Eso sí, existen algunas versiones antiguas de BASIC que permiten nombres de variables largos, pero desprecian las letras que aparecen a partir de una cierta posición. Por ejemplo, si un intérprete de BASIC sólo considera las ocho primeras letras de cada variable, considerará que una variable llamada VARIABLETEMPORAL1 y otra llamada VARIABLETEMPORAL2 son la misma. Es algo que deberíamos comprobar con la versión de BASIC que usemos, porque puede dar lugar a errores muy difíciles de detectar.

Además, algunas versiones de BASIC no sólo usan los espacios como separadores sino que también miran dónde termina cada palabra reservada. En estos BASIC (como el de los Commodore 64 y las calculadoras programables CASIO FX), las órdenes "X=5:PRINTX" escribirían un 5 en pantalla, mientras que en la mayoría de versiones de BASIC obtendríamos un mensaje de error porque el sistema no sabría qué es "PRINTX". Por el mismo motivo, en estas versiones de BASIC no podremos crear variables cuyo nombre comience como una palabra reservada: "PRINTER=5" no estaría creando una variable PRINTER con el valor 5, sino que escribiría en pantalla si la variable ER tiene el valor 5 (hablaremos de comprobación de condiciones más adelante).

Otro problema que puede existir con las variables se debe al hecho de que en el lenguaje BASIC no es necesario declarar una variable antes de usarla: no hace falta decir "voy a usar una variable llamada X", sino que el propio intérprete de BASIC, cada vez que ve una variable nueva, la acepta como válida y le da el valor 0. ¿Qué problemas puede provocar esto? Vamos a verlo con un ejemplo:

10 PRIMERAVARIABLE = 20 
20 SEGUNDAVARIABLE = 55 
30 RESULTADO = PRIMERAVARIABLE * SEGUDNAVARIABLE 
40 PRINT "RESULTADO VALE:" ; RESULTADO

(Fuente "0309.bas". Probado en GwBasic 2.02, Locomotive Basic de Amstrad CPC, Msx Basic 2.1)

Me temo que el resultado que obtenemos no es el que queríamos obtener: 20*55 = 1100, pero sin embargo nuestro programa está respondiendo RESULTADO VALE: 0 ¿Por qué? El fallo está en la línea 30: no hemos escrito SEGUNDAVARIABLE, sino SEGUDNAVARIABLE, hemos cambiado de sitio las letras N y D. En otros lenguajes, esto haría que recibiésemos una aviso de que la variable llamada SEGUDNAVARIABLE no se ha declarado previamente, pero en BASIC no ocurre así: se da por sentado que hemos escrito correctamente la variable, y se le da el valor 0. Por eso el resultado de nuestro programa es 22*0 = 0, correcto para el intérprete de BASIC... pero posiblemente incorrecto para nosotros.

Esto supone que haya que teclear con MUCHO CUIDADO y que aún así se deba PROBAR todos los programas con varios datos, para los que sepamos el resultado que se deba obtener. En cuanto notemos algo raro, habrá que revisar el programa.

Algún BASIC muy moderno (como QBasic o Visual Basic) permitirá evitar este tipo de problemas, pero eso también lo veremos más adelante.

Las variables que hemos estado utilizando hasta ahora estaban almacenando números. Concretamente, almacenaban números enteros (sin decimales). Esto es lo que permitirá cualquier versión del lenguaje BASIC. En algunas versiones podremos almacenar otros tipos de datos, como números reales (con decimales), de distintas precisiones, y ya veremos cómo indicar a nuestro intérprete de BASIC que se trata de números reales o de cualquier otro tipo de datos.

Pero existe un tipo de datos que podremos emplear en casi cualquier versión de BASIC, y que se utiliza mucho en la práctica: se trata de cadenas de texto, conjuntos de una o más letras que utilizaremos para escribir mensajes en pantalla.

La variables que almacenen cadenas de texto deberán tener nombres terminados con el signo $:

10 LET NOMBRE$="JUAN PEDRO" 
20 PRINT "HOLA " ; NOMBRE$

(Fuente "0310.bas". Probado en GwBasic 2.02, Locomotive Basic de Amstrad CPC, Commodore 64 Basic V2, Msx Basic 2.1)

Podemos "concatenar" dos cadenas de texto con el signo "+", obteniendo una nueva cadena de texto formada por las dos de partida:

10 LET SALUDO$="HOLA " 
20 INPUT "INTRODUCE TU NOMBRE"; NOMBRE$ 
30 FRASE$ = SALUDO$ + NOMBRE$ 
40 PRINT FRASE$

(Fuente "0311.bas". Probado en GwBasic 2.02, Locomotive Basic de Amstrad CPC, Commodore 64 Basic V2, Msx Basic 2.1)

Así, si el usuario teclea ALBERTO cuando se le pide su nombre, el valor de FRASE$ (que se mostraría en pantalla en la línea 40) sería HOLA ALBERTO

Con Basic256, esta programa sería casi idéntico , salvo que el texto de INPUT se debe separar de la variable con una "coma":

SALUDO$ = "HOLA " 
INPUT "INTRODUCE TU NOMBRE: ", NOMBRE$ 
FRASE$ = SALUDO$ + NOMBRE$ 
PRINT FRASE$

(Fuente "0312.bas". Probado en Basic256

Ejercicio propuesto 3.2: Crea un programa que te pida tu nombre (por ejemplo, "Juan") y tu edad (por ejemplo, 15) y diga que aparentas tener menos años: "Hola, Juan, pareces tener menos de 15 años".

Ejercicio propuesto 3.3: Crea un programa que te pida tu nombre, tu apellido, y escriba "Bienvenido, sr. " seguido por tu apellido, una coma y tu nombre.