Le nouveau mot clé

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

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

typeof myObject;
> "object"`

Cela permet à une "fonction constructeur" de fournir un modèle pour la création d'objets suivant le même modèle structurel:

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

myObject.myProperty;
> true

La valeur de this dans une fonction de constructeur fait référence à l'objet en cours de création, ce qui lui permet d'être renseigné 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 comme une seule unité portable, 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 au contexte d'exécution actuel d'une fonction, ce qui signifie qu'une fonction constructeur suit les mêmes règles pour la valeur de this que toute autre fonction. Par exemple, une fonction destinée à être constructeur utilise une 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 courant de mettre une majuscule au premier caractère de l'identifiant d'une fonction de constructeur, en suivant le modèle de dénomination établi par les fonctions de fabrique intégrées de JavaScript. Bien que vous puissiez parfois voir les termes utilisés de manière interchangeable, les fonctions de constructeur (fonctions destinées à agir sur un objet nouvellement créé lorsqu'elles sont appelées avec le mot clé new) sont différentes des "fonctions de fabrique", qui explicitement return un objet 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 des fonctions de constructeur personnalisées sont mieux servis par la syntaxe Class, plus complète, introduite dans ES6.