JavaScript has some unique behaviors that can surprise even experienced developers. One of these behaviors is hoisting. In this post, we'll take a simple look at what hoisting is, how it works, and some common scenarios where it might trip you up.

What is Hoisting?
Hoisting is a mechanism in JavaScript where variable and function declarations are moved to the top of their containing scope during the compilation phase. This means that you can use variables and functions before you declare them in your code.

However, only the declarations are hoisted, not the initializations. Let's see how this works in practice.

Hoisting with Variables
Let's start with a simple example using var:

console.log(message); // undefined
var message = "Hello, World!";
console.log(message); // "Hello, World!"

What happened here? Because of hoisting, the var declaration is moved to the top of the scope, so the code behaves as if it were written like this:

var message;
console.log(message); // undefined
message = "Hello, World!";
console.log(message); // "Hello, World!"

The variable message is declared at the top, but it's not initialized with the value "Hello, World!" until later in the code. This is why the first console.log prints undefined.

Hoisting with let and const
With let and const, the behavior is slightly different. Although they are also hoisted, they are not initialized until the code execution reaches their declaration. This results in a ReferenceError if you try to access them before they are declared.

console.log(message); // ReferenceError: Cannot access 'message' before initialization
let message = "Hello, World!";

In this case, the declaration is hoisted, but the initialization is not, and the variable is in a "temporal dead zone" until the declaration is encountered in the code.

Hoisting with Functions
Function declarations are fully hoisted, meaning you can call a function before it is defined in your code:

greet(); // "Hello, World!"

function greet() {
  console.log("Hello, World!");
}

Here, the function greet is hoisted to the top of the scope, so it can be called before its actual definition in the code.

Hoisting with Function Expressions
Function expressions, however, behave more like variables:

greet(); // TypeError: greet is not a function

var greet = function() {
  console.log("Hello, World!");
};

In this example, the variable greet is hoisted, but its assignment (the function expression) is not. So when greet() is called, it results in a TypeError because greet is undefined at that point.

Key Takeaways
Variables declared with var are hoisted to the top of their scope, but their initialization is not. This can lead to unexpected undefined values.
let and const declarations are hoisted but not initialized until their declaration is encountered, leading to a "temporal dead zone" where accessing them results in a ReferenceError.
Function declarations are hoisted entirely, allowing you to call functions before they are defined in your code.
Function expressions are treated like variables and do not hoist the function definition.
Understanding hoisting helps you avoid bugs and write cleaner, more predictable code.

Console You Later!