Const Keyword in javascript

In JavaScript, the const keyword is used to declare variables that have block scope and whose values cannot be reassigned after they are initialized. Here's an explanation of how const works:

1. Block Scope:
Variables declared with const have block scope, just like variables declared with let. They are only accessible within the block in which they are defined. This includes if statements, loops, and any other block of code. For example:

   function greet() {
     if (true) {
       const message = "Hello";
       console.log(message);
     }
     console.log(message); // Throws ReferenceError: message is not defined
   }

   greet(); // Output: Hello

In this example, the message variable is declared with const inside the if block. It is accessible within the block and can be used for logging. However, trying to access the variable outside the block will result in a ReferenceError since it is not defined in that scope.

2. Value Assignment:
Variables declared with const must be assigned a value at the time of declaration. Once assigned, the value cannot be changed or reassigned. For example:

   const PI = 3.14;
   PI = 3.14159; // Throws TypeError: Assignment to constant variable.

In this case, PI is assigned the value 3.14 when it is declared with const. Any attempt to reassign a new value to PI will result in a TypeError because const variables are read-only.

3. Immutable Values:
const variables are not completely immutable. While you cannot reassign the variable itself, if the variable holds a reference to an object or an array, the properties or elements of that object or array can still be modified. For example:

   const person = {
     name: "John",
     age: 25,
   };

   person.age = 30; // Valid, the properties of the object can be modified
   person = {}; // Throws TypeError: Assignment to constant variable.

In this example, the person variable is declared with const and initially assigned an object. Although you cannot reassign a new object to person, you can modify the properties of the existing object.

4. Hoisting and Temporal Dead Zone (TDZ):
Variables declared with const are also not hoisted to the top of their scope like variables declared with var. They are subject to the temporal dead zone (TDZ), which means they cannot be accessed before they are declared. For example:

   console.log(name); // Throws ReferenceError: name is not defined
   const name = "John";
   console.log(name); // Output: John

In this case, attempting to access the name variable before it is declared will result in a ReferenceError. The variable needs to be declared before it can be used.

The const keyword provides a way to declare variables that are intended to be read-only and not reassigned. It helps enforce immutability and ensures that certain values remain constant throughout the execution of the program. It is recommended to use const whenever you know that a variable's value should not be changed after initialization.