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.

Exemple interactif

Syntaxe

js

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.

newCible Facultatif

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 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).

js

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

Exemples

Utiliser Reflect.construct()

js

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.

js

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 à Object.create().

js

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.

js

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

Specification
ECMAScript Language Specification
# sec-reflect.construct

Compatibilité des navigateurs

BCD tables only load in the browser

Voir aussi