Variable in Programming

In programming, we often need a named storage location to store the data or values. Using variables, we can store the data in our program and access it afterward. In this article, we will learn about variables in programming, their types, declarations, initialization, naming conventions, etc.

What is a Variable in Programming?

Variable in Programming is a named storage location that holds a value or data. These values can change during the execution of a program, hence the term "variable." Variables are essential for storing and manipulating data in computer programs. A variable is the basic building block of a program that can be used in expressions as a substitute in place of the value it stores.

Declaration of Variable in Programming:

In programming, the declaration of variables involves specifying the type and name of a variable before it is used in the program. The syntax can vary slightly between programming languages, but the fundamental concept remains consistent.

#include <iostream>
using namespace std;

int main()
{
    // Syntax: datatype variable_name;
    int age;
    double price;
    char grade;

    return 0;
}

/*package whatever //do not write package name here */

import java.io.*;

class GFG {
    public static void main(String[] args)
    {
        // Syntax: datatype variable_name;
        int age;
        double price;
        char grade;
    }
}

# No explicit declaration is required in Python; variables are dynamically typed.
age = 25
price = 10.99
grade = 'A'

using System;

class Program
{
    static void Main()
    {
        // Suppress warnings for unused variables
#pragma warning disable CS0168
        int age;
        double price;
        char grade;
#pragma warning restore CS0168

        // These variables are declared but not used in this code block
    }
}

// Syntax: var/let/const variable_name;
var age;
let price;
const grade = 'A';  // Note: Constants need to be initialized during declaration.

Initialization of Variable in Programming:

Initialization of variables In Programming involves assigning an initial value to a declared variable. The syntax for variable initialization varies across programming languages.

#include <iostream>
using namespace std;

int main()
{

    // Declaration and Initialization
    int age = 25;
    double price = 10.99;
    char grade = 'A';

    return 0;
}

/*package whatever //do not write package name here */

import java.io.*;

class GFG {
    public static void main(String[] args)
    {
        // Declaration and Initialization
        int age = 25;
        double price = 10.99;
        char grade = 'A';
    }
}

# Initialization (no explicit declaration required)
age = 25
price = 10.99
grade = 'A'

using System;

class Program
{
    static void Main()
    {
        // Declaration and Initialization
        int age = 25;
        double price = 10.99;
        char grade = 'A';

        // Displaying the values (optional)
        Console.WriteLine($"Age: {age}");
        Console.WriteLine($"Price: {price}");
        Console.WriteLine($"Grade: {grade}");

        // The equivalent of 'return 0;' is just ending the Main method
    }
}

// Initialization using var (older syntax)
var age = 25;
// Initialization using let (block-scoped)
let price = 10.99;
// Initialization using const (block-scoped constant)
const grade = 'A';

Types of Variable In Programming:

1. Global Variables:

Global variables in programming are declared outside any function or block in a program and accessible throughout the entire codebase. In simpler words, Global variables can be accessed in any part of the program, including functions, blocks, or modules.

#include <iostream>
using namespace std;

int globalVariable = 5;

void gfgFnc() { cout << globalVariable << endl; }
int main()
{

    cout << globalVariable << endl;

    gfgFnc();
    return 0;
}

/*package whatever //do not write package name here */

import java.io.*;

class GFG {
    static int globalVariable = 5;

    static void gfgFnc()
    {
        System.out.println(globalVariable);
    }
    public static void main(String[] args)
    {
        System.out.println(globalVariable);

        gfgFnc();
    }
}

global_variable = 5


def gfg_fnc():
    print(global_variable)


def main():
    print(global_variable)
    gfg_fnc()


if __name__ == "__main__":
    main()

using System;

class Program
{
    // Declaring a static global variable accessible to all methods in the class
    static int globalVariable = 5;

    // Defining a method to print the value of the global variable
    static void gfgFnc()
    {
        // Output the value of the global variable
        Console.WriteLine(globalVariable);
    }

