Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://www.geeksforgeeks.org/javascript/javascript-let/ below:

JavaScript Let - GeeksforGeeks

Last Updated : 11 Jul, 2025

The let keyword is a modern way to declare variables in JavaScript and was introduced in ECMAScript 6 (ES6). Unlike var, let provides block-level scoping. This behaviour helps developers avoid unintended issues caused by variable hoisting and scope leakage that are common with var.

Syntax

let variable = value;

The let keyword allows you to declare a variable, assign a value to it, and later modify its value within the defined scope.

Variables declared with let are block-scoped, meaning they are only accessible within the block, statement, or expression where they are defined. This is a significant improvement over var, which has function scope and can lead to unexpected behaviour.

if (true) {
    let x = 10;
    console.log(x); // Output: 10
}
console.log(x); // ReferenceError: x is not defined

Output

Here, x is accessible only within the if block, leading to a ReferenceError when accessed outside of it.

While variables declared with let are hoisted, they are not initialized. This creates a temporal dead zone (TDZ) where accessing the variable before its declaration results in a ReferenceError, helping prevent unintended access.

console.log(y); // ReferenceError: Cannot access 'y' before initialization
let y = 20;

Output

• Variables declared with let are hoisted but remain uninitialized, avoiding accidental access before declaration.
• This ensures no unexpected behavior, unlike var, where the variable can be accessed before its actual declaration.

A major benefit of let is that it does not allow redeclaration of the same variable in the same scope. This prevents accidental overwrites of variables, reducing bugs and improving code readability.

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

Output

Attempting to redeclare z results in a SyntaxError, which helps catch potential issues early in development.

Using let in loops is particularly beneficial because the variable declared with let is scoped to the loop block, and each iteration gets a new instance of the variable.

for (let i = 0; i < 3; i++) {
    setTimeout(() => console.log(i), 1000);
}

Output

Here, let ensures each loop iteration has its own i, so the setTimeout callback correctly logs 0, 1, 2, instead of just 3, which would happen with var.

Because let has block-level scope, it prevents variable declarations from "leaking" outside of their intended scope. This makes code cleaner and easier to debug.

{ 
    let a = 5; 
}
console.log(a); // ReferenceError: a is not defined

Output

In this example, a is accessible only inside the block, and trying to access it outside results in a ReferenceError.

When using let, accessing a variable before its declaration results in a Temporal Dead Zone (TDZ), which prevents accidental access to uninitialized variables.

console.log(b); // ReferenceError
let b = 15;

Output

This TDZ behavior ensures that variables are not accessed before they are properly initialized, promoting safer coding practices.

With let, closures work as expected, providing a separate instance of the variable for each iteration in a loop. This avoids the common issue where the last value of a loop variable is captured by closures when using var.

const funcs = [];
for (let i = 0; i < 3; i++) {
    funcs.push(() => console.log(i));
}
funcs[0]();
funcs[1]();
funcs[2]();

Each function in the funcs array captures its own i due to let's block scoping, providing the expected behavior in closures.

The use of let aligns with modern JavaScript best practices, supporting compatibility with modules, destructuring, and ES6+ features.

let { name, age } = { name: "Pranjal", age: 20 };
console.log(name, age);

• This code uses destructuring assignment to extract the name and age properties from the object and assign them to corresponding variables.
• The console.log will output Pranjal 20, as the values of name and age are successfully assigned from the object.

• Block Scope: Unlike var, which is function-scoped, let is block-scoped, meaning it only exists within the block where it's defined (like inside loops or conditionals).
• No Redeclaration: You can't redeclare a variable with let in the same scope, which helps prevent accidental bugs in your code.
• Hoisted, But Not Initialized: let is hoisted to the top of its scope, but it isn't initialized until the line where it's declared, avoiding unexpected behavior.
• Temporal Dead Zone (TDZ): When using let, accessing the variable before its declaration results in a "temporal dead zone," leading to a reference error, which makes your code more predictable.
• Works Well with Loops: In loops, let ensures each iteration has its own value of the loop variable, unlike var, which can cause unexpected results when used inside closures.

• Limited Browser Support in Older Versions: Older browsers, especially Internet Explorer, don't support let, requiring polyfills or alternative methods for compatibility.
• No Hoisting Initialization: While let is hoisted, it can't be accessed until the declaration line, which can sometimes lead to confusion or errors for developers used to var's behavior.
• Cannot Redeclare in the Same Scope: While this is generally an advantage, it can be a drawback in cases where you might want to redeclare a variable for clarity or for resetting a value in the same block.
• Can Cause TDZ Confusion: The Temporal Dead Zone (TDZ) behavior can be tricky, especially for new developers who may not fully understand why a let variable isn't accessible before its declaration.
• Increased Memory Usage: Since let creates block-scoped variables, it can sometimes lead to more memory usage in long-running loops or functions due to its strict scope handling.

The let keyword is a modern and safer way to declare variables in JavaScript. It eliminates many pitfalls associated with var and provides developers with a clearer and more robust way to manage scope. By understanding and leveraging the features of let, developers can write more maintainable and error-free code.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4