ES6: Browser Support, Features, Known Issues

What is ES6?

ES6 is the sixth edition of the ECMAScript language specification, also known as ECMAScript 2015 or ES2015. Ecma International's TC39 committee publishes it as ECMA-262. It adds block-scoped variables, classes, arrow functions, template literals, destructuring, default parameters, promises, and native modules to JavaScript.

Which browsers does ES6 support?

ES6 works in every modern desktop and mobile browser, with Chrome, Firefox, Safari, Edge, Opera, and Samsung Internet all shipping the full specification by default. Internet Explorer 11 covers only a small slice, and IE 9 and 10 do not support ES6 at all.

What are the key features of ES6?

ES6 added the largest set of language features in any single ECMAScript edition. Most modern JavaScript code, including React, Vue, Angular, Node.js, and TypeScript output, depends on these features by default.

• let and const: Block-scoped variable declarations that replace the function-scoped var. const blocks reassignment, which makes intent obvious to the reader and stops a class of bugs.
• Arrow functions: Concise function syntax with a lexical this binding. Useful for callbacks, array methods like map and filter, and event handlers where you want to keep the outer this.
• Classes: A clean syntax for prototype-based inheritance with constructor, extends, super, and static. The runtime semantics still use prototypes underneath.
• Template literals: Backtick strings that support multi-line text and ${expression} interpolation without escape characters or string concatenation.
• Destructuring: Pulls values out of arrays or objects in one expression. Works in function parameters, return values, and import statements.
• Default, rest, and spread: Default parameter values, the rest parameter that gathers extra arguments into an array, and the spread operator that expands arrays or objects into elements.
• Promises: Built-in Promise object for chaining asynchronous work, the building block for fetch and async or await in later editions.
• Modules: Native import and export statements that replace CommonJS or AMD module systems. Browsers load them with type="module" on the script tag.
• Map, Set, WeakMap, WeakSet: Real hash-map and hash-set collection types with stable insertion order, replacing object-as-map workarounds.
• Symbols and iterators: A new primitive type plus the iterator and iterable protocols that power for...of loops and generator functions.

How do you check if a browser supports ES6?

You can confirm ES6 support inside any browser by trying to compile a small block of ES6 syntax with the Function constructor and checking that the global Symbol and Promise objects exist. The Function constructor throws a SyntaxError on engines that cannot parse ES6, which gives you a reliable yes or no answer.

Paste this snippet into the browser DevTools console to confirm ES6 support and the related ES6 module loader hook:

// Paste this into the browser DevTools console to test ES6 support.
function supportsES6() {
  try {
    // Each line uses an ES6-only construct: arrow function with default param,
    // class syntax, template literal with const, and array destructuring with let.
    new Function("(a = 1) => a")();
    new Function("class T {}");
    new Function("const x = `v${1}`");
    new Function("let [a, b] = [1, 2]");
    return typeof Symbol === "function" && typeof Promise === "function";
  } catch (e) {
    return false;
  }
}

console.log("ES6 supported in this browser:", supportsES6());
console.log("Module script support:", "noModule" in document.createElement("script"));

If supportsES6() returns true, the engine handles every common ES6 syntax feature. The noModule check tells you whether the same engine recognises the script type="module" attribute, which is the gate for native ES6 modules. For a finer-grained read, use compat-table.github.io/compat-table/es6/ in any browser.

What are the known issues with ES6 in older browsers?

ES6 has near-universal modern support, but a few real failure modes still bite teams that target older Windows fleets, embedded WebViews, or international markets where legacy mobile browsers persist. The biggest hits are Internet Explorer, partial-support Safari builds, and silent module-loader breakage.

• Internet Explorer 11 ignores most ES6 syntax: Any inline arrow function, class, let, const, or template literal throws a SyntaxError on parse. The whole script fails to load, not just the offending statement, so the page silently breaks.
• Older Safari hangs on partial features: Safari 9 supports classes and let, but proper tail calls and full destructuring landed only in Safari 10. Code that destructures inside a default parameter throws on Safari 9 and earlier.
• ES6 modules need type="module": Browsers ignore import and export when the script tag lacks type="module". Forgetting that attribute is the most common reason a working module setup throws "unexpected token" in production.
• Tail call optimisation is not really shipped: The spec calls for proper tail calls, but only Safari and JavaScriptCore implement it. Code that relies on PTC for deep recursion overflows in Chrome, Firefox, and Edge.
• Symbol.toPrimitive is uneven on legacy mobile: Older Samsung Internet and Android Browser builds skip the Symbol.toPrimitive coercion path. Custom valueOf or Symbol.toPrimitive logic returns the default object string instead.
• const with destructuring tripped older WebViews: Mobile WebViews based on pre-Chromium engines parse "const { a } = obj" inconsistently. Test embedded WebViews on real Android devices before assuming ES6 parity with the system Chrome build.
• Polyfills do not cover syntax: Polyfill libraries like core-js add Map, Set, and Promise to old engines, but they cannot add new syntax. You still need Babel or TypeScript to compile let, const, classes, and arrow functions to ES5 for IE 11.

In my experience, the most surprising failure happens on corporate Windows fleets where IE 11 still loads in compatibility mode for one internal app. A single inline arrow function in a third-party widget script crashes the whole page with "Object doesn't support this property or method", and the error never surfaces in dev tools because IE silently skips the rest of the script. Always wrap third-party widgets in a feature detect or a Babel build before shipping to a Windows enterprise audience.

Citations

All ES6 version numbers and feature notes in this guide come from these primary sources:

• Ecma International - ECMA-262, ECMAScript 2015 Language Specification: 262.ecma-international.org/6.0
• TC39 - Current ECMAScript specification: tc39.es/ecma262
• MDN Web Docs - JavaScript language overview: developer.mozilla.org/en-US/docs/Web/JavaScript/Language_overview
• MDN Web Docs - JavaScript Classes reference: developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes
• MDN Web Docs - let statement: developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/let
• MDN Web Docs - import statement: developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/import
• Wikipedia - ECMAScript: en.wikipedia.org/wiki/ECMAScript
• Wikipedia - ECMAScript version history: en.wikipedia.org/wiki/ECMAScript_version_history
• WebKit - ES6, ES7, and beyond: webkit.org/blog/6756/es6-feature-complete
• Mozilla Hacks - ES6 In Depth introduction: hacks.mozilla.org/2015/04/es6-in-depth-an-introduction
• Chrome for Developers - V8 release notes archive: v8.dev/blog
• Microsoft Learn - Microsoft Edge JavaScript support: learn.microsoft.com/en-us/microsoft-edge/web-platform
• Apple Developer - Safari Release Notes: developer.apple.com/documentation/safari-release-notes