    static void Main(string[] args)
    {
        // Output the value of the global variable in the Main method
        Console.WriteLine(globalVariable);

        // Call the gfgFnc method to print the global variable's value
        gfgFnc();
    }
}

// Define a class named GFG
class GFG {
    // Define a static variable
    static globalVariable = 5;

    // Define a static method
    static gfgFnc() {
        console.log(GFG.globalVariable);
    }

    // Define the main method
    static main() {
        console.log(GFG.globalVariable);

        // Call the static method gfgFnc
        GFG.gfgFnc();
    }
}

// Call the main method of the GFG class
GFG.main();

5
5

2. Local Variables:

Local variables in programming are declared within a specific function, block, or scope and are only accessible within that limited context. In simpler words, Local variables are confined to the block or function where they are declared and cannot be directly accessed outside that scope.

#include <iostream>
using namespace std;

void gfgFnc()
{
    int localVariable2 = 10;
    cout << localVariable2 << endl;
}

int main()
{

    int localVariable1 = 5;
    cout << localVariable1 << endl;

    gfgFnc();

    if (true) {
        int localVariable3 = 15;
        cout << localVariable3 << endl;
    }

    return 0;
}

/*package whatever //do not write package name here */

import java.io.*;

class GFG {
    static void gfgFnc()
    {
        int localVariable2 = 10;
        System.out.println(localVariable2);
    }
    public static void main(String[] args)
    {
        int localVariable1 = 5;
        System.out.println(localVariable1);

        gfgFnc();

        if (true) {
            int localVariable3 = 15;
            System.out.println(localVariable3);
        }
    }
}

def gfg_fnc():
    local_variable_2 = 10
    print(local_variable_2)


def main():
    local_variable_1 = 5
    print(local_variable_1)

    gfg_fnc()

    if True:
        local_variable_3 = 15
        print(local_variable_3)


if __name__ == "__main__":
    main()

using System;

class Program
{
    // Define a function named gfgFnc
    static void gfgFnc()
    {
        // Declare and initialize a local variable named localVariable2
        int localVariable2 = 10;
        // Print the value of localVariable2
        Console.WriteLine(localVariable2);
    }

    static void Main(string[] args)
    {
        // Declare and initialize a local variable named localVariable1
        int localVariable1 = 5;
        // Print the value of localVariable1
        Console.WriteLine(localVariable1);

        // Call the function gfgFnc
        gfgFnc();

        // Using if block to create a local scope
        if (true)
        {
            // Declare and initialize a local variable named localVariable3
            int localVariable3 = 15;
            // Print the value of localVariable3
            Console.WriteLine(localVariable3);
        }

        // Return 0 to indicate successful completion
    }
}

function gfgFnc() {
    var localVariable2 = 10;
    console.log(localVariable2);
}

function main() {
    var localVariable1 = 5;
    console.log(localVariable1);

    gfgFnc();

    if (true) {
        var localVariable3 = 15;
        console.log(localVariable3);
    }
}

// Call the main function
main();

5
10
15

Difference between Variable and Constant:

Difference between Local variables and Global Variables:

Naming Conventions:

Naming conventions for variables In Programming help maintain code readability and consistency across programming projects. While specific conventions can vary between programming languages, some common practices are widely followed. Here are general guidelines for naming variables:

• Descriptive and Meaningful: Choose names that indicate the purpose or content of the variable. A descriptive name improves code readability and understanding.
• Camel Case or Underscore Separation: Use camel case (myVariableName) or underscores (my_variable_name) to separate words in a variable name. Choose one style and stick to it consistently.
• Avoid Single Letter Names: Except for loop counters or well-known conventions (e.g., i for an index), avoid single-letter variable names. Use names that convey the variable's purpose.
• Follow Language Conventions: Adhere to the naming conventions recommended by the programming language you are using. For example, Java typically uses camel case (myVariableName), while Python often uses underscores (my_variable_name).
• Avoid Reserved Words: Avoid using reserved words or keywords of the programming language as variable names.
• Avoid Abbreviations: Use full words instead of abbreviations, except when widely accepted or for standard terms (e.g., max, min).

