convert content to md

1 files changed, 60 insertions, 73 deletions

diff --git a/files/fr/web/javascript/reference/global_objects/reflect/construct/index.md b/files/fr/web/javascript/reference/global_objects/reflect/construct/index.md
index 3a53b1c6d8..cc19267c06 100644
--- a/files/fr/web/javascript/reference/global_objects/reflect/construct/index.md
+++ b/files/fr/web/javascript/reference/global_objects/reflect/construct/index.md
@@ -10,68 +10,70 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Reflect/construct
 original_slug: Web/JavaScript/Reference/Objets_globaux/Reflect/construct
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode statique <code><strong>Reflect</strong></code><strong><code>.construct()</code></strong> agit comme l'opérateur <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_new"><code>new</code></a> sous la forme d'une fonction. Elle est équivalente à <code>new cible(...args)</code> et permet d'indiquer un prototype différent.</p>
+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.
 
-<div>{{EmbedInteractiveExample("pages/js/reflect-construct.html")}}</div>
+{{EmbedInteractiveExample("pages/js/reflect-construct.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">Reflect.construct(cible, listeArguments[, newCible])
-</pre>
+    Reflect.construct(cible, listeArguments[, newCible])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>cible</code></dt>
- <dd>La fonction cible à appeler.</dd>
- <dt><code>listeArguments</code></dt>
- <dd>Un objet semblable à un tableau définissant les arguments à passer à <code>cible</code> lors de l'appel. Utiliser {{jsxref("null")}} ou {{jsxref("undefined")}} si aucun argument ne doit être fourni à la fonction.</dd>
- <dt><code>newCible</code> {{optional_inline}}</dt>
- <dd>Le constructeur dont le prototype devrait être utilisé. Voir également l'opérateur <code><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/new.target">new.target</a></code>. Si <code>newCible</code> n'est pas présent, c'est <code>cible</code> qui sera utilisé.</dd>
-</dl>
+- `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`](/fr/docs/Web/JavaScript/Reference/Opérateurs/new.target). Si `newCible` n'est pas présent, c'est `cible` qui sera utilisé.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un nouvelle instance de la cible indiquée, créée en l'appelant comme un constructeur (ou en appelant <code>newCible</code> si elle est fournie) avec les arguments fournis.</p>
+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.
 
-<h3 id="Exceptions_levées">Exceptions levées</h3>
+### Exceptions levées
 
-<p>Une exception {{jsxref("TypeError")}} si <code>cible</code> ou <code>newCible</code> ne sont pas des constructeurs.</p>
+Une exception {{jsxref("TypeError")}} si `cible` ou `newCible` ne sont pas des constructeurs.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p><code>Reflect.construct()</code> permet d'appeler un constructeur avec un nombre d'arguments variable (ce qui peut également être fait avec <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateur_de_décomposition">l'opérateur de décomposition</a> et l'opérateur <code><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_new">new</a></code>).</p>
+`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)).
 
-<pre class="brush: js">var obj = new Toto(...args);
-var obj = Reflect.construct(Toto, args);</pre>
+```js
+var obj = new Toto(...args);
+var obj = Reflect.construct(Toto, args);
+```
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_Reflect.construct()">Utiliser <code>Reflect.construct()</code></h3>
+### Utiliser `Reflect.construct()`
 
-<pre class="brush: js">var d = Reflect.construct(Date, [1776, 6, 4]);
+```js
+var d = Reflect.construct(Date, [1776, 6, 4]);
 d instanceof Date; // true
 d.getFullYear(); // 1776
-</pre>
+```
 
-<h3 id="Utiliser_le_paramètre_newCible">Utiliser le paramètre <code>newCible</code></h3>
+### Utiliser le paramètre `newCible`
 
-<p>Pour plus d'informations sur la création de sous-classes, voir les <a href="/fr/docs/Web/JavaScript/Reference/Classes">classes</a> et l'opérateur <code><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/new.target">new.target</a></code>.</p>
+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).
 
-<pre class="brush: js">function unConstructeur() {}
+```js
+function unConstructeur() {}
 var résultat = Reflect.construct(Array, [], unConstructeur);
 
 Reflect.getPrototypeOf(résultat); // unConstructeur.prototype
 Array.isArray(résultat); // true
-</pre>
+```
 
-<h3 id="Une_comparaison_entre_Reflect.construct()_et_Object.create()">Une comparaison entre <code>Reflect.construct()</code> et <code>Object.create()</code></h3>
+### Une comparaison entre `Reflect.construct()` et `Object.create()`
 
-<p>Avant l'apparition de <code>Reflect</code>, on pouvait construire des objets avec une combinaison donnée de consttructeur et de prototype grâce à {{jsxref("Object.create()")}}.</p>
+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()")}}.
 
-<pre class="brush: js">function MaClasseA() {
+```js
+function MaClasseA() {
   this.name = 'A';
 }
 
@@ -94,13 +96,14 @@ console.log(obj2 instanceof MaClasseA); // false
 
 console.log(obj1 instanceof MaClasseB); // true
 console.log(obj2 instanceof MaClasseB); // true
-</pre>
+```
 
-<p>Toutefois, si les résultats sont identiques, il y a une différence notable. Lorsqu'on utilise <code>Object.create()</code> et <code>Function.prototype.apply()</code>, l'opérateur <code>new.target</code> pointe vers <code>undefined</code> dans la fonction utilisée comme constructeur car le mot-clé <code>new</code> n'est pas utilisé à la création de l'objet.</p>
+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.
 
-<p>Mais quand on appelle <code>Reflect.construct()</code>, <code>new.target</code> pointe vers la valeur fournie par <code>newCible</code> si ce dernier est fourni ou vers <code>cible</code> sinon.</p>
+Mais quand on appelle `Reflect.construct()`, `new.target` pointe vers la valeur fournie par `newCible` si ce dernier est fourni ou vers `cible` sinon.
 
-<pre class="brush: js">function MaClasseA() {
+```js
+function MaClasseA() {
   console.log('MaClasseA');
   console.log(new.target);
 }
@@ -123,38 +126,22 @@ var obj3 = Object.create(MaClasseB.prototype);
 MaClasseA.apply(obj3, args);
 // Résultat :
 //     MaClasseA
-//     undefined</pre>
-
-<h2 id="Spécifications">Spécifications</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">État</th>
-   <th scope="col">Commentaires</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES2015', '#sec-reflect.construct', 'Reflect.construct')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-reflect.construct', 'Reflect.construct')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Reflect.construct")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Reflect")}}</li>
- <li><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_new"><code>new</code></a></li>
- <li><code><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/new.target">new.target</a></code></li>
-</ul>
+//     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)