Befinden sich es6-Klassen im strikten Modus?

ist der strikte Modus. Intern verwenden es6-Klassen und -Module standardmäßig den strikten Modus. Daher ist es nicht erforderlich, den Ausführungsmodus mit „use strict“ anzugeben. Solange der Code in der Klasse oder im Modul geschrieben ist, ist nur der strikte Modus verfügbar. Wenn man bedenkt, dass der gesamte zukünftige Code tatsächlich in Modulen ausgeführt wird, aktualisiert ES6 tatsächlich die gesamte Sprache auf den strikten Modus.

Die Betriebsumgebung dieses Tutorials: Windows 7-System, ECMAScript Version 6, Dell G3-Computer.

... näher an traditionellen Sprachen (Java) und führt das Konzept der Klasse als Vorlage für Objekte ein. Klassen können über das Schlüsselwort class definiert werden.

class point{ 
   
	constructor(x,y){ 
   
        this.x=x;
        this.y=y;
    }
    play(){ 
   
        console.log("我会玩");
    }
}

Die ES6-Klasse kann nur als syntaktischer Zucker betrachtet werden. Die meisten ihrer Funktionen können durch die neue Klassenschreibmethode nur klarer gemacht werden und ähneln eher der Syntax der objektorientierten Programmierung.

Hinweis: „Syntaktischer Zucker“: ist ein vom britischen Informatiker Peter J. Landin erfundener Begriff, der sich auf eine bestimmte Syntax bezieht, die Computersprachen hinzugefügt wird, die keinen Einfluss auf die Funktionen der Sprache hat, aber praktischer ist für Programmierer.

Einige wichtige Punkte, die Sie zu ES6-Klassen und ES5-Schreibmethoden beachten sollten: Der Konstruktor Point von ES5 entspricht der Konstruktormethode der Point-Klasse von ES6. Alle Methoden einer Klasse werden im Prototypattribut der Klasse definiert. Beim Definieren einer „Klasse“-Methode ist es nicht erforderlich, das Schlüsselwort function davor einzufügen, sondern einfach die Funktionsdefinition direkt darin einzufügen. Es ist nicht erforderlich, die Methoden durch Kommas zu trennen. Wenn sie hinzugefügt werden, wird ein Fehler gemeldet. Die Verwendungsmethode der ES6-Klasse ist genau die gleiche wie die des ES5-Konstruktors

//类的所有方法都定义在类的prototype属性上面。
class piont{ 
   
    constructor(){ 
   
		//
    }
    play(){ 
   
        
    }
}
//上述代码等价于
point.prototype={ 
   
    constructor() { 
   },
    play(){ 
   };
}

//在类的实例上面调用方法，其实就是调用原型上的方法。
class Ba{ 
   
	//
}
let b=new Ba();
b.constructor===Ba.prototype.constructor//true

Zusätzlich: Der Konstruktor Point von ES5 entspricht dem Konstruktor der Point-Klasse von ES6.

Da die Methoden der Klasse auf dem Prototypobjekt definiert sind, können neue Methoden der Klasse auf dem Prototypobjekt hinzugefügt werden. Die Object.assign-Methode erleichtert das gleichzeitige Hinzufügen mehrerer Methoden zu einer Klasse.

class ponit{ 
   
    constructor(){ 
   
        
    }
}
Object.assign(Point.prototype,{ 
   
	play(){ 
   };
})
//Class直接定义的方法之间不需要逗号分隔，加了会报错. 但是这里是Object.assign的方法格式, 这里面需要往Point.prototype里面添加的方法就需要符合对象的默认格式

Alle innerhalb der Klasse definierten Methoden sind nicht aufzählbar. Methoden, die dem Prototyp der Klasse über die Object.assign-Methode hinzugefügt werden. Der Konstruktor ist nicht aufzählbar, andere können aufgezählt werden.

Konstruktor der grundlegenden Syntax der Klasse Durch den neuen Befehl wird eine Objektinstanz generiert. Diese Methode wird automatisch aufgerufen. Eine Klasse muss eine Konstruktormethode haben, wenn sie nicht explizit definiert ist, wird standardmäßig eine leere Konstruktormethode hinzugefügt. Die Konstruktormethode gibt standardmäßig das Instanzobjekt (d. h. dieses) zurück, und Sie können angeben, dass ein anderes Objekt zurückgegeben werden soll (Die Einstellungen müssen beim Erstellen der Klasse definiert werden. Nach dem Erstellen der Klasse kann der Rückgabewert des Konstruktors nicht über Object.assign geändert werden).

Die grundlegende Syntax der Klasse und anderer aufrufender Methoden

Die Klasse muss mit new aufgerufen werden, andernfalls wird ein Fehler gemeldet. Dies ist ein wesentlicher Unterschied zu gewöhnlichen Konstruktoren (gewöhnliche Konstruktoren können als gewöhnliche Funktionen verwendet werden), die ohne neue ausgeführt werden können.

Die grundlegende Syntax der Klasse: Getter und Setter

Wie bei ES5 können Sie die Schlüsselwörter get und set innerhalb der „Klasse“ verwenden, um die Speicherfunktion und die Wertfunktion für einen bestimmten Wert festzulegen Attribut: Fangen Sie das Zugriffsverhalten dieses Attributs ab.

  class demo{ 
   
            constructor(age){ 
   
                this.age=agie;
                this._age=age;
            }
            get age(){ 
   
                return this._age;
            }
            set age(value){ 
   
                this._age=value;
                console.log("年龄"+value);
            }
        }
        let kevin=new demo(9);
        kevin.age=18;
        console.log(kevin.age);

