Climbing the “Hoisting” Hurdle

Yash Bhandare
Published in
3 min readDec 6, 2023


Hoisting is a behaviour in JavaScript where variable and function declarations are moved to the top of their containing scope during the compilation phase, before the code is executed.

It means that you can use a variable or call a function before it’s declared in your code, and JavaScript will still work as if it has been declared in the appropriate place.

Hoisting applies to both variable declarations & function declarations but works slightly differently for each:

Variable Hoisting:

  • When you declare a variable using the var keyword, it gets hoisted to the top of its containing function or global scope. However, the variable is initialized with the value undefined by default.
  • For example:
console.log(x); // Outputs: undefined
var x = 5;
  • In the above code, the var x declaration is hoisted to the top, but its value is assigned undefined until the assignment statement x = 5 is reached.

Function Hoisting:

  • Function declarations, unlike variables declared with var, are hoisted with their entire definition, including the function body.
  • For example:
foo(); // This works even though the function is called before it's declared.

function foo() {
console.log('Hello, world!');
  • In this case, the foo function is hoisted to the top of the scope, so you can call it before its actual declaration in the code.

It’s important to note that hoisting can lead to unexpected behaviour and bugs if you’re not aware of how it works. To write more readable and maintainable code, it’s recommended to declare variables at the top of their containing function or block (if using let or const for block-scoped variables) and declare functions before you use them.

In modern JavaScript, using let and const for variable declarations instead of var can help mitigate some of the issues related to hoisting, as they have block-level scope and are not initialized to undefined by default. However, hoisting still occurs for let and const, but they are in the "temporal dead zone" until their actual declaration. This means you cannot access them before they are declared in the code.

The “Temporal Dead Zone” (TDZ) is a concept in JavaScript that applies specifically to the let and const declarations. It refers to the period between entering a scope (such as a block or function) and the actual declaration of a let or const variable within that scope. During TBZ, accessing the variable results in a ReferenceError.

Here’s how the “Temporal Dead Zone” works:

  1. Entering the Scope: When a JavaScript engine enters a new scope (e.g., a block or function), it sets up memory space for all variables declared with let and const within that scope.
  2. TDZ Begins: At this point, before the actual declarations are encountered in the code, the variables are in the temporal dead zone. This means you cannot access them or perform operations like reading their values. Attempting to access them will result in a ReferenceError.
  3. Declaration: Once the JavaScript engine encounters the let or const declaration in the code, it assigns the variable the initial value undefined (for let) or does not initialize it at all (for const). This is when the variable comes out of the temporal dead zone.
  4. Normal Operation: After the variable is declared, you can use it as usual, and it will behave as expected.

Here’s an example to illustrate the Temporal Dead Zone:

console.log(x); // ReferenceError: Cannot access 'x' before initialization
let x = 10; // Declaration happens here
console.log(x); // Now 'x' is accessible and has the value 10

In this example, the first console.log(x) inside the TDZ throws a ReferenceError because we are trying to access x before its declaration. The TDZ for x begins at the start of the block and ends when the let x declaration is encountered.

The temporal dead zone serves as a safeguard to catch potential bugs and encourages developers to declare their variables before using them. It is a feature introduced with ES6 (ECMAScript 2015) to address some of the issues associated with variable hoisting when using var.


To work effectively with hoisting and avoid potential issues, you can take some measures:

  1. Use let and const: instead of var to declare variables.
  2. Declare variables at the top of the scope.
  3. Declare functions before use.
  4. Avoid using variables before declaration.
  5. Understand the Temporal Dead Zone.