Übersicht

In ES6 wird class (Klasse) als Vorlage für Objekte eingeführt, und Klassen können mit dem Schlüsselwort class definiert werden.

Die Essenz von class ist eine Funktion.

Es kann als syntaktischer Zucker angesehen werden, der die Syntax des Objektprototyps klarer und eher wie die Syntax objektorientierter Programmierung macht.

Grundlegende Verwendung

Klassendefinition

Klassenausdrücke können anonym oder benannt sein.

//Anonyme Klasse let Beispiel = class { constructor(a) { this.a = a; } } //Benannte Klasse let Example = class Beispiel { constructor(a) { this.a = a; } }

Klassendeklaration

class Beispiel { constructor(a) { this.a = a; } }

Wichtiger Hinweis: darf nicht erneut deklariert werden.

class Example{} class Example{} // Uncaught SyntaxError: Identifier 'Example' wurde bereits // deklariert let Example1 = class{} class Example{} // Uncaught SyntaxError: Identifier 'Example' wurde bereits // deklariert

Wichtige Hinweise

Klassendefinitionen werden nicht gehoistet, was bedeutet, dass du eine Klasse definieren musst, bevor du auf sie zugreifst, andernfalls wird ein Fehler ausgelöst.

Methoden in einer Klasse erfordern nicht das Schlüsselwort function.

Semikolons können nicht zwischen Methoden eingefügt werden.

new Example(); class Example {}

Klassenkörper

Eigenschaften

prototype

In ES6 existiert prototype weiterhin. Obwohl Methoden direkt in der Klasse definiert werden können, werden sie tatsächlich weiterhin auf prototype definiert. Methoden überschreiben / Methoden während der Initialisierung hinzufügen

