--- title: Reflect.construct() slug: Web/JavaScript/Reference/Objets_globaux/Reflect/construct tags: - ECMAScript 2015 - JavaScript - Méthode - Reference - Reflect translation_of: Web/JavaScript/Reference/Global_Objects/Reflect/construct ---

La méthode statique Reflect.construct() agit comme l'opérateur new sous la forme d'une fonction. Elle est équivalente à new cible(...args) et permet d'indiquer un prototype différent.

Syntaxe

Reflect.construct(cible, listeArguments[, newCible])

Paramètres

cible: La fonction cible à appeler.
listeArguments: Un objet semblable à un tableau définissant les arguments à passer à cible lors de l'appel. Utiliser {{jsxref("null")}} ou {{jsxref("undefined")}} si aucun argument ne doit être fourni à la fonction.
newCible {{optional_inline}}: Le constructeur dont le prototype devrait être utilisé. Voir également l'opérateur new.target. Si newCible n'est pas présent, c'est cible qui sera utilisé.

Valeur de retour

Un nouvelle instance de la cible indiquée, créée en l'appelant comme un constructeur (ou en appelant newCible si elle est fournie) avec les arguments fournis.

Exceptions levées

Une exception {{jsxref("TypeError")}} si cible ou newCible ne sont pas des constructeurs.

Description

Reflect.construct() permet d'appeler un constructeur avec un nombre d'arguments variable (ce qui peut également être fait avec l'opérateur de décomposition et l'opérateur new).

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

Exemples

Utiliser `Reflect.construct()`

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

Utiliser le paramètre `newCible`

Pour plus d'informations sur la création de sous-classes, voir les classes et l'opérateur new.target.

function unConstructeur() {}
var résultat = Reflect.construct(Array, [], unConstructeur);

Reflect.getPrototypeOf(résultat); // unConstructeur.prototype
Array.isArray(résultat); // true

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

Avant l'apparition de Reflect, on pouvait construire des objets avec une combinaison donnée de consttructeur et de prototype grâce à {{jsxref("Object.create()")}}.

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

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

// Avec cette instruction :
var obj1 = Reflect.construct(MaClasseA, args, MaClasseB);

// on aura le même résultat qu'avec
var 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 résultats sont identiques, il y a une différence notable. Lorsqu'on utilise Object.create() et Function.prototype.apply(), l'opérateur new.target pointe vers undefined dans la fonction utilisée comme constructeur car le mot-clé new n'est pas utilisé à la création de l'objet.

Mais quand on appelle Reflect.construct(), new.target pointe vers la valeur fournie par newCible si ce dernier est fourni ou vers cible sinon.

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

var obj1 = Reflect.construct(MaClasseA, args);
// Résultat :
//   MaClasseA
//   function MaClasseA { ... }

var obj2 = Reflect.construct(MaClasseA, args, MaClasseB);
// Résultat :
//   MaClasseA
//   function MaClasseB { ... }

var obj3 = Object.create(MaClasseB.prototype);
MaClasseA.apply(obj3, args);
// Résultat :
//     MaClasseA
//     undefined

Spécifications

Spécification	État	Commentaires
{{SpecName('ES2015', '#sec-reflect.construct', 'Reflect.construct')}}	{{Spec2('ES2015')}}	Définition initiale.
{{SpecName('ESDraft', '#sec-reflect.construct', 'Reflect.construct')}}	{{Spec2('ESDraft')}}

Compatibilité des navigateurs

Voir aussi

{{jsxref("Reflect")}}
new
new.target