Learn ES2015

ECMAScript 2015 is an ECMAScript standard that was ratified in June 2015.

ES2015 is a significant update to the language, and the first major update to the language since ES5 was standardized in 2009. Implementation of these features in major JavaScript engines is .

See the ES2015 standard for full specification of the ECMAScript 2015 language.

ECMAScript 2015 Features

Arrows and Lexical This

Arrows are a function shorthand using the syntax. They are syntactically similar to the related feature in C#, Java 8 and CoffeeScript. They support both expression and statement bodies. Unlike functions, arrows share the same lexical this as their surrounding code. If an arrow is inside another function, it shares the “arguments” variable of its parent function.

Classes

ES2015 classes are syntactic sugar over the prototype-based OO pattern. Having a single convenient declarative form makes class patterns easier to use, and encourages interoperability. Classes support prototype-based inheritance, super calls, instance and static methods and constructors.

  1. class SkinnedMesh extends THREE.Mesh {
  2.   constructor(geometry, materials) {
  3.     super(geometry, materials);
  5.     this.idMatrix = SkinnedMesh.defaultMatrix();
  6.     this.bones = [];
  7.     this.boneMatrices = [];
  8.     //...
  9.   }
  10.   update(camera) {
  11.     //...
  12.     super.update();
  13.   }
  14.   static defaultMatrix() {
  15.     return new THREE.Matrix4();
  16.   }
  17. }

Enhanced Object Literals

Object literals are extended to support setting the prototype at construction, shorthand for foo: foo assignments, defining methods and making super calls. Together, these also bring object literals and class declarations closer together, and let object-based design benefit from some of the same conveniences.

  1. var obj = {
  2.     // Sets the prototype. "__proto__" or '__proto__' would also work.
  3.     __proto__: theProtoObj,
  4.     // Computed property name does not set prototype or trigger early error for
  5.     // duplicate __proto__ properties.
  6.     ['__proto__']: somethingElse,
  7.     // Shorthand for ‘handler: handler’
  8.     handler,
  9.     // Methods
  10.     toString() {
  11.      // Super calls
  12.      return "d " + super.toString();
  13.     },
  14.     // Computed (dynamic) property names
  15.     [ "prop_" + (() => 42)() ]: 42
  16. };

The __proto__ property requires native support, and was deprecated in previous ECMAScript versions. Most engines now support the property, but . Also, note that only web browsers are required to implement it, as it’s in . It is available in Node.

Template Strings

Template strings provide syntactic sugar for constructing strings. This is similar to string interpolation features in Perl, Python and more. Optionally, a tag can be added to allow the string construction to be customized, avoiding injection attacks or constructing higher level data structures from string contents.

  1. // Basic literal string creation
  2. `This is a pretty little template string.`
  4. // Multiline strings
  5. `In ES5 this is
  6.  not legal.`
  8. // Interpolate variable bindings
  9. var name = "Bob", time = "today";
  10. `Hello ${name}, how are you ${time}?`
  12. // Unescaped template strings
  13. String.raw`In ES5 "\n" is a line-feed.`
  15. // Construct an HTTP request prefix is used to interpret the replacements and construction
  16. GET`http://foo.org/bar?a=${a}&b=${b}
  17.     Content-Type: application/json
  18.     X-Credentials: ${credentials}
  19.     { "foo": ${foo},
  20.       "bar": ${bar}}`(myOnReadyStateChangeHandler);

Destructuring

Destructuring allows binding using pattern matching, with support for matching arrays and objects. Destructuring is fail-soft, similar to standard object lookup foo["bar"], producing undefined values when not found.

  1. // list matching
  2. var [a, ,b] = [1,2,3];
  3. a === 1;
  4. b === 3;
  6. // object matching
  7. var { op: a, lhs: { op: b }, rhs: c }
  8.        = getASTNode()
  10. // object matching shorthand
  11. // binds `op`, `lhs` and `rhs` in scope
  12. var {op, lhs, rhs} = getASTNode()
  14. // Can be used in parameter position
  15. function g({name: x}) {
  16.   console.log(x);
  17. }
  18. g({name: 5})
  20. // Fail-soft destructuring
  21. var [a] = [];
  22. a === undefined;
  24. // Fail-soft destructuring with defaults
  25. var [a = 1] = [];
  26. a === 1;
  28. // Destructuring + defaults arguments
  29. function r({x, y, w = 10, h = 10}) {
  30.   return x + y + w + h;
  31. }

