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);}

Support via polyfill

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

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.

// 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

Additional polyfill needed

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

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

Support via polyfill

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

// 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 :…}

Unsupported feature

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

(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

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.