Features von übermorgen: ES2016

Inhaltsverzeichnis

Mehr Infos

Features von übermorgen

• ES2016
• CSS3 und runde Displays
• ES7 Observer
• ES7 Decorators
• Natives MVC in HTML6?
• ES7 Async Functions
  

Die Features, die offiziell Einzug in die nächste Version des ECMAScript-Standards Einzug halten werden, sind seit letzter Woche final. Dazu gehören alle Features, die bis zum 28.01.2016 Stage 4 erreicht hatten, was – nun ja – lediglich zwei neue sind: die neue Array-Methode includes() sowie der Potenzierungs-Operator. Gute Gelegenheit, sich beides einmal kurz anzuschauen.

Array.prototype.includes

Über die neue Methode includes() wird es möglich sein zu überprüfen, ob ein Array ein bestimmtes Element enthält. Sie funktioniert vom Prinzip her also ähnlich wie die bereits bekannte Methode indexOf(), liefert aber keinen Index zurück, sondern einen booleschen Wert:

let numbers = [2,3,4,5];
console.log(numbers.includes(2));    // true
console.log(numbers.includes(4));    // true
console.log(numbers.includes(4711)); // false

let max = {
  firstName: 'Max',
  lastName: 'Mustermann'
}
let moritz = {
  firstName: 'Moritz',
  lastName: 'Mustermann'
}
let people = [max];
console.log(people.includes(max));       // true
console.log(people.includes(moritz));    // false

Als optionalen zweiten Parameter kann man der Methode der Startindex übergeben, ab dem die Überprüfung stattfinden soll:

let numbers = [2,3,4,5,4711,4];
console.log(numbers.includes(2,4));    // false
console.log(numbers.includes(4,4));    // true

Im Unterschied zu der Methode indexOf() findet die Methode includes() auch den Wert NaN:

let numbers = [NaN,2,3,4,5];
console.log(numbers.indexOf(NaN));    // -1
console.log(numbers.includes(NaN));   // true

Derzeit unterstützen die letzten Versionen von Chrome und Firefox die neue Array-Methode. Es gibt jedoch entsprechende Polyfills, über die sich die Methode auch in anderen Browsern nutzen lässt, sowie die Möglichkeit, einen Transpiler wie BabelJS zu verwenden.

Potenzierungs-Operator

Bei dem Potenzierungs-Operator (Exponentiation Operator) handelt es sich – wie der Name schon sagt – um einen Operator für die Potenzrechnung, der quasi das Gleiche macht wie die bereits bekannte Methode Math.pow(). Der Operator besteht dabei aus zwei aufeinander folgenden Sternsymbolen (**).

let x = 5;
console.log(x ** 2);  // x * x => 25
console.log(x ** 3);  // x * x * x =>125
console.log(x ** 4);  // x * x * x * x => 625
console.log(x ** 5);  // x * x * x * x * x=> 3125
console.log(x ** x);  // x * x * x * x * x=> 3125

Dabei lässt sich der Potenzierungs-Operator (wie auch schon von Additions-, Subtraktions-, Multiplikations-, Divisions- und Modulooperator bekannt) direkt als Zuweisungsoperator verwenden:

let x = 5;
x **= 2;         // Äquivalent zu x = x * x
console.log(x);  // 25
let y = 5;
y **= 5;         // Äquivalent zu y = y * y * y * y * y
console.log(y);  // 3125

Fazit

Auch wenn die Anzahl der neuen Features recht mickrig ausgefallen ist, bekräftigt das umso mehr die geplante Vorgehensweise des ECMAScript-Komitees, ab ES2015 jährlich neue Versionen des ECMAScript-Standards zu veröffentlichen, unabhängig davon, wie viele Features neu hinzukommen. Andere geplante Features wie "async functions" müssen sich noch ein wenig gedulden und werden es jetzt also frühestens in die Version ES2017 schaffen. Einen Überblick, in welcher Stage sich die einzelnen Features aktuell befinden, findet man unter folgender Tabelle. ()