convert content to md

1 files changed, 147 insertions, 134 deletions

diff --git a/files/fr/web/javascript/reference/iteration_protocols/index.md b/files/fr/web/javascript/reference/iteration_protocols/index.md
index 6e1b27bbae..a6e2b15f68 100644
--- a/files/fr/web/javascript/reference/iteration_protocols/index.md
+++ b/files/fr/web/javascript/reference/iteration_protocols/index.md
@@ -10,89 +10,106 @@ tags:
 translation_of: Web/JavaScript/Reference/Iteration_protocols
 original_slug: Web/JavaScript/Reference/Les_protocoles_iteration
 ---
-<div>{{jsSidebar("More")}}</div>
+{{jsSidebar("More")}}
 
-<p>Un des ajouts à ECMAScript 2015 (ES6) n'est ni une nouvelle syntaxe ni un nouvel objet natif mais des protocoles. Ces protocoles peuvent être implémentés par n'importe quel objet qui respecte certaines conventions.</p>
+Un des ajouts à ECMAScript 2015 (ES6) n'est ni une nouvelle syntaxe ni un nouvel objet natif mais des protocoles. Ces protocoles peuvent être implémentés par n'importe quel objet qui respecte certaines conventions.
 
-<p>Il existe deux protocoles concernant l'itération : <a href="#itérable">le protocole « itérable »</a> et <a href="#itérateur">le protocole « itérateur »</a>.</p>
+Il existe deux protocoles concernant l'itération : [le protocole « itérable »](#itérable) et [le protocole « itérateur »](#itérateur).
 
-<h2 id="Le_protocole_«_itérable_»">Le protocole « itérable »</h2>
+## Le protocole « itérable »
 
-<p>Le protocole «<strong> itérable</strong> » permet aux objets JavaScript de définir ou de personnaliser leur comportement lors d'une itération, par exemple la façon dont les valeurs seront parcourues avec une boucle {{jsxref("Instructions/for...of", "for..of")}}. Certains types natifs tels que {{jsxref("Array")}} ou {{jsxref("Map")}} possèdent un comportement itératif par défaut, d'autres types, comme {{jsxref("Object")}} n'ont pas ce type de comportement.</p>
+Le protocole « **itérable** » permet aux objets JavaScript de définir ou de personnaliser leur comportement lors d'une itération, par exemple la façon dont les valeurs seront parcourues avec une boucle {{jsxref("Instructions/for...of", "for..of")}}. Certains types natifs tels que {{jsxref("Array")}} ou {{jsxref("Map")}} possèdent un comportement itératif par défaut, d'autres types, comme {{jsxref("Object")}} n'ont pas ce type de comportement.
 
-<p>Afin d'être <strong>itérable</strong>, un objet doit implémenter la méthode <code><strong>@@iterator</strong></code>, cela signifie que l'objet (ou un des objets de <a href="/fr/docs/Web/JavaScript/Guide/Inheritance_and_the_prototype_chain">sa chaîne de prototypes</a>) doit avoir une propriété avec une clé <strong><code>@@iterator</code></strong> qui est accessible via {{jsxref("Symbol.iterator")}} :</p>
+Afin d'être **itérable**, un objet doit implémenter la méthode **`@@iterator`**, cela signifie que l'objet (ou un des objets de [sa chaîne de prototypes](/fr/docs/Web/JavaScript/Guide/Inheritance_and_the_prototype_chain)) doit avoir une propriété avec une clé **`@@iterator`** qui est accessible via {{jsxref("Symbol.iterator")}} :
 
-<table class="standard-table">
- <thead>
-  <tr>
-   <th scope="col">Propriété</th>
-   <th scope="col">Valeur</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td><code>[Symbol.iterator]</code></td>
-   <td>Une fonction sans argument qui renvoie un objet conforme au <a href="#itérateur">protocole itérateur</a>.</td>
-  </tr>
- </tbody>
-</table>
+| Propriété           | Valeur                                                                                         |
+| ------------------- | ---------------------------------------------------------------------------------------------- |
+| `[Symbol.iterator]` | Une fonction sans argument qui renvoie un objet conforme au [protocole itérateur](#itérateur). |
 
-<p>Lorsqu'on doit itérer sur un objet (ex. : au début d'une boucle <code>for..of</code>), sa méthode <code>@@iterator</code> est appelée sans argument et l'<strong>itérateur</strong> qui est renvoyé est utilisé afin d'obtenir les valeurs sur lesquelles itérer.</p>
+Lorsqu'on doit itérer sur un objet (ex. : au début d'une boucle `for..of`), sa méthode `@@iterator` est appelée sans argument et l'**itérateur** qui est renvoyé est utilisé afin d'obtenir les valeurs sur lesquelles itérer.
 
