Decrypting JavaScript Hoisting: How Variables and Functions Behave
Tags: webdev, javascript, beginners, tutorial
Published: 2023-08-09 07:20:23

If you're a JavaScript enthusiast, you've probably heard the term "hoisting." In this article, we'll unravel the mysteries of hoisting, shedding light on how it influences your code's behavior. 

## Introduction to Hoisting

Hoisting is like a magician's trick in the world of JavaScript .In JavaScript, hoisting is the behind-the-scenes process where variable and function declarations are moved to the top of their respective scopes during the compilation phase. This means that you can use these variables and functions before they're even formally declared in the code.

Hoisting plays a crucial role in how JavaScript code is executed. It ensures that variables and functions are accessible anywhere within their scope, even if they're declared further down the code. However, there's a twist – only the declarations are hoisted, not the actual assignments or initializations.

This dynamic behavior can lead to some interesting scenarios and occasional head-scratching moments, especially for newcomers to JavaScript. Understanding hoisting helps you navigate these waters and write code that behaves predictably, ultimately contributing to cleaner and more efficient programming.

In the upcoming sections, we'll take a closer look at how hoisting works, its impact on variables and functions, and best practices for harnessing its power effectively

## Variable Hoisting


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/3rma4stzw6lq4l63qeuy.png)

Picture yourself as a magician conjuring a spell; before even uttering the incantation, you gather all the mystical elements needed, ready to bring your enchantment to life. That's a bit like what happens with variables in JavaScript. Let's break it down and see how variable hoisting unfolds in the realm of JavaScript.

In JavaScript, variable declarations have a special trick up their sleeve – they're hoisted to the top of their scope before the actual code execution. 


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/vzqmjdv0lx6luc0dviwa.png)

In the code snippet provided, the enchantedVariable experiences hoisting, yet its enchanting power remains undefined until it's declared into existence later. Think of it as having all the magical elements ready at hand, yet the true mystical effect is revealed only after the magic is cast.

- Declaration vs. Initialization

It's crucial to understand that hoisting impacts solely the declaration of a variable, not its initialization. Imagine it as inscribing the names of magical components before you weave them into the enchanting spell.


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/xcpvw4wm5uoyib21rfo1.png)

Here, potionName is hoisted, but its taste (value) is undefined until you assign it.

- Hoisting and Variable Types

As we venture deeper into the world of hoisting, it's important to understand how different variable types respond to this phenomenon. While we've covered the behavior of var variables, let's now shine a spotlight on the other stars of the show – let and const

- The let Dilemma

When it comes to let variables, hoisting throws a curveball. They experience what's known as the "temporal dead zone." Envision a secret backstage enclave where enchanting actors linger before their grand entrance onto the mystical stage. In a similar fashion, let variables wait in this zone until they're officially declared in the code.


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/n2z2ptxeul5n9338n7bz.png)

In this snippet, attempting to access spellName before its declaration triggers an error, as if the actor isn't ready for their cue yet.

- How about Const

Similar to let, const variables also spend time in the temporal dead zone during hoisting. 

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/x480mgp3jffntal4ufsg.png)

Here, trying to access potionType prematurely results in an error, as if the actor hasn't entered the stage yet.

Once both let and const variables are declared, they emerge from the temporal dead zone and become accessible. It's like the curtain being drawn and the actors stepping forward to perform.

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/nnsuxcwc5juklene0c8k.png)

In this example, spellElement is a let variable that can be accessed after its declaration.

## Function Hoisting

In JavaScript, functions enjoy a special treatment during hoisting. Similar to variable declarations, function declarations are also moved to the top of their scope before the actual code execution begins. This means you can call functions even before they're formally defined in your code.

- Declaration vs. Execution

Just as actors announce their roles before they begin acting, function declarations are hoisted to the top of their scope, but they are only executed when they're called later in the code.


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/42lpjvgfe0vk4jg60bze.png)

In this example, the invokeSpell function is hoisted, allowing it to be invoked even before its actual appearance in the code.

- Function Expressions and Their Twist

Function expressions, where a function is assigned to a variable, bring an interesting twist to the hoisting story. While the variable declaration is hoisted, the assignment itself remains in place.


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/408zx4fgajuypghd6wx0.png)

In this case, attempting to enchant before the function is assigned results in an error, much like trying to interact with a character before their scene begins.

## Best Practices

Hoisting, while magical, can also lead to unexpected twists if not approached with care. Let's dive into some useful advice that can help you navigate the world of hoisting with ease. 

- Declare First, Use Later

Akin to gathering magical components before casting a spell – declare your variables and functions before using them in your code. This ensures everything is ready when you need it, without any surprises.


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/rohplxkjxwf3hizatkrr.png)

- Avoid Saying Things Twice

Just like repeating the same story gets boring, redeclaring variables and functions can lead to confusion. Keep things clear by declaring things only once in a given area.


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/5bp983xf91459nuedoac.png)

- Embrace let and const as Your Allies

Choose let and const instead of var for your variables. They're like reliable friends that make sure your variables behave the way you expect.

- Follow the Rules

Just like playing a game, following the rules makes things fair. Stick to naming things clearly and placing them where they belong to keep your code organized.

- Test Like a Champ

Testing your code is like checking a puzzle for missing pieces. It's a way to make sure everything works the way it should.

By using these simple tricks, you'll be ready to tackle hoisting challenges head-on. Remember, learning a few tricks can make your coding journey a lot more enjoyable and successful. Let's continue exploring hoisting together, armed with these handy tips! 

Graphics sourced from:   [freekpik](https://www.freepik.com/), [forgottenrealms](https://forgottenrealms.fandom.com/wiki)