javascriptweb developmentprogrammingscope and hoisting

Scope and Hoisting in JavaScript

By Swann
Picture of the author
Published on
Scope and Hoisting in JavaScript


Understanding scope and hoisting is pivotal for effectively managing variables and functions in JavaScript. Scope defines the accessibility of variables, objects, and functions in the code, whereas hoisting is JavaScript's behavior of moving declarations to the top of the current scope (to the top of the current script or the current function).

Understanding Scope

In JavaScript, there are two types of scope:

  • Global Scope: Variables declared outside a function or block are in the global scope and are accessible throughout the program.
  • Local (Function/Block) Scope: Variables declared inside a function or block are in the local scope and are only accessible within that function or block.
var globalVar = "I am global";  // Global scope

function exampleFunction() {
    var localVar = "I am local";  // Local scope
    console.log(globalVar);  // Accessible
    console.log(localVar);  // Accessible

console.log(globalVar);  // Accessible
console.log(localVar);  // ReferenceError

Var, Let, and Const

The var, let, and const keywords affect the scope and hoisting of variables.

  • var: Variables declared with var are function-scoped and are hoisted to the top of the function.
  • let and const: Variables declared with let and const are block-scoped and are not hoisted to the top of the block.

Hoisting in JavaScript

Hoisting in JavaScript moves the declarations to the top of the current scope before code execution.

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

console.log(b);  // ReferenceError
let b = 3;

In the above example, var a is hoisted but not its assignment, resulting in undefined. let b is not hoisted, resulting in a ReferenceError.

Function Hoisting

Function declarations are hoisted to the top of the scope, but function expressions (using var) are not.

console.log(funcDecl());  // "Function Declaration"
console.log(funcExpr());  // TypeError

function funcDecl() {
    return "Function Declaration";

var funcExpr = function() {
    return "Function Expression";

Best Practices

  • Use let and const: Prefer using let and const over var for block scoping and avoiding unintentional hoisting issues.
  • Initialize Variables: Ensure variables are initialized before usage to avoid undefined values due to hoisting.
  • Manage Function Declarations: Be aware of the hoisting of function declarations and expressions.


Scope and hoisting are fundamental concepts in JavaScript that influence the accessibility and usage of variables and functions. Understanding these concepts allows developers to write cleaner, error-free, and predictable code, ensuring variables and functions are utilized effectively in various parts of the application.

Additional Resources

Stay Tuned

Want to become a Next.js pro?
The best articles, links and news related to web development delivered once a week to your inbox.