const: Browser Support, Block Scope, Limitations

What is const?

const is an ECMAScript 2015 declaration statement that creates a block-scoped, read-only binding tied to a value. The engine resolves the binding inside the nearest enclosing block, and it throws a TypeError on any attempt to reassign the variable after the line that declared it.

Which browsers does const support?

Every modern desktop and mobile browser supports const by default, while Internet Explorer 11 ships only partial support and earlier Internet Explorer builds do not parse it at all.

What are the key features of const?

const gives JavaScript four guarantees that var never offered, all enforced at parse time or at the line that runs the declaration.

• Block scope: A const binding lives only inside the nearest pair of curly braces, so a const declared inside an if, for, or arrow body is invisible outside it. This stops the loop-variable leakage that var produced.
• No reassignment: Any attempt to assign a new value to a const after initialization throws a TypeError at runtime. The check is a real engine guard, not a lint rule, so refactors cannot silently break it.
• Mandatory initializer: A const must bind a value on the same statement that declares it. const x; without an initializer is a SyntaxError caught before the script runs.
• Temporal dead zone: The binding exists from the top of its block but cannot be read until the declaration line runs. Touching it earlier throws a ReferenceError, which surfaces ordering bugs that var hid behind undefined.
• No silent redeclaration: Declaring the same const twice in one block is a SyntaxError. var allowed silent re-declarations that buried bugs in long files; const fails fast at parse time.

What is the difference between const, let, and var?

All three declare variables, but only const and let follow modern block-scope rules. The table below shows the practical differences a QA engineer or developer needs when picking one.

How do you use const in older browsers?

Older Internet Explorer, early Safari, and pre-36 Firefox builds need a transpilation step that rewrites const to var while preserving the scope rules. The standard tool is Babel with @babel/preset-env, configured against your browserslist target.

• Install Babel: Run npm install --save-dev @babel/core @babel/cli @babel/preset-env so the toolchain is available locally.
• Add a browserslist target: Drop a browserslist field into package.json that names the older browsers you ship to, for example "ie 11" and "safari >= 9".
• Configure preset-env: Create a babel.config.json with the preset entry ["@babel/preset-env", { "targets": { "esmodules": false } }] so Babel reads the browserslist field and rewrites const where needed.
• Run the build: Pipe your source through npx babel src --out-dir dist, then point your bundler or static host at the dist folder.
• Confirm the output: Open the compiled JavaScript and search for const. On a correct Internet Explorer 11 target, every const should be rewritten to var with a unique name per block.
• Detect support at runtime: Paste the snippet below into the target browser's DevTools console to confirm whether the engine handles const or whether the transpiled bundle is required.

// Run in any browser DevTools console to confirm const support and block scope.
try {
  new Function("const sample = 1; { const sample = 2; } if (sample !== 1) throw new Error('block-scope-broken');")();
  console.log("const declaration: supported");
  console.log("Block scope: working");
} catch (error) {
  console.warn("const not fully supported:", error.message);
}

try {
  new Function("const value = 1; value = 2;")();
  console.warn("Reassignment did not throw - const enforcement is broken.");
} catch (error) {
  console.log("Reassignment guard: working (" + error.name + ")");
}

If the snippet logs a warning, the browser does not enforce const. Ship the transpiled bundle for that user agent and keep the original const-based bundle for modern browsers.

What are the limitations of const?

const locks the binding, not the value. That gap, plus a handful of older-browser quirks, is the source of every const-related bug worth knowing.

• Object and array contents stay mutable: A const bound to an object lets you push into arrays, set new keys, and reassign properties. Use Object.freeze on the value when callers must not mutate the contents.
• Internet Explorer 11 partial support: IE 11 parses const but skips block scope inside catch clauses and never throws on redeclaration. Code that runs in IE 11 needs a Babel transpile, not a polyfill.
• No polyfill exists: const is a parser-level keyword, not an API call, so a runtime polyfill cannot patch it. The only fix for older engines is a transpiler that rewrites const into var with the right scope guards.
• Temporal dead zone surprises: Reading a const before its declaration line throws a ReferenceError, even when a same-name var or function is in scope. This breaks code that moved between var-style and const-style files without a careful audit.
• Loop bindings need care: A const inside for (const i = 0; ... ) {} cannot increment, so the loop runs once or fails. Use let for the iteration variable and const for the per-iteration values destructured from it.
• No global property created: A top-level const at the script level does not become a property on window or globalThis, unlike a top-level var. Browser extensions and ad scripts that probe window for globals will not see const-bound names.

In my experience, the most common failure is a developer assuming const freezes an object and then watching a teammate mutate the contents in another file. Pair const with Object.freeze, or hand the value out through a getter that returns a defensive copy, when the team needs the value itself to stay constant.

Citations

All const version numbers and platform notes in this guide come from these primary sources:

• MDN Web Docs - const: developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/const
• MDN Web Docs - let: developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/let
• MDN Web Docs - var: developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/var
• ECMA-262 ECMAScript Language Specification - LexicalDeclaration: tc39.es/ecma262/#sec-let-and-const-declarations
• V8 blog - JavaScript engine in Chrome: v8.dev/blog
• WebKit blog - ECMAScript 6 in WebKit: webkit.org/blog/6756/es6-feature-complete
• Mozilla Hacks - ES6 In Depth: let and const: hacks.mozilla.org/2015/07/es6-in-depth-let-and-const
• Microsoft Learn - JavaScript const statement: learn.microsoft.com/en-us/previous-versions/visualstudio/visual-studio-2017/jj151002
• Wikipedia - ECMAScript: en.wikipedia.org/wiki/ECMAScript
• Babel docs - @babel/preset-env: babeljs.io/docs/babel-preset-env
• W3Schools - JavaScript const: w3schools.com/js/js_const.asp