Grundlegende Syntax der Klasse und andere Attributnamen

Im obigen Code wird der Methodenname getArea der Square-Klasse aus dem Ausdruck erhalten.

Besondere Punkte, die Sie bei der grundlegenden Syntax von Class beachten sollten

(1) Strikter Modus

Die Interna von Klassen und Modulen befinden sich standardmäßig im strikten Modus, daher besteht keine Notwendigkeit, den Ausführungsmodus mit „strict“ anzugeben . Solange Ihr Code in einer Klasse oder einem Modul geschrieben ist, ist nur der strikte Modus verfügbar. Wenn man bedenkt, dass der gesamte zukünftige Code tatsächlich in Modulen ausgeführt wird, aktualisiert ES6 tatsächlich die gesamte Sprache auf den strikten Modus.

(2) Es gibt keine Heraufstufung

new foo（）；
class foo{}；

Im obigen Code wird zuerst die Foo-Klasse verwendet und später definiert. Dies führt zu einem Fehler, da ES6 die Klassendeklaration nicht in den Kopf des Codes hochstuft.

(3) Namensattribut

class point{
}
point.name//point

Da ES6-Klassen im Wesentlichen nur ein Wrapper für ES5-Konstruktoren sind, werden viele Funktionen der Funktion von der Klasse geerbt, einschließlich des Namensattributs. (4) Wenn dies auf die Methode der

-Klasse verweist und diese enthält, verweist es standardmäßig auf die Instanz der Klasse. Sie müssen jedoch sehr vorsichtig sein, denn wenn Sie diese Methode allein verwenden, kann es zu einer Fehlermeldung kommen.

printName方法中的this，默认指向Logger类的实例。但是，如果将这个方法提取出来单独使用，this会指向该方法运行时所在的环境（由于 class 内部是严格模式，所以 this 实际指向的是undefined），从而导致找不到print方法而报错。

解决办法：

一个比较简单的解决方法是，在构造方法中绑定this，这样就不会找不到print方法了。

另一种解决方法是使用箭头函数。箭头函数位于构造函数内部，它的定义生效的时候，是在构造函数执行的时候。这时，箭头函数所在的运行环境，肯定是实例对象，所以this会总是指向实例对象。

class Logger{ 
   
    constructor(){ 
   
        this.printName=this.printName.bind(this);
        //但是请注意bind之后返回的函数里面的this就永久锁死了问题:!!! !!! 坚决别用 
    }
}
//箭头函数
class Obj{ 
   
    constructor(){ 
   
        this.getThis=()=>this;
    }
}
let o=new Obj();
o.getThis()===o//true

Class的静态属性和方法

类相当于实例的原型，所有在类中定义的方法，都会被实例继承。如果在一个方法前，加上static关键字，就表示该方法不会被实例继承，而是直接通过类来调用，这就称为“静态方法”。

 class Person{ 
   
            static sum=0;
            constructor(){ 
   
                this.add();
            }
            add(){ 
   
                Person.sum++;
            }
        }
        let kaiwen=new Person();
        console.log("当前的聊天室人数为："+Person.sum);
        //作用：当没有实例化的时候，我们可以通过静态的属性和方法去获取一些信息
 // 注意，如果静态方法包含this关键字，这个this指的是类，而不是实例。静态方法可以与非静态方法重名。

父类的静态方法，可以被子类继承静态方法也是可以从super对象上调用的。

 class Person{ 
   
            constructor(name){ 
   
                this.name=name;
                this.sex="男";
            }
        }
        class Student extends Person{ 
   
            constructor(name,age){ 
   
                super(name);
                this.age=age;
            }
        }
        let s=new Student("张三",11);
        console.log(s.name);
        console.log(s.age);
        console.log(s.sex);

Class的私有方法和私有属性

私有方法和私有属性:是只能在类的内部访问的方法和属性，外部不能访问。 这是常见需求，有利于代码的封装，但 ES6 不提供，只能通过变通方法模拟实现。

_bar方法前面的下划线，表示这是一个只限于内部使用的私有方法。但是，这种命名是不保险的，在类的外部，还是可以调用到这个方法

下面代码中的写法不仅可以写私有属性，还可以用来写私有方法

 class Cat{ 
   
            #eyes="眼睛";
            static pai(){ 
   
                console.log("凯文");
            }
            say(){ 
   
                Cat.pai();
                console.log("猫有一双大大的"+this.#eyes);
            }
        }
        let kate=new Cat();
        kate.say();

私有属性也可以设置 getter 和 setter 方法。

私有属性不限于从this引用，只要是在类的内部，实例也可以引用私有属性。

构造函数的新属性

ES6 为new命令引入了一个new.target属性，该属性一般用在构造函数之中，返回new命令作用于的那个构造函数。如果构造函数不是通过new命令调用的，new.target会返回undefined，因此这个属性可以用来确定构造函数是怎么调用的。

私有属性也可以设置 getter 和 setter 方法。

私有属性不限于从this引用，只要是在类的内部，实例也可以引用私有属性。

【相关推荐：javascript视频教程、编程视频】

Das obige ist der detaillierte Inhalt vonBefinden sich es6-Klassen im strikten Modus?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!