Ü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.
let Beispiel = class {
constructor(a) {
this.a = a;
}
}
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{}
let Example1 = class{}
class Example{}
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
Methoden hinzufügen
Object.assign(Beispiel.prototype,{
})
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 {
static a = 2;
}
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);
let Example=class {
constructor(a) {
this.a = a;
}
}
console.log(Example.name);
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();
Rückgabeobjekt
class Test {
constructor(){
}
}
console.log(new Test() instanceof Test);
class Example {
constructor(){
return new Test();
}
}
console.log(new Example() instanceof Example);
Statische Methoden
class Example{
static sum(a, b) {
console.log(a+b);
}
}
Example.sum(1, 2);
Prototyp-Methoden
class Example {
sum(a, b) {
console.log(a + b);
}
}
let exam = new Example();
exam.sum(1, 2);
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();
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);
console.log(Object.getPrototypeOf(exam1) === Object.getPrototypeOf(exam2));
Object.getPrototypeOf(exam1).sub = function() {
return this.a - this.b;
}
console.log(exam1.sub());
console.log(exam2.sub());
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;
Mehrere Parameter — verschachtelte Implementierung
function testable(isTestable) {
return function(target) {
target.isTestable=isTestable;
}
}
@testable(true)
class Example {}
Example.isTestable;
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;
}
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);
}
Kapselung und Vererbung
Getter / Setter
Definition
class Beispiel{
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 exam = new Example(1,2);
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);
console.log(exam1._a);
Getter darf nicht allein vorkommen
class Beispiel {
constructor(a) {
this.a = a;
}
get a() {
return this.a;
}
}
let exam = new Example(1);
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);
class Father1 {
constructor(){}
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);
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() {}
}
let test = new Child();
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();
}
}
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();
console.log(super.test());
}
static test3(){
return super.test1+2;
}
}
Child2.test3();
Wichtige Hinweise
Reguläre Objekte können nicht vererbt werden.
var Father = {
}
class Child extends Father {
}
Object.setPrototypeOf(Child.prototype, Father);