convert content to md

52 files changed, 2722 insertions, 3755 deletions

diff --git a/files/fr/web/javascript/reference/global_objects/string/@@iterator/index.md b/files/fr/web/javascript/reference/global_objects/string/@@iterator/index.md
index 0a01613d9f..38ea873740 100644
--- a/files/fr/web/javascript/reference/global_objects/string/@@iterator/index.md
+++ b/files/fr/web/javascript/reference/global_objects/string/@@iterator/index.md
@@ -12,35 +12,37 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/String/@@iterator
 original_slug: Web/JavaScript/Reference/Objets_globaux/String/@@iterator
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>[@@iterator]()</code></strong> renvoie un nouvel objet <code><a href="/fr/docs/Web/JavaScript/Guide/Le_protocole_iterator">Iterator</a></code> qui itère sur les points de code (codets) d'une chaîne de caractères, en renvoyant chaque point de code sous forme d'une chaîne de caractères.</p>
+La méthode **`[@@iterator]()`** renvoie un nouvel objet [`Iterator`](/fr/docs/Web/JavaScript/Guide/Le_protocole_iterator) qui itère sur les points de code (codets) d'une chaîne de caractères, en renvoyant chaque point de code sous forme d'une chaîne de caractères.
 
-<div>{{EmbedInteractiveExample("pages/js/string-iterator.html")}}</div>
+{{EmbedInteractiveExample("pages/js/string-iterator.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>chaîneDeCaractères</var>[Symbol.iterator]</pre>
+    chaîneDeCaractères[Symbol.iterator]
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un nouvel objet <code>Iterator</code>.</p>
+Un nouvel objet `Iterator`.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_iterator()">Utiliser <code>[@@iterator]()</code></h3>
+### Utiliser `[@@iterator]()`
 
-<pre class="brush:js">var chaîne = "A\uD835\uDC68";
+```js
+var chaîne = "A\uD835\uDC68";
 
 var chaîneIter = chaîne[Symbol.iterator]();
 
 console.log(chaîneIter.next().value); // "A"
 console.log(chaîneIter.next().value); // "\uD835\uDC68"
-</pre>
+```
 
-<h3 id="Utiliser_iterator()_avec_une_boucle_for..of">Utiliser <code>[@@iterator]()</code> avec une boucle <code>for..of</code></h3>
+### Utiliser `[@@iterator]()` avec une boucle `for..of`
 
-<pre class="brush:js">var chaine = "A\uD835\uDC68B\uD835\uDC69C\uD835\uDC6A";
+```js
+var chaine = "A\uD835\uDC68B\uD835\uDC69C\uD835\uDC6A";
 
 for (var c of chaine) {
   console.log(c);
@@ -51,36 +53,19 @@ for (var c of chaine) {
 // "\uD835\uDC69"
 // "C"
 // "\uD835\uDC6A"
-</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-string.prototype-@@iterator', 'String.prototype[@@iterator]()')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-string.prototype-@@iterator', 'String.prototype[@@iterator]()')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.String.@@iterator")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li><a href="/fr/docs/Web/JavaScript/Reference/Les_protocoles_iteration">Les protocoles d'itération</a></li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                                | État                         | Commentaires         |
+| ---------------------------------------------------------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ES2015', '#sec-string.prototype-@@iterator', 'String.prototype[@@iterator]()')}} | {{Spec2('ES2015')}}     | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-string.prototype-@@iterator', 'String.prototype[@@iterator]()')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.String.@@iterator")}}
+
+## Voir aussi
+
+- [Les protocoles d'itération](/fr/docs/Web/JavaScript/Reference/Les_protocoles_iteration)
diff --git a/files/fr/web/javascript/reference/global_objects/string/anchor/index.md b/files/fr/web/javascript/reference/global_objects/string/anchor/index.md
index f4ca8bb868..6d235268f4 100644
--- a/files/fr/web/javascript/reference/global_objects/string/anchor/index.md
+++ b/files/fr/web/javascript/reference/global_objects/string/anchor/index.md
@@ -11,75 +11,65 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/String/anchor
 original_slug: Web/JavaScript/Reference/Objets_globaux/String/anchor
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>anchor()</strong></code> permet de créer une ancre HTML {{HTMLElement("a")}} qui est utilisé comme cible hypertexte.</p>
+La méthode **`anchor()`** permet de créer une ancre HTML {{HTMLElement("a")}} qui est utilisé comme cible hypertexte.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>str</var>.anchor(<var>name</var>)</pre>
+    str.anchor(name)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>name</code></dt>
- <dd>Une chaîne de caractères représentant l'attribut <code>name</code> de la balise à créér.</dd>
-</dl>
+- `name`
+  - : Une chaîne de caractères représentant l'attribut `name` de la balise à créér.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une chaîne de caractères qui représente un élément HTML {{HTMLElement("a")}}.</p>
+Une chaîne de caractères qui représente un élément HTML {{HTMLElement("a")}}.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>On utilise la méthode <code>anchor()</code> pour créer et afficher des ancres dans un document HTML à l'aide de JavaScript.</p>
+On utilise la méthode `anchor()` pour créer et afficher des ancres dans un document HTML à l'aide de JavaScript.
 
-<p>Ici la chaîne représente le texte que verra l'utilisateur. Le paramètre <code>name</code> représente l'attribut <code>name</code> de l'élément {{HTMLElement("a")}}.</p>
+Ici la chaîne représente le texte que verra l'utilisateur. Le paramètre `name` représente l'attribut `name` de l'élément {{HTMLElement("a")}}.
 
-<p>Les ancres créées avec la méthode <code>anchor</code> deviennent des éléments accessibles à travers le tableau {{domxref("document.anchors")}}.</p>
+Les ancres créées avec la méthode `anchor` deviennent des éléments accessibles à travers le tableau {{domxref("document.anchors")}}.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<pre class="brush:js">var maChaîne = "Table des matières";
+```js
+var maChaîne = "Table des matières";
 
-document.body.innerHTML = maChaîne.anchor("ancre_contenu");</pre>
+document.body.innerHTML = maChaîne.anchor("ancre_contenu");
+```
 
-<p>produira le code HTML suivant :</p>
+produira le code HTML suivant :
 
-<pre class="brush: html">&lt;a name="ancre_contenu"&gt;Table des matières&lt;/a&gt;</pre>
+```html
+<a name="ancre_contenu">Table des matières</a>
+```
 
-<h2 id="Prothèse_d'émulation_(polyfill)">Prothèse d'émulation (<em>polyfill</em>)</h2>
+## Prothèse d'émulation (_polyfill_)
 
-<pre class="brush: js">if (!String.prototype.anchor){
+```js
+if (!String.prototype.anchor){
   String.prototype.anchor = function(x){
-    return '&lt;a name="' + x + '"&gt;' + this + '&lt;/a&gt;'
+    return '<a name="' + x + '">' + this + '</a>'
   };
 }
-</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('ES6', '#sec-string.prototype.anchor', 'String.prototype.anchor')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Définition initiale. Implémentée avec JavaScript 1.0. Défini dans l'annexe (normative) B sur les fonctionnalités additionnelles des navigateurs web.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.String.anchor")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("String.prototype.link()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                            | État                 | Commentaires                                                                                                                                         |
+| -------------------------------------------------------------------------------------------------------- | -------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- |
+| {{SpecName('ES6', '#sec-string.prototype.anchor', 'String.prototype.anchor')}} | {{Spec2('ES6')}} | Définition initiale. Implémentée avec JavaScript 1.0. Défini dans l'annexe (normative) B sur les fonctionnalités additionnelles des navigateurs web. |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.String.anchor")}}
+
+## Voir aussi
+
+- {{jsxref("String.prototype.link()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/string/big/index.md b/files/fr/web/javascript/reference/global_objects/string/big/index.md
index 0cefdf7fab..ab956a9e8d 100644
--- a/files/fr/web/javascript/reference/global_objects/string/big/index.md
+++ b/files/fr/web/javascript/reference/global_objects/string/big/index.md
@@ -11,70 +11,55 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/String/big
 original_slug: Web/JavaScript/Reference/Objets_globaux/String/big
 ---
-<div>{{JSRef}}{{deprecated_header}}</div>
+{{JSRef}}{{deprecated_header}}
 
-<p>La méthode <code><strong>big()</strong></code> crée un élément HTML {{HTMLElement("big")}} qui affichera la chaine de caractères avec une taille de police importante.</p>
+La méthode **`big()`** crée un élément HTML {{HTMLElement("big")}} qui affichera la chaine de caractères avec une taille de police importante.
 
-<div class="note">
-<p><strong>Note :</strong> L'élément <code>&lt;big&gt;</code> a été retiré de <a href="/fr/docs/Web/Guide/HTML/HTML5">HTML5</a> et ne doit pas être utilisé. À la place, les développeurs web doivent utiliser les propriétés <a href="/fr/docs/Web/CSS">CSS</a>.</p>
-</div>
+> **Note :** L'élément `<big>` a été retiré de [HTML5](/fr/docs/Web/Guide/HTML/HTML5) et ne doit pas être utilisé. À la place, les développeurs web doivent utiliser les propriétés [CSS](/fr/docs/Web/CSS).
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>str</var>.big()</pre>
+    str.big()
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une chaîne de caractères qui représente un élément HTML {{HTMLElement("big")}}.</p>
+Une chaîne de caractères qui représente un élément HTML {{HTMLElement("big")}}.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La méthode <code>big()</code> place la chaine de caractères dans une balise <code>&lt;big&gt;</code> :<br>
- <code>"&lt;big&gt;str&lt;/big&gt;</code>"</p>
+La méthode `big()` place la chaine de caractères dans une balise `<big>` :
+`"<big>str</big>`"
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<p>L'exemple suivant montre les méthodes de <code>String</code> pour changer la taille d'une chaine de caractères :</p>
+L'exemple suivant montre les méthodes de `String` pour changer la taille d'une chaine de caractères :
 
-<pre class="brush:js">var chaîneMonde = "Coucou monde";
+```js
+var chaîneMonde = "Coucou monde";
 
-console.log( chaîneMonde.small()     ); // &lt;small&gt;Coucou monde&lt;/small&gt;
-console.log( chaîneMonde.big()       ); // &lt;big&gt;Coucou monde&lt;/big&gt;
-console.log( chaîneMonde.fontsize(7) ); // &lt;fontsize=7&gt;Coucou monde&lt;/fontsize&gt;</pre>
+console.log( chaîneMonde.small()     ); // <small>Coucou monde</small>
+console.log( chaîneMonde.big()       ); // <big>Coucou monde</big>
+console.log( chaîneMonde.fontsize(7) ); // <fontsize=7>Coucou monde</fontsize>
+```
 
-<p>Avec l'objet {{domxref("HTMLElement.style", "element.style")}}, il est possible d'accéder à l'attribut <code>style</code> de l'élément et de le manipuler. Par exemple :</p>
+Avec l'objet {{domxref("HTMLElement.style", "element.style")}}, il est possible d'accéder à l'attribut `style` de l'élément et de le manipuler. Par exemple :
 
-<pre class="brush: js">document.getElementById('idÉlément').style.fontSize = '2em'</pre>
+```js
+document.getElementById('idÉlément').style.fontSize = '2em'
+```
 
-<h2 id="Spécifications">Spécifications</h2>
+## Spécifications
 
-<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('ES6', '#sec-string.prototype.big', 'String.prototype.big')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Définition initiale. Implémentée dans JavaScript 1.0. Définie dans l'annexe normative pour les fonctionnalités supplémentaires des navigateurs web.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-string.prototype.big', 'String.prototype.big')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td>Définie dans l'annexe B (normative) pour les fonctionnalités ECMAScript supplémentaires des navigateurs web.</td>
-  </tr>
- </tbody>
-</table>
+| Spécification                                                                                        | État                         | Commentaires                                                                                                                                        |
+| ---------------------------------------------------------------------------------------------------- | ---------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------- |
+| {{SpecName('ES6', '#sec-string.prototype.big', 'String.prototype.big')}}     | {{Spec2('ES6')}}         | Définition initiale. Implémentée dans JavaScript 1.0. Définie dans l'annexe normative pour les fonctionnalités supplémentaires des navigateurs web. |
+| {{SpecName('ESDraft', '#sec-string.prototype.big', 'String.prototype.big')}} | {{Spec2('ESDraft')}} | Définie dans l'annexe B (normative) pour les fonctionnalités ECMAScript supplémentaires des navigateurs web.                                        |
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.String.big")}}</p>
+{{Compat("javascript.builtins.String.big")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("String.prototype.fontsize()")}}</li>
- <li>{{jsxref("String.prototype.small()")}}</li>
-</ul>
+- {{jsxref("String.prototype.fontsize()")}}
+- {{jsxref("String.prototype.small()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/string/blink/index.md b/files/fr/web/javascript/reference/global_objects/string/blink/index.md
index a57014d354..c73d979e49 100644
--- a/files/fr/web/javascript/reference/global_objects/string/blink/index.md
+++ b/files/fr/web/javascript/reference/global_objects/string/blink/index.md
@@ -12,73 +12,60 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/String/blink
 original_slug: Web/JavaScript/Reference/Objets_globaux/String/blink
 ---
-<div>{{JSRef}}{{deprecated_header}}</div>
+{{JSRef}}{{deprecated_header}}
 
-<p>La méthode <code><strong>blink()</strong></code> crée un élément HTML {{HTMLElement("blink")}} qui affiche la chaine de caractères en clignotant.</p>
+La méthode **`blink()`** crée un élément HTML {{HTMLElement("blink")}} qui affiche la chaine de caractères en clignotant.
 
-<div class="warning"><p><strong>Attention :</strong> Les textes clignotants sont fortement déconseillés par de nombreux standards d'accessibilité. L'élément <code>&lt;blink&gt;</code> est lui-même non standard et obsolète !</p></div>
+> **Attention :** Les textes clignotants sont fortement déconseillés par de nombreux standards d'accessibilité. L'élément `<blink>` est lui-même non standard et obsolète !
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>str</var>.blink()</pre>
+    str.blink()
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une chaine de caractères représentant un élément HTML {{HTMLElement("blink")}}.</p>
+Une chaine de caractères représentant un élément HTML {{HTMLElement("blink")}}.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La méthode <code>blink()</code> place la chaine de caractères dans une balise <code>&lt;blink&gt;</code> :<br>
- <code>"&lt;blink&gt;str&lt;/blink&gt;</code>"</p>
+La méthode `blink()` place la chaine de caractères dans une balise `<blink>` :
+`"<blink>str</blink>`"
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<p>L'exemple suivant utilise des méthodes de <code>String</code> pour changer l'affichage d'une chaine de caractères :</p>
+L'exemple suivant utilise des méthodes de `String` pour changer l'affichage d'une chaine de caractères :
 
-<pre class="brush:js">var chaîneMonde = "Coucou monde";
+```js
+var chaîneMonde = "Coucou monde";
 
 console.log(chaîneMonde.blink());
 console.log(chaîneMonde.bold());
 console.log(chaîneMonde.italics());
-console.log(chaîneMonde.strike());</pre>
-
-<p>Cet exemple produira le code HTML suivant :</p>
-
-<pre class="brush:html">&lt;blink&gt;Coucou monde&lt;/blink&gt;
-&lt;b&gt;Coucou monde&lt;/b&gt;
-&lt;i&gt;Coucou monde&lt;/i&gt;
-&lt;strike&gt;Coucou monde&lt;/strike&gt;</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('ES6', '#sec-string.prototype.blink', 'String.prototype.blink')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Définition initiale. Implémentée avec JavaScript 1.0. Définie dans l'annexe B (normative) pour les fonctionnalités additionnelles des navigateurs web.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-string.prototype.blink', 'String.prototype.blink')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td>Définie dans l'annexe B (normative) pour les fonctionnalités additionnelles des navigateurs web.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.String.blink")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("String.prototype.bold()")}}</li>
- <li>{{jsxref("String.prototype.italics()")}}</li>
- <li>{{jsxref("String.prototype.strike()")}}</li>
-</ul>
+console.log(chaîneMonde.strike());
+```
+
+Cet exemple produira le code HTML suivant :
+
+```html
+<blink>Coucou monde</blink>
+<b>Coucou monde</b>
+<i>Coucou monde</i>
+<strike>Coucou monde</strike>
+```
+
+## Spécifications
+
+| Spécification                                                                                                | État                         | Commentaires                                                                                                                                           |
+| ------------------------------------------------------------------------------------------------------------ | ---------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| {{SpecName('ES6', '#sec-string.prototype.blink', 'String.prototype.blink')}}         | {{Spec2('ES6')}}         | Définition initiale. Implémentée avec JavaScript 1.0. Définie dans l'annexe B (normative) pour les fonctionnalités additionnelles des navigateurs web. |
+| {{SpecName('ESDraft', '#sec-string.prototype.blink', 'String.prototype.blink')}} | {{Spec2('ESDraft')}} | Définie dans l'annexe B (normative) pour les fonctionnalités additionnelles des navigateurs web.                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.String.blink")}}
+
+## Voir aussi
+
+- {{jsxref("String.prototype.bold()")}}
+- {{jsxref("String.prototype.italics()")}}
+- {{jsxref("String.prototype.strike()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/string/bold/index.md b/files/fr/web/javascript/reference/global_objects/string/bold/index.md
index 956d34878d..63faf319aa 100644
--- a/files/fr/web/javascript/reference/global_objects/string/bold/index.md
+++ b/files/fr/web/javascript/reference/global_objects/string/bold/index.md
@@ -11,72 +11,58 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/String/bold
 original_slug: Web/JavaScript/Reference/Objets_globaux/String/bold
 ---
-<div>{{JSRef}}{{deprecated_header}}</div>
+{{JSRef}}{{deprecated_header}}
 
-<p>La méthode <code><strong>bold()</strong></code> crée un élément HTML {{HTMLElement("b")}} qui affiche la chaine de caractères en gras.</p>
+La méthode **`bold()`** crée un élément HTML {{HTMLElement("b")}} qui affiche la chaine de caractères en gras.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>str</var>.bold()</pre>
+    str.bold()
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une chaîne de caractères représentant un élément HTML {{HTMLElement("b")}}.</p>
+Une chaîne de caractères représentant un élément HTML {{HTMLElement("b")}}.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La méthode <code>bold()</code> place la chaine de caractères dans une balise <code>&lt;b&gt;</code> :<br>
- <code>"&lt;b&gt;str&lt;/b&gt;</code>"</p>
+La méthode `bold()` place la chaine de caractères dans une balise `<b>` :
+`"<b>str</b>`"
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<p>L'exemple suivant utilise des méthodes de <code>String</code> pour changer l'affichage de la chaine de caractères :</p>
+L'exemple suivant utilise des méthodes de `String` pour changer l'affichage de la chaine de caractères :
 
-<pre class="brush:js">var chaîneMonde = "Coucou monde";
+```js
+var chaîneMonde = "Coucou monde";
 
 console.log( chaîneMonde.blink()   );
 console.log( chaîneMonde.bold()    );
 console.log( chaîneMonde.italics() );
-console.log( chaîneMonde.strike()  );</pre>
-
-<p>Cet exemple produit le même HTML que le code suivant :</p>
-
-<pre class="brush:html">&lt;blink&gt;Coucou monde&lt;/blink&gt;
-&lt;b&gt;Coucou monde&lt;/b&gt;
-&lt;i&gt;Coucou monde&lt;/i&gt;
-&lt;strike&gt;Coucou monde&lt;/strike&gt;
-</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('ES6', '#sec-string.prototype.bold', 'String.prototype.bold')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Définition initiale. Implémentée avec JavaScript 1.0. Définie dans l'annexe B (normative) pour les fonctionnalités additionnelles des navigateurs web.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-string.prototype.bold', 'String.prototype.bold')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td>Définie dans l'annexe B (normative) pour les fonctionnalités additionnelles des navigateurs web.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.String.bold")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("String.prototype.blink()")}}</li>
- <li>{{jsxref("String.prototype.italics()")}}</li>
- <li>{{jsxref("String.prototype.strike()")}}</li>
-</ul>
+console.log( chaîneMonde.strike()  );
+```
+
+Cet exemple produit le même HTML que le code suivant :
+
+```html
+<blink>Coucou monde</blink>
+<b>Coucou monde</b>
+<i>Coucou monde</i>
+<strike>Coucou monde</strike>
+```
+
+## Spécifications
+
+| Spécification                                                                                            | État                         | Commentaires                                                                                                                                           |
+| -------------------------------------------------------------------------------------------------------- | ---------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| {{SpecName('ES6', '#sec-string.prototype.bold', 'String.prototype.bold')}}     | {{Spec2('ES6')}}         | Définition initiale. Implémentée avec JavaScript 1.0. Définie dans l'annexe B (normative) pour les fonctionnalités additionnelles des navigateurs web. |
+| {{SpecName('ESDraft', '#sec-string.prototype.bold', 'String.prototype.bold')}} | {{Spec2('ESDraft')}} | Définie dans l'annexe B (normative) pour les fonctionnalités additionnelles des navigateurs web.                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.String.bold")}}
+
+## Voir aussi
+
+- {{jsxref("String.prototype.blink()")}}
+- {{jsxref("String.prototype.italics()")}}
+- {{jsxref("String.prototype.strike()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/string/charat/index.md b/files/fr/web/javascript/reference/global_objects/string/charat/index.md
index 63e8e2d422..5e6c4ef2b6 100644
--- a/files/fr/web/javascript/reference/global_objects/string/charat/index.md
+++ b/files/fr/web/javascript/reference/global_objects/string/charat/index.md
@@ -10,38 +10,37 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/String/charAt
 original_slug: Web/JavaScript/Reference/Objets_globaux/String/charAt
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>charAt()</strong></code> renvoie une nouvelle chaîne contenant le caractère (ou, plus précisément, le point de code UTF-16)  à la position indiquée en argument.</p>
+La méthode **`charAt()`** renvoie une nouvelle chaîne contenant le caractère (ou, plus précisément, le point de code UTF-16)  à la position indiquée en argument.
 
-<div>{{EmbedInteractiveExample("pages/js/string-charat.html")}}</div>
+{{EmbedInteractiveExample("pages/js/string-charat.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>str</var>.charAt(<var>index</var>)</pre>
+    str.charAt(index)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>index</code></dt>
- <dd>Un entier entre 0 et la longueur de la chaîne - 1. Si aucun index n'est fourni (ce qui correspond à fournir {{jsxref("undefined")}}) ou si l'index ne peut pas être converti en entier, la recherche sera effectuée à l'index 0 et le premier caractère sera donc renvoyé.</dd>
-</dl>
+- `index`
+  - : Un entier entre 0 et la longueur de la chaîne - 1. Si aucun index n'est fourni (ce qui correspond à fournir {{jsxref("undefined")}}) ou si l'index ne peut pas être converti en entier, la recherche sera effectuée à l'index 0 et le premier caractère sera donc renvoyé.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une chaîne de caractères qui représente le point de code UTF-16 à la position indiquée. Si la position est dehors de la chaîne, ce sera une chaîne vide.</p>
+Une chaîne de caractères qui représente le point de code UTF-16 à la position indiquée. Si la position est dehors de la chaîne, ce sera une chaîne vide.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Les caractères d'une chaîne sont indexés de la gauche vers la droite. L'indice du premier caractère est 0 et l'indice du dernier caractère est la longueur de la chaîne moins un (par exemple, si on a une chaîne <code>toto</code>, le dernier caractère de la chaine aura l'indice <code>toto.length - 1</code>). Si l'indice fourni est en dehors de cet intervalle, la méthode renverra une chaîne vide. Si aucun indice n'est fourni, la valeur par défaut utilisée sera 0.</p>
+Les caractères d'une chaîne sont indexés de la gauche vers la droite. L'indice du premier caractère est 0 et l'indice du dernier caractère est la longueur de la chaîne moins un (par exemple, si on a une chaîne `toto`, le dernier caractère de la chaine aura l'indice `toto.length - 1`). Si l'indice fourni est en dehors de cet intervalle, la méthode renverra une chaîne vide. Si aucun indice n'est fourni, la valeur par défaut utilisée sera 0.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Afficher_les_caractères_situés_à_différentes_positions_d'une_chaîne">Afficher les caractères situés à différentes positions d'une chaîne</h3>
+### Afficher les caractères situés à différentes positions d'une chaîne
 
-<p>L'exemple suivant affiche les caractères à différentes positions de la chaîne "<code>Coucou tout le monde</code>" :</p>
+L'exemple suivant affiche les caractères à différentes positions de la chaîne "`Coucou tout le monde`" :
 
-<pre class="brush:js">var uneChaîne = "Coucou tout le monde";
+```js
+var uneChaîne = "Coucou tout le monde";
 
 console.log("La caractère d'indice 0 est '" + uneChaîne.charAt(0)   + "'");
 console.log("La caractère d'indice 1 est '" + uneChaîne.charAt(1)   + "'");
@@ -49,24 +48,26 @@ console.log("La caractère d'indice 2 est '" + uneChaîne.charAt(2)   + "'");
 console.log("La caractère d'indice 3 est '" + uneChaîne.charAt(3)   + "'");
 console.log("La caractère d'indice 4 est '" + uneChaîne.charAt(4)   + "'");
 console.log("La caractère d'indice 999 est '" + uneChaîne.charAt(999) + "'");
-</pre>
+```
 
-<p>Ces lignes afficheront respectivement :</p>
+Ces lignes afficheront respectivement :
 
-<pre class="brush: js">La caractère d'indice 0 est 'C'
+```js
+La caractère d'indice 0 est 'C'
 La caractère d'indice 1 est 'o'
 La caractère d'indice 2 est 'u'
 La caractère d'indice 3 est 'c'
 La caractère d'indice 4 est 'o'
 La caractère d'indice 999 est ''
-</pre>
+```
 
-<h3 id="Obtenir_des_caractères_complets">Obtenir des caractères complets</h3>
+### Obtenir des caractères complets
 
-<p>Le code qui suit permet de s'assurer qu'on récupère des caractères complets et ce même si la chaîne de caractères contient des caractères en dehors du plan multilingue de base (BMP) (qui sont donc représentés sur deux unités de code/codets) :</p>
+Le code qui suit permet de s'assurer qu'on récupère des caractères complets et ce même si la chaîne de caractères contient des caractères en dehors du plan multilingue de base (BMP) (qui sont donc représentés sur deux unités de code/codets) :
 
-<pre class="brush:js">var str = 'A \uD87E\uDC04 Z'; // On pourrait aussi utiliser un caractère hors du BMP directement
-for (var i=0, chr; i &lt; str.length; i++) {
+```js
+var str = 'A \uD87E\uDC04 Z'; // On pourrait aussi utiliser un caractère hors du BMP directement
+for (var i=0, chr; i < str.length; i++) {
   if ((chr = getWholeChar(str, i)) === false) {
     continue;
   } // On adapte cette ligne pour chaque boucle, en passant la chaîne de caractères
@@ -81,24 +82,24 @@ function getWholeChar(str, i) {
   if (Number.isNaN(code)) {
     return ''; // la position n'a pas pu être trouvée
   }
-  if (code &lt; 0xD800 || code &gt; 0xDFFF) {
+  if (code < 0xD800 || code > 0xDFFF) {
     return str.charAt(i);
   }
 
   // On traite ici le demi codet supérieur (high surrogate)
   // La borne supérieure du test pourrait être 0xDB7F afin de prendre en compte
   // les demi-codets privés comme des caractères uniques
-  if (0xD800 &lt;= code &amp;&amp; code &lt;= 0xDBFF) {
-    if (str.length &lt;= (i+1))  {
+  if (0xD800 <= code && code <= 0xDBFF) {
+    if (str.length <= (i+1))  {
       throw 'le demi-codet supérieur n'est pas suivi par un demi-codet inférieur';
     }
     var next = str.charCodeAt(i+1);
-      if (0xDC00 &gt; next || next &gt; 0xDFFF) {
+      if (0xDC00 > next || next > 0xDFFF) {
         throw 'le demi-codet supérieur n'est pas suivi par un demi-codet inférieur';
       }
       return str.charAt(i)+str.charAt(i+1);
   }
-  // on gère le demi codet inférieur (0xDC00 &lt;= code &amp;&amp; code &lt;= 0xDFFF)
+  // on gère le demi codet inférieur (0xDC00 <= code && code <= 0xDFFF)
   if (i === 0) {
     throw 'le demi-codet inférieur n'est pas précédé d'un demi-codet supérieur';
   }
@@ -106,20 +107,20 @@ function getWholeChar(str, i) {
 
   // (la borne supérieure pourrait être modifiée en 0xDB7F afin de traiter
   // les demi-codets supérieurs privés comme des caractètres uniques)
-  if (0xD800 &gt; prev || prev &gt; 0xDBFF) {
+  if (0xD800 > prev || prev > 0xDBFF) {
     throw 'le demi-codet inférieur n'est pas précédé d'un demi-codet supérieur';
   }
   // on peut passer des demis codets inférieurs comme deuxième composant
   // d'une paire déjà traitée
   return false;
 }
+```
 
-</pre>
+Dans un environnement ECMAScript 2016 qui permet d'utiliser l'affectation par décomposition, on peut obtenir une version plus succincte et flexible :
 
-<p>Dans un environnement ECMAScript 2016 qui permet d'utiliser l'affectation par décomposition, on peut obtenir une version plus succincte et flexible :</p>
-
-<pre class="brush: js">var str = 'A\uD87E\uDC04Z'; // We could also use a non-BMP character directly
-for (var i=0, chr; i &lt; str.length; i++) {
+```js
+var str = 'A\uD87E\uDC04Z'; // We could also use a non-BMP character directly
+for (var i=0, chr; i < str.length; i++) {
   [chr, i] = getWholeCharAndI(str, i);
   // Adapt this line at the top of each loop, passing in the whole string and
   // the current iteration and returning an array with the individual character
@@ -134,23 +135,23 @@ function getWholeCharAndI(str, i) {
   if (Number.isNaN(code)) {
     return ''; // Position not found
   }
-  if (code &lt; 0xD800 || code &gt; 0xDFFF) {
+  if (code < 0xD800 || code > 0xDFFF) {
     return [str.charAt(i), i]; // Normal character, keeping 'i' the same
   }
 
   // High surrogate (could change last hex to 0xDB7F to treat high private
   // surrogates as single characters)
-  if (0xD800 &lt;= code &amp;&amp; code &lt;= 0xDBFF) {
-    if (str.length &lt;= (i+1))  {
+  if (0xD800 <= code && code <= 0xDBFF) {
+    if (str.length <= (i+1))  {
       throw 'High surrogate without following low surrogate';
     }
     var next = str.charCodeAt(i+1);
-      if (0xDC00 &gt; next || next &gt; 0xDFFF) {
+      if (0xDC00 > next || next > 0xDFFF) {
         throw 'High surrogate without following low surrogate';
       }
       return [str.charAt(i)+str.charAt(i+1), i+1];
   }
-  // Low surrogate (0xDC00 &lt;= code &amp;&amp; code &lt;= 0xDFFF)
+  // Low surrogate (0xDC00 <= code && code <= 0xDFFF)
   if (i === 0) {
     throw 'Low surrogate without preceding high surrogate';
   }
@@ -158,18 +159,20 @@ function getWholeCharAndI(str, i) {
 
   // (could change last hex to 0xDB7F to treat high private surrogates
   // as single characters)
-  if (0xD800 &gt; prev || prev &gt; 0xDBFF) {
+  if (0xD800 > prev || prev > 0xDBFF) {
     throw 'Low surrogate without preceding high surrogate';
   }
   // Return the next character instead (and increment)
   return [str.charAt(i+1), i+1];
-}</pre>
+}
+```
 
-<h3 id="Créer_une_version_de_charAt_qui_permet_de_supporter_des_caractères_hors_du_plan_basique_multilingue_(BMP)">Créer une version de <code>charAt</code> qui permet de supporter des caractères hors du plan basique multilingue (BMP)</h3>
+### Créer une version de `charAt` qui permet de supporter des caractères hors du plan basique multilingue (BMP)
 
-<p>Si on souhaite récupérer les paires de codets des caractères hors du plan classique, on peut utiliser le code suivant :</p>
+Si on souhaite récupérer les paires de codets des caractères hors du plan classique, on peut utiliser le code suivant :
 
-<pre class="brush: js">function fixedCharAt (str, idx) {
+```js
+function fixedCharAt (str, idx) {
   var ret = '';
   str += '';
   var end = str.length;
@@ -177,70 +180,46 @@ function getWholeCharAndI(str, i) {
   var surrogatePairs = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
   while ((surrogatePairs.exec(str)) != null) {
     var li = surrogatePairs.lastIndex;
-    if (li - 2 &lt; idx) {
+    if (li - 2 < idx) {
       idx++;
     } else {
       break;
     }
   }
 
-  if (idx &gt;= end || idx &lt; 0) {
+  if (idx >= end || idx < 0) {
     return '';
   }
 
   ret += str.charAt(idx);
 
-  if (/[\uD800-\uDBFF]/.test(ret) &amp;&amp; /[\uDC00-\uDFFF]/.test(str.charAt(idx+1))) {
+  if (/[\uD800-\uDBFF]/.test(ret) && /[\uDC00-\uDFFF]/.test(str.charAt(idx+1))) {
     // On avance d'un puisque l'un des caractères fait partie de la paire
     ret += str.charAt(idx+1);
   }
   return ret;
-}</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('ES1')}}</td>
-   <td>{{Spec2('ES1')}}</td>
-   <td>Définition initiale</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.5.4.4', 'String.prototype.charAt')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-string.prototype.charat', 'String.prototype.charAt')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-string.prototype.charat', 'String.prototype.charAt')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.String.charAt")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("String.prototype.indexOf()")}}</li>
- <li>{{jsxref("String.prototype.lastIndexOf()")}}</li>
- <li>{{jsxref("String.prototype.charCodeAt()")}}</li>
- <li>{{jsxref("String.prototype.codePointAt()")}}</li>
- <li>{{jsxref("String.prototype.split()")}}</li>
- <li>{{jsxref("String.fromCodePoint()")}}</li>
- <li><a href="https://mathiasbynens.be/notes/javascript-unicode">JavaScript a un problème avec Unicode</a>, billet de Mathias Bynens (en anglais)</li>
-</ul>
+}
+```
+
+## Spécifications
+
+| Spécification                                                                                                | État                         | Commentaires        |
+| ------------------------------------------------------------------------------------------------------------ | ---------------------------- | ------------------- |
+| {{SpecName('ES1')}}                                                                                     | {{Spec2('ES1')}}         | Définition initiale |
+| {{SpecName('ES5.1', '#sec-15.5.4.4', 'String.prototype.charAt')}}                     | {{Spec2('ES5.1')}}     |                     |
+| {{SpecName('ES6', '#sec-string.prototype.charat', 'String.prototype.charAt')}}     | {{Spec2('ES6')}}         |                     |
+| {{SpecName('ESDraft', '#sec-string.prototype.charat', 'String.prototype.charAt')}} | {{Spec2('ESDraft')}} |                     |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.String.charAt")}}
+
+## Voir aussi
+
+- {{jsxref("String.prototype.indexOf()")}}
+- {{jsxref("String.prototype.lastIndexOf()")}}
+- {{jsxref("String.prototype.charCodeAt()")}}
+- {{jsxref("String.prototype.codePointAt()")}}
+- {{jsxref("String.prototype.split()")}}
+- {{jsxref("String.fromCodePoint()")}}
+- [JavaScript a un problème avec Unicode](https://mathiasbynens.be/notes/javascript-unicode), billet de Mathias Bynens (en anglais)
diff --git a/files/fr/web/javascript/reference/global_objects/string/charcodeat/index.md b/files/fr/web/javascript/reference/global_objects/string/charcodeat/index.md
index 3b57bc337a..71b6ff4249 100644
--- a/files/fr/web/javascript/reference/global_objects/string/charcodeat/index.md
+++ b/files/fr/web/javascript/reference/global_objects/string/charcodeat/index.md
@@ -10,55 +10,53 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/String/charCodeAt
 original_slug: Web/JavaScript/Reference/Objets_globaux/String/charCodeAt
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>charCodeAt()</strong></code> retourne un entier compris entre 0 et 65535 qui correspond au code UTF-16 d'un caractère de la chaîne situé à une position donnée.</p>
+La méthode **`charCodeAt()`** retourne un entier compris entre 0 et 65535 qui correspond au code UTF-16 d'un caractère de la chaîne situé à une position donnée.
 
-<div>{{EmbedInteractiveExample("pages/js/string-charcodeat.html")}}</div>
+{{EmbedInteractiveExample("pages/js/string-charcodeat.html")}}
 
+Le codet UTF-16 renvoyé correspond au codet Unicode si le caractère peut être représenté sur un seul codet. Si le codet Unicode ne peut pas être représenté sur un seul codet UTF-16 (car sa valeur est supérieure à `0xFFFF`), seule la première partie de la paire sera renvoyée. Si vous souhaitez obtenir l'ensemble de la valeur, vous pouvez utiliser la méthode {{jsxref("String.prototype.codePointAt()","codePointAt()")}}.
 
+## Syntaxe
 
-<p>Le codet UTF-16 renvoyé correspond au codet Unicode si le caractère peut être représenté sur un seul codet. Si le codet Unicode ne peut pas être représenté sur un seul codet UTF-16 (car sa valeur est supérieure à <code>0xFFFF</code>), seule la première partie de la paire sera renvoyée. Si vous souhaitez obtenir l'ensemble de la valeur, vous pouvez utiliser la méthode {{jsxref("String.prototype.codePointAt()","codePointAt()")}}.</p>
+    str.charCodeAt(indice)
 
-<h2 id="Syntaxe">Syntaxe</h2>
+### Paramètres
 
-<pre class="syntaxbox notranslate"><var>str</var>.charCodeAt(<var>indice</var>)</pre>
+- `indice`
+  - : Un entier supérieur ou égal à zéro et strictement inférieur à la longueur de la chaîne. La valeur par défaut (si le paramètre est absent ou n'est pas un nombre) sera zéro (0).
 
-<h3 id="Paramètres">Paramètres</h3>
+### Valeur de retour
 
-<dl>
- <dt><code>indice</code></dt>
- <dd>Un entier supérieur ou égal à zéro et strictement inférieur à la longueur de la chaîne. La valeur par défaut (si le paramètre est absent ou n'est pas un nombre) sera zéro (0).</dd>
-</dl>
+Un nombre qui représente la valeur du point de code UTF-16 pour le caractère à la position indiquée. Si `index` pointe en dehors de la chaîne, ce sera {{jsxref("Objets_globaux/NaN","NaN")}} qui sera renvoyé.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+## Description
 
-<p>Un nombre qui représente la valeur du point de code UTF-16 pour le caractère à la position indiquée. Si <code>index</code> pointe en dehors de la chaîne, ce sera {{jsxref("Objets_globaux/NaN","NaN")}} qui sera renvoyé.</p>
+Les codets Unicode vont de 0 à 1 114 111 (0x10FFFF). Les 128 premiers caractères Unicode correspondent aux caractères ASCII (leur encodage est le même). Pour plus d'informations sur la gestion de l'Unicode en JavaScript, voir le [Guide JavaScript](/fr/docs/Web/JavaScript/Guide/Valeurs,_variables,_et_littéraux#Unicode).
 
-<h2 id="Description">Description</h2>
+La méthode `charCodeAt()` renverra toujours une valeur inférieure à 65 536. En effet, les caractères encodés sur les plus grandes valeurs sont encodés sur deux « demi-codets » (appelés _surrogate pair_ en anglais). Pour recomposer de tels caractères, il faut donc utiliser `charCodeAt(i)` **et aussi** `charCodeAt(i+1)` afin de pouvoir récupérer chaque demi-codet. Pour plus de détails, voir le deuxième et troisième exemples.
 
-<p>Les codets Unicode vont de 0 à 1 114 111 (0x10FFFF). Les 128 premiers caractères Unicode correspondent aux caractères ASCII (leur encodage est le même). Pour plus d'informations sur la gestion de l'Unicode en JavaScript, voir le <a href="/fr/docs/Web/JavaScript/Guide/Valeurs,_variables,_et_littéraux#Unicode">Guide JavaScript</a>.</p>
+`charCodeAt()` renverra {{jsxref("NaN")}} si l'indice fourni est strictement inférieur à 0 ou dépasse la longueur de la chaîne.
 
-<p>La méthode <code>charCodeAt()</code> renverra toujours une valeur inférieure à 65 536. En effet, les caractères encodés sur les plus grandes valeurs sont encodés sur deux « demi-codets » (appelés <em>surrogate pair</em> en anglais). Pour recomposer de tels caractères, il faut donc utiliser <code>charCodeAt(i)</code> <strong>et aussi</strong> <code>charCodeAt(i+1)</code> afin de pouvoir récupérer chaque demi-codet. Pour plus de détails, voir le deuxième et troisième exemples.</p>
+Dans les anciennes versions (JavaScript 1.2 par exemple) la méthode `charCodeAt()` renvoyait la valeur du caractère selon l'encodage ISO-Latin-1. L'encodage ISO-Latin-1 permet de représenter des caractères dont les valeurs vont de 0 à 255. Les valeurs 0 à 127 correspondent aux différentes valeurs ASCII.
 
-<p><code>charCodeAt()</code> renverra {{jsxref("NaN")}} si l'indice fourni est strictement inférieur à 0 ou dépasse la longueur de la chaîne.</p>
+## Exemples
 
-<p>Dans les anciennes versions (JavaScript 1.2 par exemple) la méthode <code>charCodeAt()</code> renvoyait la valeur du caractère selon l'encodage ISO-Latin-1. L'encodage ISO-Latin-1 permet de représenter des caractères dont les valeurs vont de 0 à 255. Les valeurs 0 à 127 correspondent aux différentes valeurs ASCII.</p>
+### Utiliser `charCodeAt()`
 
-<h2 id="Exemples">Exemples</h2>
+L'exemple suivant retourne 65, la valeur Unicode de A.
 
-<h3 id="Utiliser_charCodeAt">Utiliser <code>charCodeAt()</code></h3>
+```js
+"ABC".charCodeAt(0) // returns 65
+```
 
-<p>L'exemple suivant retourne 65, la valeur Unicode de A.</p>
+### Utiliser charCodeAt pour gérer les caractères hors du plan multilingue de base sans hypothèse sur leur présence
 
-<pre class="brush: js notranslate">"ABC".charCodeAt(0) // returns 65
-</pre>
+Cette fonction peut être utilisée dans des boucles ou autres dans les cas où on ne sait pas si des caractères représentés sur deux demi-codets (hors du plan BMP) existent avant la position indiquée.
 
-<h3 id="Utiliser_charCodeAt_pour_gérer_les_caractères_hors_du_plan_multilingue_de_base_sans_hypothèse_sur_leur_présence">Utiliser charCodeAt pour gérer les caractères hors du plan multilingue de base sans hypothèse sur leur présence</h3>
-
-<p>Cette fonction peut être utilisée dans des boucles ou autres dans les cas où on ne sait pas si des caractères représentés sur deux demi-codets (hors du plan BMP) existent avant la position indiquée.</p>
-
-<pre class="brush:js notranslate">function fixedCharCodeAt (str, idx) {
+```js
+function fixedCharCodeAt (str, idx) {
     // ex. fixedCharCodeAt ('\uD800\uDC00', 0); // 65536
     // ex. fixedCharCodeAt ('\uD800\uDC00', 1); // false
     idx = idx || 0;
@@ -68,7 +66,7 @@ original_slug: Web/JavaScript/Reference/Objets_globaux/String/charCodeAt
     // On gère le demi-codet supérieur (la borne supérieure
     // utilisée pourrait être 0xDB7F afin de traiter les
     // paires surrogates privées comme des caractères uniques)
-    if (0xD800 &lt;= code &amp;&amp; code &lt;= 0xDBFF) {
+    if (0xD800 <= code && code <= 0xDBFF) {
         hi = code;
         low = str.charCodeAt(idx+1);
         if (isNaN(low)) {
@@ -77,7 +75,7 @@ original_slug: Web/JavaScript/Reference/Objets_globaux/String/charCodeAt
         }
         return ((hi - 0xD800) * 0x400) + (low - 0xDC00) + 0x10000;
     }
-    if (0xDC00 &lt;= code &amp;&amp; code &lt;= 0xDFFF) {
+    if (0xDC00 <= code && code <= 0xDFFF) {
     // Demi-codet inférieur
 
         // On renvoie false pour permettre aux boucles
@@ -87,11 +85,12 @@ original_slug: Web/JavaScript/Reference/Objets_globaux/String/charCodeAt
     }
     return code;
 }
-</pre>
+```
 
-<h3 id="Utiliser_charCodeAt_pour_gérer_les_caractères_du_plan_multilingue_de_base_en_sachant_quils_sont_présents">Utiliser <code>charCodeAt()</code> pour gérer les caractères du plan multilingue de base (en sachant qu'ils sont présents)</h3>
+### Utiliser `charCodeAt()` pour gérer les caractères du plan multilingue de base (en sachant qu'ils sont présents)
 
-<pre class="brush:js notranslate">function knownCharCodeAt (str, idx) {
+```js
+function knownCharCodeAt (str, idx) {
     str += '';
     var code,
         end = str.length;
@@ -99,7 +98,7 @@ original_slug: Web/JavaScript/Reference/Objets_globaux/String/charCodeAt
     var surrogatePairs = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
     while ((surrogatePairs.exec(str)) != null) {
         var li = surrogatePairs.lastIndex;
-        if (li - 2 &lt; idx) {
+        if (li - 2 < idx) {
             idx++;
         }
         else {
@@ -107,14 +106,14 @@ original_slug: Web/JavaScript/Reference/Objets_globaux/String/charCodeAt
         }
     }
 
-    if (idx &gt;= end || idx &lt; 0) {
+    if (idx >= end || idx < 0) {
         return NaN;
     }
 
     code = str.charCodeAt(idx);
 
     var hi, low;
-    if (0xD800 &lt;= code &amp;&amp; code &lt;= 0xDBFF) {
+    if (0xD800 <= code && code <= 0xDBFF) {
         hi = code;
         low = str.charCodeAt(idx+1);
         // On prend un caractère de plus
@@ -123,50 +122,24 @@ original_slug: Web/JavaScript/Reference/Objets_globaux/String/charCodeAt
     }
     return code;
 }
+```
+
+## Spécifications
+
+| Spécification                                                                                                            | État                         | Commentaires                                          |
+| ------------------------------------------------------------------------------------------------------------------------ | ---------------------------- | ----------------------------------------------------- |
+| {{SpecName('ES1')}}                                                                                                 | {{Spec2('ES1')}}         | Définition initiale. Implémentée avec JavaScript 1.2. |
+| {{SpecName('ES5.1', '#sec-15.5.4.5', 'String.prototype.charCodeAt')}}                             | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-string.prototype.charcodeat', 'String.prototype.charCodeAt')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-string.prototype.charcodeat', 'String.prototype.charCodeAt')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.String.charCodeAt")}}
+
+## Voir aussi
 
-</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('ES1')}}</td>
-   <td>{{Spec2('ES1')}}</td>
-   <td>Définition initiale. Implémentée avec JavaScript 1.2.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.5.4.5', 'String.prototype.charCodeAt')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-string.prototype.charcodeat', 'String.prototype.charCodeAt')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-string.prototype.charcodeat', 'String.prototype.charCodeAt')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.String.charCodeAt")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("String.fromCharCode()")}}</li>
- <li>{{jsxref("String.prototype.charAt()")}}</li>
- <li>{{jsxref("String.fromCodePoint()")}}</li>
- <li>{{jsxref("String.prototype.codePointAt()")}}</li>
-</ul>
+- {{jsxref("String.fromCharCode()")}}
+- {{jsxref("String.prototype.charAt()")}}
+- {{jsxref("String.fromCodePoint()")}}
+- {{jsxref("String.prototype.codePointAt()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/string/codepointat/index.md b/files/fr/web/javascript/reference/global_objects/string/codepointat/index.md
index d461d2917d..8f6b9a9827 100644
--- a/files/fr/web/javascript/reference/global_objects/string/codepointat/index.md
+++ b/files/fr/web/javascript/reference/global_objects/string/codepointat/index.md
@@ -12,44 +12,44 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/String/codePointAt
 original_slug: Web/JavaScript/Reference/Objets_globaux/String/codePointAt
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>codePointAt()</strong></code> renvoie un entier positif qui correspond au code Unicode (<em>code point</em>) du caractère de la chaîne à la position donnée.</p>
+La méthode **`codePointAt()`** renvoie un entier positif qui correspond au code Unicode (_code point_) du caractère de la chaîne à la position donnée.
 
-<div>{{EmbedInteractiveExample("pages/js/string-codepointat.html")}}</div>
+{{EmbedInteractiveExample("pages/js/string-codepointat.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>str</var>.codePointAt(<var>pos</var>)</pre>
+    str.codePointAt(pos)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>pos</code></dt>
- <dd>La position de l'élément dans la chaîne de caractères dont on souhaite obtenir la valeur du codet.</dd>
-</dl>
+- `pos`
+  - : La position de l'élément dans la chaîne de caractères dont on souhaite obtenir la valeur du codet.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un nombre qui représente la valeur du point de code du caractère à la position indiqué. C'est la valeur {{jsxref("undefined")}} qui est renvoyée s'il n'y aucun élément à <code>pos</code>.</p>
+Un nombre qui représente la valeur du point de code du caractère à la position indiqué. C'est la valeur {{jsxref("undefined")}} qui est renvoyée s'il n'y aucun élément à `pos`.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>S'il n'y a pas d'élément à la position donnée, la valeur renvoyée sera {{jsxref("undefined")}}. Si ce n'est pas un élément représenté sur deux demi-codets (<em>surrogate pair</em>) UTF-16 et qui commence à <code>pos</code>, le codet de l'élément à l'indice <code>pos</code> est renvoyé.</p>
+S'il n'y a pas d'élément à la position donnée, la valeur renvoyée sera {{jsxref("undefined")}}. Si ce n'est pas un élément représenté sur deux demi-codets (_surrogate pair_) UTF-16 et qui commence à `pos`, le codet de l'élément à l'indice `pos` est renvoyé.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<pre class="brush: js">'ABC'.codePointAt(1);          // 66
+```js
+'ABC'.codePointAt(1);          // 66
 '\uD800\uDC00'.codePointAt(0); // 65536
 
 'XYZ'.codePointAt(42); // undefined
-</pre>
+```
 
-<h2 id="Prothèse_d'émulation_(polyfill)">Prothèse d'émulation (<em>polyfill</em>)</h2>
+## Prothèse d'émulation (_polyfill_)
 
-<p>Le fragment de code suivant permet d'ajouter la méthode <code>codePointAt()</code> pour les chaînes de caractères (<code>String</code>). En effet, cette méthode fait partie de ECMAScript 2015 et certains navigateurs peuvent ne pas proposer cette fonction nativement.</p>
+Le fragment de code suivant permet d'ajouter la méthode `codePointAt()` pour les chaînes de caractères (`String`). En effet, cette méthode fait partie de ECMAScript 2015 et certains navigateurs peuvent ne pas proposer cette fonction nativement.
 
-<pre class="brush:js">/*! https://mths.be/codepointat v0.2.0 by @mathias */
+```js
+/*! https://mths.be/codepointat v0.2.0 by @mathias */
 if (!String.prototype.codePointAt) {
   (function() {
     'use strict'; // needed to support `apply`/`call` with `undefined`/`null`
@@ -58,7 +58,7 @@ if (!String.prototype.codePointAt) {
       try {
         var object = {};
         var $defineProperty = Object.defineProperty;
-        var result = $defineProperty(object, object, object) &amp;&amp; $defineProperty;
+        var result = $defineProperty(object, object, object) && $defineProperty;
       } catch(error) {}
       return result;
     }());
@@ -74,18 +74,18 @@ if (!String.prototype.codePointAt) {
         index = 0;
       }
       // Account for out-of-bounds indices:
-      if (index &lt; 0 || index &gt;= size) {
+      if (index < 0 || index >= size) {
         return undefined;
       }
       // Get the first code unit
       var first = string.charCodeAt(index);
       var second;
       if ( // check if it’s the start of a surrogate pair
-        first &gt;= 0xD800 &amp;&amp; first &lt;= 0xDBFF &amp;&amp; // high surrogate
-        size &gt; index + 1 // there is a next code unit
+        first >= 0xD800 && first <= 0xDBFF && // high surrogate
+        size > index + 1 // there is a next code unit
       ) {
         second = string.charCodeAt(index + 1);
-        if (second &gt;= 0xDC00 &amp;&amp; second &lt;= 0xDFFF) { // low surrogate
+        if (second >= 0xDC00 && second <= 0xDFFF) { // low surrogate
           // https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
           return (first - 0xD800) * 0x400 + second - 0xDC00 + 0x10000;
         }
@@ -103,39 +103,22 @@ if (!String.prototype.codePointAt) {
     }
   }());
 }
-</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-string.prototype.codepointat', 'String.prototype.codePointAt')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-string.prototype.codepointat', 'String.prototype.codePointAt')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.String.codePointAt")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("String.fromCodePoint()")}}</li>
- <li>{{jsxref("String.fromCharCode()")}}</li>
- <li>{{jsxref("String.prototype.charCodeAt()")}}</li>
- <li>{{jsxref("String.prototype.charAt()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                                | État                         | Commentaires         |
+| ---------------------------------------------------------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ES2015', '#sec-string.prototype.codepointat', 'String.prototype.codePointAt')}}     | {{Spec2('ES2015')}}     | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-string.prototype.codepointat', 'String.prototype.codePointAt')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.String.codePointAt")}}
+
+## Voir aussi
+
+- {{jsxref("String.fromCodePoint()")}}
+- {{jsxref("String.fromCharCode()")}}
+- {{jsxref("String.prototype.charCodeAt()")}}
+- {{jsxref("String.prototype.charAt()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/string/concat/index.md b/files/fr/web/javascript/reference/global_objects/string/concat/index.md
index 8958a7491f..10583c89a1 100644
--- a/files/fr/web/javascript/reference/global_objects/string/concat/index.md
+++ b/files/fr/web/javascript/reference/global_objects/string/concat/index.md
@@ -10,36 +10,35 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/String/concat
 original_slug: Web/JavaScript/Reference/Objets_globaux/String/concat
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>concat()</strong></code> combine le texte de plusieurs chaînes avec la chaîne appelante et renvoie la nouvelle chaîne ainsi formée.</p>
+La méthode **`concat()`** combine le texte de plusieurs chaînes avec la chaîne appelante et renvoie la nouvelle chaîne ainsi formée.
 
-<div>{{EmbedInteractiveExample("pages/js/string-concat.html")}}</div>
+{{EmbedInteractiveExample("pages/js/string-concat.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox notranslate"><var>str</var>.concat(<var>string2</var>[, <var>string</var>3, ..., <var>stringN</var>])</pre>
+    str.concat(string2[, string3, ..., stringN])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>string2...string<em>N</em></code></dt>
- <dd>Chaînes de caractères à concaténer ensemble.</dd>
-</dl>
+- `string2...stringN`
+  - : Chaînes de caractères à concaténer ensemble.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une nouvelle chaîne de caractères qui contient la concaténation des chaînes de caractères fournies.</p>
+Une nouvelle chaîne de caractères qui contient la concaténation des chaînes de caractères fournies.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La fonction <code>concat()</code> renvoie une nouvelle chaîne correspondant à la concaténation des différents arguments avec la chaîne courante. La chaîne courante est celle sur laquelle a été appelée la méthode <code>concat()</code>. Si les valeurs passées en arguments ne sont pas des chaînes de caractères, elles sont automatiquement converties en chaînes (grâce à leur méthode <code>toString()</code> avant la concaténation).</p>
+La fonction `concat()` renvoie une nouvelle chaîne correspondant à la concaténation des différents arguments avec la chaîne courante. La chaîne courante est celle sur laquelle a été appelée la méthode `concat()`. Si les valeurs passées en arguments ne sont pas des chaînes de caractères, elles sont automatiquement converties en chaînes (grâce à leur méthode `toString()` avant la concaténation).
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<p>L'exemple suivant combine plusieurs chaînes afin d'en former une nouvelle.</p>
+L'exemple suivant combine plusieurs chaînes afin d'en former une nouvelle.
 
-<pre class="brush: js notranslate">var coucou = "Bonjour ";
+```js
+var coucou = "Bonjour ";
 console.log(coucou.concat("Tristan,", " bonne journée."));
 
 /* Bonjour Tristan, bonne journée. */
@@ -52,52 +51,26 @@ var salutation = ['Bonjour', ' ', 'Alfred', ' ', '!'];
 "".concat(null); // "null"
 "".concat(true); // "true"
 "".concat(4, 5); // "45"
+```
 
-</pre>
-
-<h2 id="Performance">Performance</h2>
-
-<p>Il est fortement recommandé d'utiliser les {{jsxref("Opérateurs/Opérateurs_d_affectation", "opérateurs d'affectation", "", 1)}} (+, +=) plutôt que la méthode <code>concat()</code> pour des raisons de performance.</p>
-
-<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('ES3')}}</td>
-   <td>{{Spec2('ES3')}}</td>
-   <td>Définition initiale. Implémentée avec JavaScript 1.2.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.5.4.6', 'String.prototype.concat')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-string.prototype.concat', 'String.prototype.concat')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-string.prototype.concat', 'String.prototype.concat')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.String.concat")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Array.prototype.concat()")}}</li>
- <li>{{jsxref("Opérateurs/Opérateurs_d_affectation", "Les opérateurs d'affectation", "", 1)}}</li>
-</ul>
+## Performance
+
+Il est fortement recommandé d'utiliser les {{jsxref("Opérateurs/Opérateurs_d_affectation", "opérateurs d'affectation", "", 1)}} (+, +=) plutôt que la méthode `concat()` pour des raisons de performance.
+
+## Spécifications
+
+| Spécification                                                                                                | État                         | Commentaires                                          |
+| ------------------------------------------------------------------------------------------------------------ | ---------------------------- | ----------------------------------------------------- |
+| {{SpecName('ES3')}}                                                                                     | {{Spec2('ES3')}}         | Définition initiale. Implémentée avec JavaScript 1.2. |
+| {{SpecName('ES5.1', '#sec-15.5.4.6', 'String.prototype.concat')}}                     | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-string.prototype.concat', 'String.prototype.concat')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-string.prototype.concat', 'String.prototype.concat')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.String.concat")}}
+
+## Voir aussi
+
+- {{jsxref("Array.prototype.concat()")}}
+- {{jsxref("Opérateurs/Opérateurs_d_affectation", "Les opérateurs d'affectation", "", 1)}}
diff --git a/files/fr/web/javascript/reference/global_objects/string/endswith/index.md b/files/fr/web/javascript/reference/global_objects/string/endswith/index.md
index 170935fb6e..ce3dc39e2d 100644
--- a/files/fr/web/javascript/reference/global_objects/string/endswith/index.md
+++ b/files/fr/web/javascript/reference/global_objects/string/endswith/index.md
@@ -11,90 +11,73 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/String/endsWith
 original_slug: Web/JavaScript/Reference/Objets_globaux/String/endsWith
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>endsWith()</strong></code> renvoie un booléen indiquant si la chaine de caractères se termine par la chaine de caractères fournie en argument.</p>
+La méthode **`endsWith()`** renvoie un booléen indiquant si la chaine de caractères se termine par la chaine de caractères fournie en argument.
 
-<div>{{EmbedInteractiveExample("pages/js/string-endswith.html")}}</div>
+{{EmbedInteractiveExample("pages/js/string-endswith.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>str</var>.endsWith(chaîneRecherchée[, <var>position</var>]);</pre>
+    str.endsWith(chaîneRecherchée[, position]);
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>chaîneRecherchée</code></dt>
- <dd>Les caractères à rechercher à la fin de la chaine de caractères.</dd>
- <dt><code>position</code> {{optional_inline}}</dt>
- <dd>Paramètre optionnel. Permet de rechercher dans la chaine de caractères comme si elle faisait cette longueur ; par défaut il s'agit de la longueur de la chaine de caractères <code>chaîneRecherchée</code>. Si la valeur fournie est supérieure à la longueur de la chaine de caractères, elle ne sera pas prise en compte.</dd>
-</dl>
+- `chaîneRecherchée`
+  - : Les caractères à rechercher à la fin de la chaine de caractères.
+- `position` {{optional_inline}}
+  - : Paramètre optionnel. Permet de rechercher dans la chaine de caractères comme si elle faisait cette longueur ; par défaut il s'agit de la longueur de la chaine de caractères `chaîneRecherchée`. Si la valeur fournie est supérieure à la longueur de la chaine de caractères, elle ne sera pas prise en compte.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p><code>true</code> si la chaîne de caractères se termine par la sous-chaîne indiquée, <code>false</code> sinon.</p>
+`true` si la chaîne de caractères se termine par la sous-chaîne indiquée, `false` sinon.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Cette méthode permet de savoir si une chaine de caractères se termine avec une certaine chaine de caractères (comme les autres méthodes fonctionnant avec des chaînes de caractères, cette méthode est sensible à la casse).</p>
+Cette méthode permet de savoir si une chaine de caractères se termine avec une certaine chaine de caractères (comme les autres méthodes fonctionnant avec des chaînes de caractères, cette méthode est sensible à la casse).
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<pre class="brush:js;">var str = "Être, ou ne pas être : telle est la question.";
+```js
+var str = "Être, ou ne pas être : telle est la question.";
 
 console.log(str.endsWith("question."));     // true
 console.log(str.endsWith("pas être"));      // false
 console.log(str.endsWith("pas être", 20));  // true
-</pre>
+```
 
-<h2 id="Prothèse_d'émulation_(polyfill)">Prothèse d'émulation (<em>polyfill</em>)</h2>
+## Prothèse d'émulation (_polyfill_)
 
-<p>Cette méthode a été ajoutée dans la spécification ECMAScript 6 et peut ne pas être disponible dans toutes les implémentations de JavaScript. Cependant, il est possible d'émuler le comportement de <code>String.prototype.endsWith</code> avec le fragment de code suivant :</p>
+Cette méthode a été ajoutée dans la spécification ECMAScript 6 et peut ne pas être disponible dans toutes les implémentations de JavaScript. Cependant, il est possible d'émuler le comportement de `String.prototype.endsWith` avec le fragment de code suivant :
 
-<pre class="brush: js">if (!String.prototype.endsWith) {
+```js
+if (!String.prototype.endsWith) {
   String.prototype.endsWith = function(searchString, position) {
     var subjectString = this.toString();
-    if (typeof position !== 'number' || !isFinite(position) || Math.floor(position) !== position || position &gt; subjectString.length) {
+    if (typeof position !== 'number' || !isFinite(position) || Math.floor(position) !== position || position > subjectString.length) {
       position = subjectString.length;
     }
     position -= searchString.length;
     var lastIndex = subjectString.lastIndexOf(searchString, position);
-    return lastIndex !== -1 &amp;&amp; lastIndex === position;
+    return lastIndex !== -1 && lastIndex === position;
   };
 }
-</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('ES6', '#sec-string.prototype.endswith', 'String.prototype.endsWith')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-string.prototype.endswith', 'String.prototype.endsWith')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.String.endsWith")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("String.prototype.startsWith()")}}</li>
- <li>{{jsxref("String.prototype.includes()")}}</li>
- <li>{{jsxref("String.prototype.indexOf()")}}</li>
- <li>{{jsxref("String.prototype.lastIndexOf()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                        | État                         | Commentaires         |
+| -------------------------------------------------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ES6', '#sec-string.prototype.endswith', 'String.prototype.endsWith')}}         | {{Spec2('ES6')}}         | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-string.prototype.endswith', 'String.prototype.endsWith')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.String.endsWith")}}
+
+## Voir aussi
+
+- {{jsxref("String.prototype.startsWith()")}}
+- {{jsxref("String.prototype.includes()")}}
+- {{jsxref("String.prototype.indexOf()")}}
+- {{jsxref("String.prototype.lastIndexOf()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/string/fixed/index.md b/files/fr/web/javascript/reference/global_objects/string/fixed/index.md
index c014787858..482010f528 100644
--- a/files/fr/web/javascript/reference/global_objects/string/fixed/index.md
+++ b/files/fr/web/javascript/reference/global_objects/string/fixed/index.md
@@ -11,63 +11,47 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/String/fixed
 original_slug: Web/JavaScript/Reference/Objets_globaux/String/fixed
 ---
-<div>{{JSRef}}{{deprecated_header}}</div>
+{{JSRef}}{{deprecated_header}}
 
-<p>La méthode <code><strong>fixed()</strong></code> permet de créer un élément HTML {{HTMLElement("tt")}}, ce qui permet d'afficher le texte de la chaîne de caractère dans une fonte à chasse fixe.</p>
+La méthode **`fixed()`** permet de créer un élément HTML {{HTMLElement("tt")}}, ce qui permet d'afficher le texte de la chaîne de caractère dans une fonte à chasse fixe.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>str</var>.fixed()</pre>
+    str.fixed()
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une chaîne de caractères représentant un élément HTML {{HTMLElement("tt")}}.</p>
+Une chaîne de caractères représentant un élément HTML {{HTMLElement("tt")}}.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La méthode <code>fixed()</code> encadre une chaîne de caractères dans une balise <code>&lt;tt&gt;</code> :<br>
- <code>"&lt;tt&gt;str&lt;/tt&gt;</code>"</p>
+La méthode `fixed()` encadre une chaîne de caractères dans une balise `<tt>` :
+`"<tt>str</tt>`"
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<p>L'exemple suivant illustre l'utilisation de la méthode <code>fixed</code> pour formater une chaîne de caractères :</p>
+L'exemple suivant illustre l'utilisation de la méthode `fixed` pour formater une chaîne de caractères :
 
-<pre class="brush:js">var worldString = "Coucou monde";
+```js
+var worldString = "Coucou monde";
 
 console.log(worldString.fixed());
-// "&lt;tt&gt;Coucou monde&lt;/tt&gt;"
-</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('ES6', '#sec-string.prototype.fixed', 'String.prototype.fixed')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Définition initiale. Implémentée dans JavaScript 1.0. Définie dans l'annexe B (normative) pour les fonctionnalités ECMAScript additionnelles pour les navigateurs web.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-string.prototype.fixed', 'String.prototype.fixed')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td>Définie dans l'annexe B (normative) pour les fonctionnalités ECMAScript additionnelles pour les navigateurs web.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.String.fixed")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("String.prototype.bold()")}}</li>
- <li>{{jsxref("String.prototype.italics()")}}</li>
- <li>{{jsxref("String.prototype.strike()")}}</li>
-</ul>
+// "<tt>Coucou monde</tt>"
+```
+
+## Spécifications
+
+| Spécification                                                                                                | État                         | Commentaires                                                                                                                                                           |
+| ------------------------------------------------------------------------------------------------------------ | ---------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| {{SpecName('ES6', '#sec-string.prototype.fixed', 'String.prototype.fixed')}}         | {{Spec2('ES6')}}         | Définition initiale. Implémentée dans JavaScript 1.0. Définie dans l'annexe B (normative) pour les fonctionnalités ECMAScript additionnelles pour les navigateurs web. |
+| {{SpecName('ESDraft', '#sec-string.prototype.fixed', 'String.prototype.fixed')}} | {{Spec2('ESDraft')}} | Définie dans l'annexe B (normative) pour les fonctionnalités ECMAScript additionnelles pour les navigateurs web.                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.String.fixed")}}
+
+## Voir aussi
+
+- {{jsxref("String.prototype.bold()")}}
+- {{jsxref("String.prototype.italics()")}}
+- {{jsxref("String.prototype.strike()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/string/fontcolor/index.md b/files/fr/web/javascript/reference/global_objects/string/fontcolor/index.md
index 3ae3b58925..0764c3f5d1 100644
--- a/files/fr/web/javascript/reference/global_objects/string/fontcolor/index.md
+++ b/files/fr/web/javascript/reference/global_objects/string/fontcolor/index.md
@@ -11,78 +11,60 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/String/fontcolor
 original_slug: Web/JavaScript/Reference/Objets_globaux/String/fontcolor
 ---
-<div>{{JSRef}}{{deprecated_header}}</div>
+{{JSRef}}{{deprecated_header}}
 
-<p>La méthode <code><strong>fontcolor()</strong></code> permet de créer un élément {{HTMLElement("font")}} qui permet d'afficher la chaine de caractères dans une fonte utilisant la couleur donnée.</p>
+La méthode **`fontcolor()`** permet de créer un élément {{HTMLElement("font")}} qui permet d'afficher la chaine de caractères dans une fonte utilisant la couleur donnée.
 
-<div class="note">
-<p><strong>Note :</strong> L'élément &lt;font&gt; a été retiré dans <a href="/fr/docs/Web/Guide/HTML/HTML5">HTML5</a> et ne devrait plus être utilisé. Les propriétés <a href="/fr/docs/Web/CSS">CSS</a> permettent de modifier les aspects de mise en forme et doivent donc être utilisées à la place.</p>
-</div>
+> **Note :** L'élément \<font> a été retiré dans [HTML5](/fr/docs/Web/Guide/HTML/HTML5) et ne devrait plus être utilisé. Les propriétés [CSS](/fr/docs/Web/CSS) permettent de modifier les aspects de mise en forme et doivent donc être utilisées à la place.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>str</var>.fontcolor(<var>couleur</var>)</pre>
+    str.fontcolor(couleur)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>couleur</code></dt>
- <dd>Une chaîne de caractères représentant la couleur en une valeur hexadécimale RGB ou comme un littéral. Les différents littéraux utilisables pour les noms de couleurs sont listés dans la <a href="/fr/docs/Web/CSS/color_value#Valeurs">référence des couleurs CSS</a>.</dd>
-</dl>
+- `couleur`
+  - : Une chaîne de caractères représentant la couleur en une valeur hexadécimale RGB ou comme un littéral. Les différents littéraux utilisables pour les noms de couleurs sont listés dans la [référence des couleurs CSS](/fr/docs/Web/CSS/color_value#Valeurs).
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une chaîne de caractères représentant un élément HTML {{HTMLElement("font")}}.</p>
+Une chaîne de caractères représentant un élément HTML {{HTMLElement("font")}}.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Si la couleur est représentée sous forme d'un triplet RVB, le format attendu est <code>rrvvbb</code>. Ainsi, pour représenter un rose saumon, les différentes composantes seront rouge = FA,  vert = 80, et bleu = 72, le triplet s'écrit donc "<code>FA8072</code>".</p>
+Si la couleur est représentée sous forme d'un triplet RVB, le format attendu est `rrvvbb`. Ainsi, pour représenter un rose saumon, les différentes composantes seront rouge = FA,  vert = 80, et bleu = 72, le triplet s'écrit donc "`FA8072`".
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<p>L'exemple qui suit illustre comment utiliser la méthode <code>fontcolor()</code> pour modifier la couleur d'une chaîne de caractères en créant une balise <code>&lt;font&gt;</code> qui encadre la chaîne.</p>
+L'exemple qui suit illustre comment utiliser la méthode `fontcolor()` pour modifier la couleur d'une chaîne de caractères en créant une balise `<font>` qui encadre la chaîne.
 
-<pre class="brush: js">var worldString = "Coucou monde";
+```js
+var worldString = "Coucou monde";
 
 console.log(worldString.fontcolor("red") +  " avec le littéral red sur cette ligne");
-// '&lt;font color="red"&gt;Coucou monde&lt;/font&gt; avec le littéral red sur cette ligne'
+// '<font color="red">Coucou monde</font> avec le littéral red sur cette ligne'
 
 console.log(worldString.fontcolor("FF00") + " avec la valeur hexadécimale sur cette ligne");
-// '&lt;font color="FF00"&gt;Coucou monde&lt;/font&gt; avec la valeur hexadécimale sur cette ligne'
-</pre>
-
-<p>L'objet {{domxref("HTMLElement.style", "element.style")}} permet d'utiliser l'attribut <code>style</code> de l'élément et de le manipuler de façon générique. Par exemple :</p>
-
-<pre class="brush: js">document.getElementById('IDdeVotreElement').style.color = 'red'</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('ES6', '#sec-string.prototype.fontcolor', 'String.prototype.fontcolor')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Définition initiale. Implémentée dans JavaScript 1.0. Définie dans l'annexe B (normative) pour les fonctionnalités ECMAScript additionnelles pour les navigateurs web.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-string.prototype.fontcolor', 'String.prototype.fontcolor')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td>Définie dans l'annexe B (normative) pour les fonctionnalités ECMAScript additionnelles pour les navigateurs web.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.String.fontcolor")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("String.prototype.fontsize()")}}</li>
-</ul>
+// '<font color="FF00">Coucou monde</font> avec la valeur hexadécimale sur cette ligne'
+```
+
+L'objet {{domxref("HTMLElement.style", "element.style")}} permet d'utiliser l'attribut `style` de l'élément et de le manipuler de façon générique. Par exemple :
+
+```js
+document.getElementById('IDdeVotreElement').style.color = 'red'
+```
+
+## Spécifications
+
+| Spécification                                                                                                        | État                         | Commentaires                                                                                                                                                           |
+| -------------------------------------------------------------------------------------------------------------------- | ---------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| {{SpecName('ES6', '#sec-string.prototype.fontcolor', 'String.prototype.fontcolor')}}     | {{Spec2('ES6')}}         | Définition initiale. Implémentée dans JavaScript 1.0. Définie dans l'annexe B (normative) pour les fonctionnalités ECMAScript additionnelles pour les navigateurs web. |
+| {{SpecName('ESDraft', '#sec-string.prototype.fontcolor', 'String.prototype.fontcolor')}} | {{Spec2('ESDraft')}} | Définie dans l'annexe B (normative) pour les fonctionnalités ECMAScript additionnelles pour les navigateurs web.                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.String.fontcolor")}}
+
+## Voir aussi
+
+- {{jsxref("String.prototype.fontsize()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/string/fontsize/index.md b/files/fr/web/javascript/reference/global_objects/string/fontsize/index.md
index 72aca87a1a..ebbad87fe9 100644
--- a/files/fr/web/javascript/reference/global_objects/string/fontsize/index.md
+++ b/files/fr/web/javascript/reference/global_objects/string/fontsize/index.md
@@ -12,76 +12,59 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/String/fontsize
 original_slug: Web/JavaScript/Reference/Objets_globaux/String/fontsize
 ---
-<div>{{JSRef}}{{deprecated_header}}</div>
+{{JSRef}}{{deprecated_header}}
 
-<p>La propriété <code><strong>fontsize()</strong></code> permet de créer un élément HTML {{HTMLElement("font")}} qui permet d'afficher la chaîne de caractères dans une fonte de taille donnée.</p>
+La propriété **`fontsize()`** permet de créer un élément HTML {{HTMLElement("font")}} qui permet d'afficher la chaîne de caractères dans une fonte de taille donnée.
 
-<div class="note">
-<p><strong>Note :</strong> L'élément &lt;font&gt; a été retiré dans <a href="/fr/docs/Web/Guide/HTML/HTML5">HTML5</a> et ne devrait plus être utilisé. Les propriétés <a href="/fr/docs/Web/CSS">CSS</a> permettent de modifier les aspects de mise en forme et doivent donc être utilisées à la place.</p>
-</div>
+> **Note :** L'élément \<font> a été retiré dans [HTML5](/fr/docs/Web/Guide/HTML/HTML5) et ne devrait plus être utilisé. Les propriétés [CSS](/fr/docs/Web/CSS) permettent de modifier les aspects de mise en forme et doivent donc être utilisées à la place.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>str</var>.fontsize(<var>taille</var>)</pre>
+    str.fontsize(taille)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>taille</code></dt>
- <dd>Un entier compris entre 1 et 7 ou une chaîne de caractère représentant un nombre signé entre 1 et 7.</dd>
-</dl>
+- `taille`
+  - : Un entier compris entre 1 et 7 ou une chaîne de caractère représentant un nombre signé entre 1 et 7.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une chaîne de caractères représentant un élément HTML {{HTMLElement("font")}}.</p>
+Une chaîne de caractères représentant un élément HTML {{HTMLElement("font")}}.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Lorsque le paramètre utilisé est un entier, la taille de la chaîne <code>str</code> correspondra à l'une des 7 tailles définies. Lorsque le paramètre utilisé est une chaîne de caractères (par exemple "-2"), la taille de la fonte sera ajustée relativement à la taille définie par l'élément {{HTMLElement("basefont")}}.</p>
+Lorsque le paramètre utilisé est un entier, la taille de la chaîne `str` correspondra à l'une des 7 tailles définies. Lorsque le paramètre utilisé est une chaîne de caractères (par exemple "-2"), la taille de la fonte sera ajustée relativement à la taille définie par l'élément {{HTMLElement("basefont")}}.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<p>L'exemple qui suit illustre comment utiliser les méthodes pour les chaînes de caractères afin de modifier la taille d'une chaîne de caractères :</p>
+L'exemple qui suit illustre comment utiliser les méthodes pour les chaînes de caractères afin de modifier la taille d'une chaîne de caractères :
 
-<pre class="brush:js">var worldString = "Coucou monde";
+```js
+var worldString = "Coucou monde";
 
-console.log(worldString.small()); // &lt;small&gt;Coucou monde&lt;/small&gt;
-console.log(worldString.big()); // &lt;big&gt;Coucou monde&lt;/big&gt;
-console.log(worldString.fontsize(7)); // &lt;font size="7"&gt;Coucou monde&lt;/fontsize&gt;</pre>
+console.log(worldString.small()); // <small>Coucou monde</small>
+console.log(worldString.big()); // <big>Coucou monde</big>
+console.log(worldString.fontsize(7)); // <font size="7">Coucou monde</fontsize>
+```
 
-<p>L'objet {{domxref("HTMLElement.style", "element.style")}} permet d'utiliser l'attribut <code>style</code> de l'élément et de le manipuler de façon générique. Par exemple :</p>
+L'objet {{domxref("HTMLElement.style", "element.style")}} permet d'utiliser l'attribut `style` de l'élément et de le manipuler de façon générique. Par exemple :
 
-<pre class="brush: js">document.getElementById('IdElement').style.fontSize = '0.7em'</pre>
+```js
+document.getElementById('IdElement').style.fontSize = '0.7em'
+```
 
-<h2 id="Spécifications">Spécifications</h2>
+## Spécifications
 
-<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('ES6', '#sec-string.prototype.fontsize', 'String.prototype.fontsize')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Définition initiale. Implémentée dans JavaScript 1.0. Définie dans l'annexe B (normative) pour les fonctionnalités ECMAScript additionnelles pour les navigateurs web.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-string.prototype.fontsize', 'String.prototype.fontsize')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td>Définie dans l'annexe B (normative) pour les fonctionnalités ECMAScript additionnelles pour les navigateurs web.</td>
-  </tr>
- </tbody>
-</table>
+| Spécification                                                                                                        | État                         | Commentaires                                                                                                                                                           |
+| -------------------------------------------------------------------------------------------------------------------- | ---------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| {{SpecName('ES6', '#sec-string.prototype.fontsize', 'String.prototype.fontsize')}}         | {{Spec2('ES6')}}         | Définition initiale. Implémentée dans JavaScript 1.0. Définie dans l'annexe B (normative) pour les fonctionnalités ECMAScript additionnelles pour les navigateurs web. |
+| {{SpecName('ESDraft', '#sec-string.prototype.fontsize', 'String.prototype.fontsize')}} | {{Spec2('ESDraft')}} | Définie dans l'annexe B (normative) pour les fonctionnalités ECMAScript additionnelles pour les navigateurs web.                                                       |
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.String.fontsize")}}</p>
+{{Compat("javascript.builtins.String.fontsize")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("String.prototype.big()")}}</li>
- <li>{{jsxref("String.prototype.small()")}}</li>
-</ul>
+- {{jsxref("String.prototype.big()")}}
+- {{jsxref("String.prototype.small()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/string/fromcharcode/index.md b/files/fr/web/javascript/reference/global_objects/string/fromcharcode/index.md
index db155abb0d..6d1b7f68dd 100644
--- a/files/fr/web/javascript/reference/global_objects/string/fromcharcode/index.md
+++ b/files/fr/web/javascript/reference/global_objects/string/fromcharcode/index.md
@@ -11,104 +11,79 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/String/fromCharCode
 original_slug: Web/JavaScript/Reference/Objets_globaux/String/fromCharCode
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode statique <code><strong>String.fromCharCode()</strong></code> renvoie une chaîne de caractères créée à partir de points de code UTF-16.</p>
+La méthode statique **`String.fromCharCode()`** renvoie une chaîne de caractères créée à partir de points de code UTF-16.
 
-<div>{{EmbedInteractiveExample("pages/js/string-fromcharcode.html")}}</div>
+{{EmbedInteractiveExample("pages/js/string-fromcharcode.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">String.fromCharCode(<var>num1</var>, <var>...</var>, <var>numN</var>)</pre>
+    String.fromCharCode(num1, ..., numN)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>num1, ..., numN</code></dt>
- <dd>Une séquence de nombres représentant des points de code UTF-16 entre 0 et 65535 (<code>0xFFFF</code>). Les nombres supérieurs à <code>0xFFFF</code> sont tronqués.</dd>
-</dl>
+- `num1, ..., numN`
+  - : Une séquence de nombres représentant des points de code UTF-16 entre 0 et 65535 (`0xFFFF`). Les nombres supérieurs à `0xFFFF` sont tronqués.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une chaîne de caractères qui contient les caractères correspondants à la série de points de code UTF-16.</p>
+Une chaîne de caractères qui contient les caractères correspondants à la série de points de code UTF-16.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Cette méthode renvoie une chaîne de caractère et non un objet {{jsxref("String")}}.</p>
+Cette méthode renvoie une chaîne de caractère et non un objet {{jsxref("String")}}.
 
-<p>La méthode <code>fromCharCode()</code> étant une méthode statique de l'objet <code>String</code>, elle doit toujours être utilisée avec la syntaxe <code>String.fromCharCode()</code> plutôt qu'en appelant la méthode à partir d'un objet <code>String</code> construit sur mesure.</p>
+La méthode `fromCharCode()` étant une méthode statique de l'objet `String`, elle doit toujours être utilisée avec la syntaxe `String.fromCharCode()` plutôt qu'en appelant la méthode à partir d'un objet `String` construit sur mesure.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<p>Pour les caractères du plan multilingue de base, UTF-16 utilise une seule unité de code :</p>
+Pour les caractères du plan multilingue de base, UTF-16 utilise une seule unité de code :
 
-<pre class="brush:js">String.fromCharCode(65,66,67); // ABC
+```js
+String.fromCharCode(65,66,67); // ABC
 String.fromCharCode(0x2014);   // "—"
 String.fromCharCode(0x12014);  // "—" également, le 1 a été tronqué
 String.fromCharCode(8212);     // renvoie également "—" car 8212
                                // est la forme décimale
-</pre>
+```
 
-<p>Les caractères hors de ce plan utilisent deux unités de code (on parle de <em>surrogate pair</em>) :</p>
+Les caractères hors de ce plan utilisent deux unités de code (on parle de _surrogate pair_) :
 
-<pre class="brush: js">String.fromCharCode(0xD83C, 0xDF03); // Point de code U+1F303 pour l'émoji nuit étoilée
+```js
+String.fromCharCode(0xD83C, 0xDF03); // Point de code U+1F303 pour l'émoji nuit étoilée
 
 // Forme décimale équivalente :
 String.fromCharCode(55356, 57091);
 
 String.fromCharCode(0xD834, 0xDF06, 0x61, 0xD834, 0xDF07);
 // "\uD834\uDF06a\uD834\uDF07"
-</pre>
-
-<h2 id="Utiliser_des_valeurs_Unicode_plus_grandes">Utiliser des valeurs Unicode plus grandes</h2>
-
-<p>En UTF-16, les caractères les plus communs sont représentables sur une seule valeur de 16 bits. Toutefois, cet ensemble de caractères (aussi appelé plan multilingue de base ou BMP en anglais) ne représente qu'1/17e de l'espace total représenté par les caractères Unicode. Le reste des points de code, sur l'intervalle 65536 (0x010000) à 1114111 (0x10FFFF) sont des caractères additionnels qui sont représentés par deux valeurs sur 16 bits qu'on appelle <em>surrogate pairs</em> en anglais.</p>
-
-<p>La méthode <code>fromCharCode()</code> ne fonctionne qu'avec des valeurs sur 16 bits et il faudra donc fournir une paire de codets pour obtenir certains caractères. Ainsi, <code>String.fromCharCode(0xD83C, 0xDF03)</code> renvoie le point de code U+1F303 qui représente l'émoji « nuit étoilée ».</p>
-
-<p>Bien qu'il y ait une relation mathématique entre la valeur composée et les deux codets qui forment la paire, on a besoin d'une étape supplémentaire à chaque fois. Aussi, il sera plus pratique d'utiliser {{jsxref("String.fromCodePoint()")}} (ES2015 / ES6) qui permet de manipuler les codes des caractères hors BMP : on pourra ainsi écrire <code>String.fromCodePoint(0x1F303)</code> pour renvoyer le caractère U+1F303 (émoji « nuit étoilée »).</p>
-
-<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('ES1')}}</td>
-   <td>{{Spec2('ES1')}}</td>
-   <td>Définition initiale. Implémentée avec JavaScript 1.2.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.5.3.2', 'StringfromCharCode')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-string.fromcharcodes', 'String.fromCharCode')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-string.fromcharcodes', 'String.fromCharCode')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.String.fromCharCode")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("String.prototype.charCodeAt()")}}</li>
- <li>{{jsxref("String.prototype.charAt()")}}</li>
- <li>{{jsxref("String.fromCodePoint()")}}</li>
- <li>{{jsxref("String.prototype.codePointAt()")}}</li>
-</ul>
+```
+
+## Utiliser des valeurs Unicode plus grandes
+
+En UTF-16, les caractères les plus communs sont représentables sur une seule valeur de 16 bits. Toutefois, cet ensemble de caractères (aussi appelé plan multilingue de base ou BMP en anglais) ne représente qu'1/17e de l'espace total représenté par les caractères Unicode. Le reste des points de code, sur l'intervalle 65536 (0x010000) à 1114111 (0x10FFFF) sont des caractères additionnels qui sont représentés par deux valeurs sur 16 bits qu'on appelle _surrogate pairs_ en anglais.
+
+La méthode `fromCharCode()` ne fonctionne qu'avec des valeurs sur 16 bits et il faudra donc fournir une paire de codets pour obtenir certains caractères. Ainsi, `String.fromCharCode(0xD83C, 0xDF03)` renvoie le point de code U+1F303 qui représente l'émoji « nuit étoilée ».
+
+Bien qu'il y ait une relation mathématique entre la valeur composée et les deux codets qui forment la paire, on a besoin d'une étape supplémentaire à chaque fois. Aussi, il sera plus pratique d'utiliser {{jsxref("String.fromCodePoint()")}} (ES2015 / ES6) qui permet de manipuler les codes des caractères hors BMP : on pourra ainsi écrire `String.fromCodePoint(0x1F303)` pour renvoyer le caractère U+1F303 (émoji « nuit étoilée »).
+
+## Spécifications
+
+| Spécification                                                                                        | État                         | Commentaires                                          |
+| ---------------------------------------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- |
+| {{SpecName('ES1')}}                                                                             | {{Spec2('ES1')}}         | Définition initiale. Implémentée avec JavaScript 1.2. |
+| {{SpecName('ES5.1', '#sec-15.5.3.2', 'StringfromCharCode')}}                     | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-string.fromcharcodes', 'String.fromCharCode')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-string.fromcharcodes', 'String.fromCharCode')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.String.fromCharCode")}}
+
+## Voir aussi
+
+- {{jsxref("String.prototype.charCodeAt()")}}
+- {{jsxref("String.prototype.charAt()")}}
+- {{jsxref("String.fromCodePoint()")}}
+- {{jsxref("String.prototype.codePointAt()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/string/fromcodepoint/index.md b/files/fr/web/javascript/reference/global_objects/string/fromcodepoint/index.md
index 81cf698e35..86b4cc9888 100644
--- a/files/fr/web/javascript/reference/global_objects/string/fromcodepoint/index.md
+++ b/files/fr/web/javascript/reference/global_objects/string/fromcodepoint/index.md
@@ -11,42 +11,39 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/String/fromCodePoint
 original_slug: Web/JavaScript/Reference/Objets_globaux/String/fromCodePoint
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode statique <strong><code>String.fromCodePoint()</code></strong> renvoie une chaîne de caractères créée à partir d'un suite de codets.</p>
+La méthode statique **`String.fromCodePoint()`** renvoie une chaîne de caractères créée à partir d'un suite de codets.
 
-<div>{{EmbedInteractiveExample("pages/js/string-fromcodepoint.html")}}</div>
+{{EmbedInteractiveExample("pages/js/string-fromcodepoint.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">String.fromCodePoint(<var>num1</var>[, ...[, <var>numN</var>]])</pre>
+    String.fromCodePoint(num1[, ...[, numN]])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>num1, ..., num<em>N</em></code></dt>
- <dd>Une séquence de codets (<em>code points</em>).</dd>
-</dl>
+- `num1, ..., numN`
+  - : Une séquence de codets (_code points_).
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une chaîne de caractères créée à partir de la séquence de codets indiquée.</p>
+Une chaîne de caractères créée à partir de la séquence de codets indiquée.
 
-<h3 id="Exceptions">Exceptions</h3>
+### Exceptions
 
-<ul>
- <li>Une exception {{jsxref("Erreurs/Not_a_codepoint","RangeError")}} est renvoyée si un codet (Unicode) invalide est utilisé (par exemple, on pourra avoir "RangeError: NaN is not a valid code point").</li>
-</ul>
+- Une exception {{jsxref("Erreurs/Not_a_codepoint","RangeError")}} est renvoyée si un codet (Unicode) invalide est utilisé (par exemple, on pourra avoir "RangeError: NaN is not a valid code point").
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p><code>fromCodePoint()</code> étant une méthode statique de {{jsxref("String")}}, elle doit toujours être utilisée avec la syntaxe <code>String.fromCodePoint()</code>, plutôt qu'avec une méthode d'un objet {{jsxref("String")}} qui aurait été créé.</p>
+`fromCodePoint()` étant une méthode statique de {{jsxref("String")}}, elle doit toujours être utilisée avec la syntaxe `String.fromCodePoint()`, plutôt qu'avec une méthode d'un objet {{jsxref("String")}} qui aurait été créé.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_fromCodePoint()">Utiliser <code>fromCodePoint()</code></h3>
+### Utiliser `fromCodePoint()`
 
-<pre class="brush: js">String.fromCodePoint(42);       // "*"
+```js
+String.fromCodePoint(42);       // "*"
 String.fromCodePoint(65, 90);   // "AZ"
 String.fromCodePoint(0x404);    // "\u0404"
 String.fromCodePoint(0x2F804);  // "\uD87E\uDC04"
@@ -59,50 +56,37 @@ String.fromCodePoint(-1);       // RangeError
 String.fromCodePoint(3.14);     // RangeError
 String.fromCodePoint(3e-2);     // RangeError
 String.fromCodePoint(NaN);      // RangeError
-</pre>
+```
 
-<h3 id="Comparaison_avec_fromCharCode()">Comparaison avec <code>fromCharCode()</code></h3>
+### Comparaison avec `fromCharCode()`
 
-<p>La méthode {{jsxref("String.fromCharCode()")}} ne peut pas renvoyer les caractères de l'intervalle 0x010000 à 0X10FFFF avec un seul codet, il est nécessaire de lui fournir la paire décomposée (<em>surrogate pair</em>) pour obtenr un tel caractère :</p>
+La méthode {{jsxref("String.fromCharCode()")}} ne peut pas renvoyer les caractères de l'intervalle 0x010000 à 0X10FFFF avec un seul codet, il est nécessaire de lui fournir la paire décomposée (_surrogate pair_) pour obtenr un tel caractère :
 
-<pre class="brush: js">String.fromCharCode(0xD83C, 0xDF03); // émoji « nuit étoilée »
-String.fromCharCode(55356, 57091);   // équivalent en notation décimale</pre>
+```js
+String.fromCharCode(0xD83C, 0xDF03); // émoji « nuit étoilée »
+String.fromCharCode(55356, 57091);   // équivalent en notation décimale
+```
 
-<p><code>String.fromCodePoint()</code>, en revanche, peut renvoyer les caractères qui s'expriment sur plus d'un codet de 16 bits grâce à leur codet « simple » :</p>
+`String.fromCodePoint()`, en revanche, peut renvoyer les caractères qui s'expriment sur plus d'un codet de 16 bits grâce à leur codet « simple » :
 
-<pre class="brush: js">String.fromCodePoint(0x1F303); // ou 127747 en notation décimale</pre>
+```js
+String.fromCodePoint(0x1F303); // ou 127747 en notation décimale
+```
 
-<h2 id="Spécifications">Spécifications</h2>
+## Spécifications
 
-<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-string.fromcodepoint', 'String.fromCodePoint')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-string.fromcodepoint', 'String.fromCodePoint')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
+| Spécification                                                                                        | État                         | Commentaires        |
+| ---------------------------------------------------------------------------------------------------- | ---------------------------- | ------------------- |
+| {{SpecName('ES2015', '#sec-string.fromcodepoint', 'String.fromCodePoint')}} | {{Spec2('ES2015')}}     | Définition initiale |
+| {{SpecName('ESDraft', '#sec-string.fromcodepoint', 'String.fromCodePoint')}} | {{Spec2('ESDraft')}} |                     |
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.String.fromCodePoint")}}</p>
+{{Compat("javascript.builtins.String.fromCodePoint")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("String.fromCharCode()")}}</li>
- <li>{{jsxref("String.prototype.charAt()")}}</li>
- <li>{{jsxref("String.prototype.codePointAt()")}}</li>
- <li>{{jsxref("String.prototype.charCodeAt()")}}</li>
-</ul>
+- {{jsxref("String.fromCharCode()")}}
+- {{jsxref("String.prototype.charAt()")}}
+- {{jsxref("String.prototype.codePointAt()")}}
+- {{jsxref("String.prototype.charCodeAt()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/string/includes/index.md b/files/fr/web/javascript/reference/global_objects/string/includes/index.md
index e3aba75116..55799ebce2 100644
--- a/files/fr/web/javascript/reference/global_objects/string/includes/index.md
+++ b/files/fr/web/javascript/reference/global_objects/string/includes/index.md
@@ -10,45 +10,46 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/String/includes
 original_slug: Web/JavaScript/Reference/Objets_globaux/String/includes
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>includes()</strong></code> détermine si une chaîne de caractères est contenue dans une autre et renvoie <code>true</code> ou <code>false</code> selon le cas de figure.</p>
+La méthode **`includes()`** détermine si une chaîne de caractères est contenue dans une autre et renvoie `true` ou `false` selon le cas de figure.
 
-<div>{{EmbedInteractiveExample("pages/js/string-includes.html")}}</div>
+{{EmbedInteractiveExample("pages/js/string-includes.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>str</var>.includes(<var>chaîneRecherchée</var>);
-<var>str</var>.includes(<var>chaîneRecherchée</var>, <var>position</var>);</pre>
+    str.includes(chaîneRecherchée);
+    str.includes(chaîneRecherchée, position);
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>chaîneRecherchée</code></dt>
- <dd>Une chaîne à rechercher dans la chaîne courante.</dd>
- <dt><code>position</code> {{optional_inline}}</dt>
- <dd>La position dans la chaîne à partir de laquelle commencera la recherche. La valeur par défaut de <code><var>position</var></code> est 0.</dd>
-</dl>
+- `chaîneRecherchée`
+  - : Une chaîne à rechercher dans la chaîne courante.
+- `position` {{optional_inline}}
+  - : La position dans la chaîne à partir de laquelle commencera la recherche. La valeur par défaut de `position` est 0.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p><code>true</code> si la chaîne de caractères contient la sous-chaîne recherchée, <code>false</code> sinon.</p>
+`true` si la chaîne de caractères contient la sous-chaîne recherchée, `false` sinon.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Cette méthode détermine si une chaîne de caractères est contenue dans une autre.</p>
+Cette méthode détermine si une chaîne de caractères est contenue dans une autre.
 
-<h3 id="Sensibilité_à_la_case">Sensibilité à la case</h3>
+### Sensibilité à la case
 
-<p><code>includes()</code> est sensible à la casse. Par exemple, l'expression suivante nous retournera <code>false</code> :</p>
+`includes()` est sensible à la casse. Par exemple, l'expression suivante nous retournera `false` :
 
-<pre class="brush: js">'Baleine bleue'.includes('baleine'); // false</pre>
+```js
+'Baleine bleue'.includes('baleine'); // false
+```
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_includes">Utiliser <code>includes()</code></h3>
+### Utiliser `includes()`
 
-<pre class="brush:js;">const str = "Être ou ne pas être, telle est la question.";
+```js
+const str = "Être ou ne pas être, telle est la question.";
 
 console.log(str.includes("Être"));       // true
 console.log(str.includes("question"));   // true
@@ -56,15 +57,16 @@ console.log(str.includes("pléonasme"));  // false
 console.log(str.includes("Être", 1));    // false
 console.log(str.includes("ÊTRE"));       // false
 console.log(str.includes(""));       // true
-</pre>
+```
 
-<h2 id="Prothèse_démulation_polyfill">Prothèse d'émulation (<em>polyfill</em>)</h2>
+## Prothèse d'émulation (_polyfill_)
 
-<p>Cette méthode a été ajoutée à la spécification ECMAScript 2015 et n'est peut-être pas encore disponible dans toutes les implémentations JavaScript.</p>
+Cette méthode a été ajoutée à la spécification ECMAScript 2015 et n'est peut-être pas encore disponible dans toutes les implémentations JavaScript.
 
-<p>Cependant, vous pouvez facilement {{Glossary('polyfill')}} cette méthode pour de vieux navigateurs :</p>
+Cependant, vous pouvez facilement {{Glossary('polyfill')}} cette méthode pour de vieux navigateurs :
 
-<pre class="brush: js">if (!String.prototype.includes) {
+```js
+if (!String.prototype.includes) {
   String.prototype.includes = function(search, start) {
     'use strict';
 
@@ -74,53 +76,35 @@ console.log(str.includes(""));       // true
     if (start === undefined) { start = 0; }
     return this.indexOf(search, start) !== -1;
   };
-}</pre>
-
-<h2 id="Spécifications">Spécifications</h2>
-
-<table class="standard-table">
- <thead>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">État</th>
-   <th scope="col">Commentaires</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-string.prototype.includes', 'String.prototype.includes')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-string.prototype.includes', 'String.prototype.includes')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_du_navigateur">Compatibilité du navigateur</h2>
-
-<p>{{Compat("javascript.builtins.String.includes")}}</p>
-
-<h2 id="String.prototype.contains">String.prototype.contains</h2>
-
-<p>Les versions de Firefox allant de Firefox 18 à Firefox 39 utilisent cette méthode avec le nom <code>contains()</code>. Cette méthode a été renommée en <code>includes()</code> via {{bug(1102219)}} pour la raison suivante :</p>
-
-<p>Il a été <a href="https://bugzilla.mozilla.org/show_bug.cgi?id=789036">rapporté</a> que certains sites web utilisant MooTools 1.2 plantaient sur Firefox 17. Cette version de MooTools vérifie que <code>String.prototype.contains()</code> existe bien, et si ce n'est pas le cas, ajoute sa propre fonction similaire. Avec l'introduction de cette fonction dans Firefox 17, le comportement de ce contrôle a changé de telle manière qu'il cause un plantage du code de MooTools implémenté pour <code>String.prototype.contains()</code>. En conséquence, cette implémentation a été <a href="https://hg.mozilla.org/releases/mozilla-aurora/rev/086db97198a8" title="https://bugzilla.mozilla.org/show_bug.cgi?id=793781">désactivée</a> de Firefox 17. <code>String.prototype.contains()</code> est ainsi disponible sur une version ultérieure : Firefox 18 lorsque <a href="https://mootools.net/blog/2013/02/19/mootools-1-2-6-released">MooTools a déclenché la sortie de la version 1.2.6.</a></p>
-
-<p>MooTools 1.3 force sa propre version de <code>String.prototype.includes()</code>, les sites Web l'implémentant ne sont donc pas perturbés. Néanmoins, il faut noter que les signatures des méthodes diffèrent entre <a href="https://mootools.net/docs/core/Types/String#String:includes">MooTools 1.3</a> et ECMAScript 2015 (pour le second paramètre). <a href="https://github.com/mootools/mootools-core/blob/master/Docs/Types/String.md#note">MooTools 1.5+ a modifié sa signature afin de prendre en compte le standard de ES2015.</a></p>
-
-<p>Dans Firefox 48, la méthode <code>String.prototype.contains()</code> a été retirée. <code>String.prototype.includes()</code> doit être utilisée à la place.</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Array.prototype.includes()")}}</li>
- <li>{{jsxref("TypedArray.prototype.includes()")}}</li>
- <li>{{jsxref("String.prototype.indexOf()")}}</li>
- <li>{{jsxref("String.prototype.lastIndexOf()")}}</li>
- <li>{{jsxref("String.prototype.startsWith()")}}</li>
- <li>{{jsxref("String.prototype.endsWith()")}}</li>
-</ul>
+}
+```
+
+## Spécifications
+
+| Spécification                                                                                                        | État                         | Commentaires         |
+| -------------------------------------------------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ESDraft', '#sec-string.prototype.includes', 'String.prototype.includes')}} | {{Spec2('ESDraft')}} |                      |
+| {{SpecName('ES6', '#sec-string.prototype.includes', 'String.prototype.includes')}}         | {{Spec2('ES6')}}         | Définition initiale. |
+
+## Compatibilité du navigateur
+
+{{Compat("javascript.builtins.String.includes")}}
+
+## String.prototype.contains
+
+Les versions de Firefox allant de Firefox 18 à Firefox 39 utilisent cette méthode avec le nom `contains()`. Cette méthode a été renommée en `includes()` via {{bug(1102219)}} pour la raison suivante :
+
+Il a été [rapporté](https://bugzilla.mozilla.org/show_bug.cgi?id=789036) que certains sites web utilisant MooTools 1.2 plantaient sur Firefox 17. Cette version de MooTools vérifie que `String.prototype.contains()` existe bien, et si ce n'est pas le cas, ajoute sa propre fonction similaire. Avec l'introduction de cette fonction dans Firefox 17, le comportement de ce contrôle a changé de telle manière qu'il cause un plantage du code de MooTools implémenté pour `String.prototype.contains()`. En conséquence, cette implémentation a été [désactivée](https://hg.mozilla.org/releases/mozilla-aurora/rev/086db97198a8 "https://bugzilla.mozilla.org/show_bug.cgi?id=793781") de Firefox 17. `String.prototype.contains()` est ainsi disponible sur une version ultérieure : Firefox 18 lorsque [MooTools a déclenché la sortie de la version 1.2.6.](https://mootools.net/blog/2013/02/19/mootools-1-2-6-released)
+
+MooTools 1.3 force sa propre version de `String.prototype.includes()`, les sites Web l'implémentant ne sont donc pas perturbés. Néanmoins, il faut noter que les signatures des méthodes diffèrent entre [MooTools 1.3](https://mootools.net/docs/core/Types/String#String:includes) et ECMAScript 2015 (pour le second paramètre). [MooTools 1.5+ a modifié sa signature afin de prendre en compte le standard de ES2015.](https://github.com/mootools/mootools-core/blob/master/Docs/Types/String.md#note)
+
+Dans Firefox 48, la méthode `String.prototype.contains()` a été retirée. `String.prototype.includes()` doit être utilisée à la place.
+
+## Voir aussi
+
+- {{jsxref("Array.prototype.includes()")}}
+- {{jsxref("TypedArray.prototype.includes()")}}
+- {{jsxref("String.prototype.indexOf()")}}
+- {{jsxref("String.prototype.lastIndexOf()")}}
+- {{jsxref("String.prototype.startsWith()")}}
+- {{jsxref("String.prototype.endsWith()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/string/index.md b/files/fr/web/javascript/reference/global_objects/string/index.md
index 11a12969ca..e1b7dd21f4 100644
--- a/files/fr/web/javascript/reference/global_objects/string/index.md
+++ b/files/fr/web/javascript/reference/global_objects/string/index.md
@@ -11,381 +11,313 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String
 original_slug: Web/JavaScript/Reference/Objets_globaux/String
 browser-compat: javascript.builtins.String
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>Un objet <strong><code>String</code></strong> est utilisé afin de représenter et de manipuler une chaîne de caractères.</p>
+Un objet **`String`** est utilisé afin de représenter et de manipuler une chaîne de caractères.
 
-<h2 id="description">Description</h2>
+## Description
 
-<p>Les chaînes de caractères sont utiles pour stocker des données qui peuvent être représentées sous forme de texte. Parmi les opérations les plus utilisées pour manipuler les chaînes de caractères, on a : la vérification de leur longueur avec <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String/length"><code>length</code></a>, la construction et la concaténation avec <a href="/fr/docs/Web/JavaScript/Guide/Expressions_and_Operators#string_operators">les opérateurs <code>+</code> et <code>+=</code></a>, la recherche de sous-chaîne avec les méthodes <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String/includes"><code>includes()</code></a> ou <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String/indexOf"><code>indexOf()</code></a> ou encore l'extraction de sous-chaînes avec la méthode <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String/substring"><code>substring()</code></a>.</p>
+Les chaînes de caractères sont utiles pour stocker des données qui peuvent être représentées sous forme de texte. Parmi les opérations les plus utilisées pour manipuler les chaînes de caractères, on a : la vérification de leur longueur avec [`length`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String/length), la construction et la concaténation avec [les opérateurs `+` et `+=`](/fr/docs/Web/JavaScript/Guide/Expressions_and_Operators#string_operators), la recherche de sous-chaîne avec les méthodes [`includes()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String/includes) ou [`indexOf()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String/indexOf) ou encore l'extraction de sous-chaînes avec la méthode [`substring()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String/substring).
 
-<h3 id="creating_strings">Créer des chaînes de caractères</h3>
+### Créer des chaînes de caractères
 
-<p>Il est possible de créer des chaînes de caractères comme des valeurs primitives ou comme des objets avec le constructeur <a href="/fr/docs/Web/JavaScript/Reference/String/String"><code>String()</code></a> :</p>
+Il est possible de créer des chaînes de caractères comme des valeurs primitives ou comme des objets avec le constructeur [`String()`](/fr/docs/Web/JavaScript/Reference/String/String) :
 
-<pre class="brush: js">
+```js
 const string1 = "Une chaîne de caractères primitive";
 const string2 = 'Là encore une valeur de chaîne de caractères primitive';
-const string3 = `Et ici aussi`;</pre>
+const string3 = `Et ici aussi`;
+```
 
-<pre class="brush: js">
+```js
 const string4 = new String("Un objet String");
-</pre>
+```
 
-<p>Les valeurs primitives ou les objets représentant des chaînes de caractères peuvent être utilisés de façon interchangeable dans la plupart des situations. Voir ci-après <a href="#string_primitives_and_string_objects">Chaînes de caractères : valeurs primitives et objets</a>.</p>
+Les valeurs primitives ou les objets représentant des chaînes de caractères peuvent être utilisés de façon interchangeable dans la plupart des situations. Voir ci-après [Chaînes de caractères : valeurs primitives et objets](#string_primitives_and_string_objects).
 
-<p>Les valeurs littérales pour les chaînes de caractères peuvent être indiquées avec des simples quotes (<kbd>'</kbd>), des doubles quotes (<kbd>"</kbd>) ou encore par des accents graves (<kbd>`</kbd>). Cette dernière forme permet de définir un <a href="/fr/docs/Web/JavaScript/Reference/Template_literals">littéral de gabarit de chaîne de caractères</a> avec lequel on pourra interpoler des expressions dans une chaîne de caractères.</p>
+Les valeurs littérales pour les chaînes de caractères peuvent être indiquées avec des simples quotes (<kbd>'</kbd>), des doubles quotes (<kbd>"</kbd>) ou encore par des accents graves (<kbd>`</kbd>). Cette dernière forme permet de définir un [littéral de gabarit de chaîne de caractères](/fr/docs/Web/JavaScript/Reference/Template_literals) avec lequel on pourra interpoler des expressions dans une chaîne de caractères.
 
-<h3 id="character_access">Accéder à un caractère</h3>
+### Accéder à un caractère
 
-<p>Il existe deux façons d'accéder à un caractère dans une chaîne. La première façon consiste à utiliser la méthode <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String/charAt"><code>charAt()</code></a> :</p>
+Il existe deux façons d'accéder à un caractère dans une chaîne. La première façon consiste à utiliser la méthode [`charAt()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String/charAt) :
 
-<pre class="brush: js">
+```js
 return 'chat'.charAt(2); // renvoie "a"
-</pre>
+```
 
-<p>La seconde méthode, introduite avec ECMAScript 5, est de manipuler la chaîne comme un tableau, où les caractères sont les éléments du tableau et ont un indice correspondant à leur position :</p>
+La seconde méthode, introduite avec ECMAScript 5, est de manipuler la chaîne comme un tableau, où les caractères sont les éléments du tableau et ont un indice correspondant à leur position :
 
-<pre class="brush: js">
+```js
 return 'chat'[2]; // renvoie "a"
-</pre>
+```
 
-<p>En utilisant la seconde notation, il est impossible de supprimer ou d'affecter une valeur à ces propriétés. En effet, les propriétés concernées ne sont ni accessibles en écriture ni configurables. Pour plus d'informations, voir la page de <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty"><code>Object.defineProperty()</code></a>.</p>
+En utilisant la seconde notation, il est impossible de supprimer ou d'affecter une valeur à ces propriétés. En effet, les propriétés concernées ne sont ni accessibles en écriture ni configurables. Pour plus d'informations, voir la page de [`Object.defineProperty()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty).
 
-<h3 id="comparing_strings">Comparer des chaînes de caractères</h3>
+### Comparer des chaînes de caractères
 
-<p>Les développeurs C utilisent la fonction <code>strcmp()</code> pour comparer des chaînes de caractères. En JavaScript, il est possible d'utiliser <a href="/fr/docs/Web/JavaScript/Reference/Operators">les opérateurs inférieur et supérieur </a>:</p>
+Les développeurs C utilisent la fonction `strcmp()` pour comparer des chaînes de caractères. En JavaScript, il est possible d'utiliser [les opérateurs inférieur et supérieur ](/fr/docs/Web/JavaScript/Reference/Operators):
 
-<pre class="brush: js">
+```js
 let a = "a";
 let b = "b";
-if (a &lt; b) { // true
+if (a < b) { // true
   console.log(a + " est inférieure à " + b);
-} else if (a &gt; b) {
+} else if (a > b) {
   console.log(a + " est supérieure à " + b);
 } else {
   console.log(a + " et " + b + " sont égales.");
 }
-</pre>
+```
 
-<p>On peut obtenir un résultat semblable avec la méthode <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String/localeCompare"><code>localeCompare()</code></a> qui permet de prendre en compte la locale utilisée et qui est héritée par toutes les instances de <code>String</code>.</p>
+On peut obtenir un résultat semblable avec la méthode [`localeCompare()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String/localeCompare) qui permet de prendre en compte la locale utilisée et qui est héritée par toutes les instances de `String`.
 
-<p>On notera que <code>a == b</code> compare les chaînes de caractères <code><var>a</var></code> et <code><var>b</var></code> de façon sensible à la casse. Si on souhaite comparer des chaînes sans être sensible à la casse, on pourra utiliser une fonction semblable à&nbsp;:</p>
+On notera que `a == b` compare les chaînes de caractères `a` et `b` de façon sensible à la casse. Si on souhaite comparer des chaînes sans être sensible à la casse, on pourra utiliser une fonction semblable à :
 
-<pre class="brush: js">
+```js
 function isEqual(str1, str2) {
   return str1.toUpperCase() === str2.toUpperCase()
 }
-</pre>
+```
 
-<p>On utilise ici une conversion en majuscules plutôt qu'en minuscules, car cela cause certains problèmes de conversion pour certains caractères UTF-8.</p>
+On utilise ici une conversion en majuscules plutôt qu'en minuscules, car cela cause certains problèmes de conversion pour certains caractères UTF-8.
 
-<h3 id="string_primitives_and_string_objects">Les différences entre les objets <code>String</code> et le type primitif pour les chaînes de caractères</h3>
+### Les différences entre les objets `String` et le type primitif pour les chaînes de caractères
 
-<p>En JavaScript, on distingue d'une part les objets <code>String</code> et d'autre par les valeurs primitives qui sont des chaînes de caractères (il en va de même pour les booléens/<a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Boolean"><code>Boolean</code></a> et les nombres/<a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Number"><code>Number</code></a>).</p>
+En JavaScript, on distingue d'une part les objets `String` et d'autre par les valeurs primitives qui sont des chaînes de caractères (il en va de même pour les booléens/[`Boolean`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Boolean) et les nombres/[`Number`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Number)).
 
-<p>Les valeurs littérales (délimitées par des simples quotes, des doubles quotes ou des accents graves et les chaînes de caractères renvoyées par les appels à <code>String</code> sans le mot-clé <a href="/fr/docs/Web/JavaScript/Reference/Operators/new"><code>new</code></a> sont des chaînes de caractères primitives. JavaScript convertit automatiquement les valeurs primitives en objets <code>String</code> et il est donc possible d'utiliser les méthodes objet de <code>String</code> sur les chaînes de caractères primitives. Dans les contextes où une méthode est appelée sur une chaîne de caractères primitive ou alors qu'on recherche une propriété, JavaScript convertira implicitement la valeur primitive et appellera la méthode ou accèdera à la propriété correspondante.</p>
+Les valeurs littérales (délimitées par des simples quotes, des doubles quotes ou des accents graves et les chaînes de caractères renvoyées par les appels à `String` sans le mot-clé [`new`](/fr/docs/Web/JavaScript/Reference/Operators/new) sont des chaînes de caractères primitives. JavaScript convertit automatiquement les valeurs primitives en objets `String` et il est donc possible d'utiliser les méthodes objet de `String` sur les chaînes de caractères primitives. Dans les contextes où une méthode est appelée sur une chaîne de caractères primitive ou alors qu'on recherche une propriété, JavaScript convertira implicitement la valeur primitive et appellera la méthode ou accèdera à la propriété correspondante.
 
-<pre class="brush: js">
+```js
 let s_prim = "toto";
 let s_obj = new String(s_prim);
 
 console.log(typeof s_prim); // affiche "string"
 console.log(typeof s_obj);  // affiche "object"
-</pre>
+```
 
-<p>Les chaînes primitives et les objets <code>String</code> renvoient des résultats différents lorsqu'ils sont évalués avec <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/eval"><code>eval()</code></a>. Les chaînes primitives sont traitées comme du code source, tandis que les objets <code>String</code> sont traités comme tous les autres objets, en renvoyant l'objet. Par exemple :</p>
+Les chaînes primitives et les objets `String` renvoient des résultats différents lorsqu'ils sont évalués avec [`eval()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/eval). Les chaînes primitives sont traitées comme du code source, tandis que les objets `String` sont traités comme tous les autres objets, en renvoyant l'objet. Par exemple :
 
-<pre class="brush: js">
+```js
 let s1 = "2 + 2";                // crée une chaîne primitive
 let s2 = new String("2 + 2");    // crée un objet String
 console.log(eval(s1));           // renvoie le nombre 4
 console.log(eval(s2));           // renvoie la chaîne "2 + 2"
-</pre>
+```
 
-<p>Pour ces raisons, il peut y avoir certains problèmes quand le code attend une chaîne primitive plutôt qu'un objet <code>String</code>. Toutefois, cette distinction est rarement nécessaire en pratique.</p>
+Pour ces raisons, il peut y avoir certains problèmes quand le code attend une chaîne primitive plutôt qu'un objet `String`. Toutefois, cette distinction est rarement nécessaire en pratique.
 
-<p>Un objet <code>String</code> peut toujours être converti en son équivalent primitif grâce à la méthode <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String/valueOf"><code>valueOf()</code></a>.</p>
+Un objet `String` peut toujours être converti en son équivalent primitif grâce à la méthode [`valueOf()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String/valueOf).
 
-<pre class="brush: js">
+```js
 console.log(eval(s2.valueOf())); // renvoie  4
-</pre>
-
-<h3 id="escape_notation">Échappement des caractères</h3>
-
-<p>En dehors des caractères classiques, des caractères spéciaux peuvent être encodés grâce à l'échappement :</p>
-
-<table class="standard-table">
- <thead>
-  <tr>
-   <th scope="col">Code</th>
-   <th scope="col">Résultat</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td><code>\0</code></td>
-   <td>Caractère nul (U+0000 NULL)</td>
-  </tr>
-  <tr>
-   <td><code>\'</code></td>
-   <td>simple quote (U+0027 APOSTROPHE)</td>
-  </tr>
-  <tr>
-   <td><code>\"</code></td>
-   <td>double quote (U+0022 QUOTATION MARK)</td>
-  </tr>
-  <tr>
-   <td><code>\\</code></td>
-   <td>barre oblique inversée (U+005C REVERSE SOLIDUS)</td>
-  </tr>
-  <tr>
-   <td><code>\n</code></td>
-   <td>nouvelle ligne (U+000A LINE FEED; LF)</td>
-  </tr>
-  <tr>
-   <td><code>\r</code></td>
-   <td>retour chariot (U+000D CARRIAGE RETURN; CR)</td>
-  </tr>
-  <tr>
-   <td><code>\v</code></td>
-   <td>tabulation verticale (U+000B LINE TABULATION)</td>
-  </tr>
-  <tr>
-   <td><code>\t</code></td>
-   <td>tabulation (U+0009 CHARACTER TABULATION)</td>
-  </tr>
-  <tr>
-   <td><code>\b</code></td>
-   <td>retour arrière (U+0008 BACKSPACE)</td>
-  </tr>
-  <tr>
-   <td><code>\f</code></td>
-   <td>saut de page (U+000C FORM FEED)</td>
-  </tr>
-  <tr>
-   <td><code>\uXXXX</code> (<code>XXXX</code> étant 4 chiffres hexadécimaux pour l'intervalle of 0x0000 - 0xFFFF)</td>
-   <td>Point de code Unicode entre U+0000 et U+FFFF (représente le plan Unicode multilingue basique)</td>
-  </tr>
-  <tr>
-   <td><code>\u{X}</code> ... <code>\u{XXXXXX}</code> (<code>X…XXXXXX</code> étant 1 à 6 chiffres hexadécimaux pour l'intervalle 0x0 - 0x10FFFF)</td>
-   <td>Point de code Unicode entre U+0000 et U+10FFFF (représente l'intégralité d'Unicode)</td>
-  </tr>
-  <tr>
-   <td><code>\xXX</code> (<code>XX</code> étant 2 chiffres hexadécimaux pour l'intervalle 0x00 - 0xFF)</td>
-   <td>Point de code Unicode entre U+0000 et U+00FF (correspond à Basic Latin et Latin-1 supplement ; équivalent à ISO-8859-1)</td>
-  </tr>
- </tbody>
-</table>
-
-<h3 id="long_literal_strings">Littéraux pour les chaînes longues</h3>
-
-<p>Il peut arriver que le code contienne des chaînes plutôt longues. Plutôt que d'avoir des lignes qui s'étirent sur tout le fichier et dans un éditeur de code, il est possible de casser la chaîne sur plusieurs lignes sans que cela modifie le contenu de la chaîne. Il existe deux façons de faire.</p>
-
-<h4 id="method_1">Méthode 1</h4>
-
-<pre class="brush: js">
+```
+
+### Échappement des caractères
+
+En dehors des caractères classiques, des caractères spéciaux peuvent être encodés grâce à l'échappement :
+
+| Code                                                                                                     | Résultat                                                                                                                |
+| -------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------- |
+| `\0`                                                                                                     | Caractère nul (U+0000 NULL)                                                                                             |
+| `\'`                                                                                                     | simple quote (U+0027 APOSTROPHE)                                                                                        |
+| `\"`                                                                                                     | double quote (U+0022 QUOTATION MARK)                                                                                    |
+| `\\`                                                                                                     | barre oblique inversée (U+005C REVERSE SOLIDUS)                                                                         |
+| `\n`                                                                                                     | nouvelle ligne (U+000A LINE FEED; LF)                                                                                   |
+| `\r`                                                                                                     | retour chariot (U+000D CARRIAGE RETURN; CR)                                                                             |
+| `\v`                                                                                                     | tabulation verticale (U+000B LINE TABULATION)                                                                           |
+| `\t`                                                                                                     | tabulation (U+0009 CHARACTER TABULATION)                                                                                |
+| `\b`                                                                                                     | retour arrière (U+0008 BACKSPACE)                                                                                       |
+| `\f`                                                                                                     | saut de page (U+000C FORM FEED)                                                                                         |
+| `\uXXXX` (`XXXX` étant 4 chiffres hexadécimaux pour l'intervalle of 0x0000 - 0xFFFF)                     | Point de code Unicode entre U+0000 et U+FFFF (représente le plan Unicode multilingue basique)                           |
+| `\u{X}` ... `\u{XXXXXX}` (`X…XXXXXX` étant 1 à 6 chiffres hexadécimaux pour l'intervalle 0x0 - 0x10FFFF) | Point de code Unicode entre U+0000 et U+10FFFF (représente l'intégralité d'Unicode)                                     |
+| `\xXX` (`XX` étant 2 chiffres hexadécimaux pour l'intervalle 0x00 - 0xFF)                                | Point de code Unicode entre U+0000 et U+00FF (correspond à Basic Latin et Latin-1 supplement ; équivalent à ISO-8859-1) |
+
+### Littéraux pour les chaînes longues
+
+Il peut arriver que le code contienne des chaînes plutôt longues. Plutôt que d'avoir des lignes qui s'étirent sur tout le fichier et dans un éditeur de code, il est possible de casser la chaîne sur plusieurs lignes sans que cela modifie le contenu de la chaîne. Il existe deux façons de faire.
+
+#### Méthode 1
+
+```js
 let chaineLongue = "Voici une très longue chaîne qui a besoin " +
                    " d'être passée à la ligne parce que sinon " +
                    " ça risque de devenir illisible.";
-</pre>
+```
 
-<h4 id="method_2">Méthode 2</h4>
+#### Méthode 2
 
-<p>On peut sinon utiliser le caractère barre oblique inversée "\" à la fin de chaque ligne pour indiquer que la chaîne continue sur la ligne suivante. Il faut bien faire attention à ce que la barre oblique soit bien le dernier caractère de la ligne avant le saut de ligne. Sinon, cela ne fonctionnera pas. Voilà comment se présente cette forme :</p>
+On peut sinon utiliser le caractère barre oblique inversée "\\" à la fin de chaque ligne pour indiquer que la chaîne continue sur la ligne suivante. Il faut bien faire attention à ce que la barre oblique soit bien le dernier caractère de la ligne avant le saut de ligne. Sinon, cela ne fonctionnera pas. Voilà comment se présente cette forme :
 
-<pre class="brush: js">
+```js
 let chaineLongue = "Voici une très longue chaîne qui a besoin \
 d'être passée à la ligne parce que sinon \
 ça risque de devenir illisible.";
-</pre>
+```
 
-<h4 id="method_3">Méthode 3</h4>
+#### Méthode 3
 
-<p>Si les sauts de ligne doivent faire partie du résultat, on peut utiliser l'accent grave comme délimiteur de chaîne. Celui-ci permet d'utiliser des sauts de ligne à l'intérieur de la valeur littérale.</p>
+Si les sauts de ligne doivent faire partie du résultat, on peut utiliser l'accent grave comme délimiteur de chaîne. Celui-ci permet d'utiliser des sauts de ligne à l'intérieur de la valeur littérale.
 
-<pre class="brush: js">
+```js
 let chaineLongue = `Voici une très longue chaîne qui a besoin
 d'être passée à la ligne parce que sinon
 ça risque de devenir illisible.`;
-</pre>
-
-<h2 id="constructor">Constructeur</h2>
-
-<dl>
-  <dt><a href="/fr/docs/Web/JavaScript/Reference/String/String"><code>String()</code></a></dt>
-  <dd>Crée un nouvel <code>String</code>. S'il est appelé comme une fonction plutôt que comme un constructeur, il effectue une conversion de la valeur en chaîne de caractères.</dd>
-</dl>
-
-<h2 id="static_methods">Méthodes statiques</h2>
-
-<dl>
-  <dt><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String/fromCharCode"><code>String.fromCharCode(<var>num1</var> [, ...[,<var>numN</var>]])</code></a></dt>
-  <dd>Renvoie une chaîne de caractères créée en utilisant la séquence indiquée de valeurs Unicode.</dd>
-  <dt><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String/fromCodePoint"><code>String.fromCodePoint(<var>num1</var> [, ...[,<var>numN</var>]])</code></a></dt>
-  <dd>Renvoie une chaîne de caractères créée en utilisant la séquence indiquée de points de code.</dd>
-  <dt><dt><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String/raw"><code>String.raw()</code></a></dt></dt>
-  <dd>Renvoie une chaîne de caractères créée à partir d'un gabarit de chaîne de caractères brut.</dd>
-</dl>
-
-<h2 id="instance_properties">Propriétés des instances</h2>
-
-<dl>
-  <dt><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String/length"><code>String.prototype.length</code></a></dt>
-  <dd>Cette propriété indique la longueur de la chaîne de caractères. Elle est en lecture seule.</dd>
-</dl>
-
-<h2 id="instance_methods">Méthodes des instances</h2>
-
-<dl>
- <dt><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String/at"><code>String.prototype.at(<var>index</var>)</code></a>{{Experimental_Inline}}</dt>
- <dd>Renvoie le caractère (exactement un seul codet UTF-16) à l'indice indiqué par <code><var>index</var></code>. Les indices négatifs sont acceptés, dans ce cas ils indiquent la position par rapport au dernier caractère.</dd>
-  <dt><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String/charAt"><code>String.prototype.charAt(<var>index</var>)</code></a></dt>
-  <dd>Renvoie le caractère (exactement un seul codet UTF-16) à l'indice indiqué par <code><var>index</var></code>.</dd>
-  <dt><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String/charCodeAt"><code>String.prototype.charCodeAt(index)</code></a></dt>
-  <dd>Renvoie un nombre qui est la valeur du codet UTF-16 à l'indice indiqué par <code><var>index</var></code>.</dd>
-  <dt><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String/codePointAt"><code>String.prototype.codePointAt(pos)</code></a></dt>
-  <dd>Renvoie un entier positif qui correspond à la valeur du codet UTF-16 à la position indiquée par <code><var>pos</var></code>.</dd>
-  <dt><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String/concat"><code>String.prototype.concat(<var>str </var>[,...<var>strN </var>])</code></a></dt>
-  <dd>Combine le texte de deux (ou plusieurs) chaînes en une nouvelle chaîne de caractères.</dd>
-  <dt><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String/includes"><code>String.prototype.includes(searchString [, position])</code></a></dt>
-  <dd>Détermine si la chaîne de caractères courante contient <code><var>searchString</var></code>.
-  </dd>
-  <dt><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith"><code>String.prototype.endsWith(searchString [, length])</code></a></dt>
-  <dd>Détermine si la chaîne de caractères courante se termine par <code><var>searchString</var></code>.</dd>
-  <dt><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String/indexOf"><code>String.prototype.indexOf(searchValue [, fromIndex])</code></a></dt>
-  <dd>Renvoie l'indice, au sein de la chaîne courante, de la première occurrence de <code><var>searchValue</var></code> ou <code>-1</code> si ce motif n'est pas trouvé.
-  </dd>
-  <dt><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String/lastIndexOf"><code>String.prototype.lastIndexOf(searchValue [, fromIndex])</code></a>
-  </dt>
-  <dd>Renvoie l'indice, au sein de la chaîne courant, de la dernière occurrence de <code><var>searchValue</var></code> ou <code>-1</code> si ce motif n'est pas trouvé.
-  </dd>
-  <dt><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String/localeCompare"><code>String.prototype.localeCompare(compareString [, locales [, options]])</code></a></dt>
-  <dd>Renvoie un nombre indiquant si la chaîne courante vient avant ou après (ou est équivalente à ) <code><var>compareString</var></code> pour l'ordre de tri.</dd>
-  <dt><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String/match"><code>String.prototype.match(<var>regexp</var>)</code></a>
-  </dt>
-  <dd>Permet de tester la correspondance d'une expression rationnelle entre <code><var>regexp</var></code> et la chaîne de caractères courante.
-  </dd>
-  <dt><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String/matchAll"><code>String.prototype.matchAll(regexp)</code></a></dt>
-  <dd>Renvoie un itérateur contenant l'ensemble des correspondances de l'expression rationnelle <code><var>regexp</var></code> au sein de la chaîne de caractères courante.</dd>
-  <dt><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String/normalize"><code>String.prototype.normalize([form])</code></a></dt>
-  <dd>Renvoie la forme Unicode normalisée de la chaîne courante.</dd>
-  <dt><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String/padEnd"><code>String.prototype.padEnd(targetLength [, padString])</code></a></dt>
-  <dd>Complète la chaîne courante à la fin avec une chaîne donnée afin d'obtenir une longueur cible <code><var>targetLength</var></code> et renvoie la chaîne ainsi construite.</dd>
-  <dt><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String/padStart"><code>String.prototype.padStart(targetLength [, padString])</code></a></dt>
-  <dd>Complète la chaîne courante au début avec une chaîne donnée afin d'obtenir une longueur cible <code><var>targetLength</var></code> et renvoie la chaîne ainsi construite.</dd>
-  <dt><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String/repeat"><code>String.prototype.repeat(<var>count</var>)</code></a>
-  </dt>
-  <dd>Renvoie une chaîne de caractères qui est la répétition (<code><var>count</var></code> fois) de la chaîne de caractères courante.</dd>
-  <dt><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String/replace"><code>String.prototype.replace(searchFor, replaceWith)</code></a></dt>
-  <dd>Remplace les occurrences de <code><var>searchFor</var></code> par <code><var>replaceWith</var></code>. <code><var>searchFor</var></code> peut être une chaîne de caractères ou une expression rationnelle et <code><var>replaceWith</var></code> peut être une chaîne de caractères ou une fonction.</dd>
-  <dt><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String/replaceAll"><code>String.prototype.replaceAll(searchFor, replaceWith)</code></a></dt>
-  <dd>Remplace toutes les occurrences de <code><var>searchFor</var></code> avec <code><var>replaceWith</var></code>. <code><var>searchFor</var></code> peut être une chaîne de caractères ou une expression rationnelle et <code><var>replaceWith</var></code> peut être une chaîne de caractères ou une fonction.</dd>
-  <dt><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String/search"><code>String.prototype.search(regexp)</code></a></dt>
-  <dd>Recherche une correspondance entre une expression rationnelle <code><var>regexp</var></code> et la chaîne de caractères courante.</dd>
-  <dt><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String/slice"><code>String.prototype.slice(<var>beginIndex</var>[, <var>endIndex</var>])</code></a></dt>
-  <dd>Extrait une section de la chaîne de caractères et renvoie une nouvelle chaîne de caractères.</dd>
-  <dt><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String/split"><code>String.prototype.split([<var>sep</var> [, <var>limit</var>] ])</code></a></dt>
-  <dd>Renvoie un tableau de chaînes de caractères composé des fragments de la chaîne courante scindée à chaque occurrence de la sous-chaîne <code><var>sep</var></code>.</dd>
-  <dt><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith"><code>String.prototype.startsWith(searchString [, length])</code></a></dt>
-  <dd>Détermine si la chaîne courante commence par la chaîne de caractères indiquée en paramètre (<code><var>searchString</var></code>).</dd>
-  <dt><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String/substring"><code>String.prototype.substring(indexStart [, indexEnd])</code></a></dt>
-  <dd>Renvoie une nouvelle chaîne de caractères contenant les caractères de la chaîne courante, situés à partir de l'indice donné ou entre les indices donnés.</dd>
-  <dt><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase"><code>String.prototype.toLocaleLowerCase( [locale, ...locales])</code></a>
-  </dt>
-  <dd>
-    <p>Renvoie une conversion en minuscules de la chaîne de caractères courante qui respecte la locale indiquée.</p>
-
-    <p>Pour la plupart des langues, cela renverra la même valeur que <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase"><code>toLowerCase()</code></a>.</p>
-  </dd>
-  <dt><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase"><code>String.prototype.toLocaleUpperCase( [locale, ...locales])</code></a>
-  </dt>
-  <dd>
-    <p>Renvoie une conversion en majuscules de la chaîne de caractères courante qui respecte la locale indiquée.</p>
-
-    <p>Pour la plupart des langues, cela renverra la même valeur que <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase"><code>toUpperCase()</code></a>.</p>
-  </dd>
-  <dt><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase"><code>String.prototype.toLowerCase()</code></a></dt>
-  <dd>Renvoie la valeur de la chaîne de caractères, convertie en minuscules.</dd>
-  <dt><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String/toString"><code>String.prototype.toString()</code></a></dt>
-  <dd>Renvoie une chaîne de caractères représentant l'objet courant. Surcharge la méthode <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Object/toString"><code>Object.prototype.toString()</code></a>.</dd>
-  <dt><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase"><code>String.prototype.toUpperCase()</code></a></dt>
-  <dd>Renvoie la valeur de la chaîne de caractères, convertie en majuscules.</dd>
-  <dt><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String/Trim"><code>String.prototype.trim()</code></a></dt>
-  <dd>Retire les blancs situés au début et à la fin de la chaîne de caractères.</dd>
-  <dt><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String/trimStart"><code>String.prototype.trimStart()</code></a></dt>
-  <dd>Retire les blancs situés au début de la chaîne de caractères.</dd>
-  <dt><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String/trimEnd"><code>String.prototype.trimEnd()</code></a></dt>
-  <dd>Retire les blancs situés à la fin de la chaîne de caractères.</dd>
-  <dt><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String/valueOf"><code>String.prototype.valueOf()</code></a></dt>
-  <dd>Renvoie la valeur primitive de l'objet courant. Surcharge la méthode <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Object/valueOf"><code>Object.prototype.valueOf()</code></a>.</dd>
-  <dt><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String/@@iterator"><code>String.prototype.@@iterator()</code></a></dt>
-  <dd>Renvoie un nouvel objet itérateur qui permet d'itérer sur les points de code composant la chaîne de caractère. Chaque point de code est renvoyé comme une chaîne de caractères.</dd>
-</dl>
-
-<h2 id="html_wrapper_methods">Méthodes de conversion HTML</h2>
-
-<div class="notecard warning">
-  <p><strong>Attention :</strong> Ces méthodes sont dépréciées et ne doivent plus être utilisées.</p>
-
-  <p>Elles ont des possibilités limitées et ne concernent qu'une petite sous-partie des éléments et attributs HTML disponibles.</p>
-</div>
-
-<dl>
-  <dt><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String/anchor"><code>String.prototype.anchor()</code></a></dt>
-  <dd><a href="/fr/docs/Web/HTML/Element/a#attr-name"><code>&lt;a name="name"&gt;</code></a> (cible hypertexte)</dd>
-  <dt><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String/big"><code>String.prototype.big()</code></a></dt>
-  <dd><a href="/fr/docs/Web/HTML/Element/big"><code>&lt;big&gt;</code></a></dd>
-  <dt><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String/blink"><code>String.prototype.blink()</code></a></dt>
-  <dd><a href="/fr/docs/Web/HTML/Element/blink"><code>&lt;blink&gt;</code></a></dd>
-  <dt><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String/bold"><code>String.prototype.bold()</code></a></dt>
-  <dd><a href="/fr/docs/Web/HTML/Element/b"><code>&lt;b&gt;</code></a></dd>
-  <dt><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String/fixed"><code>String.prototype.fixed()</code></a></dt>
-  <dd><a href="/fr/docs/Web/HTML/Element/tt"><code>&lt;tt&gt;</code></a></dd>
-  <dt><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String/fontcolor"><code>String.prototype.fontcolor()</code></a></dt>
-  <dd><a href="/fr/docs/Web/HTML/Element/font#attr-color"><code>&lt;font color="color"&gt;</code></a></dd>
-  <dt><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String/fontsize"><code>String.prototype.fontsize()</code></a></dt>
-  <dd><a href="/fr/docs/Web/HTML/Element/font#attr-size"><code>&lt;font size="size"&gt;</code></a></dd>
-  <dt><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String/italics"><code>String.prototype.italics()</code></a></dt>
-  <dd><a href="/fr/docs/Web/HTML/Element/i"><code>&lt;i&gt;</code></a></dd>
-  <dt><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String/link"><code>String.prototype.link()</code></a></dt>
-  <dd><a href="/fr/docs/Web/HTML/Element/a#attr-href"><code>&lt;a href="url"&gt;</code></a> (lien d'une URL)</dd>
-  <dt><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String/small"><code>String.prototype.small()</code></a></dt>
-  <dd><a href="/fr/docs/Web/HTML/Element/small"><code>&lt;small&gt;</code></a></dd>
-  <dt><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String/strike"><code>String.prototype.strike()</code></a></dt>
-  <dd><a href="/fr/docs/Web/HTML/Element/strike"><code>&lt;strike&gt;</code></a></dd>
-  <dt><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String/sub"><code>String.prototype.sub()</code></a></dt>
-  <dd><a href="/fr/docs/Web/HTML/Element/sub"><code>&lt;sub&gt;</code></a></dd>
-  <dt><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String/sup"><code>String.prototype.sup()</code></a></dt>
-  <dd><a href="/fr/docs/Web/HTML/Element/sup"><code>&lt;sup&gt;</code></a></dd>
-</dl>
-
-<h2 id="exemples">Exemples</h2>
-
-<h3 id="string_conversion">Conversion en chaîne de caractères</h3>
-
-<p>Il est possible d'utiliser <code>String</code> comme une alternative à <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String/toString"><code>toString()</code></a> car cela permet de traiter les valeurs <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/null"><code>null</code></a>, <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/undefined"><code>undefined</code></a> et les <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Symbol">symboles</a>. Ainsi :</p>
-
-<pre class="brush: js">
+```
+
+## Constructeur
+
+- [`String()`](/fr/docs/Web/JavaScript/Reference/String/String)
+  - : Crée un nouvel `String`. S'il est appelé comme une fonction plutôt que comme un constructeur, il effectue une conversion de la valeur en chaîne de caractères.
+
+## Méthodes statiques
+
+- [`String.fromCharCode(num1 [, ...[,numN]])`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String/fromCharCode)
+  - : Renvoie une chaîne de caractères créée en utilisant la séquence indiquée de valeurs Unicode.
+- [`String.fromCodePoint(num1 [, ...[,numN]])`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String/fromCodePoint)
+  - : Renvoie une chaîne de caractères créée en utilisant la séquence indiquée de points de code.
+- [`String.raw()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String/raw)
+
+  - : Renvoie une chaîne de caractères créée à partir d'un gabarit de chaîne de caractères brut.
+
+## Propriétés des instances
+
+- [`String.prototype.length`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String/length)
+  - : Cette propriété indique la longueur de la chaîne de caractères. Elle est en lecture seule.
+
+## Méthodes des instances
+
+- [`String.prototype.at(index)`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String/at){{Experimental_Inline}}
+  - : Renvoie le caractère (exactement un seul codet UTF-16) à l'indice indiqué par `index`. Les indices négatifs sont acceptés, dans ce cas ils indiquent la position par rapport au dernier caractère.
+- [`String.prototype.charAt(index)`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String/charAt)
+  - : Renvoie le caractère (exactement un seul codet UTF-16) à l'indice indiqué par `index`.
+- [`String.prototype.charCodeAt(index)`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String/charCodeAt)
+  - : Renvoie un nombre qui est la valeur du codet UTF-16 à l'indice indiqué par `index`.
+- [`String.prototype.codePointAt(pos)`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String/codePointAt)
+  - : Renvoie un entier positif qui correspond à la valeur du codet UTF-16 à la position indiquée par `pos`.
+- [`String.prototype.concat(str [,...strN ])`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String/concat)
+  - : Combine le texte de deux (ou plusieurs) chaînes en une nouvelle chaîne de caractères.
+- [`String.prototype.includes(searchString [, position])`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String/includes)
+  - : Détermine si la chaîne de caractères courante contient `searchString`.
+- [`String.prototype.endsWith(searchString [, length])`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith)
+  - : Détermine si la chaîne de caractères courante se termine par `searchString`.
+- [`String.prototype.indexOf(searchValue [, fromIndex])`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String/indexOf)
+  - : Renvoie l'indice, au sein de la chaîne courante, de la première occurrence de `searchValue` ou `-1` si ce motif n'est pas trouvé.
+- [`String.prototype.lastIndexOf(searchValue [, fromIndex])`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String/lastIndexOf)
+  - : Renvoie l'indice, au sein de la chaîne courant, de la dernière occurrence de `searchValue` ou `-1` si ce motif n'est pas trouvé.
+- [`String.prototype.localeCompare(compareString [, locales [, options]])`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String/localeCompare)
+  - : Renvoie un nombre indiquant si la chaîne courante vient avant ou après (ou est équivalente à ) `compareString` pour l'ordre de tri.
+- [`String.prototype.match(regexp)`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String/match)
+  - : Permet de tester la correspondance d'une expression rationnelle entre `regexp` et la chaîne de caractères courante.
+- [`String.prototype.matchAll(regexp)`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String/matchAll)
+  - : Renvoie un itérateur contenant l'ensemble des correspondances de l'expression rationnelle `regexp` au sein de la chaîne de caractères courante.
+- [`String.prototype.normalize([form])`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String/normalize)
+  - : Renvoie la forme Unicode normalisée de la chaîne courante.
+- [`String.prototype.padEnd(targetLength [, padString])`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String/padEnd)
+  - : Complète la chaîne courante à la fin avec une chaîne donnée afin d'obtenir une longueur cible `targetLength` et renvoie la chaîne ainsi construite.
+- [`String.prototype.padStart(targetLength [, padString])`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String/padStart)
+  - : Complète la chaîne courante au début avec une chaîne donnée afin d'obtenir une longueur cible `targetLength` et renvoie la chaîne ainsi construite.
+- [`String.prototype.repeat(count)`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String/repeat)
+  - : Renvoie une chaîne de caractères qui est la répétition (`count` fois) de la chaîne de caractères courante.
+- [`String.prototype.replace(searchFor, replaceWith)`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String/replace)
+  - : Remplace les occurrences de `searchFor` par `replaceWith`. `searchFor` peut être une chaîne de caractères ou une expression rationnelle et `replaceWith` peut être une chaîne de caractères ou une fonction.
+- [`String.prototype.replaceAll(searchFor, replaceWith)`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String/replaceAll)
+  - : Remplace toutes les occurrences de `searchFor` avec `replaceWith`. `searchFor` peut être une chaîne de caractères ou une expression rationnelle et `replaceWith` peut être une chaîne de caractères ou une fonction.
+- [`String.prototype.search(regexp)`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String/search)
+  - : Recherche une correspondance entre une expression rationnelle `regexp` et la chaîne de caractères courante.
+- [`String.prototype.slice(beginIndex[, endIndex])`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String/slice)
+  - : Extrait une section de la chaîne de caractères et renvoie une nouvelle chaîne de caractères.
+- [`String.prototype.split([sep [, limit] ])`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String/split)
+  - : Renvoie un tableau de chaînes de caractères composé des fragments de la chaîne courante scindée à chaque occurrence de la sous-chaîne `sep`.
+- [`String.prototype.startsWith(searchString [, length])`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith)
+  - : Détermine si la chaîne courante commence par la chaîne de caractères indiquée en paramètre (`searchString`).
+- [`String.prototype.substring(indexStart [, indexEnd])`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String/substring)
+  - : Renvoie une nouvelle chaîne de caractères contenant les caractères de la chaîne courante, situés à partir de l'indice donné ou entre les indices donnés.
+- [`String.prototype.toLocaleLowerCase( [locale, ...locales])`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase)
+
+  - : Renvoie une conversion en minuscules de la chaîne de caractères courante qui respecte la locale indiquée.
+
+    Pour la plupart des langues, cela renverra la même valeur que [`toLowerCase()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase).
+
+- [`String.prototype.toLocaleUpperCase( [locale, ...locales])`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase)
+
+  - : Renvoie une conversion en majuscules de la chaîne de caractères courante qui respecte la locale indiquée.
+
+    Pour la plupart des langues, cela renverra la même valeur que [`toUpperCase()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase).
+
+- [`String.prototype.toLowerCase()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase)
+  - : Renvoie la valeur de la chaîne de caractères, convertie en minuscules.
+- [`String.prototype.toString()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String/toString)
+  - : Renvoie une chaîne de caractères représentant l'objet courant. Surcharge la méthode [`Object.prototype.toString()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Object/toString).
+- [`String.prototype.toUpperCase()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase)
+  - : Renvoie la valeur de la chaîne de caractères, convertie en majuscules.
+- [`String.prototype.trim()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String/Trim)
+  - : Retire les blancs situés au début et à la fin de la chaîne de caractères.
+- [`String.prototype.trimStart()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String/trimStart)
+  - : Retire les blancs situés au début de la chaîne de caractères.
+- [`String.prototype.trimEnd()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String/trimEnd)
+  - : Retire les blancs situés à la fin de la chaîne de caractères.
+- [`String.prototype.valueOf()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String/valueOf)
+  - : Renvoie la valeur primitive de l'objet courant. Surcharge la méthode [`Object.prototype.valueOf()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Object/valueOf).
+- [`String.prototype.@@iterator()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String/@@iterator)
+  - : Renvoie un nouvel objet itérateur qui permet d'itérer sur les points de code composant la chaîne de caractère. Chaque point de code est renvoyé comme une chaîne de caractères.
+
+## Méthodes de conversion HTML
+
+> **Attention :** Ces méthodes sont dépréciées et ne doivent plus être utilisées.
+>
+> Elles ont des possibilités limitées et ne concernent qu'une petite sous-partie des éléments et attributs HTML disponibles.
+
+- [`String.prototype.anchor()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String/anchor)
+  - : [`<a name="name">`](/fr/docs/Web/HTML/Element/a#attr-name) (cible hypertexte)
+- [`String.prototype.big()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String/big)
+  - : [`<big>`](/fr/docs/Web/HTML/Element/big)
+- [`String.prototype.blink()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String/blink)
+  - : [`<blink>`](/fr/docs/Web/HTML/Element/blink)
+- [`String.prototype.bold()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String/bold)
+  - : [`<b>`](/fr/docs/Web/HTML/Element/b)
+- [`String.prototype.fixed()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String/fixed)
+  - : [`<tt>`](/fr/docs/Web/HTML/Element/tt)
+- [`String.prototype.fontcolor()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String/fontcolor)
+  - : [`<font color="color">`](/fr/docs/Web/HTML/Element/font#attr-color)
+- [`String.prototype.fontsize()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String/fontsize)
+  - : [`<font size="size">`](/fr/docs/Web/HTML/Element/font#attr-size)
+- [`String.prototype.italics()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String/italics)
+  - : [`<i>`](/fr/docs/Web/HTML/Element/i)
+- [`String.prototype.link()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String/link)
+  - : [`<a href="url">`](/fr/docs/Web/HTML/Element/a#attr-href) (lien d'une URL)
+- [`String.prototype.small()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String/small)
+  - : [`<small>`](/fr/docs/Web/HTML/Element/small)
+- [`String.prototype.strike()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String/strike)
+  - : [`<strike>`](/fr/docs/Web/HTML/Element/strike)
+- [`String.prototype.sub()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String/sub)
+  - : [`<sub>`](/fr/docs/Web/HTML/Element/sub)
+- [`String.prototype.sup()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String/sup)
+  - : [`<sup>`](/fr/docs/Web/HTML/Element/sup)
+
+## Exemples
+
+### Conversion en chaîne de caractères
+
+Il est possible d'utiliser `String` comme une alternative à [`toString()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String/toString) car cela permet de traiter les valeurs [`null`](/fr/docs/Web/JavaScript/Reference/Global_Objects/null), [`undefined`](/fr/docs/Web/JavaScript/Reference/Global_Objects/undefined) et les [symboles](/fr/docs/Web/JavaScript/Reference/Global_Objects/Symbol). Ainsi :
+
+```js
 let chainesSortie = []
-for (let i = 0, n = valeursEntree.length; i &lt; n; ++i) {
+for (let i = 0, n = valeursEntree.length; i < n; ++i) {
   chainesSortie.push(String(valeursEntree[i]));
 }
-</pre>
+```
 
-<h2 id="specifications">Spécifications</h2>
+## Spécifications
 
-<p>{{Specifications}}</p>
+{{Specifications}}
 
-<h2 id="browser_compatibility">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat}}</p>
+{{Compat}}
 
-<h2 id="voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Text_formatting">Formatage du texte dans le guide JavaScript</a></li>
-  <li><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/RegExp"><code>RegExp</code></a></li>
-  <li><a href="/fr/docs/Web/API/DOMString"><code>DOMString</code></a></li>
-  <li><a href="/fr/docs/Web/API/DOMString/Binary">Les chaînes binaires</a></li>
-</ul>
+- [Formatage du texte dans le guide JavaScript](/fr/docs/Web/JavaScript/Guide/Text_formatting)
+- [`RegExp`](/fr/docs/Web/JavaScript/Reference/Global_Objects/RegExp)
+- [`DOMString`](/fr/docs/Web/API/DOMString)
+- [Les chaînes binaires](/fr/docs/Web/API/DOMString/Binary)
diff --git a/files/fr/web/javascript/reference/global_objects/string/indexof/index.md b/files/fr/web/javascript/reference/global_objects/string/indexof/index.md
index 69a0303542..f93922e7d7 100644
--- a/files/fr/web/javascript/reference/global_objects/string/indexof/index.md
+++ b/files/fr/web/javascript/reference/global_objects/string/indexof/index.md
@@ -10,69 +10,68 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/String/indexOf
 original_slug: Web/JavaScript/Reference/Objets_globaux/String/indexOf
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>indexOf()</code></strong> renvoie l'indice de la première occurence de la valeur cherchée au sein de la chaîne courante (à partir de <code>indexDébut</code>). Elle renvoie -1 si la valeur cherchée n'est pas trouvée.</p>
+La méthode **`indexOf()`** renvoie l'indice de la première occurence de la valeur cherchée au sein de la chaîne courante (à partir de `indexDébut`). Elle renvoie -1 si la valeur cherchée n'est pas trouvée.
 
-<div>{{EmbedInteractiveExample("pages/js/string-indexof.html")}}</div>
+{{EmbedInteractiveExample("pages/js/string-indexof.html")}}
 
+> **Note :** Pour la méthode associée aux tableaux, voir la page {{jsxref("Array.prototype.indexOf()")}}.
 
+## Syntaxe
 
-<div class="note">
-<p><strong>Note :</strong> Pour la méthode associée aux tableaux, voir la page {{jsxref("Array.prototype.indexOf()")}}.</p>
-</div>
+    str.indexOf(valeurRecherchée)
+    str.indexOf(valeurRecherchée, indexDébut)
 
-<h2 id="Syntaxe">Syntaxe</h2>
+### Paramètres
 
-<pre class="syntaxbox"><var>str</var>.indexOf(<var>valeurRecherchée</var>)
-<var>str</var>.indexOf(<var>valeurRecherchée</var>, <var>indexDébut</var>)
-</pre>
+- `valeurRecherchée`
+  - : Une chaîne représentant la valeur qu'on cherche dans la chaîne courante. Si aucune valeur n'est fournie explicitement,[ `valeurRecherchée` sera convertie en `"undefined"` et c'est cette chaîne qui sera recherchée](https://tc39.github.io/ecma262/#sec-tostring).
+- `indexDébut`
+  - : Paramètre optionnel. L'indice à partir duquel commencer la recherche, effectuée du début vers la fin de la liste. Cela peut être n'importe quel entier. La valeur par défaut est 0. Si `indexDébut < 0` la chaîne sera parcourue en entier (ce qui équivaut à utiliser 0). Si `indexDébut >= str.length`, la méthode renverra -1 sauf si `valeurRecherchée` est la chaîne vide, auquel cas, la méthode renverra `str.length`.
 
-<h3 id="Paramètres">Paramètres</h3>
+### Valeur de retour
 
-<dl>
- <dt><code>valeurRecherchée</code></dt>
- <dd>Une chaîne représentant la valeur qu'on cherche dans la chaîne courante. Si aucune valeur n'est fournie explicitement,<a href="https://tc39.github.io/ecma262/#sec-tostring"> <code>valeurRecherchée</code> sera convertie en <code>"undefined"</code> et c'est cette chaîne qui sera recherchée</a>.</dd>
- <dt><code>indexDébut</code></dt>
- <dd>Paramètre optionnel. L'indice à partir duquel commencer la recherche, effectuée du début vers la fin de la liste. Cela peut être n'importe quel entier. La valeur par défaut est 0. Si <code>indexDébut &lt; 0</code> la chaîne sera parcourue en entier (ce qui équivaut à utiliser 0). Si <code>indexDébut &gt;= str.length</code>, la méthode renverra -1 sauf si <code>valeurRecherchée</code> est la chaîne vide, auquel cas, la méthode renverra <code>str.length</code>.</dd>
-</dl>
+L'indice de la première occurrence de la valeur indiquée, `-1` si elle n'est pas trouvée. Si la valeur recherchée est la chaîne vide, une correspondance sera trouvée à n'importe quel index entre `0` et `str.length`.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+## Description
 
-<p>L'indice de la première occurrence de la valeur indiquée, <code>-1</code> si elle n'est pas trouvée. Si la valeur recherchée est la chaîne vide, une correspondance sera trouvée à n'importe quel index entre <code>0</code> et <code>str.length</code>.</p>
+Les caractères dans une chaîne de caractères sont indexés de la gauche à la droite. L'indice du premier caractère est 0, celui du dernier caractère (d'une chaîne `str`) est `str.length - 1.`
 
-<h2 id="Description">Description</h2>
-
-<p>Les caractères dans une chaîne de caractères sont indexés de la gauche à la droite. L'indice du premier caractère est 0, celui du dernier caractère (d'une chaîne <code>str</code>) est <code>str.length - 1.</code></p>
-
-<pre class="brush: js">"Blue Whale".indexOf("Blue");     // retourne  0
+```js
+"Blue Whale".indexOf("Blue");     // retourne  0
 "Blue Whale".indexOf("Blute");    // retourne -1
 "Blue Whale".indexOf("Whale", 0); // retourne  5
 "Blue Whale".indexOf("Whale", 5); // retourne  5
 "Blue Whale".indexOf("");         // retourne  0
 "Blue Whale".indexOf("", 9);      // retourne  9
 "Blue Whale".indexOf("", 10);     // retourne 10
-"Blue Whale".indexOf("", 11);     // retourne 10</pre>
+"Blue Whale".indexOf("", 11);     // retourne 10
+```
 
-<h3 id="Sensibilité_à_la_casse">Sensibilité à la casse</h3>
+### Sensibilité à la casse
 
-<p>La méthode <code>indexOf()</code> est sensible à la casse. Par exemple, l'expression suivante retourne -1 :</p>
+La méthode `indexOf()` est sensible à la casse. Par exemple, l'expression suivante retourne -1 :
 
-<pre class="brush: js">"Blue Whale".indexOf("blue") // retourne -1
-</pre>
+```js
+"Blue Whale".indexOf("blue") // retourne -1
+```
 
-<p>Attention : <code>0</code> n'est pas une valeur qui peut être évaluée à <code>true</code> et <code>-1</code> n'est pas une valeur qui peut être évaluée à <code>false</code>. Ainsi, si on souhaite tester si une chaîne de caractères existe au sein d'une autre chaîne de caractères, on procèdera de cette façon (ou on utilisera {{jsxref("String.prototype.includes()")}}</p>
+Attention : `0` n'est pas une valeur qui peut être évaluée à `true` et `-1` n'est pas une valeur qui peut être évaluée à `false`. Ainsi, si on souhaite tester si une chaîne de caractères existe au sein d'une autre chaîne de caractères, on procèdera de cette façon (ou on utilisera {{jsxref("String.prototype.includes()")}}
 
-<pre class="brush: js">"Blue Whale".indexOf("Blue") != -1; // true
-"Blue Whale".indexOf("Bloe") != -1; // false</pre>
+```js
+"Blue Whale".indexOf("Blue") != -1; // true
+"Blue Whale".indexOf("Bloe") != -1; // false
+```
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_indexOf()_et_lastIndexOf()">Utiliser <code>indexOf()</code> et <code>lastIndexOf()</code></h3>
+### Utiliser `indexOf()` et `lastIndexOf()`
 
-<p>L'exemple suivant utilise <code>indexOf()</code> et <code>lastIndexOf()</code> pour localiser différentes valeurs dans la chaîne de caractères "<code>Brave new world</code>".</p>
+L'exemple suivant utilise `indexOf()` et `lastIndexOf()` pour localiser différentes valeurs dans la chaîne de caractères "`Brave new world`".
 
-<pre class="brush: js">const uneChaîne = "Brave new world"
+```js
+const uneChaîne = "Brave new world"
 
 console.log("Indice du premier w " + uneChaîne.indexOf("w"));
 // Affiche 8
@@ -83,25 +82,28 @@ console.log("Indice du premier 'new' " + uneChaîne.indexOf("new"));
 // Affiche 6
 console.log("Indice du dernier 'new' " + uneChaîne.lastIndexOf("new"));
 // Affiche 6
-</pre>
+```
 
-<h3 id="indexOf()_et_la_sensibilité_à_la_casse"><code>indexOf()</code> et la sensibilité à la casse</h3>
+### `indexOf()` et la sensibilité à la casse
 
-<p>L'exemple suivant définit 2 chaînes de caractères. Ces variables contiennent la meme chaîne de caractères sauf que la seconde chaîne de caractères contient des lettres majuscules. La première méthode <code>writeln</code> affiche 19. Cependant, comme la méthode <code>indexOf</code> est sensible à la casse, la chaîne de caractères "<code>cheddar</code>" n'est pas trouvée dans <code>myCapString</code>, donc le second résultat affiche -1.</p>
+L'exemple suivant définit 2 chaînes de caractères. Ces variables contiennent la meme chaîne de caractères sauf que la seconde chaîne de caractères contient des lettres majuscules. La première méthode `writeln` affiche 19. Cependant, comme la méthode `indexOf` est sensible à la casse, la chaîne de caractères "`cheddar`" n'est pas trouvée dans `myCapString`, donc le second résultat affiche -1.
 
-<pre class="brush: js">const maChaîne = "brie, reblochon, cheddar";
+```js
+const maChaîne = "brie, reblochon, cheddar";
 const maChaîneMajuscules = "Brie, Reblochon, Cheddar";
 
 console.log('maChaîne.indexOf("cheddar") is '+ maChaîne.indexOf("cheddar"));
 // Affiche 19
 console.log('maChaîneMajuscules.indexOf("cheddar") is ' + maChaîneMajuscules.indexOf("cheddar"));
-// Affiche -1</pre>
+// Affiche -1
+```
 
-<h3 id="Utiliser_indexOf()_pour_compter_le_nombre_d'occurences_dans_une_chaîne_de_caractères">Utiliser <code>indexOf()</code> pour compter le nombre d'occurences dans une chaîne de caractères</h3>
+### Utiliser `indexOf()` pour compter le nombre d'occurences dans une chaîne de caractères
 
-<p>L'exemple suivant utilise la variable <code>count</code> pour stocker le nombre d'occurences de la lettre <code>x</code> dans la chaîne de caractère <code>str</code> :</p>
+L'exemple suivant utilise la variable `count` pour stocker le nombre d'occurences de la lettre `x` dans la chaîne de caractère `str` :
 
-<pre class="brush: js">const str = "Chaîne x de test x";
+```js
+const str = "Chaîne x de test x";
 let count = 0;
 let pos = str.indexOf("x");
 
@@ -109,52 +111,26 @@ while ( pos != -1 ) {
    count++;
    pos = str.indexOf( "x",pos + 1 );
 }
-console.log(count); // Affiche 2</pre>
-
-<h2 id="Spécifications">Spécifications</h2>
-
-<table class="standard-table">
- <thead>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">État</th>
-   <th scope="col">Commentaires</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td>{{SpecName('ES1')}}</td>
-   <td>{{Spec2('ES1')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.5.4.7', 'String.prototype.indexOf')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-string.prototype.indexof', 'String.prototype.indexOf')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-string.prototype.indexof', 'String.prototype.indexOf')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.String.indexOf")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("String.prototype.charAt()")}}</li>
- <li>{{jsxref("String.prototype.lastIndexOf()")}}</li>
- <li>{{jsxref("String.prototype.includes()")}}</li>
- <li>{{jsxref("String.prototype.split()")}}</li>
- <li>{{jsxref("Array.prototype.indexOf()")}}</li>
-</ul>
+console.log(count); // Affiche 2
+```
+
+## Spécifications
+
+| Spécification                                                                                                    | État                         | Commentaires         |
+| ---------------------------------------------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ES1')}}                                                                                         | {{Spec2('ES1')}}         | Définition initiale. |
+| {{SpecName('ES5.1', '#sec-15.5.4.7', 'String.prototype.indexOf')}}                         | {{Spec2('ES5.1')}}     |                      |
+| {{SpecName('ES6', '#sec-string.prototype.indexof', 'String.prototype.indexOf')}}     | {{Spec2('ES6')}}         |                      |
+| {{SpecName('ESDraft', '#sec-string.prototype.indexof', 'String.prototype.indexOf')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.String.indexOf")}}
+
+## Voir aussi
+
+- {{jsxref("String.prototype.charAt()")}}
+- {{jsxref("String.prototype.lastIndexOf()")}}
+- {{jsxref("String.prototype.includes()")}}
+- {{jsxref("String.prototype.split()")}}
+- {{jsxref("Array.prototype.indexOf()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/string/italics/index.md b/files/fr/web/javascript/reference/global_objects/string/italics/index.md
index 06525ca226..c75daae3f5 100644
--- a/files/fr/web/javascript/reference/global_objects/string/italics/index.md
+++ b/files/fr/web/javascript/reference/global_objects/string/italics/index.md
@@ -11,72 +11,58 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/String/italics
 original_slug: Web/JavaScript/Reference/Objets_globaux/String/italics
 ---
-<div>{{JSRef}}{{deprecated_header}}</div>
+{{JSRef}}{{deprecated_header}}
 
-<p>La méthode <code><strong>italics()</strong></code> permet de créer un élément HTML {{HTMLElement("i")}} qui permet de représenter la chaîne courante en italique.</p>
+La méthode **`italics()`** permet de créer un élément HTML {{HTMLElement("i")}} qui permet de représenter la chaîne courante en italique.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>str</var>.italics()</pre>
+    str.italics()
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une chaîne de caractères représentant un élément HTML {{HTMLElement("i")}}.</p>
+Une chaîne de caractères représentant un élément HTML {{HTMLElement("i")}}.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La méthode <code>italics</code> encadre la chaîne de caractères dans une balise <code>&lt;i&gt;</code> :<br>
- <code>"&lt;i&gt;str&lt;/i&gt;</code>"</p>
+La méthode `italics` encadre la chaîne de caractères dans une balise `<i>` :
+`"<i>str</i>`"
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<p>Les méthodes des chaînes de caractères peuvent être utilisées pour changer le formatage d'une chaîne de caractères :</p>
+Les méthodes des chaînes de caractères peuvent être utilisées pour changer le formatage d'une chaîne de caractères :
 
-<pre class="brush:js">var worldString = "Coucou monde";
+```js
+var worldString = "Coucou monde";
 
 console.log(worldString.blink());
 console.log(worldString.bold());
 console.log(worldString.italics());
 console.log(worldString.strike());
-</pre>
-
-<p>Cet exemple permet de produire le fragment HTML suivant dans la console :</p>
-
-<pre class="brush:html">&lt;blink&gt;Coucou monde&lt;/blink&gt;
-&lt;b&gt;Coucou monde&lt;/b&gt;
-&lt;i&gt;Coucou monde&lt;/i&gt;
-&lt;strike&gt;Coucou monde&lt;/strike&gt;</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('ES6', '#sec-string.prototype.italics', 'String.prototype.italics')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Définition initiale. Implémentée dans JavaScript 1.0. Définie dans l'annexe B (normative) pour les fonctionnalités ECMAScript additionnelles pour les navigateurs web.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-string.prototype.italics', 'String.prototype.italics')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td>Définie dans l'annexe B (normative) pour les fonctionnalités ECMAScript additionnelles pour les navigateurs web.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.String.italics")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("String.prototype.blink()")}}</li>
- <li>{{jsxref("String.prototype.bold()")}}</li>
- <li>{{jsxref("String.prototype.strike()")}}</li>
-</ul>
+```
+
+Cet exemple permet de produire le fragment HTML suivant dans la console :
+
+```html
+<blink>Coucou monde</blink>
+<b>Coucou monde</b>
+<i>Coucou monde</i>
+<strike>Coucou monde</strike>
+```
+
+## Spécifications
+
+| Spécification                                                                                                    | État                         | Commentaires                                                                                                                                                           |
+| ---------------------------------------------------------------------------------------------------------------- | ---------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| {{SpecName('ES6', '#sec-string.prototype.italics', 'String.prototype.italics')}}     | {{Spec2('ES6')}}         | Définition initiale. Implémentée dans JavaScript 1.0. Définie dans l'annexe B (normative) pour les fonctionnalités ECMAScript additionnelles pour les navigateurs web. |
+| {{SpecName('ESDraft', '#sec-string.prototype.italics', 'String.prototype.italics')}} | {{Spec2('ESDraft')}} | Définie dans l'annexe B (normative) pour les fonctionnalités ECMAScript additionnelles pour les navigateurs web.                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.String.italics")}}
+
+## Voir aussi
+
+- {{jsxref("String.prototype.blink()")}}
+- {{jsxref("String.prototype.bold()")}}
+- {{jsxref("String.prototype.strike()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/string/lastindexof/index.md b/files/fr/web/javascript/reference/global_objects/string/lastindexof/index.md
index fc5c35bb08..cbaef2655e 100644
--- a/files/fr/web/javascript/reference/global_objects/string/lastindexof/index.md
+++ b/files/fr/web/javascript/reference/global_objects/string/lastindexof/index.md
@@ -10,34 +10,33 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/String/lastIndexOf
 original_slug: Web/JavaScript/Reference/Objets_globaux/String/lastIndexOf
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>lastIndexOf()</code></strong> renvoie l'indice, dans la chaîne courante, de la dernière occurence de la valeur donnée en argument. Si cette sous-chaîne n'est pas trouvée, la méthode renvoie -1. La recherche s'effectue de la fin vers le début de la chaîne, à partir de <code>indiceDébut</code>.</p>
+La méthode **`lastIndexOf()`** renvoie l'indice, dans la chaîne courante, de la dernière occurence de la valeur donnée en argument. Si cette sous-chaîne n'est pas trouvée, la méthode renvoie -1. La recherche s'effectue de la fin vers le début de la chaîne, à partir de `indiceDébut`.
 
-<div>{{EmbedInteractiveExample("pages/js/string-lastindexof.html")}}</div>
+{{EmbedInteractiveExample("pages/js/string-lastindexof.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox notranslate"><var>str</var>.lastIndexOf(<var>valeurRecherchée</var>[, <var>indiceDébut</var>])</pre>
+    str.lastIndexOf(valeurRecherchée[, indiceDébut])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>valeurRecherchée</code></dt>
- <dd>Une chaîne qu'on recherche dans la chaîne courante. Si ce paramètre n'est pas défini et que <code>indiceDébut</code> est utilisé, c'est ce dernier qui sera renvoyé par la fonction.</dd>
- <dt><code>indiceDébut </code>{{optional_inline}}</dt>
- <dd>Paramètre optionnel. L'emplacement, dans la chaîne courante, à partir duquel effectuer la recherche (en partant de la fin de la chaîne et en remontant vers le début). Cela peut être n'importe quel entier. La valeur par défaut est <code>+Infinity</code>. Si<code> indiceDébut &gt; str.length</code>, toute la chaîne sera parcourue. Si <code>indiceDébut &lt; 0</code>,  on aura le même comportement que si <code>indiceDébut</code> valait 0.</dd>
-</dl>
+- `valeurRecherchée`
+  - : Une chaîne qu'on recherche dans la chaîne courante. Si ce paramètre n'est pas défini et que `indiceDébut` est utilisé, c'est ce dernier qui sera renvoyé par la fonction.
+- `indiceDébut `{{optional_inline}}
+  - : Paramètre optionnel. L'emplacement, dans la chaîne courante, à partir duquel effectuer la recherche (en partant de la fin de la chaîne et en remontant vers le début). Cela peut être n'importe quel entier. La valeur par défaut est `+Infinity`. Si` indiceDébut > str.length`, toute la chaîne sera parcourue. Si `indiceDébut < 0`,  on aura le même comportement que si `indiceDébut` valait 0.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>L'indice de la dernière occurrence de la valeur indiquée, <code>-1</code> si elle n'est pas trouvée.</p>
+L'indice de la dernière occurrence de la valeur indiquée, `-1` si elle n'est pas trouvée.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Les caractères d'une chaîne de caractères sont indexés de gauche à droite. L'indice du premier caractère vaut 0 et l'indice du dernier caractère vaut <code>maChaîne.length - 1</code>.</p>
+Les caractères d'une chaîne de caractères sont indexés de gauche à droite. L'indice du premier caractère vaut 0 et l'indice du dernier caractère vaut `maChaîne.length - 1`.
 
-<pre class="brush: js notranslate">'canal'.lastIndexOf('a');     // renvoie 3
+```js
+'canal'.lastIndexOf('a');     // renvoie 3
 'canal'.lastIndexOf('a', 2);  // renvoie 1
 'canal'.lastIndexOf('a', 0);  // renvoie -1
 'canal'.lastIndexOf('x');     // renvoie -1
@@ -45,24 +44,24 @@ original_slug: Web/JavaScript/Reference/Objets_globaux/String/lastIndexOf
 'canal'.lastIndexOf('c', 0);  // renvoie 0
 'canal'.lastIndexOf('');      // renvoie 5
 'canal'.lastIndexOf('', 2);   // renvoie 2
-</pre>
+```
 
-<div class="note">
-<p><strong>Note :</strong> <code>'abab'.lastIndexOf('ab', 2)</code> renvoie <code>2</code> et pas <code>0</code> car l'argument <code>indiceDébut</code> ne limite que le début de la correspondance recherchée ( qui est <code>'ab'</code>)</p>
-</div>
+> **Note :** `'abab'.lastIndexOf('ab', 2)` renvoie `2` et pas `0` car l'argument `indiceDébut` ne limite que le début de la correspondance recherchée ( qui est `'ab'`)
 
-<h3 id="Sensibilité_à_la_casse">Sensibilité à la casse</h3>
+### Sensibilité à la casse
 
-<p>La méthode <code>lastIndexOf()</code> est sensible à la casse (une lettre en minuscule (i) est différente d'une lettre en majuscule (I)). Ainsi, le résultat de l'expression suivante sera -1 :</p>
+La méthode `lastIndexOf()` est sensible à la casse (une lettre en minuscule (i) est différente d'une lettre en majuscule (I)). Ainsi, le résultat de l'expression suivante sera -1 :
 
-<pre class="brush: js notranslate">'Blue Whale, Killer Whale'.lastIndexOf('blue'); // renvoie -1
-</pre>
+```js
+'Blue Whale, Killer Whale'.lastIndexOf('blue'); // renvoie -1
+```
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<p>Dans l'exemple suivant, on utilise {{jsxref("String.prototype.indexOf()", "indexOf()")}} et <code>lastIndexOf()</code> pour situer certaines valeurs dans la chaîne <code>"Brave new world"</code>.</p>
+Dans l'exemple suivant, on utilise {{jsxref("String.prototype.indexOf()", "indexOf()")}} et `lastIndexOf()` pour situer certaines valeurs dans la chaîne `"Brave new world"`.
 
-<pre class="brush: js notranslate">var maChaîne = 'Brave new world';
+```js
+var maChaîne = 'Brave new world';
 
 console.log('Indice du premier w ' + maChaîne.indexOf('w'));
 // Affiche 8
@@ -73,50 +72,25 @@ console.log('Indice du premier "new" ' + maChaîne.indexOf('new'));
 // Affiche 6
 console.log('Indice du dernier "new" ' + maChaîne.lastIndexOf('new'));
 // Affiche 6
-</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('ES1')}}</td>
-   <td>{{Spec2('ES1')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.5.4.8', 'String.prototype.lastIndexOf')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-string.prototype.lastindexof', 'String.prototype.lastIndexOf')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-string.prototype.lastindexof', 'String.prototype.lastIndexOf')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.String.lastIndexOf")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("String.prototype.charAt()")}}</li>
- <li>{{jsxref("String.prototype.indexOf()")}}</li>
- <li>{{jsxref("String.prototype.split()")}}</li>
- <li>{{jsxref("Array.prototype.indexOf()")}}</li>
- <li>{{jsxref("Array.prototype.lastIndexOf()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                                | État                         | Commentaires         |
+| ---------------------------------------------------------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ES1')}}                                                                                                     | {{Spec2('ES1')}}         | Définition initiale. |
+| {{SpecName('ES5.1', '#sec-15.5.4.8', 'String.prototype.lastIndexOf')}}                                 | {{Spec2('ES5.1')}}     |                      |
+| {{SpecName('ES6', '#sec-string.prototype.lastindexof', 'String.prototype.lastIndexOf')}}         | {{Spec2('ES6')}}         |                      |
+| {{SpecName('ESDraft', '#sec-string.prototype.lastindexof', 'String.prototype.lastIndexOf')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.String.lastIndexOf")}}
+
+## Voir aussi
+
+- {{jsxref("String.prototype.charAt()")}}
+- {{jsxref("String.prototype.indexOf()")}}
+- {{jsxref("String.prototype.split()")}}
+- {{jsxref("Array.prototype.indexOf()")}}
+- {{jsxref("Array.prototype.lastIndexOf()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/string/length/index.md b/files/fr/web/javascript/reference/global_objects/string/length/index.md
index d3f3f49913..4bbb30640d 100644
--- a/files/fr/web/javascript/reference/global_objects/string/length/index.md
+++ b/files/fr/web/javascript/reference/global_objects/string/length/index.md
@@ -10,89 +10,66 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/String/length
 original_slug: Web/JavaScript/Reference/Objets_globaux/String/length
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La propriété <strong><code>length</code></strong> représente la longueur d'une chaine de caractères, exprimée en nombre de points de code UTF-16. C'est une propriété accessible en lecture seule.</p>
+La propriété **`length`** représente la longueur d'une chaine de caractères, exprimée en nombre de points de code UTF-16. C'est une propriété accessible en lecture seule.
 
-<div>{{EmbedInteractiveExample("pages/js/string-length.html")}}</div>
+{{EmbedInteractiveExample("pages/js/string-length.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>str</var>.length</pre>
+    str.length
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Cette propriété renvoie le nombre de « codets » (ou unités de code ou bien <em>code units</em> en anglais) d'une chaîne de caractères. {{interwiki("wikipedia", "UTF-16")}}. Le format utilisé pour représenter les chaînes de caractères en JavaScript utilise un seul codet sur 16 bits pour représenter la plupart des caractères communs. En revanche, pour représenter les caractères plus rares, deux codets seront utilisés : la valeur renvoyée par <code>length</code> ne correspondra alors pas au nombre de caractères dans la chaîne.</p>
+Cette propriété renvoie le nombre de « codets » (ou unités de code ou bien _code units_ en anglais) d'une chaîne de caractères. {{interwiki("wikipedia", "UTF-16")}}. Le format utilisé pour représenter les chaînes de caractères en JavaScript utilise un seul codet sur 16 bits pour représenter la plupart des caractères communs. En revanche, pour représenter les caractères plus rares, deux codets seront utilisés : la valeur renvoyée par `length` ne correspondra alors pas au nombre de caractères dans la chaîne.
 
-<p>ECMAScript 2016 (la septième édition) établit une longueur maximale de <code>2^53 - 1</code> éléments. Auparavant, aucune longueur maximale n'était spécifiée. Pour Firefox, les chaînes ont une longueur maximale de <code>2^30-2</code> caractères (environ 1 Go). Pour les versions de Firefox antérieures à Firefox 65, la taille maximale était de de <code>2^28-1</code> (environ 256 Mo).</p>
+ECMAScript 2016 (la septième édition) établit une longueur maximale de `2^53 - 1` éléments. Auparavant, aucune longueur maximale n'était spécifiée. Pour Firefox, les chaînes ont une longueur maximale de `2^30-2` caractères (environ 1 Go). Pour les versions de Firefox antérieures à Firefox 65, la taille maximale était de de `2^28-1` (environ 256 Mo).
 
-<p>Pour une chaine vide, on aura <code>length</code> égal à 0.</p>
+Pour une chaine vide, on aura `length` égal à 0.
 
-<p>La propriété statique <code>String.length</code> renvoie la valeur 1.</p>
+La propriété statique `String.length` renvoie la valeur 1.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_String.length">Utiliser <code>String.length</code></h3>
+### Utiliser `String.length`
 
-<pre class="brush: js">const x = "Mozilla";
+```js
+const x = "Mozilla";
 const vide = "";
 
 console.log(x + " mesure " + x.length + " codets");
 /* "Mozilla mesure 7 codets" */
 
 console.log("La chaîne vide a une longueur de " + vide.length);
-/* "La chaîne vide a une longueur de 0" */</pre>
+/* "La chaîne vide a une longueur de 0" */
+```
 
-<h3 id="Affecter_une_valeur_à_length">Affecter une valeur à <code>length</code></h3>
+### Affecter une valeur à `length`
 
-<pre class="brush: js"><code>const maChaine = "Sloubi";
+```js
+const maChaine = "Sloubi";
 // Lorsqu'on tente d'affecter une valeur à la propriété length
 // rien d'observable ne se produit
 
 maChaine.length = 3;
 console.log(maChaine); /* Sloubi */
-console.log(maChaine.length); // 6</code>
-</pre>
-
-<h2 id="Spécifications">Spécifications</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">Statut</th>
-   <th scope="col">Commentaires</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES1')}}</td>
-   <td>{{Spec2('ES1')}}</td>
-   <td>Définition initiale.<br>
-    Implémentée avec JavaScript 1.0.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.5.5.1', 'String.prototype.length')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-properties-of-string-instances-length', 'String.prototype.length')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-properties-of-string-instances-length', 'String.prototype.length')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.String.length")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li><a href="http://developer.teradata.com/blog/jasonstrimpel/2011/11/javascript-string-length-and-internationalizing-web-applications">La propriété JavaScript <code>String.length</code> et l'internationalisation des applications web</a> (en anglais)</li>
-</ul>
+console.log(maChaine.length); // 6
+```
+
+## Spécifications
+
+| Spécification                                                                                                                    | Statut                       | Commentaires                                          |
+| -------------------------------------------------------------------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- |
+| {{SpecName('ES1')}}                                                                                                         | {{Spec2('ES1')}}         | Définition initiale. Implémentée avec JavaScript 1.0. |
+| {{SpecName('ES5.1', '#sec-15.5.5.1', 'String.prototype.length')}}                                         | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-properties-of-string-instances-length', 'String.prototype.length')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-properties-of-string-instances-length', 'String.prototype.length')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.String.length")}}
+
+## Voir aussi
+
+- [La propriété JavaScript `String.length` et l'internationalisation des applications web](http://developer.teradata.com/blog/jasonstrimpel/2011/11/javascript-string-length-and-internationalizing-web-applications) (en anglais)
diff --git a/files/fr/web/javascript/reference/global_objects/string/link/index.md b/files/fr/web/javascript/reference/global_objects/string/link/index.md
index f942d61c5a..d3188e88f6 100644
--- a/files/fr/web/javascript/reference/global_objects/string/link/index.md
+++ b/files/fr/web/javascript/reference/global_objects/string/link/index.md
@@ -10,75 +10,56 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/String/link
 original_slug: Web/JavaScript/Reference/Objets_globaux/String/link
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>link()</strong></code> permet de créer une chaîne de caractères représentant un élément HTML {{HTMLElement("a")}}, ce qui permet d'afficher la chaîne de caractères comme un lien hypertexte vers une URL donnée.</p>
+La méthode **`link()`** permet de créer une chaîne de caractères représentant un élément HTML {{HTMLElement("a")}}, ce qui permet d'afficher la chaîne de caractères comme un lien hypertexte vers une URL donnée.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>str</var>.link(<var>url</var>)</pre>
+    str.link(url)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>url</code></dt>
- <dd>Toute chaîne de caractères pouvant être utilisée comme valeur pour l'attribut <code>href</code> de la balise <code>a</code>. Cette chaîne doit être une URL valide (relative ou absolue) dont les caractères <code>&amp;</code> sont échappés en <code>&amp;amp;</code>, et dont les doubles quotes (<code>"</code>) doivent être échappées avec l'entité <code>&amp;quot;</code>.</dd>
-</dl>
+- `url`
+  - : Toute chaîne de caractères pouvant être utilisée comme valeur pour l'attribut `href` de la balise `a`. Cette chaîne doit être une URL valide (relative ou absolue) dont les caractères `&` sont échappés en `&amp;`, et dont les doubles quotes (`"`) doivent être échappées avec l'entité `&quot;`.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une chaîne de caractères représentant un élément HTML {{HTMLElement("a")}}.</p>
+Une chaîne de caractères représentant un élément HTML {{HTMLElement("a")}}.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La méthode <code>link</code> permet de créer un fragment HTML avec un lien hypertexte. Le chaîne renvoyée par la méthode peut ensuite être ajoutée au document grâce aux méthodes {{domxref("document.write()")}} ou {{domxref("element.innerHTML")}}.</p>
+La méthode `link` permet de créer un fragment HTML avec un lien hypertexte. Le chaîne renvoyée par la méthode peut ensuite être ajoutée au document grâce aux méthodes {{domxref("document.write()")}} ou {{domxref("element.innerHTML")}}.
 
-<p>Les liens créés avec la méthode <code>link</code> deviennent des éléments du tableau <code>links</code>, membre de l'objet <code>document</code>. Voir {{ Domxref("document.links") }}.</p>
+Les liens créés avec la méthode `link` deviennent des éléments du tableau `links`, membre de l'objet `document`. Voir {{ Domxref("document.links") }}.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<p>L'exemple qui suit affiche le texte "MDN" avec un hyperlien qui envoie l'utilisateur vers le site du Mozilla Developer Network.</p>
+L'exemple qui suit affiche le texte "MDN" avec un hyperlien qui envoie l'utilisateur vers le site du Mozilla Developer Network.
 
-<pre class="brush:js">var texteAffiché = "MDN";
+```js
+var texteAffiché = "MDN";
 var URL = "https://developer.mozilla.org/";
 
 console.log("Cliquer ici pour revenir sur " + texteAffiché.link(URL));
-// Cliquer ici pour revenir sur &lt;a href="https://developer.mozilla.org/"&gt;MDN&lt;/a&gt;</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('ES6', '#sec-string.prototype.link', 'String.prototype.link')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Définition initiale. Implémentée avec JavaScript 1.0. Définie dans l'Annexe B (normative) pour les fonctionnalités ECMAScript additionnelles concernant les navigateurs web.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-string.prototype.link', 'String.prototype.link')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td>Définie dans l'Annexe B (normative) pour les fonctionnalités ECMAScript additionnelles concernant les navigateurs web.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.String.link")}}</p>
-
-<h2 id="Notes_relatives_à_Gecko">Notes relatives à Gecko</h2>
-
-<ul>
- <li>À partir de Gecko 17.0 {{geckoRelease("17")}} le symbole de double quote <strong>"</strong> est automatiquement remplacé par l'entité HTML de référence dans le paramètre <code>url</code>.</li>
-</ul>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("String.prototype.anchor()")}}</li>
-</ul>
+// Cliquer ici pour revenir sur <a href="https://developer.mozilla.org/">MDN</a>
+```
+
+## Spécifications
+
+| Spécification                                                                                            | État                         | Commentaires                                                                                                                                                                 |
+| -------------------------------------------------------------------------------------------------------- | ---------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| {{SpecName('ES6', '#sec-string.prototype.link', 'String.prototype.link')}}     | {{Spec2('ES6')}}         | Définition initiale. Implémentée avec JavaScript 1.0. Définie dans l'Annexe B (normative) pour les fonctionnalités ECMAScript additionnelles concernant les navigateurs web. |
+| {{SpecName('ESDraft', '#sec-string.prototype.link', 'String.prototype.link')}} | {{Spec2('ESDraft')}} | Définie dans l'Annexe B (normative) pour les fonctionnalités ECMAScript additionnelles concernant les navigateurs web.                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.String.link")}}
+
+## Notes relatives à Gecko
+
+- À partir de Gecko 17.0 {{geckoRelease("17")}} le symbole de double quote **"** est automatiquement remplacé par l'entité HTML de référence dans le paramètre `url`.
+
+## Voir aussi
+
+- {{jsxref("String.prototype.anchor()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/string/localecompare/index.md b/files/fr/web/javascript/reference/global_objects/string/localecompare/index.md
index 2b84d90be0..05df8c7347 100644
--- a/files/fr/web/javascript/reference/global_objects/string/localecompare/index.md
+++ b/files/fr/web/javascript/reference/global_objects/string/localecompare/index.md
@@ -11,74 +11,71 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/String/localeCompare
 original_slug: Web/JavaScript/Reference/Objets_globaux/String/localeCompare
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>localeCompare()</strong></code> renvoie un nombre indiquant si la chaîne de caractères courante se situe avant, après ou est la même que la chaîne passée en paramètre, selon l'ordre lexicographique.</p>
+La méthode **`localeCompare()`** renvoie un nombre indiquant si la chaîne de caractères courante se situe avant, après ou est la même que la chaîne passée en paramètre, selon l'ordre lexicographique.
 
-<div>{{EmbedInteractiveExample("pages/js/string-localecompare.html")}}</div>
+{{EmbedInteractiveExample("pages/js/string-localecompare.html")}}
 
+Les arguments `locales` et `options` permettent de définir la locale et des options pour adapter le comportement de la fonction. Les anciennes implémentations ignoreront les arguments `locales` et `options`. L'ordre de tri utilisé sera entièrement dépendant de l'implémentation.
 
+## Syntaxe
 
-<p>Les arguments <code>locales</code> et <code>options</code> permettent de définir la locale et des options pour adapter le comportement de la fonction. Les anciennes implémentations ignoreront les arguments <code>locales</code> et <code>options</code>. L'ordre de tri utilisé sera entièrement dépendant de l'implémentation.</p>
+    str.localeCompare(chaineÀComparer [, locales [, options]])
 
-<h2 id="Syntaxe">Syntaxe</h2>
+### Paramètres
 
-<pre class="syntaxbox"><var>str</var>.localeCompare(<var>chaineÀComparer</var> [, <var>locales</var> [, <var>options</var>]])</pre>
+Voir le [tableau de compatibilité des navigateurs](#compat "#Browser_compatibility") pour savoir quels navigateurs prennent en charge les arguments `locales` et `options`. L'[exemple pour vérifier le support des arguments `locales` et `options`](/fr/docs/Web/JavaScript/Reference/Objets_globaux/String/localeCompare#Vérifier_le_support_des_arguments_locales_et_options) fournit un fragment de code pour détecter la prise en charge de ces fonctionnalités.
 
-<h3 id="Paramètres">Paramètres</h3>
+- `chaineÀComparer`
+  - : La chaîne avec laquelle on souhaite comparer la chaîne de caractères courante.
 
-<p>Voir le <a href="#compat" title="#Browser_compatibility">tableau de compatibilité des navigateurs</a> pour savoir quels navigateurs prennent en charge les arguments <code>locales</code> et <code>options</code>. L'<a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/String/localeCompare#Vérifier_le_support_des_arguments_locales_et_options">exemple pour vérifier le support des arguments <code>locales</code> et <code>options</code></a> fournit un fragment de code pour détecter la prise en charge de ces fonctionnalités.</p>
+{{page('fr/docs/Web/JavaScript/Reference/Objets_globaux/Collator','Param.C3.A8tres')}}
 
-<dl>
- <dt><code>chaineÀComparer</code></dt>
- <dd>La chaîne avec laquelle on souhaite comparer la chaîne de caractères courante.</dd>
-</dl>
+### Valeur de retour
 
-<div>{{page('fr/docs/Web/JavaScript/Reference/Objets_globaux/Collator','Param.C3.A8tres')}}</div>
+Un nombre négatif si la chaîne de appelante est ordonnée avant la chaîne passée en argument, un nombre positif si elle se situe après, 0 si les deux chaînes sont équivalentes.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+## Description
 
-<p>Un nombre négatif si la chaîne de appelante est ordonnée avant la chaîne passée en argument, un nombre positif si elle se situe après, 0 si les deux chaînes sont équivalentes.</p>
+Cette méthode renvoie un nombre entier qui indique si la chaîne de caractères courante se situe avant ou après la chaîne passée en argument selon l'ordre lexicographique tenant compte de la locale. Cette méthode renvoie
 
-<h2 id="Description">Description</h2>
+- un nombre négatif si la chaîne de caractères courant se situe avant la chaîne `chaineÀComparer`
+- un nombre positif si elle se situe après
+- 0 si les deux chaînes se situent au même niveau
 
-<p>Cette méthode renvoie un nombre entier qui indique si la chaîne de caractères courante se situe avant ou après la chaîne passée en argument selon l'ordre lexicographique tenant compte de la locale. Cette méthode renvoie</p>
+Attention à ne pas tester que les valeurs -1 et 1. Les valeurs entières utilisées peuvent varier en fonction des navigateurs et de leurs versions. En effet, la spécification indique uniquement le signe de la valeur à fournir. Par exemple, certains navigateurs pourront renvoyer -2 ou 2 (voire d'autres valeurs).
 
-<ul>
- <li>un nombre négatif si la chaîne de caractères courant se situe avant la chaîne <code>chaineÀComparer</code></li>
- <li>un nombre positif si elle se situe après</li>
- <li>0 si les deux chaînes se situent au même niveau</li>
-</ul>
+## Exemples
 
-<p>Attention à ne pas tester que les valeurs -1 et 1. Les valeurs entières utilisées peuvent varier en fonction des navigateurs et de leurs versions. En effet, la spécification indique uniquement le signe de la valeur à fournir. Par exemple, certains navigateurs pourront renvoyer -2 ou 2 (voire d'autres valeurs).</p>
+### Utiliser la méthode `localeCompare()`
 
-<h2 id="Exemples">Exemples</h2>
+L'exemple qui suit illustre les différents cas de figures lors de la comparaison des chaînes de caractères :
 
-<h3 id="Utiliser_la_méthode_localeCompare()">Utiliser la méthode <code>localeCompare()</code></h3>
-
-<p>L'exemple qui suit illustre les différents cas de figures lors de la comparaison des chaînes de caractères :</p>
-
-<pre class="brush: js">console.log('a'.localeCompare('c')); // -2, ou -1, ou toute autre valeur négative
+```js
+console.log('a'.localeCompare('c')); // -2, ou -1, ou toute autre valeur négative
 console.log('c'.localeCompare('a')); // 2, ou 1, ou toute autre valeur positive
 console.log('a'.localeCompare('a')); // 0
-</pre>
+```
 
-<p>Les résultats illustrés ici peuvent varier entre les différents navigateurs et selon les versions des navigateurs. En effet, les valeurs renvoyées sont spécifiques selon les implémentations. La spécification définit uniquement le signe de la valeur à renvoyer.</p>
+Les résultats illustrés ici peuvent varier entre les différents navigateurs et selon les versions des navigateurs. En effet, les valeurs renvoyées sont spécifiques selon les implémentations. La spécification définit uniquement le signe de la valeur à renvoyer.
 
-<h3 id="Trier_un_tableau">Trier un tableau</h3>
+### Trier un tableau
 
-<p><code>localeCompare()</code> permet de trier un tableau sans tenir compte de la casse :</p>
+`localeCompare()` permet de trier un tableau sans tenir compte de la casse :
 
-<pre class="brush: js">var items = ['réservé', 'Premier', 'Cliché', 'communiqué', 'café', 'Adieu'];
-items.sort((a, b) =&gt; a.localeCompare(b, 'fr', {ignorePunctuation: true}));
+```js
+var items = ['réservé', 'Premier', 'Cliché', 'communiqué', 'café', 'Adieu'];
+items.sort((a, b) => a.localeCompare(b, 'fr', {ignorePunctuation: true}));
 // ['Adieu', 'café', 'Cliché', 'communiqué', 'Premier', 'réservé']
-</pre>
+```
 
-<h3 id="Vérifier_le_support_des_arguments_locales_et_options">Vérifier le support des arguments <code>locales</code> et <code>options</code></h3>
+### Vérifier le support des arguments `locales` et `options`
 
-<p>Les argument <code>locales</code> et <code>options</code> ne sont pas supportés par tous les navigateurs. Pour vérifier qu'une implémentation supporte ces paramètres, il est possible d'utiliser un cas d'erreur quand on utilise une balise de langue incorrecte (ce qui provoque une exception {{jsxref("RangeError")}}) :</p>
+Les argument `locales` et `options` ne sont pas supportés par tous les navigateurs. Pour vérifier qu'une implémentation supporte ces paramètres, il est possible d'utiliser un cas d'erreur quand on utilise une balise de langue incorrecte (ce qui provoque une exception {{jsxref("RangeError")}}) :
 
-<pre class="brush: js">function localeCompareSupportsLocales() {
+```js
+function localeCompareSupportsLocales() {
     try {
         "a".localeCompare​("b", "i");
     } catch (e) {
@@ -86,30 +83,33 @@ items.sort((a, b) =&gt; a.localeCompare(b, 'fr', {ignorePunctuation: true}));
     }
     return false;
 }
-</pre>
+```
 
-<h3 id="Utiliser_le_paramètre_locales">Utiliser le paramètre <code>locales</code></h3>
+### Utiliser le paramètre `locales`
 
-<p>Les résultats fournis par la méthode <code>localeCompare()</code> peuvent varier selon les langues utilisées. Pour spécifier la langue à utiliser pour votre application, utiliser l'argument <code>locales</code> pour définir la locale à utiliser (et éventuellement des langues de recours) :</p>
+Les résultats fournis par la méthode `localeCompare()` peuvent varier selon les langues utilisées. Pour spécifier la langue à utiliser pour votre application, utiliser l'argument `locales` pour définir la locale à utiliser (et éventuellement des langues de recours) :
 
-<pre class="brush: js">console.log('ä'.localeCompare('z', 'de')); // une valeur négative : en allemand ä est avant z
+```js
+console.log('ä'.localeCompare('z', 'de')); // une valeur négative : en allemand ä est avant z
 console.log('ä'.localeCompare('z', 'sv')); // une valeur positive : en suédois, ä arrive après z
-</pre>
+```
 
-<h3 id="Utiliser_le_paramètre_options">Utiliser le paramètre <code>options</code></h3>
+### Utiliser le paramètre `options`
 
-<p>Les résultats construits par la méthode <code>localeCompare()</code> peuvent être adaptés grâce au paramètre <code>options</code> :</p>
+Les résultats construits par la méthode `localeCompare()` peuvent être adaptés grâce au paramètre `options` :
 
-<pre class="brush: js">// en allemand, ä et a ont la même lettre de base
+```js
+// en allemand, ä et a ont la même lettre de base
 console.log('ä'.localeCompare('a', 'de', {sensitivity: "base"})); // 0
 
 // en suédois, ä et a n'ont pas la même lettre de base
 console.log('ä'.localeCompare('a', 'sv', {sensitivity: "base"})); // une valeur positive
-</pre>
+```
 
-<h3 id="Tri_numérique">Tri numérique</h3>
+### Tri numérique
 
-<pre class="brush: js">// Par défaut, selon l'ordre lexicographique, "2" est supérieur à "10"
+```js
+// Par défaut, selon l'ordre lexicographique, "2" est supérieur à "10"
 console.log("2".localeCompare("10")); // 1
 
 // En utilisant un ordre numérique :
@@ -117,66 +117,28 @@ console.log("2".localeCompare("10", undefined, {numeric: true})); // -1
 
 // En utilisant une balise de locale:
 console.log("2".localeCompare("10","en-u-kn-true")); // -1
-</pre>
-
-<h2 id="Performances">Performances</h2>
-
-<p>Pour comparer un grand nombre de chaînes de caractères, par exemple pour trier de grands tableaux, il est préférable de créer un objet {{jsxref("Objets_globaux/Collator", "Intl.Collator")}} et utiliser la fonction fournie par la propriété {{jsxref("Collator.prototype.compare", "compare")}}.</p>
-
-<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('ES3')}}</td>
-   <td>{{Spec2('ES3')}}</td>
-   <td>Définition initiale.<br>
-    Implémentée avec JavaScript 1.2</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.5.4.9', 'String.prototype.localeCompare')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-string.prototype.localecompare', 'String.prototype.localeCompare')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-string.prototype.localecompare', 'String.prototype.localeCompare')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES Int 1.0', '#sec-13.1.1', 'String.prototype.localeCompare')}}</td>
-   <td>{{Spec2('ES Int 1.0')}}</td>
-   <td>Définition des paramètres<code> locale</code> et <code>option</code></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES Int 2.0', '#sec-13.1.1', 'String.prototype.localeCompare')}}</td>
-   <td>{{Spec2('ES Int 2.0')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES Int Draft', '#sec-String.prototype.localeCompare', 'String.prototype.localeCompare')}}</td>
-   <td>{{Spec2('ES Int Draft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.String.localeCompare")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Objets_globaux/Collator", "Intl.Collator")}}</li>
-</ul>
+```
+
+## Performances
+
+Pour comparer un grand nombre de chaînes de caractères, par exemple pour trier de grands tableaux, il est préférable de créer un objet {{jsxref("Objets_globaux/Collator", "Intl.Collator")}} et utiliser la fonction fournie par la propriété {{jsxref("Collator.prototype.compare", "compare")}}.
+
+## Spécifications
+
+| Spécification                                                                                                                            | État                             | Commentaires                                         |
+| ---------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------- | ---------------------------------------------------- |
+| {{SpecName('ES3')}}                                                                                                                 | {{Spec2('ES3')}}             | Définition initiale. Implémentée avec JavaScript 1.2 |
+| {{SpecName('ES5.1', '#sec-15.5.4.9', 'String.prototype.localeCompare')}}                                         | {{Spec2('ES5.1')}}         |                                                      |
+| {{SpecName('ES6', '#sec-string.prototype.localecompare', 'String.prototype.localeCompare')}}             | {{Spec2('ES6')}}             |                                                      |
+| {{SpecName('ESDraft', '#sec-string.prototype.localecompare', 'String.prototype.localeCompare')}}         | {{Spec2('ESDraft')}}     |                                                      |
+| {{SpecName('ES Int 1.0', '#sec-13.1.1', 'String.prototype.localeCompare')}}                                     | {{Spec2('ES Int 1.0')}} | Définition des paramètres` locale` et `option`       |
+| {{SpecName('ES Int 2.0', '#sec-13.1.1', 'String.prototype.localeCompare')}}                                     | {{Spec2('ES Int 2.0')}} |                                                      |
+| {{SpecName('ES Int Draft', '#sec-String.prototype.localeCompare', 'String.prototype.localeCompare')}} | {{Spec2('ES Int Draft')}} |                                                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.String.localeCompare")}}
+
+## Voir aussi
+
+- {{jsxref("Objets_globaux/Collator", "Intl.Collator")}}
diff --git a/files/fr/web/javascript/reference/global_objects/string/match/index.md b/files/fr/web/javascript/reference/global_objects/string/match/index.md
index 27d3d04e85..9b070559b6 100644
--- a/files/fr/web/javascript/reference/global_objects/string/match/index.md
+++ b/files/fr/web/javascript/reference/global_objects/string/match/index.md
@@ -11,61 +11,54 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/String/match
 original_slug: Web/JavaScript/Reference/Objets_globaux/String/match
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>match()</code></strong> permet d'obtenir le tableau des correspondances entre la chaîne courante et une expression rationnelle.</p>
+La méthode **`match()`** permet d'obtenir le tableau des correspondances entre la chaîne courante et une expression rationnelle.
 
-<div>{{EmbedInteractiveExample("pages/js/string-match.html")}}</div>
+{{EmbedInteractiveExample("pages/js/string-match.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>str</var>.match(<var>regexp</var>)</pre>
+    str.match(regexp)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>regexp</code></dt>
- <dd>Un objet représentant une expression rationnelle. Si ce n'est pas un objet de type <code>RegExp</code>, celui-ci sera converti en un objet {{jsxref("RegExp")}} grâce à <code>new RegExp(regexp)</code>. Si aucun paramètre n'est utilisé, cela renverra un tableau contenant un élément étant la chaîne vide : <code>[""]</code>.</dd>
-</dl>
+- `regexp`
+  - : Un objet représentant une expression rationnelle. Si ce n'est pas un objet de type `RegExp`, celui-ci sera converti en un objet {{jsxref("RegExp")}} grâce à `new RegExp(regexp)`. Si aucun paramètre n'est utilisé, cela renverra un tableau contenant un élément étant la chaîne vide : `[""]`.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un tableau ({{jsxref("Array")}}) contenant les correspondances et les groupes capturés avec les parenthèses ou {{jsxref("null")}} s'il n'y a pas de correspondance. Le contenu de ce tableau dépend de l'utilisation du marqueur pour la recherche globale <code>g</code> :</p>
+Un tableau ({{jsxref("Array")}}) contenant les correspondances et les groupes capturés avec les parenthèses ou {{jsxref("null")}} s'il n'y a pas de correspondance. Le contenu de ce tableau dépend de l'utilisation du marqueur pour la recherche globale `g` :
 
-<ul>
- <li>Si le marqueur <code>g</code> est utilisé, tous les résultats correspondants à l'expression rationnelle complète seront renvoyés mais les groupes capturants ne seront pas renvoyés.</li>
- <li>Si le marqueur <code>g</code> n'est pas utilisé, seule la première correspondance et ses groupes capturants seront renvoyés. Dans ce cas, l'élément renvoyé aura des propriétés supplémentaires listées ci-après.</li>
-</ul>
+- Si le marqueur `g` est utilisé, tous les résultats correspondants à l'expression rationnelle complète seront renvoyés mais les groupes capturants ne seront pas renvoyés.
+- Si le marqueur `g` n'est pas utilisé, seule la première correspondance et ses groupes capturants seront renvoyés. Dans ce cas, l'élément renvoyé aura des propriétés supplémentaires listées ci-après.
 
-<h4 id="Propriétés_supplémentaires">Propriétés supplémentaires</h4>
+#### Propriétés supplémentaires
 
-<p>Comme indiqué ci-avant, les résultats peuvent contenir certaines propriétés supplémentaires :</p>
+Comme indiqué ci-avant, les résultats peuvent contenir certaines propriétés supplémentaires :
 
-<ul>
- <li><code>groups</code> : un tableau de groupes capturants nommés ou {{jsxref("undefined")}} si aucun groupe capturant n'a été défini. Voir <a href="/fr/docs/Web/JavaScript/Guide/Regular_Expressions/Groups_and_Ranges">la page sur les groupes et les intervalles</a> pour plus d'informations.</li>
- <li><code>index</code> : l'indice de la chaîne de caractères où a été trouvée la correspondance.</li>
- <li><code>input</code> : une copie de la chaîne sur laquelle a été effectuée la recherche.</li>
-</ul>
+- `groups` : un tableau de groupes capturants nommés ou {{jsxref("undefined")}} si aucun groupe capturant n'a été défini. Voir [la page sur les groupes et les intervalles](/fr/docs/Web/JavaScript/Guide/Regular_Expressions/Groups_and_Ranges) pour plus d'informations.
+- `index` : l'indice de la chaîne de caractères où a été trouvée la correspondance.
+- `input` : une copie de la chaîne sur laquelle a été effectuée la recherche.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Si l'expression n'utilise pas le drapeau (<em>flag</em>) <code>g</code>, le résultat obtenu sera le même qu'avec {{jsxref("RegExp.prototype.exec()", "RegExp.exec()")}}.</p>
+Si l'expression n'utilise pas le drapeau (_flag_) `g`, le résultat obtenu sera le même qu'avec {{jsxref("RegExp.prototype.exec()", "RegExp.exec()")}}.
 
-<h3 id="Voir_aussi_les_méthodes_de_RegExp">Voir aussi : les méthodes de <code>RegExp</code></h3>
+### Voir aussi : les méthodes de `RegExp`
 
-<ul>
- <li>Si on souhaite savoir s'il existe des correspondances entre une chaîne de caractères et une expression rationnelle {{jsxref("RegExp")}}, on pourra utiliser {{jsxref("RegExp.prototype.test()", "RegExp.test()")}}.</li>
- <li>Si on ne souhaite obtenir que la première correspondance, on pourra plutôt utiliser {{jsxref("RegExp.prototype.exec()", "RegExp.exec()")}} à la place.</li>
- <li>Si on souhaite obtenir les groupes correspondants et que le drapeau « global » est activé, il faudra utiliser {{jsxref("RegExp.prototype.exec()", "RegExp.exec()")}} à la place.</li>
-</ul>
+- Si on souhaite savoir s'il existe des correspondances entre une chaîne de caractères et une expression rationnelle {{jsxref("RegExp")}}, on pourra utiliser {{jsxref("RegExp.prototype.test()", "RegExp.test()")}}.
+- Si on ne souhaite obtenir que la première correspondance, on pourra plutôt utiliser {{jsxref("RegExp.prototype.exec()", "RegExp.exec()")}} à la place.
+- Si on souhaite obtenir les groupes correspondants et que le drapeau « global » est activé, il faudra utiliser {{jsxref("RegExp.prototype.exec()", "RegExp.exec()")}} à la place.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_match()">Utiliser <code>match()</code></h3>
+### Utiliser `match()`
 
-<p>Dans l'exemple suivant, on utilise <code>match()</code> afin de trouver la chaîne <code>'Chapitre'</code> suivie par un ou plusieurs chiffres séparés par des points. L'expression utilisée active le drapeau <code>i</code> afin que la casse ne soit pas prise en compte.</p>
+Dans l'exemple suivant, on utilise `match()` afin de trouver la chaîne `'Chapitre'` suivie par un ou plusieurs chiffres séparés par des points. L'expression utilisée active le drapeau `i` afin que la casse ne soit pas prise en compte.
 
-<pre class="brush: js">var str = 'Pour plus d\'informations, voir le chapitre 3.4.5.1';
+```js
+var str = 'Pour plus d\'informations, voir le chapitre 3.4.5.1';
 var re = /(chapitre \d+(\.\d)*)/i;
 var trouvé = str.match(re);
 
@@ -77,78 +70,54 @@ console.log(trouvé);
 // 'chapitre 3.4.5.1' est la valeur gardée en mémoire par
 // `(chapitre \d+(\.\d)*)`.
 // '.1' est la valeur gardée en mémoire par `(\.\d)`.
-</pre>
+```
 
-<h3 id="Utiliser_les_drapeaux_g_(global)_et_i_(ignorer_la_casse)_avec_match()">Utiliser les drapeaux <code>g</code> (global) et <code>i</code> (ignorer la casse) avec <code>match()</code></h3>
+### Utiliser les drapeaux `g` (global) et `i` (ignorer la casse) avec `match()`
 
-<p>Dans cet exemple, on illustre comment utiliser des drapeaux avec l'expression rationnelle qui est un argument de <code>match()</code>. Chaque lettre de A à E et de a à e est renvoyée, chacune dans un élément du tableau de résultat.</p>
+Dans cet exemple, on illustre comment utiliser des drapeaux avec l'expression rationnelle qui est un argument de `match()`. Chaque lettre de A à E et de a à e est renvoyée, chacune dans un élément du tableau de résultat.
 
-<pre class="brush: js">var str = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
+```js
+var str = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
 var regexp = /[A-E]/gi;
 var tableau_correspondances = str.match(regexp);
 
 console.log(tableau_correspondances);
 // ['A', 'B', 'C', 'D', 'E', 'a', 'b', 'c', 'd', 'e']
-</pre>
+```
 
-<h3 id="Utiliser_un_paramètre_qui_n'est_pas_une_RegExp">Utiliser un paramètre qui n'est pas une <code>RegExp</code></h3>
+### Utiliser un paramètre qui n'est pas une `RegExp`
 
-<p>Lorsque le paramètre passé à la fonction est une chaîne de caractères ou un nombre, il est converti de façon implicite en un objet  {{jsxref("RegExp")}} grâce à <code>new RegExp(obj)</code>. Si c'est un nombre positif avec le signe +, la méthode <code>RegExp()</code> ignorera ce signe.</p>
+Lorsque le paramètre passé à la fonction est une chaîne de caractères ou un nombre, il est converti de façon implicite en un objet  {{jsxref("RegExp")}} grâce à `new RegExp(obj)`. Si c'est un nombre positif avec le signe +, la méthode `RegExp()` ignorera ce signe.
 
-<pre class="brush: js">var str1 = "NaN signifie : qui n'est pas un nombre.";
+```js
+var str1 = "NaN signifie : qui n'est pas un nombre.";
 var str2 = "Mon père a 65 ans."
 str1.match("nombre");   // "nombre" est une chaîne, renvoie ["nombre"]
 str1.match(NaN);        // NaN est de type number, renvoie ["NaN"]
 str2.match(65);         // Renvoie ["65"]
-str2.match(+65);        // Renvoie également ["65"]</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('ES3')}}</td>
-   <td>{{Spec2('ES3')}}</td>
-   <td>Définition initiale. Implémentée avec JavaScript 1.2.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.5.4.10', 'String.prototype.match')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-string.prototype.match', 'String.prototype.match')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-string.prototype.match', 'String.prototype.match')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.String.match")}}</p>
-
-<h2 id="Notes_spécifiques_à_FirefoxGecko">Notes spécifiques à Firefox/Gecko</h2>
-
-<ul>
- <li><code>flags</code> était un second argument non standard présent uniquement sur Gecko : <var>str</var>.match(<var>regexp, flags</var>) et a été retiré avec Firefox 49.</li>
- <li>À partir de Firefox 27, cette méthode a été ajustée afin d'être conforme à ECMAScript. Lorsque <code>match()</code> est appelée sur une expression rationnelle globale, la propriété {{jsxref("RegExp.lastIndex")}} de l'objet sera redéfini à <code>0</code> ({{bug(501739)}}).</li>
-</ul>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("RegExp")}}</li>
- <li>{{jsxref("RegExp.prototype.exec()")}}</li>
- <li>{{jsxref("RegExp.prototype.test()")}}</li>
-</ul>
+str2.match(+65);        // Renvoie également ["65"]
+```
+
+## Spécifications
+
+| Spécification                                                                                                | État                         | Commentaires                                          |
+| ------------------------------------------------------------------------------------------------------------ | ---------------------------- | ----------------------------------------------------- |
+| {{SpecName('ES3')}}                                                                                     | {{Spec2('ES3')}}         | Définition initiale. Implémentée avec JavaScript 1.2. |
+| {{SpecName('ES5.1', '#sec-15.5.4.10', 'String.prototype.match')}}                     | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-string.prototype.match', 'String.prototype.match')}}         | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-string.prototype.match', 'String.prototype.match')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.String.match")}}
+
+## Notes spécifiques à Firefox/Gecko
+
+- `flags` était un second argument non standard présent uniquement sur Gecko : _str_.match(_regexp, flags_) et a été retiré avec Firefox 49.
+- À partir de Firefox 27, cette méthode a été ajustée afin d'être conforme à ECMAScript. Lorsque `match()` est appelée sur une expression rationnelle globale, la propriété {{jsxref("RegExp.lastIndex")}} de l'objet sera redéfini à `0` ({{bug(501739)}}).
+
+## Voir aussi
+
+- {{jsxref("RegExp")}}
+- {{jsxref("RegExp.prototype.exec()")}}
+- {{jsxref("RegExp.prototype.test()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/string/matchall/index.md b/files/fr/web/javascript/reference/global_objects/string/matchall/index.md
index 5b9e8b50c9..440e124d00 100644
--- a/files/fr/web/javascript/reference/global_objects/string/matchall/index.md
+++ b/files/fr/web/javascript/reference/global_objects/string/matchall/index.md
@@ -10,34 +10,33 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/String/matchAll
 original_slug: Web/JavaScript/Reference/Objets_globaux/String/matchAll
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>matchAll()</code></strong> renvoie un itérateur contenant l'ensemble des correspondances entre une chaîne de caractères d'une part et une expression rationnelle d'autre part (y compris les groupes capturants).</p>
+La méthode **`matchAll()`** renvoie un itérateur contenant l'ensemble des correspondances entre une chaîne de caractères d'une part et une expression rationnelle d'autre part (y compris les groupes capturants).
 
-<div>{{EmbedInteractiveExample("pages/js/string-matchall.html")}}</div>
+{{EmbedInteractiveExample("pages/js/string-matchall.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>str</var>.matchAll(<var>regexp</var>)</pre>
+    str.matchAll(regexp)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>regexp</code></dt>
- <dd>Un objet représentant une expression rationnelle. Si cet objet n'est pas une instance de {{jsxref("RegExp")}}, il est automatiquement et implicitement converti en une telle instance à l'aide de <code>new RegExp(obj)</code>.</dd>
-</dl>
+- `regexp`
+  - : Un objet représentant une expression rationnelle. Si cet objet n'est pas une instance de {{jsxref("RegExp")}}, il est automatiquement et implicitement converti en une telle instance à l'aide de `new RegExp(obj)`.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un <a href="https://developer.mozilla.org/fr/docs/Web/JavaScript/Guide/iterateurs_et_generateurs">itérateur</a>.</p>
+Un [itérateur](https://developer.mozilla.org/fr/docs/Web/JavaScript/Guide/iterateurs_et_generateurs).
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Regexp.exec()_et_matchAll()"><code>Regexp.exec()</code> et <code>matchAll()</code></h3>
+### `Regexp.exec()` et `matchAll()`
 
-<p>Avant l'apparition de <code>matchAll()</code> en JavaScript, il était possible d'utiliser {{jsxref("RegExp.exec")}} (et des expressions rationnelles utilisant le marqueur <code>/g</code>) dans une boucle afin d'obtenir l'ensemble des correspondances :</p>
+Avant l'apparition de `matchAll()` en JavaScript, il était possible d'utiliser {{jsxref("RegExp.exec")}} (et des expressions rationnelles utilisant le marqueur `/g`) dans une boucle afin d'obtenir l'ensemble des correspondances :
 
-<pre class="brush: js">const regexp = RegExp('foo*','g');
+```js
+const regexp = RegExp('foo*','g');
 const str = 'table football, foosball';
 
 while ((matches = regexp.exec(str)) !== null) {
@@ -45,11 +44,12 @@ while ((matches = regexp.exec(str)) !== null) {
   // dans la console : "foo trouvé. Prochaine recherche à partir de 9."
   // dans la console : "foo trouvé. Prochaine recherche à partir de 19."
 }
-</pre>
+```
 
-<p>Avec <code>matchAll()</code>, on peut éviter la boucle <code>while</code> et le marqueur global. On récupère l'itérateur et on utilise une boucle <code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/for...of">for...of</a></code>, <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Syntaxe_décomposition">la décomposition de tableau</a> ou encore {{jsxref("Array.from()")}} :</p>
+Avec `matchAll()`, on peut éviter la boucle `while` et le marqueur global. On récupère l'itérateur et on utilise une boucle [`for...of`](/fr/docs/Web/JavaScript/Reference/Instructions/for...of), [la décomposition de tableau](/fr/docs/Web/JavaScript/Reference/Opérateurs/Syntaxe_décomposition) ou encore {{jsxref("Array.from()")}} :
 
-<pre class="brush: js">const regexp = RegExp('foo*','g');
+```js
+const regexp = RegExp('foo*','g');
 const str = 'table football, foosball';
 let matches = str.matchAll(regexp);
 
@@ -63,57 +63,45 @@ for (const match of matches) {
 // On rappelle matchAll afin de créer un nouvel itérateur
 matches = str.matchAll(regexp);
 
-Array.from(matches, m =&gt; m[0]);
+Array.from(matches, m => m[0]);
 // Array [ "foo", "foo" ]
-</pre>
+```
 
-<h3 id="Meilleur_accès_aux_groupes_capturants">Meilleur accès aux groupes capturants</h3>
+### Meilleur accès aux groupes capturants
 
-<p>Un autre avantage de <code>matchAll()</code> est un meilleur accès aux groupes capturants. De fait, les groupes capturants sont ignorés par <code><a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/String/match">match()</a></code> lorsqu'on utilise le marqueur global <code>/g</code> :</p>
+Un autre avantage de `matchAll()` est un meilleur accès aux groupes capturants. De fait, les groupes capturants sont ignorés par [`match()`](/fr/docs/Web/JavaScript/Reference/Objets_globaux/String/match) lorsqu'on utilise le marqueur global `/g` :
 
-<pre class="brush: js">var regexp = /t(e)(st(\d?))/g;
+```js
+var regexp = /t(e)(st(\d?))/g;
 var str = 'test1test2';
 
 str.match(regexp);
-// Array ['test1', 'test2']</pre>
+// Array ['test1', 'test2']
+```
 
-<p>Avec <code>matchAll()</code>, on peut y accéder :</p>
+Avec `matchAll()`, on peut y accéder :
 
-<pre class="brush: js">let array = [...str.matchAll(regexp)];
+```js
+let array = [...str.matchAll(regexp)];
 
 array[0];
 // ['test1', 'e', 'st1', '1', index: 0, input: 'test1test2', length: 4]
 array[1];
 // ['test2', 'e', 'st2', '2', index: 5, input: 'test1test2', length: 4]
-</pre>
-
-<h2 id="Spécifications">Spécifications</h2>
-
-<table class="standard-table">
- <thead>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">État</th>
-   <th scope="col">Commentaires</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-string.prototype.matchall', 'String.prototype.matchAll')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.String.matchAll")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("RegExp")}}</li>
- <li>{{jsxref("RegExp.prototype.exec()")}}</li>
- <li>{{jsxref("RegExp.prototype.test()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                        | État                         | Commentaires |
+| -------------------------------------------------------------------------------------------------------------------- | ---------------------------- | ------------ |
+| {{SpecName('ESDraft', '#sec-string.prototype.matchall', 'String.prototype.matchAll')}} | {{Spec2('ESDraft')}} |              |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.String.matchAll")}}
+
+## Voir aussi
+
+- {{jsxref("RegExp")}}
+- {{jsxref("RegExp.prototype.exec()")}}
+- {{jsxref("RegExp.prototype.test()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/string/normalize/index.md b/files/fr/web/javascript/reference/global_objects/string/normalize/index.md
index b35ff15f8b..c3c1818ded 100644
--- a/files/fr/web/javascript/reference/global_objects/string/normalize/index.md
+++ b/files/fr/web/javascript/reference/global_objects/string/normalize/index.md
@@ -12,48 +12,44 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/String/normalize
 original_slug: Web/JavaScript/Reference/Objets_globaux/String/normalize
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>normalize()</strong></code> permet de renvoyer la forme normalisée Unicode d'une chaîne de caractères (si la valeur n'est pas une chaîne de caractères, elle sera convertie).</p>
+La méthode **`normalize()`** permet de renvoyer la forme normalisée Unicode d'une chaîne de caractères (si la valeur n'est pas une chaîne de caractères, elle sera convertie).
 
-<div>{{EmbedInteractiveExample("pages/js/string-normalize.html")}}</div>
+{{EmbedInteractiveExample("pages/js/string-normalize.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>str</var>.normalize([<var>form</var>]);</pre>
+    str.normalize([form]);
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>form</code></dt>
- <dd>Paramètre optionnel. Une chaîne parmi "NFC", "NFD", "NFKC", ou "NFKD", définissant la forme de normalisation Unicode à utiliser. Si le paramètre n'est pas précisé ou vaut {{jsxref("undefined")}}, la valeur par défaut utilisée sera "<code>NFC</code>".
- <ul>
-  <li><code>NFC</code> - Normalization Form Canonical Composition.</li>
-  <li><code>NFD</code> - Normalization Form Canonical Decomposition.</li>
-  <li><code>NFKC</code> - Normalization Form Compatibility Composition.</li>
-  <li><code>NFKD</code> - Normalization Form Compatibility Decomposition.</li>
- </ul>
- </dd>
-</dl>
+- `form`
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+  - : Paramètre optionnel. Une chaîne parmi "NFC", "NFD", "NFKC", ou "NFKD", définissant la forme de normalisation Unicode à utiliser. Si le paramètre n'est pas précisé ou vaut {{jsxref("undefined")}}, la valeur par défaut utilisée sera "`NFC`".
 
-<p>Une chaîne de caractères qui est le forme Unicode normalisée de la chaîne appelante.</p>
+    - `NFC` - Normalization Form Canonical Composition.
+    - `NFD` - Normalization Form Canonical Decomposition.
+    - `NFKC` - Normalization Form Compatibility Composition.
+    - `NFKD` - Normalization Form Compatibility Decomposition.
 
-<h3 id="Exceptions">Exceptions</h3>
+### Valeur de retour
 
-<dl>
- <dt>{{jsxref("RangeError")}}</dt>
- <dd>Une exception <code>RangeError</code> est envoyée si le paramètre <code>form</code> n'est pas une des valeurs définies ci-avant.</dd>
-</dl>
+Une chaîne de caractères qui est le forme Unicode normalisée de la chaîne appelante.
 
-<h2 id="Description">Description</h2>
+### Exceptions
 
-<p>La méthode <code>normalize()</code> renvoie la forme normalisée Unicode de la chaîne de caractères. Elle n'affecte pas la valeur de la chaîne.</p>
+- {{jsxref("RangeError")}}
+  - : Une exception `RangeError` est envoyée si le paramètre `form` n'est pas une des valeurs définies ci-avant.
 
-<h2 id="Exemples">Exemples</h2>
+## Description
 
-<pre class="brush:js;">// Chaîne initiale
+La méthode `normalize()` renvoie la forme normalisée Unicode de la chaîne de caractères. Elle n'affecte pas la valeur de la chaîne.
+
+## Exemples
+
+```js
+// Chaîne initiale
 
 // U+1E9B: LATIN SMALL LETTER LONG S WITH DOT ABOVE
 // U+0323: COMBINING DOT BELOW
@@ -88,37 +84,20 @@ str.normalize("NFKC"); // "\u1E69"
 // U+0323: COMBINING DOT BELOW
 // U+0307: COMBINING DOT ABOVE
 str.normalize("NFKD"); // "\u0073\u0323\u0307"
-</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-string.prototype.normalize', 'String.prototype.normalize')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-string.prototype.normalize', 'String.prototype.normalize')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.String.normalize")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li><a href="https://www.unicode.org/reports/tr15/">Formes de normalisation Unicode, Annexe n°15 du standard Unicode</a></li>
- <li><a href="https://en.wikipedia.org/wiki/Unicode_equivalence">Équivalence Unicode</a></li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                        | État                         | Commentaires         |
+| -------------------------------------------------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ES2015', '#sec-string.prototype.normalize', 'String.prototype.normalize')}} | {{Spec2('ES2015')}}     | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-string.prototype.normalize', 'String.prototype.normalize')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.String.normalize")}}
+
+## Voir aussi
+
+- [Formes de normalisation Unicode, Annexe n°15 du standard Unicode](https://www.unicode.org/reports/tr15/)
+- [Équivalence Unicode](https://en.wikipedia.org/wiki/Unicode_equivalence)
diff --git a/files/fr/web/javascript/reference/global_objects/string/padend/index.md b/files/fr/web/javascript/reference/global_objects/string/padend/index.md
index 2039f7be3c..07462ad3f9 100644
--- a/files/fr/web/javascript/reference/global_objects/string/padend/index.md
+++ b/files/fr/web/javascript/reference/global_objects/string/padend/index.md
@@ -9,65 +9,47 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/String/padEnd
 original_slug: Web/JavaScript/Reference/Objets_globaux/String/padEnd
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>padEnd()</code></strong> permet de compléter la chaîne courante avec une chaîne de caractères donnée afin d'obtenir une chaîne de longueur fixée. Pour atteindre cette longueur, la chaîne complémentaire peut être répétée. La chaîne courante est complétée depuis la fin.</p>
+La méthode **`padEnd()`** permet de compléter la chaîne courante avec une chaîne de caractères donnée afin d'obtenir une chaîne de longueur fixée. Pour atteindre cette longueur, la chaîne complémentaire peut être répétée. La chaîne courante est complétée depuis la fin.
 
-<div>{{EmbedInteractiveExample("pages/js/string-padend.html")}}</div>
+{{EmbedInteractiveExample("pages/js/string-padend.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>str</var>.padEnd(<var>longueurCible</var> [, <var>chaîneComplémentaire</var>])</pre>
+    str.padEnd(longueurCible [, chaîneComplémentaire])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>longueurCible</code></dt>
- <dd>La longueur de la chaîne qu'on souhaite obtenir. Si la longueur indiquée est inférieure à celle de la chaîne courante, cette dernière est renvoyée telle quelle.</dd>
- <dt><code>chaîneComplémentaire</code> {{optional_inline}}</dt>
- <dd>La chaîne de caractères avec laquelle on veut compléter la chaîne courante. Si cette chaîne est trop longue, on prendra uniquement le début (la partie la plus à gauche pour les langues écrites de gauche à droite et la partie la plus à droite pour les langues écrites de droite à gauche). La valeur par défaut de ce paramètre est l'espace " " (U+0020). Si cette chaîne est trop courte, elle sera répétée.</dd>
-</dl>
+- `longueurCible`
+  - : La longueur de la chaîne qu'on souhaite obtenir. Si la longueur indiquée est inférieure à celle de la chaîne courante, cette dernière est renvoyée telle quelle.
+- `chaîneComplémentaire` {{optional_inline}}
+  - : La chaîne de caractères avec laquelle on veut compléter la chaîne courante. Si cette chaîne est trop longue, on prendra uniquement le début (la partie la plus à gauche pour les langues écrites de gauche à droite et la partie la plus à droite pour les langues écrites de droite à gauche). La valeur par défaut de ce paramètre est l'espace " " (U+0020). Si cette chaîne est trop courte, elle sera répétée.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une chaîne de caractères ({{jsxref("String")}}) dont la longueur est celle indiquée, complétée avec la chaîne fournie.</p>
+Une chaîne de caractères ({{jsxref("String")}}) dont la longueur est celle indiquée, complétée avec la chaîne fournie.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<pre class="brush: js">'abc'.padEnd(10);         // "abc       "
+```js
+'abc'.padEnd(10);         // "abc       "
 'abc'.padEnd(10, "toto"); // "abctototot"
 'abc'.padEnd(6,"123456"); // "abc123"
 'abc'.padEnd(1);          // "abc"
-</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('ESDraft', '#sec-string.prototype.padend', 'String.prototype.padEnd')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES8', '#sec-string.prototype.padend', 'String.prototype.padEnd')}}</td>
-   <td>{{Spec2('ES8')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.String.padEnd")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("String.prototype.padStart()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                | État                         | Commentaires         |
+| ------------------------------------------------------------------------------------------------------------ | ---------------------------- | -------------------- |
+| {{SpecName('ESDraft', '#sec-string.prototype.padend', 'String.prototype.padEnd')}} | {{Spec2('ESDraft')}} |                      |
+| {{SpecName('ES8', '#sec-string.prototype.padend', 'String.prototype.padEnd')}}     | {{Spec2('ES8')}}         | Définition initiale. |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.String.padEnd")}}
+
+## Voir aussi
+
+- {{jsxref("String.prototype.padStart()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/string/padstart/index.md b/files/fr/web/javascript/reference/global_objects/string/padstart/index.md
index 85ecc07e2d..1957a024e6 100644
--- a/files/fr/web/javascript/reference/global_objects/string/padstart/index.md
+++ b/files/fr/web/javascript/reference/global_objects/string/padstart/index.md
@@ -9,67 +9,48 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/String/padStart
 original_slug: Web/JavaScript/Reference/Objets_globaux/String/padStart
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>padStart()</code></strong> permet de compléter la chaîne courante avec une chaîne de caractères donnée afin d'obtenir une chaîne de longueur fixée. Pour atteindre cette longueur, la chaîne complémentaire peut être répétée. La chaîne courante est complétée depuis le début.</p>
+La méthode **`padStart()`** permet de compléter la chaîne courante avec une chaîne de caractères donnée afin d'obtenir une chaîne de longueur fixée. Pour atteindre cette longueur, la chaîne complémentaire peut être répétée. La chaîne courante est complétée depuis le début.
 
-<div>{{EmbedInteractiveExample("pages/js/string-padstart.html")}}</div>
+{{EmbedInteractiveExample("pages/js/string-padstart.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>str</var>.padStart(<var>longueurCible</var> [, <var>chaîneComplémentaire</var>])</pre>
+    str.padStart(longueurCible [, chaîneComplémentaire])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>longueurCible</code></dt>
- <dd>La longueur de la chaîne qu'on souhaite obtenir. Si la longueur indiquée est inférieure à celle de la chaîne courante, cette dernière est renvoyée telle quelle.</dd>
- <dt><code>chaîneComplémentaire</code> {{optional_inline}}</dt>
- <dd>La chaîne de caractères avec laquelle on veut compléter la chaîne courante. Si cette chaîne est trop longue, on prendra uniquement le début (la partie la plus à gauche quand la langue s'écrit de gauche à droite). La valeur par défaut de ce paramètre est l'espace " " (U+0020). Si cette chaîne est trop courte, elle sera répétée.</dd>
-</dl>
+- `longueurCible`
+  - : La longueur de la chaîne qu'on souhaite obtenir. Si la longueur indiquée est inférieure à celle de la chaîne courante, cette dernière est renvoyée telle quelle.
+- `chaîneComplémentaire` {{optional_inline}}
+  - : La chaîne de caractères avec laquelle on veut compléter la chaîne courante. Si cette chaîne est trop longue, on prendra uniquement le début (la partie la plus à gauche quand la langue s'écrit de gauche à droite). La valeur par défaut de ce paramètre est l'espace " " (U+0020). Si cette chaîne est trop courte, elle sera répétée.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une chaîne de caractères ({{jsxref("String")}}) dont la longueur est celle indiquée, complétée avec la chaîne fournie au début de la chaîne courante.</p>
+Une chaîne de caractères ({{jsxref("String")}}) dont la longueur est celle indiquée, complétée avec la chaîne fournie au début de la chaîne courante.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<pre class="brush: js">'abc'.padStart(10);         // "        abc"
+```js
+'abc'.padStart(10);         // "        abc"
 'abc'.padStart(10, "toto"); // "totototabc"
 'abc'.padStart(6,"123465"); // "123abc"
 'abc'.padStart(8, "0");     // "00000abc"
-'abc'.padStart(1);          // "abc"</pre>
-
-<h2 id="Spécifications">Spécifications</h2>
-
-<table class="standard-table">
- <thead>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">État</th>
-   <th scope="col">Commentaires</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-string.prototype.padstart', 'String.prototype.padStart')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES8', '#sec-string.prototype.padstart', 'String.prototype.padStart')}}</td>
-   <td>{{Spec2('ES8')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.String.padStart")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("String.prototype.padEnd()")}}</li>
-</ul>
+'abc'.padStart(1);          // "abc"
+```
+
+## Spécifications
+
+| Spécification                                                                                                        | État                         | Commentaires         |
+| -------------------------------------------------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ESDraft', '#sec-string.prototype.padstart', 'String.prototype.padStart')}} | {{Spec2('ESDraft')}} |                      |
+| {{SpecName('ES8', '#sec-string.prototype.padstart', 'String.prototype.padStart')}}         | {{Spec2('ES8')}}         | Définition initiale. |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.String.padStart")}}
+
+## Voir aussi
+
+- {{jsxref("String.prototype.padEnd()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/string/raw/index.md b/files/fr/web/javascript/reference/global_objects/string/raw/index.md
index 9a9724ffc9..17e88c7b4a 100644
--- a/files/fr/web/javascript/reference/global_objects/string/raw/index.md
+++ b/files/fr/web/javascript/reference/global_objects/string/raw/index.md
@@ -10,50 +10,46 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/String/raw
 original_slug: Web/JavaScript/Reference/Objets_globaux/String/raw
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode statique <code><strong>String.raw()</strong></code> est une fonction d'étiquetage (<em>tag function</em>) pour les <a href="/fr/docs/Web/JavaScript/Reference/Littéraux_gabarits#Les_gabarits_étiquetés">gabarits de chaînes de caractères</a> (elle est <a href="https://bugs.chromium.org/p/v8/issues/detail?id=5016">semblable</a> au préfixe <code>r</code> en Python ou au préfixe <code>@</code> en C#). Cette fonction permet d'obtenir la chaîne brute pour un gabarit (les caractères spéciaux ne sont pas pris en compte mais retranscrits tels quels, les séquences d'échappement ne sont pas interprétées et les emplacements (ex. <code>${toto}</code>) sont traités).</p>
+La méthode statique **`String.raw()`** est une fonction d'étiquetage (_tag function_) pour les [gabarits de chaînes de caractères](/fr/docs/Web/JavaScript/Reference/Littéraux_gabarits#Les_gabarits_étiquetés) (elle est [semblable](https://bugs.chromium.org/p/v8/issues/detail?id=5016) au préfixe `r` en Python ou au préfixe `@` en C#). Cette fonction permet d'obtenir la chaîne brute pour un gabarit (les caractères spéciaux ne sont pas pris en compte mais retranscrits tels quels, les séquences d'échappement ne sont pas interprétées et les emplacements (ex. `${toto}`) sont traités).
 
-<div>{{EmbedInteractiveExample("pages/js/string-raw.html")}}</div>
+{{EmbedInteractiveExample("pages/js/string-raw.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox notranslate">String.raw(callSite, <em>...substitutions</em>)
+    String.raw(callSite, ...substitutions)
 
-String.raw`gabaritChaîne`
-</pre>
+    String.raw`gabaritChaîne`
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>callSite</code></dt>
- <dd>Un site d'appel bien formé pour un gabarit (<em>call site object</em>) tel que <code>{raw: "string"}</code>.</dd>
- <dt>...substitutions</dt>
- <dd>Paramètre contenant les valeurs à substituer.</dd>
- <dt>gabaritChaîne</dt>
- <dd><a href="/fr/docs/Web/JavaScript/Reference/Gabarit_chaînes_caractères">Un gabarit de chaîne de caractères</a>, éventuellement avec des substitutions (<code>${...}</code>).</dd>
-</dl>
+- `callSite`
+  - : Un site d'appel bien formé pour un gabarit (_call site object_) tel que `{raw: "string"}`.
+- ...substitutions
+  - : Paramètre contenant les valeurs à substituer.
+- gabaritChaîne
+  - : [Un gabarit de chaîne de caractères](/fr/docs/Web/JavaScript/Reference/Gabarit_chaînes_caractères), éventuellement avec des substitutions (`${...}`).
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>La chaîne de caractères brute correspondant à un gabarit donné.</p>
+La chaîne de caractères brute correspondant à un gabarit donné.
 
-<h3 id="Exceptions">Exceptions</h3>
+### Exceptions
 
-<dl>
- <dt>{{jsxref("TypeError")}}</dt>
- <dd>Une exception <code>TypeError</code> est renvoyée si le premier argument n'est pas un objet bien formé.</dd>
-</dl>
+- {{jsxref("TypeError")}}
+  - : Une exception `TypeError` est renvoyée si le premier argument n'est pas un objet bien formé.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Dans la plupart des cas, <code>String.raw()</code> est utilisé avec des gabarits de chaînes de caractères. La première syntaxe, présentée ci-avant est rarement utilisée. En effet, le moteur JavaScript appellera cette forme avec les arguments appropriés, comme pour les <a href="/fr/docs/Web/JavaScript/Reference/Gabarit_chaînes_caractères#Les_gabarits_de_cha.C3.AEnes_.C3.A9tiquett.C3.A9s">fonctions d'étiquetage (<em>tag</em>)</a>.</p>
+Dans la plupart des cas, `String.raw()` est utilisé avec des gabarits de chaînes de caractères. La première syntaxe, présentée ci-avant est rarement utilisée. En effet, le moteur JavaScript appellera cette forme avec les arguments appropriés, comme pour les [fonctions d'étiquetage (_tag_)](/fr/docs/Web/JavaScript/Reference/Gabarit_chaînes_caractères#Les_gabarits_de_cha.C3.AEnes_.C3.A9tiquett.C3.A9s).
 
-<p>La méthode <code>String.raw()</code> est la seule méthode d'étiquetage native pour les chaînes de caractères. Elle fonctionne comme la fonction par défaut pour les gabarits et permet d'effectuer des concaténations. Il est également possible d'implémenter cette méthode avec du code JavaScript.</p>
+La méthode `String.raw()` est la seule méthode d'étiquetage native pour les chaînes de caractères. Elle fonctionne comme la fonction par défaut pour les gabarits et permet d'effectuer des concaténations. Il est également possible d'implémenter cette méthode avec du code JavaScript.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<pre class="brush: js notranslate">String.raw`Hi\n${2+3}!`;
+```js
+String.raw`Hi\n${2+3}!`;
 // "Hi\n5!", le caractère après "Hi" n'est pas
 // le caractère de nouvelle ligne
 // "\" et "n" sont bien deux caractères distincts
@@ -76,38 +72,21 @@ String.raw`Hi\n${nom}!`;
 // comme une fonction, mais c'est possible :
 String.raw({raw: "test"}, 0, 1, 2);
 // "t0e1s2t"
-</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-string.raw', 'String.raw')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-string.raw', 'String.raw')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.String.raw")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li><a href="/fr/docs/Web/JavaScript/Reference/Gabarit_chaînes_caractères">Gabarits de chaînes de caractères</a></li>
- <li>{{jsxref("String")}}</li>
- <li><a href="/fr/docs/Web/JavaScript/Reference/Grammaire_lexicale">Grammaire lexicale JavaScript</a></li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                | État                         | Commentaires         |
+| ---------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ES2015', '#sec-string.raw', 'String.raw')}}     | {{Spec2('ES2015')}}     | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-string.raw', 'String.raw')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.String.raw")}}
+
+## Voir aussi
+
+- [Gabarits de chaînes de caractères](/fr/docs/Web/JavaScript/Reference/Gabarit_chaînes_caractères)
+- {{jsxref("String")}}
+- [Grammaire lexicale JavaScript](/fr/docs/Web/JavaScript/Reference/Grammaire_lexicale)
diff --git a/files/fr/web/javascript/reference/global_objects/string/repeat/index.md b/files/fr/web/javascript/reference/global_objects/string/repeat/index.md
index 77600fdf96..94d7c0e7eb 100644
--- a/files/fr/web/javascript/reference/global_objects/string/repeat/index.md
+++ b/files/fr/web/javascript/reference/global_objects/string/repeat/index.md
@@ -12,73 +12,56 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/String/repeat
 original_slug: Web/JavaScript/Reference/Objets_globaux/String/repeat
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>repeat()</strong></code> construit et renvoie une nouvelle chaine de caractères qui contient le nombre de copie demandée de la chaine de caractères sur laquelle la méthode a été appelée, concaténées les unes aux autres.</p>
+La méthode **`repeat()`** construit et renvoie une nouvelle chaine de caractères qui contient le nombre de copie demandée de la chaine de caractères sur laquelle la méthode a été appelée, concaténées les unes aux autres.
 
-<div>{{EmbedInteractiveExample("pages/js/string-repeat.html")}}</div>
+{{EmbedInteractiveExample("pages/js/string-repeat.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>str</var>.repeat(<var>compte</var>)</pre>
+    str.repeat(compte)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>compte</code></dt>
- <dd>Un nombre entier entre 0 and +∞ : [ 0, +∞[, indiquant le nombre de fois que la chaine de caractères doit être repétée dans la nouvelle chaine de caractères.</dd>
-</dl>
+- `compte`
+  - : Un nombre entier entre 0 and +∞ : \[ 0, +∞\[, indiquant le nombre de fois que la chaine de caractères doit être repétée dans la nouvelle chaine de caractères.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une nouvelle chaîne de caractères composée du nombre indiqué de copies de la chaîne appelante.</p>
+Une nouvelle chaîne de caractères composée du nombre indiqué de copies de la chaîne appelante.
 
-<h3 id="Exceptions">Exceptions</h3>
+### Exceptions
 
-<ul>
- <li>{{jsxref("Erreurs/Negative_repetition_count", "RangeError")}} : le nombre de répétition doit être positif.</li>
- <li>{{jsxref("Erreurs/Resulting_string_too_large", "RangeError")}} : le nombre de répétition ne doit pas être infini et la taille de la chaîne résultante ne doit pas dépasser la taille maximale pour une chaîne de caractères.</li>
-</ul>
+- {{jsxref("Erreurs/Negative_repetition_count", "RangeError")}} : le nombre de répétition doit être positif.
+- {{jsxref("Erreurs/Resulting_string_too_large", "RangeError")}} : le nombre de répétition ne doit pas être infini et la taille de la chaîne résultante ne doit pas dépasser la taille maximale pour une chaîne de caractères.
 
-<dl>
- <dt>{{jsxref("RangeError")}}</dt>
- <dd>La compteur doit être positif et inférieur à l'infini.</dd>
-</dl>
+<!---->
 
-<h2 id="Exemples">Exemples</h2>
+- {{jsxref("RangeError")}}
+  - : La compteur doit être positif et inférieur à l'infini.
 
-<pre class="brush:js">"abc".repeat(-1)     // RangeError
+## Exemples
+
+```js
+"abc".repeat(-1)     // RangeError
 "abc".repeat(0)      // ""
 "abc".repeat(1)      // "abc"
 "abc".repeat(2)      // "abcabc"
 "abc".repeat(3.5)    // "abcabcabc" (le compteur est converti en un nombre entier)
 "abc".repeat(1/0)    // RangeError
 
-({toString : () =&gt; "abc", repeat : String.prototype.repeat}).repeat(2)
-// "abcabc" (repeat() est une méthode générique)</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">Commentaire</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES2015', '#sec-string.prototype.repeat', 'String.prototype.repeat')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Première définition.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-string.prototype.repeat', 'String.prototype.repeat')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.String.repeat")}}</p>
+({toString : () => "abc", repeat : String.prototype.repeat}).repeat(2)
+// "abcabc" (repeat() est une méthode générique)
+```
+
+## Spécifications
+
+| Spécification                                                                                                | État                         | Commentaire          |
+| ------------------------------------------------------------------------------------------------------------ | ---------------------------- | -------------------- |
+| {{SpecName('ES2015', '#sec-string.prototype.repeat', 'String.prototype.repeat')}} | {{Spec2('ES2015')}}     | Première définition. |
+| {{SpecName('ESDraft', '#sec-string.prototype.repeat', 'String.prototype.repeat')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.String.repeat")}}
diff --git a/files/fr/web/javascript/reference/global_objects/string/replace/index.md b/files/fr/web/javascript/reference/global_objects/string/replace/index.md
index 69816aace6..3dbd06edb5 100644
--- a/files/fr/web/javascript/reference/global_objects/string/replace/index.md
+++ b/files/fr/web/javascript/reference/global_objects/string/replace/index.md
@@ -12,191 +12,224 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/String/replace
 original_slug: Web/JavaScript/Reference/Objets_globaux/String/replace
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>replace()</strong></code> renvoie une nouvelle chaîne de caractères dans laquelle tout ou partie des correspondances à un <code>modèle</code> sont remplacées par un <code>remplacement</code>. Le <code>modèle</code> utilisé peut être une {{jsxref("RegExp")}} et le remplacement peut être une chaîne ou une fonction à appeler pour chaque correspondance. Si <code>modèle</code> est une chaîne de caractères, seule la première correspondance sera remplacée.</p>
+La méthode **`replace()`** renvoie une nouvelle chaîne de caractères dans laquelle tout ou partie des correspondances à un `modèle` sont remplacées par un `remplacement`. Le `modèle` utilisé peut être une {{jsxref("RegExp")}} et le remplacement peut être une chaîne ou une fonction à appeler pour chaque correspondance. Si `modèle` est une chaîne de caractères, seule la première correspondance sera remplacée.
 
-<p>La chaîne de caractère originale reste inchangée.</p>
+La chaîne de caractère originale reste inchangée.
 
-<div>{{EmbedInteractiveExample("pages/js/string-replace.html")}}</div>
+{{EmbedInteractiveExample("pages/js/string-replace.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>chn</var>.replace(<var>regexp</var>|<var>souschn</var>, nouv<var>Souschn</var>|<var>fonction</var>)</pre>
+    chn.replace(regexp|souschn, nouvSouschn|fonction)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>regexp</code> (modèle)</dt>
- <dd>Un objet ou un littéral {{jsxref("RegExp")}}. La ou les correspondances sont remplacées  par <code>nouvSouschn</code> ou par la valeur retournée par la <code>fonction</code> indiquée.</dd>
- <dt><code>souschn</code> (modèle)</dt>
- <dd>Une {{jsxref("String")}} qui est à remplacer par <code>nouvSouschn</code>. Elle est traitée comme une chaîne de caractères verbatim et elle n'est <em>pas</em> interprétée comme une expression régulière. Seule la première occurrence sera remplacée.</dd>
- <dt><code>nouvSouschn</code> (remplacement)</dt>
- <dd>La {{jsxref("String")}} qui remplace la chaîne de caractères indiquée par le paramètre <code>regexp</code> ou <code>souschn</code>. Un certain nombre de modèles de remplacement spéciaux sont supportés ; voir la section "<a href="#Indiquer_une_chaîne_de_caractère_comme_paramètre">Indiquer une chaîne de caractères comme paramètre</a>" ci-dessous.</dd>
- <dt><code>fonction</code> (remplacement)</dt>
- <dd>Une fonction à appeler pour créer la nouvelle sous-chaîne de caractères à utiliser pour remplacer la <code>regexp</code> ou la <code>souschn</code> donnée. Les arguments passés à cette fonction sont décrits dans la section "<a href="#Indiquer_une_fonction_comme_paramètre">Indiquer une fonction comme paramètre</a>" ci-dessous.</dd>
-</dl>
+- `regexp` (modèle)
+  - : Un objet ou un littéral {{jsxref("RegExp")}}. La ou les correspondances sont remplacées  par `nouvSouschn` ou par la valeur retournée par la `fonction` indiquée.
+- `souschn` (modèle)
+  - : Une {{jsxref("String")}} qui est à remplacer par `nouvSouschn`. Elle est traitée comme une chaîne de caractères verbatim et elle n'est _pas_ interprétée comme une expression régulière. Seule la première occurrence sera remplacée.
+- `nouvSouschn` (remplacement)
+  - : La {{jsxref("String")}} qui remplace la chaîne de caractères indiquée par le paramètre `regexp` ou `souschn`. Un certain nombre de modèles de remplacement spéciaux sont supportés ; voir la section "[Indiquer une chaîne de caractères comme paramètre](#Indiquer_une_chaîne_de_caractère_comme_paramètre)" ci-dessous.
+- `fonction` (remplacement)
+  - : Une fonction à appeler pour créer la nouvelle sous-chaîne de caractères à utiliser pour remplacer la `regexp` ou la `souschn` donnée. Les arguments passés à cette fonction sont décrits dans la section "[Indiquer une fonction comme paramètre](#Indiquer_une_fonction_comme_paramètre)" ci-dessous.
 
-<h3 id="Valeur_retournée">Valeur retournée</h3>
+### Valeur retournée
 
-<p>Une nouvelle chaîne de caractères avec tout ou partie des correspondances du modèle remplacées par un remplacement.</p>
+Une nouvelle chaîne de caractères avec tout ou partie des correspondances du modèle remplacées par un remplacement.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Cette méthode ne change pas l'objet {{jsxref("String")}} auquel elle est appliquée. Elle retourne simplement une nouvelle chaîne de caractères.</p>
+Cette méthode ne change pas l'objet {{jsxref("String")}} auquel elle est appliquée. Elle retourne simplement une nouvelle chaîne de caractères.
 
-<p>Pour réaliser une recherche et remplacement global(e), incluez le commutateur <code>g</code> dans l'expression régulière.</p>
+Pour réaliser une recherche et remplacement global(e), incluez le commutateur `g` dans l'expression régulière.
 
-<h3 id="Indiquer_une_chaîne_de_caractère_comme_paramètre">Indiquer une chaîne de caractère comme paramètre</h3>
+### Indiquer une chaîne de caractère comme paramètre
 
-<p>La chaîne de caractère de remplacement peut inclure les modèles de remplacement spéciaux suivants :</p>
+La chaîne de caractère de remplacement peut inclure les modèles de remplacement spéciaux suivants :
 
 <table class="standard-table">
- <tbody>
-  <tr>
-   <td class="header">Modèle</td>
-   <td class="header">Insère</td>
-  </tr>
-  <tr>
-   <td><code>$$</code></td>
-   <td>Insère un "$".</td>
-  </tr>
-  <tr>
-   <td><code>$&amp;</code></td>
-   <td>Insère la chaine de caractère en correspondance.</td>
-  </tr>
-  <tr>
-   <td><code>$`</code></td>
-   <td>Insère la partie de la chaîne de caractère qui précède la sous-chaîne en correspondance.</td>
-  </tr>
-  <tr>
-   <td><code>$'</code></td>
-   <td>Insère la partie de la chaîne de caractère qui suit la sous-chaîne en correspondance.</td>
-  </tr>
-  <tr>
-   <td><code>$n</code></td>
-   <td>
-    <p>Où <code><em>n</em></code> est un entier positif inférieur à 100. Insère la <em>n</em> ième chaîne de sous-correspondance entre parenthèses, à condition que le premier argument ait été un objet {{jsxref("RegExp")}}. Notez que ceci est réalisé en indices base 1.</p>
-   </td>
-  </tr>
- </tbody>
+  <tbody>
+    <tr>
+      <td class="header">Modèle</td>
+      <td class="header">Insère</td>
+    </tr>
+    <tr>
+      <td><code>$$</code></td>
+      <td>Insère un "$".</td>
+    </tr>
+    <tr>
+      <td><code>$&#x26;</code></td>
+      <td>Insère la chaine de caractère en correspondance.</td>
+    </tr>
+    <tr>
+      <td><code>$`</code></td>
+      <td>
+        Insère la partie de la chaîne de caractère qui précède la sous-chaîne en
+        correspondance.
+      </td>
+    </tr>
+    <tr>
+      <td><code>$'</code></td>
+      <td>
+        Insère la partie de la chaîne de caractère qui suit la sous-chaîne en
+        correspondance.
+      </td>
+    </tr>
+    <tr>
+      <td><code>$n</code></td>
+      <td>
+        <p>
+          Où <code><em>n</em></code> est un entier positif inférieur à 100.
+          Insère la <em>n</em> ième chaîne de sous-correspondance entre
+          parenthèses, à condition que le premier argument ait été un objet
+          {{jsxref("RegExp")}}. Notez que ceci est réalisé en
+          indices base 1.
+        </p>
+      </td>
+    </tr>
+  </tbody>
 </table>
 
-<h3 id="Indiquer_une_fonction_comme_paramètre">Indiquer une fonction comme paramètre</h3>
+### Indiquer une fonction comme paramètre
 
-<p>Vous pouvez indiquer une fonction comme second paramètre. Dans ce cas, cette fonction sera appelée après que la recherche a été effectuée. Le résultat de la fonction (valeur retournée) sera utilisé comme chaîne de remplacement. (Note : les modèles de remplacement spéciaux mentionnés ci-dessus ne s'appliquent <em>pas</em> dans ce cas). Notez que cette fonction sera appelée plusieurs fois, pour chaque correspondance complète à remplacer si l'expression régulière dans le premier paramètre est globale.</p>
+Vous pouvez indiquer une fonction comme second paramètre. Dans ce cas, cette fonction sera appelée après que la recherche a été effectuée. Le résultat de la fonction (valeur retournée) sera utilisé comme chaîne de remplacement. (Note : les modèles de remplacement spéciaux mentionnés ci-dessus ne s'appliquent _pas_ dans ce cas). Notez que cette fonction sera appelée plusieurs fois, pour chaque correspondance complète à remplacer si l'expression régulière dans le premier paramètre est globale.
 
-<p>Les arguments de cette fonction sont les suivants :</p>
+Les arguments de cette fonction sont les suivants :
 
 <table class="standard-table">
- <tbody>
-  <tr>
-   <td class="header">Nom possible</td>
-   <td class="header">Valeur fournie</td>
-  </tr>
-  <tr>
-   <td><code>correspondance</code></td>
-   <td>La chaîne de caractère en correspondance. (Correspond au <code>$&amp;</code> défini ci-dessus.)</td>
-  </tr>
-  <tr>
-   <td><code>p1, p2, ...</code></td>
-   <td>
-    <p>La <em>n</em>-ième chaîne de sous-correspondance entre parenthèses capturantes, à condition que le premier argument de <code>replace()</code> soit un objet <code>RegExp</code>. (Correspond aux <code>$1</code>, <code>$2</code>, etc. ci-dessus.) Par exemple, si <code>/(\a+)(\b+)/</code> a été indiqué, <code>p1</code> correspond à <code>\a+</code>, et <code>p2</code> à <code>\b+</code>.</p>
-   </td>
-  </tr>
-  <tr>
-   <td><code>decalage</code></td>
-   <td>Le décalage entre la sous-chaîne en correspondance à l'intérieur de la chaîne complète en cours d'analyse. (Par exemple, si la chaîne complète était <code>'abcd'</code>, et que le chaîne en correspondance était <code>'bc'</code>, alors cet argument vaudra 1.)</td>
-  </tr>
-  <tr>
-   <td><code>chaine</code></td>
-   <td>La chaîne complète en cours d'analyse.</td>
-  </tr>
- </tbody>
+  <tbody>
+    <tr>
+      <td class="header">Nom possible</td>
+      <td class="header">Valeur fournie</td>
+    </tr>
+    <tr>
+      <td><code>correspondance</code></td>
+      <td>
+        La chaîne de caractère en correspondance. (Correspond au
+        <code>$&#x26;</code> défini ci-dessus.)
+      </td>
+    </tr>
+    <tr>
+      <td><code>p1, p2, ...</code></td>
+      <td>
+        <p>
+          La <em>n</em>-ième chaîne de sous-correspondance entre parenthèses
+          capturantes, à condition que le premier argument de <code
+            >replace()</code
+          >
+          soit un objet <code>RegExp</code>. (Correspond aux <code>$1</code>,
+          <code>$2</code>, etc. ci-dessus.) Par exemple,
+          si <code>/(\a+)(\b+)/</code> a été indiqué, <code>p1</code> correspond
+          à <code>\a+</code>, et <code>p2</code> à <code>\b+</code>.
+        </p>
+      </td>
+    </tr>
+    <tr>
+      <td><code>decalage</code></td>
+      <td>
+        Le décalage entre la sous-chaîne en correspondance à l'intérieur de la
+        chaîne complète en cours d'analyse. (Par exemple, si la chaîne complète
+        était <code>'abcd'</code>, et que le chaîne en correspondance
+        était <code>'bc'</code>, alors cet argument vaudra 1.)
+      </td>
+    </tr>
+    <tr>
+      <td><code>chaine</code></td>
+      <td>La chaîne complète en cours d'analyse.</td>
+    </tr>
+  </tbody>
 </table>
 
-<p>(Le nombre exact d'arguments varie suivant que le premier paramètre est ou non un objet {{jsxref("RegExp")}} et, dans ce cas, du nombre de sous-correspondances entre parenthèses qu'il indique.)</p>
+(Le nombre exact d'arguments varie suivant que le premier paramètre est ou non un objet {{jsxref("RegExp")}} et, dans ce cas, du nombre de sous-correspondances entre parenthèses qu'il indique.)
 
-<p>L'exemple suivant affectera <code>'abc - 12345 - #$*%'</code> à la variable <code>nouvelleChaine</code> :</p>
+L'exemple suivant affectera `'abc - 12345 - #$*%'` à la variable `nouvelleChaine` :
 
-<pre class="brush: js">function remplaceur(correspondance, p1, p2, p3, decalage, chaine) {
+```js
+function remplaceur(correspondance, p1, p2, p3, decalage, chaine) {
   // p1 est non numérique, p2 numérique, et p3 non-alphanumérique
   return [p1, p2, p3].join(' - ');
 }
 var nouvelleChaine = 'abc12345#$*%'.replace(/([^\d]*)(\d*)([^\w]*)/, remplaceur);
 console.log(nouvelleChaine); // abc - 12345 - #$*%
-</pre>
+```
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Définition_de_lexpression_régulière_dans_replace">Définition de l'expression régulière dans <code>replace()</code></h3>
+### Définition de l'expression régulière dans `replace()`
 
-<p>Dans l'exemple suivant, l'expression régulière est définie dans <code>replace()</code> et inclut l'indicateur d'indifférence à la casse.</p>
+Dans l'exemple suivant, l'expression régulière est définie dans `replace()` et inclut l'indicateur d'indifférence à la casse.
 
-<pre class="brush: js">var chn = 'Twas the night before Xmas...';
+```js
+var chn = 'Twas the night before Xmas...';
 var nouvChn = chn.replace(/xmas/i, 'Christmas');
-console.log(nouvChn); // Twas the night before Christmas...</pre>
+console.log(nouvChn); // Twas the night before Christmas...
+```
 
-<p>Cela affiche 'Twas the night before Christmas...'.</p>
+Cela affiche 'Twas the night before Christmas...'.
 
-<div class="note">
-<p><strong>Note :</strong> Voir <a href="/fr/docs/Web/JavaScript/Guide/Expressions_r%C3%A9guli%C3%A8res">ce guide</a> pour plus d'explications concernant les expressions régulières.</p>
-</div>
+> **Note :** Voir [ce guide](/fr/docs/Web/JavaScript/Guide/Expressions_r%C3%A9guli%C3%A8res) pour plus d'explications concernant les expressions régulières.
 
-<h3 id="Utilisation_de_global_et_ignore_avec_replace">Utilisation de <code>global</code> et <code>ignore</code> avec <code>replace()</code></h3>
+### Utilisation de `global` et `ignore` avec `replace()`
 
-<p>Le remplacement global ne peut être fait qu'avec une expression régulière. Dans l'exemple suivant, l'expression régulière inclut les indicateurs global et indifférence à la casse, qui permettent à <code>replace()</code> de remplacer chaque occurrence de 'pommes' dans la chaîne par 'oranges'.</p>
+Le remplacement global ne peut être fait qu'avec une expression régulière. Dans l'exemple suivant, l'expression régulière inclut les indicateurs global et indifférence à la casse, qui permettent à `replace()` de remplacer chaque occurrence de 'pommes' dans la chaîne par 'oranges'.
 
-<pre class="brush: js">var re = /pommes/gi;
+```js
+var re = /pommes/gi;
 var chn = 'Les pommes sont rondes, et les pommes sont juteuses.';
 var nouvChn = chn.replace(re, 'oranges');
 console.log(nouvChn); // Les oranges sont rondes, et les oranges sont juteuses.
-</pre>
+```
 
-<p>Cela affiche 'Les oranges sont rondes, et les oranges sont juteuses.'.</p>
+Cela affiche 'Les oranges sont rondes, et les oranges sont juteuses.'.
 
-<h3 id="Inverser_des_mots_dans_une_chaîne_de_caractères">Inverser des mots dans une chaîne de caractères</h3>
+### Inverser des mots dans une chaîne de caractères
 
-<p>Le script suivant intervertit les mots dans la chaîne de caractères. Pour le texte de remplacement, le script utilise les modèles de remplacement <code>$1</code> et <code>$2</code>.</p>
+Le script suivant intervertit les mots dans la chaîne de caractères. Pour le texte de remplacement, le script utilise les modèles de remplacement `$1` et `$2`.
 
-<pre class="brush: js">var re = /(\w+)\s(\w+)/;
+```js
+var re = /(\w+)\s(\w+)/;
 var chn = 'Jean Martin';
 var nouvChn = chn.replace(re, "$2, $1");
 console.log(nouvChn); // Martin, Jean
-</pre>
+```
 
-<p>Cela affiche 'Martin, Jean'.</p>
+Cela affiche 'Martin, Jean'.
 
-<h3 id="Utilisation_dune_fonction_inline_modifiant_les_caractères_en_correspondance">Utilisation d'une fonction inline modifiant les caractères en correspondance</h3>
+### Utilisation d'une fonction inline modifiant les caractères en correspondance
 
-<p>Dans cet exemple, toutes les occurrences des lettres majuscules sont converties en minuscules, et un tiret est inséré juste avant l'emplacement de la correspondance. La chose importante ici est que des opérations suppémentaires sont nécessaires sur l'élément en correspondance avant qu'il ne soit retourné comme remplacement.</p>
+Dans cet exemple, toutes les occurrences des lettres majuscules sont converties en minuscules, et un tiret est inséré juste avant l'emplacement de la correspondance. La chose importante ici est que des opérations suppémentaires sont nécessaires sur l'élément en correspondance avant qu'il ne soit retourné comme remplacement.
 
-<p>La fonction de remplacement accepte le fragment en correspondance comme paramètre, et elle l'utilise pour transformer sa casse et y concaténer le tiret avant de le retourner.</p>
+La fonction de remplacement accepte le fragment en correspondance comme paramètre, et elle l'utilise pour transformer sa casse et y concaténer le tiret avant de le retourner.
 
-<pre class="brush: js">function styleFormatTiret(nomPropriete) {
+```js
+function styleFormatTiret(nomPropriete) {
   function majusculesEnTiretMinuscules(correspondance, decalage, chaine) {
-    return (decalage &gt; 0 ? '-' : '') + correspondance.toLowerCase();
+    return (decalage > 0 ? '-' : '') + correspondance.toLowerCase();
   }
   return nomPropriete.replace(/[A-Z]/g, majusculesEnTiretMinuscules);
 }
-</pre>
+```
 
-<p>Avec <code>styleFormatTiret(</code><code>'borderTop')</code>, cela renvoie 'border-top'.</p>
+Avec ` styleFormatTiret(``'borderTop') `, cela renvoie 'border-top'.
 
-<p>Du fait que nous voulons transformer davantage le résultat de la correspondance avant la substitution finale, nous devons utiliser une fonction. Cela force l'évaluation de la correspondance avant la méthode {{jsxref ("String.prototype.toLowerCase()", "toLowerCase()")}}. Si nous avions essayé de le faire en utilisant la correspondance sans fonction, le {{jsxref ("String.prototype.toLowerCase()", "toLowerCase()")}} n'aurait eu aucun effet.</p>
+Du fait que nous voulons transformer davantage le résultat de la correspondance avant la substitution finale, nous devons utiliser une fonction. Cela force l'évaluation de la correspondance avant la méthode {{jsxref ("String.prototype.toLowerCase()", "toLowerCase()")}}. Si nous avions essayé de le faire en utilisant la correspondance sans fonction, le {{jsxref ("String.prototype.toLowerCase()", "toLowerCase()")}} n'aurait eu aucun effet.
 
-<pre class="brush: js">var nouvChn = nomPropriete.replace(/[A-Z]/g, '-' + '$&amp;'.toLowerCase()); // ne fonctionne pas
-</pre>
+```js
+var nouvChn = nomPropriete.replace(/[A-Z]/g, '-' + '$&'.toLowerCase()); // ne fonctionne pas
+```
 
-<p>Ceci est dû au fait que <code>'$&amp;'.toLowerCase()</code> serait d'abord évalué comme un littéral de chaîne (résultant en le même <code>'$&amp;'</code>) avant d'utiliser les caractères comme modèle.</p>
+Ceci est dû au fait que `'$&'.toLowerCase()` serait d'abord évalué comme un littéral de chaîne (résultant en le même `'$&'`) avant d'utiliser les caractères comme modèle.
 
-<h3 id="Remplacer_un_degré_Fahrenheit_par_son_équivalent_Celsius">Remplacer un degré Fahrenheit par son équivalent Celsius</h3>
+### Remplacer un degré Fahrenheit par son équivalent Celsius
 
-<p>L'exemple suivant remplace des degrés Fahrenheit par leur équivalent en degrés Celsius. Les degrés Fahrenheit doivent être un nombre se terminant par F. La fonction renvoie le nombre en Celsius se terminant par C. Par exemple, si le nombre de départ est 212F, la fonction renvoie 100C. Si le nombre de départ est 0F, la fonction retourne -17.77777777777778C.</p>
+L'exemple suivant remplace des degrés Fahrenheit par leur équivalent en degrés Celsius. Les degrés Fahrenheit doivent être un nombre se terminant par F. La fonction renvoie le nombre en Celsius se terminant par C. Par exemple, si le nombre de départ est 212F, la fonction renvoie 100C. Si le nombre de départ est 0F, la fonction retourne -17.77777777777778C.
 
-<p>L'expression régulière <code>test</code> vérifie tout nombre se terminant par F. Le nombre de degrés Fahrenheit est accessible à la fonction via son deuxième paramètre, <code>p1</code>. La fonction définit le nombre Celsius sur la base des degrés Fahrenheit transmis dans une chaîne à la fonction <code>f2c()</code>. <code>f2c()</code> renvoie ensuite le nombre Celsius. Cette fonction se rapproche de l'indicateur <code>s///e</code> de Perl.</p>
+L'expression régulière `test` vérifie tout nombre se terminant par F. Le nombre de degrés Fahrenheit est accessible à la fonction via son deuxième paramètre, `p1`. La fonction définit le nombre Celsius sur la base des degrés Fahrenheit transmis dans une chaîne à la fonction `f2c()`. `f2c()` renvoie ensuite le nombre Celsius. Cette fonction se rapproche de l'indicateur `s///e` de Perl.
 
-<pre class="brush: js">function f2c(x) {
+```js
+function f2c(x) {
   function convertir(chn, p1, decalage, s) {
     return ((p1-32) * 5/9) + 'C';
   }
@@ -204,103 +237,72 @@ console.log(nouvChn); // Martin, Jean
   var test = /(-?\d+(?:\.\d*)?)F\b/g;
   return s.replace(test, convertir);
 }
-</pre>
+```
 
-<h3 id="Utiliser_une_fonction_inline_avec_une_expression_régulière_pour_éviter_des_boucles_for">Utiliser une fonction inline avec une expression régulière pour éviter des boucles <code>for</code></h3>
+### Utiliser une fonction inline avec une expression régulière pour éviter des boucles `for`
 
-<p>L'exemple suivant accepte un modèle chaîne et le convertit en un tableau d'objets.</p>
+L'exemple suivant accepte un modèle chaîne et le convertit en un tableau d'objets.
 
-<p><strong>Entrée : </strong></p>
+**Entrée :**
 
-<p>Une chaîne de caractères composée des caractères <code>x</code>, <code>-</code> et <code>_</code></p>
+Une chaîne de caractères composée des caractères `x`, `-` et `_`
 
-<pre class="brush: js">x-x_
+```js
+x-x_
 x---x---x---x---
 x-xxx-xx-x-
-x_x_x___x___x___</pre>
+x_x_x___x___x___
+```
 
-<div><strong>Sortie :</strong></div>
+**Sortie :**Un tableau d'objets. Un `'x'` dénote un état `'marche'`, un `'-'` symbolise un état '`arret`' et un  `'_'` (blanc souligné) symbolise la longueur d'un état `'marche'`.
 
-<div></div>
-
-<div>Un tableau d'objets. Un <code>'x'</code> dénote un état <code>'marche'</code>, un <code>'-'</code> symbolise un état '<code>arret</code>' et un  <code>'_'</code> (blanc souligné) symbolise la longueur d'un état <code>'<code>marche</code>'</code>.</div>
-
-<div></div>
-
-<pre class="brush: json">[
+```json
+[
   { marche: true, longueur: 1 },
   { marche: false, longueur: 1 },
   { marche: true, longueur: 2 }
   ...
-]</pre>
+]
+```
 
-<div><strong>Fragment :</strong></div>
+**Fragment :**
 
-<div></div>
-
-<div>
-<pre class="brush: js">var chn = 'x-x_';
+```js
+var chn = 'x-x_';
 var tabRet = [];
 chn.replace(/(x_*)|(-)/g, function(correspondance, $1, $2){
   if($1) tabRet.push({ marche: true, longueur: $1.length });
   if($2) tabRet.push({ marche: false, longueur: 1 });
 });
 
-console.log(tabRet);</pre>
-</div>
+console.log(tabRet);
+```
 
-<div>Ce fragment génère un tableau de 3 objets au format désiré sans utiliser de boucle <code>for</code>.</div>
+Ce fragment génère un tableau de 3 objets au format désiré sans utiliser de boucle `for`.
 
-<h2 id="Spécifications">Spécifications</h2>
+## Spécifications
 
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">Statut</th>
-   <th scope="col">Commentaire</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES3')}}</td>
-   <td>{{Spec2('ES3')}}</td>
-   <td>Définition initiale. Implémentée en JavaScript 1.2</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.5.4.11', 'String.prototype.replace')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-string.prototype.replace', 'String.prototype.replace')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-string.prototype.replace', 'String.prototype.replace')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
+| Spécification                                                                                                    | Statut                       | Commentaire                                        |
+| ---------------------------------------------------------------------------------------------------------------- | ---------------------------- | -------------------------------------------------- |
+| {{SpecName('ES3')}}                                                                                         | {{Spec2('ES3')}}         | Définition initiale. Implémentée en JavaScript 1.2 |
+| {{SpecName('ES5.1', '#sec-15.5.4.11', 'String.prototype.replace')}}                         | {{Spec2('ES5.1')}}     |                                                    |
+| {{SpecName('ES6', '#sec-string.prototype.replace', 'String.prototype.replace')}}     | {{Spec2('ES6')}}         |                                                    |
+| {{SpecName('ESDraft', '#sec-string.prototype.replace', 'String.prototype.replace')}} | {{Spec2('ESDraft')}} |                                                    |
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.String.replace")}}</p>
+{{Compat("javascript.builtins.String.replace")}}
 
-<h2 id="Notes_spécifiques_à_Firefox">Notes spécifiques à Firefox</h2>
+## Notes spécifiques à Firefox
 
-<ul>
- <li><code>flags</code> était un troisième argument non standard disponible uniquement dans Gecko : <var>str</var>.replace(<var>regexp</var>|<var>substr</var>, <var>newSubStr</var>|<var>function, flags</var>)</li>
- <li>À partir de Gecko 27 {{geckoRelease(27)}}, cette méthode a été modifiée pour être conforme à la spécification ECMAScript. Lorsque <code>replace()</code> est appelée avec une expression régulière globale, la propriété {{jsxref("RegExp.lastIndex")}} (si elle est définie) sera remise à <code>0</code> ({{bug(501739)}}).</li>
- <li>À partir de Gecko 39 {{geckoRelease(39)}}, l'argument non-standard <code>flags</code> est désapprouvé et déclenche un avertissement dans la console ({{bug(1142351)}}).</li>
- <li>À partir de Gecko 47 {{geckoRelease(47)}}, l'argument non-standard <code>flags</code> n'est plus supporté dans les versions non distribution et sera bientôt retiré complètement ({{bug(1245801)}}).</li>
- <li>À partir de Gecko 49 {{geckoRelease(49)}}, l'argument non-standard <code>flags</code> n'est plus supporté ({{bug(1108382)}}).</li>
-</ul>
+- `flags` était un troisième argument non standard disponible uniquement dans Gecko : *str*.replace(_regexp_|_substr_, _newSubStr_|_function, flags_)
+- À partir de Gecko 27 {{geckoRelease(27)}}, cette méthode a été modifiée pour être conforme à la spécification ECMAScript. Lorsque `replace()` est appelée avec une expression régulière globale, la propriété {{jsxref("RegExp.lastIndex")}} (si elle est définie) sera remise à `0` ({{bug(501739)}}).
+- À partir de Gecko 39 {{geckoRelease(39)}}, l'argument non-standard `flags` est désapprouvé et déclenche un avertissement dans la console ({{bug(1142351)}}).
+- À partir de Gecko 47 {{geckoRelease(47)}}, l'argument non-standard `flags` n'est plus supporté dans les versions non distribution et sera bientôt retiré complètement ({{bug(1245801)}}).
+- À partir de Gecko 49 {{geckoRelease(49)}}, l'argument non-standard `flags` n'est plus supporté ({{bug(1108382)}}).
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("String.prototype.match()")}}</li>
- <li>{{jsxref("RegExp.prototype.exec()")}}</li>
- <li>{{jsxref("RegExp.prototype.test()")}}</li>
-</ul>
+- {{jsxref("String.prototype.match()")}}
+- {{jsxref("RegExp.prototype.exec()")}}
+- {{jsxref("RegExp.prototype.test()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/string/replaceall/index.md b/files/fr/web/javascript/reference/global_objects/string/replaceall/index.md
index c06b93eca3..32d1bcef6b 100644
--- a/files/fr/web/javascript/reference/global_objects/string/replaceall/index.md
+++ b/files/fr/web/javascript/reference/global_objects/string/replaceall/index.md
@@ -4,164 +4,147 @@ slug: Web/JavaScript/Reference/Global_Objects/String/replaceAll
 translation_of: Web/JavaScript/Reference/Global_Objects/String/replaceAll
 original_slug: Web/JavaScript/Reference/Objets_globaux/String/replaceAll
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>replaceAll()</code></strong> retourne une nouvelle chaîne de caractères dans laquelle toutes les occurrences d'un motif donné ont été remplacées par une chaîne de remplacement. L'argument <code>pattern</code> fournit pour décrire le motif peut être une chaîne de caractères ou une expression rationnelle (<a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/RegExp"><code>RegExp</code></a>), l'argument <code>replacement</code> peut être une chaîne de caractères ou une fonction qui sera appelée pour chaque correspondance.</p>
+La méthode **`replaceAll()`** retourne une nouvelle chaîne de caractères dans laquelle toutes les occurrences d'un motif donné ont été remplacées par une chaîne de remplacement. L'argument `pattern` fournit pour décrire le motif peut être une chaîne de caractères ou une expression rationnelle ([`RegExp`](/fr/docs/Web/JavaScript/Reference/Global_Objects/RegExp)), l'argument `replacement` peut être une chaîne de caractères ou une fonction qui sera appelée pour chaque correspondance.
 
-<p>La chaîne de caractères initiale restera inchangée.</p>
+La chaîne de caractères initiale restera inchangée.
 
-<div>{{EmbedInteractiveExample("pages/js/string-replaceall.html")}}</div>
+{{EmbedInteractiveExample("pages/js/string-replaceall.html")}}
 
-<h2 id="syntax">Syntaxe</h2>
+## Syntaxe
 
-<pre class="brush: js">const newStr = <var>str</var>.replaceAll(<var>regexp</var>|<var>substr</var>, <var>newSubstr</var>|<var>function</var>)
-</pre>
+```js
+const newStr = str.replaceAll(regexp|substr, newSubstr|function)
+```
 
-<div class="notecard note">
-<p><strong>Note :</strong> Quand on utilise une expression rationnelle, il est nécessaire d'utiliser le marqueur global ("g"); autrement, l'exception <code>TypeError</code>: <i>"replaceAll must be called with a global RegExp"</i> sera levée.</p>
-</div>
+> **Note :** Quand on utilise une expression rationnelle, il est nécessaire d'utiliser le marqueur global ("g"); autrement, l'exception `TypeError`: _"replaceAll must be called with a global RegExp"_ sera levée.
 
-<h3 id="parameters">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code><var>regexp</var></code> (le motif à rechercher)</dt>
- <dd>Un objet ou littérale <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/RegExp"><code>RegExp</code></a> avec le marqueur global. Les correspondances sont remplacées par <code><var>newSubstr</var></code> ou la valeur retournée par la <code><var>function</var></code> spécifiée. Une RegExp sans le marqueur global ("g") renverra l'erreur <code>TypeError</code>: "replaceAll must be called with a global RegExp".</dd>
- <dt><code><var>substr</var></code></dt>
- <dd>Une chaîne de caractères (<a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String"><code>String</code></a>) qui sera remplacée par <code><var>newSubstr</var></code>. Elle est traitée comme une chaîne de caracères littérale et <em>non pas</em> comme une expression régulière.</dd>
- <dt><code><var>newSubstr</var></code> (remplacement)</dt>
- <dd>La chaîne de caractères (<a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String"><code>String</code></a>) qui remplacera la sous-chaîne indiquée par la <code><var>regexp</var></code> ou <code><var>substr</var></code> donnée en paramètre. Un certain nombre de motifs spéciaux pour le remplacement sont pris en charge, voir la section "<a href="#specifying_a_string_as_a_parameter">Spécifier une chaîne de caractères comme paramètre</a>" ci-dessous.</dd>
- <dt><code><var>function</var></code> (remplacement)</dt>
- <dd>Une fonction qui a pour but de créer la nouvelle sous-chaîne qui remplacera les occurrences trouvées via la <code><var>regexp</var></code> ou <code><var>substr</var></code> donnée en paramètre. Les arguments passés à cette fonction sont détaillés dans la section "<a href="#specifying_a_function_as_a_parameter">Spécifier une fonction comme paramètre</a>" ci-dessous.</dd>
-</dl>
+- `regexp` (le motif à rechercher)
+  - : Un objet ou littérale [`RegExp`](/fr/docs/Web/JavaScript/Reference/Global_Objects/RegExp) avec le marqueur global. Les correspondances sont remplacées par `newSubstr` ou la valeur retournée par la `function` spécifiée. Une RegExp sans le marqueur global ("g") renverra l'erreur `TypeError`: "replaceAll must be called with a global RegExp".
+- `substr`
+  - : Une chaîne de caractères ([`String`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String)) qui sera remplacée par `newSubstr`. Elle est traitée comme une chaîne de caracères littérale et _non pas_ comme une expression régulière.
+- `newSubstr` (remplacement)
+  - : La chaîne de caractères ([`String`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String)) qui remplacera la sous-chaîne indiquée par la `regexp` ou `substr` donnée en paramètre. Un certain nombre de motifs spéciaux pour le remplacement sont pris en charge, voir la section "[Spécifier une chaîne de caractères comme paramètre](#specifying_a_string_as_a_parameter)" ci-dessous.
+- `function` (remplacement)
+  - : Une fonction qui a pour but de créer la nouvelle sous-chaîne qui remplacera les occurrences trouvées via la `regexp` ou `substr` donnée en paramètre. Les arguments passés à cette fonction sont détaillés dans la section "[Spécifier une fonction comme paramètre](#specifying_a_function_as_a_parameter)" ci-dessous.
 
-<h3 id="return_value">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une nouvelle chaîne avec toutes les occurrences trouvées remplacées par le pattern de remplacement.</p>
+Une nouvelle chaîne avec toutes les occurrences trouvées remplacées par le pattern de remplacement.
 
-<h2 id="description">Description</h2>
+## Description
 
-<p>Cette méthode ne remplace ni ne modifie l'objet <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String"><code>String</code></a> original. Elle retourne juste une nouvelle chaîne de caractères.</p>
+Cette méthode ne remplace ni ne modifie l'objet [`String`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String) original. Elle retourne juste une nouvelle chaîne de caractères.
 
-<h3 id="specifying_a_string_as_a_parameter">Spécifier une chaîne de caractères comme paramètre</h3>
+### Spécifier une chaîne de caractères comme paramètre
 
-<p>La chaîne de caractères de remplacement peut inclure les motifs de remplacement spéciaux suivants :</p>
+La chaîne de caractères de remplacement peut inclure les motifs de remplacement spéciaux suivants :
 
-<table class="standard-table">
- <thead>
-  <tr>
-   <th class="header" scope="col">Motif</th>
-   <th class="header" scope="col">Insertion</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td><code>$$</code></td>
-   <td>Insère un <code>"$"</code>.</td>
-  </tr>
-  <tr>
-   <td><code>$&amp;</code></td>
-   <td>Insère la chaîne de caractères trouvée.</td>
-  </tr>
-  <tr>
-   <td><code>$`</code></td>
-   <td>Insère la portion de chaîne de caractères qui précède celle trouvée.</td>
-  </tr>
-  <tr>
-   <td><code>$'</code></td>
-   <td>Insère la portion de chaîne de caractères qui suit celle trouvée.</td>
-  </tr>
-  <tr>
-   <td><code>$<var>n</var></code></td>
-   <td>Où <code><var>n</var></code> est un entier positif inférieur à 100. Insère la n-ième occurrence trouvée, à condition que le premier argument soit un objet <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/RegExp"><code>RegExp</code></a>. Cet indice démarre à partir de 1.</td>
-  </tr>
- </tbody>
-</table>
+| Motif    | Insertion                                                                                                                                                                                                                                   |
+| -------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `$$`     | Insère un `"$"`.                                                                                                                                                                                                                            |
+| `$&`     | Insère la chaîne de caractères trouvée.                                                                                                                                                                                                     |
+| `` $` `` | Insère la portion de chaîne de caractères qui précède celle trouvée.                                                                                                                                                                        |
+| `$'`     | Insère la portion de chaîne de caractères qui suit celle trouvée.                                                                                                                                                                           |
+| `$n`     | Où `n` est un entier positif inférieur à 100. Insère la n-ième occurrence trouvée, à condition que le premier argument soit un objet [`RegExp`](/fr/docs/Web/JavaScript/Reference/Global_Objects/RegExp). Cet indice démarre à partir de 1. |
 
-<h3 id="specifying_a_function_as_a_parameter">Spécifier une fonction comme paramètre</h3>
+### Spécifier une fonction comme paramètre
 
-<p>Vous pouvez passer une fonction comme second paramètre. Dans ce cas, la fonction sera appelée après qu'une occurrence soit trouvée. Le résultat de la fonction (valeur de retour) sera utilisé comme chaîne de remplacement. (<strong>Note : </strong>les remplacements spéciaux mentionnés plus haut <em>ne s'appliqueront pas</em> dans ce cas.)</p>
+Vous pouvez passer une fonction comme second paramètre. Dans ce cas, la fonction sera appelée après qu'une occurrence soit trouvée. Le résultat de la fonction (valeur de retour) sera utilisé comme chaîne de remplacement. (**Note :** les remplacements spéciaux mentionnés plus haut _ne s'appliqueront pas_ dans ce cas.)
 
-<p>À noter que la fonction sera utilisée à chaque fois qu'une occurrence sera rencontrée, si l'expression régulière donnée en paramètre est globale.</p>
+À noter que la fonction sera utilisée à chaque fois qu'une occurrence sera rencontrée, si l'expression régulière donnée en paramètre est globale.
 
-<p>La fonction admet les arguments suivants :</p>
+La fonction admet les arguments suivants :
 
 <table class="standard-table">
- <thead>
-  <tr>
-   <th class="header" scope="col">Nom possible</th>
-   <th class="header" scope="col">Valeur fournie</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td><code>match</code></td>
-   <td>L'occurrence trouvée. (Correspond au <code>$&amp;</code> du précédent tableau.)</td>
-  </tr>
-  <tr>
-   <td><code>p1, p2…</code></td>
-   <td>
-    <p>Le n-ième chaîne de caractères trouvée par une sous-correspondance entre parenthèses, à condition que le premier paramètre soit un objet de type <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/RegExp"><code>RegExp</code></a>.<br>
-     (Correspond aux <code>$1</code>, <code>$2</code>… précédents.) Par exemple, si <code>/(\a+)(\b+)/</code> a été passé en paramètre, <code>p1</code> est la correspondance pour <code>\a+</code>, et <code>p2</code> pour <code>\b+</code>.</p>
-   </td>
-  </tr>
-  <tr>
-   <td><code>offset</code></td>
-   <td>Le décalage de la sous-chaîne trouvée dans la chaîne d'entrée (par exemple, si la chaîne complète d'entrée était <code>'abcd'</code> et la sous-chaîne <code>'bc'</code> alors, cet argument vaudra 1.)</td>
-  </tr>
-  <tr>
-   <td><code>string</code></td>
-   <td>La chaîne compète examinée.</td>
-  </tr>
- </tbody>
+  <thead>
+    <tr>
+      <th class="header" scope="col">Nom possible</th>
+      <th class="header" scope="col">Valeur fournie</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td><code>match</code></td>
+      <td>
+        L'occurrence trouvée. (Correspond au <code>$&#x26;</code> du précédent
+        tableau.)
+      </td>
+    </tr>
+    <tr>
+      <td><code>p1, p2…</code></td>
+      <td>
+        <p>
+          Le n-ième chaîne de caractères trouvée par une sous-correspondance
+          entre parenthèses, à condition que le premier paramètre soit un objet
+          de type
+          <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/RegExp"
+            ><code>RegExp</code></a
+          >.<br />(Correspond aux <code>$1</code>, <code>$2</code>… précédents.)
+          Par exemple, si <code>/(\a+)(\b+)/</code> a été passé en paramètre,
+          <code>p1</code> est la correspondance pour <code>\a+</code>, et
+          <code>p2</code> pour <code>\b+</code>.
+        </p>
+      </td>
+    </tr>
+    <tr>
+      <td><code>offset</code></td>
+      <td>
+        Le décalage de la sous-chaîne trouvée dans la chaîne d'entrée (par
+        exemple, si la chaîne complète d'entrée était <code>'abcd'</code> et la
+        sous-chaîne <code>'bc'</code> alors, cet argument vaudra 1.)
+      </td>
+    </tr>
+    <tr>
+      <td><code>string</code></td>
+      <td>La chaîne compète examinée.</td>
+    </tr>
+  </tbody>
 </table>
 
-<p>Le nombre d'arguments exact dépend du premier argument de <code>replaceAll()</code> : si c'est un objet de type <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/RegExp"><code>RegExp</code></a> et, si tel est le cas, du nombre de sous-correspondances entre parenthèses qu'il spécifie.</p>
+Le nombre d'arguments exact dépend du premier argument de `replaceAll()` : si c'est un objet de type [`RegExp`](/fr/docs/Web/JavaScript/Reference/Global_Objects/RegExp) et, si tel est le cas, du nombre de sous-correspondances entre parenthèses qu'il spécifie.
 
-<h2 id="examples">Exemples</h2>
+## Exemples
 
-<h3 id="using_replaceAll">Utiliser replaceAll()</h3>
+### Utiliser replaceAll()
 
-<pre class="brush: js">'aabbcc'.replaceAll('b', '.');
-// 'aa..cc'</pre>
+```js
+'aabbcc'.replaceAll('b', '.');
+// 'aa..cc'
+```
 
-<h3 id="non-global_regex_throws">Exceptions pour les expressions rationnelles non globales</h3>
+### Exceptions pour les expressions rationnelles non globales
 
-<p>Quand on utilise une expression rationnelle pour chercher une valeur, celle-ci doit être globale. Le code suivant ne fonctionnera pas :</p>
+Quand on utilise une expression rationnelle pour chercher une valeur, celle-ci doit être globale. Le code suivant ne fonctionnera pas :
 
-<pre class="brush: js; example-bad">'aabbcc'.replaceAll(/b/, '.');
+```js example-bad
+'aabbcc'.replaceAll(/b/, '.');
 TypeError: replaceAll must be called with a global RegExp
-</pre>
+```
 
-<p>L'exemple suivant, utilisant le marqueur <code>g</code>, fonctionnera :</p>
+L'exemple suivant, utilisant le marqueur `g`, fonctionnera :
 
-<pre class="brush: js; example-good">'aabbcc'.replaceAll(/b/g, '.');
+```js example-good
+'aabbcc'.replaceAll(/b/g, '.');
 "aa..cc"
-</pre>
+```
 
-<h2 id="specifications">Spécifications</h2>
+## Spécifications
 
-<table class="standard-table">
- <thead>
-  <tr>
-   <th scope="col">Spécification</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-string.prototype.replaceall', 'String.prototype.replaceAll')}}</td>
-  </tr>
- </tbody>
-</table>
+| Spécification                                                                                                            |
+| ------------------------------------------------------------------------------------------------------------------------ |
+| {{SpecName('ESDraft', '#sec-string.prototype.replaceall', 'String.prototype.replaceAll')}} |
 
-<h2 id="browser_compatibility">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.String.replaceAll")}}</p>
+{{Compat("javascript.builtins.String.replaceAll")}}
 
-<h2 id="see_also">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String/replace"><code>String.prototype.replace()</code></a></li>
- <li><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String/match"><code>String.prototype.match()</code></a></li>
- <li><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/RegExp/exec"><code>RegExp.prototype.exec()</code></a></li>
- <li><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/RegExp/test"><code>RegExp.prototype.test()</code></a></li>
-</ul>
+- [`String.prototype.replace()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String/replace)
+- [`String.prototype.match()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String/match)
+- [`RegExp.prototype.exec()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/RegExp/exec)
+- [`RegExp.prototype.test()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/RegExp/test)
diff --git a/files/fr/web/javascript/reference/global_objects/string/search/index.md b/files/fr/web/javascript/reference/global_objects/string/search/index.md
index aa1828528f..29c4facc8d 100644
--- a/files/fr/web/javascript/reference/global_objects/string/search/index.md
+++ b/files/fr/web/javascript/reference/global_objects/string/search/index.md
@@ -11,93 +11,66 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/String/search
 original_slug: Web/JavaScript/Reference/Objets_globaux/String/search
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>search()</strong></code> éxecute une recherche dans une chaine de caractères grâce à une expression rationnelle appliquée sur la chaîne courante.</p>
+La méthode **`search()`** éxecute une recherche dans une chaine de caractères grâce à une expression rationnelle appliquée sur la chaîne courante.
 
-<div>{{EmbedInteractiveExample("pages/js/string-search.html")}}</div>
+{{EmbedInteractiveExample("pages/js/string-search.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>str</var>.search(<var>regexp</var>)</pre>
+    str.search(regexp)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>regexp</code></dt>
- <dd>Un objet représentant une expression rationnelle. Si l'objet passé n'est pas un objet d'expression régulière, il est directement converti en une instance de {{jsxref("RegExp")}} en utilisant <code>new RegExp(obj)</code>.</dd>
-</dl>
+- `regexp`
+  - : Un objet représentant une expression rationnelle. Si l'objet passé n'est pas un objet d'expression régulière, il est directement converti en une instance de {{jsxref("RegExp")}} en utilisant `new RegExp(obj)`.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Si la recherche aboutit, <code>search()</code> renvoie un entier qui correspond à l'indice de la première correspondance trouvée dans la chaîne. Si rien n'est trouvé, la méthode renvoie <code>-1</code>.</p>
+Si la recherche aboutit, `search()` renvoie un entier qui correspond à l'indice de la première correspondance trouvée dans la chaîne. Si rien n'est trouvé, la méthode renvoie `-1`.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Si la recherche est positive, <code>search()</code> renvoie l'indice de la première correspondance pour l'expression rationnelle au sein de la chaine de caractères. Sinon, la méthode renvoie -1.</p>
+Si la recherche est positive, `search()` renvoie l'indice de la première correspondance pour l'expression rationnelle au sein de la chaine de caractères. Sinon, la méthode renvoie -1.
 
-<p>Si on souhaite savoir si un motif est trouvé dans une chaine de caractères, on utilisera cette méthode (semblable à la méthode {{jsxref("RegExp.prototype.test", "test()")}}) du prototype de <code>RegExp</code> ; pour plus d'informations (mais une éxecution plus lente), on utilisera {{jsxref("String.prototype.match", "match()")}} (semblable à la méthode {{jsxref("RegExp.prototype.exec", "exec()")}} pour les expressions rationnelles). La méthode <code>test</code> est semblable mais renvoie uniquement un booléen indiquant si une correspondance a été trouvée.</p>
+Si on souhaite savoir si un motif est trouvé dans une chaine de caractères, on utilisera cette méthode (semblable à la méthode {{jsxref("RegExp.prototype.test", "test()")}}) du prototype de `RegExp` ; pour plus d'informations (mais une éxecution plus lente), on utilisera {{jsxref("String.prototype.match", "match()")}} (semblable à la méthode {{jsxref("RegExp.prototype.exec", "exec()")}} pour les expressions rationnelles). La méthode `test` est semblable mais renvoie uniquement un booléen indiquant si une correspondance a été trouvée.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<p>Dans l'exemple suivant, on utilise une chaîne de caractères pour laquelle on applique deux expressions rationnelles (la première permet d'obtenir une correspondance et la seconde n'en trouve aucune).</p>
+Dans l'exemple suivant, on utilise une chaîne de caractères pour laquelle on applique deux expressions rationnelles (la première permet d'obtenir une correspondance et la seconde n'en trouve aucune).
 
-<pre class="brush: js">var maChaine = "CoucOu";
+```js
+var maChaine = "CoucOu";
 var regex1 = /[A-Z]/g;
 var regex2 = /[.]/g;
 
 console.log(maChaine.search(regex1)); // Renvoie 0, la position de la première majuscule
-console.log(maChaine.search(regex2)); // Renvoie -1 car il n'y a aucun point dans la chaîne</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('ES3')}}</td>
-   <td>{{Spec2('ES3')}}</td>
-   <td>Définition initiale. Implémentée avec JavaScript 1.2</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.5.4.12', 'String.prototype.search')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-string.prototype.search', 'String.prototype.search')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-string.prototype.search', 'String.prototype.search')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.String.search")}}</p>
-
-<h2 id="Notes_spécifiques_à_Gecko">Notes spécifiques à Gecko</h2>
-
-<ul>
- <li><code>flags</code> était un second argument non standard présent uniquement sur Gecko : <var>str</var>.search(<var>regexp, flags</var>)</li>
- <li>Avant {{Gecko("8.0")}}, <code>search()</code> n'était pas implémenté correctement ; quand il était appelé sans paramètre ou avec {{jsxref("undefined")}}, la recherche validait la chaine de caractères "undefined", au lieu de valider une chaine de caractères vide. Cela a été corrigé ; désormais, <code>"a".search()</code> et <code>"a".search(undefined)</code> renvoient bien 0.</li>
- <li>À partir de Gecko 39 {{geckoRelease(39)}}, les arguments non-standards (<code>flags</code>) pour les drapeaux sont dépréciés et déclenchent des avertissements dans la console ({{bug(1142351)}}). Cette propriété est spécifique à Gecko et sera retirée à l'avenir.</li>
- <li>À partir de Gecko 47 {{geckoRelease(47)}}, l'argument non-standard <code>flags</code> n'est plus supporté dans les versions hors <em>release</em> et sera bientôt retiré définitivement ({{bug(1245801)}}).</li>
- <li>À partir de Gecko 49 {{geckoRelease(49)}}, l'argument non-standard <code>flags</code> n'est plus pris en charge ({{bug(1108382)}}).</li>
-</ul>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("String.prototype.match()")}}</li>
- <li>{{jsxref("RegExp.prototype.exec()")}}</li>
-</ul>
+console.log(maChaine.search(regex2)); // Renvoie -1 car il n'y a aucun point dans la chaîne
+```
+
+## Spécifications
+
+| Spécification                                                                                                | État                         | Commentaires                                         |
+| ------------------------------------------------------------------------------------------------------------ | ---------------------------- | ---------------------------------------------------- |
+| {{SpecName('ES3')}}                                                                                     | {{Spec2('ES3')}}         | Définition initiale. Implémentée avec JavaScript 1.2 |
+| {{SpecName('ES5.1', '#sec-15.5.4.12', 'String.prototype.search')}}                     | {{Spec2('ES5.1')}}     |                                                      |
+| {{SpecName('ES6', '#sec-string.prototype.search', 'String.prototype.search')}}     | {{Spec2('ES6')}}         |                                                      |
+| {{SpecName('ESDraft', '#sec-string.prototype.search', 'String.prototype.search')}} | {{Spec2('ESDraft')}} |                                                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.String.search")}}
+
+## Notes spécifiques à Gecko
+
+- `flags` était un second argument non standard présent uniquement sur Gecko : _str_.search(_regexp, flags_)
+- Avant {{Gecko("8.0")}}, `search()` n'était pas implémenté correctement ; quand il était appelé sans paramètre ou avec {{jsxref("undefined")}}, la recherche validait la chaine de caractères "undefined", au lieu de valider une chaine de caractères vide. Cela a été corrigé ; désormais, `"a".search()` et `"a".search(undefined)` renvoient bien 0.
+- À partir de Gecko 39 {{geckoRelease(39)}}, les arguments non-standards (`flags`) pour les drapeaux sont dépréciés et déclenchent des avertissements dans la console ({{bug(1142351)}}). Cette propriété est spécifique à Gecko et sera retirée à l'avenir.
+- À partir de Gecko 47 {{geckoRelease(47)}}, l'argument non-standard `flags` n'est plus supporté dans les versions hors _release_ et sera bientôt retiré définitivement ({{bug(1245801)}}).
+- À partir de Gecko 49 {{geckoRelease(49)}}, l'argument non-standard `flags` n'est plus pris en charge ({{bug(1108382)}}).
+
+## Voir aussi
+
+- {{jsxref("String.prototype.match()")}}
+- {{jsxref("RegExp.prototype.exec()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/string/slice/index.md b/files/fr/web/javascript/reference/global_objects/string/slice/index.md
index a43faa2bd1..5360b4ab0e 100644
--- a/files/fr/web/javascript/reference/global_objects/string/slice/index.md
+++ b/files/fr/web/javascript/reference/global_objects/string/slice/index.md
@@ -10,117 +10,97 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/String/slice
 original_slug: Web/JavaScript/Reference/Objets_globaux/String/slice
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>slice()</strong></code> extrait une section d'une chaine de caractères et la retourne comme une nouvelle chaine de caractères. La chaîne de caractères courante n'est pas modifiée.</p>
+La méthode **`slice()`** extrait une section d'une chaine de caractères et la retourne comme une nouvelle chaine de caractères. La chaîne de caractères courante n'est pas modifiée.
 
-<div>{{EmbedInteractiveExample("pages/js/string-slice.html")}}</div>
+{{EmbedInteractiveExample("pages/js/string-slice.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><em>chn</em>.slice(<em>indiceDe<var>but</var></em>[, <em>indiceF</em><var><em>in</em></var>])</pre>
+    chn.slice(indiceDebut[, indiceFin])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>indiceDebut</code></dt>
- <dd>L'indice base 0 auquel commencer l'extraction. Si négatif, il est traité comme (<code>longueurSource + indiceDebut</code>) où <code>longueurSource</code> est la longueur de la chaine de caractères (par exemple, si <code>indiceDebut</code> est -3, il sera traité comme <code>longueurSource - 3</code>). Si <code>indiceDebut</code> est supérieur à la longueur de la chaîne, <code>slice()</code> renvoie une chaîne vide.</dd>
- <dt><code>indiceFin</code></dt>
- <dd>Paramètre optionnel. Un indice base 0 <em>avant</em> lequel terminer l'extraction. Le caractère à cet indice ne sera pas inclus. Si <code>indiceFin</code> est absent, <code>slice()</code> extraira jusqu'à la fin de la chaine de caractères. Si négatif, il sera traité comme (<code>longueurSource + indiceFin</code>) où <code>longueurSource</code> est la longueur de la chaine de caractères (par exemple s'il vaut <code>-3</code>, il sera traité comme <code>longueurSource - 3</code>)</dd>
-</dl>
+- `indiceDebut`
+  - : L'indice base 0 auquel commencer l'extraction. Si négatif, il est traité comme (`longueurSource + indiceDebut`) où `longueurSource` est la longueur de la chaine de caractères (par exemple, si `indiceDebut` est -3, il sera traité comme `longueurSource - 3`). Si `indiceDebut` est supérieur à la longueur de la chaîne, `slice()` renvoie une chaîne vide.
+- `indiceFin`
+  - : Paramètre optionnel. Un indice base 0 _avant_ lequel terminer l'extraction. Le caractère à cet indice ne sera pas inclus. Si `indiceFin` est absent, `slice()` extraira jusqu'à la fin de la chaine de caractères. Si négatif, il sera traité comme (`longueurSource + indiceFin`) où `longueurSource` est la longueur de la chaine de caractères (par exemple s'il vaut `-3`, il sera traité comme `longueurSource - 3`)
 
-<h3 id="Valeur_retournée">Valeur retournée</h3>
+### Valeur retournée
 
-<p>Une nouvelle chaîne de caractères contenant la section extraite de la chaîne.</p>
+Une nouvelle chaîne de caractères contenant la section extraite de la chaîne.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p><code>slice()</code> extrait le texte d'une chaine de caractères et retourne une nouvelle chaîne de caractères. Les changements au texte dans une chaine de caractères n'affectent pas l'autre chaîne.</p>
+`slice()` extrait le texte d'une chaine de caractères et retourne une nouvelle chaîne de caractères. Les changements au texte dans une chaine de caractères n'affectent pas l'autre chaîne.
 
-<p><code>slice()</code> extrait jusqu'à <code>indiceFin</code>, mais sans l'inclure. Par exemple, <code>chn.slice(1, 4)</code> extrait du second caractère jusqu'au quatrième caractère (caractères d'indices 1, 2 et 3).</p>
+`slice()` extrait jusqu'à `indiceFin`, mais sans l'inclure. Par exemple, `chn.slice(1, 4)` extrait du second caractère jusqu'au quatrième caractère (caractères d'indices 1, 2 et 3).
 
-<p>Par exemple, <code>chn.slice(2, -1)</code> extrait du troisième caractère jusqu'à l'avant-dernier caractère de la chaine de caractères.</p>
+Par exemple, `chn.slice(2, -1)` extrait du troisième caractère jusqu'à l'avant-dernier caractère de la chaine de caractères.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utilisation_de_slice()_pour_créer_une_nouvelle_chaîne_de_caractères">Utilisation de <code>slice()</code> pour créer une nouvelle chaîne de caractères</h3>
+### Utilisation de `slice()` pour créer une nouvelle chaîne de caractères
 
-<p>L'exemple suivant utilise <code>slice()</code> pour créer une nouvelle chaîne de caractères.</p>
+L'exemple suivant utilise `slice()` pour créer une nouvelle chaîne de caractères.
 
-<pre class="brush: js">var chn1 = 'Le matin est sur nous.', // la longueur de chn1 est de 22
-<code>    </code>chn<code>2 = </code>chn<code>1.slice(1, 8),
-    </code>chn<code>3 = </code>chn<code>1.slice(3, -2),
-    </code>chn<code>4 = </code>chn<code>1.slice(13),
-    </code>chn<code>5 = </code>chn<code>1.slice(30);
-console.log(</code>chn<code>2); // SORTIE : </code>e matin<code>
-console.log(</code>chn<code>3); // SORTIE : m</code>atin est sur nou<code>
-console.log(</code>chn<code>4); // SORTIE : </code>sur nous.<code>
-console.log(</code>chn<code>5); // SORTIE : ""</code></pre>
+```js
+var chn1 = 'Le matin est sur nous.', // la longueur de chn1 est de 22
+    chn2 = chn1.slice(1, 8),
+    chn3 = chn1.slice(3, -2),
+    chn4 = chn1.slice(13),
+    chn5 = chn1.slice(30);
+console.log(chn2); // SORTIE : e matin
+console.log(chn3); // SORTIE : matin est sur nou
+console.log(chn4); // SORTIE : sur nous.
+console.log(chn5); // SORTIE : ""
+```
 
-<h3 id="Utilisation_de_slice()_avec_des_indices_négatifs">Utilisation de <code>slice()</code> avec des indices négatifs</h3>
+### Utilisation de `slice()` avec des indices négatifs
 
-<p>L'exemple suivant utilise <code>slice()</code> avec des indices négatifs.</p>
+L'exemple suivant utilise `slice()` avec des indices négatifs.
 
-<pre class="brush:js">var chn = 'Le matin est sur nous.';
+```js
+var chn = 'Le matin est sur nous.';
 chn.slice(-3);     // retourne "us."
 chn.slice(-3, -1); // retourne "us"
 chn.slice(0, -1);  // retourne "Le matin est sur nous"
-</pre>
-
-<p>Dans l'exemple qui suit, on commence à chercher l'indice de début à partir de la fin de la chaîne avec l'argument <code>-11</code> et on utilise un indice de fin positif avec <code>16</code> :</p>
-
-<pre class="brush: js">console.log(chn.slice(-11, 16)); // "st sur"</pre>
-
-<p>On utilise ensuite un indice de début positif (la recherche est effectuée depuis le début de la chaîne) et un indice de fin négatif pour parvenir au même résultat :</p>
-
-<pre class="brush: js">console.log(chn.slice(10, -5)); // "st sur"</pre>
-
-<p>Enfin, on utilise deux indices négatifs : la position de début et la position de fin sont recherchées à parti de la fin de la chaîne :</p>
-
-<pre class="brush: js">console.log(chn.slice(-11, -5)); // "st sur"</pre>
-
-<h2 id="Spécifications">Spécifications</h2>
-
-<table class="standard-table">
- <thead>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">Statut</th>
-   <th scope="col">Commentaire</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td>{{SpecName('ES3')}}</td>
-   <td>{{Spec2('ES3')}}</td>
-   <td>Définition initiale. Implémentée dans JavaScript 1.2.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.5.4.13', 'String.prototype.slice')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-string.prototype.slice', 'String.prototype.slice')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-string.prototype.slice', 'String.prototype.slice')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.String.slice")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("String.prototype.substr()")}} {{deprecated_inline}}</li>
- <li>{{jsxref("String.prototype.substring()")}}</li>
- <li>{{jsxref("Array.prototype.slice()")}}</li>
-</ul>
+```
+
+Dans l'exemple qui suit, on commence à chercher l'indice de début à partir de la fin de la chaîne avec l'argument `-11` et on utilise un indice de fin positif avec `16` :
+
+```js
+console.log(chn.slice(-11, 16)); // "st sur"
+```
+
+On utilise ensuite un indice de début positif (la recherche est effectuée depuis le début de la chaîne) et un indice de fin négatif pour parvenir au même résultat :
+
+```js
+console.log(chn.slice(10, -5)); // "st sur"
+```
+
+Enfin, on utilise deux indices négatifs : la position de début et la position de fin sont recherchées à parti de la fin de la chaîne :
+
+```js
+console.log(chn.slice(-11, -5)); // "st sur"
+```
+
+## Spécifications
+
+| Spécification                                                                                                | Statut                       | Commentaire                                           |
+| ------------------------------------------------------------------------------------------------------------ | ---------------------------- | ----------------------------------------------------- |
+| {{SpecName('ES3')}}                                                                                     | {{Spec2('ES3')}}         | Définition initiale. Implémentée dans JavaScript 1.2. |
+| {{SpecName('ES5.1', '#sec-15.5.4.13', 'String.prototype.slice')}}                     | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-string.prototype.slice', 'String.prototype.slice')}}         | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-string.prototype.slice', 'String.prototype.slice')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.String.slice")}}
+
+## Voir aussi
+
+- {{jsxref("String.prototype.substr()")}} {{deprecated_inline}}
+- {{jsxref("String.prototype.substring()")}}
+- {{jsxref("Array.prototype.slice()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/string/small/index.md b/files/fr/web/javascript/reference/global_objects/string/small/index.md
index 5fba5a585f..f3f5b9941d 100644
--- a/files/fr/web/javascript/reference/global_objects/string/small/index.md
+++ b/files/fr/web/javascript/reference/global_objects/string/small/index.md
@@ -12,68 +12,55 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/String/small
 original_slug: Web/JavaScript/Reference/Objets_globaux/String/small
 ---
-<div>{{JSRef}}{{deprecated_header}}</div>
+{{JSRef}}{{deprecated_header}}
 
-<p>La méthode <code><strong>small()</strong></code> permet de créer un élément HTML {{HTMLElement("small")}}, ce qui permet d'afficher la chaîne de caractères dans une fonte de petite taille.</p>
+La méthode **`small()`** permet de créer un élément HTML {{HTMLElement("small")}}, ce qui permet d'afficher la chaîne de caractères dans une fonte de petite taille.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>str</var>.small()</pre>
+    str.small()
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une chaîne de caractères représentant un élément HTML {{HTMLElement("small")}}.</p>
+Une chaîne de caractères représentant un élément HTML {{HTMLElement("small")}}.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La méthode <code>small()</code> encadre la chaîne courante dans une balise <code>&lt;small&gt;</code> :<br>
- <code>"&lt;small&gt;str&lt;/small&gt;</code>"</p>
+La méthode `small()` encadre la chaîne courante dans une balise `<small>` :
+`"<small>str</small>`"
 
-<h2 id="Exemple">Exemple</h2>
+## Exemple
 
-<h3 id="Utiliser_la_méthode_small()">Utiliser la méthode <code>small()</code></h3>
+### Utiliser la méthode `small()`
 
-<p>L'exemple suivant illustre les différentes méthodes de <code>String</code> permettant de changer la taille d'une chaîne de caractères :</p>
+L'exemple suivant illustre les différentes méthodes de `String` permettant de changer la taille d'une chaîne de caractères :
 
-<pre class="brush:js">var worldString = "Coucou monde";
+```js
+var worldString = "Coucou monde";
 
-console.log(worldString.small());     // &lt;small&gt;Coucou monde&lt;/small&gt;
-console.log(worldString.big());       // &lt;big&gt;Coucou monde&lt;/big&gt;
-console.log(worldString.fontsize(7)); // &lt;font size="7"&gt;Coucou monde&lt;/fontsize&gt;</pre>
+console.log(worldString.small());     // <small>Coucou monde</small>
+console.log(worldString.big());       // <big>Coucou monde</big>
+console.log(worldString.fontsize(7)); // <font size="7">Coucou monde</fontsize>
+```
 
-<p>L'objet {{domxref("HTMLElement.style", "element.style")}} permet d'utiliser l'attribut <code>style</code> de l'élément et de le manipuler de façon générique. Par exemple :</p>
+L'objet {{domxref("HTMLElement.style", "element.style")}} permet d'utiliser l'attribut `style` de l'élément et de le manipuler de façon générique. Par exemple :
 
-<pre class="brush: js">document.getElementById('IDélément').style.fontSize = '0.7em'</pre>
+```js
+document.getElementById('IDélément').style.fontSize = '0.7em'
+```
 
-<h2 id="Spécifications">Spécifications</h2>
+## Spécifications
 
-<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('ES6', '#sec-string.prototype.small', 'String.prototype.small')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Définition initiale. Implémentée dans JavaScript 1.0. Définie dans l'annexe B (normative) pour les fonctionnalités ECMAScript additionnelles pour les navigateurs web.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-string.prototype.small', 'String.prototype.small')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td>Définie dans l'annexe B (normative) pour les fonctionnalités ECMAScript additionnelles pour les navigateurs web.</td>
-  </tr>
- </tbody>
-</table>
+| Spécification                                                                                                | État                         | Commentaires                                                                                                                                                           |
+| ------------------------------------------------------------------------------------------------------------ | ---------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| {{SpecName('ES6', '#sec-string.prototype.small', 'String.prototype.small')}}         | {{Spec2('ES6')}}         | Définition initiale. Implémentée dans JavaScript 1.0. Définie dans l'annexe B (normative) pour les fonctionnalités ECMAScript additionnelles pour les navigateurs web. |
+| {{SpecName('ESDraft', '#sec-string.prototype.small', 'String.prototype.small')}} | {{Spec2('ESDraft')}} | Définie dans l'annexe B (normative) pour les fonctionnalités ECMAScript additionnelles pour les navigateurs web.                                                       |
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.String.small")}}</p>
+{{Compat("javascript.builtins.String.small")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("String.prototype.fontsize()")}}</li>
- <li>{{jsxref("String.prototype.big()")}}</li>
-</ul>
+- {{jsxref("String.prototype.fontsize()")}}
+- {{jsxref("String.prototype.big()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/string/split/index.md b/files/fr/web/javascript/reference/global_objects/string/split/index.md
index 208f978a7d..c076dff412 100644
--- a/files/fr/web/javascript/reference/global_objects/string/split/index.md
+++ b/files/fr/web/javascript/reference/global_objects/string/split/index.md
@@ -11,74 +11,68 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/String/split
 original_slug: Web/JavaScript/Reference/Objets_globaux/String/split
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>split()</code></strong> divise une <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String">chaîne de caractères</a> en une liste ordonnée de sous-chaînes, place ces sous-chaînes dans un tableau et retourne le tableau. La division est effectuée en recherchant un motif ; où le motif est fourni comme premier paramètre dans l'appel de la méthode.</p>
+La méthode **`split()`** divise une [chaîne de caractères](/fr/docs/Web/JavaScript/Reference/Global_Objects/String) en une liste ordonnée de sous-chaînes, place ces sous-chaînes dans un tableau et retourne le tableau. La division est effectuée en recherchant un motif ; où le motif est fourni comme premier paramètre dans l'appel de la méthode.
 
-<div>{{EmbedInteractiveExample("pages/js/string-split.html", "taller")}}</div>
+{{EmbedInteractiveExample("pages/js/string-split.html", "taller")}}
 
-<h2 id="syntax">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>str</var>.split([<var>separator</var>[, limit]])</pre>
+    str.split([separator[, limit]])
 
-<h3 id="parameters">Paramètres</h3>
+### Paramètres
 
-<dl>
-  <dt><code>separator</code> Facultatif</dt>
-  <dd>
-    <p>Le motif décrivant où chaque séparation doit se produire. Le <code>separator</code> peut être une simple chaîne de caractères ou peut être une <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/RegExp">expression régulière</a>.</p>
+- `separator` Facultatif
 
-    <ul>
-      <li>Le cas le plus simple est celui où <code>separator</code> n'est qu'un seul caractère ; il est utilisé pour diviser une chaîne délimitée. Par exemple, une chaîne contenant des valeurs séparées par des tabulations (TSV) pourrait être analysée en passant un caractère de tabulation comme séparateur, comme ceci : <code>myString.split("\t")</code>.</li>
-      <li>Si <code>separator</code> contient plusieurs caractères, cette séquence de caractères entière doit être trouvée afin de diviser la chaîne.</li>
-      <li>Si <code>separator</code> est omis ou n'apparaît pas dans la chaîne <code>str</code>, le tableau retourné contient un élément constitué de la chaîne entière.</li>
-      <li>Si <code>separator</code> apparaît au début (ou à la fin) de la chaîne, il a quand même l'effet de division. Le résultat est une chaîne vide (c'est-à-dire de longueur nulle), qui apparaît à la première (ou dernière) position du tableau retourné.</li>
-      <li>Si <code>separator</code> est une chaîne vide (<code>""</code>), la chaîne <code>str</code> est convertie en un tableau de chacun de ses "caractères" UTF-16.</li>
-    </ul>
+  - : Le motif décrivant où chaque séparation doit se produire. Le `separator` peut être une simple chaîne de caractères ou peut être une [expression régulière](/fr/docs/Web/JavaScript/Reference/Global_Objects/RegExp).
 
-    <div class="warning">
-      <p><strong>Attention :</strong> Lorsque une chaîne vide (<code>""</code>) est utilisée comme séparateur, la chaîne n'est <strong>pas</strong> divisée par des <em>caractères perçus par l'utilisateur</em> (<a href="https://unicode.org/reports/tr29/#Grapheme_Cluster_Boundaries">grappes de graphèmes</a>) ou des caractères unicodes (codepoints), mais par des unités de code UTF-16. Cela détruit les <a href="http://unicode.org/faq/utf_bom.html#utf16-2">paires de substituts</a>. Voir <a href="https://stackoverflow.com/a/34717402">« Comment obtenir une chaîne de caractères vers un tableau de caractères en JavaScript ? » sur StackOverflow</a>.</p>
-    </div>
-  </dd>
-  <dt><code>limit</code> Facultatif</dt>
-  <dd>
-    <p>Un nombre entier non négatif spécifiant une limite sur le nombre de sous-chaînes à inclure dans le tableau. S'il est fourni, il divise la chaîne de caractères à chaque occurrence du <code>separator</code> spécifié, mais s'arrête lorsque la <code>limit</code> (limite) d'entrées a été atteinte dans le tableau. Tout texte restant n'est pas du tout inclus dans le tableau.</p>
+    - Le cas le plus simple est celui où `separator` n'est qu'un seul caractère ; il est utilisé pour diviser une chaîne délimitée. Par exemple, une chaîne contenant des valeurs séparées par des tabulations (TSV) pourrait être analysée en passant un caractère de tabulation comme séparateur, comme ceci : `myString.split("\t")`.
+    - Si `separator` contient plusieurs caractères, cette séquence de caractères entière doit être trouvée afin de diviser la chaîne.
+    - Si `separator` est omis ou n'apparaît pas dans la chaîne `str`, le tableau retourné contient un élément constitué de la chaîne entière.
+    - Si `separator` apparaît au début (ou à la fin) de la chaîne, il a quand même l'effet de division. Le résultat est une chaîne vide (c'est-à-dire de longueur nulle), qui apparaît à la première (ou dernière) position du tableau retourné.
+    - Si `separator` est une chaîne vide (`""`), la chaîne `str` est convertie en un tableau de chacun de ses "caractères" UTF-16.
 
-    <ul>
-      <li>Le tableau peut contenir moins d'entrées que la <code>limit</code> (limite), si la fin de la chaîne de caractères est atteinte avant que la limite ne soit atteinte.</li>
-      <li>Si <code>limit</code> est paramétré sur <code>0</code>, un tableau vide <code>[]</code> est retourné.</li>
-    </ul>
-  </dd>
-</dl>
+    > **Attention :** Lorsque une chaîne vide (`""`) est utilisée comme séparateur, la chaîne n'est **pas** divisée par des _caractères perçus par l'utilisateur_ ([grappes de graphèmes](https://unicode.org/reports/tr29/#Grapheme_Cluster_Boundaries)) ou des caractères unicodes (codepoints), mais par des unités de code UTF-16. Cela détruit les [paires de substituts](http://unicode.org/faq/utf_bom.html#utf16-2). Voir [« Comment obtenir une chaîne de caractères vers un tableau de caractères en JavaScript ? » sur StackOverflow](https://stackoverflow.com/a/34717402).
 
-<h3 id="return_value">Valeur de retour</h3>
+- `limit` Facultatif
 
-<p>Un tableau (<a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Array"><code>Array</code></a>) qui contient les fragments de la chaîne de caractères, découpée en fonction du séparateur indiqué.</p>
+  - : Un nombre entier non négatif spécifiant une limite sur le nombre de sous-chaînes à inclure dans le tableau. S'il est fourni, il divise la chaîne de caractères à chaque occurrence du `separator` spécifié, mais s'arrête lorsque la `limit` (limite) d'entrées a été atteinte dans le tableau. Tout texte restant n'est pas du tout inclus dans le tableau.
 
-<h2 id="description">Description</h2>
+    - Le tableau peut contenir moins d'entrées que la `limit` (limite), si la fin de la chaîne de caractères est atteinte avant que la limite ne soit atteinte.
+    - Si `limit` est paramétré sur `0`, un tableau vide `[]` est retourné.
 
-<p>Lorsqu'il est trouvé, <code>separator</code> est supprimé de la chaîne de caractère, et les sous-chaînes sont retournées dans un tableau.</p>
+### Valeur de retour
 
-<p>Si <code>separator</code> est une expression régulière avec des parenthèses de capture, alors chaque fois que <code>separator</code> correspond, les résultats (y compris tout résultat <code>undefined</code>) des parenthèses de capture sont joints au tableau de sortie.</p>
+Un tableau ([`Array`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Array)) qui contient les fragments de la chaîne de caractères, découpée en fonction du séparateur indiqué.
 
-<p>Si le séparateur est un tableau, alors ce tableau est converti en une chaîne de caractères et est utilisé comme séparateur.</p>
+## Description
 
-<h2 id="examples">Exemples</h2>
+Lorsqu'il est trouvé, `separator` est supprimé de la chaîne de caractère, et les sous-chaînes sont retournées dans un tableau.
 
-<h3 id="using_split">Utiliser <code>split()</code></h3>
+Si `separator` est une expression régulière avec des parenthèses de capture, alors chaque fois que `separator` correspond, les résultats (y compris tout résultat `undefined`) des parenthèses de capture sont joints au tableau de sortie.
 
-<p>Lorsque la chaîne de caractères est vide, <code>split()</code> retourne un tableau contenant une chaîne de caractères vide, plutôt qu'un tableau vide. Si la chaîne et le séparateur sont tous deux des chaînes vides, un tableau vide est retourné.</p>
+Si le séparateur est un tableau, alors ce tableau est converti en une chaîne de caractères et est utilisé comme séparateur.
 
-<pre class="brush: js">const myString = ''
+## Exemples
+
+### Utiliser `split()`
+
+Lorsque la chaîne de caractères est vide, `split()` retourne un tableau contenant une chaîne de caractères vide, plutôt qu'un tableau vide. Si la chaîne et le séparateur sont tous deux des chaînes vides, un tableau vide est retourné.
+
+```js
+const myString = ''
 const splits = myString.split()
 
 console.log(splits)
 
-// ↪ [""]</pre>
+// ↪ [""]
+```
 
-<p>L'exemple suivant définit une fonction qui divise une chaîne en un tableau de chaînes selon un délimiteur spécifié. Après la coupe de la chaîne, la fonction affiche des messages indiquant la chaîne initiale (avant la coupe), le délimiteur utilisé, le nombre d'éléments dans le tableau, et les éléments du tableau retourné.</p>
+L'exemple suivant définit une fonction qui divise une chaîne en un tableau de chaînes selon un délimiteur spécifié. Après la coupe de la chaîne, la fonction affiche des messages indiquant la chaîne initiale (avant la coupe), le délimiteur utilisé, le nombre d'éléments dans le tableau, et les éléments du tableau retourné.
 
-<pre class="brush: js">function splitString(stringToSplit, separator) {
+```js
+function splitString(stringToSplit, separator) {
   var arrayOfStrings = stringToSplit.split(separator);
 
   console.log(`La chaine d'origine est : ${stringToSplit}`);
@@ -95,11 +89,12 @@ var virgule = ",";
 splitString(tempestString, espace);
 splitString(tempestString);
 splitString(monthString, virgule);
-</pre>
+```
 
-<p>Cet exemple produira la sortie suivante :</p>
+Cet exemple produira la sortie suivante :
 
-<pre class="brush: js">La chaine d'origine est : "Oh brave new world that has such people in it."
+```js
+La chaine d'origine est : "Oh brave new world that has such people in it."
 Le délimiteur est : " "
 Le tableau comporte 10 elements : Oh / brave / new / world / that / has / such / people / in / it. /
 
@@ -110,103 +105,102 @@ Le tableau comporte 1 elements : Oh brave new world that has such people in it.
 La chaine d'origine est : "Jan,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec"
 Le délimiteur est : ","
 Le tableau comporte 12 elements : Jan / Feb / Mar / Apr / May / Jun / Jul / Aug / Sep / Oct / Nov / Dec /
-</pre>
+```
 
-<h3 id="removing_spaces_from_a_string">Supprimer les espaces d'une chaîne</h3>
+### Supprimer les espaces d'une chaîne
 
-<p>Dans l'exemple suivant, <code>split</code> recherche zéro ou plusieurs espaces suivis d'un point-virgule, lui-même suivi par zéro ou plus espaces. Lorsque ce « motif » est trouvé, cela supprime celui-ci de la chaîne. <code>nameList</code> est le tableau retourné du résultat de <code>split</code>.</p>
+Dans l'exemple suivant, `split` recherche zéro ou plusieurs espaces suivis d'un point-virgule, lui-même suivi par zéro ou plus espaces. Lorsque ce « motif » est trouvé, cela supprime celui-ci de la chaîne. `nameList` est le tableau retourné du résultat de `split`.
 
-<pre class="brush: js">var names = "Harry Trump ;Fred Barney; Helen Rigby ; Bill Abel ;Chris Hand ";
+```js
+var names = "Harry Trump ;Fred Barney; Helen Rigby ; Bill Abel ;Chris Hand ";
 
 console.log(names);
 
 var re = /\s*(;|$)\s*/;
 var nameList = names.split(re);
 
-console.log(nameList);</pre>
+console.log(nameList);
+```
 
-<p>Ceci affichera deux lignes dans la console ; la première ligne correspondant à la chaîne d'origine, et la seconde au tableau de résultats.</p>
+Ceci affichera deux lignes dans la console ; la première ligne correspondant à la chaîne d'origine, et la seconde au tableau de résultats.
 
-<pre class="brush: js">Harry Trump ;Fred Barney; Helen Rigby ; Bill Abel ;Chris Hand
-["Harry Trump","Fred Barney","Helen Rigby","Bill Abel","Chris Hand"]</pre>
+```js
+Harry Trump ;Fred Barney; Helen Rigby ; Bill Abel ;Chris Hand
+["Harry Trump","Fred Barney","Helen Rigby","Bill Abel","Chris Hand"]
+```
 
-<h3 id="returning_a_limited_number_of_splits">Retourner un nombre limité de sous-chaînes</h3>
+### Retourner un nombre limité de sous-chaînes
 
-<p>Dans l'exemple suivant, <code>split()</code> recherche des espaces dans une chaîne et retourne les 3 premières sous-chaînes qui correspondent.</p>
+Dans l'exemple suivant, `split()` recherche des espaces dans une chaîne et retourne les 3 premières sous-chaînes qui correspondent.
 
-<pre class="brush: js">var myString = "Hello World. How are you doing?";
+```js
+var myString = "Hello World. How are you doing?";
 var splits = myString.split(" ", 3);
 
-console.log(splits);</pre>
+console.log(splits);
+```
 
-<p>Ce script affichera :</p>
+Ce script affichera :
 
-<pre class="brush: js">["Hello", "World.", "How"]</pre>
+```js
+["Hello", "World.", "How"]
+```
 
-<h3 id="splitting_with_a_regexp_to_include_parts_of_the_separator_in_the_result">Découper une expression rationnelle - Parenthèses capturantes</h3>
+### Découper une expression rationnelle - Parenthèses capturantes
 
-<p>Si le paramètre <code>séparateur</code> est une expression rationnelle qui contient des parenthèses de capture, les résultats seront retournés dans le tableau.</p>
+Si le paramètre `séparateur` est une expression rationnelle qui contient des parenthèses de capture, les résultats seront retournés dans le tableau.
 
-<pre class="brush: js">var myString = "Hello 1 word. Sentence number 2.";
+```js
+var myString = "Hello 1 word. Sentence number 2.";
 var splits = myString.split(/(\d)/);
 
-console.log(splits);</pre>
-
-<p>Ce script affichera :</p>
-
-<pre class="brush: js">[ "Hello ", "1", " word. Sentence number ", "2", "." ]</pre>
-
-<div class="note">
-  <p><strong>Note :</strong> <code>\d</code> correspond à la <a href="/fr/docs/Web/JavaScript/Guide/Regular_Expressions/Character_Classes">classe de caractères</a> pour les chiffres compris entre 0 et 9.</p>
-</div>
-
-<h3 id="reversing_a_string_using_split">Inverser une chaîne en utilisant <code>split()</code></h3>
-
-<div class="warning">
-  <p><strong>Attention :</strong> Ce n'est pas une façon robuste d'inverser une chaîne :</p>
+console.log(splits);
+```
 
-  <pre class="brush: js example-bad">const str = 'asdfghjkl'
-const strReverse = str.split('').reverse().join('')
-// 'lkjhgfdsa'
+Ce script affichera :
 
-// split() retourne un tableau sur lequel reverse() et join() peuvent être appliqués.</pre>
+```js
+[ "Hello ", "1", " word. Sentence number ", "2", "." ]
+```
 
-  <p>Cela ne fonctionne pas si la chaîne de caractères contient des groupes de graphèmes, même en utilisant une division sensible aux unicodes. (Utilisez, par exemple, <a href="https://github.com/mathiasbynens/esrever">esrever</a> à la place).</p>
+> **Note :** `\d` correspond à la [classe de caractères](/fr/docs/Web/JavaScript/Guide/Regular_Expressions/Character_Classes) pour les chiffres compris entre 0 et 9.
 
-  <pre class="brush: js example-bad">const str = 'résumé'
-const strReverse = str.split(/(?:)/u).reverse().join('')
-// =&gt; "́emuśer"
-</pre>
+### Inverser une chaîne en utilisant `split()`
 
-  <p><strong>Bonus :</strong> utiliser l'opérateur <a href="/fr/docs/Web/JavaScript/Reference/Operators"><code>===</code></a> pour tester si la chaîne d'origine est un palindrome.</p>
-</div>
+> **Attention :** Ce n'est pas une façon robuste d'inverser une chaîne :
+>
+> ```js example-bad
+> const str = 'asdfghjkl'
+> const strReverse = str.split('').reverse().join('')
+> // 'lkjhgfdsa'
+>
+> // split() retourne un tableau sur lequel reverse() et join() peuvent être appliqués.
+> ```
+>
+> Cela ne fonctionne pas si la chaîne de caractères contient des groupes de graphèmes, même en utilisant une division sensible aux unicodes. (Utilisez, par exemple, [esrever](https://github.com/mathiasbynens/esrever) à la place).
+>
+> ```js example-bad
+> const str = 'résumé'
+> const strReverse = str.split(/(?:)/u).reverse().join('')
+> // => "́emuśer"
+> ```
+>
+> **Bonus :** utiliser l'opérateur [`===`](/fr/docs/Web/JavaScript/Reference/Operators) pour tester si la chaîne d'origine est un palindrome.
 
-<h2 id="specifications">Spécifications</h2>
+## Spécifications
 
-<table class="standard-table">
-  <thead>
-    <tr>
-      <th scope="col">Spécification</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td>{{SpecName('ESDraft', '#sec-string.prototype.split', 'String.prototype.split')}}
-      </td>
-    </tr>
-  </tbody>
-</table>
+| Spécification                                                                                                |
+| ------------------------------------------------------------------------------------------------------------ |
+| {{SpecName('ESDraft', '#sec-string.prototype.split', 'String.prototype.split')}} |
 
-<h2 id="browser_compatibility">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.String.split")}}</p>
+{{Compat("javascript.builtins.String.split")}}
 
-<h2 id="see_also">Voir aussi</h2>
+## Voir aussi
 
-<ul>
-  <li><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String/charAt"><code>String.prototype.charAt()</code></a></li>
-  <li><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String/indexOf"><code>String.prototype.indexOf()</code></a></li>
-  <li><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String/lastIndexOf"><code>String.prototype.lastIndexOf()</code></a></li>
-  <li><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Array/join"><code>Array.prototype.join()</code></a></li>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Regular_Expressions">Expressions régulières</a></li>
-</ul>
+- [`String.prototype.charAt()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String/charAt)
+- [`String.prototype.indexOf()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String/indexOf)
+- [`String.prototype.lastIndexOf()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String/lastIndexOf)
+- [`Array.prototype.join()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Array/join)
+- [Expressions régulières](/fr/docs/Web/JavaScript/Guide/Regular_Expressions)
diff --git a/files/fr/web/javascript/reference/global_objects/string/startswith/index.md b/files/fr/web/javascript/reference/global_objects/string/startswith/index.md
index 6216df303c..7c6803b778 100644
--- a/files/fr/web/javascript/reference/global_objects/string/startswith/index.md
+++ b/files/fr/web/javascript/reference/global_objects/string/startswith/index.md
@@ -12,73 +12,56 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/String/startsWith
 original_slug: Web/JavaScript/Reference/Objets_globaux/String/startsWith
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>startsWith()</strong></code> renvoie un booléen indiquant si la chaine de caractères commence par la deuxième chaine de caractères fournie en argument.</p>
+La méthode **`startsWith()`** renvoie un booléen indiquant si la chaine de caractères commence par la deuxième chaine de caractères fournie en argument.
 
-<div>{{EmbedInteractiveExample("pages/js/string-startswith.html")}}</div>
+{{EmbedInteractiveExample("pages/js/string-startswith.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>str</var>.startsWith(<var>chaîneRecherchée</var> [, <var>position</var>]);</pre>
+    str.startsWith(chaîneRecherchée [, position]);
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>chaîneRecherchée</code></dt>
- <dd>Les caractères à rechercher au début de la chaine de caractères.</dd>
- <dt><code>position</code> {{optional_inline}}</dt>
- <dd>La position à laquelle commencer la recherche de <code><var>chaîneRecherchée</var></code> ; par défaut 0.</dd>
-</dl>
+- `chaîneRecherchée`
+  - : Les caractères à rechercher au début de la chaine de caractères.
+- `position` {{optional_inline}}
+  - : La position à laquelle commencer la recherche de `chaîneRecherchée` ; par défaut 0.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p><code>true</code> si la chaîne de caractères commence avec la sous-chaîne en argument, <code>false</code> sinon</p>
+`true` si la chaîne de caractères commence avec la sous-chaîne en argument, `false` sinon
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Cette méthode permet de savoir si une chaine de caractères commence avec une autre chaine de caractères (comme pour les autres méthodes fonctionnant avec les chaînes de caractères, cette méthode est sensible à la casse).</p>
+Cette méthode permet de savoir si une chaine de caractères commence avec une autre chaine de caractères (comme pour les autres méthodes fonctionnant avec les chaînes de caractères, cette méthode est sensible à la casse).
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<pre class="brush:js;">var str = "Être, ou ne pas être : telle est la question.";
+```js
+var str = "Être, ou ne pas être : telle est la question.";
 
 console.log(str.startsWith("Être"));         // true
 console.log(str.startsWith("pas être"));     // false
-console.log(str.startsWith("pas être", 12)); // true</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-string.prototype.startswith', 'String.prototype.startsWith')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-string.prototype.startswith', 'String.prototype.startsWith')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.String.startsWith")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("String.prototype.endsWith()")}}</li>
- <li>{{jsxref("String.prototype.includes()")}}</li>
- <li>{{jsxref("String.prototype.indexOf()")}}</li>
- <li>{{jsxref("String.prototype.lastIndexOf()")}}</li>
- <li><a href="https://github.com/mathiasbynens/String.prototype.startsWith">Prothèse (<em>polyfill</em>) de Mathias Bynens</a></li>
-</ul>
+console.log(str.startsWith("pas être", 12)); // true
+```
+
+## Spécifications
+
+| Spécification                                                                                                            | État                         | Commentaires         |
+| ------------------------------------------------------------------------------------------------------------------------ | ---------------------------- | -------------------- |
+| {{SpecName('ES2015', '#sec-string.prototype.startswith', 'String.prototype.startsWith')}} | {{Spec2('ES2015')}}     | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-string.prototype.startswith', 'String.prototype.startsWith')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.String.startsWith")}}
+
+## Voir aussi
+
+- {{jsxref("String.prototype.endsWith()")}}
+- {{jsxref("String.prototype.includes()")}}
+- {{jsxref("String.prototype.indexOf()")}}
+- {{jsxref("String.prototype.lastIndexOf()")}}
+- [Prothèse (_polyfill_) de Mathias Bynens](https://github.com/mathiasbynens/String.prototype.startsWith)
diff --git a/files/fr/web/javascript/reference/global_objects/string/strike/index.md b/files/fr/web/javascript/reference/global_objects/string/strike/index.md
index 9dc8d4aa4a..22a9cb1804 100644
--- a/files/fr/web/javascript/reference/global_objects/string/strike/index.md
+++ b/files/fr/web/javascript/reference/global_objects/string/strike/index.md
@@ -12,71 +12,58 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/String/strike
 original_slug: Web/JavaScript/Reference/Objets_globaux/String/strike
 ---
-<div>{{JSRef}}{{deprecated_header}}</div>
+{{JSRef}}{{deprecated_header}}
 
-<p>La méthode <code><strong>strike()</strong></code> permet de créer un élément HTML {{HTMLElement("strike")}} qui permet d'afficher la chaîne comme un texte barré.</p>
+La méthode **`strike()`** permet de créer un élément HTML {{HTMLElement("strike")}} qui permet d'afficher la chaîne comme un texte barré.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>str</var>.strike()</pre>
+    str.strike()
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une chaîne de caractères représentant un élément HTML {{HTMLElement("strike")}}.</p>
+Une chaîne de caractères représentant un élément HTML {{HTMLElement("strike")}}.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Cette méthode encadre la chaîne de caractères dans une balise <code>&lt;strike&gt;</code> :<br>
- <code>"&lt;strike&gt;str&lt;/strike&gt;</code>"</p>
+Cette méthode encadre la chaîne de caractères dans une balise `<strike>` :
+`"<strike>str</strike>`"
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<p>Les méthodes suivantes peuvent être utilisées pour modifier le formatage d'une chaîne de caractères :</p>
+Les méthodes suivantes peuvent être utilisées pour modifier le formatage d'une chaîne de caractères :
 
-<pre class="brush:js">var worldString = "Coucou monde";
+```js
+var worldString = "Coucou monde";
 
 console.log(worldString.blink());
 console.log(worldString.bold());
 console.log(worldString.italics());
-console.log(worldString.strike());</pre>
-
-<p>Cela produira le code HTML suivant dans la console :</p>
-
-<pre class="brush:html">&lt;blink&gt;Coucou monde&lt;/blink&gt;
-&lt;b&gt;Coucou monde&lt;/b&gt;
-&lt;i&gt;Coucou monde&lt;/i&gt;
-&lt;strike&gt;Coucou monde&lt;/strike&gt;</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('ES6', '#sec-string.prototype.strike', 'String.prototype.strike')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Définition initiale. Implémentée dans JavaScript 1.0. Définie dans l'annexe B (normative) pour les fonctionnalités ECMAScript additionnelles pour les navigateurs web.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-string.prototype.strike', 'String.prototype.strike')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td>Définie dans l'annexe B (normative) pour les fonctionnalités ECMAScript additionnelles pour les navigateurs web.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.String.strike")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("String.prototype.blink()")}}</li>
- <li>{{jsxref("String.prototype.bold()")}}</li>
- <li>{{jsxref("String.prototype.italics()")}}</li>
-</ul>
+console.log(worldString.strike());
+```
+
+Cela produira le code HTML suivant dans la console :
+
+```html
+<blink>Coucou monde</blink>
+<b>Coucou monde</b>
+<i>Coucou monde</i>
+<strike>Coucou monde</strike>
+```
+
+## Spécifications
+
+| Spécification                                                                                                | État                         | Commentaires                                                                                                                                                           |
+| ------------------------------------------------------------------------------------------------------------ | ---------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| {{SpecName('ES6', '#sec-string.prototype.strike', 'String.prototype.strike')}}     | {{Spec2('ES6')}}         | Définition initiale. Implémentée dans JavaScript 1.0. Définie dans l'annexe B (normative) pour les fonctionnalités ECMAScript additionnelles pour les navigateurs web. |
+| {{SpecName('ESDraft', '#sec-string.prototype.strike', 'String.prototype.strike')}} | {{Spec2('ESDraft')}} | Définie dans l'annexe B (normative) pour les fonctionnalités ECMAScript additionnelles pour les navigateurs web.                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.String.strike")}}
+
+## Voir aussi
+
+- {{jsxref("String.prototype.blink()")}}
+- {{jsxref("String.prototype.bold()")}}
+- {{jsxref("String.prototype.italics()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/string/sub/index.md b/files/fr/web/javascript/reference/global_objects/string/sub/index.md
index 2f53665a08..6e407df677 100644
--- a/files/fr/web/javascript/reference/global_objects/string/sub/index.md
+++ b/files/fr/web/javascript/reference/global_objects/string/sub/index.md
@@ -12,64 +12,49 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/String/sub
 original_slug: Web/JavaScript/Reference/Objets_globaux/String/sub
 ---
-<div>{{JSRef}}{{deprecated_header}}</div>
+{{JSRef}}{{deprecated_header}}
 
-<p>La méthode <code><strong>sub()</strong></code> crée un élément HTML {{HTMLElement("sub")}} qui entraîne l'affichage de la chaîne en indice.</p>
+La méthode **`sub()`** crée un élément HTML {{HTMLElement("sub")}} qui entraîne l'affichage de la chaîne en indice.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>str</var>.sub()</pre>
+    str.sub()
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une chaîne de caractères représentant un élément HTML {{HTMLElement("sub")}}.</p>
+Une chaîne de caractères représentant un élément HTML {{HTMLElement("sub")}}.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La méthode <code>sub</code> encapsule une chaîne dans une balise <code>&lt;sub&gt;</code> :<br>
- <code>"&lt;sub&gt;str&lt;/sub&gt;</code>".</p>
+La méthode `sub` encapsule une chaîne dans une balise `<sub>` :
+`"<sub>str</sub>`".
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<p>L'exemple suivant utilise les méthodes <code>sub()</code> et {{jsxref("String.prototype.sup()", "sup()")}} pour mettre en forme une chaîne :</p>
+L'exemple suivant utilise les méthodes `sub()` et {{jsxref("String.prototype.sup()", "sup()")}} pour mettre en forme une chaîne :
 
-<pre class="brush: js">var superText = "exposant";
+```js
+var superText = "exposant";
 var subText = "indice";
 
 console.log("Ceci illustre l'affichage d'un texte en " + superText.sup() + ".");
-// "Ceci illustre l'affichage d'un texte en &lt;sup&gt;expostant&lt;/sup&gt;
+// "Ceci illustre l'affichage d'un texte en <sup>expostant</sup>
 
 console.log("Ceci illustre l'affichage d'un texte en " + subText.sub() + ".");
-// "Ceci illustre l'affichage d'un texte en &lt;sub&gt;indice&lt;/sub&gt;</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">Commentaire</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-string.prototype.sub', 'String.prototype.sub')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Définition initiale. Implementée avec JavaScript 1.0. Définie dans l'annexe B (normative) des fonctionnalités ECMAScript additionnelles pour les navigateurs web.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-string.prototype.sub', 'String.prototype.sub')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td>Définie dans l'annexe B (normative) des fonctionnalités ECMAScript additionnelles pour les navigateurs web.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.String.sub")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("String.prototype.sup()")}}</li>
-</ul>
+// "Ceci illustre l'affichage d'un texte en <sub>indice</sub>
+```
+
+## Spécifications
+
+| Spécification                                                                                        | État                         | Commentaire                                                                                                                                                       |
+| ---------------------------------------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| {{SpecName('ES6', '#sec-string.prototype.sub', 'String.prototype.sub')}}     | {{Spec2('ES6')}}         | Définition initiale. Implementée avec JavaScript 1.0. Définie dans l'annexe B (normative) des fonctionnalités ECMAScript additionnelles pour les navigateurs web. |
+| {{SpecName('ESDraft', '#sec-string.prototype.sub', 'String.prototype.sub')}} | {{Spec2('ESDraft')}} | Définie dans l'annexe B (normative) des fonctionnalités ECMAScript additionnelles pour les navigateurs web.                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.String.sub")}}
+
+## Voir aussi
+
+- {{jsxref("String.prototype.sup()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/string/substr/index.md b/files/fr/web/javascript/reference/global_objects/string/substr/index.md
index 9ee8253861..00eabdbffd 100644
--- a/files/fr/web/javascript/reference/global_objects/string/substr/index.md
+++ b/files/fr/web/javascript/reference/global_objects/string/substr/index.md
@@ -11,67 +11,68 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/String/substr
 original_slug: Web/JavaScript/Reference/Objets_globaux/String/substr
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<div class="warning"><p><strong>Attention :</strong> Bien que <code>String.prototype.substr(…)</code> ne soit pas strictement obsolète (au sens où elle n'a pas été retirée des standards), elle est définie au sein de <a href="https://www.ecma-international.org/ecma-262/9.0/index.html#sec-additional-ecmascript-features-for-web-browsers">l'Annexe B</a> du standard ECMA-262 qui définit l'ensemble des fonctionnalités historiques qui doivent être évitées autant que possible. On utilisera la méthode {{jsxref("String.prototype.substring()")}} à la place.</p></div>
+> **Attention :** Bien que `String.prototype.substr(…)` ne soit pas strictement obsolète (au sens où elle n'a pas été retirée des standards), elle est définie au sein de [l'Annexe B](https://www.ecma-international.org/ecma-262/9.0/index.html#sec-additional-ecmascript-features-for-web-browsers) du standard ECMA-262 qui définit l'ensemble des fonctionnalités historiques qui doivent être évitées autant que possible. On utilisera la méthode {{jsxref("String.prototype.substring()")}} à la place.
 
-<p>La méthode <strong><code>substr()</code></strong> retourne la partie d'une chaîne de caractères comprise entre l'indice de départ et un certain nombre de caractères après celui-ci.</p>
+La méthode **`substr()`** retourne la partie d'une chaîne de caractères comprise entre l'indice de départ et un certain nombre de caractères après celui-ci.
 
-<div>{{EmbedInteractiveExample("pages/js/string-substr.html")}}</div>
+{{EmbedInteractiveExample("pages/js/string-substr.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><em>chn</em>.substr(<var>début</var>[, <var>longueur</var>])</pre>
+    chn.substr(début[, longueur])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>début</code></dt>
- <dd>L'indice du premier caractère à inclure dans la sous-chaîne retournée.</dd>
- <dt><code>longueur</code></dt>
- <dd>Optionnel. Le nombre de caractères à extraire.</dd>
-</dl>
+- `début`
+  - : L'indice du premier caractère à inclure dans la sous-chaîne retournée.
+- `longueur`
+  - : Optionnel. Le nombre de caractères à extraire.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une nouvelle chaîne contenant la partie indiquée de la chaîne donnée.</p>
+Une nouvelle chaîne contenant la partie indiquée de la chaîne donnée.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p><code>substr()</code> extrait <code>longueur</code> caractères d'une <code>string</code>, en comptant à partir de l'indice <code>début</code>.</p>
+`substr()` extrait `longueur` caractères d'une `string`, en comptant à partir de l'indice `début`.
 
-<p>Si <code>début</code> est un nombre positif, l'indice commence à compter du début de la chaîne. Sa valeur est limitée à <code>chn.length</code>.</p>
+Si `début` est un nombre positif, l'indice commence à compter du début de la chaîne. Sa valeur est limitée à `chn.length`.
 
-<p>Si <code>début</code> est un nombre négatif, l'indice commence à compter de la fin de la chaîne. Sa valeur est limitée à <code>-chn.length</code>.</p>
+Si `début` est un nombre négatif, l'indice commence à compter de la fin de la chaîne. Sa valeur est limitée à `-chn.length`.
 
-<p>Note : dans JScript de Microsoft, les valeurs négatives de l'argument <code>début</code> ne sont pas considérées comme faisant référence à la fin de la chaîne.</p>
+Note : dans JScript de Microsoft, les valeurs négatives de l'argument `début` ne sont pas considérées comme faisant référence à la fin de la chaîne.
 
-<p>Si <code>longueur</code> est omise, <code>substr()</code> extrait les caractères jusqu'à la fin de la chaîne.</p>
+Si `longueur` est omise, `substr()` extrait les caractères jusqu'à la fin de la chaîne.
 
-<p>Si <code>longueur</code> est {{jsxref("undefined")}}, <code>substr()</code> extrait les caractères jusqu'à la fin de la chaîne.</p>
+Si `longueur` est {{jsxref("undefined")}}, `substr()` extrait les caractères jusqu'à la fin de la chaîne.
 
-<p>Si <code>longueur</code> est négative, elle est traitée comme 0.</p>
+Si `longueur` est négative, elle est traitée comme 0.
 
-<p>Pour <code>début</code> comme pour <code>longueur</code>, NaN est traité comme 0.</p>
+Pour `début` comme pour `longueur`, NaN est traité comme 0.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<pre class="brush: js">var uneChaine = 'Mozilla';
+```js
+var uneChaine = 'Mozilla';
 
-<code>console.log(</code>uneChaine<code>.substr(0, 1));   // 'M'
-console.log(</code>uneChaine<code>.substr(1, 0));   // ''
-console.log(</code>uneChaine<code>.substr(-1, 1));  // 'a'
-console.log(</code>uneChaine<code>.substr(1, -1));  // ''
-console.log(</code>uneChaine<code>.substr(-3));     // 'lla'
-console.log(</code>uneChaine<code>.substr(1));      // 'ozilla'
-console.log(</code>uneChaine<code>.substr(-20, 2)); // 'Mo'
-console.log(</code>uneChaine<code>.substr(20, 2));  // ''</code></pre>
+console.log(uneChaine.substr(0, 1));   // 'M'
+console.log(uneChaine.substr(1, 0));   // ''
+console.log(uneChaine.substr(-1, 1));  // 'a'
+console.log(uneChaine.substr(1, -1));  // ''
+console.log(uneChaine.substr(-3));     // 'lla'
+console.log(uneChaine.substr(1));      // 'ozilla'
+console.log(uneChaine.substr(-20, 2)); // 'Mo'
+console.log(uneChaine.substr(20, 2));  // ''
+```
 
-<h2 id="Prothèse_d'émulation_(polyfill)">Prothèse d'émulation (<em>polyfill</em>)</h2>
+## Prothèse d'émulation (_polyfill_)
 
-<p>JScript de Microsoft ne supporte pas les valeurs négatives pour l'indice de début. Pour utiliser cette fonctionnalité, vous pouvez utiliser le code suivant :</p>
+JScript de Microsoft ne supporte pas les valeurs négatives pour l'indice de début. Pour utiliser cette fonctionnalité, vous pouvez utiliser le code suivant :
 
-<pre class="brush: js">// N'appliquer que lorsque la fonction est incomplète
+```js
+// N'appliquer que lorsque la fonction est incomplète
 if ('ab'.substr(-1) != 'b') {
   /**
    *  Obtenir la sous-chaîne d'une chaîne
@@ -81,56 +82,31 @@ if ('ab'.substr(-1) != 'b') {
    */
   String.prototype.substr = function(substr) {
     return function(début, longueur) {
-      <code>// Appel de la méthode originale
-      return </code>substr<code>.call(this,</code>
+      // Appel de la méthode originale
+      return substr.call(this,
         // Si on a un début négatif, calculer combien il vaut à partir du début de la chaîne
         // Ajuster le paramètre pour une valeur négative
-<code>        début &lt; 0 ? this.length + début : début,
+        début < 0 ? this.length + début : début,
         longueur)
-    </code>}
+    }
   }(String.prototype.substr);
 }
-</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('ES3')}}</td>
-   <td>{{Spec2('ES3')}}</td>
-   <td>Définie dans la Compatibility Annex B (informative). Implémentée dans JavaScript 1.0.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-B.2.3', 'String.prototype.substr')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td>Définie dans la Compatibility Annex B (informative).</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-string.prototype.substr', 'String.prototype.substr')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Définie dans l'Annex B (normative) pour les Additional ECMAScript Features for Web Browsers.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-string.prototype.substr', 'String.prototype.substr')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td>Définie dans l'Annex B (normative) pour les Additional ECMAScript Features for Web Browsers</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.String.substr")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("String.prototype.slice()")}}</li>
- <li>{{jsxref("String.prototype.substring()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                | État                         | Commentaires                                                                                 |
+| ------------------------------------------------------------------------------------------------------------ | ---------------------------- | -------------------------------------------------------------------------------------------- |
+| {{SpecName('ES3')}}                                                                                     | {{Spec2('ES3')}}         | Définie dans la Compatibility Annex B (informative). Implémentée dans JavaScript 1.0.        |
+| {{SpecName('ES5.1', '#sec-B.2.3', 'String.prototype.substr')}}                         | {{Spec2('ES5.1')}}     | Définie dans la Compatibility Annex B (informative).                                         |
+| {{SpecName('ES6', '#sec-string.prototype.substr', 'String.prototype.substr')}}     | {{Spec2('ES6')}}         | Définie dans l'Annex B (normative) pour les Additional ECMAScript Features for Web Browsers. |
+| {{SpecName('ESDraft', '#sec-string.prototype.substr', 'String.prototype.substr')}} | {{Spec2('ESDraft')}} | Définie dans l'Annex B (normative) pour les Additional ECMAScript Features for Web Browsers  |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.String.substr")}}
+
+## Voir aussi
+
+- {{jsxref("String.prototype.slice()")}}
+- {{jsxref("String.prototype.substring()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/string/substring/index.md b/files/fr/web/javascript/reference/global_objects/string/substring/index.md
index df6dc3157c..5fbc2431f5 100644
--- a/files/fr/web/javascript/reference/global_objects/string/substring/index.md
+++ b/files/fr/web/javascript/reference/global_objects/string/substring/index.md
@@ -10,49 +10,46 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/String/substring
 original_slug: Web/JavaScript/Reference/Objets_globaux/String/substring
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>substring()</strong></code> retourne une sous-chaîne de la chaîne courante, entre un indice de début et un indice de fin.</p>
+La méthode **`substring()`** retourne une sous-chaîne de la chaîne courante, entre un indice de début et un indice de fin.
 
-<div>{{EmbedInteractiveExample("pages/js/string-substring.html")}}</div>
+{{EmbedInteractiveExample("pages/js/string-substring.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>str</var>.substring(<var>indiceA</var>[, <var>indiceB</var>])</pre>
+    str.substring(indiceA[, indiceB])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>indiceA</code></dt>
- <dd>Un entier compris entre 0 et la longueur de la chaîne.</dd>
- <dt><code>indiceB</code></dt>
- <dd>Paramètre optionnel : un entier compris entre 0 et la longueur de la chaine.</dd>
-</dl>
+- `indiceA`
+  - : Un entier compris entre 0 et la longueur de la chaîne.
+- `indiceB`
+  - : Paramètre optionnel : un entier compris entre 0 et la longueur de la chaine.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une nouvelle chaîne de caractères qui correspond à la section souhaitée de la chaîne appelante.</p>
+Une nouvelle chaîne de caractères qui correspond à la section souhaitée de la chaîne appelante.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p><code>substring</code> extrait des caractères de la chaîne courante à partir de <code>indiceA</code> jusqu'à <code>indiceB</code> (non compris). On a notamment :</p>
+`substring` extrait des caractères de la chaîne courante à partir de `indiceA` jusqu'à `indiceB` (non compris). On a notamment :
 
-<ul>
- <li>Si <code>indiceA</code> est égal à <code>indiceB</code>, <code>substring</code> retournera une chaîne vide.</li>
- <li>Si <code>indiceB</code> est omis, <code>substring</code> effectuera l'extraction des caractères jusqu'à la fin de la chaîne.</li>
- <li>Si l'un des deux arguments est négatif ou vaut {{jsxref("NaN")}}, il sera traité comme 0.</li>
- <li>Si l'un des deux arguments est plus grand que <code>str.length</code>, il sera traité comme <code>str.length</code>.</li>
-</ul>
+- Si `indiceA` est égal à `indiceB`, `substring` retournera une chaîne vide.
+- Si `indiceB` est omis, `substring` effectuera l'extraction des caractères jusqu'à la fin de la chaîne.
+- Si l'un des deux arguments est négatif ou vaut {{jsxref("NaN")}}, il sera traité comme 0.
+- Si l'un des deux arguments est plus grand que `str.length`, il sera traité comme `str.length`.
 
-<p>Si <code>indiceA</code> est supérieur à <code>indiceB</code>, la fonction <code>substring()</code> intervertira ces deux valeurs afin de les traiter comme si elles avaient été passées dans le bon ordre. Par exemple : <code><var>str</var>.substring(1, 0) == <var>str</var>.substring(0, 1)</code>.</p>
+Si `indiceA` est supérieur à `indiceB`, la fonction `substring()` intervertira ces deux valeurs afin de les traiter comme si elles avaient été passées dans le bon ordre. Par exemple : `str.substring(1, 0) == str.substring(0, 1)`.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_substring()">Utiliser <code>substring()</code></h3>
+### Utiliser `substring()`
 
-<p>Les exemples suivants utilisent la méthode <code>substring()</code> pour extraire et afficher des caractères à partir de la chaine "<code>Mozilla</code>" :</p>
+Les exemples suivants utilisent la méthode `substring()` pour extraire et afficher des caractères à partir de la chaine "`Mozilla`" :
 
-<pre class="brush:js">var uneChaîne = "Mozilla";
+```js
+var uneChaîne = "Mozilla";
 
 // Affiche "Moz"
 console.log(uneChaîne.substring(0,3));
@@ -69,15 +66,16 @@ console.log(uneChaîne.substring(0,6));
 // Affiche "Mozilla"
 console.log(uneChaîne.substring(0,7));
 console.log(uneChaîne.substring(0,10));
-</pre>
+```
 
-<h3 id="Remplacer_une_sous-chaîne_dans_une_chaîne">Remplacer une sous-chaîne dans une chaîne</h3>
+### Remplacer une sous-chaîne dans une chaîne
 
-<p>L'exemple suivant remplace une partie d'une chaine. Elle remplace à la fois les caractères individuels et les sous-chaines. La fonction appelée à la fin de cet exemple transforme la chaine "<code>Brave New World</code>" en "<code>Brave New Web</code>".</p>
+L'exemple suivant remplace une partie d'une chaine. Elle remplace à la fois les caractères individuels et les sous-chaines. La fonction appelée à la fin de cet exemple transforme la chaine "`Brave New World`" en "`Brave New Web`".
 
-<pre class="brush:js">function replaceString(oldS, newS, fullS) {
+```js
+function replaceString(oldS, newS, fullS) {
 // On remplace oldS avec newS dans fullS
-  for (var i = 0; i &lt; fullS.length; i++) {
+  for (var i = 0; i < fullS.length; i++) {
     if (fullS.substring(i, i + oldS.length) == oldS) {
      fullS = fullS.substring(0, i) + newS + fullS.substring(i + oldS.length, fullS.length);
     }
@@ -85,93 +83,73 @@ console.log(uneChaîne.substring(0,10));
   return fullS;
 }
 
-replaceString("World", "Web", "Brave New World");</pre>
+replaceString("World", "Web", "Brave New World");
+```
 
-<p>Attention : ceci peut résulter en une boucle infinie si <code>oldS</code> est elle-même une sous-chaine de <code>newS</code> -- par exemple, si on essaie de remplacer "World" par "OtherWorld". Une meilleure solution serait de remplacer les chaines de cette manière :</p>
+Attention : ceci peut résulter en une boucle infinie si `oldS` est elle-même une sous-chaine de `newS` -- par exemple, si on essaie de remplacer "World" par "OtherWorld". Une meilleure solution serait de remplacer les chaines de cette manière :
 
-<pre class="brush:js">function replaceString(oldS, newS,fullS){
+```js
+function replaceString(oldS, newS,fullS){
   return fullS.split(oldS).join(newS);
-}</pre>
-
-<p>Le code ci-dessus sert d'exemple pour les opérations sur les sous-chaines. S'il est nécessaire de remplacer des sous-chaines, la plupart du temps il faudrait préférer l'utilisation de {{jsxref("String.prototype.replace()")}}.</p>
-
-<h3 id="Différence_entre_substring()_et_substr()">Différence entre <code>substring()</code> et <code>substr()</code></h3>
-
-<p>Il existe une légère différence entre les méthodes <code>substring()</code> et {{jsxref("String.substr", "substr()")}}. Les deux ne doivent pas être confondues.</p>
-
-<p>Les arguments de la méthode <code>substring()</code> représentent les indices de début et de fin sur la chaîne. Pour <code>substr()</code>, les arguments représentent l'indice de début et le nombre de caractères à utiliser pour la chaîne résultante.</p>
-
-<pre class="brush: js">var texte = "Mozilla";
-console.log(texte.substring(2,5)); // =&gt; "zil"
-console.log(texte.substr(2,3)); // =&gt; "zil"
-</pre>
-
-<h3 id="Différences_entre_substring()_et_slice()">Différences entre <code>substring()</code> et <code>slice()</code></h3>
-
-<p>Les méthodes <code>substring()</code> et {{jsxref("String.slice", "slice()")}} sont très proches mais certaines différences les distinguent, notamment la façon de gérer les arguments négatifs.</p>
-
-<p>La méthode <code>substring()</code> échangera les deux arguments si <code>indiceA</code> est supérieur à <code>indiceB</code> et renverra donc une chaîne de caractères. La méthode {{jsxref("String.slice", "slice()")}} n'échange pas les arguments et renvoie donc une chaîne vide si le premier est supérieur au second :</p>
-
-<pre class="brush: js">var text = 'Mozilla';
-console.log(text.substring(5, 2)); // =&gt; "zil"
-console.log(text.slice(5, 2));     // =&gt; ""
-</pre>
-
-<p>Si l'un ou l'autre des arguments sont négatifs ou valent <code>NaN</code>, la méthode <code>substring()</code> les traitera comme s'ils valaient <code>0</code>.</p>
-
-<pre class="brush: js">console.log(text.substring(-5, 2)); // =&gt; "Mo"
-console.log(text.substring(-5, -2)); // =&gt; ""
-</pre>
-
-<p><code>slice()</code> traite également <code>NaN</code> comme <code>0</code>, mais parcourt la chaîne à partir de la fin lorsque des arguments négatifs sont utilisés.</p>
-
-<pre class="brush: js">console.log(text.slice(-5, 2)); // =&gt; ""
-console.log(text.slice(-5, -2)); // =&gt; "zil"
-</pre>
-
-<p>Pour plus d'exemples sur l'utilisation d'arguments négatifs, voir la page {{jsxref("String.slice", "slice()")}}.</p>
-
-<h2 id="Spécifications">Spécifications</h2>
-
-<table class="standard-table">
- <thead>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">État</th>
-   <th scope="col">Commentaires</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td>{{SpecName('ES1')}}</td>
-   <td>{{Spec2('ES1')}}</td>
-   <td>Implémentée avec JavaScript 1.0.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.5.4.15', 'String.prototype.substring')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-string.prototype.substring', 'String.prototype.substring')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-string.prototype.substring', 'String.prototype.substring')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.String.substring")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("String.prototype.substr()")}} {{deprecated_inline}}</li>
- <li>{{jsxref("String.prototype.slice()")}}</li>
-</ul>
+}
+```
+
+Le code ci-dessus sert d'exemple pour les opérations sur les sous-chaines. S'il est nécessaire de remplacer des sous-chaines, la plupart du temps il faudrait préférer l'utilisation de {{jsxref("String.prototype.replace()")}}.
+
+### Différence entre `substring()` et `substr()`
+
+Il existe une légère différence entre les méthodes `substring()` et {{jsxref("String.substr", "substr()")}}. Les deux ne doivent pas être confondues.
+
+Les arguments de la méthode `substring()` représentent les indices de début et de fin sur la chaîne. Pour `substr()`, les arguments représentent l'indice de début et le nombre de caractères à utiliser pour la chaîne résultante.
+
+```js
+var texte = "Mozilla";
+console.log(texte.substring(2,5)); // => "zil"
+console.log(texte.substr(2,3)); // => "zil"
+```
+
+### Différences entre `substring()` et `slice()`
+
+Les méthodes `substring()` et {{jsxref("String.slice", "slice()")}} sont très proches mais certaines différences les distinguent, notamment la façon de gérer les arguments négatifs.
+
+La méthode `substring()` échangera les deux arguments si `indiceA` est supérieur à `indiceB` et renverra donc une chaîne de caractères. La méthode {{jsxref("String.slice", "slice()")}} n'échange pas les arguments et renvoie donc une chaîne vide si le premier est supérieur au second :
+
+```js
+var text = 'Mozilla';
+console.log(text.substring(5, 2)); // => "zil"
+console.log(text.slice(5, 2));     // => ""
+```
+
+Si l'un ou l'autre des arguments sont négatifs ou valent `NaN`, la méthode `substring()` les traitera comme s'ils valaient `0`.
+
+```js
+console.log(text.substring(-5, 2)); // => "Mo"
+console.log(text.substring(-5, -2)); // => ""
+```
+
+`slice()` traite également `NaN` comme `0`, mais parcourt la chaîne à partir de la fin lorsque des arguments négatifs sont utilisés.
+
+```js
+console.log(text.slice(-5, 2)); // => ""
+console.log(text.slice(-5, -2)); // => "zil"
+```
+
+Pour plus d'exemples sur l'utilisation d'arguments négatifs, voir la page {{jsxref("String.slice", "slice()")}}.
+
+## Spécifications
+
+| Spécification                                                                                                        | État                         | Commentaires                     |
+| -------------------------------------------------------------------------------------------------------------------- | ---------------------------- | -------------------------------- |
+| {{SpecName('ES1')}}                                                                                             | {{Spec2('ES1')}}         | Implémentée avec JavaScript 1.0. |
+| {{SpecName('ES5.1', '#sec-15.5.4.15', 'String.prototype.substring')}}                         | {{Spec2('ES5.1')}}     |                                  |
+| {{SpecName('ES6', '#sec-string.prototype.substring', 'String.prototype.substring')}}     | {{Spec2('ES6')}}         |                                  |
+| {{SpecName('ESDraft', '#sec-string.prototype.substring', 'String.prototype.substring')}} | {{Spec2('ESDraft')}} |                                  |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.String.substring")}}
+
+## Voir aussi
+
+- {{jsxref("String.prototype.substr()")}} {{deprecated_inline}}
+- {{jsxref("String.prototype.slice()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/string/sup/index.md b/files/fr/web/javascript/reference/global_objects/string/sup/index.md
index a7806d7dbe..c8fd418ecf 100644
--- a/files/fr/web/javascript/reference/global_objects/string/sup/index.md
+++ b/files/fr/web/javascript/reference/global_objects/string/sup/index.md
@@ -12,64 +12,48 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/String/sup
 original_slug: Web/JavaScript/Reference/Objets_globaux/String/sup
 ---
-<div>{{JSRef}} {{deprecated_header}}</div>
+{{JSRef}} {{deprecated_header}}
 
-<p>La méthode <code><strong>sup()</strong></code> crée un élément HTML {{HTMLElement("sup")}} qui entraîne l'affichage de la chaîne en exposant.</p>
+La méthode **`sup()`** crée un élément HTML {{HTMLElement("sup")}} qui entraîne l'affichage de la chaîne en exposant.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>str</var>.sup()</pre>
+    str.sup()
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une chaîne de caractères représentant un élément HTML {{HTMLElement("sup")}}.</p>
+Une chaîne de caractères représentant un élément HTML {{HTMLElement("sup")}}.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La méthode <code>sup</code> encapsule une chaîne dans une balise <code>&lt;sup&gt;</code> :<br>
- <code>"&lt;sup&gt;str&lt;/sup&gt;</code>".</p>
+La méthode `sup` encapsule une chaîne dans une balise `<sup>` :
+`"<sup>str</sup>`".
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<p>L'exemple suivant utilise les méthodes {{jsxref("String.prototype.sub()", "sub()")}} et <code>sup</code> pour mettre en forme une chaîne :</p>
+L'exemple suivant utilise les méthodes {{jsxref("String.prototype.sub()", "sub()")}} et `sup` pour mettre en forme une chaîne :
 
-<pre class="brush: js">var superText = "exposant";
+```js
+var superText = "exposant";
 var subText = "indice";
 
 console.log("Ceci illustre l'affichage d'un texte en " + superText.sup() + ".");
-// Ceci illustre l'affichage d'un texte en &lt;sup&gt;exposant&lt;/sup&gt;.
+// Ceci illustre l'affichage d'un texte en <sup>exposant</sup>.
 console.log("Ceci illustre l'affichage d'un texte en " + subText.sub() + ".");
-Ceci illustre l'affichage d'un texte en &lt;sub&gt;indice&lt;/sub&gt;.
-</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('ES6', '#sec-string.prototype.sup', 'String.prototype.sup')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Définition initiale. Implémentée avec JavaScript 1.0. Définie dans l'annexe B (normative) pour les fonctionnalités ECMAScript additionnelles des navigateurs web.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-string.prototype.sup', 'String.prototype.sup')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td>Définition initiale. Implémentée avec JavaScript 1.0. Définie dans l'annexe B (normative) pour les fonctionnalités ECMAScript additionnelles des navigateurs web.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.String.sup")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("String.prototype.sub()")}}</li>
-</ul>
+Ceci illustre l'affichage d'un texte en <sub>indice</sub>.
+```
+
+## Spécifications
+
+| Spécification                                                                                        | État                         | Commentaires                                                                                                                                                      |
+| ---------------------------------------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| {{SpecName('ES6', '#sec-string.prototype.sup', 'String.prototype.sup')}}     | {{Spec2('ES6')}}         | Définition initiale. Implémentée avec JavaScript 1.0. Définie dans l'annexe B (normative) pour les fonctionnalités ECMAScript additionnelles des navigateurs web. |
+| {{SpecName('ESDraft', '#sec-string.prototype.sup', 'String.prototype.sup')}} | {{Spec2('ESDraft')}} | Définition initiale. Implémentée avec JavaScript 1.0. Définie dans l'annexe B (normative) pour les fonctionnalités ECMAScript additionnelles des navigateurs web. |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.String.sup")}}
+
+## Voir aussi
+
+- {{jsxref("String.prototype.sub()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/string/tolocalelowercase/index.md b/files/fr/web/javascript/reference/global_objects/string/tolocalelowercase/index.md
index caf1c9c0c8..9eccd4d59d 100644
--- a/files/fr/web/javascript/reference/global_objects/string/tolocalelowercase/index.md
+++ b/files/fr/web/javascript/reference/global_objects/string/tolocalelowercase/index.md
@@ -12,95 +12,63 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase
 original_slug: Web/JavaScript/Reference/Objets_globaux/String/toLocaleLowerCase
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>toLocaleLowerCase()</strong></code> renvoie la chaîne de caractères qui appelle la méthode en une chaîne de caractères représentées en minuscules, en tenant compte des correspondances de caractères propres aux différentes locales.</p>
+La méthode **`toLocaleLowerCase()`** renvoie la chaîne de caractères qui appelle la méthode en une chaîne de caractères représentées en minuscules, en tenant compte des correspondances de caractères propres aux différentes locales.
 
-<div>{{EmbedInteractiveExample("pages/js/string-tolocalelowercase.html")}}</div>
+{{EmbedInteractiveExample("pages/js/string-tolocalelowercase.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>str</var>.toLocaleLowerCase()
-<var>str</var>.toLocaleLowerCase(locale)
-<var>str</var>.toLocaleLowerCase([locale, locale, ...])</pre>
+    str.toLocaleLowerCase()
+    str.toLocaleLowerCase(locale)
+    str.toLocaleLowerCase([locale, locale, ...])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>locale</code> {{optional_inline}}</dt>
- <dd>Ce paramètre indique la locale dans laquelle convertir la chaîne en minuscules en utilisant les correspondances de cette locale. Si plusieurs locales sont fournies au sein d'un tableau, c'est la meilleure locale disponible qui est utilisée. La locale par défaut est celle utilisée par le système hôte.</dd>
-</dl>
+- `locale` {{optional_inline}}
+  - : Ce paramètre indique la locale dans laquelle convertir la chaîne en minuscules en utilisant les correspondances de cette locale. Si plusieurs locales sont fournies au sein d'un tableau, c'est la meilleure locale disponible qui est utilisée. La locale par défaut est celle utilisée par le système hôte.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une nouvelle chaîne de caractères obtenue à partir de la chaîne appelante, convertie en minuscules en tenant compte de la locale.</p>
+Une nouvelle chaîne de caractères obtenue à partir de la chaîne appelante, convertie en minuscules en tenant compte de la locale.
 
-<h3 id="Exceptions">Exceptions</h3>
+### Exceptions
 
-<p>Cette méthode peut lever les exceptions suivantes :</p>
+Cette méthode peut lever les exceptions suivantes :
 
-<ul>
- <li>{{jsxref("RangeError")}} ("invalid language tag: xx_yy") si l'argument <code>locale</code> ne correspond pas à une balise de langue valide.</li>
- <li>{{jsxref("TypeError")}} ("invalid element in locales argument") si un des éléments du tableau passé en argument n'est pas une chaîne de caractères.</li>
-</ul>
+- {{jsxref("RangeError")}} ("invalid language tag: xx_yy") si l'argument `locale` ne correspond pas à une balise de langue valide.
+- {{jsxref("TypeError")}} ("invalid element in locales argument") si un des éléments du tableau passé en argument n'est pas une chaîne de caractères.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La méthode <code>toLocaleLowerCase()</code> renvoie la valeur de la chaîne de caractères, convertie en minuscules selon les correspondances propres à la la locale. <code>toLocaleLowerCase()</code> ne modifie pas la chaîne d'origine. Dans la plupart des cas, cette méthode produira le même résultat que {{jsxref("String.toLowerCase", "toLowerCase()")}}. En revanche, pour certaines locales, par exemple les locales turques dont les correspondances entre les caractères ne sont pas celles par défaut, prévues par Unicode, cette méthode pourra produire un résultat différent.</p>
+La méthode `toLocaleLowerCase()` renvoie la valeur de la chaîne de caractères, convertie en minuscules selon les correspondances propres à la la locale. `toLocaleLowerCase()` ne modifie pas la chaîne d'origine. Dans la plupart des cas, cette méthode produira le même résultat que {{jsxref("String.toLowerCase", "toLowerCase()")}}. En revanche, pour certaines locales, par exemple les locales turques dont les correspondances entre les caractères ne sont pas celles par défaut, prévues par Unicode, cette méthode pourra produire un résultat différent.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<pre class="brush:js">"ALPHABET".toLocaleLowerCase(); // "alphabet"
+```js
+"ALPHABET".toLocaleLowerCase(); // "alphabet"
 
 "\u0130".toLocaleLowerCase("tr") === "i"; // true
 "\u0130".toLocaleLowerCase("en-US") === "i"; // false
-</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('ES3')}}</td>
-   <td>{{Spec2('ES3')}}</td>
-   <td>Définition initiale. Implémentée avec JavaScript 1.2.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.5.4.17', 'String.prototype.toLocaleLowerCase')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-string.prototype.tolocalelowercase', 'String.prototype.toLocaleLowerCase')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-string.prototype.tolocalelowercase', 'String.prototype.toLocaleLowerCase')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES Int Draft', '#sup-string.prototype.tolocalelowercase', 'String.prototype.toLocaleLowerCase')}}</td>
-   <td>{{Spec2('ES Int Draft')}}</td>
-   <td>Ajout du paramètre <code>locale</code> dans ES Intl 2017</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.String.toLocaleLowerCase")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("String.prototype.toLocaleUpperCase()")}}</li>
- <li>{{jsxref("String.prototype.toLowerCase()")}}</li>
- <li>{{jsxref("String.prototype.toUpperCase()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                                                    | État                             | Commentaires                                          |
+| ------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------- | ----------------------------------------------------- |
+| {{SpecName('ES3')}}                                                                                                                         | {{Spec2('ES3')}}             | Définition initiale. Implémentée avec JavaScript 1.2. |
+| {{SpecName('ES5.1', '#sec-15.5.4.17', 'String.prototype.toLocaleLowerCase')}}                                         | {{Spec2('ES5.1')}}         |                                                       |
+| {{SpecName('ES6', '#sec-string.prototype.tolocalelowercase', 'String.prototype.toLocaleLowerCase')}}             | {{Spec2('ES6')}}             |                                                       |
+| {{SpecName('ESDraft', '#sec-string.prototype.tolocalelowercase', 'String.prototype.toLocaleLowerCase')}}     | {{Spec2('ESDraft')}}     |                                                       |
+| {{SpecName('ES Int Draft', '#sup-string.prototype.tolocalelowercase', 'String.prototype.toLocaleLowerCase')}} | {{Spec2('ES Int Draft')}} | Ajout du paramètre `locale` dans ES Intl 2017         |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.String.toLocaleLowerCase")}}
+
+## Voir aussi
+
+- {{jsxref("String.prototype.toLocaleUpperCase()")}}
+- {{jsxref("String.prototype.toLowerCase()")}}
+- {{jsxref("String.prototype.toUpperCase()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/string/tolocaleuppercase/index.md b/files/fr/web/javascript/reference/global_objects/string/tolocaleuppercase/index.md
index 0116ac288d..016286cab7 100644
--- a/files/fr/web/javascript/reference/global_objects/string/tolocaleuppercase/index.md
+++ b/files/fr/web/javascript/reference/global_objects/string/tolocaleuppercase/index.md
@@ -12,96 +12,64 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase
 original_slug: Web/JavaScript/Reference/Objets_globaux/String/toLocaleUpperCase
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>toLocaleUpperCase()</strong></code> renvoie la chaîne de caractères qui appelle la méthode en caractères majuscules, selon les correspondances de caractères propres aux différentes locales.</p>
+La méthode **`toLocaleUpperCase()`** renvoie la chaîne de caractères qui appelle la méthode en caractères majuscules, selon les correspondances de caractères propres aux différentes locales.
 
-<div>{{EmbedInteractiveExample("pages/js/string-tolocaleuppercase.html")}}</div>
+{{EmbedInteractiveExample("pages/js/string-tolocaleuppercase.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>str</var>.toLocaleUpperCase()
-<var>str</var>.toLocaleUpperCase(locale)
-<var>str</var>.toLocaleUpperCase([locale, locale, ...])</pre>
+    str.toLocaleUpperCase()
+    str.toLocaleUpperCase(locale)
+    str.toLocaleUpperCase([locale, locale, ...])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>locale</code> {{optional_inline}}</dt>
- <dd>Le paramètre <code>locale</code> indique la locale dans laquelle convertir la chaîne en majuscules afin que la méthode utilise les correspondances de cette locale. Si plusieurs locales sont fournies au sein d'un tableau, la meilleure locale disponible est alors utilisée. La locale par défaut est celle utilisée par le système hôte.</dd>
-</dl>
+- `locale` {{optional_inline}}
+  - : Le paramètre `locale` indique la locale dans laquelle convertir la chaîne en majuscules afin que la méthode utilise les correspondances de cette locale. Si plusieurs locales sont fournies au sein d'un tableau, la meilleure locale disponible est alors utilisée. La locale par défaut est celle utilisée par le système hôte.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une nouvelle chaîne de caractères obtenue en transformant la chaîne de caractères appelante en majuscules et en tenant compte de la locale.</p>
+Une nouvelle chaîne de caractères obtenue en transformant la chaîne de caractères appelante en majuscules et en tenant compte de la locale.
 
-<h3 id="Exceptions">Exceptions</h3>
+### Exceptions
 
-<p>Cette méthode peut lever les exceptions suivantes :</p>
+Cette méthode peut lever les exceptions suivantes :
 
-<ul>
- <li>{{jsxref("RangeError")}} ("invalid language tag: xx_yy") si l'argument <code>locale</code> ne correspond pas à une balise de langue valide.</li>
- <li>{{jsxref("TypeError")}} ("invalid element in locales arguments") si un élément du tableau de locales passé en argument n'est pas une chaîne de caractères.</li>
-</ul>
+- {{jsxref("RangeError")}} ("invalid language tag: xx_yy") si l'argument `locale` ne correspond pas à une balise de langue valide.
+- {{jsxref("TypeError")}} ("invalid element in locales arguments") si un élément du tableau de locales passé en argument n'est pas une chaîne de caractères.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La méthode <code>toLocaleUpperCase()</code> renvoie la valeur de la chaîne de caractères, convertie en majuscules selon les correspondances propres à la la locale. <code>toLocaleUpperCase()</code> ne modifie pas la chaîne d'origine. Dans la plupart des cas, cette méthode produira le même résultat que {{jsxref("String.toUpperCase", "toUpperCase()")}}. En revanche, pour certaines locales, par exemple les locales turques dont les correspondances entre les caractères ne sont pas celles par défaut prévue par Unicode, cette méthode pourra produire un résultat différent.</p>
+La méthode `toLocaleUpperCase()` renvoie la valeur de la chaîne de caractères, convertie en majuscules selon les correspondances propres à la la locale. `toLocaleUpperCase()` ne modifie pas la chaîne d'origine. Dans la plupart des cas, cette méthode produira le même résultat que {{jsxref("String.toUpperCase", "toUpperCase()")}}. En revanche, pour certaines locales, par exemple les locales turques dont les correspondances entre les caractères ne sont pas celles par défaut prévue par Unicode, cette méthode pourra produire un résultat différent.
 
-<p>On notera également que la conversion ne repose pas sur une correspondance un à un de chaque caractère. En effet, certains caractères produisent deux (voire plus) caractères lorsqu'ils sont convertis en majuscules. Ainsi, la longueur de la chaîne passée en majuscules peut être différente de la longueur de la chaîne originale. Cela implique que la transformation n'est pas stable, autrement dit, l'instruction suivante pourra renvoyer <code>false</code> : <code>x.toLocaleLowerCase() === x.toLocaleUpperCase().toLocaleLowerCase()</code>.</p>
+On notera également que la conversion ne repose pas sur une correspondance un à un de chaque caractère. En effet, certains caractères produisent deux (voire plus) caractères lorsqu'ils sont convertis en majuscules. Ainsi, la longueur de la chaîne passée en majuscules peut être différente de la longueur de la chaîne originale. Cela implique que la transformation n'est pas stable, autrement dit, l'instruction suivante pourra renvoyer `false` : `x.toLocaleLowerCase() === x.toLocaleUpperCase().toLocaleLowerCase()`.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<pre class="brush: js">"alphabet".toLocaleUpperCase();       // "ALPHABET"
+```js
+"alphabet".toLocaleUpperCase();       // "ALPHABET"
 'Gesäß'.toLocaleUpperCase();          // 'GESÄSS'
 "i\u0307".toLocaleUpperCase("lt-LT"); // "I"
-</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('ES3')}}</td>
-   <td>{{Spec2('ES3')}}</td>
-   <td>Définition initiale. Implémentée avec JavaScript 1.2.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.5.4.19', 'String.prototype.toLocaleUpperCase')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-string.prototype.tolocaleuppercase', 'String.prototype.toLocaleUpperCase')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-string.prototype.tolocaleuppercase', 'String.prototype.toLocaleUpperCase')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES Int Draft', '#sup-string.prototype.tolocaleuppercase', 'String.prototype.toLocaleUpperCase')}}</td>
-   <td>{{Spec2('ES Int Draft')}}</td>
-   <td>Ajout du paramètre <code>locale</code> dans ES Intl 2017.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.String.toLocaleUpperCase")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("String.prototype.toLocaleLowerCase()")}}</li>
- <li>{{jsxref("String.prototype.toLowerCase()")}}</li>
- <li>{{jsxref("String.prototype.toUpperCase()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                                                    | État                             | Commentaires                                          |
+| ------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------- | ----------------------------------------------------- |
+| {{SpecName('ES3')}}                                                                                                                         | {{Spec2('ES3')}}             | Définition initiale. Implémentée avec JavaScript 1.2. |
+| {{SpecName('ES5.1', '#sec-15.5.4.19', 'String.prototype.toLocaleUpperCase')}}                                         | {{Spec2('ES5.1')}}         |                                                       |
+| {{SpecName('ES6', '#sec-string.prototype.tolocaleuppercase', 'String.prototype.toLocaleUpperCase')}}             | {{Spec2('ES6')}}             |                                                       |
+| {{SpecName('ESDraft', '#sec-string.prototype.tolocaleuppercase', 'String.prototype.toLocaleUpperCase')}}     | {{Spec2('ESDraft')}}     |                                                       |
+| {{SpecName('ES Int Draft', '#sup-string.prototype.tolocaleuppercase', 'String.prototype.toLocaleUpperCase')}} | {{Spec2('ES Int Draft')}} | Ajout du paramètre `locale` dans ES Intl 2017.        |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.String.toLocaleUpperCase")}}
+
+## Voir aussi
+
+- {{jsxref("String.prototype.toLocaleLowerCase()")}}
+- {{jsxref("String.prototype.toLowerCase()")}}
+- {{jsxref("String.prototype.toUpperCase()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/string/tolowercase/index.md b/files/fr/web/javascript/reference/global_objects/string/tolowercase/index.md
index 88a37a316c..abd97d98aa 100644
--- a/files/fr/web/javascript/reference/global_objects/string/tolowercase/index.md
+++ b/files/fr/web/javascript/reference/global_objects/string/tolowercase/index.md
@@ -10,69 +10,45 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/String/toLowerCase
 original_slug: Web/JavaScript/Reference/Objets_globaux/String/toLowerCase
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>toLowerCase()</strong></code> retourne la chaîne de caractères courante en minuscules.</p>
+La méthode **`toLowerCase()`** retourne la chaîne de caractères courante en minuscules.
 
-<div>{{EmbedInteractiveExample("pages/js/string-tolowercase.html")}}</div>
+{{EmbedInteractiveExample("pages/js/string-tolowercase.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>str</var>.toLowerCase()</pre>
+    str.toLowerCase()
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une nouvelle chaîne de caractères qui est obtenue en passant la chaîne appelante en minuscules.</p>
+Une nouvelle chaîne de caractères qui est obtenue en passant la chaîne appelante en minuscules.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La méthode <code>toLowerCase()</code> renvoie la valeur de la chaîne convertie en minuscules. <code>toLowerCase()</code> ne modifie pas la valeur de la chaîne courante.</p>
+La méthode `toLowerCase()` renvoie la valeur de la chaîne convertie en minuscules. `toLowerCase()` ne modifie pas la valeur de la chaîne courante.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<pre class="brush: js">console.log( "ALPHABET".toLowerCase() ); // "alphabet"
-</pre>
+```js
+console.log( "ALPHABET".toLowerCase() ); // "alphabet"
+```
 
-<h2 id="Spécifications">Spécifications</h2>
+## Spécifications
 
-<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('ES1')}}</td>
-   <td>{{Spec2('ES1')}}</td>
-   <td>Définition initiale. Implémentée avec JavaScript 1.0.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.5.4.16', 'String.prototype.toLowerCase')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-string.prototype.tolowercase', 'String.prototype.toLowerCase')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-string.prototype.tolowercase', 'String.prototype.toLowerCase')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
+| Spécification                                                                                                                | État                         | Commentaires                                          |
+| ---------------------------------------------------------------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- |
+| {{SpecName('ES1')}}                                                                                                     | {{Spec2('ES1')}}         | Définition initiale. Implémentée avec JavaScript 1.0. |
+| {{SpecName('ES5.1', '#sec-15.5.4.16', 'String.prototype.toLowerCase')}}                             | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-string.prototype.tolowercase', 'String.prototype.toLowerCase')}}         | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-string.prototype.tolowercase', 'String.prototype.toLowerCase')}} | {{Spec2('ESDraft')}} |                                                       |
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.String.toLowerCase")}}</p>
+{{Compat("javascript.builtins.String.toLowerCase")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("String.prototype.toLocaleLowerCase()")}}</li>
- <li>{{jsxref("String.prototype.toLocaleUpperCase()")}}</li>
- <li>{{jsxref("String.prototype.toUpperCase()")}}</li>
-</ul>
+- {{jsxref("String.prototype.toLocaleLowerCase()")}}
+- {{jsxref("String.prototype.toLocaleUpperCase()")}}
+- {{jsxref("String.prototype.toUpperCase()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/string/tosource/index.md b/files/fr/web/javascript/reference/global_objects/string/tosource/index.md
index 2fb635149a..501689fa18 100644
--- a/files/fr/web/javascript/reference/global_objects/string/tosource/index.md
+++ b/files/fr/web/javascript/reference/global_objects/string/tosource/index.md
@@ -11,47 +11,43 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/String/toSource
 original_slug: Web/JavaScript/Reference/Objets_globaux/String/toSource
 ---
-<div>{{JSRef}} {{Non-standard_header}}</div>
+{{JSRef}} {{Non-standard_header}}
 
-<p>La méthode <code><strong>toSource()</strong></code> permet de renvoyer une chaîne de caractères représentant le code source de l'objet.</p>
+La méthode **`toSource()`** permet de renvoyer une chaîne de caractères représentant le code source de l'objet.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">String.toSource()
-<var>str</var>.toSource()
-</pre>
+    String.toSource()
+    str.toSource()
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une chaîne de caractères qui représente le code source de la chaîne de caractères appelante.</p>
+Une chaîne de caractères qui représente le code source de la chaîne de caractères appelante.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La méthode <code>toSource()</code> renvoie les valeurs suivantes :</p>
+La méthode `toSource()` renvoie les valeurs suivantes :
 
-<ul>
- <li>Pour l'objet natif {{jsxref("String")}}, <code>toSource()</code> renvoie la chaîne de caractère suivante, indiquant que le code source n'est pas disponible :
+- Pour l'objet natif {{jsxref("String")}}, `toSource()` renvoie la chaîne de caractère suivante, indiquant que le code source n'est pas disponible :
 
-  <pre class="brush: js">function String() {
-    [native code]
-}
-</pre>
- </li>
- <li>Pour les instances de {{jsxref("String")}} ou les littéraux de chaînes de caractères, <code>toSource()</code> renvoie une chaîne de caractère représentant le code source.</li>
-</ul>
+  ```js
+    function String() {
+        [native code]
+    }
+    ```
 
-<p>Généralement, cette méthode est appelée par du code interne au moteur JavaScript et n'est pas trouvée dans du code JavaScript externe.</p>
+- Pour les instances de {{jsxref("String")}} ou les littéraux de chaînes de caractères, `toSource()` renvoie une chaîne de caractère représentant le code source.
 
-<h2 id="Spécifications">Spécifications</h2>
+Généralement, cette méthode est appelée par du code interne au moteur JavaScript et n'est pas trouvée dans du code JavaScript externe.
 
-<p>Cette méthode ne fait partie d'aucun standard. Elle a été implémentée avec JavaScript 1.3.</p>
+## Spécifications
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+Cette méthode ne fait partie d'aucun standard. Elle a été implémentée avec JavaScript 1.3.
 
-<p>{{Compat("javascript.builtins.String.toSource")}}</p>
+## Compatibilité des navigateurs
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+{{Compat("javascript.builtins.String.toSource")}}
 
-<ul>
- <li>{{jsxref("Object.prototype.toSource()")}}</li>
-</ul>
+## Voir aussi
+
+- {{jsxref("Object.prototype.toSource()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/string/tostring/index.md b/files/fr/web/javascript/reference/global_objects/string/tostring/index.md
index 0cdc5b48b2..630a4a4d32 100644
--- a/files/fr/web/javascript/reference/global_objects/string/tostring/index.md
+++ b/files/fr/web/javascript/reference/global_objects/string/tostring/index.md
@@ -10,72 +10,47 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/String/toString
 original_slug: Web/JavaScript/Reference/Objets_globaux/String/toString
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>toString()</strong></code> renvoie une chaine de caractères représentant l'objet renseigné.</p>
+La méthode **`toString()`** renvoie une chaine de caractères représentant l'objet renseigné.
 
+{{EmbedInteractiveExample("pages/js/string-tostring.html")}}
 
+## Syntaxe
 
-<div>{{EmbedInteractiveExample("pages/js/string-tostring.html")}}</div>
+    str.toString()
 
-<h2 id="Syntaxe">Syntaxe</h2>
+### Valeur de retour
 
-<pre class="syntaxbox"><var>str</var>.toString()</pre>
+Une chaîne de caractères représentant la chaîne appelante.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+## Description
 
-<p>Une chaîne de caractères représentant la chaîne appelante.</p>
+L'objet {{jsxref("String")}} surcharge la méthode `toString()` de l'objet {{jsxref("Object")}} ; il n'hérite pas de {{jsxref("Object.toString","Object.prototype.toString()")}}. Pour Les objets `String`, la méthode `toString()` renvoie une chaine de caractères représentant l'objet, et est similaire à la méthode {{jsxref("String.prototype.valueOf()")}}.
 
-<h2 id="Description">Description</h2>
+## Exemples
 
-<p>L'objet {{jsxref("String")}} surcharge la méthode <code>toString()</code> de l'objet {{jsxref("Object")}} ; il n'hérite pas de {{jsxref("Object.toString","Object.prototype.toString()")}}. Pour Les objets <code>String</code>, la méthode <code>toString()</code> renvoie une chaine de caractères représentant l'objet, et est similaire à la méthode {{jsxref("String.prototype.valueOf()")}}.</p>
+L'exemple suivant affiche la valeur textuelle d'un objet  {{jsxref("String")}} :
 
-<h2 id="Exemples">Exemples</h2>
+```js
+var x = new String("coucou monde");
+console.log(x.toString()); // affiche "coucou monde"
+```
 
-<p>L'exemple suivant affiche la valeur textuelle d'un objet  {{jsxref("String")}} :</p>
+## Spécifications
 
-<pre class="brush:js">var x = new String("coucou monde");
-console.log(x.toString()); // affiche "coucou monde"</pre>
+| Spécification                                                                                                        | État                         | Commentaires                                          |
+| -------------------------------------------------------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- |
+| {{SpecName('ES3')}}                                                                                             | {{Spec2('ES3')}}         | Définition initiale. Implémentée avec JavaScript 1.1. |
+| {{SpecName('ES5.1', '#sec-15.5.4.2', 'String.prototype.toString')}}                             | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-string.prototype.tostring', 'String.prototype.toString')}}         | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-string.prototype.tostring', 'String.prototype.toString')}} | {{Spec2('ESDraft')}} |                                                       |
 
-<h2 id="Spécifications">Spécifications</h2>
+## Compatibilité des navigateurs
 
-<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('ES3')}}</td>
-   <td>{{Spec2('ES3')}}</td>
-   <td>Définition initiale. Implémentée avec JavaScript 1.1.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.5.4.2', 'String.prototype.toString')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-string.prototype.tostring', 'String.prototype.toString')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-string.prototype.tostring', 'String.prototype.toString')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
+{{Compat("javascript.builtins.String.toString")}}
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Voir aussi
 
-<p>{{Compat("javascript.builtins.String.toString")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Object.prototype.toSource()")}}</li>
- <li>{{jsxref("String.prototype.valueOf()")}}</li>
-</ul>
+- {{jsxref("Object.prototype.toSource()")}}
+- {{jsxref("String.prototype.valueOf()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/string/touppercase/index.md b/files/fr/web/javascript/reference/global_objects/string/touppercase/index.md
index cd9d6b0f9b..efa4875d7d 100644
--- a/files/fr/web/javascript/reference/global_objects/string/touppercase/index.md
+++ b/files/fr/web/javascript/reference/global_objects/string/touppercase/index.md
@@ -10,42 +10,43 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/String/toUpperCase
 original_slug: Web/JavaScript/Reference/Objets_globaux/String/toUpperCase
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>toUpperCase()</strong></code> retourne la valeur de la chaîne courante, convertie en majuscules.</p>
+La méthode **`toUpperCase()`** retourne la valeur de la chaîne courante, convertie en majuscules.
 
-<div>{{EmbedInteractiveExample("pages/js/string-touppercase.html")}}</div>
+{{EmbedInteractiveExample("pages/js/string-touppercase.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>str</var>.toUpperCase()</pre>
+    str.toUpperCase()
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une nouvelle chaîne de caractères obtenue à partir de la chaîne appelante, passée en majuscules.</p>
+Une nouvelle chaîne de caractères obtenue à partir de la chaîne appelante, passée en majuscules.
 
-<h3 id="Exceptions_levées">Exceptions levées</h3>
+### Exceptions levées
 
-<dl>
- <dt>{{jsxref("TypeError")}}</dt>
- <dd>Une telle exception sera levée si on appelle cette méthode sur {{jsxref("null")}} ou {{jsxref("undefined")}} (en utilisant <code>Function.prototype.call()</code> par exemple).</dd>
-</dl>
+- {{jsxref("TypeError")}}
+  - : Une telle exception sera levée si on appelle cette méthode sur {{jsxref("null")}} ou {{jsxref("undefined")}} (en utilisant `Function.prototype.call()` par exemple).
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La méthode <code>toUpperCase()</code> retourne la valeur de la chaîne convertie en majuscules. <code>toUpperCase</code> n'affecte pas la valeur de la chaîne elle-même.</p>
+La méthode `toUpperCase()` retourne la valeur de la chaîne convertie en majuscules. `toUpperCase` n'affecte pas la valeur de la chaîne elle-même.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_toUpperCase()">Utiliser <code>toUpperCase()</code></h3>
+### Utiliser `toUpperCase()`
 
-<pre class="brush: js">console.log( "alphabet".toUpperCase() ); // "ALPHABET"</pre>
+```js
+console.log( "alphabet".toUpperCase() ); // "ALPHABET"
+```
 
-<h3 id="Convertir_une_valeur_this_en_chaîne_de_caractères">Convertir une valeur <code>this</code> en chaîne de caractères</h3>
+### Convertir une valeur `this` en chaîne de caractères
 
-<p class="brush: js">Cette peut être utilisée pour convertir une valeur qui n'est pas une chaîne de caractères lorsque celle-ci est fournie comme valeur <code>this</code> : ​​​​</p>
+Cette peut être utilisée pour convertir une valeur qui n'est pas une chaîne de caractères lorsque celle-ci est fournie comme valeur `this` : ​​​​
 
-<pre class="brush: js">var obj = {
+```js
+var obj = {
   toString: function toString(){
     return 'abcdef';
   }
@@ -55,50 +56,23 @@ var b = String.prototype.toUpperCase.call(true);
 
 console.log(a); // Affiche 'ABCDEF' dans la console
 console.log(b); // Affiche 'TRUE' dans la console
-</pre>
-
-<h2 id="Spécifications">Spécifications</h2>
-
-<table class="standard-table">
- <thead>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">État</th>
-   <th scope="col">Commentaires</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td>{{SpecName('ES1')}}</td>
-   <td>{{Spec2('ES1')}}</td>
-   <td>Définition initiale. Implémentée avec JavaScript 1.0.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.5.4.18', 'String.prototype.toUpperCase')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-string.prototype.touppercase', 'String.prototype.toUpperCase')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-string.prototype.touppercase', 'String.prototype.toUpperCase')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.String.toUpperCase")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("String.prototype.toLocaleLowerCase()")}}</li>
- <li>{{jsxref("String.prototype.toLocaleUpperCase()")}}</li>
- <li>{{jsxref("String.prototype.toLowerCase()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                                | État                         | Commentaires                                          |
+| ---------------------------------------------------------------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- |
+| {{SpecName('ES1')}}                                                                                                     | {{Spec2('ES1')}}         | Définition initiale. Implémentée avec JavaScript 1.0. |
+| {{SpecName('ES5.1', '#sec-15.5.4.18', 'String.prototype.toUpperCase')}}                             | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-string.prototype.touppercase', 'String.prototype.toUpperCase')}}         | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-string.prototype.touppercase', 'String.prototype.toUpperCase')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.String.toUpperCase")}}
+
+## Voir aussi
+
+- {{jsxref("String.prototype.toLocaleLowerCase()")}}
+- {{jsxref("String.prototype.toLocaleUpperCase()")}}
+- {{jsxref("String.prototype.toLowerCase()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/string/trim/index.md b/files/fr/web/javascript/reference/global_objects/string/trim/index.md
index 24146f8e6f..a36df76b58 100644
--- a/files/fr/web/javascript/reference/global_objects/string/trim/index.md
+++ b/files/fr/web/javascript/reference/global_objects/string/trim/index.md
@@ -12,82 +12,63 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/String/Trim
 original_slug: Web/JavaScript/Reference/Objets_globaux/String/trim
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>trim()</code></strong> permet de retirer les blancs en début et fin de chaîne. Les blancs considérés sont les caractères d'espacement (espace, tabulation, espace insécable, etc.) ainsi que les caractères de fin de ligne (LF, CR, etc.).</p>
+La méthode **`trim()`** permet de retirer les blancs en début et fin de chaîne. Les blancs considérés sont les caractères d'espacement (espace, tabulation, espace insécable, etc.) ainsi que les caractères de fin de ligne (LF, CR, etc.).
 
-<div>{{EmbedInteractiveExample("pages/js/string-trim.html")}}</div>
+{{EmbedInteractiveExample("pages/js/string-trim.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>str</var>.trim()</pre>
+    str.trim()
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une nouvelle chaîne de caractères dérivant de la chaîne appelante pour laquelle les blancs ont été retirés aux deux extrémités de la chaîne.</p>
+Une nouvelle chaîne de caractères dérivant de la chaîne appelante pour laquelle les blancs ont été retirés aux deux extrémités de la chaîne.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La méthode <code>trim()</code> renvoie la chaîne sans blanc au début et à la fin. La méthode <code>trim()</code> n'affecte pas la valeur de la chaîne courante.</p>
+La méthode `trim()` renvoie la chaîne sans blanc au début et à la fin. La méthode `trim()` n'affecte pas la valeur de la chaîne courante.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<p>L'exemple qui suit affiche la chaîne <code>'toto'</code> :</p>
+L'exemple qui suit affiche la chaîne `'toto'` :
 
-<pre class="brush: js">var chaîneOriginale = '   toto  ';
+```js
+var chaîneOriginale = '   toto  ';
 console.log(chaîneOriginale.trim()); // 'toto'
 
 // Un autre exemple de .trim() qui enlève les espaces juste d'un côté
 
 var chaîneOriginale = 'toto    ';
 console.log(chaîneOriginale.trim()); // 'toto'
-</pre>
+```
 
-<h2 id="Prothèse_d'émulation_(polyfill)">Prothèse d'émulation (<em>polyfill</em>)</h2>
+## Prothèse d'émulation (_polyfill_)
 
-<p>Si l'environnement utilisé ne possède pas cette méthode, il est possible de l'émuler avec le fragment de code suivant :</p>
+Si l'environnement utilisé ne possède pas cette méthode, il est possible de l'émuler avec le fragment de code suivant :
 
-<pre class="brush: js">if (!String.prototype.trim) {
+```js
+if (!String.prototype.trim) {
   String.prototype.trim = function () {
     return this.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, '');
   };
 }
-</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('ES5.1', '#sec-15.5.4.20', 'String.prototype.trim')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td>Définition initiale. Implémentée avec JavaScript 1.8.1.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-string.prototype.trim', 'String.prototype.trim')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-string.prototype.trim', 'String.prototype.trim')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.String.trim")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("String.prototype.trimStart()")}}</li>
- <li>{{jsxref("String.prototype.trimEnd()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                            | État                         | Commentaires                                            |
+| -------------------------------------------------------------------------------------------------------- | ---------------------------- | ------------------------------------------------------- |
+| {{SpecName('ES5.1', '#sec-15.5.4.20', 'String.prototype.trim')}}                     | {{Spec2('ES5.1')}}     | Définition initiale. Implémentée avec JavaScript 1.8.1. |
+| {{SpecName('ES6', '#sec-string.prototype.trim', 'String.prototype.trim')}}     | {{Spec2('ES6')}}         |                                                         |
+| {{SpecName('ESDraft', '#sec-string.prototype.trim', 'String.prototype.trim')}} | {{Spec2('ESDraft')}} |                                                         |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.String.trim")}}
+
+## Voir aussi
+
+- {{jsxref("String.prototype.trimStart()")}}
+- {{jsxref("String.prototype.trimEnd()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/string/trimend/index.md b/files/fr/web/javascript/reference/global_objects/string/trimend/index.md
index 3f3ea377c8..ded81deeb9 100644
--- a/files/fr/web/javascript/reference/global_objects/string/trimend/index.md
+++ b/files/fr/web/javascript/reference/global_objects/string/trimend/index.md
@@ -10,70 +10,58 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/String/trimEnd
 original_slug: Web/JavaScript/Reference/Objets_globaux/String/trimEnd
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>trimEnd()</strong></code> permet de retirer les blancs situés à la fin d'une chaîne de caractères. <code>trimRight()</code> est un synonyme pour cette méthode.</p>
+La méthode **`trimEnd()`** permet de retirer les blancs situés à la fin d'une chaîne de caractères. `trimRight()` est un synonyme pour cette méthode.
 
-<div>{{EmbedInteractiveExample("pages/js/string-trimend.html")}}</div>
+{{EmbedInteractiveExample("pages/js/string-trimend.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>str</var>.trimEnd();
-str.trimRight();</pre>
+    str.trimEnd();
+    str.trimRight();
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une nouvelle chaîne de caractères basée sur la chaîne appelante et dont les blancs en fin de chaîne ont été supprimés.</p>
+Une nouvelle chaîne de caractères basée sur la chaîne appelante et dont les blancs en fin de chaîne ont été supprimés.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La méthode <code>trimEnd()</code> renvoie la chaîne de caractères sans les blancs présents à partir de la droite de la chaîne. <code>trimEnd()</code> ne modifie pas la chaîne elle-même.</p>
+La méthode `trimEnd()` renvoie la chaîne de caractères sans les blancs présents à partir de la droite de la chaîne. `trimEnd()` ne modifie pas la chaîne elle-même.
 
-<h3 id="Synonyme">Synonyme</h3>
+### Synonyme
 
-<p>Pour des raisons de cohérence avec les méthodes existantes comme {{jsxref("String.prototype.padEnd")}}, le nom standard de cette méthode est <code>trimEnd</code>. Toutefois, à des fins de compatibilité web, <code>trimRight</code> est un synonyme de <code>trimEnd</code>. Pour certains moteurs JavaScript, on pourra donc avoir :</p>
+Pour des raisons de cohérence avec les méthodes existantes comme {{jsxref("String.prototype.padEnd")}}, le nom standard de cette méthode est `trimEnd`. Toutefois, à des fins de compatibilité web, `trimRight` est un synonyme de `trimEnd`. Pour certains moteurs JavaScript, on pourra donc avoir :
 
-<pre class="brush: js">String.prototype.trimRight.name === "trimEnd";</pre>
+```js
+String.prototype.trimRight.name === "trimEnd";
+```
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<p>L'exemple qui suit illustre comment afficher la chaîne "   toto":</p>
+L'exemple qui suit illustre comment afficher la chaîne "   toto":
 
-<pre class="brush:js">var str = "   toto  ";
+```js
+var str = "   toto  ";
 
 console.log(str.length); // 9
 
 str = str.trimEnd();
 console.log(str.length); // 7
 console.log(str);        // "   toto"
-</pre>
-
-<h2 id="Spécifications">Spécifications</h2>
-
-<table class="standard-table">
- <thead>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">État</th>
-   <th scope="col">Commentaires</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td>Proposition pour <code><a href="https://github.com/tc39/proposal-string-left-right-trim/#stringprototypetrimstart--stringprototypetrimend">String.prototype.{trimStart,trimEnd}</a></code></td>
-   <td>Brouillon de niveau 4</td>
-   <td>Attendu pour ES2019</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.String.trimEnd")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("String.prototype.trim()")}}</li>
- <li>{{jsxref("String.prototype.trimStart()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                                                                        | État                  | Commentaires        |
+| -------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------- | ------------------- |
+| Proposition pour [`String.prototype.{trimStart,trimEnd}`](https://github.com/tc39/proposal-string-left-right-trim/#stringprototypetrimstart--stringprototypetrimend) | Brouillon de niveau 4 | Attendu pour ES2019 |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.String.trimEnd")}}
+
+## Voir aussi
+
+- {{jsxref("String.prototype.trim()")}}
+- {{jsxref("String.prototype.trimStart()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/string/trimstart/index.md b/files/fr/web/javascript/reference/global_objects/string/trimstart/index.md
index fb06eafc08..1e22e0a695 100644
--- a/files/fr/web/javascript/reference/global_objects/string/trimstart/index.md
+++ b/files/fr/web/javascript/reference/global_objects/string/trimstart/index.md
@@ -10,70 +10,58 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/String/trimStart
 original_slug: Web/JavaScript/Reference/Objets_globaux/String/trimStart
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>trimStart()</strong></code> permet de retirer les blancs au début de la chaîne de caractères. <code>trimLeft()</code> est un synonyme pour cette méthode.</p>
+La méthode **`trimStart()`** permet de retirer les blancs au début de la chaîne de caractères. `trimLeft()` est un synonyme pour cette méthode.
 
-<div>{{EmbedInteractiveExample("pages/js/string-trimstart.html")}}</div>
+{{EmbedInteractiveExample("pages/js/string-trimstart.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>str</var>.trimStart();
-<var>str</var>.trimLeft();</pre>
+    str.trimStart();
+    str.trimLeft();
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une nouvelle chaîne de caractères dérivant de la chaîne appelante pour laquelle les blancs en début de chaîne ont été retirés.</p>
+Une nouvelle chaîne de caractères dérivant de la chaîne appelante pour laquelle les blancs en début de chaîne ont été retirés.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La méthode <code>trimStart()</code> renvoie la chaîne de caractères dont les blancs à gauche ont été retirés. <code>trimStart</code> ne modifie pas la chaîne elle-même.</p>
+La méthode `trimStart()` renvoie la chaîne de caractères dont les blancs à gauche ont été retirés. `trimStart` ne modifie pas la chaîne elle-même.
 
-<h3 id="Synonyme">Synonyme</h3>
+### Synonyme
 
-<p>Pour des raisons de cohérences avec les méthodes préexistantes (telles que {{jsxref("String.prototype.padStart")}}), le nom standard de cette méthode est <code>trimStart</code>. Toutefois, à des fins de compatibilité web, le nom <code>trimLeft</code> sera gardé comme un synonyme. Pour certains moteurs JavaScript, on pourra donc avoir :</p>
+Pour des raisons de cohérences avec les méthodes préexistantes (telles que {{jsxref("String.prototype.padStart")}}), le nom standard de cette méthode est `trimStart`. Toutefois, à des fins de compatibilité web, le nom `trimLeft` sera gardé comme un synonyme. Pour certains moteurs JavaScript, on pourra donc avoir :
 
-<pre class="brush: js">String.prototype.trimLeft.name === "trimStart";</pre>
+```js
+String.prototype.trimLeft.name === "trimStart";
+```
 
-<h2 id="Exemple">Exemple</h2>
+## Exemple
 
-<p>L'exemple qui suit illustre comment afficher la chaîne de caractères <code>"toto  "</code> en minuscules :</p>
+L'exemple qui suit illustre comment afficher la chaîne de caractères `"toto "` en minuscules :
 
-<pre class="brush:js">var str = "   toto  ";
+```js
+var str = "   toto  ";
 
 console.log(str.length); // 8
 
 str = str.trimStart();
 console.log(str.length); // 5
 console.log(str);        // "toto  "
-</pre>
-
-<h2 id="Spécifications">Spécifications</h2>
-
-<table class="standard-table">
- <thead>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">État</th>
-   <th scope="col">Commentaires</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td>Proposition pour <code><a href="https://github.com/tc39/proposal-string-left-right-trim/#stringprototypetrimstart--stringprototypetrimend">String.prototype.{trimStart,trimEnd}</a></code></td>
-   <td>Brouillon de niveau 4</td>
-   <td>Attendu pour ES2019</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.String.trimStart")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("String.prototype.trim()")}}</li>
- <li>{{jsxref("String.prototype.trimEnd()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                                                                        | État                  | Commentaires        |
+| -------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------- | ------------------- |
+| Proposition pour [`String.prototype.{trimStart,trimEnd}`](https://github.com/tc39/proposal-string-left-right-trim/#stringprototypetrimstart--stringprototypetrimend) | Brouillon de niveau 4 | Attendu pour ES2019 |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.String.trimStart")}}
+
+## Voir aussi
+
+- {{jsxref("String.prototype.trim()")}}
+- {{jsxref("String.prototype.trimEnd()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/string/valueof/index.md b/files/fr/web/javascript/reference/global_objects/string/valueof/index.md
index edacaf0f0c..e1ba2b7fd6 100644
--- a/files/fr/web/javascript/reference/global_objects/string/valueof/index.md
+++ b/files/fr/web/javascript/reference/global_objects/string/valueof/index.md
@@ -10,71 +10,47 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/String/valueOf
 original_slug: Web/JavaScript/Reference/Objets_globaux/String/valueOf
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>valueOf()</strong></code> renvoie la valeur primitive de l'objet {{jsxref("String")}}.</p>
+La méthode **`valueOf()`** renvoie la valeur primitive de l'objet {{jsxref("String")}}.
 
-<div>{{EmbedInteractiveExample("pages/js/string-valueof.html")}}</div>
+{{EmbedInteractiveExample("pages/js/string-valueof.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>str</var>.valueOf()</pre>
+    str.valueOf()
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une chaîne de caractères qui représente la valeur primitive d'un objet {{jsxref("String")}}.</p>
+Une chaîne de caractères qui représente la valeur primitive d'un objet {{jsxref("String")}}.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La méthode <code>valueOf()</code> de <code>String</code> renvoie la valeur primitive de l'objet <code>String</code> sous la forme d'une chaine de caractères. Cette valeur est équivalente à {{jsxref("String.prototype.toString()")}}.</p>
+La méthode `valueOf()` de `String` renvoie la valeur primitive de l'objet `String` sous la forme d'une chaine de caractères. Cette valeur est équivalente à {{jsxref("String.prototype.toString()")}}.
 
-<p>Cette méthode est généralement appelée en interne par JavaScript et non explicitement dans du code.</p>
+Cette méthode est généralement appelée en interne par JavaScript et non explicitement dans du code.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<pre class="brush: js">var x = new String("Coucou monde");
+```js
+var x = new String("Coucou monde");
 console.log(x.valueOf()); // affiche "Coucou monde"
-</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('ES1')}}</td>
-   <td>{{Spec2('ES1')}}</td>
-   <td>Définition initiale. Implémentée avec JavaScript 1.1.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.5.4.3', 'String.prototype.valueOf')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-string.prototype.valueof', 'String.prototype.valueOf')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-string.prototype.valueof', 'String.prototype.valueOf')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.String.valueOf")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("String.prototype.toString()")}}</li>
- <li>{{jsxref("Object.prototype.valueOf()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                    | État                         | Commentaires                                          |
+| ---------------------------------------------------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- |
+| {{SpecName('ES1')}}                                                                                         | {{Spec2('ES1')}}         | Définition initiale. Implémentée avec JavaScript 1.1. |
+| {{SpecName('ES5.1', '#sec-15.5.4.3', 'String.prototype.valueOf')}}                         | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-string.prototype.valueof', 'String.prototype.valueOf')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-string.prototype.valueof', 'String.prototype.valueOf')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.String.valueOf")}}
+
+## Voir aussi
+
+- {{jsxref("String.prototype.toString()")}}
+- {{jsxref("Object.prototype.valueOf()")}}