JavaScript const Declaration

The const declaration creates a block-scoped, read-only reference to a value. It establishes an immutable binding, meaning the variable identifier cannot be reassigned to a new value, nor can it be redeclared within the same lexical scope.

const name1 = value1 [, name2 = value2 [, ...]];

Initialization Requirement

Because the binding cannot be altered after creation, a const declaration requires an immediate initializer. Declaring a const without an assignment throws a SyntaxError during the parsing phase.

const MAX_RETRIES = 5; // Valid

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

Reassignment and Redeclaration

Attempting to reassign a const identifier throws a runtime TypeError.

const API_URL = "https://api.example.com";
API_URL = "https://api.v2.example.com"; // TypeError: Assignment to constant variable.

Attempting to redeclare an identifier that already exists in the same lexical scope throws a parse-time SyntaxError.

const MAX_USERS = 100;
const MAX_USERS = 200; // SyntaxError: Identifier 'MAX_USERS' has already been declared

Immutable Binding vs. Immutable Value

The const keyword guarantees an immutable binding, not an immutable value. If the assigned value is a reference type (such as an Object or an Array), the underlying data structure is not frozen. The properties or elements of that structure can be mutated, provided the variable identifier itself is not reassigned to a new memory address.

const config = { port: 8080 };
config.port = 3000; // Valid: Mutating the object's property

const ports = [80, 443];
ports.push(8080);   // Valid: Mutating the array

const config = { port: 8080 };
config = { port: 3000 }; // TypeError: Assignment to constant variable.

Block Scope and the Temporal Dead Zone (TDZ)

const declarations are block-scoped, meaning their visibility is limited to the nearest enclosing block { ... }.

{
  const limit = 50;
}
console.log(limit); // ReferenceError: limit is not defined

During execution context creation, const declarations are hoisted to the top of their block scope but remain uninitialized. The period between entering the scope and the actual lexical declaration is known as the Temporal Dead Zone (TDZ). Accessing the identifier within the TDZ throws a ReferenceError.

{
  // TDZ starts for 'threshold'
  console.log(threshold); // ReferenceError: Cannot access 'threshold' before initialization
  const threshold = 10;   // TDZ ends, binding is initialized
}

Global Object Context

When executed in a global script context (such as a standard <script> tag in a browser), const declarations do not create properties on the global object (e.g., window). This contrasts with var, which does append its identifier to the global environment record. (Note: In Node.js, top-level declarations are scoped to the module wrapper by default, meaning neither var nor const creates a property on the global object.)

// Executed in a browser's global script scope
var legacyVersion = "0.9.0";
const version = "1.0.0";

console.log(window.legacyVersion); // "0.9.0"
console.log(window.version);       // undefined

Tired of Poor JavaScript Skills? Fix That With Deep Grasping!Learn More

Functions

Methods

Constructors

Classes

Destructuring

Decorators

Modules

Accessors

Variables

Fields

Parameters

Error Handling

Control Flow

Statement Forms

Loops

Primitive Types

Comments

Access Operators

Spread Operators

Call Operators

Conditional Operators

Logical Operators

Equality Operators

Relational Operators

Arithmetic Operators

Assignment Operators

Update Operators

Unary Operators

Yield Operators

Bitwise Operators

Shift Operators

JavaScript const Declaration

Initialization Requirement

Reassignment and Redeclaration

Immutable Binding vs. Immutable Value

Block Scope and the Temporal Dead Zone (TDZ)

Global Object Context

​Initialization Requirement

​Reassignment and Redeclaration

​Immutable Binding vs. Immutable Value

​Block Scope and the Temporal Dead Zone (TDZ)

​Global Object Context

Initialization Requirement

Reassignment and Redeclaration

Immutable Binding vs. Immutable Value

Block Scope and the Temporal Dead Zone (TDZ)

Global Object Context