• JavaScript
  • JavaScript
  • Tutorials and guides
  • Beginner's tutorials
    1. JavaScript Guide
      1. Loops and iteration
      2. Representing dates & times
      3. Working with objects
      4. Iterators and generators
      5. Asynchronous JavaScript
      6. Equality comparisons and sameness
      7. Meta programming
      8. AggregateError
      9. AsyncGenerator
      10. BigInt
      11. DataView
      12. encodeURI()
      13. escape() Deprecated
      14. Float16Array
      15. Generator
      16. Int8Array
      17. InternalError Non-standard
      18. Iterator
      19. NaN
      20. parseInt()
      21. ReferenceError
      22. SharedArrayBuffer
      23. Temporal Experimental
      24. Uint8ClampedArray
      25. unescape() Deprecated
      26. WeakSet
  • Assignment (=)
  • Bitwise AND (&)
  • Bitwise OR assignment (|=)
  • Comma operator (,)
  • Destructuring
  • Exponentiation (**)
  • Greater than (>)
  • import.meta.resolve()
  • Inequality (!=)
  • Less than (<)
  • Logical NOT (!)
  • Multiplication assignment (*=)
  • Nullish coalescing assignment (??=)
  • Optional chaining (?.)
  • Right shift (>>)
  • Strict inequality (!==)
  • this
  • Unsigned right shift (>>>)
  • yield*
  • Block statement
  • continue
  • export
  • for...in
  • if...else
  • let
  • try...catch
  • with Deprecated
  • get
  • The arguments object
    1. callee Deprecated
    2. extends
    3. Static initialization blocks
  • Character class escape: \d, \D, \w, \W, \s, \S
  • Input boundary assertion: ^, $
  • Modifier: (?ims-ims:...)
  • Quantifier: *, +, ?, {n}, {n,}, {n,m}
  • Errors
    1. RangeError: argument is not a valid code point
    2. RangeError: invalid array length
    3. RangeError: repeat count must be less than infinity
    4. ReferenceError: assignment to undeclared variable "x"
    5. SyntaxError: 'arguments'/'eval' can't be defined or assigned to in strict mode code
    6. SyntaxError: \ at end of pattern
    7. SyntaxError: await is only valid in async functions, async generators and modules
    8. SyntaxError: continue must be inside loop
    9. SyntaxError: function statement requires a name
    10. SyntaxError: identifier starts immediately after numeric literal
    11. SyntaxError: invalid assignment left-hand side
    12. SyntaxError: invalid class set operation in regular expression
    13. SyntaxError: invalid property name in regular expression
    14. SyntaxError: invalid unicode escape in regular expression
    15. SyntaxError: missing ) after argument list
    16. SyntaxError: missing } after property list
    17. SyntaxError: missing variable name
    18. SyntaxError: numbers out of order in {} quantifier.
    19. SyntaxError: property name __proto__ appears more than once in object literal
    20. SyntaxError: rest parameter may not have a default
    21. SyntaxError: super() is only valid in derived class constructors
    22. SyntaxError: unlabeled break must be inside loop or switch
    23. TypeError: 'caller', 'callee', and 'arguments' properties may not be accessed
    24. TypeError: "x" is not a function
    25. TypeError: BigInt value can't be serialized in JSON
    26. TypeError: can't convert BigInt to number
    27. TypeError: can't redefine non-configurable property "x"
    28. TypeError: class constructors must be invoked with 'new'
    29. TypeError: Initializing an object twice is an error with private fields/methods
    30. TypeError: Iterator/AsyncIterator constructor can't be used directly
    31. TypeError: property "x" is non-configurable and can't be deleted
    32. TypeError: X.prototype.y called on incompatible type
    33. JavaScript technologies overview
    34. Strict mode
    35. Learn more
    36. See full compatibility
  • The const declaration declares block-scoped local variables. The value of a constant can't be changed through reassignment using the object, its properties can be added, updated, or removed.

    Try it

    const number = 42;
    
    try {
      number = 99;
    } catch (err) {
      console.log(err);
      / Expected output: TypeError: invalid assignment to const 'number'
      / (Note: the exact output may be browser-dependent)
    }
    
    console.log(number);
    / Expected output: 42
    

    Syntax

    js
    const name1 = value1;
    const name1 = value1, name2 = value2;
    const name1 = value1, name2 = value2, /* …, */ nameN = valueN;
    
    nameN

    The name of the variable to declare. Each must be a legal JavaScript destructuring binding pattern.

    valueN

    Initial value of the variable. It can be any legal expression.

    Description

    The const declaration is very similar to let:

    • const declarations are scoped to blocks as well as functions.

    • const declarations can only be accessed after the place of declaration is reached (see non-hoisted.

    • const declarations do not create properties on globalThis when declared at the top level of a script.

    • const declarations cannot be redeclared by any other declaration in the same scope.

    • const begins declarations, not statements. That means you cannot use a lone const declaration as the body of a block (which makes sense, since there's no way to access the variable).

      js
      if (true) const a = 1; / SyntaxError: Lexical declaration cannot appear in a single-statement context
      

    An initializer for a constant is required. You must specify its value in the same declaration. (This makes sense, given that it can't be changed later.)

    js
    const FOO; / SyntaxError: Missing initializer in const declaration
    

    The const declaration creates an immutable reference to a value. It does not mean the value it holds is immutable — just that the variable identifier cannot be reassigned. For instance, in the case where the content is an object, this means the object's contents (e.g., its properties) can be altered. You should understand const declarations as "create a variable whose identity remains constant", not "whose value remains constant" — or, "create immutable bindings", not "immutable values".

    Many style guides (including let whenever a variable is not reassigned in its scope. This makes the intent clear that a variable's type (or value, in the case of a primitive) can never change. Others may prefer let for non-primitives that are mutated.

    The list that follows the const keyword is called a assignment operators. Initializers of later variables can refer to earlier variables in the list.

    Examples

    Basic const usage

    Constants can be declared with uppercase or lowercase, but a common convention is to use all-uppercase letters, especially for primitives because they are truly immutable.

    js
    / define MY_FAV as a constant and give it the value 7
    const MY_FAV = 7;
    
    console.log(`my favorite number is: ${MY_FAV}`);
    
    js
    / Re-assigning to a constant variable throws an error
    MY_FAV = 20; / TypeError: Assignment to constant variable
    
    / Redeclaring a constant throws an error
    const MY_FAV = 20; / SyntaxError: Identifier 'MY_FAV' has already been declared
    var MY_FAV = 20; / SyntaxError: Identifier 'MY_FAV' has already been declared
    let MY_FAV = 20; / SyntaxError: Identifier 'MY_FAV' has already been declared
    

    Block scoping

    It's important to note the nature of block scoping.

    js
    const MY_FAV = 7;
    
    if (MY_FAV === 7) {
      / This is fine because it's in a new block scope
      const MY_FAV = 20;
      console.log(MY_FAV); / 20
    
      / var declarations are not scoped to blocks so this throws an error
      var MY_FAV = 20; / SyntaxError: Identifier 'MY_FAV' has already been declared
    }
    
    console.log(MY_FAV); / 7
    

    const in objects and arrays

    const also works on objects and arrays. Attempting to overwrite the object throws an error "Assignment to constant variable".

    js
    const MY_OBJECT = { key: "value" };
    MY_OBJECT = { OTHER_KEY: "value" };
    

    However, object keys are not protected, so the following statement is executed without problem.

    js
    MY_OBJECT.key = "otherValue";
    

    You would need to use Object.freeze() to make an object immutable.

    The same applies to arrays. Assigning a new array to the variable throws an error "Assignment to constant variable".

    js
    const MY_ARRAY = [];
    MY_ARRAY = ["B"];
    

    Still, it's possible to push items into the array and thus mutate it.

    js
    MY_ARRAY.push("A"); / ["A"]
    

    Declaration with destructuring

    The left-hand side of each = can also be a binding pattern. This allows creating multiple variables at once.

    js
    const result = /(a+)(b+)(c+)/.exec("aaabcc");
    const [, a, b, c] = result;
    console.log(a, b, c); / "aaa" "b" "cc"
    

    For more information, see Destructuring.

    Specifications

    Specification
    ECMAScript® 2026 Language Specification
    # sec-let-and-const-declarations

    Browser compatibility

    See also