Reflect.construct()

Baseline Large disponibilit

Cette fonctionnalit est bien tablie et fonctionne sur de nombreux appareils et versions de navigateurs. Elle est disponible sur tous les navigateurs depuis septembre 2016.

En savoir plus
Voir la compatibilit complte

La mthode statique Reflect.construct() agit comme l'oprateur new sous la forme d'une fonction. Elle est quivalente new cible(...args) et permet d'indiquer une valeur diffrente pour new.target.

Exemple interactif

function func1(a, b, c) {
  this.sum = a + b + c;
}

const args = [1, 2, 3];
const object1 = new func1(...args);
const object2 = Reflect.construct(func1, args);

console.log(object2.sum);
// Expected output: 6

console.log(object1.sum);
// Expected output: 6

Syntaxe

Reflect.construct(cible, listeArguments)
Reflect.construct(cible, listeArguments, nouvelleCible)

Paramtres

cible: La fonction cible appeler.
listeArguments: Un objet semblable un tableau dfinissant les arguments passer cible lors de l'appel.
nouvelleCible Facultatif: La valeur de l'expression new.target pour cible. cible indique la logique d'initialisation de l'objet, tandis que nouvelleCible.prototype indique le prototype de l'objet construit.

Valeur de retour

Une nouvelle instance de la cible indique, cre en l'appelant comme un constructeur (ou en appelant nouvelleCible si elle est fournie) avec les arguments fournis.

Exceptions leves

TypeError: Leve si cible ou nouvelleCible ne sont pas des constructeurs, ou si listeArguments n'est pas un objet.

Description

Reflect.construct() fournit la smantique rflective d'un appel un constructeur. Autrement dit, Reflect.construct(cible, listeArguments, nouvelleCible) est smantiquement quivalent :

new cible(...listeArguments);

Quand on utilise l'oprateur new, cibleet nouvelleCible sont toujours les mmes constructeurs. Reflect.construct() permet quant elle de passer une valeur diffrente pour new.target. Conceptuellement, nouvelleCible est la fonction sur laquelle new est appel et nouvelleCible.prototype devient le prototype de l'objet construit, tandis que cible est le constructeur effectivement excut pour l'initialisation de l'objet. On peut par exemple avoir une valeur new.target diffrente du constructeur excut pour l'hritage de classe :

class A {
  constructor() {
    console.log(new.target.name);
  }
}
class B extends A {}

new B(); // "B"

