Hoisting in JavaScript

What is Hoisting in JavaScript? How to use Hoisting?

Hoisting is one of the default behavior of moving declaration to the top in JavaScript. In this tutorial, we will learn about JavaScript hoisting with the help of examples. The concept of hoisting is very important becase it causes error many time if you haven't use this concept properly.

In JavaScript, Hoisting is a behavior in which a variable or a function can be used before declaration.

Note:
In strict mode "use strict;", JavaScript does not allow variables to be used if they are not declared.

For example,

                                // using abc before declaring
                                console.log(abc); // undefined
                                var abc;
                            

The above codes will work fine and the output will be undefined, internally this will behave as:

                                // using abc after declaring
                                var test;
                                console.log(abc); // undefined
                            

Note:
If we talk about the variables and constants, keyword var is hoisted and let and const does not allow hoisting.

Examples

                                a = 5;
                                console.log(a);
                                var a; // 5
                            

                                var a;
                                a = 5;
                                console.log(a); // 5
                            

                                console.log(a); // undefined
                                var a = 5; 
                            

Hoisting, inside the function:

When we use any variable in the function scope, the variable is hoisted only to the top of the function. Outside the function scope, it will throw an error "Uncaught ReferenceError: X is not defined", For example:

                                var a = 4;
                                
                                function test() {
                                    b = 'hello';
                                    console.log(b); // hello
                                    var b;
                                }
                                
                                test(); // hello
                                console.log(b); // Uncaught ReferenceError: b is not defined
                            

Note:
In JavaScript hoisting, the variable declaration is only accessible to the immediate scope. If you are using let then you can not use hoisting behavior. While using let, the variable must be declared first.

Examples with let and const:

                                a = 5;
                                console.log(a);
                                let a; // error - Uncaught ReferenceError: Cannot access 'a' before initialization
                            

Function Hoisting in JavaScript:

A function can be hoisted in JavaScript, It means a function can be called before declaring it. For example,

                                test();
                                
                                function test() {
                                    console.log('Hi, test.'); // Hi, test.
                                }
                            

Here is an issue with function hoisting:

If you are using an function expression it will throw an error, because only declarations are hoisted.

                                test(); // Uncaught ReferenceError: test is not defined
                                
                                let test = function() {
                                    console.log('Hi, test.');
                                }
                            

If you use var in the above codes, then you will get another error "Uncaught TypeError: test is not a function".

                                test(); // Uncaught TypeError: test is not a function
                                
                                var test = function() {
                                    console.log('Hi, test.'); 
                                }
                            

Conclusion:

In this article we implemented Hoisting in JavaScript and learned about What is Hoisting in JavaScript? How to use Hoisting?. We have seen some examples and implemented Hoisting, inside the functions. We read about the Function Hoisting in JavaScript. Now we can implement Hoisting in our javascript projects.