Blog

Mit Erscheinen von NodeJS 4 haben einige ES6 Features es in den Sprachkern von NodeJS geschafft. Viele dieser kleinen und großen Helfer können uns Node-Progammierern den Alltag erleichtern. Demnach möchte ich euch heute einen kurzen Überblick einiger der neuen Änderungen in aller Kürze geben.

Template Strings

Mit ES6 haben wir nun die Möglichkeit mehrzeilige Strings anzugeben. Außerdem ist es möglich Platzhalter automatisch ersetzen zu lassen:

var x = `Backticks
are
awesome for multiline strings`

var y = 'World!'
console.log(`Hello ${y}`);

> Hello World!

let & const

Neben der einfachen Variablendeklaration mit var ist es nun möglich Konstanten zu definieren. Mit let gibt es nun eine Variante von var, die den aktuellen Scope korrekt berücksichtigt.

for (var i = 0; i++)  {
  setImmediate(function() { console.log(i); });
}

> 10
> 10
> 10
> 10
> 10
> 10
> 10
> 10
> 10
> 10

for (var i = 0; i++)  {
  let j = i;
  setImmediate(function() { console.log(j); });
}

> 0
> 1
> 2
> 3
> 4
> 5
> 6
> 7
> 8
> 9

Die so erzeugte Variable ist nur in ihrem jeweiligen Scope gültig! Konstanten sind ebenso selbsterklärend. Einzig interessant ist, dass das Setzen von Konstanten auf einen neuen Wert keinen Fehler darstellt

const MY_CONST = 42;
MY_CONST = 17
console.log(MY_CONST);

> 42

const MY_CONST = 42;
var MY_CONST = 13
console.log(MY_CONST);

> 42

Achtung: Nur die Referenz auf einen Wert ist konstant. Der Inhalt von Objekten kann beispielsweise immer noch verändert werden:

const MY_CONST = {value: 42};
MY_CONST.value = 17
console.log(MY_CONST);

> 17

Klassen mit `class`

Endlich werden Klassen mit Vererbung direkt durch syntaktischen Zucker unterstützt. Hier nur ein kleines Beispiels, wie Klassen genutzt werden können:

'use strict';

class A {
  constructor(a) {
    this._factor = a;
  }

  get factor() {
    return this._factor;
  }

  instanceFunction(b) {
    return this.factor * b;
  }

}

class B extends A {
  instanceFunction(b) {
    return this.factor * super.instanceFunction(b);
  }
}

var x = new A(2);
var y = new B(2);

x.instanceFunction(3);

> 6

y.instanceFunction(3);

> 12

Fat-Arrow Funktionen

Kurzschreibweise für anonyme Funktionen, die als Bonus die Selbstreferenz (this) binden:

class A {
  calc(a) {
    return a * 2;
  }

  get() {
    someAsyncFunction(params, (err, result) => {
      this.calc(result); // this entspricht der Instanz auf der get aufgerufen wurde
    });
  }
}

Maps und Sets

Neben Objekten gibt es nun spezielle Klassen, die Map- und Set-Semantik erfüllen. Besonders interessant sind hierbei WeakSet und WeakMap, die es erlauben Caches zu bauen, da die gesetzten Schlüssel für den Garbage Collector als nicht referenziert zählen. Sobald keine weitere Referenz auf einen Schlüssel existiert, kann der Schlüssel (und im Fall der WeakMap der ganze Eintrag) freigegeben werden.

var wm = new WeakMap()
var key = {} // some non-primitive object

wm.set(key, value);
wm.get(key);
wm.delete(key);

Generator Funktionen mit yield

yield verdient einen eigenen Artikel. Als Vorgeschmack verweise ich aber gerne auf diesen Blogpost

Symbole

Symbole erlauben unter anderem kollisionsfreiheie Erweiterung von Objekten um Eigenschaften. Besonders nützlich, sind diese, wenn Objekte ergänzt werden sollen, die nicht im eigenen Modul erzeugt wurden.

var otherObject = {};

const MY_PROPERTY = Symbol('Purpose of the Symbol');
otherObject[MY_PROPERTY] = 'VALUE';

console.log(otherObject[MY_PROPERTY]);
> 'VALUE'

Symbole werden von den folgenden Funktionen ignoriert:

• for-in
• Oject.keys(...),
• Object.getOwnPropertyNames(...).

Somit werden sie beispielsweise auch nicht von JSON.stringify(...) beachtet.

Promise

Mit ES6 haben sind nun auch endlich Promise-Objekte im Sprachkern verankert. Wer mehr wissen sollte findet unter MDN alles Wissenswerte.

Weitere

• Binary & Octal Literals,
• Typed Arrays,
• Erweiterte String Methoden (startsWith, endsWith, ...)

Noch setzt NodeJS 4 nicht alle in ES6 geforderten Änderungen um, aber Wir halten euch auf dem Laufenden!