Le nouveau mot clé

L'appel d'une fonction avec new crée un objet utilisant la fonction appelée en tant que le "constructeur" pour cet objet:

function MyFunction() {}
const myObject = new MyFunction();

typeof myObject;
> "object"`

Cela permet à une « fonction constructeur » fournir un modèle pour la création qui suivent le même modèle structurel:

function MyFunction() {
  this.myProperty = true;
}
const myObject = new MyFunction();

myObject.myProperty;
> true

La valeur de this dans un constructeur fait référence à l'objet en cours de création, ce qui permet de l'insérer avec des propriétés et des méthodes au moment de la création. Cela permet de créer des objets contenant des valeurs de données et toutes les méthodes nécessaires pour agir sur ces données en tant qu'unité portable unique, un concept appelé "encapsulation" :

function MyFunction( myArgument ) {
    this.myValue = myArgument;
    this.doubleMyValue = () => myArgument * 2;
}
const myObject = new MyFunction( 10 );

myObject.myValue;
> 10

myObject.doubleMyValue();
> 20

this fait référence à l'exécution en cours le contexte d'une fonction, ce qui signifie qu'une fonction constructeur suit le même des règles pour la valeur de this comme pour toute autre fonction. Par exemple, une fonction destinée à être un constructeur utilise la liaison globale pour la valeur de this lorsqu'elle est appelée indépendamment :

function MyFunction() {
    console.log( this  );
}
const myObject = new MyFunction();
> MyFunction { }

MyFunction(); // Global `this` binding outside of strict mode is `globalThis`
> Window {  }

(function() {
    "use strict";
    function MyFunction() {
            console.log( this );
    }
    MyFunction();  // Global `this` binding inside of strict mode is `undefined`
}());
> undefined

Il est conventionnel de mettre en majuscule le premier caractère de la chaîne suivant le modèle de dénomination établi par l'API les fonctions d'usine. Même si vous voyez parfois les termes utilisés de manière interchangeable, les fonctions de constructeur : des fonctions destinées à agir sur un ensemble lorsqu'il est appelé avec le mot clé new (différent de "factory") des fonctions ». qui explicitement return un lorsqu'il est appelé normalement:

function myFunction( myArgument = false ) {
  return { "myProperty" : myArgument };
}
const myObject = myFunction( true );

myObject;
> Object { myProperty: true }

Bien que les principes sous-jacents soient les mêmes, les cas d'utilisation de l'authentification personnalisée les fonctions de constructeur sont mieux adaptées Syntaxe de classe introduite dans ES6.