Reflect.construct()
Baseline Widely available
This feature is well established and works across many devices and browser versions. It’s been available across browsers since September 2016.
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
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
. SinewCible
n'est pas présent, c'estcible
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
).
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 à 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
Specification |
---|
ECMAScript Language Specification # sec-reflect.construct |
Compatibilité des navigateurs
BCD tables only load in the browser