Default + Rest + Spread

Callee-evaluated default parameter values. Turn an array into consecutive arguments in a function call. Bind trailing parameters to an array. Rest replaces the need for arguments and addresses common cases more directly.

  1. function f(x, y=12) {
  2.   // y is 12 if not passed (or passed as undefined)
  3.   return x + y;
  4. }
  5. f(3) == 15
  1. function f(x, ...y) {
  2.   // y is an Array
  3.   return x * y.length;
  4. }
  5. f(3, "hello", true) == 6
  1. function f(x, y, z) {
  2.   return x + y + z;
  3. }
  4. // Pass each elem of array as argument
  5. f(...[1,2,3]) == 6

Block-scoped binding constructs. let is the new var. const is single-assignment. Static restrictions prevent use before assignment.

  1. function f() {
  2.   {
  3.     let x;
  4.     {
  5.       // this is ok since it's a block scoped name
  6.       const x = "sneaky";
  7.       // error, was just defined with `const` above
  8.       x = "foo";
  9.     }
  10.     // this is ok since it was declared with `let`
  11.     x = "bar";
  12.     // error, already declared above in this block
  13.     let x = "inner";
  15. }

Iterators + For..Of

Iterator objects enable custom iteration like CLR IEnumerable or Java Iterable. Generalize for..in to custom iterator-based iteration with for..of. Don’t require realizing an array, enabling lazy design patterns like LINQ.

  1. let fibonacci = {
  2.   [Symbol.iterator]() {
  3.     let pre = 0, cur = 1;
  4.     return {
  5.       next() {
  6.         [pre, cur] = [cur, pre + cur];
  7.         return { done: false, value: cur }
  8.       }
  9.     }
  10.   }
  11. }
  13. for (var n of fibonacci) {
  14.   // truncate the sequence at 1000
  15.   if (n > 1000)
  16.     break;
  17.   console.log(n);
  18. }

Iteration is based on these duck-typed interfaces (using TypeScript type syntax for exposition only):

Support via polyfill

In order to use Iterators you must include the Babel polyfill.

Generators

Note: Can also be used to enable ‘await’-like async programming, see also ES7 await proposal.

  1. var fibonacci = {
  2.   [Symbol.iterator]: function*() {
  3.     var pre = 0, cur = 1;
  4.     for (;;) {
  5.       var temp = pre;
  6.       pre = cur;
  7.       cur += temp;
  8.       yield cur;
  9.     }
  10.   }
  11. }
  13. for (var n of fibonacci) {
  14.   // truncate the sequence at 1000
  15.   if (n > 1000)
  16.     break;
  17.   console.log(n);
  18. }

The generator interface is (using type syntax for exposition only):

  1. interface Generator extends Iterator {
  2.     next(value?: any): IteratorResult;
  3.     throw(exception: any);
  4. }

Support via polyfill

In order to use Generators you must include the Babel .

Comprehensions

Removed in Babel 6.0

Unicode

Non-breaking additions to support full Unicode, including new unicode literal form in strings and new RegExp u mode to handle code points, as well as new APIs to process strings at the 21bit code points level. These additions support building global apps in JavaScript.

  1. // same as ES5.1
  2. "𠮷".length == 2
  4. // new RegExp behaviour, opt-in ‘u’
  5. "𠮷".match(/./u)[0].length == 2
  7. // new form
  8. "\u{20BB7}" == "𠮷"
  9. "𠮷" == "\uD842\uDFB7"
  11. // new String ops
  12. "𠮷".codePointAt(0) == 0x20BB7
  14. // for-of iterates code points
  15. for(var c of "𠮷") {
  16.   console.log(c);
  17. }

Modules

Language-level support for modules for component definition. Codifies patterns from popular JavaScript module loaders (AMD, CommonJS). Runtime behaviour defined by a host-defined default loader. Implicitly async model – no code executes until requested modules are available and processed.

  1. // lib/math.js
  2. export function sum(x, y) {
  3.   return x + y;
  4. }
  5. export var pi = 3.141593;
  1. // app.js
  2. import * as math from "lib/math";
  3. console.log("2π = " + math.sum(math.pi, math.pi));
  1. // otherApp.js
  2. import {sum, pi} from "lib/math";
  3. console.log("2π = " + sum(pi, pi));

Some additional features include export default and export *:

  1. // lib/mathplusplus.js
  2. export * from "lib/math";
  3. export var e = 2.71828182846;
  4. export default function(x) {
  5.     return Math.exp(x);
  6. }
  1. // app.js
  2. import exp, {pi, e} from "lib/mathplusplus";
  3. console.log("e^π = " + exp(pi));

Module Loaders

Not part of ES2015

This is left as implementation-defined within the ECMAScript 2015 specification. The eventual standard will be in WHATWG’s , but that is currently a work in progress. What is below is from a previous ES2015 draft.

Module loaders support:

  • Dynamic loading
  • State isolation
  • Global namespace isolation
  • Compilation hooks
  • Nested virtualization

The default module loader can be configured, and new loaders can be constructed to evaluate and load code in isolated or constrained contexts.

  1. // Dynamic loading – ‘System’ is default loader
  2. System.import("lib/math").then(function(m) {
  3.   alert("2π = " + m.sum(m.pi, m.pi));
  4. });
  6. // Create execution sandboxes – new Loaders
  7. var loader = new Loader({
  8.   global: fixup(window) // replace ‘console.log’
  9. });
  10. loader.eval("console.log(\"hello world!\");");
  12. // Directly manipulate module cache
  13. System.get("jquery");

Additional polyfill needed

Since Babel defaults to using common.js modules, it does not include the polyfill for the module loader API. Get it .

Using Module Loader

In order to use this, you’ll need to tell Babel to use the system module formatter. Also be sure to check out

Efficient data structures for common algorithms. WeakMaps provides leak-free object-key’d side tables.

Support via polyfill

In order to support Maps, Sets, WeakMaps, and WeakSets in all environments you must include the Babel .

Proxies

  1. // Proxying a normal object
  2. var target = {};
  3. var handler = {
  4.   get: function (receiver, name) {
  5.     return `Hello, ${name}!`;
  6.   }
  7. };
  9. var p = new Proxy(target, handler);
  10. p.world === "Hello, world!";
  1. // Proxying a function object
  2. var target = function () { return "I am the target"; };
  3. var handler = {
  4.   apply: function (receiver, ...args) {
  5.     return "I am the proxy";
  6.   }
  7. };
  10. p() === "I am the proxy";

There are traps available for all of the runtime-level meta-operations:

  1. var handler =
  2. {
  3.   // target.prop
  4.   get: ...,
  5.   // target.prop = value
  6.   set: ...,
  7.   // 'prop' in target
  8.   has: ...,
  9.   // delete target.prop
  10.   deleteProperty: ...,
  11.   // target(...args)
  12.   apply: ...,
  13.   // new target(...args)
  14.   construct: ...,
  15.   // Object.getOwnPropertyDescriptor(target, 'prop')
  16.   getOwnPropertyDescriptor: ...,
  17.   // Object.defineProperty(target, 'prop', descriptor)
  18.   defineProperty: ...,
  19.   // Object.getPrototypeOf(target), Reflect.getPrototypeOf(target),
  20.   // target.__proto__, object.isPrototypeOf(target), object instanceof target
  21.   getPrototypeOf: ...,
  22.   // Object.setPrototypeOf(target), Reflect.setPrototypeOf(target)
  23.   setPrototypeOf: ...,
  24.   // for (let i in target) {}
  25.   enumerate: ...,
  26.   // Object.keys(target)
  27.   ownKeys: ...,
  28.   // Object.preventExtensions(target)
  29.   preventExtensions: ...,
  30.   // Object.isExtensible(target)
  31.   isExtensible :...
  32. }

Unsupported feature

Due to the limitations of ES5, Proxies cannot be transpiled or polyfilled. See support in various JavaScript engines.

Symbols

Symbols enable access control for object state. Symbols allow properties to be keyed by either string (as in ES5) or symbol. Symbols are a new primitive type. Optional name parameter used in debugging - but is not part of identity. Symbols are unique (like gensym), but not private since they are exposed via reflection features like Object.getOwnPropertySymbols.

  1. (function() {
  3.   // module scoped symbol
  4.   var key = Symbol("key");
  6.   function MyClass(privateData) {
  7.     this[key] = privateData;
  8.   }
  10.   MyClass.prototype = {
  11.     doStuff: function() {
  12.       ... this[key] ...
  13.     }
  14.   };
  16.   // Limited support from Babel, full support requires native implementation.
  17.   typeof key === "symbol"
  18. })();
  20. var c = new MyClass("hello")
  21. c["key"] === undefined

Subclassable Built-ins

In ES2015, built-ins like Array, Date and DOM Elements can be subclassed.

  1. // User code of Array subclass
  2. class MyArray extends Array {
  3.     constructor(...args) { super(...args); }
  4. }
  6. var arr = new MyArray();
  7. arr[1] = 12;
  8. arr.length == 2

Partial support

Built-in subclassability should be evaluated on a case-by-case basis as classes such as HTMLElement can be subclassed while many such as Date, Array and Error cannot be due to ES5 engine limitations.

Math + Number + String + Object APIs

Many new library additions, including core Math libraries, Array conversion helpers, and Object.assign for copying.

  1. Number.EPSILON
  2. Number.isInteger(Infinity) // false
  3. Number.isNaN("NaN") // false
  5. Math.acosh(3) // 1.762747174039086
  6. Math.hypot(3, 4) // 5
  7. Math.imul(Math.pow(2, 32) - 1, Math.pow(2, 32) - 2) // 2
  9. "abcde".includes("cd") // true
  10. "abc".repeat(3) // "abcabcabc"
  12. Array.from(document.querySelectorAll("*")) // Returns a real Array
  13. Array.of(1, 2, 3) // Similar to new Array(...), but without special one-arg behavior
  14. [0, 0, 0].fill(7, 1) // [0,7,7]
  15. [1,2,3].findIndex(x => x == 2) // 1
  16. ["a", "b", "c"].entries() // iterator [0, "a"], [1,"b"], [2,"c"]
  17. ["a", "b", "c"].keys() // iterator 0, 1, 2
  18. ["a", "b", "c"].values() // iterator "a", "b", "c"
  20. Object.assign(Point, { origin: new Point(0,0) })

Limited support from polyfill

Most of these APIs are supported by the Babel polyfill. However, certain features are omitted for various reasons (e.g. String.prototype.normalize needs a lot of additional code to support). You can find more polyfills .

Binary and Octal Literals

Two new numeric literal forms are added for binary (b) and octal (o).

  1. 0b111110111 === 503 // true
  2. 0o767 === 503 // true

Only supports literal form

Babel is only able to transform 0o767 and not Number("0o767").

Promises

Promises are a library for asynchronous programming. Promises are a first class representation of a value that may be made available in the future. Promises are used in many existing JavaScript libraries.

  1. function timeout(duration = 0) {
  2.     return new Promise((resolve, reject) => {
  3.         setTimeout(resolve, duration);
  4.     })
  5. }
  7. var p = timeout(1000).then(() => {
  8.     return timeout(2000);
  9. }).then(() => {
  10.     throw new Error("hmm");
  11. }).catch(err => {
  12.     return Promise.all([timeout(100), timeout(200)]);
  13. })

Support via polyfill

In order to support Promises you must include the Babel polyfill.

Full reflection API exposing the runtime-level meta-operations on objects. This is effectively the inverse of the Proxy API, and allows making calls corresponding to the same meta-operations as the proxy traps. Especially useful for implementing proxies.

  1. var O = {a: 1};
  2. Object.defineProperty(O, 'b', {value: 2});
  3. O[Symbol('c')] = 3;
  5. Reflect.ownKeys(O); // ['a', 'b', Symbol(c)]
  7. function C(a, b){
  8.   this.c = a + b;
  9. }
  10. instance.c; // 42

Tail Calls

Calls in tail-position are guaranteed to not grow the stack unboundedly. Makes recursive algorithms safe in the face of unbounded inputs.

Temporarily Removed in Babel 6