What is function hoisting?

Function hoisting is a behavior in JavaScript where function declarations are moved (or "hoisted") to the top of their containing scope during the compilation phase. This means that you can call a function before its actual declaration in the code, and JavaScript will still execute it correctly. However, it's important to note that this behavior applies only to function declarations, not to function expressions or arrow functions.

Function Declaration Hoisting

sayHello(); // This works because of hoisting function sayHello() { console.log("Hello!"); }

In this example, the sayHello function is called before its declaration in the code. Due to hoisting, JavaScript moves the function declaration to the top, allowing it to be invoked without any issues.

Function Expression and Arrow Function Hoisting

greet(); // This will result in an error var greet = function() { console.log("Greetings!"); };

Unlike function declarations, function expressions are not hoisted in the same way. In the above example, trying to invoke greet before its declaration will result in an error, as the variable greet is hoisted, but its value (the function) is not assigned until later in the code.

Important Considerations:

  1. Hoisting Order: Function declarations are hoisted before variables, which means they take precedence when declared in the same scope.
  2. Function Expressions: Function expressions and arrow functions are not hoisted in the same way as function declarations. Their variables are hoisted, but their values (functions) are not assigned until their actual positions in the code.
  3. Redeclaration: If a function is declared multiple times in the same scope, the later declaration will overwrite the earlier one due to hoisting.
  4. Best Practice: While function hoisting can be convenient, it's considered a best practice to define functions before using them in the code. This enhances code readability and avoids potential confusion.
  5. Let and Const: Variables declared with let and const are hoisted as well, but unlike function declarations, they are not initialized until their declaration in the code. This is known as the "temporal dead zone."


Function hoisting simplifies the ordering of code but can also lead to confusion if not used carefully. To avoid unexpected behavior, it's recommended to define functions before they are called and to be aware of how different types of function declarations and expressions behave with respect to hoisting.