ECMAScript 6 ist im Grunde genommen ein Industriestandard geworden. Es verbreitet sich viel schneller als ES5, hauptsächlich weil moderne Browser ES6 recht schnell unterstützen, insbesondere Chrome und Firefox, die bereits die große Mehrheit der ES6-Funktionen unterstützen.
1. let, const und Block-Scope
let ermöglicht die Erstellung von Block-Scope. ES6 empfiehlt, in Funktionen let anstelle von var zum Definieren von Variablen zu verwenden:
var a = 2;
{
let a = 3;
console.log(a); // 3
}
console.log(a); // 2
Eine weitere Möglichkeit, Variablen zu deklarieren, die auch im Block-Scope gültig ist, ist const, womit eine Konstante deklariert werden kann. In ES6 ähnelt eine mit const deklarierte Konstante einem Zeiger; sie verweist auf eine Referenz, was bedeutet, dass diese "Konstante" nicht unveränderlich ist. Zum Beispiel:
{
const ARR = [5,6];
ARR.push(7);
console.log(ARR); // [5,6,7]
ARR = 10; // TypeError
}
Es gibt einige Punkte zu beachten:
- Mit dem Schlüsselwort let deklarierte Variablen haben keine Hoisting-Eigenschaften.
- Deklarationen mit let und const sind nur innerhalb des nächstgelegenen Blocks (innerhalb geschweifter Klammern) gültig.
- Verwenden Sie bei der Deklaration mit dem Konstanten-Schlüsselwort const Großbuchstaben für Variablennamen, z. B.: CAPITAL_CASING
- const muss bei der Deklaration ein Wert zugewiesen werden.
2. Pfeilfunktionen
In ES6 sind Pfeilfunktionen eine Kurzform von Funktionen. Parameter werden in Klammern gesetzt, gefolgt von =>, und dann folgt der Funktionskörper:
var getPrice = function() {
return 4.55;
};
// Implementation with Arrow Function
var getPrice = () => 4.55;
Beachten Sie, dass die Pfeilfunktion getPrice im obigen Beispiel einen knappen Funktionskörper verwendet, der keine return-Anweisung erfordert. Das folgende Beispiel verwendet einen normalen Funktionskörper:
let arr = ['apple', 'banana', 'orange'];
let breakfast = arr.map(fruit => {
return fruit + 's';
});
console.log(breakfast); // apples bananas oranges
Natürlich machen Pfeilfunktionen den Code nicht nur knapper; das this in einer Funktion ist immer an das Objekt selbst gebunden. Hier sind einige Beispiele:
function Person() {
this.age = 0;
setInterval(function growUp() {
// 在非严格模式下,growUp() 函数的 this 指向 window 对象
this.age++;
}, 1000);
}
var person = new Person();
Wir müssen oft eine Variable verwenden, um this zu speichern und dann in der Funktion growUp darauf zu verweisen:
function Person() {
var self = this;
self.age = 0;
setInterval(function growUp() {
self.age++;
}, 1000);
}
Die Verwendung von Pfeilfunktionen kann diesen Ärger ersparen:
function Person(){
this.age = 0;
setInterval(() => {
// |this| 指向 person 对象
this.age++;
}, 1000);
}
var person = new Person();
3. Standardwerte für Funktionsparameter
ES6 ermöglicht es dir, Standardwerte für Funktionsparameter festzulegen:
let getFinalPrice = (price, tax=0.7) => price + price * tax; getFinalPrice(500); // 850
4. Spread-/Rest-Operator
Der Spread-/Rest-Operator bezieht sich auf ..., und ob es sich um Spread oder Rest handelt, hängt vom Kontext ab.
Wenn er in einem Iterierbaren verwendet wird, ist er ein Spread-Operator:
function foo(x,y,z) {
console.log(x,y,z);
}
let arr = [1,2,3];
foo(...arr); // 1 2 3
Wenn er zum Übergeben von Funktionsargumenten verwendet wird, ist er ein Rest-Operator:
function foo(...args) {
console.log(args);
}
foo( 1, 2, 3, 4, 5); // [1, 2, 3, 4, 5]
5. Erweiterungen von Objektliteralen
ES6 erlaubt eine Kurzschreibweise beim Deklarieren von Objektliteralen, um Eigenschaftsvariablen zu initialisieren und Methoden zu definieren, und erlaubt außerdem berechnete Operationen in Objekteigenschaften:
function getCar(make, model, value) {
return {
// 简写变量
make, // 等同于 make: make
model, // 等同于 model: model
value, // 等同于 value: value
// 属性可以使用表达式计算值
['make' + make]: true,
// 忽略 `function` 关键词简写对象函数
depreciate() {
this.value -= 2500;
}
};
}
let car = getCar('Barret', 'Lee', 40000);
// output: {
// make: 'Barret',
// model:'Lee',
// value: 40000,
// makeBarret: true,
// depreciate: [Function: depreciate]
// }
6. Binäre und oktale Literale
ES6 unterstützt binäre und oktale Literale. Indem man einer Zahl 0o oder 0O voranstellt, kann sie in einen oktalen Wert umgewandelt werden:
let oValue = 0o10; console.log(oValue); // 8 let bValue = 0b10; // 二进制使用 `0b` 或者 `0B` console.log(bValue); // 2
7. Objekt- und Array-Destrukturierung
Destrukturierung kann Zwischenvariablen vermeiden, wenn Objektwerte zugewiesen werden:
function foo() {
return [1,2,3];
}
let arr = foo(); // [1,2,3]
let [a, b, c] = foo();
console.log(a, b, c); // 1 2 3
function bar() {
return {
x: 4,
y: 5,
z: 6
};
}
let {x: x, y: y, z: z} = bar();
console.log(x, y, z); // 4 5 6
8. Object-Superklasse
ES6 erlaubt die Verwendung der super-Methode in Objekten:
var parent = {
foo() {
console.log("Hello from the Parent");
}
}
var child = {
foo() {
super.foo();
console.log("Hello from the Child");
}
}
Object.setPrototypeOf(child, parent);
child.foo(); // Hello from the Parent
// Hello from the Child
9. Template-Syntax und Begrenzungszeichen
ES6 bietet eine sehr prägnante Möglichkeit, eine Reihe von Strings und Variablen zusammenzusetzen.
- ${ ... } wird verwendet, um eine Variable zu rendern
- ` wird als Begrenzungszeichen verwendet
let user = 'Barret';
console.log(`Hi ${user}!`); // Hi Barret!
10. for...of VS for...in
for...of wird verwendet, um über ein Iterable zu iterieren, z. B. ein Array:
let nicknames = ['di', 'boo', 'punkeye'];
nicknames.size = 3;
for (let nickname of nicknames) {
console.log(nickname);
}
// 结果: di, boo, punkeye
for...in wird verwendet, um über Eigenschaften in einem Objekt zu iterieren:
let nicknames = ['di', 'boo', 'punkeye'];
nicknames.size = 3;
for (let nickname in nicknames) {
console.log(nickname);
}
Result: 0, 1, 2, size
11. Map und WeakMap
ES6 hat zwei neue Datenstruktur-Sammlungen: Map und WeakMap. Tatsächlich kann jedes Objekt als Map betrachtet werden.
Ein Objekt besteht aus mehreren Schlüssel-Wert-Paaren. In einer Map kann jeder Typ als Schlüssel eines Objekts verwendet werden, z. B.:
var myMap = new Map();
var keyString = "a string",
keyObj = {},
keyFunc = function () {};
// 设置值
myMap.set(keyString, "value 与 'a string' 关联");
myMap.set(keyObj, "value 与 keyObj 关联");
myMap.set(keyFunc, "value 与 keyFunc 关联");
myMap.size; // 3
// 获取值
myMap.get(keyString); // "value 与 'a string' 关联"
myMap.get(keyObj); // "value 与 keyObj 关联"
myMap.get(keyFunc); // "value 与 keyFunc 关联"
WeakMap
WeakMap ist eine Map, außer dass alle ihre Schlüssel schwache Referenzen sind, was bedeutet, dass Dinge in WeakMap bei der Garbage Collection nicht berücksichtigt werden, sodass Sie sich bei der Verwendung keine Gedanken über Probleme mit Speicherlecks machen müssen.
Ein weiterer zu beachtender Punkt ist, dass alle Schlüssel von WeakMap Objekte sein müssen. Es hat nur vier Methoden: delete(key), has(key), get(key) und set(key, val):
let w = new WeakMap();
w.set('a', 'b');
// Uncaught TypeError: Invalid value used as weak map key
var o1 = {},
o2 = function(){},
o3 = window;
w.set(o1, 37);
w.set(o2, "azerty");
w.set(o3, undefined);
w.get(o3); // undefined, because that is the set value
w.has(o1); // true
w.delete(o1);
w.has(o1); // false
12. Set und WeakSet
Ein Set-Objekt ist eine Sammlung eindeutiger Werte. Doppelte Werte werden ignoriert, und die Werttypen können primitive Typen und Referenztypen sein:
let mySet = new Set([1, 1, 2, 2, 3, 3]);
mySet.size; // 3
mySet.has(1); // true
mySet.add('strings');
mySet.add({ a: 1, b:2 });
Sie können ein Set-Objekt mit forEach und for...of durchlaufen:
mySet.forEach((item) => {
console.log(item);
// 1
// 2
// 3
// 'strings'
// Object { a: 1, b: 2 }
});
for (let value of mySet) {
console.log(value);
// 1
// 2
// 3
// 'strings'
// Object { a: 1, b: 2 }
}
Set hat außerdem die Methoden delete() und clear().
WeakSet
Ähnlich wie WeakMap ermöglicht ein WeakSet-Objekt, schwache Referenzen auf Objekte in einer Sammlung zu speichern. Objekte in WeakSet dürfen nur einmal vorkommen:
var ws = new WeakSet();
var obj = {};
var foo = {};
ws.add(window);
ws.add(obj);
ws.has(window); // true
ws.has(foo); // false, foo 没有添加成功
ws.delete(window); // 从结合中删除 window 对象
ws.has(window); // false, window 对象已经被删除
13. Klassen
ES6 hat eine class-Syntax. Es ist erwähnenswert, dass class hier kein neues Objektvererbungsmodell ist; es ist nur syntaktischer Zucker für die Prototypkette.
Verwenden Sie in Funktionen das Schlüsselwort static, um Methoden und Eigenschaften des Konstruktors zu definieren:
class Task {
constructor() {
console.log("task instantiated!");
}
showId() {
console.log(23);
}
static loadAll() {
console.log("Loading all tasks..");
}
}
console.log(typeof Task); // function
let task = new Task(); // "task instantiated!"
task.showId(); // 23
Task.loadAll(); // "Loading all tasks.."
Vererbung und super in Klassen:
class Car {
constructor() {
console.log("Creating a new car");
}
}
class Porsche extends Car {
constructor() {
super();
console.log("Creating Porsche");
}
}
let c = new Porsche();
// Creating a new car
// Creating Porsche
extends ermöglicht es einer Unterklasse, von einer Elternklasse zu erben. Beachten Sie, dass die Konstruktorfunktion der Unterklasse die Funktion super() ausführen muss.
Natürlich können Sie in Methoden der Unterklasse auch Methoden der Elternklasse aufrufen, wie z. B. super.parentMethodName().
Lesen Sie hier mehr über Klassen.
Einige Punkte, die erwähnenswert sind:
- Klassendeklarationen werden nicht gehoistet. Wenn Sie eine bestimmte Klasse verwenden möchten, müssen Sie sie vor der Verwendung definieren, andernfalls wird ein ReferenceError ausgelöst.
- Sie müssen das Schlüsselwort function nicht verwenden, um Funktionen in einer Klasse zu definieren.
14. Symbol
Symbol ist ein neuer Datentyp, dessen Wert eindeutig und unveränderlich ist. Der Zweck der Einführung von symbol in ES6 ist es, eine eindeutige Kennung zu erzeugen, aber Sie können nicht auf diese Kennung zugreifen:
var sym = Symbol( "some optional description" ); console.log(typeof sym); // symbol
Beachten Sie, dass der new-Operator hier nicht vor Symbol verwendet werden kann.
Wenn es als Eigenschaft eines Objekts verwendet wird, ist diese Eigenschaft nicht aufzählbar:
var o = {
val: 10,
[ Symbol("random") ]: "I'm a symbol",
};
console.log(Object.getOwnPropertyNames(o)); // val
Um die Symbol-Eigenschaften eines Objekts zu erhalten, müssen Sie Object.getOwnPropertySymbols(o) verwenden.
15. Iteratoren
Iteratoren ermöglichen jeweils den Zugriff auf ein Element einer Datensammlung. Wenn der Zeiger auf das letzte Element der Datensammlung zeigt, endet der Iterator. Er bietet eine next()-Funktion zum Durchlaufen einer Sequenz, und diese Methode gibt ein Objekt zurück, das die Eigenschaften done und value enthält.
In ES6 kannst du über Symbol.iterator einen Standard-Iterator für ein Objekt festlegen. Wann immer ein Objekt iteriert werden muss, kann das Ausführen seiner @@iterator-Methode einen Iterator zum Abrufen von Werten zurückgeben.
Ein Array ist standardmäßig ein Iterator:
var arr = [11,12,13];
var itr = arr[Symbol.iterator]();
itr.next(); // { value: 11, done: false }
itr.next(); // { value: 12, done: false }
itr.next(); // { value: 13, done: false }
itr.next(); // { value: undefined, done: true }
Du kannst einen Iterator für ein Objekt über [Symbol.iterator]() anpassen.
16. Generatoren
Generatorfunktionen sind eine neue Funktion von ES6. Sie ermöglichen es einer Funktion, ein iterierbares Objekt zurückzugeben, das mehrere Werte erzeugt.
In der Anwendung wirst du die *-Syntax und ein neues Schlüsselwort yield sehen:
function *infiniteNumbers() {
var n = 1;
while (true){
yield n++;
}
}
var numbers = infiniteNumbers(); // returns an iterable object
numbers.next(); // { value: 1, done: false }
numbers.next(); // { value: 2, done: false }
numbers.next(); // { value: 3, done: false }
Jedes Mal, wenn yield ausgeführt wird, wird der zurückgegebene Wert der nächste Wert des Iterators.
17. Promises
ES6 bietet native Unterstützung für Promise. Ein Promise ist ein Objekt, das darauf wartet, asynchron ausgeführt zu werden. Wenn es die Ausführung abschließt, wird sein Zustand erfüllt oder abgelehnt.
var p = new Promise(function(resolve, reject) {
if (/* condition */) {
// fulfilled successfully
resolve(/* value */);
} else {
// error, rejected
reject(/* reason */);
}
});
Jedes Promise hat eine .then-Methode. Diese Methode akzeptiert zwei Parameter: Der erste ist ein Callback zur Behandlung des erfüllten Zustands, und der zweite ist ein Callback zur Behandlung des abgelehnten Zustands:
p.then((val) => console.log("Promise Resolved", val),
(err) => console.log("Promise Rejected", err));
Original: https://github.com/metagrover/ES6-for-humans
Übersetzung: http://www.barretlee.com/blog/2016/07/09/a-kickstarter-guide-to-writing-es6/
Übersetzer/Little Bearded Brother