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.