« Volver al inicio

¿Qué son las variables?

Vamos a imaginarnos que necesitamos calcular el área de un rectángulo. En el colegio nos enseñaron que el área se calcula multiplicando la base por la altura:

$$A = b × h$$

Si por ejemplo, queremos calcular el área de un rectángulo que mida 10 de ancho y 5 de alto, la fórmula se completaría así:

$$A = 10 × 5$$

Esto lo podemos trabajar en programación usando variables. Las variables nos las tenemos que imaginar como “cajitas” de datos que se almacenan en memoria, y que se pueden manipular y recuperar dentro del código de un programa para darle distintos usos.

En el ejemplo anterior, A podría ser una variable que almacene el área del rectángulo, mientras que b representaría la base del rectángulo y h a la altura. En C Sharp las declararíamos así:

int b = 10;
int h = 5;
int A = b * h;

Pero las buenas prácticas de programación nos exigen mayor claridad para ponerle nombres a las variables, de cara a que los programas sean más legibles. Igual pasan unas semanas, vemos nuestro propio código de nuevo y nos hemos olvidado de qué significa A, qué significa h, y qué significa b*. Y ya ni te cuento si una tercera persona intenta analizar nuestro código.

int base = 10;
int altura = 5;
int area = base * altura;

O también podemos declararlo al principio del código para más adelante darles otro valor, lo cual es también bastante común:

int base;
int altura;
int area;

...

base = 10;
altura = 5;
area = base * altura;

Si nos fijamos bien, a las variables les estamos asignando un valor

Tenemos que fijarnos en varias cosas aquí:

1. La variable area la asignamos en último lugar.
2. Las variables siempre las estamos declarando con int.
3. Todas las líneas acaban en ;
4. Usamos el asterisco como signo para multiplicar.

Si es la primera vez que te metes en programación o si aún tienes dudas sobre cómo funciona, quizá te interese seguir leyendo esta sección, pues vamos a profundizar un poco sobre el tema.

¿Por qué area va después?

Esto es importante empezar a controlarlo. Tenemos que saber que las líneas de código se ejecutan de arriba a abajo secuencialmente. Esto es, que detrás de una instrucción, viene otra.

De una forma visual, el código anterior se ejecutaría de esta forma (pero mucho más rápidamente):

Esto no siempre es así, pero eso ya lo veremos en estructuras de control.

Como la variable area depende de las variables base y altura, si asignamos el valor de area antes de asignarle valores a base y altura, el compilador nos devolverá error en el momento de evaluar la línea donde se intenta asignar el valor de area.

¿Por qué int?

Las variables, como hemos comentado antes, nos las tenemos que imaginar como si fueran “cajitas” abstractas con información dentro. Estas “cajas” ocupan un tamaño fijo en memoria y su información puede ser manipulada por el programador para darle diferentes usos en el código.

Dicha información puede ser un número, una letra, un texto, un número decimal, etc. Todo esto son tipos de datos simples y estos nunca pueden ser cambiados en una variable una vez que ha sido declarada (un número será siempre un número en una variable).

En este ejemplo concreto, estamos trabajando con números enteros. En matemáticas estos son números, sin decimales, que van desde 0 hasta ∞ por arriba, y hasta -∞ por debajo de cero.

$$\mathbb{Z} = {…, -4, -3, -2, -1, 0, 1, 2, 3, 4, …}$$

En programación, y concretamente en C#, al igual que sus predecesores, este tipo de dato se representa con el símbolo int, que viene de la palabra inglesa integer.

int numero = 42;

Si queremos declarar muchas variables de un mismo tipo, también las podemos declarar todas en la misma línea así:

int base, altura, area;

Más adelante manejaremos otros tipos de datos, como string para definir cadenas de texto o char para caracteres de un solo byte.

¿Por qué el punto y coma?

El punto y coma es un símbolo que se tiene que poner al final de cada instrucción en C# al igual que ocurría en C y C++. Esto es una forma de indicarle al compilador, cuando vayamos a construir el programa, que hasta ahí finaliza esa instrucción, sirviendo también como separador para otras instrucciones que se vayan añadiendo más adelante en el código.

