Understanding JavaScript Variable Declarations: var, let, and const ๐Ÿš€


4 min read

Play this article

In the dynamic world of JavaScript, effective variable management is a fundamental skill for every developer. The choices you make when declaring variables can profoundly impact your code's behaviour and maintainability. In this comprehensive guide, we delve into the key differences between var, let, and const variable declarations, shedding light on their scope, hoisting behaviour, and reassignment rules. Whether you're a junior developer looking to solidify your understanding or a seasoned pro seeking a quick reference, this article has you covered. ๐Ÿ”

Var Declarations: The Legacy Choice ๐Ÿ•ฐ๏ธ


In the pre-ES6 era, JavaScript developers relied heavily on the var keyword for variable declarations. var variables exhibit two distinct scopes:

  1. Global Scope: When declared outside a function, a var variable becomes globally scoped. This means it can be accessed from anywhere in your code. ๐ŸŒ

     var greetingGlobal = "hey hi"; // globally scoped
     function newFunction() {
       var greetingFunction = "hello"; // function scoped
     console.log(greetingGlobal); // "hey hi"
  2. Function Scope: When declared within a function, a var variable is limited to that function's scope and cannot be accessed outside of it. ๐Ÿ—ƒ๏ธ


One notable feature of var variables is their leniency regarding reassignment. You can update and re-declare var variables within the same scope without encountering errors:

var greeter = "good morning";
var greeterUpdated = "good day instead"; // No error


var variables are hoisted to the top of their scope and automatically initialized with the value undefined. This hoisting behaviour can lead to unexpected results if you're not careful. ๐Ÿงฉ

Let Declarations: Block-Scoped Excellence ๐Ÿงฑ

With the introduction of ES6, the let keyword emerged as the preferred choice for variable declarations. It offers a more controlled approach to variable management.


The key distinction of let variables is their block scope. A let variable is only accessible within the block where it's declared. This block scope ensures that your variables are isolated and don't leak into unintended parts of your code:

let greetingBlock = "say Hi";

if (isMorning) {
  let greetingMorning = "say Good Morning instead";
  console.log(greetingMorning); // "say Good Morning instead"

console.log(greetingBlock); // "say Hi"


While you can update the value of a let variable within its scope, attempting to re-declare it in the same scope will result in an error:

let greetingLet = "say Hi";
greetingLet = "say Hello instead"; // No error

let greetingLet = "say Hi"; // error: Identifier 'greetingLet' has already been declared


Like var, let declarations be hoisted to the top of their respective blocks. However, unlike var, let variables are not initialized. Attempting to use a let variable before declaration will result in a Reference Error. ๐Ÿšง

Const Declarations: Immutable Blocks ๐Ÿ—„๏ธ

When you want to declare variables that should remain constant throughout their lifespan, const comes to the rescue.


const variables share the block scope feature with let. They are accessible only within the block where they are defined.

const pi = 3.14159;

if (isCircle) {
  const pi = 22 / 7;
  console.log(pi); // 3.142857142857143

console.log(pi); // 3.14159


The defining characteristic of const variables is their immutability. Once a value is assigned to a const, it cannot be updated or re-declared:

const greetingConst = "say Hi";
greetingConst = "say Hello instead"; // error: Assignment to constant variable.

const greetingConst = "say Hi"; // error: Identifier 'greetingConst' has already been declared

Object Properties

Interestingly, while a const object itself cannot be updated, its properties can still be modified:

const car = {
  brand: "Tesla",
  model: "Model 3"

car.model = "Model Y"; // No error


Similar to let, const declarations are hoisted to the top of their blocks but are not initialized. Attempting to access a const variable before declaration will result in a Reference Error. ๐Ÿ“ฆ

In Summary ๐Ÿ“

To recap, here's a quick reference guide to help you navigate the nuances of variable declarations in JavaScript:

  • var: Globally or function scoped, allows reassignment, hoisted with undefined.

  • let: Block scoped, allows updates but not redeclaration, hoisted without initialization.

  • const: Block scoped, immutable, allows object property updates, hoisted without initialization.

By understanding the distinctions between var, let, and const, you'll be better equipped to write clean and error-free JavaScript code. These choices may seem subtle, but they can significantly impact the behaviour and maintainability of your applications. Happy coding! ๐Ÿš€

๐ŸŒŸ Happy Coding! ๐ŸŒŸ