Programming Concept

Variables

Variables are named storage locations used to hold data that a program can read and modify during execution.

🎯 Beginner ⏱ 10 min read
Variables
Explore This Guide

What's Inside

Follow the guide from the fundamentals to the details, examples, practical concepts, and advanced topics.

Definition

What is Variables?

A variable is a named storage location that holds data while a program is running. Variables allow programs to store, retrieve, and manipulate information, making them one of the fundamental building blocks of programming.

How Variables Work

Although variables look simple when written in code, they represent an important relationship between a name and a value.

At a basic level, you can think of a variable as a label associated with some piece of data.

name = "Buraq"
age = 25

Here, name refers to the text value "Buraq", while age refers to the number 25.

When the program later uses name or age, it can retrieve the corresponding value instead of requiring the value to be written directly again.

The exact way this works internally depends on the programming language. Some languages treat variables primarily as references to objects, while others can represent variables more directly as stored values. The important concept is that the variable gives the programmer a way to work with data through a meaningful name.

Declaring and Assigning Variables

Different programming languages use different syntax for creating variables.

There are three related concepts that are useful to understand:

  • Declaration — telling the language that a variable exists.
  • Initialization — giving a variable its first value.
  • Assignment — giving or changing the value associated with a variable.

For example, JavaScript allows variables to be declared with let:

let age;
age = 25;

The first statement declares the variable. The second assigns a value to it.

These operations can also be combined:

let age = 25;

Python uses a simpler syntax:

age = 25

Some statically typed languages also require the variable’s type to be specified:

int age = 25;

The syntax changes between languages, but the underlying idea remains the same: a program creates a named piece of data that it can work with later.

Variable Naming

A variable’s name should communicate what the stored value represents.

For example, this is generally clearer:

user_age = 25

than this:

x = 25

Programming languages impose different rules on variable names. Common rules include:

  • Names usually cannot contain spaces.
  • Names generally cannot begin with a number.
  • Reserved keywords cannot normally be used as variable names.
  • Most languages allow letters, numbers, underscores, or similar characters.
  • Many languages distinguish between uppercase and lowercase letters.

Naming conventions also vary between languages. Python commonly uses snake_case, while JavaScript frequently uses camelCase.

Good variable names make code easier to understand without requiring additional comments.

Types of Variables

Variables can contain many different kinds of values.

Common categories include:

  • Numbers — such as integers and decimal values.
  • Strings — sequences of text.
  • Booleans — values representing true or false.
  • Arrays or lists — collections of values.
  • Objects — structured collections of related data.
  • Functions — in languages where functions can be stored in variables.
  • References — values that refer to another object or location.

The exact type system depends on the language.

For example, Python determines the type of a value dynamically:

age = 25
name = "Buraq"
is_active = True

JavaScript similarly allows variables to hold different types of values:

let value = 25;
value = "Hello";

In a statically typed language such as TypeScript, a variable can instead be constrained to a particular type:

let age: number = 25;

Variable Scope

Scope determines where a variable can be accessed within a program.

A variable may exist only inside a particular function, block, module, or other region of code.

Common forms of scope include:

  • Global scope — accessible from a broad portion of the program.
  • Local scope — available only within a particular function or region.
  • Block scope — limited to a specific block of code.
  • Module scope — available within a particular module.

Scope is important because it prevents every variable in a program from becoming accessible everywhere.

For example:

function greet() {
    let message = "Hello";
    console.log(message);
}

The variable message exists inside the function and cannot normally be accessed from outside that function.

Understanding scope becomes especially important when working with functions, loops, conditional statements, modules, and closures.

Mutable vs Immutable Variables

Mutability describes whether a value can be changed after it has been created.

A mutable value can be modified, while an immutable value cannot be directly changed after creation.

This distinction is especially important when working with objects, arrays, strings, and functional programming patterns.

It is also important to distinguish between a variable and the value stored in it.

A variable may be allowed to receive a new value even when the original value itself is immutable.

For example, in JavaScript:

let name = "Alice";
name = "Bob";

The variable was reassigned. This does not mean the original string itself was modified.

Understanding this distinction helps prevent many confusing bugs involving references and object mutation.

Constants

A constant is a named value that is intended not to be reassigned after it has been initialized.

Many programming languages provide a specific mechanism for defining constants.

For example, JavaScript provides const:

const siteName = "iGrasped";

The variable cannot later be reassigned:

siteName = "Other Site";

This produces an error because the constant cannot be reassigned.

Constants are useful for values that should remain consistent throughout a particular part of a program, such as configuration values, mathematical constants, or fixed identifiers.

However, the exact behavior of constants differs between languages. In some languages, a constant guarantees that a value itself cannot change. In others, it primarily prevents the variable from being reassigned.

Variables and Memory

Variables are closely connected to how a programming language manages memory, although the programmer does not always need to know the underlying memory details.

When a program creates data, the runtime environment needs somewhere to represent that data while the program executes.

A variable provides a way for the program to refer to that data.

For simple values, a language may store or represent the value directly. For objects and more complex structures, a variable may instead contain a reference to data stored elsewhere in memory.

