1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
|
---
title: Reflect.construct()
slug: Web/JavaScript/Reference/Global_Objects/Reflect/construct
tags:
- ECMAScript 2015
- JavaScript
- Méthode
- Reference
- Reflect
translation_of: Web/JavaScript/Reference/Global_Objects/Reflect/construct
original_slug: Web/JavaScript/Reference/Objets_globaux/Reflect/construct
---
{{JSRef}}
La méthode statique **`Reflect.construct()`** agit comme l'opérateur [`new`](/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_new) sous la forme d'une fonction. Elle est équivalente à `new cible(...args)` et permet d'indiquer un prototype différent.
{{EmbedInteractiveExample("pages/js/reflect-construct.html")}}
## 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` {{optional_inline}}
- : Le constructeur dont le prototype devrait être utilisé. Voir également l'opérateur [`new.target`](/fr/docs/Web/JavaScript/Reference/Opérateurs/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](/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateur_de_décomposition) et l'opérateur [`new`](/fr/docs/Web/JavaScript/Reference/Opérateurs/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](/fr/docs/Web/JavaScript/Reference/Classes) et l'opérateur [`new.target`](/fr/docs/Web/JavaScript/Reference/Opérateurs/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 à {{jsxref("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
| 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
{{Compat("javascript.builtins.Reflect.construct")}}
## Voir aussi
- {{jsxref("Reflect")}}
- [`new`](/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_new)
- [`new.target`](/fr/docs/Web/JavaScript/Reference/Opérateurs/new.target)
|