-<h2 id="Le_protocole_«_itérateur_»">Le protocole « itérateur »</h2>
+## Le protocole « itérateur »
 
-<p>Le protocole « <strong>itérateur</strong> » définit une façon standard pour produire une suite de valeurs (finie ou infinie) ainsi qu'une valeur de retour lorsque toutes les valeurs ont été générées.</p>
+Le protocole « **itérateur** » définit une façon standard pour produire une suite de valeurs (finie ou infinie) ainsi qu'une valeur de retour lorsque toutes les valeurs ont été générées.
 
-<p>Un objet est considéré comme un itérateur lorsqu'il implémente une méthode <code><strong>next()</strong></code> avec la sémantique suivante :</p>
+Un objet est considéré comme un itérateur lorsqu'il implémente une méthode **`next()`** avec la sémantique suivante :
 
 <table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Propriété</th>
-   <th scope="col">Valeur</th>
-  </tr>
-  <tr>
-   <td><code>next</code></td>
-   <td>
-    <p>Une fonction sans argument qui renvoie un objet qui possède au moins deux propriétés :</p>
-
-    <ul>
-     <li><code>done</code> (un booléen)
-
-      <ul>
-       <li>Qui vaut <code>true</code> lorsque l'itérateur a fini la suite. Dans ce cas, la propriété <code>value</code> sera facultative et permettra de spécifier la valeur de retour de l'itérateur. Les valeurs de retour sont détaillées <a href="https://www.2ality.com/2013/06/iterators-generators.html#generators-as-threads">ici</a>.</li>
-       <li>Qui vaut <code>false</code> lorsque l'itérateur a pu produire la prochaine valeur de la suite. Si on ne définit pas la propriété <code>done</code>, on aura ce comportement par défaut.</li>
-      </ul>
-     </li>
-     <li><code>value</code> : n'importe quelle valeur JavaScript, renvoyée par l'itérateur. Cette propriété peut être absente lorsque <code>done</code> vaut <code>true</code>.</li>
-    </ul>
-
-    <p>La méthode <code>next</code> doit toujours renvoyer un objet contenant les propriétés <code>done</code> et <code>value</code>. Si c'est une valeur primitive qui est renvoyée (ex. <code>false</code> ou <code>undefined</code>), une exception {{jsxref("TypeError")}} sera levée ("iterator.next() returned a non-object value").</p>
-   </td>
-  </tr>
- </tbody>
+  <tbody>
+    <tr>
+      <th scope="col">Propriété</th>
+      <th scope="col">Valeur</th>
+    </tr>
+    <tr>
+      <td><code>next</code></td>
+      <td>
+        <p>
+          Une fonction sans argument qui renvoie un objet qui possède au moins
+          deux propriétés :
+        </p>
+        <ul>
+          <li>
+            <code>done</code> (un booléen)
+            <ul>
+              <li>
+                Qui vaut <code>true</code> lorsque l'itérateur a fini la suite.
+                Dans ce cas, la propriété <code>value</code> sera facultative et
+                permettra de spécifier la valeur de retour de l'itérateur. Les
+                valeurs de retour sont détaillées
+                <a
+                  href="https://www.2ality.com/2013/06/iterators-generators.html#generators-as-threads"
+                  >ici</a
+                >.
+              </li>
+              <li>
+                Qui vaut <code>false</code> lorsque l'itérateur a pu produire la
+                prochaine valeur de la suite. Si on ne définit pas la propriété
+                <code>done</code>, on aura ce comportement par défaut.
+              </li>
+            </ul>
+          </li>
+          <li>
+            <code>value</code> : n'importe quelle valeur JavaScript, renvoyée
+            par l'itérateur. Cette propriété peut être absente lorsque
+            <code>done</code> vaut <code>true</code>.
+          </li>
+        </ul>
+        <p>
+          La méthode <code>next</code> doit toujours renvoyer un objet contenant
+          les propriétés <code>done</code> et <code>value</code>. Si c'est une
+          valeur primitive qui est renvoyée (ex. <code>false</code> ou
+          <code>undefined</code>), une exception
+          {{jsxref("TypeError")}} sera levée ("iterator.next() returned
+          a non-object value").
+        </p>
+      </td>
+    </tr>
+  </tbody>
 </table>
 
-<p>Certains itérateurs sont des itérables :</p>
+Certains itérateurs sont des itérables :
 
-<pre class="brush: js">var unTableau = [1, 5, 7];
+```js
+var unTableau = [1, 5, 7];
 var élémentsDuTableau = unTableau.entries();
 
 élémentsDuTableau.toString();    // "[object Array Iterator]"
 élémentsDuTableau === élémentsDuTableau[Symbol.iterator]();    // true
-</pre>
+```
 
-<h2 id="Exemples_d'utilisation_des_protocoles_d'itération">Exemples d'utilisation des protocoles d'itération</h2>
+## Exemples d'utilisation des protocoles d'itération
 
-<p>Une {{jsxref("String")}} est un exemple d'objet natif itérable :</p>
+Une {{jsxref("String")}} est un exemple d'objet natif itérable :
 
-<pre class="brush: js">var uneChaîne = "coucou";
+```js
+var uneChaîne = "coucou";
 typeof uneChaîne[Symbol.iterator];           // "function"
-</pre>
+```
 
-<p><a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/String/@@iterator">L'itérateur par défaut d'un objet <code>String</code></a> renverra les caractères de la chaîne les uns à la suite des autres :</p>
+[L'itérateur par défaut d'un objet `String`](/fr/docs/Web/JavaScript/Reference/Objets_globaux/String/@@iterator) renverra les caractères de la chaîne les uns à la suite des autres :
 
-<pre class="brush: js">var itérateur = uneChaîne[Symbol.iterator]();
+```js
+var itérateur = uneChaîne[Symbol.iterator]();
 itérateur + "";     // "[object String Iterator]"
 
 itérateur.next();  // { value: "c", done: false }
@@ -101,15 +118,19 @@ itérateur.next();  // { value: "u", done: false }
 itérateur.next();  // { value: "c", done: false }
 itérateur.next();  // { value: "o", done: false }
 itérateur.next();  // { value: "u", done: false }
-itérateur.next();  // { value: undefined, done: true }</pre>
+itérateur.next();  // { value: undefined, done: true }
+```
 
-<p>Certains éléments natifs du langage, tels que <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateur_de_décomposition">la syntaxe de décomposition</a>, utilisent ce même protocole :</p>
+Certains éléments natifs du langage, tels que [la syntaxe de décomposition](/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateur_de_décomposition), utilisent ce même protocole :
 
-<pre class="brush: js">[...uneChaîne];   // ["c", "o", "u", "c", "o", "u"]</pre>
+```js
+[...uneChaîne];   // ["c", "o", "u", "c", "o", "u"]
+```
 
-<p>Il est possible de redéfinir le comportement par défaut en définissant soi-même le symbole <code>@@iterator</code> :</p>
+Il est possible de redéfinir le comportement par défaut en définissant soi-même le symbole `@@iterator` :
 
-<pre class="brush: js">var uneChaîne = new String("yo");          // on construit un objet String explicitement afin d'éviter la conversion automatique
+```js
+var uneChaîne = new String("yo");          // on construit un objet String explicitement afin d'éviter la conversion automatique
 
 uneChaîne[Symbol.iterator] = function() {
   return { // l'objet itérateur qui renvoie un seul élément, la chaîne "bop"
@@ -124,38 +145,41 @@ uneChaîne[Symbol.iterator] = function() {
     _first: true
   };
 };
-</pre>
+```
 
-<p>On notera que redéfinir le symbole <code>@@iterator</code> affecte également le comportement des éléments du langage qui utilisent le protocole :</p>
+On notera que redéfinir le symbole `@@iterator` affecte également le comportement des éléments du langage qui utilisent le protocole :
 
-<pre class="brush: js">[...uneChaîne];  // ["bop"]
+```js
+[...uneChaîne];  // ["bop"]
 uneChaîne + "";  // "yo"
-</pre>
+```
 
-<h2 id="Exemples_d'itérables">Exemples d'itérables</h2>
+## Exemples d'itérables
 
-<h3 id="Les_itérables_natifs">Les itérables natifs</h3>
+### Les itérables natifs
 
-<p>{{jsxref("String")}}, {{jsxref("Array")}}, {{jsxref("TypedArray")}}, {{jsxref("Map")}} et {{jsxref("Set")}} sont des itérables natifs car leurs prototypes possèdent une méthode <code>@@iterator</code>.</p>
+{{jsxref("String")}}, {{jsxref("Array")}}, {{jsxref("TypedArray")}}, {{jsxref("Map")}} et {{jsxref("Set")}} sont des itérables natifs car leurs prototypes possèdent une méthode `@@iterator`.
 
-<h3 id="Les_itérables_définis_par_l'utilisateur">Les itérables définis par l'utilisateur</h3>
+### Les itérables définis par l'utilisateur
 
-<p>Il est possible de construire un itérable dans un script de la façon suivante :</p>
+Il est possible de construire un itérable dans un script de la façon suivante :
 
-<pre class="brush: js">var monItérable = {};
+```js
+var monItérable = {};
 monItérable[Symbol.iterator] = function* () {
     yield 1;
     yield 2;
     yield 3;
 };
 [...monItérable]; // [1, 2, 3]
-</pre>
+```
 
-<h3 id="Les_API_natives_utilisant_des_itérables">Les API natives utilisant des itérables</h3>
+### Les API natives utilisant des itérables
 
-<p>Plusieurs API utilisent les itérables, par exemple : {{jsxref("Map", "Map([itérable])")}}, {{jsxref("WeakMap", "WeakMap([itérable])")}}, {{jsxref("Set", "Set([itérable])")}} et {{jsxref("WeakSet", "WeakSet([itérable])")}} :</p>
+Plusieurs API utilisent les itérables, par exemple : {{jsxref("Map", "Map([itérable])")}}, {{jsxref("WeakMap", "WeakMap([itérable])")}}, {{jsxref("Set", "Set([itérable])")}} et {{jsxref("WeakSet", "WeakSet([itérable])")}} :
 
-<pre class="brush: js">var monObjet = {};
+```js
+var monObjet = {};
 new Map([[1,"a"],[2,"b"],[3,"c"]]).get(2);  // "b"
 new WeakMap([[{},"a"],[monObjet,"b"],[{},"c"]]).get(monObjet); // "b"
 new Set([1, 2, 3]).has(3);    // true
@@ -165,15 +189,16 @@ new WeakSet(function*() {
     yield monObjet;
     yield {};
 }()).has(monObjet);           // true
-</pre>
+```
 
-<p>ainsi que {{jsxref("Promise.all", "Promise.all(itérable)")}}, {{jsxref("Promise.race", "Promise.race(itérable)")}}, {{jsxref("Array.from", "Array.from()")}}</p>
+ainsi que {{jsxref("Promise.all", "Promise.all(itérable)")}}, {{jsxref("Promise.race", "Promise.race(itérable)")}}, {{jsxref("Array.from", "Array.from()")}}
 
-<h3 id="Les_éléments_de_syntaxe_utilisant_des_itérables">Les éléments de syntaxe utilisant des itérables</h3>
+### Les éléments de syntaxe utilisant des itérables
 
-<p>Certains éléments du langage utilisent des itérables, par exemple : <code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/for...of">for..of</a></code>, <a href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateur_de_d%C3%A9composition">la syntaxe de décomposition</a>, <a href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/yield*">yield*</a>, <a href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Affecter_par_d%C3%A9composition">l'affectation par décomposition</a> :</p>
+Certains éléments du langage utilisent des itérables, par exemple : [`for..of`](/fr/docs/Web/JavaScript/Reference/Instructions/for...of), [la syntaxe de décomposition](/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateur_de_d%C3%A9composition), [yield\*](/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/yield*), [l'affectation par décomposition](/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Affecter_par_d%C3%A9composition) :
 
-<pre class="brush: js">for(let value of ["a", "b", "c"]){
+```js
+for(let value of ["a", "b", "c"]){
     console.log(value);
 }
 // "a"
@@ -190,28 +215,29 @@ gen().next(); // { value:"a", done:false }
 
 [a, b, c] = new Set(["a", "b", "c"]);
 a; // "a"
+```
 
-</pre>
-
-<h3 id="Itérables_mal-formés">Itérables mal-formés</h3>
+### Itérables mal-formés
 
-<p>Si une méthode <code>@@iterator</code> d'un objet itérable ne renvoie pas d'objet itérateur, on dira que cet objet est un itérable mal-formé. Utiliser de tels itérables peut provoquer des exceptions lors de l'exécution ou un comportement erratique :</p>
+Si une méthode `@@iterator` d'un objet itérable ne renvoie pas d'objet itérateur, on dira que cet objet est un itérable mal-formé. Utiliser de tels itérables peut provoquer des exceptions lors de l'exécution ou un comportement erratique :
 
-<pre class="brush: js">var itérableMalFormé = {}
-itérableMalFormé[Symbol.iterator] = () =&gt; 1
+```js
+var itérableMalFormé = {}
+itérableMalFormé[Symbol.iterator] = () => 1
 [...itérableMalFormé] // TypeError: [] is not a function
-</pre>
+```
 
-<h2 id="Exemples_d'itérateurs">Exemples d'itérateurs</h2>
+## Exemples d'itérateurs
 
-<h3 id="Un_itérateur_simple">Un itérateur simple</h3>
+### Un itérateur simple
 
-<pre class="brush: js">function créerItérateur(tableau){
+```js
+function créerItérateur(tableau){
     var nextIndex = 0;
 
     return {
        next: function(){
-           return nextIndex &lt; tableau.length ?
+           return nextIndex < tableau.length ?
                {value: tableau[nextIndex++], done: false} :
                {done: true};
        }
@@ -223,11 +249,12 @@ var it = créerItérateur(['yo', 'ya']);
 console.log(it.next().value); // 'yo'
 console.log(it.next().value); // 'ya'
 console.log(it.next().done);  // true
-</pre>
+```
 
-<h3 id="Un_itérateur_infini">Un itérateur infini</h3>
+### Un itérateur infini
 
-<pre class="brush: js">function créateurID(){
+```js
+function créateurID(){
     var index = 0;
 
     return {
@@ -243,14 +270,15 @@ console.log(it.next().value); // '0'
 console.log(it.next().value); // '1'
 console.log(it.next().value); // '2'
 // ...
-</pre>
+```
 
-<h3 id="Avec_un_générateur">Avec un générateur</h3>
+### Avec un générateur
 
-<pre class="brush: js">function* créerUnGénérateurSimple(tableau){
+```js
+function* créerUnGénérateurSimple(tableau){
     var nextIndex = 0;
 
-    while(nextIndex &lt; tableau.length){
+    while(nextIndex < tableau.length){
         yield tableau[nextIndex++];
     }
 }
@@ -272,11 +300,12 @@ var gen = créateurID();
 console.log(gen.next().value); // '0'
 console.log(gen.next().value); // '1'
 console.log(gen.next().value); // '2'
-</pre>
+```
 
-<h3 id="Avec_une_classe_ECMAScript_2015_(ES6)">Avec une classe ECMAScript 2015 (ES6)</h3>
+### Avec une classe ECMAScript 2015 (ES6)
 
-<pre class="brush: js">class ClasseSimple {
+```js
+class ClasseSimple {
   constructor(data) {
     this.index = 0;
     this.data = data;
@@ -284,8 +313,8 @@ console.log(gen.next().value); // '2'
 
   [Symbol.iterator]() {
     return {
-      next: () =&gt; {
-        if (this.index &lt; this.data.length) {
+      next: () => {
+        if (this.index < this.data.length) {
           return {value: this.data[this.index++], done: false};
         } else {
           this.index = 0;
@@ -304,13 +333,14 @@ const simple = new ClasseSimple([1,2,3,4,5]);
 for (const val of simple) {
   console.log(val);  // '1' '2' '3' '4' '5'
 }
-</pre>
+```
 
-<h2 id="Un_générateur_est-il_un_itérateur_ou_un_itérable">Un générateur est-il un itérateur ou un itérable ?</h2>
+## Un générateur est-il un itérateur ou un itérable ?
 
-<p>Les deux réponses sont correctes :</p>
+Les deux réponses sont correctes :
 
-<pre class="brush: js">var unObjetGénérateur = function*(){
+```js
+var unObjetGénérateur = function*(){
     yield 1;
     yield 2;
     yield 3;
@@ -323,32 +353,15 @@ unObjetGénérateur[Symbol.iterator]() === unObjetGénérateur
 // vrai car la méthode @@iterator renvoie elle-même, un itérateur, c'est donc un itérable bien formé
 [...unObjetGénérateur]
 // [1, 2, 3]
-</pre>
+```
 
-<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-iteration', 'Iteration')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-iteration', 'Iteration')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
+| Spécification                                                            | État                         | Commentaires        |
+| ------------------------------------------------------------------------ | ---------------------------- | ------------------- |
+| {{SpecName('ES2015', '#sec-iteration', 'Iteration')}} | {{Spec2('ES2015')}}     | Définition initiale |
+| {{SpecName('ESDraft', '#sec-iteration', 'Iteration')}} | {{Spec2('ESDraft')}} |                     |
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>Pour plus d'informations sur les générateurs définis par ES2015, voir <a href="/fr/docs/Web/JavaScript/Reference/Instructions/function*">la page dédiée</a>.</li>
-</ul>
+- Pour plus d'informations sur les générateurs définis par ES2015, voir [la page dédiée](/fr/docs/Web/JavaScript/Reference/Instructions/function*).