Global and Local variables in JavaScript

In JavaScript, understanding the distinction between global and local variables is crucial for effective programming. Each type of variable has its own scope, which determines where it can be accessed within the code.

Global Variables

Definition: Global variables are declared outside of any function or block scope. They can be accessed from anywhere in the script, including inside functions and blocks.

Key Characteristics:

• Scope: Accessible throughout the entire script.
• Automatic Global Variables: If a variable is declared without var, let, or const inside a function, it automatically becomes a global variable. This can lead to unintended bugs if not managed carefully.

Example:

javascript

let petName = 'Rocky'; // Global variable

function myFunction() {
    fruit = 'apple'; // Automatically global
    console.log(`My pet name is ${petName}`); // Accessing global variable
}

myFunction();
console.log(`Fruit name is ${fruit}`); // Accessing the automatically global variable

In this example, petName is a global variable, while fruit becomes global due to lack of declaration1.

Local Variables

Definition: Local variables are defined within functions or blocks and are only accessible within that specific context.

Key Characteristics:

• Scope: Limited to the function or block in which they are declared.
• Function-Specific: Each function can have its own local variables, even if they share the same name with variables in other functions.

Example:

javascript

function myFunction() {
    let petName = "Sizzer"; // Local variable
    console.log(petName); // Outputs "Sizzer"
}

function anotherFunc() {
    let petName = "Tom"; // Another local variable
    console.log(petName); // Outputs "Tom"
}

myFunction();
anotherFunc();
console.log(petName); // ReferenceError: petName is not defined

In this case, each function has its own petName variable that cannot be accessed outside its respective function13.

Summary of Differences

Understanding these differences helps in writing cleaner and more maintainable code by minimizing unintended side effects from variable scope and lifetime