This distinction explains why two variables can sometimes refer to the same object.

let userA = {
    name: "Alice"
};

let userB = userA;

In this example, userB can refer to the same object as userA. Changing the object’s properties through one reference can therefore affect what is observed through the other reference.

The exact memory model differs between programming languages, so concepts such as stack, heap, references, pointers, and garbage collection should be understood in the context of the language being used.

Variables in Different Programming Languages

Variables exist in virtually every mainstream programming language, but languages make different design decisions about how variables behave.

Python

name = "Alice"
age = 25

Python uses dynamic typing, so a variable does not normally require an explicit type declaration.

JavaScript

let age = 25;
const name = "Alice";

JavaScript provides let, const, and the older var keyword.

TypeScript

let age: number = 25;
let name: string = "Alice";

TypeScript adds static type checking to JavaScript.

Java

int age = 25;
String name = "Alice";

Java is statically typed, so variables normally have declared types.

C

int age = 25;
char grade = 'A';

C provides explicit types and gives programmers much more direct control over memory through pointers.

The syntax differs significantly, but every example serves the same fundamental purpose: giving a name to data that the program needs to work with.

Variables Inside Functions

Functions frequently create and use their own variables.

function calculateTotal(price, quantity) {
    const total = price * quantity;
    return total;
}

Here, price and quantity are parameters, while total is a local variable created inside the function.

Local variables are useful because they allow a function to perform intermediate calculations without exposing every internal detail to the rest of the program.

Variables also play an important role in closures, callbacks, recursion, and asynchronous programming.

Common Variable Mistakes

Variables are simple to create, but incorrect use of variables can cause difficult bugs.

Using unclear names

x = 25

A name such as user_age usually communicates much more information.

Using a variable before it has a valid value

Some languages allow variables to exist without an initial value, while others prevent or restrict this behavior. Understanding the language’s rules is essential.

Accidental reassignment

A variable may unintentionally receive a new value somewhere else in the program.

Ignoring scope

A variable may be unavailable in the part of the program where you try to use it.

Unexpected mutation

When multiple variables reference the same object, changing that object through one reference can produce unexpected results elsewhere.

Using global variables unnecessarily

Global state can make programs harder to reason about because many unrelated parts of an application can potentially depend on or modify the same data.

Variable Best Practices

  • Use descriptive names.
  • Follow the naming conventions of the language.
  • Keep variables within the smallest useful scope.
  • Avoid unnecessary global variables.
  • Prefer constants when a value should not be reassigned.
  • Initialize variables appropriately.
  • Avoid unnecessary mutation.
  • Keep related data and variables logically organized.
  • Choose variable names that explain intent rather than implementation details.
  • Use the type system when the language provides one.

Good variable practices make code easier to read, maintain, debug, test, and modify.

Real-World Examples

Variables appear throughout real software applications.

User accounts

username = "alice"
email = "alice@example.com"
is_verified = True

These variables can represent information associated with a user account.

Shopping carts

item_price = 50
quantity = 3
total = item_price * quantity

The application can calculate the total dynamically instead of hard-coding the result.

Web applications

current_user = get_current_user()
is_logged_in = current_user is not None

Variables can represent the current user, authentication state, configuration, API responses, and other application data.

Games

player_health = 100
player_score = 2500
current_level = 4

As the game runs, these values can change based on what the player does.

Variable vs Constant

A variable generally represents data that can be reassigned, while a constant is intended to remain assigned to the same value.

Variable vs Parameter

A parameter is a named input provided to a function. Once inside the function, it can behave similarly to a local variable depending on the language.

Variable vs Property

A property is data associated with an object or structure, while a variable is generally a named binding available within a particular scope.

Variable vs Value

A value is the actual piece of data. A variable is the name through which a program can refer to that data.

Variable vs Reference

A reference identifies or points toward another piece of data, while a variable is the named entity used by the program. Some languages use references as the values stored inside variables.

Frequently Asked Questions

What is a variable in programming?

A variable is a named way for a program to store or refer to data so that the data can be accessed and potentially changed during execution.

Can a variable change its value?

In many languages, yes. Variables can usually be reassigned unless they have been declared as constants or the language’s rules prevent reassignment.

Are variables the same in every programming language?

No. The fundamental idea is similar, but languages differ in syntax, typing, scope rules, memory behavior, mutability, and how variables are represented internally.

Why are variables important?

Variables allow programs to work with information dynamically. Without them, programs would have very limited ability to remember, process, and manipulate changing data.

What makes a good variable name?

A good variable name clearly communicates what the value represents and follows the naming conventions of the language being used.

What to Learn Next

Once you understand variables, several related concepts become much easier to learn.

  • Data types — understand the different kinds of values variables can contain.
  • Operators — learn how values can be calculated and compared.
  • Functions — learn how variables and parameters work inside reusable blocks of code.
  • Scope — understand where variables can be accessed.
  • Objects — learn how related data can be grouped together.
  • Memory management — understand how programs represent and manage data.

Variables are one of the first concepts programmers learn, but understanding them deeply provides a foundation for almost every other area of programming.

Continue Learning

Related concepts will appear here.