JS. let vs var

In JavaScript, let and var are both used to declare variables, but they have significant differences in their behavior and scope. Here's a breakdown:

Scope

• var: Has function scope. This means it is accessible throughout the function in which it is declared, regardless of block boundaries.
• let: Has block scope. This means it is only accessible within the block (enclosed by {}) in which it is declared.

// Example of var
function exampleVar() {
    if (true) {
        var x = 10;
    }

    console.log(x); // 10 (Accessible outside the block)
}

// Example of let
function exampleLet() {
    if (true) {
        let y = 20;
    }

    console.log(y); // ReferenceError: y is not defined (Not accessible outside the block)
}

Hoisting

• var: Is hoisted, but its value is undefined until the code execution reaches the variable declaration.
• let: Is also hoisted, but it is in a "temporal dead zone" from the start of the block until its declaration, meaning you cannot access it before it's declared.

console.log(a); // undefined (var is hoisted)
var a = 5;

console.log(b); // ReferenceError (let is hoisted but in temporal dead zone)
let b = 10;

Re-declaration

• var: Allows re-declaration of the same variable in the same scope.
• let: Does not allow re-declaration in the same scope.

var c = 10;
var c = 20; // Allowed

let d = 30;
let d = 40; // SyntaxError: Identifier 'd' has already been declared

Global Object Property

• var: If declared in the global scope, it becomes a property of the global object (window in browsers).
• let: Does not create a property on the global object.

var e = "globalVar";
console.log(window.e); // "globalVar"

let f = "globalLet";
console.log(window.f); // undefined

Use Cases

• var: Used in older JavaScript code but is generally not recommended in modern JavaScript due to its function scope and potential for bugs.
• let: Preferred for variables whose values will change and where block scope is desirable.

In summary, let is the modern and safer choice for variable declarations due to its block scope and stricter behavior, while var is largely considered outdated and best avoided in most scenarios.