Explication détaillée du mot-clé de classe dans ES6

La classe est l'une des fonctionnalités les plus importantes introduites par es6. Avant qu'il y ait une classe, nous ne pouvions simuler des classes que via la chaîne de prototypes. Cet article présente principalement le mot-clé class dans ES6. Class est l'une des fonctionnalités les plus importantes introduites par es6. Cet article vous donne une explication détaillée à travers un exemple de code. Les amis qui en ont besoin peuvent s'y référer. J'espère que cela pourra aider tout le monde.

1. Introduction

  //定义类
  class Point {
   constructor(x, y) {
   this.x = x;
   this.y = y;
   }
   toString() {
   return '(' + this.x + ', ' + this.y + ')';
   }
  }

En plus de la méthode de construction, la classe Point définit également une méthode toString. Notez que lors de la définition d'une méthode "classe", vous n'avez pas besoin d'ajouter le mot-clé function devant, il suffit de mettre directement la définition de la fonction. De plus, il n’est pas nécessaire de séparer les méthodes par des virgules, sinon une erreur sera signalée.

 //类的数据类型就是函数，类本身就指向构造函数。用的时候，也是直接对类使用new命令，跟构造函数的用法完全一致。
  class Bar {
   doStuff() {
   console.log('stuff');
   }
  }
  var b = new Bar();
  b.doStuff() // "stuff"

2. Mode strict

En interne, le mode par défaut des classes et des modules est le mode strict, il n'est donc pas nécessaire d'utiliser use strict pour spécifier le mode d'exécution. Tant que votre code est écrit dans une classe ou un module, seul le mode strict est disponible

3. Méthode constructeur

La méthode constructeur est la méthode par défaut de la classe lorsqu'une instance d'objet est. généré via la nouvelle commande, il est automatiquement appelé cette méthode. Une classe doit avoir une méthode constructeur Si elle n'est pas explicitement définie, une méthode constructeur vide sera ajoutée par défaut. ​​

class Point {
  }
  // 等同于
  class Point {
   constructor() {}//constructor方法默认返回实例对象（即this），完全可以指定返回另外一个对象。
  }
  //注意：类必须使用new调用，否则会报错。这是它跟普通构造函数的一个主要区别，后者不用new也可以执行。

4. Objet instance de classe

Pour générer un objet instance d'une classe, utilisez la nouvelle commande.

À moins que les attributs d'une instance ne soient explicitement définis sur elle-même (c'est-à-dire définis sur cet objet), ils sont définis sur le prototype (c'est-à-dire définis sur la classe). ​​

 class Point {
   // ...
  }
  // 报错
  var point = Point(2, 3);
  // 正确
  var point = new Point(2, 3);

5. Expression de classe

Le code suivant utilise une expression pour définir une classe. A noter que le nom de cette classe est MyClass au lieu de Me n'est disponible que dans le code interne de Class et fait référence à la classe actuelle.

 const MyClass = class Me {
   getClassName() {
   return Me.name;
   }
  };
  //采用 Class 表达式，可以写出立即执行的 Class。
  var person = new class {
   constructor(name) {
   this.name = name;
   }
   sayName() {
   console.log(this.name);
   }
  }('张三');
  person.sayName(); // "张三"

6. Il n'y a pas de levage de variable

Il n'y a pas de levage de variable (hoist) dans la classe

Dans le code suivant, la classe Foo est utilisée en premier et défini en dernier, comme ceci Une erreur sera signalée car ES6 ne promeut pas la déclaration de classe en tête du code. La raison de cette disposition est liée à l'héritage mentionné ci-dessous. Il faut s'assurer que la sous-classe est définie après la classe parent.

  new Foo(); // ReferenceError
  class Foo {}

7. Méthodes privées

Les méthodes privées sont une exigence courante, mais ES6 ne les fournit pas et ne peut être simulée que via des solutions de contournement.

Ajouter des méthodes privées

① Faites une différence dans la dénomination.

　② Profitez du caractère unique de la valeur Symbol et nommez la méthode privée comme valeur Symbol.​​  

 /*命名上加以区别*/
  class Widget {
   // 公有方法
   foo (baz) {
   this._bar(baz);
   }
   // 私有方法
   _bar(baz) {
   return this.snaf = baz;
   }
   // ...
  }
  /*利用Symbol*/
  const bar = Symbol('bar');
  const snaf = Symbol('snaf');
  
  export default class myClass{
   // 公有方法
   foo(baz) {
   this[bar](baz);
   }
   // 私有方法
   [bar](baz) {
   return this[snaf] = baz;
   }
   // ...
  };

8. Propriétés privées

Comme les méthodes privées, ES6 ne prend pas en charge les propriétés privées. Actuellement, il existe une proposition visant à ajouter des attributs privés aux classes. La méthode consiste à utiliser # avant le nom de l'attribut. ​

 class Point {
   #x;
   constructor(x = 0) {
   #x = +x; // 写成 this.#x 亦可
   }
   get x() { return #x }
   set x(value) { #x = +value }
  }

9. Cela pointe vers

Si une méthode de classe contient ceci, elle pointe vers une instance de la classe par défaut.
Une fois cette méthode utilisée seule, une erreur est susceptible d'être signalée.

 class Logger {
   printName(name = 'there') {
   this.print(`Hello ${name}`);
   }
  
   print(text) {
   console.log(text);
   }
  } 
  const logger = new Logger();
  const { printName } = logger;
  printName();
  //上面代码中，printName方法中的this，默认指向Logger类的实例。但是，如果将这个方法提取出来单独使用，this会指向该方法运行时所在的环境，因为找不到print方法而导致报错。
  /*解决方法是，在构造方法中绑定this，这样就不会找不到print方法了。*/
  class Logger {
   constructor() {
   this.printName = this.printName.bind(this);
   }  
   // ...
  }

10. attribut de nom

Puisque, par essence, la classe ES6 n'est qu'une couche d'emballage pour le constructeur ES5, de nombreuses fonctionnalités de la fonction sont héritées par la classe. , y compris l'attribut name.
L'attribut name renvoie toujours le nom de la classe immédiatement après le mot-clé class.

 class Point {}
  Point.name // "Point"

Recommandations associées :

Explication détaillée du super mot-clé dans la classe ES6

Classe de classe dans les exemples javascript ES6 d'utilisation get et set

Comment utiliser l'attribut class dans JS

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!