Pouvez-vous appeler un constructeur de classe sans le mot-clé « nouveau » en JavaScript ?

Invocation de constructeurs de classe sans le « nouveau » mot-clé

Dans ES6, les classes fournissent une syntaxe concise pour l'encapsulation et l'héritage. Cependant, appeler un constructeur de classe sans le mot-clé 'new' peut être une pierre d'achoppement.

Considérez la classe suivante :

<code class="javascript">class Foo {
  constructor(x) {
    if (!(this instanceof Foo)) return new Foo(x);
    this.x = x;
  }
  hello() {
    return `hello ${this.x}`;
  }
}</code>

Intuitivement, on pourrait s'attendre à ce que le code suivant fonctionne :

<code class="javascript">Foo("world").hello();       // "hello world"</code>

Cependant, cette tentative échoue avec l'erreur "Impossible d'appeler une classe en tant que fonction."

Le rôle des constructeurs de classe

En JavaScript, les classes définissent un " corps de classe" qui sert de constructeur. Ce constructeur est invoqué lorsque la classe est appelée, créant ainsi une instance de la classe. Par conséquent, il est essentiel d'utiliser le mot-clé « nouveau » pour lancer le constructeur et créer un nouvel objet.

Omettre le mot-clé « nouveau » : solutions et compromis

Il existe trois approches principales pour surmonter cette restriction :

1. Fonctions régulières

Au lieu d'utiliser une classe, on peut définir une fonction régulière qui se comporte de la même manière.

<code class="javascript">function Foo(x) {
  if (!(this instanceof Foo)) return new Foo(x);
  this.x = x;
  this.hello = function() {
    return this.x;
  }
}</code>

2. Appliquer le mot-clé 'new'

Pour garantir que la classe est toujours invoquée avec le mot-clé 'new', on peut implémenter une vérification au sein du constructeur :

<code class="javascript">class Foo {
  constructor(x) {
    if (!(this instanceof Foo)) throw new Error("Class must be invoked with 'new'");
    this.x = x;
  }
  hello() {
    return `hello ${this.x}`;
  }
}</code>

3. Fonction d'emballage

En encapsulant la classe dans une fonction régulière, il devient possible de l'invoquer à la fois avec et sans le mot-clé 'new'.

<code class="javascript">class Foo {
  constructor(x) {
    this.x = x;
  }
  hello() {
    return `hello ${this.x}`;
  }
}

var _old = Foo;
Foo = function(...args) { return new _old(...args) };</code>

Chaque solution présente ses propres compromis . Les fonctions régulières ne bénéficient pas des avantages d'encapsulation et d'héritage des classes, tandis que le mot clé « new » appliqué peut restreindre la flexibilité dans certains scénarios. L'approche de la fonction d'emballage établit un équilibre entre les deux options.

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!