Mastering JavaScript Const: The Ultimate Guide to Constants

-

Introduction to JavaScript Const

In JavaScript, the `const` keyword is used to declare a constant - a value that cannot be reassigned once it has been initialized. Constants are often used to store values that should never change throughout the program.

Properties:

  • Cannot be reassigned.
  • It’s Block Scope
  • It can be assigned to the variable on the declaration line.
  • It’s a Primitive value.
  • The property of a const object can be changed but it cannot be changed to a reference to the new object
  • The values inside the const array can be changed, it can add new items to const arrays but it cannot reference a new array.
  • Re-declaring of a const variable inside different block scopes is allowed.
  • Cannot be Hoisted.
  • Creates only read-only references to value.

Here's an example of declaring a constant:

const PI = 3.14159;

In this example, `PI` is a constant that has been assigned the value of `3.14159`. Once this constant has been declared and assigned, it cannot be reassigned to a different value.

Declaration and Initialization

To declare a constant, you use the `const` keyword followed by the constant name and the value you want to assign to it. Constants must be initialized at the time of declaration. Once initialized, constants cannot be redeclared or have their value changed.

Here's an example:

const name = 'John';
 
const age = 30;

In this example, `name` is a constant that is assigned the string value `'John'`, and `age` is a constant that is assigned the numerical value `30`.

Block Scope

Constants, like variables created with the `let` keyword, have **block scope**. This means they are only accessible within the block of code where they are defined. A block is typically defined by a set of curly braces `{}` used for loops, conditional statements, or function declarations.

Here's an example:

{
 
  const x = 10;
 
  console.log(x); // Output: 10
 
}
 
console.log(x); // Output: ReferenceError: x is not defined

In this example, `x` is a constant that is defined within the first block of code (enclosed by `{}`). It is accessible within that block and any nested blocks (if any). However, outside of that block, `x` is not defined.

Reassignment

Once a constant has been declared and assigned a value, it cannot be reassigned to a different value. Attempting to do so will result in an error.

Here's an example:

const country = 'Canada';
 
country = 'USA'; // Error: Assignment to constant variable

In this example, `country` is a constant that is initially assigned the value `'Canada'`. The following line tries to reassign `country` to the value `'USA'`, which results in an error.

Object Constants

When dealing with objects assigned to constants, the object itself cannot be reassigned (i.e., assigned a different object). However, the properties of the object can be modified.

Here's an example:

const person = {
 
  name: 'John',
 
  age: 30
 
};
 
person.name = 'Jane'; // Valid: Modifying a property
 
person = {};          // Error: Assignment to constant variable

In this example, `person` is a constant that is assigned an object with two properties: `name` and `age`. It is valid to modify the value of the properties (`person.name = 'Jane'`), but trying to reassign `person` to an empty object (`person = {}`) will result in an error.

Key Takeaways

  • The `const` keyword is used to declare constants in JavaScript.

  • Constants cannot be reassigned once they have been initialized.

  • Constants have block scope, meaning they are only accessible within the block of code where they are defined.

  • Constants can be used with objects, but the object itself cannot be reassigned - only its properties can be modified.

Comments

Post a Comment

Popular posts from this blog

Limitations of JavaScript

-
Introduction to Limitations of JavaScript JavaScript is a widely used programming language that runs on all major web browsers. It is known for its versatility and ability to create dynamic and interactive web pages. However, like any programming language, JavaScript has its limitations. In this learning guide, we will explore the limitations of JavaScript to help you better understand its strengths and weaknesses. 1. Performance Limitations JavaScript is an interpreted language , which means that it is executed line by line at run-time. This can result in slower performance compared to compiled languages like C++ or Java. Additionally, JavaScript is a single-threaded language , meaning that it can only execute one operation at a time. This can lead to performance bottlenecks when dealing with computationally intensive tasks or handling large amounts of data. // Example of slow performance in JavaScript for ( var i = 0 ; i < 1000000000 ; i ++ ) { // Perform some computati...
Read more

'for in' Loop

-
Introduction to JavaScript 'for in' Loop The `for in` loop is a type of loop in JavaScript that is used to iterate over the properties of an object. It is often used when you need to loop through the keys or properties of an object and perform some action on each one. Unlike other loops like `for` and `while`, the `for in` loop is specifically designed to work with objects. Syntax The syntax for the `for in` loop is as follows: for   ( variable  in  object )   {    // code to be executed } The `variable` represents a temporary variable that will hold the key of each property in the object. The `object` is the object that you want to iterate over. Example Let's take a look at an example to understand how the `for in` loop works: const  person  =   {   name :   'John' ,   age :   30 ,   gender :   'male' } ;   for ...
Read more

What is JIT compiler? Is JavaScript compiled or interpreted or both?

-
What is JIT compiler? A Just-In-Time (JIT) compiler is a type of compiler that dynamically converts programming code into machine code at runtime, just before the code is executed. Unlike traditional compilers that convert the entire program ahead of time, a JIT compiler optimizes and compiles code on-the-fly, as it is needed. The primary advantage of a JIT compiler is that it can make the execution of code significantly faster compared to an interpreter. It achieves this by analyzing the code at runtime, identifying hotspots (frequently executed portions of code), and applying various optimization techniques to generate highly efficient machine code specific to the underlying hardware. JIT compilers are commonly used in programming languages such as Java and JavaScript, where the execution speed of the code is crucial. So is JavaScript Compiled or Interpreted? JavaScript is generally considered an interpreted language . Traditionally, JavaScript code is executed by an interpreter, wh...
Read more