Example.prototype={ //methods }

Methoden hinzufügen

Object.assign(Beispiel.prototype,{ //Methoden })

Statische Eigenschaften

Statische Eigenschaften: Eigenschaften der Klasse selbst, d. h. Eigenschaften, die direkt innerhalb der Klasse definiert werden (Class.propname) und keine Instanziierung erfordern. In ES6 ist festgelegt, dass eine Klasse nur statische Methoden und keine statischen Eigenschaften hat.

class Beispiel { //Neuer Vorschlag static a = 2; } //Derzeit umsetzbarer Ansatz Beispiel.b = 2;

Öffentliche Eigenschaften

class Beispiel{} Beispiel.prototype.a = 2;

Instanzeigenschaften

Instanzeigenschaften: Eigenschaften, die auf dem Instanzobjekt (this) definiert werden.

class Beispiel { a = 2; constructor () { console.log(this.a); } }

name-Eigenschaft

Gibt den Klassennamen nach class zurück (falls vorhanden).

let Example=class Exam { constructor(a) { this.a = a; } } console.log(Example.name); // Exam let Example=class { constructor(a) { this.a = a; } } console.log(Example.name); // Example

Methoden

Konstruktormethode

Die Konstruktormethode ist die Standardmethode einer Klasse und wird aufgerufen, wenn ein Instanzobjekt der Klasse erstellt wird.

class Example{ constructor(){ console.log('Ich bin Konstruktor'); } } new Example(); //Ich bin Konstruktor

Rückgabeobjekt

class Test { constructor(){ //Gibt standardmäßig das Instanzobjekt this zurück } } console.log(new Test() instanceof Test); // true class Example { constructor(){ //Rückgabeobjekt angeben return new Test(); } } console.log(new Example() instanceof Example); // false

Statische Methoden

class Example{ static sum(a, b) { console.log(a+b); } } Example.sum(1, 2); // 3

Prototyp-Methoden

class Example { sum(a, b) { console.log(a + b); } } let exam = new Example(); exam.sum(1, 2); // 3

Instanzmethoden

class Beispiel { constructor() { this.sum = (a, b) => { console.log(a + b); } } }

Klasseninstanziierung

new

Die Instanziierung einer Klasse muss das Schlüsselwort new verwenden.

class Example {} let exam1 = Example(); // Klassenkonstruktor Example kann nicht ohne 'new' aufgerufen werden

Instanziiertes Objekt

Gemeinsames Prototypobjekt

class Beispiel { constructor(a, b) { this.a = a; this.b = b; console.log('Example'); } sum() { return this.a + this.b; } } let exam1 = new Example(2, 1); let exam2 = new Example(3, 1); //__proto__ ist veraltet und wird nicht empfohlen. // console.log(exam1.__proto__ == exam2.__proto__); console.log(Object.getPrototypeOf(exam1) === Object.getPrototypeOf(exam2));// true Object.getPrototypeOf(exam1).sub = function() { return this.a - this.b; } console.log(exam1.sub()); // 1 console.log(exam2.sub()); // 2

Dekorator

Ein Decorator ist eine Funktion, mit der das Verhalten einer Klasse geändert wird und die zur Kompilierungszeit des Codes wirksam wird.

Klassen-Decorator

Ein Parameter

Der erste Parameter, target, verweist auf die Klasse selbst.

function testable(target) { target.isTestable = true; } @testable class Example {} Example.isTestable; // wahr

Mehrere Parameter — verschachtelte Implementierung

function testable(isTestable) { return function(target) { target.isTestable=isTestable; } } @testable(true) class Example {} Example.isTestable; // true

Instanzeigenschaften

Die beiden obigen Beispiele fügen statische Eigenschaften hinzu. Um Instanzeigenschaften hinzuzufügen, arbeiten Sie einfach mit dem Prototyp der Klasse.

Methodendekorator

Drei Parameter: target (das Prototypobjekt der Klasse), name (der Name der geänderten Eigenschaft), descriptor (das Deskriptorobjekt der Eigenschaft).

class Example { @writable sum(a, b) { return a + b; } } function writable(target, name, descriptor) { descriptor.writable = false; return descriptor; //Muss zurückgeben }

Decorator-Ausführungsreihenfolge

Tritt von außen nach innen ein, führt von innen nach außen aus.

class Example { @logMethod(1) @logMethod(2) sum(a, b){ return a + b; } } function logMethod(id) { console.log('logMethod ausgewertet'+id); return (target, name, desctiptor) => console.log('logMethod ausgeführt '+id); } // logMethod 1 ausgewertet // logMethod 2 ausgewertet // logMethod 2 ausgeführt // logMethod 1 ausgeführt

Kapselung und Vererbung

Getter / Setter

Definition

class Beispiel{ constructor(a, b) { this.a = a; //Die set-Methode wird bei der Instanziierung aufgerufen this.b = b; } get a(){ console.log('getter'); return this.a; } set a(a){ console.log('setter'); this.a = a; //Selbstrekursiver Aufruf } } let exam = new Example(1,2); //Gibt kontinuierlich Setter aus, was schließlich einen RangeError verursacht class Example1{ constructor(a, b) { this.a = a; this.b = b; } get a(){ console.log('getter'); return this._a; } set a(a){ console.log('setter'); this._a = a; } } let exam1 = new Example1(1,2); //Gibt nur Setter aus, ruft die Getter-Methode nicht auf console.log(exam1._a); //1, kann direkt darauf zugegriffen werden

Getter darf nicht allein vorkommen

class Beispiel { constructor(a) { this.a = a; } get a() { return this.a; } } let exam = new Example(1); // Uncaught TypeError: Eigenschaft // a von #<Example> kann nicht gesetzt werden, da sie nur einen Getter hat

Getter und Setter müssen auf derselben Ebene stehen

class Father { constructor(){} get a() { return this._a; } } class Child extends Father { constructor(){ super(); } set a(a) { this._a = a; } } let test = new Child(); test.a = 2; console.log(test.a); // undefined class Father1 { constructor(){} //Oder setze beide in die Unterklasse get a() { return this._a; } set a(a) { this._a = a; } } class Child1 extends Father1 { constructor(){ super(); } } let test1 = new Child1(); test1.a = 2; console.log(test1.a); // 2

extends

Die Vererbung von Klassen wird durch extends implementiert.

class Child extends Father { ... }

super

Die Konstruktormethode der Unterklasse muss super enthalten, und sie muss vor this erscheinen.

class Father { constructor() {} } class Child extends Father { constructor() {} // oder // constructor(a) { // this.a = a; // super(); // } } let test = new Child(); // Uncaught ReferenceError: super muss aufgerufen werden // constructor in abgeleiteter Klasse, bevor auf 'this' zugegriffen wird oder // aus dem abgeleiteten constructor zurückgekehrt wird

Der Aufruf von constructor der Elternklasse kann nur im constructor der Unterklasse vorkommen.

class Father { test(){ return 0; } static test1(){ return 1; } } class Child extends Father { constructor(){ super(); } } class Child1 extends Father { test2() { super(); // Uncaught SyntaxError: 'super'-Schlüsselwort // hier unerwartet } }

Aufrufen von Methoden der Elternklasse: super verweist als Objekt in normalen Methoden auf das Prototypobjekt der Elternklasse und in static-Methoden auf die Elternklasse.

class Child2 extends Father { constructor(){ super(); //Aufrufen normaler Methoden der Elternklasse console.log(super.test()); // 0 } static test3(){ //Aufruf statischer Methoden der Elternklasse return super.test1+2; } } Child2.test3(); // 3

Wichtige Hinweise

Reguläre Objekte können nicht vererbt werden.

var Father = { // ... } class Child extends Father { // ... } // Uncaught TypeError: Der von der Klasse erweiterte Wert #<Object> ist kein Konstruktor oder null. //Lösung Object.setPrototypeOf(Child.prototype, Father);