convert content to md

1 files changed, 97 insertions, 119 deletions

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()")}}