Hoisting in Javascript

There’s a concept called Hoisting in JavaScript. Let’s look at what it is in the next video.

In the last video, you looked at what hoisting is. So, what happens behind-the-scenes in hoisting? All the variables which are declared in your code are moved at the top and remembered by the compiler. This is how, when you run the code, all the variables are accessible even though it seems like the variables haven’t been declared yet. But remember that all these variables are initialized with the value as undefined. And this is why, if you try to access a variable without initializing it, you get the value as undefined.

Till now, you learned what happens when variables are hoisted in JavaScript. Let’s now discuss what happens when the functions are hoisted in JavaScript. Consider this example:
 

function add(x, y) {
   console.log(x+y);
}

add(1, 2);

Well, it’s very obvious that the output of this code will be 3, which is the sum of 1 and 2.
Output:
 

3

Now, what will happen if you move the invoke statement before function declaration, like this:
 

add(1, 2);

function add(x, y) {
   console.log(x+y);
}

Notice that here you are calling a function before even declaring and defining it. What do you think the output of this code be?

Output:
 

3

Well, it’s again 3. This is because like variable declarations, JavaScript hoists function declarations to the top of the code as well. Thus, you can call any function which has been declared later. Well, I won’t recommend you doing that but of course, this is possible.

Now, one more question. Consider this code snippet:
 

var add;
add(1, 2);

Notice that the add is not declared as a function anywhere. So, what do you think will happen when you run this code?

Output:
 

Uncaught TypeError: add is not a function

Well, it will throw a type error and say that add is not a function. This is because the variable add contains the default value undefined and undefined value cannot be considered as a function.
 

Now that you have learned hoisting, a last tricky question for you. What do you think will be the output of this code snippet?
 

add(1, 2);

var add = function(x, y) {
   console.log(x + y);
};

Do you think it will print 3?
Output:
 

Uncaught TypeError: add is not a function

This will instead throw a type error saying “add is not a function”. This is because add is a variable here and you are assigning a function to this variable. Now, as you know that variables are hoisted in JavaScript to the top, so this code will be transformed to:
 

var add;

add(1, 2);

add = function(x, y) {
   console.log(x + y);
};

As you can see, this is quite similar to the one we already saw in the last example where a variable is declared and initialized to undefined and then that variable is treated as a function and thus, an error is thrown.
 

So, we saw what hoisting is. Now, how can you prevent it? You can do so by declaring all your variables at the top of the scope where they are needed to be referenced. Also, you should try to initialize the variables that will not change their values in future so as to prevent their undefined behaviour.