Qué es el ámbito de las variables

Al trabajar con variables en programación, es fundamental entender el ámbito de la variable. Este es uno de los temas que más cuesta entender a muchos programadores (cuando, en realidad, es muy sencillo).

El ámbito de una variable es el contexto en el que una variable existe y puede ser utilizada. Fuera de su ámbito, la variable no existe (y por tanto, no podemos usarla).

Al igual que vimos al ver el ciclo de vida de un programa, una variable tiene su propio “ciclo de vida”. En general, durante nuestro programa,

La zona donde podemos usar la variable es su ámbito. En general (¡spoiler!) en prácticamente todos los lenguajes modernos la variable existe desde que se crea, hasta que se acaba el bloque en que está definida .

Resulta intuitivo pensar que no podemos usar una variable antes de crearla (aunque veremos que algunos lenguajes son especialitos, ¿verdad JavaScript?).

El otro factor que falta ¿Cuándo deja de existir la variable? Pues salvo que la liberemos manualmente, la variable se destruye automáticamente al salir del bloque donde se crea.

Así que el ámbito de existencia de la variable, incluye todas las instrucciones y bloques anidados que se encuentren entre la creación y la destrucción de la variable, que por lo normal se produce al acabar el bloque en el que se creó.

Lo qué, puesto en forma de código, es algo como lo siguiente:

// aqui NO está disponible ❌ 
{
   // aqui NO está disponible ❌ 

   int miVariable = 5;
   // aqui SI está disponible ✔️
   
   {
	   // en este bloque interior TAMBIEN esta disponible ✔️
   }
}
// aqui NO está disponible ❌ 

Ejemplos de ámbito de variables en distintos lenguajes

Vamos a ver el ámbito de la variable en distintos lenguajes

class EjemploClase 
{
   int variableDeClase = 5;

   void EjemploFuncion()
   {
      int variableDeFuncion = 10;
	 
      if(condition)
      {
         int variableDeBloque = 15;
      }
   }
}

def ejemplo():
   variableDeFuncion = 10
   
   if True:
      variableDeBloque = 15
      print(variableDeBloque)
      
   print(variableDeFuncion)

if (true) {
   var x = 20;   // ¡¡esto tiene de ámbito la funcion, no el if 😱
}

if (true) {
   let x = 20;   // esto tiene de ámbito el if
}

Variables globales y variables locales

En muchos lenguajes de programación es posible definir variables globales, que se pueden acceder desde cualquier parte del programa.

int globalVariable = 10; // Declaración de una variable global

void setup() {
}

void loop() {
  // Mostrar el valor de la variable global en el monitor serial
  Serial.println(globalVariable);
}

x = 10

def myfunc():
  # Mostrar el valor de la variable global en la consola
  print(x)  

let globalVariable = 10;

function updateGlobalVariable() {
  // Mostrar el valor de la variable global en la consola
  console.log(globalVariable)
}

En general, casi todos los lenguajes tienen funciones globales implementadas, de una u otra forma, o con sus peculiaridades de lenguaje. Pero las tienen.

Buenas prácticas Consejos

Se suele decir que emplear variables globales es una mala práctica. Bueno, no siempre es una mala práctica. De hecho, no es solo que tengan su utilidad, es que son necesarias para que funcione el programa (el punto de entrada, sin ir más lejos, es una variable global).

Lo que si es cierto es que abusar de las variables globales es una mala práctica. En general, deberemos usar siempre que sea posible variables locales, y usar variables globales en los pocos casos donde realmente es imprescindible.

Veamos un ejemplo muy sencillo, en una máquina hipotética que lee una temperatura y usa una función para modificarla.

int rawTemperature; // Declaración de una variable global

void correct_temperature() {
   rawTemperature *= 2;  // Hacer cualquier cosa con tu variable global
}

void loop() {
  rawTemperature = 10;

  correct_temperature();
}

Subir todas las variables como globales es bastante guarr… bueno ya me entiendes. Es muchísimo mejor si en lugar de eso, usamos variables locales, y cada función tiene definidos los parámetros que necesita y que devuelve.

int correct_temperature(int temperature) {
   return temperature * 2;
}

void loop() {
  int rawTemperature = 10;
  int corrected_temperature = correct_temperature(rawTemperature);
}

A la larga, el código es mucho más mantenible, mejor aislado, reusable, etc etc

Explicación bajo nivel Avanzado

Vamos a intentar explicar de forma resumida como funciona el ámbito de una variable y los motivos de que exista, a bajo nivel.

En lenguajes de compilados como C++ cuando creamos una variable dentro de un bloque, esta se guarda en el stack. Independientemente de que el “contenido” de la variable vaya al heap, la variable en sí siempre va al stack.

Después el bloque hace sus acciones y sus cositas. Cuando se finaliza el bloque, la pila debe de quedar limpia y en estado neutro. Durante el proceso se eliminan las variables locales.

Es decir, a bajo nivel, el hecho de que las variables siempre estén adscritas al bloque en el que son creadas, *es una imposición debido a la forma en la que funciona el procesador.

En lenguajes semi-compilados como Java o C# o interpretados como Python, no tendría porqué ser así. Aquí el gestor de memoria o el intérprete, podrían decidir guardar la variable tras la finalización del bloque.

Sin embargo, se ha seguido con las mismas normas porque resultan intuitivas y prácticas. El hecho de que una variable tenga carácter local y deje de existir cuando sale de su ámbito, parece que tiene sentido ¿no?

Esto favorece la reutilización de código y disminuye la posibilidad de errores. Por tanto, los lenguajes de programación más ‘modernos’ siguen manteniendo las mismas normas aunque, a diferencia de los lenguajes más de bajo nivel, estrictamente no se verían obligados a cumplirla.