Skip to content

LanguageFeatures

Jump to bottom Edit New page
Michael B. Younkin edited this page Feb 7, 2014 · 16 revisions

Language Features

Property Method Assignment

These features are proposals for ECMAScript Harmony unless otherwise noted.

Classes

This implements class syntax and semantics as described in the ES6 draft spec. In earlier versions of Traceur we had more feature rich classes but in the spirit of Harmony we have scaled back and are now only supporting the minimal class proposal.

Classes are a great way to reuse code. Several JS libraries provide classes and inheritance, but they aren't mutually compatible. Here's an example:

class Monster extends Character {
  constructor(x, y, name) {
    super(x, y);
    this.name = name;
    this.health_ = 100;
  }

  attack(character) {
    super.attack(character);
  }

  get isAlive() { return this.health > 0; }
  get health() { return this.health_; }
  set health(value) {
    if (value < 0) throw new Error('Health must be non-negative.');
    this.health_ = value;
  }
}

Here's an example of subclassing an HTML button:

class CustomButton extends HTMLButtonElement {
  constructor() {
    this.value = 'Custom Button';
  }
  // ... other methods ...
}
var button = new CustomButton();
document.body.appendChild(button);

Warning This is currently not supported.

Modules

Modules are mostly implemented, with some parts of the Loader API still to be corrected. Modules try to solve many issues in dependencies and deployment, allowing users to create modules with explicit exports, import specific exported names from those modules, and keep these names separate.

// Profile.js
export var firstName = 'David';
export var lastName = 'Belle';
export var year = 1973;
// ProfileView.js
import {firstName, lastName, year} from './Profile';

function setHeader(element) {
  element.textContent = firstName + ' ' + lastName;
}
// rest of module

These modules can be loaded in several ways. We'll just show a couple of ways to get you started.

In a Web page you can use script tags with type="module":

<script type="module" src="ProfileView.js"></script>

and the WebPageTranscoder:

 new traceur.WebPageTranscoder(document.location.href).run(function() {
    // things you want to do with the modules.
  });

See for example, runner.html.

On the traceur command line you can load them with Loader.import:

    function getLoader() {
      var LoaderHooks = traceur.modules.LoaderHooks;
      var loaderHooks = new LoaderHooks(new traceur.util.ErrorReporter(), url);
      return new traceur.modules.CodeLoader(loaderHooks);
    }
    getLoader().import('../src/traceur.js',
        function(mod) {
          console.log('DONE');
        },
        function(error) {
          console.error(error);
        }
    );

See for example, repl.html.

Iterators and For Of Loops

Iterators are objects that can traverse a container. It's a useful way to make a class work inside a for of loop. The interface is similar to the iterators proposal. Iterating with a for of loop looks like:

for (let element of [1, 2, 3]) {
  console.log(element);
}

You can also create your own iterable objects. Normally this is done via the yield keyword (discussed below in Generators but it could be done explicitly by returning an object that has '@@iterator':

function iterateElements(array) {
  return {
    [Symbol.iterator]: function() {
      var index = 0;
      var current;
      return {
        get current() {
          return current;
        },
        moveNext: function() {
          if (index < array.length) {
            current = array[index++];
            return true;
          }
          return false;
        }
      };
    }
  };
}

Generators

Generators make it easy to create iterators. Instead of tracking state yourself and implementing '@@iterator', you just use yield (or yield* to yield each element in an iterator):

// A binary tree class.
function Tree(left, label, right) {
  this.left = left;
  this.label = label;
  this.right = right;
}
// A recursive generator that iterates the Tree labels in-order.
function* inorder(t) {
  if (t) {
    yield* inorder(t.left);
    yield t.label;
    yield* inorder(t.right);
  }
}

// Make a tree
function make(array) {
  // Leaf node:
  if (array.length == 1) return new Tree(null, array[0], null);
  return new Tree(make(array[0]), array[1], make(array[2]));
}
let tree = make([[['a'], 'b', ['c']], 'd', [['e'], 'f', ['g']]]);

// Iterate over it
for (let node of inorder(tree)) {
  console.log(node); // a, b, c, d, ...
}

A generator function needs to be annotated as function* instead of just function.

Destructuring Assignment

Destructuring assignment is a nice way to assign or initialize several variables at once:

var [a, [b], c, d] = ['hello', [', ', 'junk'], ['world']];
alert(a + b + c); // hello, world

It can also destructure objects:

var pt = {x: 123, y: 444};
var rect = {topLeft: {x: 1, y: 2}, bottomRight: {x: 3, y: 4}};
// ... other code ...
var {x, y} = pt; // unpack the point
var {topLeft: {x: x1, y: y1}, bottomRight: {x: x2, y: y2}} = rect;

alert(x + y); // 567
alert([x1, y1, x2, y2].join(',')) // 1,2,3,4

Default Parameters

Default parameters allow your functions to have optional arguments without needing to check arguments.length or check for undefined.

function slice(list, indexA = 0, indexB = list.length) {
  // ... 
}

Rest Parameters

Rest parameters allows your functions to have variable number of arguments without using the arguments object.

function push(array, ...items) {
  items.forEach(function(item) {
    array.push(item);
  });
}

The rest parameter is an instance of Array so all the array methods just works.

Spread Operator

The spread operator is like the reverse of rest parameters. It allows you to expand an array into multiple formal parameters.

function push(array, ...items) {
  array.push(...items);
}

function add(x, y) {
  return x + y;
}

var numbers = [4, 38];
add(...numbers);  // 42

The spread operator also works in array literals which allows you to combine multiple arrays more easily.

var a = [1];
var b = [2, 3, 4];
var c = [6, 7];
var d = [0, ...a, ...b, 5, ...c];

Object Initialiser Shorthand

This proposal allows you to skip repeating yourself when the property name and property value are the same in an object literal.

function getPoint() {
  var x = ...;
  var y = ...;
  ...
  return {x, y};
}

Property Method Assignment

Did you ever end up staring at code looking like this wondering where the syntax error was?

var object = {
  value: 42,
  toString() {
    return this.value;
  }
};

This proposal makes this a valid way to define methods on objects.

Block Scoped Bindings

Block scoped bindings provide scopes other than the function and top level scope. This ensures your variables don't leak out of the scope they're defined:

{
  const tmp = a;
  a = b;
  b = tmp;
}
alert(tmp); // error: 'tmp' is not defined.

It's also useful for capturing variables in a loop:

let funcs = [];
for (let i of [4,5,6]) {
  funcs.push(function() { return i; });
}
for (var func of funcs) {
  console.log(func()); // 4, 5, 6
}

Promises

Currently we have a version of Promises which needs to be documented better here.

function awaitTimeout(ms) {
  return new Promise((resolve) => {
    setTimeout(resolve, ms);
  });
}

function awaitOutput() {
  console.log( "Ready to await." );
  await awaitTimeout(1000);
  console.log( "Await finished." );
}

awaitOutput();

Deferred functions allow you to write asynchronous non-blocking code without writing callback functions, which don't compose well. With deferred functions, you can use JavaScript control flow constructs that you're used to, inline with the rest of your code.

function deferredAnimate(element) {
    for (var i = 0; i < 100; ++i) {
        element.style.left = i;
        await deferredTimeout(20);
    }
};

deferredAnimate(document.getElementById('box'));

Deferred functions use await expressions to suspend execution and return an object that represents the continuation of the function.

Add a custom footer
Add a custom sidebar
Clone this wiki locally