Reflect.construct() permet d'invoquer un constructeur avec un nombre variable d'arguments (ce qui est galement possible lors d'un appel un constructeur normal grce la syntaxe de dcomposition).

const obj = new Toto(...args);
const obj = Reflect.construct(Toto, args);

Reflect.construct() invoque la mthode interne [[Construct]] de cible.

Exemples

Utiliser `Reflect.construct()`

const d = Reflect.construct(Date, [1776, 6, 4]);
d instanceof Date; // true
d.getFullYear(); // 1776

Utiliser le paramtre `nouvelleCible`

Si le paramtre nouvelleCible est utilis, il modifiera la valeur de new.target dans le constructeur. L'objet ainsi construit sera une instance de nouvelleCible, pas de cible.

function ClasseUne() {
  console.log("ClasseUne excute");
  console.log(`new.target vaut ${new.target.name}`);
}

function AutreClasse() {
  console.log("AutreClasse excute");
  console.log(`new.target vaut ${new.target.name}`);
}

const obj1 = Reflect.construct(ClasseUne, []);
// Affiche dans la console :
// ClasseUne excute
// new.target vaut ClasseUne
console.log(obj1 instanceof ClasseUne); // true

const obj2 = Reflect.construct(ClasseUne, [], AutreClasse);
// Affiche dans la console :
// ClasseUne excute
// new.target vaut AutreClasse
console.log(obj2 instanceof AutreClasse); // true
console.log(obj2 instanceof ClasseUne); // false

Il n'y a pas de garantie forte quant la chane de prototypes de l'objet construit, car celle-ci dpend de l'implmentation du constructeur. Par exemple, si le constructeur cible renvoie un objet, c'est cet objet qui sera l'objet construit, quelle que soit la valeur de nouvelleCible. Si cible est un proxy avec une trappe pour construct, ce sera la trappe qui contrlera compltement le processus de construction.

function ClasseUne() {
  return { name: "un" };
}

function AutreClasse() {
  return { name: "autre" };
}

const obj1 = Reflect.construct(ClasseUne, [], AutreClasse);
console.log(obj1.name); // 'un'
console.log(obj1 instanceof ClasseUne); // false
console.log(obj1 instanceof AutreClasse); // false

Pour tre tout fait valide, new.target devrait tre une fonction constructrice avec une proprit prototype, mais cette rgle n'est pas impose. Si la valeur de la proprit prototype n'est pas un objet, l'objet initialis hritera de Object.prototype.

function ClasseUne() {
  console.log("ClasseUne excute");
  console.log(`new.target vaut ${new.target.name}`);
}

function AutreClasse() {
  console.log("AutreClasse excute");
  console.log(`new.target vaut ${new.target.name}`);
}

AutreClasse.prototype = null;

const obj = Reflect.construct(ClasseUne, [], AutreClasse);
// Affiche dans la console :
// ClasseUne excute
// new.target vaut AutreClasse
console.log(Object.getPrototypeOf(obj) === Object.prototype); // true

Une comparaison entre `Reflect.construct()` et `Object.create()`

Avant l'apparition de Reflect, on pouvait construire des objets avec une combinaison donne de consttructeur et de prototype grce Object.create().

function MaClasseA() {
  this.name = "A";
}

function MaClasseB() {
  this.name = "B";
}

const args = [];
const obj1 = Reflect.construct(MaClasseA, args, MaClasseB);
const obj2 = Object.create(MaClasseB.prototype);
MaClasseA.apply(obj2, args);

console.log(obj1.name); // 'A'
console.log(obj2.name); // 'A'

console.log(obj1 instanceof MaClasseA); // false
console.log(obj2 instanceof MaClasseA); // false

console.log(obj1 instanceof MaClasseB); // true
console.log(obj2 instanceof MaClasseB); // true

Toutefois, si les rsultats sont identiques, il y a une diffrence notable. Lorsqu'on utilise Object.create() et Function.prototype.apply(), l'oprateur new.target pointe vers undefined dans la fonction utilise comme constructeur, car le mot-cl new n'est pas utilis la cration de l'objet (dans cette situation, c'est la mme smantique que apply() qui s'applique, pas celle de construct(), mme si les fonctions normales se comportent presque identiquement).

En revanche, quand on appelle Reflect.construct(), new.target pointe vers la valeur fournie par nouvelleCible si elle indique ou vers cible sinon.

function MaClasseA() {
  console.log("MaClasseA");
  console.log(new.target);
}
function MaClasseB() {
  console.log("MaClasseB");
  console.log(new.target);
}

const obj1 = Reflect.construct(MaClasseA, args);
// Affiche dans la console :
//   MaClasseA
//   function MaClasseA { ... }

const obj2 = Reflect.construct(MaClasseA, args, MaClasseB);
// Affiche dans la console :
//   MaClasseA
//   function MaClasseB { ... }

const obj3 = Object.create(MaClasseB.prototype);
MaClasseA.apply(obj3, args);
// Affiche dans la console :
//     MaClasseA
//     undefined

Spcifications

Spcification
ECMAScript 2027 LanguageSpecification # sec-reflect.construct

Compatibilit des navigateurs

Voir aussi

Aider amliorer MDN

Cette page vous a-t-elle t utile ?

Oui Non

Apprendre contribuer

Cette page a t modifie le 17 fvr. 2025 par les contributeurices du MDN.

Voir cette page sur GitHub Signaler un problme avec ce contenu