Scope of a variable:

The scope of a variable in programming refers to the region of the program where the variable can be accessed or modified. It defines the visibility and lifetime of a variable within a program. There are typically two types of variable scope:

Local Scope:

• A variable declared inside a function, block, or loop has a local scope.
• It can only be accessed within the specific function, block, or loop where it is declared.
• Its lifetime is limited to the duration of the function, block, or loop.

#include <iostream>
using namespace std;

void myFunction() {
    // Variable with local scope
    int localVar = 10;
    cout << "Inside myFunction: " << localVar << endl;
}

int main() {

    myFunction();  // Calling the function

    return 0;
}

public class Main {

    public static void myFunction() {
        // Variable with local scope
        int localVar = 10;

        // Accessing the local variable
        System.out.println("Inside myFunction: " + localVar);
    }

    public static void main(String[] args) {

        myFunction();  // Calling the function
    }
}

def my_function():
    # Variable with local scope
    local_var = 10
    # Accessing the local variable
    print("Inside my_function:", local_var)

my_function()  # Calling the function

using System;

class Program
{
    static void MyFunction()
    {
        // Variable with local scope
        int localVar = 10;

        // Accessing the local variable
        Console.WriteLine("Inside MyFunction: " + localVar);
    }

    static void Main()
    {
        // Attempting to access the local variable from Main (not allowed)
        // Uncommenting the line below will result in a compilation error
        // Console.WriteLine("Inside Main: " + localVar);

        MyFunction();  // Calling the function
    }
}

function myFunction() {
    // Variable with local scope
    let localVar = 10;
    console.log("Inside myFunction:", localVar);
}

// Calling the function
myFunction();

Inside myFunction: 10

Global Scope:

• A variable declared outside of any function or block has a global scope.
• It can be accessed from anywhere in the program, including inside functions.
• Its lifetime extends throughout the entire program.

#include <iostream>
using namespace std;

// Variable with global scope
int globalVar = 20;

void myFunction() {
    // Accessing the global variable
    cout << "Inside myFunction: " << globalVar << endl;
}

int main() {
    // Accessing the global variable from main
    cout << "Inside main: " << globalVar << endl;

    myFunction();  // Calling the function

    return 0;
}

public class Main {
    // Variable with class (global) scope
    static int globalVar = 20;

    public static void myFunction() {
        // Accessing the global variable
        System.out.println("Inside myFunction: " + globalVar);
    }

    public static void main(String[] args) {
        // Accessing the global variable from the main method
        System.out.println("Inside main: " + globalVar);

        myFunction();  // Calling the function
    }
}

# Variable with global scope
global_var = 20

def my_function():
    # Accessing the global variable
    print("Inside my_function:", global_var)

# Accessing the global variable from the global scope
print("Inside global scope:", global_var)

my_function()  # Calling the function

using System;

class Program
{
    // Variable with global scope
    static int globalVar = 20;

    static void MyFunction()
    {
        // Accessing the global variable
        Console.WriteLine("Inside MyFunction: " + globalVar);
    }

    static void Main()
    {
        // Accessing the global variable from Main
        Console.WriteLine("Inside Main: " + globalVar);

        MyFunction();  // Calling the function
    }
}

// Variable with global scope
let globalVar = 20;

function myFunction() {
    // Accessing the global variable
    console.log("Inside myFunction: " + globalVar);
}

function main() {
    // Accessing the global variable from main
    console.log("Inside main: " + globalVar);

    myFunction(); // Calling the function
}

main(); // Call the main function

Inside main: 20
Inside myFunction: 20

Understanding and managing variable scope is crucial for writing maintainable and bug-free code, as it helps avoid naming conflicts and unintended side effects.

In conclusion, variables In programming are fundamental elements in programming, serving as named storage locations to hold and manipulate data. They are crucial in writing dynamic, adaptable, and functional code. The proper use of variables, adherence to clear naming conventions, and understanding of scope contribute to code readability, maintainability, and scalability.