Which JavaScript Keyword Declares a Block Scoped Variable

Learn which JavaScript keyword declares a block scoped variable and how let and const work. Explore scope, TDZ, hoisting, and modern JavaScript best practices.

JavaScripting Team

March 1, 2026·5 min read

Variables Learn JavaScript Frontend Syntax

Block Scope in JavaScript - JavaScripting — Photo by Startup Stock Photos via Pexels

Block scoped variable declaration (let and const)

Block scoped variable declaration is a way to declare variables whose scope is restricted to the nearest enclosing block; in JavaScript this is achieved with let or const.

Understanding block scope in JavaScript

Block scope defines where a variable declared with let or const is accessible. Unlike var, which is scoped to the containing function, let and const bindings live only inside the nearest enclosing block, such as inside a for loop, an if statement, or a block delimited by curly braces. This scoping model helps prevent accidental interactions between different parts of your code and makes reasoning about values easier, especially in asynchronous code. Consider the typical example of looping with let inside a for loop; each iteration gets its own binding, avoiding classic closure bugs that var would introduce.

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

The let and const keywords and how they work

JavaScript provides two block scoped declarations: let and const. A variable declared with let can be reassigned, while one declared with const cannot be reassigned. Both declarations create bindings that are confined to the surrounding block. This means you can safely declare loop counters, temporary helpers, or configuration values inside a narrow scope without affecting outer code. Remember that const does not make the value immutable; it makes the binding immutable, while objects can still be mutated internally.

let x = 5;
x = 6; // allowed
const y = { count: 1 };
y.count = 2; // allowed, object mutation

Temporal dead zone and hoisting explained

When you declare a variable with let or const, the binding exists from the start of the block but is not initialized until the declaration is evaluated. Accessing it before initialization results in a ReferenceError, a condition known as the temporal dead zone (TDZ). In contrast, var is hoisted and initialized with undefined, which can lead to subtle bugs. Understanding TDZ helps you write safer code.

console.log(z); // ReferenceError
let z = 3;

Regarding hoisting, both let and const are hoisted, but do not initialize until their declaration; this is different from var, which is initialized as undefined from the start.

Block scope in control structures and loops with practical examples

Block scope behaves differently in loops and conditional blocks. A for loop declared with let creates a new binding for each iteration, preventing closures from all referencing the same loop variable. Conversely, using var inside the same loop shares a single binding, which can cause unexpected results. This distinction matters in event handlers and asynchronous callbacks. The following example demonstrates a common pattern:

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

If you switch let to var, you may see all three outputs equal to the final value, revealing how block scope changes behavior in practical code. In general, prefer let and const inside blocks to limit scope and reduce bugs.

Best practices and patterns for modern JavaScript development

Adopt a few core patterns to leverage block scope effectively:

Default to const for bindings that should not be reassigned, and use let only when reassignment is needed.
Keep variables as close as possible to where they are used to minimize their scope.
Avoid redeclaring the same binding in the same scope; let and const do not allow this.
Use block scope to encapsulate helpers within functions, loops, and conditional blocks to prevent leakage into the global scope.
Be mindful of TDZ and ensure initialization happens before any access.

Following these practices helps create readable, maintainable, and bug-resistant JavaScript code that scales well across teams and projects.

Common questions and pitfalls everyone should know

Block scope can be tricky when coming from var based code or when working in older environments. A few practical tips:

Always prefer const by default; switch to let when you need to reassign.
Be careful with objects declared with const; their properties can still change, even though the binding cannot be reassigned.
If you need to run code in different iterations of a loop with closures, use let inside the loop to create new bindings per iteration.
Understand the TDZ to avoid ReferenceError during initializations inside blocks.
In some environments, block scope for function declarations inside blocks can vary; prefer function expressions or arrows when you need consistent behavior across runtimes.

These guidelines help you write robust code that behaves predictably in modern JavaScript engines.

Questions & Answers

What is the difference between let and var in terms of block scope?

Let declares a block scoped variable, which means its binding is limited to the nearest enclosing block. Var declares a function scoped variable, which can lead to leaks or unexpected behavior inside blocks. In modern code, prefer let for mutable state and var only in legacy patterns.

Is const block-scoped in JavaScript?

Yes. Const creates a block scoped binding just like let. The binding cannot be reassigned, though the contents of objects can still be mutated. Use const for values that should not change after initialization.

What is the temporal dead zone and how does it relate to block scope?

The temporal dead zone is the period where a let or const binding exists but is not yet initialized. Accessing it yields a ReferenceError. This behavior reinforces safe initialization within blocks.

Can I redeclare a variable declared with let or const?

No. You cannot redeclare a binding created with let or const in the same scope. This helps prevent accidental overwrites and improves code clarity.

When should I use let over const?

If a variable will be reassigned, use let. Otherwise, default to const to express intent clearly and reduce the chance of accidental reassignments.

Does block scope apply to function declarations inside blocks?

In modern engines, function declarations inside blocks are largely block-scoped, but behavior can vary by environment. For consistency, prefer function expressions or arrow functions inside blocks when you need reliable scope.