A javascript constant uses the const identifier and is a read-only definition. Like javascript variables constants have global and local scope. Using the perennial Circle example:

const PI = 3.14159;

function Circle(radius) {
  this.radius = radius;
  this.circumference = function() {
    return this.radius * 2 * PI;
  }  
}

circle = new Circle(10);
alert(circle.circumference());

There is a Math.PI constant in the javascript libraries. So this isn't necessarily a good example. A constant can be declared and used in a javascript object as a private variable and its scope will only be in the object.

function Circle(radius) {
  this.radius = radius;
  const PI = 3.14159;
  this.circumference = function() {
    return this.radius * 2 * PI;
  }
  this.expansion = function(by) {
    return this.radius * by * 2 * PI;
  }  
}

But what if we place a constant in global scope above a Javascript object, then try to change that constant by declaring it again in a function that is run from onload() in the body tag?

const PI = 3;
function Circle(radius) {
  this.radius = radius;
  this.circumference = function() {
    return this.radius * 2 * PI;
  }
  this.expansion = function(by) {
    return this.radius * by * 2 * PI;
  }  
}

function run() {
circle = new Circle(10);
alert(circle.expansion(2));
const PI = 3.14159;
alert(circle.expansion(2));

I deliberately used 3 as the initial PI declaration, though I think some town passed a law once that pi was equal to three, to differentiate from the 3.142 results.

The Circle picks up the PI constant as 3 despite trying to override the constant in the run() method. If we reorganise the run method to put the redeclared constant before the instantiation of the Circle the result is the same.

function run() {
const PI = 3.14159;
circle = new Circle(10);
alert(circle.expansion(2));
}

The global scoping of the constant over-rides the local scoping of a constant with the same name. If PI is declared in the global scope twice there is a javascript error, "redeclaration of const".