Learn about the difference between var, let, and const keywords in JavaScript and when to use them.
Tags: javascript, webdev, beginners
Published: 2023-06-02 10:21:01

## var, let, and const: What's the Difference in JavaScript?

JavaScript is a dynamic and flexible language that allows you to declare variables in different ways. You can use var, let, or const keywords to declare variables in JavaScript, but what's the difference between them and when should you use them?

In this article, you will learn about the difference between var, let, and const keywords in JavaScript and some of their advantages and disadvantages.

## What is a variable?
A variable is a container for storing information. You can use a variable to store a value, such as a number, a string, a boolean, an object, or a function. You can also use a variable to refer to a value that may change over time.

To declare a variable in JavaScript, you need to use a keyword followed by a name for the variable. For example:

var x = 10; // Declare a variable using var
let y = 20; // Declare a variable using let
const z = 30; // Declare a variable using const

The name of the variable must follow some rules:

•  It must begin with a letter, or $, or _.

•  It cannot contain spaces or punctuation marks (except $ and _).

•  It cannot be a reserved word in JavaScript, such as var, let, const, if, for, etc.

•  It is case sensitive, meaning that x and X are different variables.

## What is the difference between var, let, and const?
The main difference between var, let, and const is how they affect the scope and hoisting of the variables.

**Scope**
The scope of a variable is the part of the code where the variable can be accessed or used. In JavaScript, there are two types of scopes: global scope and local scope.

•  Global scope: A variable declared in the global scope can be accessed from anywhere in the code. A variable declared outside any function or block is in the global scope.

•  Local scope: A variable declared in the local scope can only be accessed within the function or block where it is declared. A variable declared inside a function or block is in the local scope.

The scope of a variable declared with var is either global or function-based. This means that if you declare a variable with var inside a function, it can only be accessed within that function. However, if you declare a variable with var inside a block (such as an if statement or a for loop), it can be accessed outside that block as well.



![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/kb3jljx1lebempdkyfiq.png)

For example:
```
function foo() {
var x = 10; // Declare x with var inside foo function
if (true) {
var y = 20; // Declare y with var inside if block
console.log(x); // 10 (x is accessible inside if block)
console.log(y); // 20 (y is accessible inside if block)
}
console.log(x); // 10 (x is accessible outside if block)
console.log(y); // 20 (y is accessible outside if block)
}

foo();

console.log(x); // ReferenceError: x is not defined (x is not accessible outside foo function)
console.log(y); // ReferenceError: y is not defined (y is not accessible outside foo function)

```

The scope of a variable declared with let or const is block-based. This means that if you declare a variable with let or const inside any block (such as a function, an if statement, or a for loop), it can only be accessed within that block.

For example:
```
function foo() {
let x = 10; // Declare x with let inside foo function
const z = 30; // Declare z with const inside foo function
if (true) {
let y = 20; // Declare y with let inside if block
console.log(x); // 10 (x is accessible inside if block)
console.log(y); // 20 (y is accessible inside if block)
console.log(z); // 30 (z is accessible inside if block)
}
console.log(x); // 10 (x is accessible outside if block)
console.log(y); // ReferenceError: y is not defined (y is not accessible outside if block)
console.log(z); // 30 (z is accessible outside if block)
}

foo();

console.log(x); // ReferenceError: x is not defined (x is not accessible outside foo function)
console.log(y); // ReferenceError: y is not defined (y is not accessible outside foo function)
console.log(z); // ReferenceError: z is not defined (z is not accessible outside foo function)
```

Using block-based scope can prevent accidental leaks and conflicts of variables with the same name in different blocks.

Hoisting
Hoisting is a mechanism in JavaScript that moves the declarations of variables to the top of their scope before any code is executed. This means that you can use a variable before it is declared, but its initial value will be undefined.

Hoisting applies differently to variables declared with var, let, and const.

Variables declared with var are hoisted to the top of their scope, either global or function-based. This means that you can use them before they are declared, but their initial value will be undefined.

For example:

console.log(x); // undefined (x is hoisted but not initialized)
var x = 10;
console.log(x); // 10

Variables declared with let or const are also hoisted to the top of their scope, but they are not initialized until they are declared. This means that you cannot use them before they are declared, and you will get a reference error.

For example:
```
console.log(x); // ReferenceError: Cannot access 'x' before initialization (x is hoisted but not initialized)
let x = 10;
console.log(x); // 10

console.log(y); // ReferenceError: Cannot access 'y' before initialization (y is hoisted but not initialized)
const y = 20;
console.log(y); // 20
```

This behavior creates a temporal dead zone between the hoisting and the initialization of the variables declared with let or const. This can prevent errors and enforce good coding practices.

When to use var, let, and const?
As you have seen, there are some advantages and disadvantages of using var, let, and const to declare variables in JavaScript. So when should you use them?

The general recommendation is to avoid using var unless you have a specific reason to do so. Using var can cause confusion and errors due to its function-based scope and hoisting behavior.

Instead, you should use let or const to declare variables with block-based scope and temporal dead zone. This can prevent accidental leaks and conflicts of variables with different blocks.

The main difference between let and const is that let allows you to change the value of a variable after it is declared, while const does not. You should use const when you want to declare a constant value that will not change, such as:

•  A primitive value like a number or a string.

•  A reference to an object or an array that will always point to the same object or array.

•  A function expression or an arrow function.

You should use let when you want to declare a variable that may change over time, such as:

•  A counter or an iterator in a loop.

•  A temporary value in an algorithm.

•  A conditionally assigned value in an if-else statement.

Here are some examples of using let and const:
```
// Use const for primitive values that will not change
const PI = 3.14;
const NAME = "John";

// Use const for references to objects or arrays that will always point to the same object or array
const person = {name: "John", age: 25};
const numbers = [1, 2, 3];

// Use const for function expressions or arrow functions
const add = function(a,b) {
return a + b;
};

const multiply = (a,b) => {
return a * b;
};

// Use let for counters or iterators in loops
for (let i = 0
i < 10; i++) {
console.log(i); // 0, 1, 2, ..., 9
}

// Use let for temporary values in algorithms
let a = 10;
let b = 20;
let temp = a; // Use temp to swap the values of a and b
a = b;
b = temp;

// Use let for conditionally assigned values in if-else statements
let greeting;
if (hour < 12) {
greeting = "Good morning";
} else {
greeting = "Good afternoon";
}

console.log(greeting); // Depends on the value of hour
```

## Conclusion

In this article, you learned about the difference between `var`, `let`, and `const` keywords in JavaScript and when to use them. You learned that:

•  `var` declares a variable with function scope or global scope, and it is hoisted to the top of its scope with an initial value of `undefined`.

•  `let` and `const` declare variables with block scope, and they are hoisted to the top of their scope but not initialized until they are declared.

•  You should avoid using `var` unless you have a specific reason to do so, and use `let` or `const` instead.

•  You should use `const` when you want to declare a constant value that will not change, and use `let` when you want to declare a variable that may change over time.


I hope this article helps you understand the difference between `var`, `let`, and `const` in JavaScript. If you have any questions or feedback, please leave a comment below. Thanks for reading!blush