Esto quiere decir que, en caso de que no coloquemos ese punto y coma al final de una instrucción, el compilador se pensará que la instrucción seguirá en las siguientes líneas hasta encontrar el próximo punto y coma, lo cual puede resultar en un error de compilación o a veces incluso resultados inesperados aunque compile correctamente el código.

Por ejemplo, este código:

int area = base *
		altura;

Hará exactamente lo mismo que esto:

int area = base * altura;

O que esto:

int area = 
	base * 
	altura;

Sin embargo, existen excepciones de uso. Veamos este simple ejemplo:

 1class Ejemplo_con_llaves {
 2	static void Main() {
 3		int base;
 4		int altura;
 5		int area;
 6		
 7		base = 10;
 8		altura = 5;
 9		area = base * altura;
10	}
11}

Si nos damos cuenta, hay algunas líneas que no llevan punto y coma, como es por ejemplo en la línea 1, cuando definimos la clase Ejemplo con llaves (más adelante hablaremos de clases, por ahora no nos tenemos que preocupar), o en la línea 2 cuando definimos la función Main(). Asimismo, tampoco vemos punto y coma al final de las líneas 10 y 11, que sólo tienen un cierre de llave. A partir de aquí podemos deducir que no siempre hay que introducir el punto y coma al final de cada instrucción.

Para entender por qué sucede esto, primero tenemos que entender qué son las instrucciones en línea y cuáles son las instrucciones en bloque.

Las instrucciones en línea tienen la siguiente estructura:

int suma;
string texto = "Saliendo";

suma = 2 + 2;

System.Console.Write("El resultado es: ");
System.Console.WriteLine(suma);
System.Console.WriteLine(texto);

Mientras que las que tienen una estructura de bloque se ven así:

if(suma == 4) {
	...
}

switch(suma) {
	default:
		...
}

while(true) {
	...
}

Es decir, al final lo que observamos es que los bloques de código, los que están encerrados entre { llaves }, no necesitan tener un punto y coma, ya que el compilador sabrá cuándo empieza y cuándo empieza un bloque de instrucciones. Sin embargo, las instrucciones que hay dentro de cada par de llaves, sí que deben tener punto y coma al final de instrucción siempre que se traten de órdenes simples o en línea.

*Importante: en esta sección hemos usado base como nombre de variable a modo de ejemplo. En la práctica, esto no se debe hacer, ya que base es en realidad una palabra clave reservada por el lenguaje C# (de ahí que aparezca remarcada en los bloques de código). La daremos cuando veamos la programación orientada a objetos.

Los asteriscos (y otras operaciones)

Si queremos usar el compilador de C# como una calculadora, lo podemos hacer de forma sencilla:

System.Console.WriteLine(1 + 1);

Esto nos devolverá 2 por consola. Esta es una de las operaciones aritméticas que se pueden realizar en C# y tenemos que conocer cuáles son sus símbolos:

Es decir, en el ejemplo anterior en el que estábamos calculando el área, cuando hacemos 10 * 5 en realidad estamos multiplicando 10 por 5.

Es importante también que vayamos familiarizándonos con la operación %, también llamada módulo. El módulo de una división es el resto de dicha división.

Por ejemplo, vamos a resolver la siguiente división como lo hacíamos en el colegio, para refrescar un poco la memoria sobre qué era el resto de la división:

25  │ 2
    └─────

Primero dividiríamos 2 / 2, que nos da 1. 2 * 1 = 2. 2 (primera cifra de 25) menos 2 nos da 0:

25  │ 2
    └─────
0     1

Bajamos 5, dividimos 5 / 2, que nos da 2. 2 * 2 = 4. 5 (segunda cifra de 25) menos 4 nos da 1. Como no hay más cifras que bajar, ese será el resto:

25  │ 2
    └─────
05    12
 1
 ¯

Por lo tanto, 25 % 2 es igual a 1, porque el resto de la división entre 25 y 2 da 1. Esto puede ser muy útil por ejemplo para determinar si un número es par o no:

12 % 2 == 0
13 % 2 == 1
14 % 2 == 0
15 % 2 == 1
37 % 2 == 1
49 % 2 == 1
80 % 2 == 0

Es decir, cualquier operación con módulo a 2 nos resultará 0 si el número es par (resto 0 al dividir por 2), o 1 si es impar (resto 1 al dividir por 2).

Esto también nos servirá para poder calcular la letra de un DNI, ya que depende de calcular el resto de la divisón entre el número del DNI y el número de letras que hay, que son 23. Por lo tanto, tendremos que realizar una operación módulo con ese mismo número, pudiendo devolver un valor entre 0 y 22. Con este simple código lo podemos imprimir por pantalla:

using System;

class a {
	static void Main() {
		int dni = 21234567;  // DNI del usuario
		string letra = "TRWAGMYFPDXBNJZSQVHLCKE"; // Letras ordenadas del 0 al 23
	
		Console.Write(dni); // imprime número
		dni %= 23; // equivale a dni = dni % 23
	
		Console.WriteLine(letra[dni]); // imprime letra
	
	}
}

La salida será 21234567R porque el número 21234567 dividido por 23 da resto 1.

Guardar datos del usuario

Si entendemos qué son las variables y su funcionamiento básico, va siendo hora de saber cómo asignarle valores que le quiera dar el usuario, ya que el programador no siempre va a tener que predefinir las variables de un programa.

Hasta ahora sólo hemos visto cómo mostrar texto por pantalla, pero a lo mejor queremos pedirle al usuario que introduzca algún dato por el teclado. Para ello, primero tenemos que mostrar un texto que aclare la información que queramos pedirle al usuario:

using System; // Nos ahorramos tener que escribir "System."

Console.Write("Introduce tu edad: ");

Pero ahora mismo al usuario no le dará tiempo a escribir su edad. Necesitaremos añadir justo después una instrucción que espere una respuesta del usuario. Esta función se llama Console.ReadLine:

using System;

Console.Write("Introduce tu edad: ");
Console.ReadLine();

Pero ahora mismo este programa no tiene ningún sentido. Estamos preguntando la edad al usuario, pero el programa no guardará el número en ningún lugar, por lo que luego no podremos trabajar con dicha información en el resto del programa. Así que, primero tendremos que declarar una varuabke de tiempo entero (int), y a dicho entero, asignarle el valor que le dé el usuario:

using System;
int edad;

Console.Write("Introduce tu edad: ");
edad = Console.ReadLine();

Nos dará error de compilación porque aquí se nos suma otro problema. No podemos simplemente guardar lo que nos escriba el usuario por la consola y guardarla en una variable numérica. Esto se debe a que la función Console.ReadLine convertirá a string lo que haya introducido el usuario una vez que pulse la tecla Intro. Un string es una cadena de texto, es decir, todo lo que encerramos entre "comillas" en el código.

¿Solución? Convertir a entero lo que haya introducido el usuario por pantalla. Esto se consigue con la función Convert.ToInt32 de esta forma:

using System;
int edad;

Console.Write("Introduce tu edad: ");
edad = Convert.ToInt32(Console.ReadLine());

En esa línea, primero lo que hará el programa es pedir al usuario que introduzca su texto mediante Console.ReadLine(); a continuación ese texto se convertirá a tipo entero mediante Convert.ToInt32 y por último se guardará en la variable int edad.

Ahora podemos hacer lo que queramos con esa información. Podemos devolver su edad por pantalla, calcular su fecha de nacimiento, etc.

using System;
int edad, anyo; // Evitamos las eñes y las tildes en los identificadores

Console.Write("Introduce tu edad: ");
edad = Convert.ToInt32(Console.ReadLine());

anyo = 2025 - edad;

Console.WriteLine("Tienes {0} años, así que debiste haber nacido en el año {1}.", edad, anyo);

Su salida por consola será, por ejemplo para alguien que tenga 40 años:

Introduce tu edad: 40
Tienes 40 años, así que debiste haber nacido en el año 1985.