What is the scope of variables

When working with variables in programming, it is essential to understand the variable’s scope. This is one of the topics that many programmers struggle to understand (when, in reality, it’s very simple).

The scope of a variable is the context in which a variable exists and can be used. Outside its scope, the variable does not exist (and therefore, we cannot use it).

Just as we saw when looking at a program’s lifecycle, a variable has its own “lifecycle.” In general, during our program,

The area where we can use the variable is its scope. In general (spoiler alert!) in almost all modern languages, the variable exists from the moment it is created until the block in which it is defined ends.

It’s intuitive to think that we cannot use a variable before creating it (although we will see that some languages are a bit special, right JavaScript?).

The other missing factor: When does the variable cease to exist? Well, unless we manually free it, the variable is automatically destroyed when exiting the block where it was created.

So the scope of existence of the variable includes all the instructions and nested blocks found between the creation and destruction of the variable, which normally occurs at the end of the block where it was created.

Which, put into code form, looks something like this:

// here NOT available ❌ 
{
   // here NOT available ❌ 

   int myVariable = 5;
   // here IS available ✔️
   
   {
	   // in this inner block IS also available ✔️
   }
}
// here NOT available ❌ 

Examples of Variable Scope in Different Languages

Let’s look at variable scope in different languages.

class ExampleClass 
{
   int classVariable = 5;

   void ExampleFunction()
   {
      int functionVariable = 10;
	 
      if(condition)
      {
         int blockVariable = 15;
      }
   }
}

def example():
   functionVariable = 10
   
   if True:
      blockVariable = 15
      print(blockVariable)
      
   print(functionVariable)

if (true) {
   var x = 20;   // this has function scope, not if scope 😱
}

if (true) {
   let x = 20;   // this has if scope
}

Global Variables and Local Variables

In many programming languages it is possible to define global variables, which can be accessed from anywhere in the program.

int globalVariable = 10; // Declaration of a global variable

void setup() {
}

void loop() {
  // Show the value of the global variable on the serial monitor
  Serial.println(globalVariable);
}

x = 10

def myfunc():
  # Show the value of the global variable in the console
  print(x)  

let globalVariable = 10;

function updateGlobalVariable() {
  // Show the value of the global variable in the console
  console.log(globalVariable)
}

In general, almost all languages have global functions implemented, one way or another, or with their language-specific peculiarities. But they have them.

Best Practices Tips

It is often said that using global variables is a bad practice. Well, it’s not always a bad practice. In fact, not only are they useful, but they are necessary for the program to work (the entry point, for starters, is a global variable).

What is true is that abusing global variables is a bad practice. In general, we should always use local variables whenever possible, and use global variables in the few cases where it is truly essential.

Let’s look at a very simple example, in a hypothetical machine that reads a temperature and uses a function to modify it.

int rawTemperature; // Declaration of a global variable

void correct_temperature() {
   rawTemperature *= 2;  // Do anything with your global variable
}

void loop() {
  rawTemperature = 10;

  correct_temperature();
}

Making all variables global is pretty nast… well, you know what I mean. It’s much better if instead, we use local variables, and each function has defined the parameters it needs and what it returns.

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

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

In the long run, the code is much more maintainable, better isolated, reusable, etc., etc.

Low-Level Explanation Advanced

Let’s try to briefly explain how variable scope works and the reasons for its existence, at a low level.

In compiled languages like C++, when we create a variable inside a block, it is stored on the stack. Regardless of whether the variable’s “content” goes to the heap, the variable itself always goes to the stack.

Then the block performs its actions and its tasks. When the block ends, the stack must be clean and in a neutral state. During the process, local variables are removed.

That is, at a low level, the fact that variables are always attached to the block in which they are created is an imposition due to how the processor works.

In semi-compiled languages like Java or C# or interpreted ones like Python, it wouldn’t necessarily have to be this way. Here, the memory manager or the interpreter could decide to keep the variable after the block ends.

However, the same rules have been kept because they are intuitive and practical. The fact that a variable is local and ceases to exist when it leaves its scope seems to make sense, doesn’t it?

This favors code reuse and reduces the possibility of errors. Therefore, more ‘modern’ programming languages continue to maintain the same rules, although, unlike lower-level languages, they are not strictly forced to comply.