Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://www.geeksforgeeks.org/javascript/javascript-const/ below:

JavaScript const - GeeksforGeeks

Last Updated : 11 Jul, 2025

The const keyword in JavaScript is a modern way to declare variables, introduced in (ES6). It is used to declare variables whose values need to remain constant throughout the lifetime of the application.

const is block-scoped, similar to let, and is useful for ensuring immutability in your code. Unlike let, the primary feature of const is that it cannot be reassigned once it has been initialized.

Syntax

const variable = value;

• const is used to declare a variable and assign a value to it.
• After initialization, the value of a const variable cannot be reassigned.

Variables declared with const are block-scoped, which means they are accessible only within the block, statement, or expression in which they are defined.

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

• The variable x is declared with const inside a block, and its value 10 is logged within the block.
• Trying to access x outside the block causes an error because const variables are block-scoped.

Variables declared with const cannot be reassigned after their initial declaration. Attempting to do so results in a TypeError.

const y = 20;
y = 30; // TypeError: Assignment to constant variable.

• The variable y is declared with const and assigned a value of 20.
• Attempting to reassign y to 30 results in a TypeError because const variables cannot be reassigned.

Unlike let, a const variable must be initialized at the time of declaration. Declaring a const variable without assigning a value will throw a SyntaxError.

const z; // SyntaxError: Missing initializer in const declaration

• The variable z is declared with const, but it is missing an initial value.
• This causes a SyntaxError because const requires an initializer (a value) at the time of declaration.

const makes the variable binding immutable, but if the value is an object or array, you can still modify its properties or contents.

const obj = { name: "Pranjal" };
obj.name = "Nanda";
console.log(obj.name); 

const arr = [1, 2, 3];
arr.push(4); 
console.log(arr); 

Nanda
[ 1, 2, 3, 4 ]

• The code shows that although obj and arr are declared with const, their properties and elements can still be modified.
• The object’s property name and the array’s elements are successfully changed, demonstrating that const applies only to the binding, not the contents.

Variables declared with const cannot be redeclared within the same scope, similar to let.

const a = 10;
const a = 20; // SyntaxError: Identifier 'a' has already been declared

• Redeclaring a with const causes a SyntaxError because it's already defined.
• const prevents redeclaring variables in the same scope.

The const keyword is ideal for defining constants or variables whose values should not change during the program's execution. For example.

const PI = 3.14159;
const MAX_USERS = 100;
PI=10

• const variables can't be changed, so PI = 10 will cause an error.
• The extra ( in PI=10( makes the code invalid. It should be PI = 10; without the parentheses.

Using const with functions ensures that the function reference cannot be reassigned, though the function itself can still be executed normally.

const greet = () => console.log("Hello, world!");
greet(); 

greet = () => console.log("Hi!"); 

• greet is declared with const, so it can't be reassigned, causing a TypeError.
• The first call logs "Hello, world!", but the reassignment won't happen due to the error.

const aligns with modern JavaScript practices, supporting features like destructuring and modules for cleaner, maintainable code.

const { name, age } = { name:"Meenal", age: 28 };
console.log(name, age); 

• The code uses destructuring to extract the name and age properties from the object and assign them to variables.
• It then logs the values of name ("Meenal") and age (28) to the console.

• Block-scoped: Like let, const is block-scoped, meaning it is only accessible within the block, statement, or expression where it is defined.
• Immutable Binding: A const variable cannot be reassigned once it is initialized, providing a guarantee of immutability for the binding (not the value itself).
• Objects and Arrays: While the binding of a const variable is immutable, the contents of objects and arrays assigned to const can still be modified.
• Hoisting: Variables declared with const are hoisted to the top of their block but cannot be accessed until they are initialized, resulting in a "temporal dead zone" error if accessed before assignment.
• Used with Destructuring: const can be used in object and array destructuring, allowing you to easily unpack values from an object or array into individual variables.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4