class SkinnedMesh extends THREE.Mesh {  constructor(geometry, materials) {    super(geometry, materials);    this.idMatrix = SkinnedMesh.defaultMatrix();    this.bones = [];    this.boneMatrices = [];    //…  }  update(camera) {    //…    super.update();  }  static defaultMatrix() {    return new THREE.Matrix4();  }}

var obj = {    // Sets the prototype. "proto" or 'proto' would also work.    proto: theProtoObj,    // Computed property name does not set prototype or trigger early error for    // duplicate _proto properties.    ['__proto']: somethingElse,    // Shorthand for ‘handler: handler’    handler,    // Methods    toString() {     // Super calls     return "d " + super.toString();    },    // Computed (dynamic) property names    [ "prop" + (() => 42)() ]: 42};

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

// Basic literal string creationThis is a pretty little template string.// Multiline stringsIn ES5 this is
 not legal.// Interpolate variable bindingsvar name = "Bob", time = "today";Hello ${name}, how are you ${time}?// Unescaped template stringsString.rawIn ES5 "\n" is a line-feed.// Construct an HTTP request prefix is used to interpret the replacements and constructionGEThttp://foo.org/bar?a=${a}&b=${b}
    Content-Type: application/json
    X-Credentials: ${credentials}
    { "foo": ${foo},
      "bar": ${bar}}(myOnReadyStateChangeHandler);

// list matchingvar [a, ,b] = [1,2,3];a === 1;b === 3;// object matchingvar { op: a, lhs: { op: b }, rhs: c }       = getASTNode()// object matching shorthand// binds op, lhs and rhs in scopevar {op, lhs, rhs} = getASTNode()// Can be used in parameter positionfunction g({name: x}) {  console.log(x);}g({name: 5})// Fail-soft destructuringvar [a] = [];a === undefined;// Fail-soft destructuring with defaultsvar [a = 1] = [];a === 1;// Destructuring + defaults argumentsfunction r({x, y, w = 10, h = 10}) {  return x + y + w + h;}r({x:1, y:2}) === 23

function f(x, y=12) {  // y is 12 if not passed (or passed as undefined)  return x + y;}f(3) == 15

function f(x, …y) {  // y is an Array  return x  y.length;}f(3, "hello", true) == 6

function f(x, y, z) {  return x + y + z;}// Pass each elem of array as argumentf(…[1,2,3]) == 6

function f() {  {    let x;    {      // this is ok since it's a block scoped name      const x = "sneaky";      // error, was just defined with const above      x = "foo";    }    // this is ok since it was declared with let    x = "bar";    // error, already declared above in this block    let x = "inner";  }}

let fibonacci = {  Symbol.iterator {    let pre = 0, cur = 1;    return {      next() {        [pre, cur] = [cur, pre + cur];        return { done: false, value: cur }      }    }  }}for (var n of fibonacci) {  // truncate the sequence at 1000  if (n > 1000)    break;  console.log(n);}

interface IteratorResult {  done: boolean;  value: any;}interface Iterator {  next(): IteratorResult;}interface Iterable {  Symbol.iterator: Iterator}

var fibonacci = {  [Symbol.iterator]: function() {    var pre = 0, cur = 1;    for (;;) {      var temp = pre;      pre = cur;      cur += temp;      yield cur;    }  }}for (var n of fibonacci) {  // truncate the sequence at 1000  if (n > 1000)    break;  console.log(n);}

interface Generator extends Iterator {    next(value?: any): IteratorResult;    throw(exception: any);}

Support via polyfill

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

// same as ES5.1"𠮷".length == 2// new RegExp behaviour, opt-in ‘u’"𠮷".match(/./u)[0].length == 2// new form"\u{20BB7}" == "𠮷""𠮷" == "\uD842\uDFB7"// new String ops"𠮷".codePointAt(0) == 0x20BB7// for-of iterates code pointsfor(var c of "𠮷") {  console.log(c);}

// lib/math.jsexport function sum(x, y) {  return x + y;}export var pi = 3.141593;

// app.jsimport  as math from "lib/math";console.log("2π = " + math.sum(math.pi, math.pi));

// otherApp.jsimport {sum, pi} from "lib/math";console.log("2π = " + sum(pi, pi));

// lib/mathplusplus.jsexport  from "lib/math";export var e = 2.71828182846;export default function(x) {    return Math.exp(x);}

// app.jsimport exp, {pi, e} from "lib/mathplusplus";console.log("e^π = " + exp(pi));

// Dynamic loading – ‘System’ is default loaderSystem.import("lib/math").then(function(m) {  alert("2π = " + m.sum(m.pi, m.pi));});// Create execution sandboxes – new Loadersvar loader = new Loader({  global: fixup(window) // replace ‘console.log’});loader.eval("console.log(\"hello world!\");");// Directly manipulate module cacheSystem.get("jquery");System.set("jquery", Module({$: $})); // WARNING: not yet finalized

// Setsvar s = new Set();s.add("hello").add("goodbye").add("hello");s.size === 2;s.has("hello") === true;// Mapsvar m = new Map();m.set("hello", 42);m.set(s, 34);m.get(s) == 34;// Weak Mapsvar wm = new WeakMap();wm.set(s, { extra: 42 });wm.size === undefined// Weak Setsvar ws = new WeakSet();ws.add({ data: 42 });// Because the added object has no other references, it will not be held in the set

// Proxying a normal objectvar target = {};var handler = {  get: function (receiver, name) {    return Hello, ${name}!;  }};var p = new Proxy(target, handler);p.world === "Hello, world!";

// Proxying a function objectvar target = function () { return "I am the target"; };var handler = {  apply: function (receiver, …args) {    return "I am the proxy";  }};var p = new Proxy(target, handler);p() === "I am the proxy";

var handler ={  // target.prop  get: …,  // target.prop = value  set: …,  // 'prop' in target  has: …,  // delete target.prop  deleteProperty: …,  // target(…args)  apply: …,  // new target(…args)  construct: …,  // Object.getOwnPropertyDescriptor(target, 'prop')  getOwnPropertyDescriptor: …,  // Object.defineProperty(target, 'prop', descriptor)  defineProperty: …,  // Object.getPrototypeOf(target), Reflect.getPrototypeOf(target),  // target.proto, object.isPrototypeOf(target), object instanceof target  getPrototypeOf: …,  // Object.setPrototypeOf(target), Reflect.setPrototypeOf(target)  setPrototypeOf: …,  // for (let i in target) {}  enumerate: …,  // Object.keys(target)  ownKeys: …,  // Object.preventExtensions(target)  preventExtensions: …,  // Object.isExtensible(target)  isExtensible :…}

(function() {  // module scoped symbol  var key = Symbol("key");  function MyClass(privateData) {    this[key] = privateData;  }  MyClass.prototype = {    doStuff: function() {      … this[key] …    }  };  // Limited support from Babel, full support requires native implementation.  typeof key === "symbol"})();var c = new MyClass("hello")c["key"] === undefined

// User code of Array subclassclass MyArray extends Array {    constructor(…args) { super(…args); }}var arr = new MyArray();arr[1] = 12;arr.length == 2

Number.EPSILONNumber.isInteger(Infinity) // falseNumber.isNaN("NaN") // falseMath.acosh(3) // 1.762747174039086Math.hypot(3, 4) // 5Math.imul(Math.pow(2, 32) - 1, Math.pow(2, 32) - 2) // 2"abcde".includes("cd") // true"abc".repeat(3) // "abcabcabc"Array.from(document.querySelectorAll("")) // Returns a real ArrayArray.of(1, 2, 3) // Similar to new Array(…), but without special one-arg behavior[0, 0, 0].fill(7, 1) // [0,7,7][1,2,3].findIndex(x => x == 2) // 1["a", "b", "c"].entries() // iterator [0, "a"], [1,"b"], [2,"c"]["a", "b", "c"].keys() // iterator 0, 1, 2["a", "b", "c"].values() // iterator "a", "b", "c"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 here.

0b111110111 === 503 // true0o767 === 503 // true

Only supports literal form

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

function timeout(duration = 0) {    return new Promise((resolve, reject) => {        setTimeout(resolve, duration);    })}var p = timeout(1000).then(() => {    return timeout(2000);}).then(() => {    throw new Error("hmm");}).catch(err => {    return Promise.all([timeout(100), timeout(200)]);})

Support via polyfill

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

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

Support via polyfill

In order to use the Reflect API you must include the Babel polyfill.

function factorial(n, acc = 1) {    "use strict";    if (n <= 1) return acc;    return factorial(n - 1, n * acc);}// Stack overflow in most implementations today,// but safe on arbitrary inputs in ES2015factorial(100000)

Temporarily Removed in Babel 6

Only explicit self referencing tail recursion was supported due to the complexity and performance impact of supporting tail calls globally. Removed due to other bugs and will be re-implemented.