From 844f5103992238c0c23203286dad16a466e89c97 Mon Sep 17 00:00:00 2001
From: julieng <julien.gattelier@gmail.com>
Date: Tue, 3 Aug 2021 08:03:09 +0200
Subject: move *.html to *.md

---
 .../global_objects/asyncfunction/index.html        | 118 ---------------------
 .../global_objects/asyncfunction/index.md          | 118 +++++++++++++++++++++
 2 files changed, 118 insertions(+), 118 deletions(-)
 delete mode 100644 files/fr/web/javascript/reference/global_objects/asyncfunction/index.html
 create mode 100644 files/fr/web/javascript/reference/global_objects/asyncfunction/index.md

(limited to 'files/fr/web/javascript/reference/global_objects/asyncfunction')

diff --git a/files/fr/web/javascript/reference/global_objects/asyncfunction/index.html b/files/fr/web/javascript/reference/global_objects/asyncfunction/index.html
deleted file mode 100644
index 778e94b924..0000000000
--- a/files/fr/web/javascript/reference/global_objects/asyncfunction/index.html
+++ /dev/null
@@ -1,118 +0,0 @@
----
-title: AsyncFunction
-slug: Web/JavaScript/Reference/Global_Objects/AsyncFunction
-tags:
-  - Constructeur
-  - Experimental
-  - JavaScript
-  - Reference
-translation_of: Web/JavaScript/Reference/Global_Objects/AsyncFunction
-original_slug: Web/JavaScript/Reference/Objets_globaux/AsyncFunction
----
-<div>{{JSRef}}</div>
-
-<p>Le constructeur <code><strong>Async</strong></code><strong><code>Function</code></strong> crée un nouvel objet pour {{jsxref("Instructions/async function", "une fonction asynchrone","",1)}}. En JavaScript, chaque fonction asynchrone est en fait un objet <code>AsyncFunction</code>.</p>
-
-<p>Attention, <code>AsyncFunction</code> n'est pas un objet global. On peut l'obtenir grâce au code suivant :</p>
-
-<pre class="brush: js">Object.getPrototypeOf(async function(){}).constructor
-</pre>
-
-<h2 id="Syntaxe">Syntaxe</h2>
-
-<pre class="syntaxbox">new AsyncFunction ([<var>arg1</var>[, <var>arg2</var>[, ...<var>argN</var>]],] <var>functionBody</var>)</pre>
-
-<h3 id="Paramètres">Paramètres</h3>
-
-<dl>
- <dt><code>arg1, arg2, ... arg<em>N</em></code></dt>
- <dd>Les noms des paramètres passés à la fonction. Chacun doit être une chaîne de caractères qui puisse être un identifiant JavaScript valide ou une liste de telles chaînes séparées par une virgule (ex. "<code>x</code>", "<code>laValeur</code>", ou "<code>a,b</code>").</dd>
- <dt><code>functionBody</code></dt>
- <dd>Une chaîne de caractères qui contient les instructions JavaScript définissant la définition de la fonction.</dd>
-</dl>
-
-<h2 id="Description">Description</h2>
-
-<p>Les objets des {{jsxref("Instructions/async_function", "fonctions asynchrones","",1)}} créés avec le constructeur <code>AsyncFunction</code> sont analysés lorsque la fonction est créée. C'est moins efficace que de déclarer une fonction asynchrone avec une {{jsxref("Instructions/async_function", "expression de fonction asynchrone")}} et de l'appeler depuis le code car ces fonctions sont analysées avec le reste du code.</p>
-
-<p>Tous les arguments passés à la fonction sont traités comme les noms des identifiants des paramètres de la fonction qui sera créée, dans l'ordre dans lequel ils sont passés.</p>
-
-<div class="note">
-<p><strong>Note :</strong> Les fonctions asynchrones créées avec le constructeur <code>AsyncFunction</code> ne créent pas de fermetutres dans leurs contextes de création. Elles sont toujours créées dans la portée globale. Lorsqu'on les exécute, ellee ne pourront accéder qu'à leurs variables locales et aux variables globales, pas à celles qui appartiennent à la portée dans laquelle <code>AsyncFunction</code> a été appelé. On aurait donc un comportement différent  si on appelait {{jsxref("Objets_globaux/eval", "eval")}} avec le code de l'expression de la fonction asynchrone.</p>
-</div>
-
-<p>Si on appelle <code>AsyncFunction</code> comme une fonction (c'est-à-dire sans <code>new</code>), cela aura le même effet que s'il est appelé comme un constructeur.</p>
-
-<h2 id="Propriétés">Propriétés</h2>
-
-<dl>
- <dt><code><strong>AsyncFunction.length</strong></code></dt>
- <dd>La propriété de longueur du constructeur <code>AsyncFunction</code> dont la valeur est 1.</dd>
- <dt>{{jsxref("AsyncFunction.prototype")}}</dt>
- <dd>Le prototype permet d'ajouter des propriétés à tous les objets représentant les fonctions asynchrones.</dd>
-</dl>
-
-<h2 id="Prototype_de_l'objet_AsyncFunction">Prototype de l'objet <code>AsyncFunction</code></h2>
-
-<h3 id="Propriétés_2">Propriétés</h3>
-
-<div>{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/AsyncFunction/prototype', 'Propriétés')}}</div>
-
-<h2 id="Instances_AsyncFunction">Instances <code>AsyncFunction</code></h2>
-
-<p>Les instances d'<code>AsyncFunction</code> héritent des méthodes et des propriétés de {{jsxref("AsyncFunction.prototype")}}. Comme avec les autres constructeurs, on peut changer l'objet prototype du constructeur afin de modifier l'ensemble des instances <code>AsyncFunction</code>.</p>
-
-<h2 id="Exemples">Exemples</h2>
-
-<h3 id="Créer_une_fonction_asynchrone_avec_un_constructeur_AsyncFunction">Créer une fonction asynchrone avec un constructeur <code>AsyncFunction</code></h3>
-
-<pre class="brush: js">function resolveAfter2Seconds(x) {
-  return new Promise(resolve =&gt; {
-    setTimeout(() =&gt; {
-      resolve(x);
-    }, 2000);
-  });
-}
-
-var AsyncFunction = Object.getPrototypeOf(async function(){}).constructor
-var a = new AsyncFunction("a",
-                          "b",
-                          "return await resolveAfter2Seconds(a) + await resolveAfter2Seconds(b);");
-a(10, 20).then(v =&gt; {
-  console.log(v); // affiche 30 après 4 secondes
-});
-</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-async-function-objects', 'AsyncFunction object')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td>Définition initiale dans ES2017.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.AsyncFunction")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>Instruction {{jsxref("Instructions/async_function", "async function")}}</li>
- <li>Expression {{jsxref("Opérateurs/async_function","async function")}}</li>
- <li>{{jsxref("Objets_globaux/Function", "Function")}}</li>
- <li>Instruction {{jsxref("Instructions/function", "function")}}</li>
- <li>Expression {{jsxref("Opérateurs/function", "function")}}</li>
- <li>{{jsxref("Fonctions", "Fonctions et portées des fonctions", "", 1)}}</li>
-</ul>
diff --git a/files/fr/web/javascript/reference/global_objects/asyncfunction/index.md b/files/fr/web/javascript/reference/global_objects/asyncfunction/index.md
new file mode 100644
index 0000000000..778e94b924
--- /dev/null
+++ b/files/fr/web/javascript/reference/global_objects/asyncfunction/index.md
@@ -0,0 +1,118 @@
+---
+title: AsyncFunction
+slug: Web/JavaScript/Reference/Global_Objects/AsyncFunction
+tags:
+  - Constructeur
+  - Experimental
+  - JavaScript
+  - Reference
+translation_of: Web/JavaScript/Reference/Global_Objects/AsyncFunction
+original_slug: Web/JavaScript/Reference/Objets_globaux/AsyncFunction
+---
+<div>{{JSRef}}</div>
+
+<p>Le constructeur <code><strong>Async</strong></code><strong><code>Function</code></strong> crée un nouvel objet pour {{jsxref("Instructions/async function", "une fonction asynchrone","",1)}}. En JavaScript, chaque fonction asynchrone est en fait un objet <code>AsyncFunction</code>.</p>
+
+<p>Attention, <code>AsyncFunction</code> n'est pas un objet global. On peut l'obtenir grâce au code suivant :</p>
+
+<pre class="brush: js">Object.getPrototypeOf(async function(){}).constructor
+</pre>
+
+<h2 id="Syntaxe">Syntaxe</h2>
+
+<pre class="syntaxbox">new AsyncFunction ([<var>arg1</var>[, <var>arg2</var>[, ...<var>argN</var>]],] <var>functionBody</var>)</pre>
+
+<h3 id="Paramètres">Paramètres</h3>
+
+<dl>
+ <dt><code>arg1, arg2, ... arg<em>N</em></code></dt>
+ <dd>Les noms des paramètres passés à la fonction. Chacun doit être une chaîne de caractères qui puisse être un identifiant JavaScript valide ou une liste de telles chaînes séparées par une virgule (ex. "<code>x</code>", "<code>laValeur</code>", ou "<code>a,b</code>").</dd>
+ <dt><code>functionBody</code></dt>
+ <dd>Une chaîne de caractères qui contient les instructions JavaScript définissant la définition de la fonction.</dd>
+</dl>
+
+<h2 id="Description">Description</h2>
+
+<p>Les objets des {{jsxref("Instructions/async_function", "fonctions asynchrones","",1)}} créés avec le constructeur <code>AsyncFunction</code> sont analysés lorsque la fonction est créée. C'est moins efficace que de déclarer une fonction asynchrone avec une {{jsxref("Instructions/async_function", "expression de fonction asynchrone")}} et de l'appeler depuis le code car ces fonctions sont analysées avec le reste du code.</p>
+
+<p>Tous les arguments passés à la fonction sont traités comme les noms des identifiants des paramètres de la fonction qui sera créée, dans l'ordre dans lequel ils sont passés.</p>
+
+<div class="note">
+<p><strong>Note :</strong> Les fonctions asynchrones créées avec le constructeur <code>AsyncFunction</code> ne créent pas de fermetutres dans leurs contextes de création. Elles sont toujours créées dans la portée globale. Lorsqu'on les exécute, ellee ne pourront accéder qu'à leurs variables locales et aux variables globales, pas à celles qui appartiennent à la portée dans laquelle <code>AsyncFunction</code> a été appelé. On aurait donc un comportement différent  si on appelait {{jsxref("Objets_globaux/eval", "eval")}} avec le code de l'expression de la fonction asynchrone.</p>
+</div>
+
+<p>Si on appelle <code>AsyncFunction</code> comme une fonction (c'est-à-dire sans <code>new</code>), cela aura le même effet que s'il est appelé comme un constructeur.</p>
+
+<h2 id="Propriétés">Propriétés</h2>
+
+<dl>
+ <dt><code><strong>AsyncFunction.length</strong></code></dt>
+ <dd>La propriété de longueur du constructeur <code>AsyncFunction</code> dont la valeur est 1.</dd>
+ <dt>{{jsxref("AsyncFunction.prototype")}}</dt>
+ <dd>Le prototype permet d'ajouter des propriétés à tous les objets représentant les fonctions asynchrones.</dd>
+</dl>
+
+<h2 id="Prototype_de_l'objet_AsyncFunction">Prototype de l'objet <code>AsyncFunction</code></h2>
+
+<h3 id="Propriétés_2">Propriétés</h3>
+
+<div>{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/AsyncFunction/prototype', 'Propriétés')}}</div>
+
+<h2 id="Instances_AsyncFunction">Instances <code>AsyncFunction</code></h2>
+
+<p>Les instances d'<code>AsyncFunction</code> héritent des méthodes et des propriétés de {{jsxref("AsyncFunction.prototype")}}. Comme avec les autres constructeurs, on peut changer l'objet prototype du constructeur afin de modifier l'ensemble des instances <code>AsyncFunction</code>.</p>
+
+<h2 id="Exemples">Exemples</h2>
+
+<h3 id="Créer_une_fonction_asynchrone_avec_un_constructeur_AsyncFunction">Créer une fonction asynchrone avec un constructeur <code>AsyncFunction</code></h3>
+
+<pre class="brush: js">function resolveAfter2Seconds(x) {
+  return new Promise(resolve =&gt; {
+    setTimeout(() =&gt; {
+      resolve(x);
+    }, 2000);
+  });
+}
+
+var AsyncFunction = Object.getPrototypeOf(async function(){}).constructor
+var a = new AsyncFunction("a",
+                          "b",
+                          "return await resolveAfter2Seconds(a) + await resolveAfter2Seconds(b);");
+a(10, 20).then(v =&gt; {
+  console.log(v); // affiche 30 après 4 secondes
+});
+</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-async-function-objects', 'AsyncFunction object')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td>Définition initiale dans ES2017.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+
+<p>{{Compat("javascript.builtins.AsyncFunction")}}</p>
+
+<h2 id="Voir_aussi">Voir aussi</h2>
+
+<ul>
+ <li>Instruction {{jsxref("Instructions/async_function", "async function")}}</li>
+ <li>Expression {{jsxref("Opérateurs/async_function","async function")}}</li>
+ <li>{{jsxref("Objets_globaux/Function", "Function")}}</li>
+ <li>Instruction {{jsxref("Instructions/function", "function")}}</li>
+ <li>Expression {{jsxref("Opérateurs/function", "function")}}</li>
+ <li>{{jsxref("Fonctions", "Fonctions et portées des fonctions", "", 1)}}</li>
+</ul>
-- 
cgit v1.2.3-54-g00ecf


From bf8e099b9c8b3c60d60b3712b4fc97b052c39887 Mon Sep 17 00:00:00 2001
From: julieng <julien.gattelier@gmail.com>
Date: Tue, 3 Aug 2021 08:03:23 +0200
Subject: convert content to md

---
 .../a_re-introduction_to_javascript/index.md       |  855 ++++++------
 files/fr/web/javascript/about_javascript/index.md  |   58 +-
 files/fr/web/javascript/closures/index.md          |  206 +--
 files/fr/web/javascript/data_structures/index.md   |  441 +++----
 .../index.md                                       |  650 ++++++----
 .../equality_comparisons_and_sameness/index.md     |  573 +++------
 files/fr/web/javascript/eventloop/index.md         |  131 +-
 .../guide/control_flow_and_error_handling/index.md |  346 ++---
 .../guide/details_of_the_object_model/index.md     |  586 +++++----
 .../guide/expressions_and_operators/index.md       | 1333 +++++++++----------
 files/fr/web/javascript/guide/functions/index.md   |  572 +++++----
 .../javascript/guide/grammar_and_types/index.md    |  715 +++++------
 files/fr/web/javascript/guide/index.md             |  289 ++---
 .../javascript/guide/indexed_collections/index.md  |  585 +++++----
 .../fr/web/javascript/guide/introduction/index.md  |  136 +-
 .../guide/iterators_and_generators/index.md        |  106 +-
 .../javascript/guide/keyed_collections/index.md    |  120 +-
 .../javascript/guide/loops_and_iteration/index.md  |  357 +++---
 .../web/javascript/guide/meta_programming/index.md |  568 ++++----
 files/fr/web/javascript/guide/modules/index.md     |  467 +++----
 .../javascript/guide/numbers_and_dates/index.md    |  468 +++----
 .../guide/regular_expressions/assertions/index.md  |  163 ++-
 .../regular_expressions/character_classes/index.md |  400 +++---
 .../regular_expressions/groups_and_ranges/index.md |  228 ++--
 .../javascript/guide/regular_expressions/index.md  | 1355 ++++++++++++--------
 .../guide/regular_expressions/quantifiers/index.md |  210 +--
 .../unicode_property_escapes/index.md              |  506 ++------
 .../web/javascript/guide/text_formatting/index.md  |  354 +++--
 .../web/javascript/guide/using_promises/index.md   |  295 +++--
 .../javascript/guide/working_with_objects/index.md |  360 +++---
 files/fr/web/javascript/index.md                   |  224 ++--
 .../inheritance_and_the_prototype_chain/index.md   |  438 ++++---
 .../javascript_technologies_overview/index.md      |   94 +-
 .../fr/web/javascript/language_resources/index.md  |  366 ++++--
 files/fr/web/javascript/memory_management/index.md |  142 +-
 files/fr/web/javascript/reference/about/index.md   |   62 +-
 .../reference/classes/constructor/index.md         |  103 +-
 .../javascript/reference/classes/extends/index.md  |  101 +-
 files/fr/web/javascript/reference/classes/index.md |  303 +++--
 .../classes/private_class_fields/index.md          |  133 +-
 .../reference/classes/public_class_fields/index.md |  188 +--
 .../javascript/reference/classes/static/index.md   |  104 +-
 .../deprecated_and_obsolete_features/index.md      |  384 +++---
 .../the_legacy_iterator_protocol/index.md          |   59 +-
 .../reference/errors/already_has_pragma/index.md   |   38 +-
 .../reference/errors/array_sort_argument/index.md  |   44 +-
 .../javascript/reference/errors/bad_octal/index.md |   46 +-
 .../javascript/reference/errors/bad_radix/index.md |   55 +-
 .../reference/errors/bad_regexp_flag/index.md      |  139 +-
 .../reference/errors/bad_return_or_yield/index.md  |   47 +-
 .../errors/called_on_incompatible_type/index.md    |   57 +-
 .../index.md                                       |   45 +-
 .../reference/errors/cant_access_property/index.md |   58 +-
 .../errors/cant_assign_to_property/index.md        |   45 +-
 .../index.md                                       |   49 +-
 .../reference/errors/cant_delete/index.md          |   48 +-
 .../errors/cant_redefine_property/index.md         |   46 +-
 .../reference/errors/cyclic_object_value/index.md  |   57 +-
 .../reference/errors/dead_object/index.md          |   45 +-
 .../errors/delete_in_strict_mode/index.md          |   51 +-
 .../deprecated_caller_or_arguments_usage/index.md  |   56 +-
 .../errors/deprecated_expression_closures/index.md |   69 +-
 .../reference/errors/deprecated_octal/index.md     |   63 +-
 .../errors/deprecated_source_map_pragma/index.md   |   56 +-
 .../errors/deprecated_string_generics/index.md     |  124 +-
 .../errors/deprecated_tolocaleformat/index.md      |   74 +-
 .../reference/errors/equal_as_assign/index.md      |   50 +-
 .../for-each-in_loops_are_deprecated/index.md      |  121 +-
 .../reference/errors/getter_only/index.md          |   44 +-
 .../errors/identifier_after_number/index.md        |   47 +-
 .../reference/errors/illegal_character/index.md    |   77 +-
 .../errors/in_operator_no_object/index.md          |   70 +-
 files/fr/web/javascript/reference/errors/index.md  |   18 +-
 .../reference/errors/invalid_array_length/index.md |   61 +-
 .../invalid_assignment_left-hand_side/index.md     |   37 +-
 .../errors/invalid_const_assignment/index.md       |   91 +-
 .../reference/errors/invalid_date/index.md         |   58 +-
 .../errors/invalid_for-in_initializer/index.md     |   59 +-
 .../errors/invalid_for-of_initializer/index.md     |   48 +-
 .../index.md                                       |   44 +-
 .../reference/errors/is_not_iterable/index.md      |   94 +-
 .../reference/errors/json_bad_parse/index.md       |  158 +--
 .../errors/malformed_formal_parameter/index.md     |   49 +-
 .../reference/errors/malformed_uri/index.md        |   69 +-
 .../errors/missing_bracket_after_list/index.md     |   38 +-
 .../missing_colon_after_property_id/index.md       |   76 +-
 .../missing_curly_after_function_body/index.md     |   57 +-
 .../missing_curly_after_property_list/index.md     |   41 +-
 .../errors/missing_formal_parameter/index.md       |   59 +-
 .../errors/missing_initializer_in_const/index.md   |   62 +-
 .../missing_name_after_dot_operator/index.md       |   55 +-
 .../index.md                                       |   57 +-
 .../missing_parenthesis_after_condition/index.md   |   67 +-
 .../missing_semicolon_before_statement/index.md    |   80 +-
 .../errors/more_arguments_needed/index.md          |   44 +-
 .../errors/negative_repetition_count/index.md      |   40 +-
 .../reference/errors/no_non-null_object/index.md   |   66 +-
 .../reference/errors/no_properties/index.md        |   34 +-
 .../reference/errors/no_variable_name/index.md     |   82 +-
 .../errors/non_configurable_array_element/index.md |   67 +-
 .../reference/errors/not_a_codepoint/index.md      |   46 +-
 .../reference/errors/not_a_constructor/index.md    |   83 +-
 .../reference/errors/not_a_function/index.md       |  130 +-
 .../reference/errors/not_defined/index.md          |   62 +-
 .../reference/errors/precision_range/index.md      |  116 +-
 .../errors/property_access_denied/index.md         |   45 +-
 .../javascript/reference/errors/read-only/index.md |   65 +-
 .../reference/errors/redeclared_parameter/index.md |   53 +-
 .../index.md                                       |   98 +-
 .../reference/errors/reserved_identifier/index.md  |   83 +-
 .../errors/resulting_string_too_large/index.md     |   43 +-
 .../reference/errors/stmt_after_return/index.md    |   59 +-
 .../errors/strict_non_simple_params/index.md       |  111 +-
 .../reference/errors/too_much_recursion/index.md   |   58 +-
 .../reference/errors/undeclared_var/index.md       |   60 +-
 .../reference/errors/undefined_prop/index.md       |   42 +-
 .../reference/errors/unexpected_token/index.md     |   70 +-
 .../reference/errors/unexpected_type/index.md      |   58 +-
 .../errors/unnamed_function_statement/index.md     |  103 +-
 .../errors/unterminated_string_literal/index.md    |   77 +-
 .../reference/errors/var_hides_argument/index.md   |   43 +-
 .../functions/arguments/@@iterator/index.md        |   65 +-
 .../reference/functions/arguments/callee/index.md  |  167 ++-
 .../reference/functions/arguments/index.md         |  262 ++--
 .../reference/functions/arguments/length/index.md  |   98 +-
 .../reference/functions/arrow_functions/index.md   |  349 ++---
 .../functions/default_parameters/index.md          |  158 ++-
 .../javascript/reference/functions/get/index.md    |  181 ++-
 .../fr/web/javascript/reference/functions/index.md |  999 +++++++--------
 .../functions/method_definitions/index.md          |  177 ++-
 .../reference/functions/rest_parameters/index.md   |  163 ++-
 .../javascript/reference/functions/set/index.md    |  150 +--
 .../global_objects/aggregateerror/index.md         |   69 +-
 .../global_objects/array/@@iterator/index.md       |   87 +-
 .../global_objects/array/@@species/index.md        |   82 +-
 .../global_objects/array/@@unscopables/index.md    |   73 +-
 .../reference/global_objects/array/array/index.md  |   78 +-
 .../reference/global_objects/array/concat/index.md |  150 +--
 .../global_objects/array/copywithin/index.md       |  139 +-
 .../global_objects/array/entries/index.md          |   91 +-
 .../reference/global_objects/array/every/index.md  |  166 ++-
 .../reference/global_objects/array/fill/index.md   |  123 +-
 .../reference/global_objects/array/filter/index.md |  190 ++-
 .../reference/global_objects/array/find/index.md   |  146 +--
 .../global_objects/array/findindex/index.md        |  153 +--
 .../reference/global_objects/array/flat/index.md   |  115 +-
 .../global_objects/array/flatmap/index.md          |  141 +-
 .../global_objects/array/foreach/index.md          |  242 ++--
 .../reference/global_objects/array/from/index.md   |  109 +-
 .../global_objects/array/includes/index.md         |  130 +-
 .../reference/global_objects/array/index.md        |  510 ++++----
 .../global_objects/array/indexof/index.md          |  162 +--
 .../global_objects/array/isarray/index.md          |  101 +-
 .../reference/global_objects/array/join/index.md   |  115 +-
 .../reference/global_objects/array/keys/index.md   |   82 +-
 .../global_objects/array/lastindexof/index.md      |  151 +--
 .../reference/global_objects/array/length/index.md |  119 +-
 .../reference/global_objects/array/map/index.md    |  181 ++-
 .../reference/global_objects/array/of/index.md     |  105 +-
 .../reference/global_objects/array/pop/index.md    |  112 +-
 .../reference/global_objects/array/push/index.md   |  131 +-
 .../reference/global_objects/array/reduce/index.md |  437 ++++---
 .../global_objects/array/reduceright/index.md      |  358 +++---
 .../global_objects/array/reverse/index.md          |  103 +-
 .../reference/global_objects/array/shift/index.md  |  111 +-
 .../reference/global_objects/array/slice/index.md  |  158 +--
 .../reference/global_objects/array/some/index.md   |  156 +--
 .../reference/global_objects/array/sort/index.md   |  254 ++--
 .../reference/global_objects/array/splice/index.md |  111 +-
 .../global_objects/array/tolocalestring/index.md   |  126 +-
 .../global_objects/array/tosource/index.md         |   62 +-
 .../global_objects/array/tostring/index.md         |   73 +-
 .../global_objects/array/unshift/index.md          |  108 +-
 .../reference/global_objects/array/values/index.md |   90 +-
 .../global_objects/arraybuffer/@@species/index.md  |   78 +-
 .../global_objects/arraybuffer/bytelength/index.md |   62 +-
 .../reference/global_objects/arraybuffer/index.md  |  154 +--
 .../global_objects/arraybuffer/isview/index.md     |   82 +-
 .../global_objects/arraybuffer/slice/index.md      |   81 +-
 .../global_objects/asyncfunction/index.md          |  129 +-
 .../reference/global_objects/atomics/add/index.md  |   92 +-
 .../reference/global_objects/atomics/and/index.md  |  178 +--
 .../atomics/compareexchange/index.md               |   96 +-
 .../global_objects/atomics/exchange/index.md       |   82 +-
 .../reference/global_objects/atomics/index.md      |  179 ++-
 .../global_objects/atomics/islockfree/index.md     |   72 +-
 .../reference/global_objects/atomics/load/index.md |   88 +-
 .../global_objects/atomics/notify/index.md         |  109 +-
 .../reference/global_objects/atomics/or/index.md   |  180 +--
 .../global_objects/atomics/store/index.md          |   80 +-
 .../reference/global_objects/atomics/sub/index.md  |   91 +-
 .../reference/global_objects/atomics/wait/index.md |  113 +-
 .../reference/global_objects/atomics/xor/index.md  |  180 +--
 .../global_objects/bigint/asintn/index.md          |   64 +-
 .../global_objects/bigint/asuintn/index.md         |   65 +-
 .../reference/global_objects/bigint/index.md       |  232 ++--
 .../global_objects/bigint/tolocalestring/index.md  |   88 +-
 .../global_objects/bigint/tostring/index.md        |   90 +-
 .../global_objects/bigint/valueof/index.md         |   50 +-
 .../global_objects/bigint64array/index.md          |  274 ++--
 .../global_objects/biguint64array/index.md         |  274 ++--
 .../reference/global_objects/boolean/index.md      |  165 +--
 .../global_objects/boolean/tosource/index.md       |   51 +-
 .../global_objects/boolean/tostring/index.md       |   92 +-
 .../global_objects/boolean/valueof/index.md        |   88 +-
 .../global_objects/dataview/buffer/index.md        |   60 +-
 .../global_objects/dataview/bytelength/index.md    |   74 +-
 .../global_objects/dataview/byteoffset/index.md    |   74 +-
 .../global_objects/dataview/getbigint64/index.md   |   92 +-
 .../global_objects/dataview/getbiguint64/index.md  |   92 +-
 .../global_objects/dataview/getfloat32/index.md    |  102 +-
 .../global_objects/dataview/getfloat64/index.md    |  102 +-
 .../global_objects/dataview/getint16/index.md      |  102 +-
 .../global_objects/dataview/getint32/index.md      |  102 +-
 .../global_objects/dataview/getint8/index.md       |   98 +-
 .../global_objects/dataview/getuint16/index.md     |  102 +-
 .../global_objects/dataview/getuint32/index.md     |  102 +-
 .../global_objects/dataview/getuint8/index.md      |   98 +-
 .../reference/global_objects/dataview/index.md     |  171 ++-
 .../global_objects/dataview/setbigint64/index.md   |   90 +-
 .../global_objects/dataview/setbiguint64/index.md  |   90 +-
 .../global_objects/dataview/setfloat32/index.md    |  102 +-
 .../global_objects/dataview/setfloat64/index.md    |  102 +-
 .../global_objects/dataview/setint16/index.md      |  102 +-
 .../global_objects/dataview/setint32/index.md      |  102 +-
 .../global_objects/dataview/setint8/index.md       |  100 +-
 .../global_objects/dataview/setuint16/index.md     |  102 +-
 .../global_objects/dataview/setuint32/index.md     |  102 +-
 .../global_objects/dataview/setuint8/index.md      |   98 +-
 .../global_objects/date/@@toprimitive/index.md     |   58 +-
 .../reference/global_objects/date/getdate/index.md |   92 +-
 .../reference/global_objects/date/getday/index.md  |  109 +-
 .../global_objects/date/getfullyear/index.md       |   90 +-
 .../global_objects/date/gethours/index.md          |   86 +-
 .../global_objects/date/getmilliseconds/index.md   |   86 +-
 .../global_objects/date/getminutes/index.md        |   86 +-
 .../global_objects/date/getmonth/index.md          |  107 +-
 .../global_objects/date/getseconds/index.md        |   86 +-
 .../reference/global_objects/date/gettime/index.md |  114 +-
 .../global_objects/date/gettimezoneoffset/index.md |   66 +-
 .../global_objects/date/getutcdate/index.md        |   88 +-
 .../global_objects/date/getutcday/index.md         |   88 +-
 .../global_objects/date/getutcfullyear/index.md    |   75 +-
 .../global_objects/date/getutchours/index.md       |   86 +-
 .../date/getutcmilliseconds/index.md               |   90 +-
 .../global_objects/date/getutcminutes/index.md     |   86 +-
 .../global_objects/date/getutcmonth/index.md       |   86 +-
 .../global_objects/date/getutcseconds/index.md     |   86 +-
 .../reference/global_objects/date/getyear/index.md |  139 +-
 .../reference/global_objects/date/index.md         |  376 +++---
 .../reference/global_objects/date/now/index.md     |   98 +-
 .../reference/global_objects/date/parse/index.md   |  216 ++--
 .../reference/global_objects/date/setdate/index.md |  101 +-
 .../global_objects/date/setfullyear/index.md       |  108 +-
 .../global_objects/date/sethours/index.md          |  115 +-
 .../global_objects/date/setmilliseconds/index.md   |   96 +-
 .../global_objects/date/setminutes/index.md        |  110 +-
 .../global_objects/date/setmonth/index.md          |  120 +-
 .../global_objects/date/setseconds/index.md        |  106 +-
 .../reference/global_objects/date/settime/index.md |   96 +-
 .../global_objects/date/setutcdate/index.md        |   96 +-
 .../global_objects/date/setutcfullyear/index.md    |  106 +-
 .../global_objects/date/setutchours/index.md       |  110 +-
 .../date/setutcmilliseconds/index.md               |   96 +-
 .../global_objects/date/setutcminutes/index.md     |  106 +-
 .../global_objects/date/setutcmonth/index.md       |  102 +-
 .../global_objects/date/setutcseconds/index.md     |  102 +-
 .../reference/global_objects/date/setyear/index.md |  100 +-
 .../global_objects/date/todatestring/index.md      |  103 +-
 .../global_objects/date/togmtstring/index.md       |   90 +-
 .../global_objects/date/toisostring/index.md       |   94 +-
 .../reference/global_objects/date/tojson/index.md  |   84 +-
 .../date/tolocaledatestring/index.md               |  154 +--
 .../global_objects/date/tolocalestring/index.md    |  169 +--
 .../date/tolocaletimestring/index.md               |  154 +--
 .../global_objects/date/tosource/index.md          |   48 +-
 .../global_objects/date/tostring/index.md          |  169 +--
 .../global_objects/date/totimestring/index.md      |   92 +-
 .../global_objects/date/toutcstring/index.md       |   98 +-
 .../reference/global_objects/date/utc/index.md     |  141 +-
 .../reference/global_objects/date/valueof/index.md |   92 +-
 .../reference/global_objects/decodeuri/index.md    |  109 +-
 .../global_objects/decodeuricomponent/index.md     |  102 +-
 .../reference/global_objects/encodeuri/index.md    |  121 +-
 .../global_objects/encodeuricomponent/index.md     |  130 +-
 .../global_objects/error/columnnumber/index.md     |   31 +-
 .../global_objects/error/filename/index.md         |   35 +-
 .../reference/global_objects/error/index.md        |  219 ++--
 .../global_objects/error/linenumber/index.md       |   44 +-
 .../global_objects/error/message/index.md          |   68 +-
 .../reference/global_objects/error/name/index.md   |   66 +-
 .../reference/global_objects/error/stack/index.md  |  105 +-
 .../global_objects/error/tosource/index.md         |   46 +-
 .../global_objects/error/tostring/index.md         |   87 +-
 .../reference/global_objects/escape/index.md       |  110 +-
 .../reference/global_objects/eval/index.md         |  262 ++--
 .../reference/global_objects/evalerror/index.md    |  124 +-
 .../reference/global_objects/float32array/index.md |  306 ++---
 .../reference/global_objects/float64array/index.md |  312 +++--
 .../global_objects/function/apply/index.md         |  244 ++--
 .../global_objects/function/arguments/index.md     |   82 +-
 .../global_objects/function/bind/index.md          |  186 ++-
 .../global_objects/function/call/index.md          |  166 +--
 .../global_objects/function/caller/index.md        |   67 +-
 .../global_objects/function/displayname/index.md   |   46 +-
 .../reference/global_objects/function/index.md     |  150 +--
 .../global_objects/function/length/index.md        |   88 +-
 .../global_objects/function/name/index.md          |  177 ++-
 .../global_objects/function/tosource/index.md      |   73 +-
 .../global_objects/function/tostring/index.md      |  110 +-
 .../reference/global_objects/generator/index.md    |  156 +--
 .../global_objects/generator/next/index.md         |  103 +-
 .../global_objects/generator/return/index.md       |  114 +-
 .../global_objects/generator/throw/index.md        |   92 +-
 .../global_objects/generatorfunction/index.md      |  127 +-
 .../reference/global_objects/globalthis/index.md   |   79 +-
 .../javascript/reference/global_objects/index.md   |  322 +++--
 .../reference/global_objects/infinity/index.md     |   91 +-
 .../reference/global_objects/int16array/index.md   |  306 ++---
 .../reference/global_objects/int32array/index.md   |  306 ++---
 .../reference/global_objects/int8array/index.md    |  306 ++---
 .../global_objects/internalerror/index.md          |   78 +-
 .../global_objects/intl/collator/compare/index.md  |   99 +-
 .../global_objects/intl/collator/index.md          |  203 ++-
 .../intl/collator/resolvedoptions/index.md         |   97 +-
 .../intl/collator/supportedlocalesof/index.md      |  104 +-
 .../intl/datetimeformat/format/index.md            |  122 +-
 .../intl/datetimeformat/formatrange/index.md       |   62 +-
 .../datetimeformat/formatrangetoparts/index.md     |   51 +-
 .../intl/datetimeformat/formattoparts/index.md     |  173 ++-
 .../global_objects/intl/datetimeformat/index.md    |  399 +++---
 .../intl/datetimeformat/resolvedoptions/index.md   |   69 +-
 .../datetimeformat/supportedlocalesof/index.md     |  104 +-
 .../intl/displaynames/displaynames/index.md        |  151 +--
 .../global_objects/intl/displaynames/index.md      |  109 +-
 .../intl/getcanonicallocales/index.md              |   74 +-
 .../reference/global_objects/intl/index.md         |  196 ++-
 .../global_objects/intl/listformat/format/index.md |   57 +-
 .../intl/listformat/formattoparts/index.md         |   87 +-
 .../global_objects/intl/listformat/index.md        |  170 +--
 .../intl/listformat/resolvedoptions/index.md       |   88 +-
 .../intl/listformat/supportedlocalesof/index.md    |   93 +-
 .../global_objects/intl/locale/basename/index.md   |   65 +-
 .../global_objects/intl/locale/calendar/index.md   |  260 ++--
 .../global_objects/intl/locale/casefirst/index.md  |   93 +-
 .../global_objects/intl/locale/collation/index.md  |  279 ++--
 .../global_objects/intl/locale/hourcycle/index.md  |  130 +-
 .../reference/global_objects/intl/locale/index.md  |   67 +-
 .../global_objects/intl/locale/language/index.md   |   63 +-
 .../global_objects/intl/locale/maximize/index.md   |   73 +-
 .../global_objects/intl/locale/minimize/index.md   |   73 +-
 .../intl/locale/numberingsystem/index.md           |  522 ++------
 .../global_objects/intl/locale/numeric/index.md    |   72 +-
 .../global_objects/intl/locale/region/index.md     |   75 +-
 .../global_objects/intl/locale/script/index.md     |   63 +-
 .../global_objects/intl/locale/tostring/index.md   |   70 +-
 .../intl/numberformat/format/index.md              |   99 +-
 .../intl/numberformat/formattoparts/index.md       |  160 ++-
 .../global_objects/intl/numberformat/index.md      |  199 ++-
 .../intl/numberformat/resolvedoptions/index.md     |  111 +-
 .../intl/numberformat/supportedlocalesof/index.md  |  104 +-
 .../global_objects/intl/pluralrules/index.md       |  133 +-
 .../intl/pluralrules/resolvedoptions/index.md      |   92 +-
 .../intl/pluralrules/select/index.md               |   68 +-
 .../intl/pluralrules/supportedlocalesof/index.md   |   87 +-
 .../intl/relativetimeformat/format/index.md        |   88 +-
 .../intl/relativetimeformat/formattoparts/index.md |   87 +-
 .../intl/relativetimeformat/index.md               |  155 +--
 .../relativetimeformat/resolvedoptions/index.md    |  111 +-
 .../relativetimeformat/supportedlocalesof/index.md |   78 +-
 .../reference/global_objects/isfinite/index.md     |  100 +-
 .../reference/global_objects/isnan/index.md        |  133 +-
 .../reference/global_objects/json/index.md         |  245 ++--
 .../reference/global_objects/json/parse/index.md   |  116 +-
 .../global_objects/json/stringify/index.md         |  260 ++--
 .../global_objects/map/@@iterator/index.md         |   81 +-
 .../global_objects/map/@@species/index.md          |   78 +-
 .../global_objects/map/@@tostringtag/index.md      |   47 +-
 .../reference/global_objects/map/clear/index.md    |   70 +-
 .../reference/global_objects/map/delete/index.md   |   76 +-
 .../reference/global_objects/map/entries/index.md  |   74 +-
 .../reference/global_objects/map/foreach/index.md  |  104 +-
 .../reference/global_objects/map/get/index.md      |   80 +-
 .../reference/global_objects/map/has/index.md      |   80 +-
 .../reference/global_objects/map/index.md          |  204 ++-
 .../reference/global_objects/map/keys/index.md     |   72 +-
 .../reference/global_objects/map/set/index.md      |   96 +-
 .../reference/global_objects/map/size/index.md     |   54 +-
 .../reference/global_objects/map/values/index.md   |   73 +-
 .../reference/global_objects/math/abs/index.md     |  107 +-
 .../reference/global_objects/math/acos/index.md    |  112 +-
 .../reference/global_objects/math/acosh/index.md   |  106 +-
 .../reference/global_objects/math/asin/index.md    |  113 +-
 .../reference/global_objects/math/asinh/index.md   |   94 +-
 .../reference/global_objects/math/atan/index.md    |  108 +-
 .../reference/global_objects/math/atan2/index.md   |  126 +-
 .../reference/global_objects/math/atanh/index.md   |  105 +-
 .../reference/global_objects/math/cbrt/index.md    |   89 +-
 .../reference/global_objects/math/ceil/index.md    |  118 +-
 .../reference/global_objects/math/clz32/index.md   |   93 +-
 .../reference/global_objects/math/cos/index.md     |  106 +-
 .../reference/global_objects/math/cosh/index.md    |  114 +-
 .../reference/global_objects/math/e/index.md       |   89 +-
 .../reference/global_objects/math/exp/index.md     |  109 +-
 .../reference/global_objects/math/expm1/index.md   |  105 +-
 .../reference/global_objects/math/floor/index.md   |  106 +-
 .../reference/global_objects/math/fround/index.md  |   87 +-
 .../reference/global_objects/math/hypot/index.md   |  120 +-
 .../reference/global_objects/math/imul/index.md    |   95 +-
 .../reference/global_objects/math/index.md         |  295 ++---
 .../reference/global_objects/math/ln10/index.md    |   89 +-
 .../reference/global_objects/math/ln2/index.md     |   89 +-
 .../reference/global_objects/math/log/index.md     |  121 +-
 .../reference/global_objects/math/log10/index.md   |  103 +-
 .../reference/global_objects/math/log10e/index.md  |   89 +-
 .../reference/global_objects/math/log1p/index.md   |  103 +-
 .../reference/global_objects/math/log2/index.md    |   94 +-
 .../reference/global_objects/math/log2e/index.md   |   89 +-
 .../reference/global_objects/math/max/index.md     |  132 +-
 .../reference/global_objects/math/min/index.md     |  125 +-
 .../reference/global_objects/math/pi/index.md      |   85 +-
 .../reference/global_objects/math/pow/index.md     |  106 +-
 .../reference/global_objects/math/random/index.md  |  105 +-
 .../reference/global_objects/math/round/index.md   |  106 +-
 .../reference/global_objects/math/sign/index.md    |   92 +-
 .../reference/global_objects/math/sin/index.md     |  105 +-
 .../reference/global_objects/math/sinh/index.md    |  109 +-
 .../reference/global_objects/math/sqrt/index.md    |  103 +-
 .../reference/global_objects/math/sqrt1_2/index.md |   75 +-
 .../reference/global_objects/math/sqrt2/index.md   |   75 +-
 .../reference/global_objects/math/tan/index.md     |  112 +-
 .../reference/global_objects/math/tanh/index.md    |  111 +-
 .../reference/global_objects/math/trunc/index.md   |  101 +-
 .../reference/global_objects/nan/index.md          |  106 +-
 .../reference/global_objects/null/index.md         |   88 +-
 .../global_objects/number/epsilon/index.md         |   80 +-
 .../reference/global_objects/number/index.md       |  297 ++---
 .../global_objects/number/isfinite/index.md        |  103 +-
 .../global_objects/number/isinteger/index.md       |   94 +-
 .../reference/global_objects/number/isnan/index.md |  105 +-
 .../global_objects/number/issafeinteger/index.md   |  102 +-
 .../number/max_safe_integer/index.md               |   78 +-
 .../global_objects/number/max_value/index.md       |   75 +-
 .../number/min_safe_integer/index.md               |   66 +-
 .../global_objects/number/min_value/index.md       |   77 +-
 .../reference/global_objects/number/nan/index.md   |   79 +-
 .../number/negative_infinity/index.md              |  114 +-
 .../global_objects/number/parsefloat/index.md      |   87 +-
 .../global_objects/number/parseint/index.md        |   93 +-
 .../number/positive_infinity/index.md              |  116 +-
 .../global_objects/number/toexponential/index.md   |  114 +-
 .../global_objects/number/tofixed/index.md         |  112 +-
 .../global_objects/number/tolocalestring/index.md  |  164 +--
 .../global_objects/number/toprecision/index.md     |  102 +-
 .../global_objects/number/tosource/index.md        |   52 +-
 .../global_objects/number/tostring/index.md        |  116 +-
 .../global_objects/number/valueof/index.md         |   86 +-
 .../object/__definegetter__/index.md               |   95 +-
 .../object/__definesetter__/index.md               |  108 +-
 .../object/__lookupgetter__/index.md               |   91 +-
 .../object/__lookupsetter__/index.md               |   85 +-
 .../global_objects/object/assign/index.md          |  161 ++-
 .../global_objects/object/constructor/index.md     |  151 +--
 .../global_objects/object/create/index.md          |  118 +-
 .../object/defineproperties/index.md               |  168 +--
 .../global_objects/object/defineproperty/index.md  |  287 +++--
 .../global_objects/object/entries/index.md         |  138 +-
 .../global_objects/object/freeze/index.md          |  176 ++-
 .../global_objects/object/fromentries/index.md     |  113 +-
 .../object/getownpropertydescriptor/index.md       |  131 +-
 .../object/getownpropertydescriptors/index.md      |  125 +-
 .../object/getownpropertynames/index.md            |  145 +--
 .../object/getownpropertysymbols/index.md          |   84 +-
 .../global_objects/object/getprototypeof/index.md  |  109 +-
 .../global_objects/object/hasownproperty/index.md  |  140 +-
 .../reference/global_objects/object/index.md       |  261 ++--
 .../reference/global_objects/object/is/index.md    |  127 +-
 .../global_objects/object/isextensible/index.md    |  105 +-
 .../global_objects/object/isfrozen/index.md        |  103 +-
 .../global_objects/object/isprototypeof/index.md   |  121 +-
 .../global_objects/object/issealed/index.md        |  104 +-
 .../reference/global_objects/object/keys/index.md  |  111 +-
 .../object/preventextensions/index.md              |  111 +-
 .../object/propertyisenumerable/index.md           |  118 +-
 .../reference/global_objects/object/proto/index.md |  153 +--
 .../reference/global_objects/object/seal/index.md  |  118 +-
 .../global_objects/object/setprototypeof/index.md  |  145 +--
 .../global_objects/object/tolocalestring/index.md  |   79 +-
 .../global_objects/object/tosource/index.md        |  116 +-
 .../global_objects/object/tostring/index.md        |  135 +-
 .../global_objects/object/valueof/index.md         |  126 +-
 .../global_objects/object/values/index.md          |   98 +-
 .../reference/global_objects/parsefloat/index.md   |  149 +--
 .../reference/global_objects/parseint/index.md     |  202 ++-
 .../reference/global_objects/promise/all/index.md  |  189 ++-
 .../global_objects/promise/allsettled/index.md     |   61 +-
 .../reference/global_objects/promise/any/index.md  |  128 +-
 .../global_objects/promise/catch/index.md          |  127 +-
 .../global_objects/promise/finally/index.md        |  112 +-
 .../reference/global_objects/promise/index.md      |  242 ++--
 .../reference/global_objects/promise/race/index.md |  132 +-
 .../global_objects/promise/reject/index.md         |   81 +-
 .../global_objects/promise/resolve/index.md        |  114 +-
 .../reference/global_objects/promise/then/index.md |  192 ++-
 .../reference/global_objects/proxy/index.md        |  208 ++-
 .../global_objects/proxy/proxy/apply/index.md      |  123 +-
 .../global_objects/proxy/proxy/construct/index.md  |  134 +-
 .../proxy/proxy/defineproperty/index.md            |  148 +--
 .../proxy/proxy/deleteproperty/index.md            |  115 +-
 .../global_objects/proxy/proxy/get/index.md        |  128 +-
 .../proxy/proxy/getownpropertydescriptor/index.md  |  132 +-
 .../proxy/proxy/getprototypeof/index.md            |  131 +-
 .../global_objects/proxy/proxy/has/index.md        |  128 +-
 .../reference/global_objects/proxy/proxy/index.md  |  121 +-
 .../proxy/proxy/isextensible/index.md              |  118 +-
 .../global_objects/proxy/proxy/ownkeys/index.md    |  128 +-
 .../proxy/proxy/preventextensions/index.md         |  118 +-
 .../global_objects/proxy/proxy/set/index.md        |  127 +-
 .../proxy/proxy/setprototypeof/index.md            |  125 +-
 .../global_objects/proxy/revocable/index.md        |   87 +-
 .../reference/global_objects/rangeerror/index.md   |  140 +-
 .../global_objects/referenceerror/index.md         |  129 +-
 .../global_objects/reflect/apply/index.md          |  101 +-
 .../comparing_reflect_and_object_methods/index.md  |  261 ++--
 .../global_objects/reflect/construct/index.md      |  133 +-
 .../global_objects/reflect/defineproperty/index.md |  107 +-
 .../global_objects/reflect/deleteproperty/index.md |   91 +-
 .../reference/global_objects/reflect/get/index.md  |   95 +-
 .../reflect/getownpropertydescriptor/index.md      |  103 +-
 .../global_objects/reflect/getprototypeof/index.md |   96 +-
 .../reference/global_objects/reflect/has/index.md  |   91 +-
 .../reference/global_objects/reflect/index.md      |  103 +-
 .../global_objects/reflect/isextensible/index.md   |  100 +-
 .../global_objects/reflect/ownkeys/index.md        |   93 +-
 .../reflect/preventextensions/index.md             |  100 +-
 .../reference/global_objects/reflect/set/index.md  |  101 +-
 .../global_objects/reflect/setprototypeof/index.md |   93 +-
 .../global_objects/regexp/@@match/index.md         |  111 +-
 .../global_objects/regexp/@@matchall/index.md      |   99 +-
 .../global_objects/regexp/@@replace/index.md       |  124 +-
 .../global_objects/regexp/@@search/index.md        |  115 +-
 .../global_objects/regexp/@@species/index.md       |   80 +-
 .../global_objects/regexp/@@split/index.md         |  121 +-
 .../global_objects/regexp/compile/index.md         |  101 +-
 .../global_objects/regexp/dotall/index.md          |   46 +-
 .../reference/global_objects/regexp/exec/index.md  |  271 ++--
 .../reference/global_objects/regexp/flags/index.md |   65 +-
 .../global_objects/regexp/global/index.md          |   91 +-
 .../global_objects/regexp/ignorecase/index.md      |   80 +-
 .../reference/global_objects/regexp/index.md       |  269 ++--
 .../reference/global_objects/regexp/input/index.md |   48 +-
 .../global_objects/regexp/lastindex/index.md       |  121 +-
 .../global_objects/regexp/lastmatch/index.md       |   52 +-
 .../global_objects/regexp/lastparen/index.md       |   50 +-
 .../global_objects/regexp/leftcontext/index.md     |   48 +-
 .../global_objects/regexp/multiline/index.md       |   96 +-
 .../reference/global_objects/regexp/n/index.md     |   66 +-
 .../global_objects/regexp/rightcontext/index.md    |   48 +-
 .../global_objects/regexp/source/index.md          |   86 +-
 .../global_objects/regexp/sticky/index.md          |   89 +-
 .../reference/global_objects/regexp/test/index.md  |  131 +-
 .../global_objects/regexp/tosource/index.md        |   50 +-
 .../global_objects/regexp/tostring/index.md        |   98 +-
 .../global_objects/regexp/unicode/index.md         |   68 +-
 .../global_objects/set/@@iterator/index.md         |   81 +-
 .../global_objects/set/@@species/index.md          |   78 +-
 .../reference/global_objects/set/add/index.md      |   80 +-
 .../reference/global_objects/set/clear/index.md    |   70 +-
 .../reference/global_objects/set/delete/index.md   |   90 +-
 .../reference/global_objects/set/entries/index.md  |   70 +-
 .../reference/global_objects/set/foreach/index.md  |  120 +-
 .../reference/global_objects/set/has/index.md      |   84 +-
 .../reference/global_objects/set/index.md          |  182 ++-
 .../reference/global_objects/set/size/index.md     |   54 +-
 .../reference/global_objects/set/values/index.md   |   72 +-
 .../sharedarraybuffer/bytelength/index.md          |   62 +-
 .../global_objects/sharedarraybuffer/index.md      |  140 +-
 .../sharedarraybuffer/slice/index.md               |   97 +-
 .../global_objects/string/@@iterator/index.md      |   77 +-
 .../global_objects/string/anchor/index.md          |   92 +-
 .../reference/global_objects/string/big/index.md   |   79 +-
 .../reference/global_objects/string/blink/index.md |   97 +-
 .../reference/global_objects/string/bold/index.md  |   96 +-
 .../global_objects/string/charat/index.md          |  177 ++-
 .../global_objects/string/charcodeat/index.md      |  137 +-
 .../global_objects/string/codepointat/index.md     |  105 +-
 .../global_objects/string/concat/index.md          |  103 +-
 .../global_objects/string/endswith/index.md        |  103 +-
 .../reference/global_objects/string/fixed/index.md |   80 +-
 .../global_objects/string/fontcolor/index.md       |   98 +-
 .../global_objects/string/fontsize/index.md        |   85 +-
 .../global_objects/string/fromcharcode/index.md    |  125 +-
 .../global_objects/string/fromcodepoint/index.md   |   98 +-
 .../global_objects/string/includes/index.md        |  140 +-
 .../reference/global_objects/string/index.md       |  528 ++++----
 .../global_objects/string/indexof/index.md         |  162 +--
 .../global_objects/string/italics/index.md         |   94 +-
 .../global_objects/string/lastindexof/index.md     |  124 +-
 .../global_objects/string/length/index.md          |   99 +-
 .../reference/global_objects/string/link/index.md  |   93 +-
 .../global_objects/string/localecompare/index.md   |  188 ++-
 .../reference/global_objects/string/match/index.md |  159 +--
 .../global_objects/string/matchall/index.md        |  106 +-
 .../global_objects/string/normalize/index.md       |  103 +-
 .../global_objects/string/padend/index.md          |   80 +-
 .../global_objects/string/padstart/index.md        |   83 +-
 .../reference/global_objects/string/raw/index.md   |  105 +-
 .../global_objects/string/repeat/index.md          |   85 +-
 .../global_objects/string/replace/index.md         |  376 +++---
 .../global_objects/string/replaceall/index.md      |  227 ++--
 .../global_objects/string/search/index.md          |  117 +-
 .../reference/global_objects/string/slice/index.md |  164 ++-
 .../reference/global_objects/string/small/index.md |   77 +-
 .../reference/global_objects/string/split/index.md |  218 ++--
 .../global_objects/string/startswith/index.md      |   93 +-
 .../global_objects/string/strike/index.md          |   95 +-
 .../reference/global_objects/string/sub/index.md   |   77 +-
 .../global_objects/string/substr/index.md          |  146 +--
 .../global_objects/string/substring/index.md       |  216 ++--
 .../reference/global_objects/string/sup/index.md   |   78 +-
 .../string/tolocalelowercase/index.md              |  116 +-
 .../string/tolocaleuppercase/index.md              |  118 +-
 .../global_objects/string/tolowercase/index.md     |   76 +-
 .../global_objects/string/tosource/index.md        |   52 +-
 .../global_objects/string/tostring/index.md        |   79 +-
 .../global_objects/string/touppercase/index.md     |  108 +-
 .../reference/global_objects/string/trim/index.md  |   91 +-
 .../global_objects/string/trimend/index.md         |   82 +-
 .../global_objects/string/trimstart/index.md       |   82 +-
 .../global_objects/string/valueof/index.md         |   88 +-
 .../global_objects/symbol/@@toprimitive/index.md   |   54 +-
 .../global_objects/symbol/asynciterator/index.md   |   60 +-
 .../global_objects/symbol/description/index.md     |   56 +-
 .../reference/global_objects/symbol/for/index.md   |  112 +-
 .../global_objects/symbol/hasinstance/index.md     |   55 +-
 .../reference/global_objects/symbol/index.md       |  271 ++--
 .../symbol/isconcatspreadable/index.md             |  100 +-
 .../global_objects/symbol/iterator/index.md        |  118 +-
 .../global_objects/symbol/keyfor/index.md          |   76 +-
 .../reference/global_objects/symbol/match/index.md |   84 +-
 .../global_objects/symbol/matchall/index.md        |   59 +-
 .../global_objects/symbol/replace/index.md         |   53 +-
 .../global_objects/symbol/search/index.md          |   53 +-
 .../global_objects/symbol/species/index.md         |   63 +-
 .../reference/global_objects/symbol/split/index.md |   53 +-
 .../global_objects/symbol/toprimitive/index.md     |   64 +-
 .../global_objects/symbol/tosource/index.md        |   58 +-
 .../global_objects/symbol/tostring/index.md        |   80 +-
 .../global_objects/symbol/tostringtag/index.md     |   87 +-
 .../global_objects/symbol/unscopables/index.md     |   82 +-
 .../global_objects/symbol/valueof/index.md         |   54 +-
 .../reference/global_objects/syntaxerror/index.md  |  127 +-
 .../global_objects/typedarray/@@iterator/index.md  |   83 +-
 .../global_objects/typedarray/@@species/index.md   |   99 +-
 .../global_objects/typedarray/buffer/index.md      |   58 +-
 .../global_objects/typedarray/bytelength/index.md  |   70 +-
 .../global_objects/typedarray/byteoffset/index.md  |   56 +-
 .../typedarray/bytes_per_element/index.md          |   69 +-
 .../global_objects/typedarray/copywithin/index.md  |   90 +-
 .../global_objects/typedarray/entries/index.md     |   90 +-
 .../global_objects/typedarray/every/index.md       |  133 +-
 .../global_objects/typedarray/fill/index.md        |  101 +-
 .../global_objects/typedarray/filter/index.md      |  126 +-
 .../global_objects/typedarray/find/index.md        |  125 +-
 .../global_objects/typedarray/findindex/index.md   |  122 +-
 .../global_objects/typedarray/foreach/index.md     |  126 +-
 .../global_objects/typedarray/from/index.md        |  139 +-
 .../global_objects/typedarray/includes/index.md    |   84 +-
 .../reference/global_objects/typedarray/index.md   |  402 +++---
 .../global_objects/typedarray/indexof/index.md     |   96 +-
 .../global_objects/typedarray/join/index.md        |   91 +-
 .../global_objects/typedarray/keys/index.md        |   89 +-
 .../global_objects/typedarray/lastindexof/index.md |   86 +-
 .../global_objects/typedarray/length/index.md      |   70 +-
 .../global_objects/typedarray/map/index.md         |  125 +-
 .../global_objects/typedarray/name/index.md        |   63 +-
 .../global_objects/typedarray/of/index.md          |  112 +-
 .../global_objects/typedarray/reduce/index.md      |  112 +-
 .../global_objects/typedarray/reduceright/index.md |  118 +-
 .../global_objects/typedarray/reverse/index.md     |   56 +-
 .../global_objects/typedarray/set/index.md         |  105 +-
 .../global_objects/typedarray/slice/index.md       |  104 +-
 .../global_objects/typedarray/some/index.md        |  139 +-
 .../global_objects/typedarray/sort/index.md        |   78 +-
 .../global_objects/typedarray/subarray/index.md    |   97 +-
 .../typedarray/tolocalestring/index.md             |   72 +-
 .../global_objects/typedarray/tostring/index.md    |   81 +-
 .../global_objects/typedarray/values/index.md      |   85 +-
 .../reference/global_objects/typeerror/index.md    |  127 +-
 .../reference/global_objects/uint16array/index.md  |  306 ++---
 .../reference/global_objects/uint32array/index.md  |  306 ++---
 .../reference/global_objects/uint8array/index.md   |  306 ++---
 .../global_objects/uint8clampedarray/index.md      |  306 ++---
 .../reference/global_objects/undefined/index.md    |  132 +-
 .../reference/global_objects/unescape/index.md     |  106 +-
 .../reference/global_objects/uneval/index.md       |   53 +-
 .../reference/global_objects/urierror/index.md     |  135 +-
 .../global_objects/weakmap/clear/index.md          |   29 +-
 .../global_objects/weakmap/delete/index.md         |   76 +-
 .../reference/global_objects/weakmap/get/index.md  |   80 +-
 .../reference/global_objects/weakmap/has/index.md  |   80 +-
 .../reference/global_objects/weakmap/index.md      |  133 +-
 .../reference/global_objects/weakmap/set/index.md  |   94 +-
 .../reference/global_objects/weakset/add/index.md  |   84 +-
 .../global_objects/weakset/delete/index.md         |   78 +-
 .../reference/global_objects/weakset/has/index.md  |   84 +-
 .../reference/global_objects/weakset/index.md      |  129 +-
 .../global_objects/webassembly/compile/index.md    |   97 +-
 .../webassembly/compileerror/index.md              |  135 +-
 .../webassembly/compilestreaming/index.md          |   89 +-
 .../global_objects/webassembly/global/index.md     |  119 +-
 .../reference/global_objects/webassembly/index.md  |  163 ++-
 .../webassembly/instance/exports/index.md          |   55 +-
 .../global_objects/webassembly/instance/index.md   |   73 +-
 .../webassembly/instantiate/index.md               |  173 ++-
 .../webassembly/instantiatestreaming/index.md      |   99 +-
 .../global_objects/webassembly/linkerror/index.md  |  135 +-
 .../webassembly/memory/buffer/index.md             |   56 +-
 .../webassembly/memory/grow/index.md               |   88 +-
 .../global_objects/webassembly/memory/index.md     |  138 +-
 .../webassembly/module/customsections/index.md     |   99 +-
 .../webassembly/module/exports/index.md            |  101 +-
 .../webassembly/module/imports/index.md            |   90 +-
 .../global_objects/webassembly/module/index.md     |   85 +-
 .../webassembly/runtimeerror/index.md              |  135 +-
 .../global_objects/webassembly/table/get/index.md  |   76 +-
 .../global_objects/webassembly/table/grow/index.md |   87 +-
 .../global_objects/webassembly/table/index.md      |  160 +--
 .../webassembly/table/length/index.md              |   59 +-
 .../global_objects/webassembly/table/set/index.md  |  114 +-
 .../global_objects/webassembly/validate/index.md   |   80 +-
 files/fr/web/javascript/reference/index.md         |   48 +-
 .../reference/iteration_protocols/index.md         |  281 ++--
 .../javascript/reference/lexical_grammar/index.md  |  752 +++++------
 .../reference/operators/addition/index.md          |   70 +-
 .../operators/addition_assignment/index.md         |   64 +-
 .../reference/operators/assignment/index.md        |   48 +-
 .../reference/operators/async_function/index.md    |  116 +-
 .../javascript/reference/operators/await/index.md  |  132 +-
 .../reference/operators/bitwise_and/index.md       |  106 +-
 .../operators/bitwise_and_assignment/index.md      |   43 +-
 .../reference/operators/bitwise_not/index.md       |   89 +-
 .../reference/operators/bitwise_or/index.md        |  102 +-
 .../operators/bitwise_or_assignment/index.md       |   43 +-
 .../reference/operators/bitwise_xor/index.md       |  102 +-
 .../operators/bitwise_xor_assignment/index.md      |   41 +-
 .../javascript/reference/operators/class/index.md  |  103 +-
 .../reference/operators/comma_operator/index.md    |  119 +-
 .../operators/conditional_operator/index.md        |  152 +--
 .../reference/operators/decrement/index.md         |   68 +-
 .../javascript/reference/operators/delete/index.md |  231 ++--
 .../operators/destructuring_assignment/index.md    |  334 ++---
 .../reference/operators/division/index.md          |   61 +-
 .../operators/division_assignment/index.md         |   41 +-
 .../reference/operators/equality/index.md          |  116 +-
 .../reference/operators/exponentiation/index.md    |   89 +-
 .../operators/exponentiation_assignment/index.md   |   41 +-
 .../reference/operators/function/index.md          |  163 +--
 .../reference/operators/function_star_/index.md    |  106 +-
 .../reference/operators/greater_than/index.md      |  119 +-
 .../operators/greater_than_or_equal/index.md       |  119 +-
 .../reference/operators/grouping/index.md          |   86 +-
 .../web/javascript/reference/operators/in/index.md |  136 +-
 .../reference/operators/increment/index.md         |   68 +-
 .../fr/web/javascript/reference/operators/index.md |  508 ++++----
 .../reference/operators/inequality/index.md        |   74 +-
 .../reference/operators/instanceof/index.md        |  132 +-
 .../reference/operators/left_shift/index.md        |   55 +-
 .../operators/left_shift_assignment/index.md       |   43 +-
 .../reference/operators/less_than/index.md         |  144 +--
 .../operators/less_than_or_equal/index.md          |  119 +-
 .../reference/operators/logical_and/index.md       |  164 ++-
 .../operators/logical_and_assignment/index.md      |   81 +-
 .../reference/operators/logical_not/index.md       |   91 +-
 .../operators/logical_nullish_assignment/index.md  |   65 +-
 .../reference/operators/logical_or/index.md        |  147 ++-
 .../operators/logical_or_assignment/index.md       |   79 +-
 .../reference/operators/multiplication/index.md    |   66 +-
 .../operators/multiplication_assignment/index.md   |   42 +-
 .../reference/operators/new.target/index.md        |   91 +-
 .../javascript/reference/operators/new/index.md    |  206 ++-
 .../operators/nullish_coalescing_operator/index.md |  131 +-
 .../operators/object_initializer/index.md          |  267 ++--
 .../operators/operator_precedence/index.md         |  922 ++++++++-----
 .../reference/operators/optional_chaining/index.md |  168 +--
 .../operators/property_accessors/index.md          |  185 ++-
 .../reference/operators/remainder/index.md         |   73 +-
 .../operators/remainder_assignment/index.md        |   41 +-
 .../reference/operators/right_shift/index.md       |   63 +-
 .../operators/right_shift_assignment/index.md      |   45 +-
 .../reference/operators/spread_syntax/index.md     |  249 ++--
 .../reference/operators/strict_equality/index.md   |   79 +-
 .../reference/operators/strict_inequality/index.md |   67 +-
 .../reference/operators/subtraction/index.md       |   59 +-
 .../operators/subtraction_assignment/index.md      |   41 +-
 .../javascript/reference/operators/super/index.md  |   81 +-
 .../javascript/reference/operators/this/index.md   |  284 ++--
 .../javascript/reference/operators/typeof/index.md |  265 ++--
 .../reference/operators/unary_negation/index.md    |   64 +-
 .../reference/operators/unary_plus/index.md        |   67 +-
 .../operators/unsigned_right_shift/index.md        |   62 +-
 .../unsigned_right_shift_assignment/index.md       |   45 +-
 .../javascript/reference/operators/void/index.md   |  148 +--
 .../javascript/reference/operators/yield/index.md  |  187 ++-
 .../reference/operators/yield_star_/index.md       |  137 +-
 .../reference/statements/async_function/index.md   |  199 ++-
 .../javascript/reference/statements/block/index.md |  116 +-
 .../javascript/reference/statements/break/index.md |  141 +-
 .../javascript/reference/statements/class/index.md |  124 +-
 .../javascript/reference/statements/const/index.md |   92 +-
 .../reference/statements/continue/index.md         |  136 +-
 .../reference/statements/debugger/index.md         |   75 +-
 .../reference/statements/do...while/index.md       |   89 +-
 .../javascript/reference/statements/empty/index.md |  108 +-
 .../reference/statements/export/index.md           |  232 ++--
 .../reference/statements/for-await...of/index.md   |  117 +-
 .../reference/statements/for...in/index.md         |  154 +--
 .../reference/statements/for...of/index.md         |  231 ++--
 .../javascript/reference/statements/for/index.md   |  167 +--
 .../reference/statements/function/index.md         |  166 +--
 .../reference/statements/function_star_/index.md   |  213 ++-
 .../reference/statements/if...else/index.md        |  152 +--
 .../reference/statements/import.meta/index.md      |   68 +-
 .../reference/statements/import/index.md           |  286 ++---
 .../web/javascript/reference/statements/index.md   |  237 ++--
 .../javascript/reference/statements/label/index.md |  184 ++-
 .../javascript/reference/statements/let/index.md   |  259 ++--
 .../reference/statements/return/index.md           |  151 +--
 .../reference/statements/switch/index.md           |  326 ++---
 .../javascript/reference/statements/throw/index.md |  120 +-
 .../reference/statements/try...catch/index.md      |  254 ++--
 .../javascript/reference/statements/var/index.md   |  212 ++-
 .../javascript/reference/statements/while/index.md |  121 +-
 .../javascript/reference/statements/with/index.md  |  163 +--
 .../web/javascript/reference/strict_mode/index.md  |  305 +++--
 .../transitioning_to_strict_mode/index.md          |  137 +-
 .../reference/template_literals/index.md           |  231 ++--
 .../javascript/reference/trailing_commas/index.md  |  182 ++-
 files/fr/web/javascript/shells/index.md            |   50 +-
 .../index.md                                       |  138 +-
 files/fr/web/javascript/typed_arrays/index.md      |  192 ++-
 841 files changed, 48888 insertions(+), 61369 deletions(-)

(limited to 'files/fr/web/javascript/reference/global_objects/asyncfunction')

diff --git a/files/fr/web/javascript/a_re-introduction_to_javascript/index.md b/files/fr/web/javascript/a_re-introduction_to_javascript/index.md
index 0724f02931..962ace144f 100644
--- a/files/fr/web/javascript/a_re-introduction_to_javascript/index.md
+++ b/files/fr/web/javascript/a_re-introduction_to_javascript/index.md
@@ -11,125 +11,126 @@ tags:
 translation_of: Web/JavaScript/A_re-introduction_to_JavaScript
 original_slug: Web/JavaScript/Une_réintroduction_à_JavaScript
 ---
-<div>{{jsSidebar}}</div>
+{{jsSidebar}}
 
-<p>Pourquoi une réintroduction ? Parce que JavaScript est connu pour être source d'incompréhensions. Bien que souvent raillé comme étant un simple jouet, derrière sa simplicité désarmante se cachent certaines fonctionnalités de langage très puissantes. JavaScript est maintenant utilisé par un nombre incroyable d'applications de haut rang, ce qui montre qu'une connaissance approfondie de cette technologie est une compétence importante pour toute développeuse ou développeur web ou mobile.</p>
+Pourquoi une réintroduction ? Parce que JavaScript est connu pour être source d'incompréhensions. Bien que souvent raillé comme étant un simple jouet, derrière sa simplicité désarmante se cachent certaines fonctionnalités de langage très puissantes. JavaScript est maintenant utilisé par un nombre incroyable d'applications de haut rang, ce qui montre qu'une connaissance approfondie de cette technologie est une compétence importante pour toute développeuse ou développeur web ou mobile.
 
-<p>Il peut être utile de commencer avec un aperçu de l'histoire de ce langage. JavaScript a été créé en 1995 par Brendan Eich, alors ingénieur à Netscape. Ce langage est sorti au grand jour pour la première fois avec Netscape 2 au début de l'année 1996. Il était au départ censé s'appeler LiveScript, mais a été renommé par une décision marketing mal avisée dans le but de capitaliser sur la popularité du langage Java de Sun Microsystems, malgré le fait qu'ils n'aient que très peu en commun. Cela n'a jamais cessé d'être une source de confusion.</p>
+Il peut être utile de commencer avec un aperçu de l'histoire de ce langage. JavaScript a été créé en 1995 par Brendan Eich, alors ingénieur à Netscape. Ce langage est sorti au grand jour pour la première fois avec Netscape 2 au début de l'année 1996. Il était au départ censé s'appeler LiveScript, mais a été renommé par une décision marketing mal avisée dans le but de capitaliser sur la popularité du langage Java de Sun Microsystems, malgré le fait qu'ils n'aient que très peu en commun. Cela n'a jamais cessé d'être une source de confusion.
 
-<p>Quelques mois plus tard, Microsoft a lancé avec Internet Explorer 3 une version du langage globalement compatible, appelée JScript. Quelques mois après, Netscape a soumis le langage à l'<a href="https://www.ecma-international.org/">Ecma International</a>, une organisation de normalisation européenne, ce qui a permis d'aboutir à la première édition du standard <a href="/fr/docs/Glossary/ECMAScript">ECMAScript</a> en 1997. Ce standard a reçu une mise à jour importante appelée <a href="https://www.ecma-international.org/publications/standards/Ecma-262.htm">ECMAScript edition 3</a> en 1999, et est resté relativement stable depuis. La quatrième édition a été abandonnée suite à des différends portants sur la complexité du langage. De nombreuses sections de la quatrième édition ont été utilisées pour servir de fondation à la cinquième édition d'ECMAScript, publiée en décembre 2009. La sixième édition, qui apporte des nouveautés majeures, a été publiée en juin 2015.</p>
+Quelques mois plus tard, Microsoft a lancé avec Internet Explorer 3 une version du langage globalement compatible, appelée JScript. Quelques mois après, Netscape a soumis le langage à l'[Ecma International](https://www.ecma-international.org/), une organisation de normalisation européenne, ce qui a permis d'aboutir à la première édition du standard [ECMAScript](/fr/docs/Glossary/ECMAScript) en 1997. Ce standard a reçu une mise à jour importante appelée [ECMAScript edition 3](https://www.ecma-international.org/publications/standards/Ecma-262.htm) en 1999, et est resté relativement stable depuis. La quatrième édition a été abandonnée suite à des différends portants sur la complexité du langage. De nombreuses sections de la quatrième édition ont été utilisées pour servir de fondation à la cinquième édition d'ECMAScript, publiée en décembre 2009. La sixième édition, qui apporte des nouveautés majeures, a été publiée en juin 2015.
 
-<div class="note">
-  <p><strong>Note :</strong> Dans la suite de cet article et à des fins de simplicité, nous utiliserons les termes «&nbsp;JavaScript&nbsp;» et «&nbsp;ECMAScript&nbsp;» pour désigner la même chose.</p>
-</div>
+> **Note :** Dans la suite de cet article et à des fins de simplicité, nous utiliserons les termes « JavaScript » et « ECMAScript » pour désigner la même chose.
 
-<p>Contrairement à la plupart des langages de programmation, JavaScript n'a pas de concept d'entrée ou de sortie. Il est conçu pour s'exécuter comme un langage de script dans un environnement hôte, et c'est à cet environnement de fournir des mécanismes de communication avec le monde extérieur. L'environnement hôte le plus commun est un navigateur, mais des interpréteurs JavaScript existent également dans Adobe Acrobat, Photoshop, les images SVG, le moteur de widgets de Yahoo!, et même au sein d'environnements côté serveur tels que <a href="https://nodejs.org/">Node.js</a>. Cette liste ne se limite pas qu'à ces éléments et on retrouve également JavaScript dans les bases de données NoSQL telles que <a href="https://couchdb.apache.org/">Apache CouchDB</a>, les ordinateurs embarqués ou encore des environnements de bureaux comme <a href="https://www.gnome.org/">GNOME</a> (l'une des interfaces graphiques les plus populaires des systèmes d'exploitation GNU/Linux), etc.</p>
+Contrairement à la plupart des langages de programmation, JavaScript n'a pas de concept d'entrée ou de sortie. Il est conçu pour s'exécuter comme un langage de script dans un environnement hôte, et c'est à cet environnement de fournir des mécanismes de communication avec le monde extérieur. L'environnement hôte le plus commun est un navigateur, mais des interpréteurs JavaScript existent également dans Adobe Acrobat, Photoshop, les images SVG, le moteur de widgets de Yahoo!, et même au sein d'environnements côté serveur tels que [Node.js](https://nodejs.org/). Cette liste ne se limite pas qu'à ces éléments et on retrouve également JavaScript dans les bases de données NoSQL telles que [Apache CouchDB](https://couchdb.apache.org/), les ordinateurs embarqués ou encore des environnements de bureaux comme [GNOME](https://www.gnome.org/) (l'une des interfaces graphiques les plus populaires des systèmes d'exploitation GNU/Linux), etc.
 
-<h2 id="Overview">Aperçu</h2>
+## Aperçu
 
-<p>JavaScript est un langage dynamique multi-paradigme : il dispose de différents types, opérateurs, objets natifs et méthodes. Sa syntaxe s'inspire des langages Java et C et de nombreuses structures de ces langages s'appliquent également à JavaScript. JavaScript permet la programmation orientée objet avec les prototypes (voir <a href="/fr/docs/Web/JavaScript/Inheritance_and_the_prototype_chain">l'héritage et la chaîne de prototypes</a> et <a href="/fr/docs/Web/JavaScript/Reference/Classes">les classes</a> apparues avec ES6/ES2015). JavaScript permet également la programmation fonctionnelle car ses fonctions sont des objets et on peut donc stocker ces fonctions dans des variables et les transmettre comme n'importe quel objet.</p>
+JavaScript est un langage dynamique multi-paradigme : il dispose de différents types, opérateurs, objets natifs et méthodes. Sa syntaxe s'inspire des langages Java et C et de nombreuses structures de ces langages s'appliquent également à JavaScript. JavaScript permet la programmation orientée objet avec les prototypes (voir [l'héritage et la chaîne de prototypes](/fr/docs/Web/JavaScript/Inheritance_and_the_prototype_chain) et [les classes](/fr/docs/Web/JavaScript/Reference/Classes) apparues avec ES6/ES2015). JavaScript permet également la programmation fonctionnelle car ses fonctions sont des objets et on peut donc stocker ces fonctions dans des variables et les transmettre comme n'importe quel objet.
 
-<p>Commençons par nous intéresser aux briques de base de tout langage : les types. Les programmes en JavaScript manipulent des valeurs, et ces valeurs appartiennent toutes à un type. Les types JavaScript sont :</p>
+Commençons par nous intéresser aux briques de base de tout langage : les types. Les programmes en JavaScript manipulent des valeurs, et ces valeurs appartiennent toutes à un type. Les types JavaScript sont :
 
-<ul>
-  <li>Les nombres : <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Number"><code>Number</code></a></li>
-  <li>Les grands entiers (<i>BigInt</i>) : <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/BigInt"><code>BigInt</code></a></li>
-  <li>Les chaînes de caractères : <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String"><code>String</code></a></li>
-  <li>Les booléens : <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Boolean"><code>Boolean</code></a></li>
-  <li>Les fonctions : <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Function"><code>Function</code></a></li>
-  <li>Les objets : <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Object"><code>Object</code></a></li>
-  <li>Les symboles : <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Symbol"><code>Symbol</code></a> (apparus avec la sixième édition d'ECMAScript, ES2015)</li>
-</ul>
+- Les nombres : [`Number`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Number)
+- Les grands entiers (_BigInt_) : [`BigInt`](/fr/docs/Web/JavaScript/Reference/Global_Objects/BigInt)
+- Les chaînes de caractères : [`String`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String)
+- Les booléens : [`Boolean`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Boolean)
+- Les fonctions : [`Function`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Function)
+- Les objets : [`Object`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Object)
+- Les symboles : [`Symbol`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Symbol) (apparus avec la sixième édition d'ECMAScript, ES2015)
 
-<p>On aura également <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/undefined"><code>undefined</code></a> et <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/null"><code>null</code></a>, qui sont relativement étranges. Les <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Array">tableaux ou <code>Array</code></a> permettent d'organiser des séries d'objets au sein d'un même objet. Les <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Date">dates (<code>Date</code>)</a> et les <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/RegExp">expressions rationnelles (<code>RegExp</code>)</a> qui sont  également des objets nativement disponibles en JavaScript. Afin d'être tout à fait précis, les fonctions sont aussi une sorte particulière d'objets, de sorte que le diagramme de types ressemble plutôt à ceci :</p>
+On aura également [`undefined`](/fr/docs/Web/JavaScript/Reference/Global_Objects/undefined) et [`null`](/fr/docs/Web/JavaScript/Reference/Global_Objects/null), qui sont relativement étranges. Les [tableaux ou `Array`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Array) permettent d'organiser des séries d'objets au sein d'un même objet. Les [dates (`Date`)](/fr/docs/Web/JavaScript/Reference/Global_Objects/Date) et les [expressions rationnelles (`RegExp`)](/fr/docs/Web/JavaScript/Reference/Global_Objects/RegExp) qui sont également des objets nativement disponibles en JavaScript. Afin d'être tout à fait précis, les fonctions sont aussi une sorte particulière d'objets, de sorte que le diagramme de types ressemble plutôt à ceci :
 
-<ul>
-  <li><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Number"><code>Number</code></a></li>
-  <li><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/BigInt"><code>BigInt</code></a></li>
-  <li><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String"><code>String</code></a></li>
-  <li><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Boolean"><code>Boolean</code></a></li>
-  <li><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Symbol"><code>Symbol</code></a> (apparu avec la sixième édition d'ECMAScript, ES2015)</li>
-  <li><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Object"><code>Object</code></a>
-    <ul>
-      <li><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Function"><code>Function</code></a></li>
-      <li><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Array"><code>Array</code></a></li>
-      <li><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Date"><code>Date</code></a></li>
-      <li><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/RegExp"><code>RegExp</code></a></li>
-    </ul>
-  </li>
-  <li><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/null"><code>null</code></a></li>
-  <li><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/undefined"><code>undefined</code></a></li>
-</ul>
+- [`Number`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Number)
+- [`BigInt`](/fr/docs/Web/JavaScript/Reference/Global_Objects/BigInt)
+- [`String`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String)
+- [`Boolean`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Boolean)
+- [`Symbol`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Symbol) (apparu avec la sixième édition d'ECMAScript, ES2015)
+- [`Object`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Object)
 
-<p>Enfin, il y a également quelques types natifs pour gérer les exceptions : <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Error"><code>Error</code></a>. Pour garder une approche simple, nous utiliserons la première de ces listes pour présenter les types.</p>
+  - [`Function`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Function)
+  - [`Array`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Array)
+  - [`Date`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Date)
+  - [`RegExp`](/fr/docs/Web/JavaScript/Reference/Global_Objects/RegExp)
 
-<h2 id="numbers">Les nombres</h2>
+- [`null`](/fr/docs/Web/JavaScript/Reference/Global_Objects/null)
+- [`undefined`](/fr/docs/Web/JavaScript/Reference/Global_Objects/undefined)
 
-<p>ECMAScript possède deux types numériques intégrés : <strong>Number</strong> et <strong>BigInt</strong>.</p>
+Enfin, il y a également quelques types natifs pour gérer les exceptions : [`Error`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Error). Pour garder une approche simple, nous utiliserons la première de ces listes pour présenter les types.
 
-<p>Les nombres en JavaScript sont « des valeurs <a href="https://en.wikipedia.org/wiki/Double_precision_floating-point_format">au format IEEE 754 en double précision 64 bits</a> », d'après la spécification. Cela permet de représenter les nombres entre -(2^53 − 1) et 2^53 − 1. Lorsqu'on fait référence (ici ou dans les autres articles) à des entiers, on parle généralement d'une représentation d'un entier avec une valeur de type Number. En effet, les valeurs Number ne sont pas strictement des entiers et il faut donc prendre quelques précautions :</p>
+## Les nombres
 
-<pre class="brush: js">
+ECMAScript possède deux types numériques intégrés : **Number** et **BigInt**.
+
+Les nombres en JavaScript sont « des valeurs [au format IEEE 754 en double précision 64 bits](https://en.wikipedia.org/wiki/Double_precision_floating-point_format) », d'après la spécification. Cela permet de représenter les nombres entre -(2^53 − 1) et 2^53 − 1. Lorsqu'on fait référence (ici ou dans les autres articles) à des entiers, on parle généralement d'une représentation d'un entier avec une valeur de type Number. En effet, les valeurs Number ne sont pas strictement des entiers et il faut donc prendre quelques précautions :
+
+```js
 console.log(3 / 2);             // 1.5 et pas 1
 console.log(Math.floor(3 / 2)); // 1
-</pre>
+```
 
-<p>Ainsi, un <em>entier apparent</em> est en fait <em>implicitement un nombre à virgule flottante</em>.</p>
+Ainsi, un _entier apparent_ est en fait _implicitement un nombre à virgule flottante_.
 
-<p>Aussi, faites attention à des choses comme :</p>
+Aussi, faites attention à des choses comme :
 
-<pre class="brush: js">0.1 + 0.2 == 0.30000000000000004;</pre>
+```js
+0.1 + 0.2 == 0.30000000000000004;
+```
 
-<p>Dans la pratique, les valeurs entières sont traitées comme des entiers représentés sur 32 bits (certaines implémentations les stockent même ainsi tant qu'il n'y a pas besoin d'effectuer une opération valide pour un nombre mais pas pour un entier sur 32 bits). Cette représentation peut être importante pour les opérations binaires.</p>
+Dans la pratique, les valeurs entières sont traitées comme des entiers représentés sur 32 bits (certaines implémentations les stockent même ainsi tant qu'il n'y a pas besoin d'effectuer une opération valide pour un nombre mais pas pour un entier sur 32 bits). Cette représentation peut être importante pour les opérations binaires.
 
-<p>Les <a href="/fr/docs/Web/JavaScript/Reference/Operators#arithmetic_operators">opérateurs arithmétiques</a> standards sont gérés, dont l'addition, la soustraction, le reste arithmétique et ainsi de suite. Il existe également un objet natif, qui n'a pas été mentionné jusqu'à présent, appelé <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Math"><code>Math</code></a>, qui permet de gérer certaines fonctions et constantes mathématiques plus avancées :</p>
+Les [opérateurs arithmétiques](/fr/docs/Web/JavaScript/Reference/Operators#arithmetic_operators) standards sont gérés, dont l'addition, la soustraction, le reste arithmétique et ainsi de suite. Il existe également un objet natif, qui n'a pas été mentionné jusqu'à présent, appelé [`Math`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Math), qui permet de gérer certaines fonctions et constantes mathématiques plus avancées :
 
-<pre class="brush: js">
+```js
 Math.sin(3.5);
 let circonference = 2 * Math.PI * r;
-</pre>
+```
 
-<p>On peut convertir une chaîne de caractères en un nombre entier à l'aide de la fonction intégrée <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/parseInt"><code>parseInt()</code></a>. Elle reçoit la base de conversion comme second paramètre, qui devrait toujours être fourni afin de lever une éventuelle ambiguïté :</p>
+On peut convertir une chaîne de caractères en un nombre entier à l'aide de la fonction intégrée [`parseInt()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/parseInt). Elle reçoit la base de conversion comme second paramètre, qui devrait toujours être fourni afin de lever une éventuelle ambiguïté :
 
-<pre class="brush: js">
+```js
 parseInt("123", 10); // 123
 parseInt("010", 10); //10
-</pre>
+```
 
-<p>Si la base n'est pas indiquée, les résultats peuvent être surprenants dans les anciens navigateurs qui datent de 2013 ou avant où les chaînes commençant par <code>0</code> pouvaient ne pas être considérées comme exprimées en notation octale. À moins que vous ne soyez certain du format de votre chaîne de caractères, vous pouvez obtenir des résultats surprenants sur ces anciens navigateurs :</p>
+Si la base n'est pas indiquée, les résultats peuvent être surprenants dans les anciens navigateurs qui datent de 2013 ou avant où les chaînes commençant par `0` pouvaient ne pas être considérées comme exprimées en notation octale. À moins que vous ne soyez certain du format de votre chaîne de caractères, vous pouvez obtenir des résultats surprenants sur ces anciens navigateurs :
 
-<pre class="brush: js">
+```js
 parseInt("010");  //  8
 parseInt("0x10"); // 16
-</pre>
+```
 
-<p>Cela se produit parce que la fonction <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/parseInt"><code>parseInt()</code></a> a été implémentée pour traiter la première chaîne comme un nombre octal à cause du zéro initial et la seconde comme une représentation hexadécimale car commençant avec <code>0x</code>. Une telle notation hexadécimale peut toujours être utilisée mais la notation octale a été retirée.</p>
+Cela se produit parce que la fonction [`parseInt()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/parseInt) a été implémentée pour traiter la première chaîne comme un nombre octal à cause du zéro initial et la seconde comme une représentation hexadécimale car commençant avec `0x`. Une telle notation hexadécimale peut toujours être utilisée mais la notation octale a été retirée.
 
-<p>Si on souhaite convertir un nombre binaire en un entier, il suffit de changer la base :</p>
+Si on souhaite convertir un nombre binaire en un entier, il suffit de changer la base :
 
-<pre class="brush: js">parseInt("11", 2); // 3</pre>
+```js
+parseInt("11", 2); // 3
+```
 
-<p>De la même manière, vous pouvez traiter les nombres à virgule flottante à l'aide de la fonction intégrée <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/parseFloat"><code>parseFloat()</code></a>, qui, à la différence de <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/parseInt"><code>parseInt()</code></a>, utilise toujours la base 10.</p>
+De la même manière, vous pouvez traiter les nombres à virgule flottante à l'aide de la fonction intégrée [`parseFloat()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/parseFloat), qui, à la différence de [`parseInt()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/parseInt), utilise toujours la base 10.
 
-<p>On peut également utiliser l'opérateur unaire <code>+</code> pour convertir des valeurs en nombres :</p>
+On peut également utiliser l'opérateur unaire `+` pour convertir des valeurs en nombres :
 
-<pre class="brush: js">
+```js
 + "42";   // 42
 + "010";  // 10
 + "0x10"; // 16
-</pre>
+```
 
-<p>Une valeur spéciale appelée <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/NaN"><code>NaN</code></a> (qui signifie « <em>Not a Number</em> », soit « pas un nombre ») est renvoyée si la chaîne est non numérique :</p>
+Une valeur spéciale appelée [`NaN`](/fr/docs/Web/JavaScript/Reference/Global_Objects/NaN) (qui signifie « _Not a Number_ », soit « pas un nombre ») est renvoyée si la chaîne est non numérique :
 
-<pre class="brush: js">parseInt("coucou", 10); // NaN</pre>
+```js
+parseInt("coucou", 10); // NaN
+```
 
-<p><code>NaN</code> est « toxique » : si cette valeur est fournie en entrée pour n'importe quelle opération mathématique, le résultat sera également <code>NaN</code> :</p>
+`NaN` est « toxique » : si cette valeur est fournie en entrée pour n'importe quelle opération mathématique, le résultat sera également `NaN` :
 
-<pre class="brush: js">NaN + 5; // NaN</pre>
+```js
+NaN + 5; // NaN
+```
 
-<p>Cette valeur peut être détectée grâce à la fonction native <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Number/isNaN"><code>Number.isNaN()</code></a> (qui fait <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Number/isNaN#description">exactement ce que son nom indique</a>) :</p>
+Cette valeur peut être détectée grâce à la fonction native [`Number.isNaN()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Number/isNaN) (qui fait [exactement ce que son nom indique](/fr/docs/Web/JavaScript/Reference/Global_Objects/Number/isNaN#description)) :
 
-<pre class="brush: js">
+```js
 Number.isNaN(NaN); // true
 Number.isNaN('bonjour'); // false
 Number.isNaN('1'); // false
@@ -137,177 +138,178 @@ Number.isNaN(undefined); // false
 Number.isNaN({}); // false
 Number.isNaN([1]) // false
 Number.isNaN([1,2]) // false
-</pre>
+```
 
-<p>Mais ne testez pas le <code>NaN</code> en utilisant la fonction globale <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/isNaN"><code>isNaN()</code></a>, <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/isNaN#confusing_special-case_behavior">qui a un comportement peu intuitif</a> :</p>
+Mais ne testez pas le `NaN` en utilisant la fonction globale [`isNaN()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/isNaN), [qui a un comportement peu intuitif](/fr/docs/Web/JavaScript/Reference/Global_Objects/isNaN#confusing_special-case_behavior) :
 
-<pre class="brush: js">
+```js
 isNaN('bonjour'); // true
 isNaN('1'); // false
 isNaN(undefined); // true
 isNaN({}); // true
 isNaN([1]) // false
 isNaN([1,2]) // true
-</pre>
+```
 
-<p>JavaScript dispose également de valeur spéciales pour l'infini <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Infinity"><code>Infinity</code></a> et l'infini négatif (<code>-Infinity</code>)&nbsp;:</p>
+JavaScript dispose également de valeur spéciales pour l'infini [`Infinity`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Infinity) et l'infini négatif (`-Infinity`) :
 
-<pre class="brush: js">
+```js
 1 / 0; // Infinity
 -1 / 0; // -Infinity
-</pre>
+```
 
-<p>Il est possible de tester les valeurs <code>Infinity</code>, <code>-Infinity</code> et <code>NaN</code> à l'aide de la fonction native <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/isFinite"><code>isFinite()</code></a> :</p>
+Il est possible de tester les valeurs `Infinity`, `-Infinity` et `NaN` à l'aide de la fonction native [`isFinite()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/isFinite) :
 
-<pre class="brush: js">
+```js
 isFinite(1/0); // false
 isFinite(-Infinity); // false
 isFinite(NaN); // false
-</pre>
+```
 
-<div class="note">
-  <p><strong>Note :</strong> Les fonctions <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/parseFloat"><code>parseFloat()</code></a> et <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/parseInt"><code>parseInt()</code></a> traitent une chaîne de caractères jusqu'à ce qu'elles atteignent un caractère qui n'est pas valide pour le format numérique indiqué, puis renvoient le nombre traité jusqu'à ce point. Cependant, l'opérateur "+" convertit simplement la chaîne à <code>NaN</code> à partir du moment où la chaîne contient le moindre caractère non valide. Vous pouvez tester ce comportement en manipulant la chaîne "10.2abc" avec chaque méthode dans la console afin de mieux comprendre les différences.</p>
-</div>
+> **Note :** Les fonctions [`parseFloat()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/parseFloat) et [`parseInt()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/parseInt) traitent une chaîne de caractères jusqu'à ce qu'elles atteignent un caractère qui n'est pas valide pour le format numérique indiqué, puis renvoient le nombre traité jusqu'à ce point. Cependant, l'opérateur "+" convertit simplement la chaîne à `NaN` à partir du moment où la chaîne contient le moindre caractère non valide. Vous pouvez tester ce comportement en manipulant la chaîne "10.2abc" avec chaque méthode dans la console afin de mieux comprendre les différences.
 
-<h2 id="strings">Les chaînes de caractères</h2>
+## Les chaînes de caractères
 
-<p>Les chaînes en JavaScript sont des séquences de <a href="/fr/docs/Web/JavaScript/Guide/Grammar_and_types#unicode">caractères Unicode</a>. Cette nouvelle devrait être bien accueillie par toute personne qui a déjà eu affaire à des problèmes d'internationalisation. Pour être plus précis, ce sont des séquences de codets UTF-16 : chaque codet est représenté par un nombre sur 16 bits et chaque caractère Unicode est représenté par 1 ou 2 codets.</p>
+Les chaînes en JavaScript sont des séquences de [caractères Unicode](/fr/docs/Web/JavaScript/Guide/Grammar_and_types#unicode). Cette nouvelle devrait être bien accueillie par toute personne qui a déjà eu affaire à des problèmes d'internationalisation. Pour être plus précis, ce sont des séquences de codets UTF-16 : chaque codet est représenté par un nombre sur 16 bits et chaque caractère Unicode est représenté par 1 ou 2 codets.
 
-<p>Si vous voulez représenter un seul caractère, il suffit d'utiliser une chaîne qui contient un seul caractère.</p>
+Si vous voulez représenter un seul caractère, il suffit d'utiliser une chaîne qui contient un seul caractère.
 
-<p>Pour connaître la longueur d'une chaîne, utilisez sa propriété <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String/length"><code>length</code></a> :</p>
+Pour connaître la longueur d'une chaîne, utilisez sa propriété [`length`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String/length) :
 
-<pre class="brush: js">"bonjour".length; // 7</pre>
+```js
+"bonjour".length; // 7
+```
 
-<p>C'est notre première rencontre avec les objets JavaScript ! Les chaînes peuvent également être utilisées comme des <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Object">objets</a>. Elles possèdent aussi des <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String#instance_methods">méthodes</a> permettant de manipuler la chaîne et d'accéder à certaines informations sur cette chaîne de caractères :</p>
+C'est notre première rencontre avec les objets JavaScript ! Les chaînes peuvent également être utilisées comme des [objets](/fr/docs/Web/JavaScript/Reference/Global_Objects/Object). Elles possèdent aussi des [méthodes](/fr/docs/Web/JavaScript/Reference/Global_Objects/String#instance_methods) permettant de manipuler la chaîne et d'accéder à certaines informations sur cette chaîne de caractères :
 
-<pre class="brush: js">
+```js
 "bonjour".charAt(0); // "b"
 "coucou monde".replace("coucou", "bonjour"); // "bonjour monde"
 "bonjour".toUpperCase(); // "BONJOUR"
-</pre>
+```
 
-<h2 id="other_types">Les autres types</h2>
+## Les autres types
 
-<p>JavaScript fait la distinction entre <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/null"><code>null</code></a>, qui est un objet de type <code>object</code> indiquant une absence délibérée de valeur, et <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/undefined"><code>undefined</code></a> qui est un objet de type <code>undefined</code> indiquant une variable non initialisée — c'est-à-dire qui n'a pas encore été assignée. Nous parlerons des variables plus tard, mais en JavaScript il est possible de déclarer une variable sans lui assigner de valeur. Si vous faites cela, le type de la variable sera <code>undefined</code> qui est une constante.</p>
+JavaScript fait la distinction entre [`null`](/fr/docs/Web/JavaScript/Reference/Global_Objects/null), qui est un objet de type `object` indiquant une absence délibérée de valeur, et [`undefined`](/fr/docs/Web/JavaScript/Reference/Global_Objects/undefined) qui est un objet de type `undefined` indiquant une variable non initialisée — c'est-à-dire qui n'a pas encore été assignée. Nous parlerons des variables plus tard, mais en JavaScript il est possible de déclarer une variable sans lui assigner de valeur. Si vous faites cela, le type de la variable sera `undefined` qui est une constante.
 
-<p>JavaScript dispose d'un type booléen, dont les valeurs possibles sont <code>true</code> (vrai) et <code>false</code> (faux). L'un et l'autre sont des mots clés. Toute valeur peut être convertie en une valeur booléenne selon les règles suivantes :</p>
+JavaScript dispose d'un type booléen, dont les valeurs possibles sont `true` (vrai) et `false` (faux). L'un et l'autre sont des mots clés. Toute valeur peut être convertie en une valeur booléenne selon les règles suivantes :
 
-<ol>
-  <li><code>false</code>, <code>0</code>, la chaîne vide (<code>""</code>), <code>NaN</code>, <code>null</code> et <code>undefined</code> deviennent toutes <code>false</code> </li>
-  <li>toutes les autres valeurs deviennent <code>true</code>.</li>
-</ol>
+1.  `false`, `0`, la chaîne vide (`""`), `NaN`, `null` et `undefined` deviennent toutes `false`
+2.  toutes les autres valeurs deviennent `true`.
 
-<p>Cette conversion peut être faite de manière explicite à l'aide de la fonction <code>Boolean()</code> :</p>
+Cette conversion peut être faite de manière explicite à l'aide de la fonction `Boolean()` :
 
-<pre class="brush: js">
+```js
 Boolean("");  // false
 Boolean(234); // true
-</pre>
+```
 
-<p>Cependant, c'est rarement nécessaire, puisque JavaScript effectuera cette conversion silencieusement chaque fois qu'il attend une valeur booléenne, par exemple dans une instruction <code>if</code> (voir plus bas). Pour cette raison, on parle souvent simplement de valeurs « vraies » et « fausses » pour indiquer des valeurs devenant respectivement <code>true</code> et <code>false</code> lorsqu'elles sont converties en valeurs booléennes.</p>
+Cependant, c'est rarement nécessaire, puisque JavaScript effectuera cette conversion silencieusement chaque fois qu'il attend une valeur booléenne, par exemple dans une instruction `if` (voir plus bas). Pour cette raison, on parle souvent simplement de valeurs « vraies » et « fausses » pour indiquer des valeurs devenant respectivement `true` et `false` lorsqu'elles sont converties en valeurs booléennes.
 
-<p>Les opérations booléennes comme <code>&amp;&amp;</code> (<em>et</em> logique), <code>||</code> (<em>ou</em> logique) et <code>!</code> (<em>non</em> logique) sont également gérées, comme on le verra plus bas.</p>
+Les opérations booléennes comme `&&` (_et_ logique), `||` (_ou_ logique) et `!` (_non_ logique) sont également gérées, comme on le verra plus bas.
 
-<h2 id="variables">Les variables</h2>
+## Les variables
 
-<p>En JavaScript, on peut déclarer de nouvelles variables grâce à l'un de ces trois mots-clés : <a href="/fr/docs/Web/JavaScript/Reference/Statements/let"><code>let</code></a>, <a href="/fr/docs/Web/JavaScript/Reference/Statements/const"><code>const</code></a>, ou <code><a href="/fr/docs/Web/JavaScript/Reference/Statements/var" title="/en/JavaScript/Reference/Statements/var">var</a></code>.</p>
+En JavaScript, on peut déclarer de nouvelles variables grâce à l'un de ces trois mots-clés : [`let`](/fr/docs/Web/JavaScript/Reference/Statements/let), [`const`](/fr/docs/Web/JavaScript/Reference/Statements/const), ou [`var`](/fr/docs/Web/JavaScript/Reference/Statements/var "/en/JavaScript/Reference/Statements/var").
 
-<p><strong><code>let</code></strong> permet de déclarer des variables qui pourront être utilisées dans un bloc. La variable déclarée avec <code>let</code> est uniquement disponible dans le bloc qui contient la déclaration.</p>
+**`let`** permet de déclarer des variables qui pourront être utilisées dans un bloc. La variable déclarée avec `let` est uniquement disponible dans le bloc qui contient la déclaration.
 
-<pre class="brush: js">
+```js
 let a;
 let nom = "Simon";
-</pre>
+```
 
-<p>Voici un exemple de <em>portée</em> avec <strong><code>let</code></strong> :</p>
+Voici un exemple de _portée_ avec **`let`** :
 
-<pre class="brush: js">
+```js
 // variableLet n'est pas utilisable ici
 
-for (let variableLet = 0; variableLet &lt; 5; variableLet++) {
+for (let variableLet = 0; variableLet < 5; variableLet++) {
   // variableLet peut être utilisée ici
 }
 
 // variableLet n'est pas utilisable ici
-</pre>
+```
 
-<p><strong><code>const</code></strong> permet de déclarer des variables dont la valeur ne doit pas changer. Une variable déclarée avec <code>const</code> est disponible dans le bloc dans lequel elle est déclarée.</p>
+**`const`** permet de déclarer des variables dont la valeur ne doit pas changer. Une variable déclarée avec `const` est disponible dans le bloc dans lequel elle est déclarée.
 
-<pre class="brush: js">
+```js
 const Pi = 3.14; // la constante Pi est définie
 Pi = 1; // produira une erreur, car on ne peut pas modifier une variable constante.
-</pre>
+```
 
-<p><strong><code>var</code></strong> est le mot-clé le plus fréquemment utilisé pour déclarer des variables. Ce mot-clé était disponible avant <code>let</code> et <code>const</code> (c'était alors le seul qui permettait de déclarer des variables). Une variable qu'on déclare avec <strong><code>var</code></strong> est disponible dans la <em>fonction</em> dans laquelle elle est déclarée.</p>
+**`var`** est le mot-clé le plus fréquemment utilisé pour déclarer des variables. Ce mot-clé était disponible avant `let` et `const` (c'était alors le seul qui permettait de déclarer des variables). Une variable qu'on déclare avec **`var`** est disponible dans la _fonction_ dans laquelle elle est déclarée.
 
-<pre class="brush: js">
+```js
 var a;
 var nom = "simon";
-</pre>
+```
 
-<p>Voici un exemple pour étudier la portée d'une variable déclarée avec <strong><code>var</code></strong> :</p>
+Voici un exemple pour étudier la portée d'une variable déclarée avec **`var`** :
 
-<pre class="brush: js">
+```js
 // variableVar *est* utilisable ici
 
-for (var variableVar = 0; variableVar &lt; 5; variableVar++) {
+for (var variableVar = 0; variableVar < 5; variableVar++) {
   // variableVar *est* également disponible ici
 }
 
-// variableVar *est* toujours disponible ici</pre>
+// variableVar *est* toujours disponible ici
+```
 
-<p>Si on déclare une variable sans lui affecter aucune valeur, son type sera alors <code>undefined</code>.</p>
+Si on déclare une variable sans lui affecter aucune valeur, son type sera alors `undefined`.
 
-<p>JavaScript possède une différence importante quant aux autres langages de programmation comme Java&nbsp;: en JavaScript, les blocs ne créent pas de portées pour les variables déclarées avec <code>var</code>, c'est la fonction qui gère la portée d'une variable déclarée avec <code>var</code>. Aussi, si une variable est définie avec <code>var</code> au sein d'une instruction conditionnelle avec <code>if</code>, cette variable sera visible depuis l'ensemble de la fonction. Avec ECMAScript 2015, les instructions de déclarations, <a href="/fr/docs/Web/JavaScript/Reference/Statements/let"><code>let</code></a> et <a href="/fr/docs/Web/JavaScript/Reference/Statements/const"><code>const</code></a> permettent de créer des variables dont la portée est limitée à celle du bloc qui l'englobe.</p>
+JavaScript possède une différence importante quant aux autres langages de programmation comme Java : en JavaScript, les blocs ne créent pas de portées pour les variables déclarées avec `var`, c'est la fonction qui gère la portée d'une variable déclarée avec `var`. Aussi, si une variable est définie avec `var` au sein d'une instruction conditionnelle avec `if`, cette variable sera visible depuis l'ensemble de la fonction. Avec ECMAScript 2015, les instructions de déclarations, [`let`](/fr/docs/Web/JavaScript/Reference/Statements/let) et [`const`](/fr/docs/Web/JavaScript/Reference/Statements/const) permettent de créer des variables dont la portée est limitée à celle du bloc qui l'englobe.
 
-<h2 id="operators">Les opérateurs</h2>
+## Les opérateurs
 
-<p>Les opérateurs numériques en JavaScript sont <code>+</code>, <code>-</code>, <code>*</code>, <code>/</code> et <code>%</code> (qui est <a href="/fr/docs/conflicting/Web/JavaScript/Reference/Operators#remainder_()">l'opérateur de reste, à ne pas confondre avec le « modulo » mathématique</a>). Les valeurs sont affectées à l'aide de <code>=</code> et il existe également des opérateurs d'affectation combinés comme <code>+=</code> et <code>-=</code>. Ils sont équivalents à <code>x = x <em>opérateur</em> y</code>.</p>
+Les opérateurs numériques en JavaScript sont `+`, `-`, `*`, `/` et `%` (qui est [l'opérateur de reste, à ne pas confondre avec le « modulo » mathématique](</fr/docs/conflicting/Web/JavaScript/Reference/Operators#remainder_()>)). Les valeurs sont affectées à l'aide de `=` et il existe également des opérateurs d'affectation combinés comme `+=` et `-=`. Ils sont équivalents à `x = x opérateur y`.
 
-<pre class="brush: js">
+```js
 x += 5;
 x = x + 5;
-</pre>
+```
 
-<p>Vous pouvez utiliser <code>++</code> et <code>--</code> respectivement pour incrémenter et pour décrémenter. Ils peuvent être utilisés comme opérateurs préfixes ou suffixes.</p>
+Vous pouvez utiliser `++` et `--` respectivement pour incrémenter et pour décrémenter. Ils peuvent être utilisés comme opérateurs préfixes ou suffixes.
 
-<p>L'<a href="/fr/docs/conflicting/Web/JavaScript/Reference/Operators#addition_(.2b)">opérateur <code>+</code> </a> permet également de concaténer des chaînes :</p>
+L'[opérateur `+` ](</fr/docs/conflicting/Web/JavaScript/Reference/Operators#addition_(.2b)>)permet également de concaténer des chaînes :
 
-<pre class="brush: js">"coucou" + " monde"; // "coucou monde"</pre>
+```js
+"coucou" + " monde"; // "coucou monde"
+```
 
-<p>Si vous additionnez une chaîne à un nombre (ou une autre valeur), tout est d'abord converti en une chaîne. Ceci pourrait vous surprendre :</p>
+Si vous additionnez une chaîne à un nombre (ou une autre valeur), tout est d'abord converti en une chaîne. Ceci pourrait vous surprendre :
 
-<pre class="brush: js">
+```js
 "3" + 4 + 5; // "345"
 3 + 4 + "5"; // "75"
-</pre>
+```
 
-<p>L'ajout d'une chaîne vide à une valeur est une manière utile de convertir cette valeur une chaîne de caractères.</p>
+L'ajout d'une chaîne vide à une valeur est une manière utile de convertir cette valeur une chaîne de caractères.
 
-<p>Les <a href="/fr/docs/Web/JavaScript/Reference/Operators">comparaisons</a> en JavaScript se font à l'aide des opérateurs <code>&lt;</code>, <code>&gt;</code>, <code>&lt;=</code> et <code>&gt;=</code>. Ceux-ci fonctionnent tant pour les chaînes que pour les nombres. L'égalité est un peu moins évidente. L'opérateur double égal effectue une équivalence si vous lui donnez des types différents, ce qui donne parfois des résultats intéressants :</p>
+Les [comparaisons](/fr/docs/Web/JavaScript/Reference/Operators) en JavaScript se font à l'aide des opérateurs `<`, `>`, `<=` et `>=`. Ceux-ci fonctionnent tant pour les chaînes que pour les nombres. L'égalité est un peu moins évidente. L'opérateur double égal effectue une équivalence si vous lui donnez des types différents, ce qui donne parfois des résultats intéressants :
 
-<pre class="brush: js">
+```js
 123 == "123"; // true
 1 == true;    // true
-</pre>
+```
 
-<p>Pour éviter les conversions implicites avant les comparaisons, utilisez l'opérateur triple égal :</p>
+Pour éviter les conversions implicites avant les comparaisons, utilisez l'opérateur triple égal :
 
-<pre class="brush: js">
+```js
 123 === "123"; //false
 true === true; // true
-</pre>
+```
 
-<p>Les opérateurs <code>!=</code> et <code>!==</code> existent également.</p>
+Les opérateurs `!=` et `!==` existent également.
 
-<p>JavaScript dispose également d'<a href="/fr/docs/Web/JavaScript/Reference/Operators">opérations bit à bit</a>.</p>
+JavaScript dispose également d'[opérations bit à bit](/fr/docs/Web/JavaScript/Reference/Operators).
 
-<h2 id="control_structures">Les structures de contrôle</h2>
+## Les structures de contrôle
 
-<p>JavaScript dispose d'un ensemble de structures de contrôle similaires aux autres langages de la famille du langage C. Les structures conditionnelles sont présentes avec <code>if</code> et <code>else</code> ; lesquels peuvent être chaînés si nécessaire :</p>
+JavaScript dispose d'un ensemble de structures de contrôle similaires aux autres langages de la famille du langage C. Les structures conditionnelles sont présentes avec `if` et `else` ; lesquels peuvent être chaînés si nécessaire :
 
-<pre class="brush: js">
+```js
 let nom = "des chatons";
 if (nom == "des chiots") {
   nom += " !";
@@ -317,11 +319,11 @@ if (nom == "des chiots") {
   nom = " !" + nom;
 }
 nom == "des chatons !!"
-</pre>
+```
 
-<p>JavaScript dispose également de boucles <code>while</code> et <code>do-while</code>. Les premières permettent de former des boucles basiques ; les secondes permettent de construire des boucles qui seront exécutées au moins une fois :</p>
+JavaScript dispose également de boucles `while` et `do-while`. Les premières permettent de former des boucles basiques ; les secondes permettent de construire des boucles qui seront exécutées au moins une fois :
 
-<pre class="brush: js">
+```js
 while (true) {
   // une boucle infinie !
 }
@@ -330,53 +332,61 @@ let input;
 do {
   input = getInput();
 } while (inputNonValide(input));
-</pre>
+```
 
-<p>Les boucles <a href="/fr/docs/Web/JavaScript/Reference/Statements/for"><code>for</code></a> en JavaScript sont les mêmes qu'en C et en Java : elles permettent de fournir les informations de contrôle de la boucle en une seule ligne.</p>
+Les boucles [`for`](/fr/docs/Web/JavaScript/Reference/Statements/for) en JavaScript sont les mêmes qu'en C et en Java : elles permettent de fournir les informations de contrôle de la boucle en une seule ligne.
 
-<pre class="brush: js">
-for (let i = 0; i &lt; 5; i++) {
+```js
+for (let i = 0; i < 5; i++) {
   // Sera exécutée cinq fois
 }
-</pre>
+```
 
-<p>JavaScript permet également d'utiliser deux autres types de boucles : <a href="/fr/docs/Web/JavaScript/Reference/Statements/for...of"><code>for</code>...<code>of</code></a> :</p>
+JavaScript permet également d'utiliser deux autres types de boucles : [`for`...`of`](/fr/docs/Web/JavaScript/Reference/Statements/for...of) :
 
-<pre class="brush: js">
+```js
 for (let element of tableau) {
   // utiliser des instructions
   // pour manipuler la valeur element
 }
-</pre>
+```
 
-<p>et <a href="/fr/docs/Web/JavaScript/Reference/Statements/for...in"><code>for</code>...<code>in</code></a> :</p>
+et [`for`...`in`](/fr/docs/Web/JavaScript/Reference/Statements/for...in) :
 
-<pre class="brush: js">
+```js
 for (let propriete in objet) {
   // utiliser des instructions
   // pour manipuler la propriété de l'objet
 }
-</pre>
+```
 
-<p>Les opérateurs <code>&amp;&amp;</code> et <code>||</code> utilisent une logique de court-circuit, ce qui signifie qu'ils exécuteront leur second opérande ou non selon la valeur du premier. C'est très utile pour vérifier qu'un objet n'est pas égal à <code>null</code> avant d'essayer d'accéder à ses attributs :</p>
+Les opérateurs `&&` et `||` utilisent une logique de court-circuit, ce qui signifie qu'ils exécuteront leur second opérande ou non selon la valeur du premier. C'est très utile pour vérifier qu'un objet n'est pas égal à `null` avant d'essayer d'accéder à ses attributs :
 
-<pre class="brush: js">let nom = o &amp;&amp; o.getNom();</pre>
+```js
+let nom = o && o.getNom();
+```
 
-<p>Ou pour définir des valeurs par défaut :</p>
+Ou pour définir des valeurs par défaut :
 
-<pre class="brush: js">let nom = autreNom || "nomParDéfaut";</pre>
+```js
+let nom = autreNom || "nomParDéfaut";
+```
 
-<p>De la même façon, le OU peut être utilisé pour mettre en cache des valeurs (lorsque les valeurs équivalentes à faux sont invalides) :</p>
+De la même façon, le OU peut être utilisé pour mettre en cache des valeurs (lorsque les valeurs équivalentes à faux sont invalides) :
 
-<pre class="brush: js">let nom = nomEnCache || (nomEnCache = getNom());</pre>
+```js
+let nom = nomEnCache || (nomEnCache = getNom());
+```
 
-<p>JavaScript propose également un opérateur ternaire pour les assignations conditionnelles en une ligne :</p>
+JavaScript propose également un opérateur ternaire pour les assignations conditionnelles en une ligne :
 
-<pre class="brush: js">let permis = (age &gt; 18) ? "oui" : "non";</pre>
+```js
+let permis = (age > 18) ? "oui" : "non";
+```
 
-<p>L'instruction <code>switch</code> peut être utilisée pour différentes branches de code basées sur un nombre ou une chaîne :</p>
+L'instruction `switch` peut être utilisée pour différentes branches de code basées sur un nombre ou une chaîne :
 
-<pre class="brush: js">
+```js
 switch (action) {
   case 'dessiner':
     dessine();
@@ -387,58 +397,64 @@ switch (action) {
   default:
     neRienFaire();
 }
-</pre>
+```
 
-<p>Si vous n'ajoutez pas d'instruction <code>break</code>, l'exécution va se poursuivre au niveau suivant. C'est rarement ce qui est désiré, en fait ça vaut même la peine de préciser dans un commentaire si la poursuite au cas suivant est délibérée pour aider au débogage :</p>
+Si vous n'ajoutez pas d'instruction `break`, l'exécution va se poursuivre au niveau suivant. C'est rarement ce qui est désiré, en fait ça vaut même la peine de préciser dans un commentaire si la poursuite au cas suivant est délibérée pour aider au débogage :
 
-<pre class="brush: js">switch (a) {
+```js
+switch (a) {
   case 1: // identique au cas 2
   case 2:
     mange();
     break;
   default:
     nerienfaire();
-}</pre>
+}
+```
 
-<p>La clause <code>default</code> est optionnelle. Vous pouvez placer des expressions à la fois dans la partie <code>switch</code> et dans les cas à gérer si vous voulez ; les comparaisons entre les deux se font comme si on avait utilisé l'opérateur <code>===</code> :</p>
+La clause `default` est optionnelle. Vous pouvez placer des expressions à la fois dans la partie `switch` et dans les cas à gérer si vous voulez ; les comparaisons entre les deux se font comme si on avait utilisé l'opérateur `===` :
 
-<pre class="brush: js">switch (1 + 3){
+```js
+switch (1 + 3){
   case 2 + 2:
     yay();
     break;
   default:
     nArriveJamais();
-}</pre>
+}
+```
 
-<h2 id="objects">Les objets</h2>
+## Les objets
 
-<p>Les objets en JavaScript sont simplement des collections de paires nom-valeur. Dans ce sens, ils sont similaires aux :</p>
+Les objets en JavaScript sont simplement des collections de paires nom-valeur. Dans ce sens, ils sont similaires aux :
 
-<ul>
-  <li>dictionnaires en Python,</li>
-  <li>hashs en Perl et Ruby,</li>
-  <li>tables de hachage en C et C++,</li>
-  <li>HashMaps en Java,</li>
-  <li>tableaux associatifs en PHP.</li>
-</ul>
+- dictionnaires en Python,
+- hashs en Perl et Ruby,
+- tables de hachage en C et C++,
+- HashMaps en Java,
+- tableaux associatifs en PHP.
 
-<p>Le fait que cette structure de données soit si largement utilisée est un témoignage de sa polyvalence. Puisque tout (sauf les types de base) est un objet en JavaScript, tout programme écrit dans ce langage implique naturellement un grand nombre de recherches dans des tables de hachage. C'est une bonne chose que ce soit si rapide !</p>
+Le fait que cette structure de données soit si largement utilisée est un témoignage de sa polyvalence. Puisque tout (sauf les types de base) est un objet en JavaScript, tout programme écrit dans ce langage implique naturellement un grand nombre de recherches dans des tables de hachage. C'est une bonne chose que ce soit si rapide !
 
-<p>La partie « nom » est une chaîne JavaScript, tandis que la partie « valeur » peut être n'importe quelle valeur JavaScript, y compris d'autres objets. Cela permet de construire des structures de données de n'importe quel niveau de complexité.</p>
+La partie « nom » est une chaîne JavaScript, tandis que la partie « valeur » peut être n'importe quelle valeur JavaScript, y compris d'autres objets. Cela permet de construire des structures de données de n'importe quel niveau de complexité.
 
-<p>Il existe deux façons très simples pour créer un objet vide :</p>
+Il existe deux façons très simples pour créer un objet vide :
 
-<pre class="brush: js">let obj = new Object();</pre>
+```js
+let obj = new Object();
+```
 
-<p>Et :</p>
+Et :
 
-<pre class="brush: js">let obj = {};</pre>
+```js
+let obj = {};
+```
 
-<p>Ils sont sémantiquement équivalents ; la seconde écriture est appelée syntaxe littérale d'objet et est plus pratique. Cette syntaxe est également au cœur du format JSON et devrait être privilégiée à tout moment.</p>
+Ils sont sémantiquement équivalents ; la seconde écriture est appelée syntaxe littérale d'objet et est plus pratique. Cette syntaxe est également au cœur du format JSON et devrait être privilégiée à tout moment.
 
-<p>La syntaxe littérale pour écrire un objet peut être utilisée afin d'initialiser tout un objet :</p>
+La syntaxe littérale pour écrire un objet peut être utilisée afin d'initialiser tout un objet :
 
-<pre class="brush: js">
+```js
 let obj = {
   name: 'Carotte',
   _for: 'Max', // Le mot "for" est un mot réservé, utilisez plutôt "_for".
@@ -446,18 +462,19 @@ let obj = {
     color: 'orange',
     size: 12
   }
-};</pre>
+};
+```
 
-<p>L'accès aux attributs peut être enchaîné :</p>
+L'accès aux attributs peut être enchaîné :
 
-<pre class="brush: js">
+```js
 obj.details.color; // orange
 obj['details']['size']; // 12
-</pre>
+```
 
-<p>L'exemple suivant crée un prototype d'objet (<code>Person</code>) et une instance de ce prototype (<code>you</code>).</p>
+L'exemple suivant crée un prototype d'objet (`Person`) et une instance de ce prototype (`you`).
 
-<pre class="brush: js">
+```js
 function Person(name, age) {
   this.name = name;
   this.age = age;
@@ -466,226 +483,183 @@ function Person(name, age) {
 // Définir un objet
 let you = new Person('You', 24);
 // Nous créons une nouvelle personne nommée "You" âgée de 24 ans.
-</pre>
+```
 
-<p><strong>Une fois l'objet créé</strong>, on peut accéder à ses propriétés de l'une des deux manières suivantes :</p>
+**Une fois l'objet créé**, on peut accéder à ses propriétés de l'une des deux manières suivantes :
 
-<pre class="brush: js">
+```js
 // notation par points
 obj.name = 'Simon';
 let name = obj.name;
-</pre>
+```
 
-<p>Et…</p>
+Et…
 
-<pre class="brush: js">
+```js
 // notation entre crochets
 obj['name'] = 'Simon';
 let name = obj['name'];
 // on peut utiliser une variable pour définir une clé
 let user = prompt('quelle clé ?');
 obj[user] = prompt('quelle valeur ?');
-</pre>
+```
 
-<p>Ces deux méthodes sont également sémantiquement équivalentes. La seconde méthode a l'avantage de fournir le nom de l'attribut de l'objet dans une chaîne, ce qui signifie qu'il peut être calculé au moment de l'exécution (mais ce qui peut empêcher certaines optimisations du moteur JavaScript). Elle peut également être utilisée pour définir et lire des propriétés dont les noms sont des <a href="/fr/docs/Web/JavaScript/Reference/Lexical_grammar#keywords">mots réservés</a> :</p>
+Ces deux méthodes sont également sémantiquement équivalentes. La seconde méthode a l'avantage de fournir le nom de l'attribut de l'objet dans une chaîne, ce qui signifie qu'il peut être calculé au moment de l'exécution (mais ce qui peut empêcher certaines optimisations du moteur JavaScript). Elle peut également être utilisée pour définir et lire des propriétés dont les noms sont des [mots réservés](/fr/docs/Web/JavaScript/Reference/Lexical_grammar#keywords) :
 
-<pre class="brush: js">
+```js
 obj.for = "Simon"; // erreur de syntaxe, car "for" est un mot réservé
 obj["for"] = "Simon"; // fonctionne très bien
-</pre>
+```
 
-<div class="note">
-  <p><strong>Note :</strong> À partir d'ECMAScript 5, les mots réservés peuvent être utilisés comme noms de propriétés d'objets « en vrac ». Cela signifie qu'ils n'ont pas besoin d'être « habillés » de guillemets lors de la définition des littéraux d'objet. Voir <a href="https://es5.github.io/#x7.6.1">la spécification ES5</a>.</p>
-</div>
+> **Note :** À partir d'ECMAScript 5, les mots réservés peuvent être utilisés comme noms de propriétés d'objets « en vrac ». Cela signifie qu'ils n'ont pas besoin d'être « habillés » de guillemets lors de la définition des littéraux d'objet. Voir [la spécification ES5](https://es5.github.io/#x7.6.1).
 
-<p>Pour en savoir plus sur les objets et les prototypes, voir <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Object"><code>Object.prototype</code></a>. Pour une explication des prototypes d'objets et des chaînes de prototypes, voir <a href="/fr/docs/Web/JavaScript/Inheritance_and_the_prototype_chain">l'héritage et la chaîne de prototypes</a>.</p>
+Pour en savoir plus sur les objets et les prototypes, voir [`Object.prototype`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Object). Pour une explication des prototypes d'objets et des chaînes de prototypes, voir [l'héritage et la chaîne de prototypes](/fr/docs/Web/JavaScript/Inheritance_and_the_prototype_chain).
 
-<div class="note">
-  <p><strong>Note :</strong> À partir d'ECMAScript 2015, les clés des objets peuvent être définies par la variable en utilisant la notation entre parenthèses lors de sa création. <code>{[phoneType] : 12345}</code> est possible au lieu de simplement <code>var userPhone = {}; userPhone[phoneType] = 12345;</code>.</p>
-</div>
+> **Note :** À partir d'ECMAScript 2015, les clés des objets peuvent être définies par la variable en utilisant la notation entre parenthèses lors de sa création. `{[phoneType] : 12345}` est possible au lieu de simplement `var userPhone = {}; userPhone[phoneType] = 12345;`.
 
-<h2 id="arrays">Les tableaux</h2>
+## Les tableaux
 
-<p>Les tableaux (<em>Arrays</em>) en JavaScript sont en fait un type spécial d'objets. Ils fonctionnent d'une façon tout à fait similaire aux objets normaux (on peut naturellement accéder aux propriétés numériques avec la syntaxe des crochets <code>[]</code>), mais ils ont également une propriété magique appelée <code>length</code>. Elle vaut toujours un de plus que le plus grand indice dans le tableau.</p>
+Les tableaux (_Arrays_) en JavaScript sont en fait un type spécial d'objets. Ils fonctionnent d'une façon tout à fait similaire aux objets normaux (on peut naturellement accéder aux propriétés numériques avec la syntaxe des crochets `[]`), mais ils ont également une propriété magique appelée `length`. Elle vaut toujours un de plus que le plus grand indice dans le tableau.
 
-<p>L'ancienne manière de créer des tableaux est celle-ci :</p>
+L'ancienne manière de créer des tableaux est celle-ci :
 
-<pre class="brush: js">
+```js
 let a = new Array();
 a[0] = "chien";
 a[1] = "chat";
 a[2] = "poule";
 a.length; // 3
-</pre>
+```
 
-<p>Une notation plus pratique est la syntaxe littérale :</p>
+Une notation plus pratique est la syntaxe littérale :
 
-<pre class="brush: js">
+```js
 let a = ["chien", "chat", "poule"];
 a.length; // 3
-</pre>
+```
 
-<p>Notez que <code>array.length</code> ne correspond pas nécessairement au nombre d'éléments dans le tableau. Observez le code suivant :</p>
+Notez que `array.length` ne correspond pas nécessairement au nombre d'éléments dans le tableau. Observez le code suivant :
 
-<pre class="brush: js">
+```js
 let a = ["chien", "chat", "poule"];
 a[100] = "renard";
 a.length // 101
-</pre>
+```
 
-<p>Rappelez-vous : la longueur du tableau vaut simplement un de plus que l'indice le plus élevé.</p>
+Rappelez-vous : la longueur du tableau vaut simplement un de plus que l'indice le plus élevé.
 
-<p>Si vous interrogez un élément de tableau non existant, vous obtenez <code>undefined</code> :</p>
+Si vous interrogez un élément de tableau non existant, vous obtenez `undefined` :
 
-<pre class="brush: js">typeof(a[90]); // undefined</pre>
+```js
+typeof(a[90]); // undefined
+```
 
-<p>Si vous prenez cela en compte, il est possible de parcourir un tableau à l'aide de la boucle suivante :</p>
+Si vous prenez cela en compte, il est possible de parcourir un tableau à l'aide de la boucle suivante :
 
-<pre class="brush: js">
-for (let i = 0; i &lt; a.length; i++) {
+```js
+for (let i = 0; i < a.length; i++) {
   // Faire quelque chose avec a[i]
 }
-</pre>
+```
 
-<p>ES2015 a introduit la boucle plus concise <a href="/fr/docs/Web/JavaScript/Reference/Statements/for...of"><code>for</code>...<code>of</code></a> pour les objets itérables tels que les tableaux :</p>
+ES2015 a introduit la boucle plus concise [`for`...`of`](/fr/docs/Web/JavaScript/Reference/Statements/for...of) pour les objets itérables tels que les tableaux :
 
-<pre class="brush: js">
+```js
 for (const currentValue of a) {
   // Faire quelque chose avec currentValue
 }
-</pre>
+```
 
-<p>Vous pourriez également itérer sur un tableau en utilisant une boucle <a href="/fr/docs/Web/JavaScript/Reference/Statements/for...in"><code>for</code>...<code>in</code></a>, cependant cela n'itère pas sur les éléments du tableau, mais sur les indices du tableau. De plus, si quelqu'un ajoutait de nouvelles propriétés à <code>Array.prototype</code>, elles seraient également parcourues par une telle boucle. Par conséquent, ce type de boucle n'est pas recommandé pour les tableaux.</p>
+Vous pourriez également itérer sur un tableau en utilisant une boucle [`for`...`in`](/fr/docs/Web/JavaScript/Reference/Statements/for...in), cependant cela n'itère pas sur les éléments du tableau, mais sur les indices du tableau. De plus, si quelqu'un ajoutait de nouvelles propriétés à `Array.prototype`, elles seraient également parcourues par une telle boucle. Par conséquent, ce type de boucle n'est pas recommandé pour les tableaux.
 
-<p>Une autre façon d'itérer sur un tableau qui a été ajoutée avec ECMAScript 5 est <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach"><code>forEach()</code></a> :</p>
+Une autre façon d'itérer sur un tableau qui a été ajoutée avec ECMAScript 5 est [`forEach()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach) :
 
-<pre class="brush: js">
+```js
 ['chien', 'chat', 'poule'].forEach(function(currentValue, index, array) {
   // Faire quelque chose avec currentValue ou array[index]
 });
-</pre>
-
-<p>Si vous voulez ajouter un élément à un tableau, procédez comme suit :</p>
-
-<pre class="brush: js">a.push(item);</pre>
-
-<p>Les tableaux sont accompagnés d'un certain nombre de méthodes. Voir également la <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Array">documentation complète sur les méthodes des tableaux</a>.</p>
-
-<table class="standard-table">
-  <thead>
-    <tr>
-      <th scope="col">Nom de la méthode</th>
-      <th scope="col">Description</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td><code>a.toString()</code></td>
-      <td>Renvoie une chaîne composée des différents éléments auxquels on a appliqué <code>toString()</code>, séparés par des virgules.</td>
-    </tr>
-    <tr>
-      <td><code>a.toLocaleString()</code></td>
-      <td>Renvoie une chaîne composée des différents éléments auxquels on a appliqué <code>toLocaleString()</code>, séparés par des virgules.</td>
-    </tr>
-    <tr>
-      <td><code>a.concat(item1[, item2[, ...[, itemN]]])</code></td>
-      <td>Renvoie un nouveau tableau auquel on a ajouté les éléments.</td>
-    </tr>
-    <tr>
-      <td><code>a.join(sep)</code></td>
-      <td>Convertit le tableau en une chaîne dont les valeurs sont séparées par le paramètre <code>sep</code>.</td>
-    </tr>
-    <tr>
-      <td><code>a.pop()</code></td>
-      <td>Renvoie le dernier élément du tableau et le retire du tableau.</td>
-    </tr>
-    <tr>
-      <td><code>a.push(item1, ..., itemN)</code></td>
-      <td>Ajoute un ou plusieurs éléments à la fin du tableau.</td>
-    </tr>
-    <tr>
-      <td><code>a.shift()</code></td>
-      <td>Renvoie le premier élément du tableau et le retire du tableau.</td>
-    </tr>
-    <tr>
-      <td><code>a.unshift(item1[, item2[, ...[, itemN]]])</code></td>
-      <td>Ajoute des éléments au début du tableau.</td>
-    </tr>
-    <tr>
-      <td><code>a.slice(start[, end])</code></td>
-      <td>Renvoie un sous-tableau.</td>
-    </tr>
-    <tr>
-      <td><code>a.sort([cmpfn])</code></td>
-      <td>Trie le tableau (avec une fonction de comparaison optionnelle).</td>
-    </tr>
-    <tr>
-      <td><code>a.splice(start, delcount[, item1[, ...[, itemN]]])</code></td>
-      <td>Permet de modifier un tableau en en supprimant une partie et en la remplaçant avec plus d'éléments.</td>
-    </tr>
-    <tr>
-      <td><code>a.reverse()</code></td>
-      <td>Retourne le tableau.</td>
-    </tr>
-  </tbody>
-</table>
-
-<h2 id="functions">Les fonctions</h2>
-
-<p>Avec les objets, les fonctions sont les composants de base d'une bonne compréhension de JavaScript. La fonction la plus basique n'a rien de compliqué :</p>
-
-<pre class="brush: js">
+```
+
+Si vous voulez ajouter un élément à un tableau, procédez comme suit :
+
+```js
+a.push(item);
+```
+
+Les tableaux sont accompagnés d'un certain nombre de méthodes. Voir également la [documentation complète sur les méthodes des tableaux](/fr/docs/Web/JavaScript/Reference/Global_Objects/Array).
+
+| Nom de la méthode                                    | Description                                                                                                              |
+| ---------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------ |
+| `a.toString()`                                       | Renvoie une chaîne composée des différents éléments auxquels on a appliqué `toString()`, séparés par des virgules.       |
+| `a.toLocaleString()`                                 | Renvoie une chaîne composée des différents éléments auxquels on a appliqué `toLocaleString()`, séparés par des virgules. |
+| `a.concat(item1[, item2[, ...[, itemN]]])`           | Renvoie un nouveau tableau auquel on a ajouté les éléments.                                                              |
+| `a.join(sep)`                                        | Convertit le tableau en une chaîne dont les valeurs sont séparées par le paramètre `sep`.                                |
+| `a.pop()`                                            | Renvoie le dernier élément du tableau et le retire du tableau.                                                           |
+| `a.push(item1, ..., itemN)`                          | Ajoute un ou plusieurs éléments à la fin du tableau.                                                                     |
+| `a.shift()`                                          | Renvoie le premier élément du tableau et le retire du tableau.                                                           |
+| `a.unshift(item1[, item2[, ...[, itemN]]])`          | Ajoute des éléments au début du tableau.                                                                                 |
+| `a.slice(start[, end])`                              | Renvoie un sous-tableau.                                                                                                 |
+| `a.sort([cmpfn])`                                    | Trie le tableau (avec une fonction de comparaison optionnelle).                                                          |
+| `a.splice(start, delcount[, item1[, ...[, itemN]]])` | Permet de modifier un tableau en en supprimant une partie et en la remplaçant avec plus d'éléments.                      |
+| `a.reverse()`                                        | Retourne le tableau.                                                                                                     |
+
+## Les fonctions
+
+Avec les objets, les fonctions sont les composants de base d'une bonne compréhension de JavaScript. La fonction la plus basique n'a rien de compliqué :
+
+```js
 function ajoute(x, y) {
   let total = x + y;
   return total;
 }
-</pre>
+```
 
-<p>Ceci représente tout ce qu'il y a à savoir à propos des fonctions basiques. Une fonction JavaScript peut recevoir 0 paramètre nommé ou plus. Son corps peut contenir autant d'instructions que vous le voulez et permet de déclarer des variables qui sont locales à la fonction. L'instruction <code>return</code> peut être utilisée pour renvoyer une valeur à tout moment, mettant ainsi fin à la fonction. Si aucune instruction <code>return</code> n'est utilisée (ou que l'instruction <code>return</code> n'est suivie d'aucune valeur), JavaScript renvoie <code>undefined</code>.</p>
+Ceci représente tout ce qu'il y a à savoir à propos des fonctions basiques. Une fonction JavaScript peut recevoir 0 paramètre nommé ou plus. Son corps peut contenir autant d'instructions que vous le voulez et permet de déclarer des variables qui sont locales à la fonction. L'instruction `return` peut être utilisée pour renvoyer une valeur à tout moment, mettant ainsi fin à la fonction. Si aucune instruction `return` n'est utilisée (ou que l'instruction `return` n'est suivie d'aucune valeur), JavaScript renvoie `undefined`.
 
-<p>On se rendra compte que les paramètres sont plus des indications qu'autre chose. Il est en effet possible d'appeler une fonction sans lui fournir les paramètres qu'elle attend, auquel cas ils vaudront <code>undefined</code>.</p>
+On se rendra compte que les paramètres sont plus des indications qu'autre chose. Il est en effet possible d'appeler une fonction sans lui fournir les paramètres qu'elle attend, auquel cas ils vaudront `undefined`.
 
-<pre class="brush: js">
+```js
 ajoute(); // NaN 
 // Il n'est pas possible d'additionner des variables indéfinies
-</pre>
+```
 
-<p>Il est également possible de fournir plus de paramètres que demandé par la fonction :</p>
+Il est également possible de fournir plus de paramètres que demandé par la fonction :
 
-<pre class="brush: js">
+```js
 ajoute(2, 3, 4); // 5
 // les deux premiers sont additionnés ; 4 est ignoré
-</pre>
+```
 
-<p>Par définition les fonctions ont accès à des variables supplémentaires à l'intérieur de leur corps, appelée <a href="/fr/docs/Web/JavaScript/Reference/Functions/arguments"><code>arguments</code></a>. Il s'agit d'un objet semblable à un tableau qui contient toutes les valeurs reçues par la fonction. Réécrivons la fonction <code>ajoute</code> pour recevoir autant de valeurs qu'on veut :</p>
+Par définition les fonctions ont accès à des variables supplémentaires à l'intérieur de leur corps, appelée [`arguments`](/fr/docs/Web/JavaScript/Reference/Functions/arguments). Il s'agit d'un objet semblable à un tableau qui contient toutes les valeurs reçues par la fonction. Réécrivons la fonction `ajoute` pour recevoir autant de valeurs qu'on veut :
 
-<pre class="brush: js">function ajoute() {
+```js
+function ajoute() {
   let somme = 0;
-  for (let i = 0, j = arguments.length; i &lt; j; i++) {
+  for (let i = 0, j = arguments.length; i < j; i++) {
     somme += arguments[i];
   }
   return somme;
 }
 
 ajoute(2, 3, 4, 5); // 14
-</pre>
+```
 
-<p>Ce n'est cependant pas vraiment plus utile que d'écrire <code>2 + 3 + 4 + 5</code>. Écrivons plutôt une fonction de calcul de moyenne :</p>
+Ce n'est cependant pas vraiment plus utile que d'écrire `2 + 3 + 4 + 5`. Écrivons plutôt une fonction de calcul de moyenne :
 
-<pre class="brush: js">
+```js
 function moyenne() {
   let somme = 0;
-  for (let i = 0, j = arguments.length; i &lt; j; i++) {
+  for (let i = 0, j = arguments.length; i < j; i++) {
     somme += arguments[i];
   }
   return somme / arguments.length;
 }
 moyenne(2, 3, 4, 5); // 3.5
-</pre>
+```
 
-<p>C'est assez utile, mais cela semble un peu verbeux. Pour réduire un peu plus ce code, nous pouvons envisager de substituer l'utilisation du tableau d'arguments par <a href="/fr/docs/Web/JavaScript/Reference/Functions/rest_parameters">la syntaxe du reste des paramètres</a>. De cette façon, nous pouvons passer un nombre quelconque d'arguments dans la fonction tout en gardant notre code minimal. <strong>L'opérateur du reste des paramètres</strong> est utilisé dans les listes de paramètres de fonctions avec le format : <strong>...variable</strong> et il inclura dans cette variable la liste entière des arguments non capturés avec lesquels la fonction a été appelée. Nous remplacerons également la boucle <strong>for</strong> par une boucle <strong>for...of</strong> pour retourner les valeurs dans notre variable.</p>
+C'est assez utile, mais cela semble un peu verbeux. Pour réduire un peu plus ce code, nous pouvons envisager de substituer l'utilisation du tableau d'arguments par [la syntaxe du reste des paramètres](/fr/docs/Web/JavaScript/Reference/Functions/rest_parameters). De cette façon, nous pouvons passer un nombre quelconque d'arguments dans la fonction tout en gardant notre code minimal. **L'opérateur du reste des paramètres** est utilisé dans les listes de paramètres de fonctions avec le format : **...variable** et il inclura dans cette variable la liste entière des arguments non capturés avec lesquels la fonction a été appelée. Nous remplacerons également la boucle **for** par une boucle **for...of** pour retourner les valeurs dans notre variable.
 
-<pre class="brush: js">
+```js
 function moyenne(...args) {
   let somme = 0;
   for (let valeur of args) {
@@ -694,78 +668,80 @@ function moyenne(...args) {
   return somme / args.length;
 }
 moyenne(2, 3, 4, 5); // 3.5
-</pre>
+```
 
-<p>Avec le reste des paramètres, dans l'exemple précédent, <code>args</code> contient tous les arguments passés à la fonction.</p>
+Avec le reste des paramètres, dans l'exemple précédent, `args` contient tous les arguments passés à la fonction.
 
-<p>Il est important de noter que, quel que soit l'endroit où est écrit l'opérateur du reste des paramètres au sein de la déclaration de fonction, il stockera tous les arguments écrits <em>après</em> mais pas avant. Autrement dit, <em>function avg(<strong>premiereValeur, </strong>...args)</em> stockera la première valeur passée à la fonction dans la variable <strong>firstValue</strong> et les autres arguments iront dans <strong>args</strong>.</p>
+Il est important de noter que, quel que soit l'endroit où est écrit l'opérateur du reste des paramètres au sein de la déclaration de fonction, il stockera tous les arguments écrits _après_ mais pas avant. Autrement dit, _function avg(**premiereValeur,** ...args)_ stockera la première valeur passée à la fonction dans la variable **firstValue** et les autres arguments iront dans **args**.
 
-<p>C'est très pratique, mais on rencontre un nouveau problème. La fonction <code>moyenne()</code> reçoit une liste de valeurs séparées par des virgules, mais comment fait-on si on souhaite trouver la moyenne des valeurs d'un tableau ?</p>
+C'est très pratique, mais on rencontre un nouveau problème. La fonction `moyenne()` reçoit une liste de valeurs séparées par des virgules, mais comment fait-on si on souhaite trouver la moyenne des valeurs d'un tableau ?
 
-<p>On pourrait simplement récrire la fonction comme ceci :</p>
+On pourrait simplement récrire la fonction comme ceci :
 
-<pre class="brush: js">
+```js
 function moyenneTableau(arr) {
   let somme = 0;
-  for (let i = 0, j = arr.length; i &lt; j; i++) {
+  for (let i = 0, j = arr.length; i < j; i++) {
     somme += arr[i];
   }
   return somme / arr.length;
 }
 moyenneTableau([2, 3, 4, 5]); // 3.5
-</pre>
+```
 
-<p>Mais ce serait bien si on pouvait réutiliser la fonction qu'on avait déjà créée. Par chance, JavaScript permet d'appeler une fonction et de lui donner un tableau de paramètres d'une longueur arbitraire, à l'aide de la méthode <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Function/apply"><code>apply()</code></a> de tout objet <code>Function</code>.</p>
+Mais ce serait bien si on pouvait réutiliser la fonction qu'on avait déjà créée. Par chance, JavaScript permet d'appeler une fonction et de lui donner un tableau de paramètres d'une longueur arbitraire, à l'aide de la méthode [`apply()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Function/apply) de tout objet `Function`.
 
-<pre class="brush: js">moyenne.apply(null, [2, 3, 4, 5]); // 3.5</pre>
+```js
+moyenne.apply(null, [2, 3, 4, 5]); // 3.5
+```
 
-<p>Le second paramètre envoyé à <code>apply()</code> est le tableau à utiliser comme paramètre ; nous parlerons du premier plus tard. Cela permet de souligner le fait que les fonctions sont aussi des objets.</p>
+Le second paramètre envoyé à `apply()` est le tableau à utiliser comme paramètre ; nous parlerons du premier plus tard. Cela permet de souligner le fait que les fonctions sont aussi des objets.
 
-<p>On peut également utiliser <a href="/fr/docs/Web/JavaScript/Reference/Operators/Spread_syntax">l'opérateur de décomposition</a> pour l'appel et la définition de la fonction pour écrire, par exemple, <code>moyenne(...nombres)</code>.</p>
+On peut également utiliser [l'opérateur de décomposition](/fr/docs/Web/JavaScript/Reference/Operators/Spread_syntax) pour l'appel et la définition de la fonction pour écrire, par exemple, `moyenne(...nombres)`.
 
-<h3 id="anonymous_functions">Fonctions anonymes</h3>
+### Fonctions anonymes
 
-<p>JavaScript vous permet de créer des fonctions anonymes, c'est-à-dire des fonctions sans nom :</p>
+JavaScript vous permet de créer des fonctions anonymes, c'est-à-dire des fonctions sans nom :
 
-<pre class="brush: js">
+```js
 function() {
   let somme = 0;
-  for (let i = 0, j = arguments.length; i &lt; j; i++) {
+  for (let i = 0, j = arguments.length; i < j; i++) {
     somme += arguments[i];
   }
   return somme / arguments.length;
 };
-</pre>
+```
 
-<p>Mais une telle fonction anonyme n'est pas utile en soi, car sans nom, il n'y a aucun moyen d'appeler la fonction. En pratique, les fonctions anonymes sont donc généralement utilisées comme arguments pour d'autres fonctions ou sont rendues appelables en les assignant immédiatement à une variable qui peut être utilisée pour invoquer la fonction :</p>
+Mais une telle fonction anonyme n'est pas utile en soi, car sans nom, il n'y a aucun moyen d'appeler la fonction. En pratique, les fonctions anonymes sont donc généralement utilisées comme arguments pour d'autres fonctions ou sont rendues appelables en les assignant immédiatement à une variable qui peut être utilisée pour invoquer la fonction :
 
-<pre class="brush: js">
+```js
 let moyenne = function() {
   let somme = 0;
-  for (let i = 0, j = arguments.length; i &lt; j; i++) {
+  for (let i = 0, j = arguments.length; i < j; i++) {
     somme += arguments[i];
   }
   return somme / arguments.length;
 };
-</pre>
+```
 
-<p>Cela rend la fonction anonyme invocable en appelant <code>moyenne()</code> avec des arguments — c'est-à-dire que c'est sémantiquement équivalent à déclarer la fonction en utilisant la forme nommée <code>fonction moyenne()</code>.</p>
+Cela rend la fonction anonyme invocable en appelant `moyenne()` avec des arguments — c'est-à-dire que c'est sémantiquement équivalent à déclarer la fonction en utilisant la forme nommée `fonction moyenne()`.
 
-<p>Mais les fonctions anonymes peuvent être utiles même si elles ne sont jamais affectées à des variables ou transmises comme arguments à d'autres fonctions : JavaScript fournit un mécanisme permettant de déclarer et d'invoquer simultanément une fonction à l'aide d'une seule expression. Cela s'appelle une <a href="/fr/docs/Glossary/IIFE">expression de fonction invoquée immédiatement (<i>IIFE</i> pour l'acronyme anglais)</a>, et la syntaxe pour l'utiliser avec une fonction anonyme ressemble à ceci :</p>
+Mais les fonctions anonymes peuvent être utiles même si elles ne sont jamais affectées à des variables ou transmises comme arguments à d'autres fonctions : JavaScript fournit un mécanisme permettant de déclarer et d'invoquer simultanément une fonction à l'aide d'une seule expression. Cela s'appelle une [expression de fonction invoquée immédiatement (_IIFE_ pour l'acronyme anglais)](/fr/docs/Glossary/IIFE), et la syntaxe pour l'utiliser avec une fonction anonyme ressemble à ceci :
 
-<pre class="brush: js">
+```js
 (function() {
   // …
 })();
-</pre>
+```
 
-<p>De plus amples détails sur les IIFE sont hors de portée de cet article d'introduction — mais un bon exemple de ce à quoi ils sont particulièrement utiles se trouve dans la section <a href="/fr/docs/Web/JavaScript/Closures#emulating_private_methods_with_closures">Émulation de méthodes privées avec des fermetures</a> de l'article <a href="/fr/docs/Web/JavaScript/Closures">Fermetures</a>.</p>
+De plus amples détails sur les IIFE sont hors de portée de cet article d'introduction — mais un bon exemple de ce à quoi ils sont particulièrement utiles se trouve dans la section [Émulation de méthodes privées avec des fermetures](/fr/docs/Web/JavaScript/Closures#emulating_private_methods_with_closures) de l'article [Fermetures](/fr/docs/Web/JavaScript/Closures).
 
-<h3 id="recursive_functions">Fonctions récursives</h3>
+### Fonctions récursives
 
-<p>JavaScript permet d'appeler des fonctions récursivement. C'est particulièrement utile lorsqu'on a affaire à des structures en arbre, comme c'est le cas dans le DOM du navigateur.</p>
+JavaScript permet d'appeler des fonctions récursivement. C'est particulièrement utile lorsqu'on a affaire à des structures en arbre, comme c'est le cas dans le DOM du navigateur.
 
-<pre class="brush: js">
+```js
 function countChars(elm) {
   if (elm.nodeType == 3) { // TEXT_NODE
     return elm.nodeValue.length;
@@ -776,11 +752,11 @@ function countChars(elm) {
   }
   return count;
 }
-</pre>
+```
 
-<p>Cela met en évidence un problème potentiel avec les fonctions anonymes : comment les appeler de manière récursive si elles n'ont pas de nom ? JavaScript vous permet de nommer les expressions de fonctions pour cela. Vous pouvez utiliser des <a href="/fr/docs/Glossary/IIFE">IIFE (« Immediately Invoked Function Expressions » en anglais soit « Expressions de fonctions immédiatement invoquées » en français)</a> nommées, comme indiqué ci-dessous :</p>
+Cela met en évidence un problème potentiel avec les fonctions anonymes : comment les appeler de manière récursive si elles n'ont pas de nom ? JavaScript vous permet de nommer les expressions de fonctions pour cela. Vous pouvez utiliser des [IIFE (« Immediately Invoked Function Expressions » en anglais soit « Expressions de fonctions immédiatement invoquées » en français)](/fr/docs/Glossary/IIFE) nommées, comme indiqué ci-dessous :
 
-<pre class="brush: js">
+```js
 let charsInBody = (function counter(elm) {
   if (elm.nodeType == 3) { // TEXT_NODE
     return elm.nodeValue.length;
@@ -791,21 +767,19 @@ let charsInBody = (function counter(elm) {
   }
   return count;
 })(document.body);
-</pre>
+```
 
-<p>Le nom fourni à l'expression de la fonction n'est disponible qu'au sein de la portée de la fonction. Cela permet au moteur JavaScript de faire des optimisations. Cela rend également le code plus lisible. Le nom apparaîtra également dans le débogueur et les piles d'appel, ce qui permettra de gagner du temps.</p>
+Le nom fourni à l'expression de la fonction n'est disponible qu'au sein de la portée de la fonction. Cela permet au moteur JavaScript de faire des optimisations. Cela rend également le code plus lisible. Le nom apparaîtra également dans le débogueur et les piles d'appel, ce qui permettra de gagner du temps.
 
-<p>En JavaScript, les fonctions sont également des objets. Il est donc possible de leur ajouter ou de modifier leurs propriétés.</p>
+En JavaScript, les fonctions sont également des objets. Il est donc possible de leur ajouter ou de modifier leurs propriétés.
 
-<h2 id="custom_objects">Les objets personnalisés</h2>
+## Les objets personnalisés
 
-<div class="note">
-  <p><strong>Note :</strong> Pour une approche plus détaillée de la programmation orientée objet en JavaScript, voir l'<a href="/fr/docs/conflicting/Learn/JavaScript/Objects">Introduction à JavaScript orienté objet</a>.</p>
-</div>
+> **Note :** Pour une approche plus détaillée de la programmation orientée objet en JavaScript, voir l'[Introduction à JavaScript orienté objet](/fr/docs/conflicting/Learn/JavaScript/Objects).
 
-<p>Dans la programmation orientée objet classique, les objets sont des collections de données et de méthodes opérant sur ces données. Imaginons un objet personne avec les champs prénom et nom. Il y a deux manières d'afficher son nom complet : de la façon « prénom nom » ou de la façon « nom prénom ». À l'aide des fonctions et des objets vus précédemment, voici une manière de le faire :</p>
+Dans la programmation orientée objet classique, les objets sont des collections de données et de méthodes opérant sur ces données. Imaginons un objet personne avec les champs prénom et nom. Il y a deux manières d'afficher son nom complet : de la façon « prénom nom » ou de la façon « nom prénom ». À l'aide des fonctions et des objets vus précédemment, voici une manière de le faire :
 
-<pre class="brush: js example-bad">
+```js example-bad
 function creerPersonne(prenom, nom) {
   return {
     prenom: prenom,
@@ -824,11 +798,11 @@ function personneNomCompletInverse(personne) {
 let s = creerPersonne("Simon", "Willison");
 personneNomComplet(s); // Simon Willison
 personneNomCompletInverse(s); // Willison Simon
-</pre>
+```
 
-<p>Ça fonctionne, mais c'est inutilement verbeux. On va se retrouver avec des dizaines de fonctions dans l'espace de noms global. Ce dont on aurait vraiment besoin, c'est d'une manière d'attacher une fonction à un objet. Comme les fonctions sont des objets, c'est facile :</p>
+Ça fonctionne, mais c'est inutilement verbeux. On va se retrouver avec des dizaines de fonctions dans l'espace de noms global. Ce dont on aurait vraiment besoin, c'est d'une manière d'attacher une fonction à un objet. Comme les fonctions sont des objets, c'est facile :
 
-<pre class="brush: js example-good">
+```js example-good
 function creerPersonne(prenom, nom) {
   return {
     prenom: prenom,
@@ -845,23 +819,23 @@ function creerPersonne(prenom, nom) {
 let s = creerPersonne("Simon", "Willison")
 s.nomComplet(); // Simon Willison
 s.nomCompletInverse(); // Willison Simon
-</pre>
+```
 
-<p>Il y a quelque chose que nous n'avons pas vu jusqu'à présent : le mot-clé <a href="/fr/docs/Web/JavaScript/Reference/Operators/this"><code>this</code></a>. Utilisé au sein d'une fonction, <code>this</code> fait référence à l'objet courant. Sa signification dépend de la façon dont la fonction a été appelée. Si elle a été appelée avec <a href="/fr/docs/Web/JavaScript/Reference/Operators/Object_initializer#accessing_properties">la notation utilisant le point ou les crochets</a> sur un objet, cet objet devient <code>this</code>. Si cette notation n'a pas été utilisée pour l'appel, <code>this</code> fera référence à l'objet global.</p>
+Il y a quelque chose que nous n'avons pas vu jusqu'à présent : le mot-clé [`this`](/fr/docs/Web/JavaScript/Reference/Operators/this). Utilisé au sein d'une fonction, `this` fait référence à l'objet courant. Sa signification dépend de la façon dont la fonction a été appelée. Si elle a été appelée avec [la notation utilisant le point ou les crochets](/fr/docs/Web/JavaScript/Reference/Operators/Object_initializer#accessing_properties) sur un objet, cet objet devient `this`. Si cette notation n'a pas été utilisée pour l'appel, `this` fera référence à l'objet global.
 
-<p>C'est une source fréquente d'erreurs. Par exemple :</p>
+C'est une source fréquente d'erreurs. Par exemple :
 
-<pre class="brush: js">
+```js
 let s = creerPersonne("Simon", "Willison");
 let nomComplet = s.nomComplet;
 nomComplet(); // undefined undefined
-</pre>
+```
 
-<p>Lorsqu'on appelle <code>nomComplet()</code> seul, sans utiliser <code>s.nomComplet()</code>, <code>this</code> est lié à l'objet global. Comme il n'y a pas de variables globales appelées <code>prenom</code> ou <code>nom</code>, on se retrouve avec <code>undefined</code> pour chacune.</p>
+Lorsqu'on appelle `nomComplet()` seul, sans utiliser `s.nomComplet()`, `this` est lié à l'objet global. Comme il n'y a pas de variables globales appelées `prenom` ou `nom`, on se retrouve avec `undefined` pour chacune.
 
-<p>On peut se servir du mot-clé <code>this</code> pour améliorer notre fonction de construction :</p>
+On peut se servir du mot-clé `this` pour améliorer notre fonction de construction :
 
-<pre class="brush: js">
+```js
 function Personne(prenom, nom) {
   this.prenom = prenom;
   this.nom = nom;
@@ -873,15 +847,15 @@ function Personne(prenom, nom) {
   }
 }
 let s = new Personne("Simon", "Willison");
-</pre>
+```
 
-<p>Nous avons utilisé un nouveau mot clé : <a href="/fr/docs/Web/JavaScript/Reference/Operators/new"><code>new</code></a>. <code>new</code> est très lié à <code>this</code>. Il crée un nouvel objet vide et appelle ensuite la fonction spécifiée, avec <code>this</code> pointant vers ce nouvel objet. On notera cependant que la fonction appelée avec ce <code>this</code> ne renvoie pas de valeur mais ne fait que modifier l'objet <code>this</code>. C'est l'opérateur <code>new</code> qui renvoie l'objet <code>this</code> à l'endroit de l'appel. Les fonctions prévues pour être appelées par <code>new</code> sont appelées des constructeurs. L'usage courant est de mettre la première lettre de ces fonctions en majuscule pour se souvenir de les appeler avec <code>new</code>.</p>
+Nous avons utilisé un nouveau mot clé : [`new`](/fr/docs/Web/JavaScript/Reference/Operators/new). `new` est très lié à `this`. Il crée un nouvel objet vide et appelle ensuite la fonction spécifiée, avec `this` pointant vers ce nouvel objet. On notera cependant que la fonction appelée avec ce `this` ne renvoie pas de valeur mais ne fait que modifier l'objet `this`. C'est l'opérateur `new` qui renvoie l'objet `this` à l'endroit de l'appel. Les fonctions prévues pour être appelées par `new` sont appelées des constructeurs. L'usage courant est de mettre la première lettre de ces fonctions en majuscule pour se souvenir de les appeler avec `new`.
 
-<p>La fonction améliorée présente toujours le même écueil avec l'appel de <code>personneNomComplet()</code> seul.</p>
+La fonction améliorée présente toujours le même écueil avec l'appel de `personneNomComplet()` seul.
 
-<p>Nos objets <code>Personne</code> s'améliorent, mais il leur reste certaines aspérités pas très esthétiques. Chaque fois que l'on crée une personne, on crée deux nouveaux objets de fonctions en même temps. Ne serait-ce pas mieux si ce code était partagé ?</p>
+Nos objets `Personne` s'améliorent, mais il leur reste certaines aspérités pas très esthétiques. Chaque fois que l'on crée une personne, on crée deux nouveaux objets de fonctions en même temps. Ne serait-ce pas mieux si ce code était partagé ?
 
-<pre class="brush: js">
+```js
 function personneNomComplet() {
   return this.prenom + ' ' + this.nom;
 }
@@ -896,11 +870,11 @@ function Personne(prenom, nom) {
   this.nomComplet = personneNomComplet;
   this.nomCompletInverse = personneNomCompletInverse;
 }
-</pre>
+```
 
-<p>C'est mieux : on crée les fonctions une seule fois, et on leur assigne des références au sein du constructeur. Est-il possible de faire encore mieux que ça ? La réponse est oui :</p>
+C'est mieux : on crée les fonctions une seule fois, et on leur assigne des références au sein du constructeur. Est-il possible de faire encore mieux que ça ? La réponse est oui :
 
-<pre class="brush: js">
+```js
 function Personne(prenom, nom) {
   this.prenom = prenom;
   this.nom = nom;
@@ -913,13 +887,13 @@ Personne.prototype.nomComplet = function() {
 Personne.prototype.nomCompletInverse = function() {
   return this.nom + ', ' + this.prenom;
 }
-</pre>
+```
 
-<p><code>Personne.prototype</code> est un objet partagé par toutes les instances de <code>Personne</code>. Il fait partie d'une chaîne de résolution (qui a un nom spécial, la « chaîne de prototypes ») : chaque fois que vous essayez d'accéder à une propriété de <code>Personne</code> qui n'est pas définie, JavaScript va vérifier <code>Personne.prototype</code> pour voir si cette propriété n'existe pas plutôt à cet endroit. Par conséquent, tout ce qui est assigné à <code>Personne.prototype</code> devient disponible à toutes les instances de ce constructeur via l'objet <code>this</code>.</p>
+`Personne.prototype` est un objet partagé par toutes les instances de `Personne`. Il fait partie d'une chaîne de résolution (qui a un nom spécial, la « chaîne de prototypes ») : chaque fois que vous essayez d'accéder à une propriété de `Personne` qui n'est pas définie, JavaScript va vérifier `Personne.prototype` pour voir si cette propriété n'existe pas plutôt à cet endroit. Par conséquent, tout ce qui est assigné à `Personne.prototype` devient disponible à toutes les instances de ce constructeur via l'objet `this`.
 
-<p>C'est un outil incroyablement puissant. JavaScript vous permet de modifier le prototype de quelque chose à tout moment dans votre programme, cela signifie qu'il est possible d'ajouter des méthodes supplémentaires à des objets existants lors de l'exécution :</p>
+C'est un outil incroyablement puissant. JavaScript vous permet de modifier le prototype de quelque chose à tout moment dans votre programme, cela signifie qu'il est possible d'ajouter des méthodes supplémentaires à des objets existants lors de l'exécution :
 
-<pre class="brush: js">
+```js
 let s = new Personne("Simon", "Willison");
 s.prenomEnMajuscules(); // TypeError on line 1: s.prenomEnMajuscules is not a function
 
@@ -927,63 +901,69 @@ Personne.prototype.prenomEnMajuscules = function prenomEnMajuscules() {
   return this.prenom.toUpperCase()
 }
 s.prenomEnMajuscules(); // "SIMON"
-</pre>
+```
 
-<p>Il est également possible d'ajouter des choses aux prototypes de classes d'objets JavaScript prédéfinies. Ajoutons par exemple une méthode à <code>String</code> qui renvoie cette chaîne à l'envers :</p>
+Il est également possible d'ajouter des choses aux prototypes de classes d'objets JavaScript prédéfinies. Ajoutons par exemple une méthode à `String` qui renvoie cette chaîne à l'envers :
 
-<pre class="brush: js">
+```js
 let s = "Simon";
 s.inverse(); // TypeError on line 1: s.inverse is not a function
 
 String.prototype.inverse = function inverse() {
   let r = "";
-  for (let i = this.length - 1; i &gt;= 0; i--) {
+  for (let i = this.length - 1; i >= 0; i--) {
     r += this[i];
   }
   return r;
 }
 s.inverse(); // "nomiS"
-</pre>
+```
 
-<p>Notre nouvelle méthode fonctionne même sur les chaînes littérales !</p>
+Notre nouvelle méthode fonctionne même sur les chaînes littérales !
 
-<pre class="brush: js">"Ceci peut maintenant être inversé.".inverse() // ".ésrevni ertê tnanetniam tuep iceC"</pre>
+```js
+"Ceci peut maintenant être inversé.".inverse() // ".ésrevni ertê tnanetniam tuep iceC"
+```
 
-<p>Comme mentionné précédemment, le prototype fait partie d'une chaîne de prototypes. Le début de cette chaîne est <code>Object.prototype</code>, dont <code>toString()</code> fait partie des méthodes. C'est cette méthode qui est appelée quand vous essayez de représenter un objet sous la forme d'une chaîne. Elle sera utile pour déboguer nos objets <code>Personne</code> :</p>
+Comme mentionné précédemment, le prototype fait partie d'une chaîne de prototypes. Le début de cette chaîne est `Object.prototype`, dont `toString()` fait partie des méthodes. C'est cette méthode qui est appelée quand vous essayez de représenter un objet sous la forme d'une chaîne. Elle sera utile pour déboguer nos objets `Personne` :
 
-<pre class="brush: js">
+```js
 let s = new Personne("Simon", "Willison");
 s; // [object Object]
 
 Personne.prototype.toString = function() {
-  return '&lt;Personne : ' + this.nomComplet() + '&gt;';
+  return '<Personne : ' + this.nomComplet() + '>';
 }
-s.toString(); // "&lt;Personne : Simon Willison&gt;"
-</pre>
+s.toString(); // "<Personne : Simon Willison>"
+```
 
-<p>Vous vous souvenez de la fonction <code>moyenne.apply()</code> qui avait un premier paramètre défini à <code>null</code> ? Nous pouvons en reparler à présent. Le premier paramètre d'<code>apply()</code> est l'objet qui doit être traité comme <code>this</code>. Par exemple, voici une implémentation de <code>new</code> :</p>
+Vous vous souvenez de la fonction `moyenne.apply()` qui avait un premier paramètre défini à `null` ? Nous pouvons en reparler à présent. Le premier paramètre d'`apply()` est l'objet qui doit être traité comme `this`. Par exemple, voici une implémentation de `new` :
 
-<pre class="brush: js">
+```js
 function trivialNew(constructor, ...args) {
   let o = {}; // Crée un objet
   constructor.apply(o, ...args);
   return o;
 }
-</pre>
+```
 
-<p>Ce n'est pas une réplique exacte de <code>new</code> parce qu'elle n'initialise pas la chaîne de prototype. La méthode <code>apply()</code> est difficile à illustrer, ce n'est pas quelque chose qu'on utilise très souvent, mais c'est utile de savoir qu'elle existe. Dans ce fragment de code, on utilise le <a href="/fr/docs/Web/JavaScript/Reference/Functions/rest_parameters">reste des arguments</a>, représentés par <code>...args</code>. Comme son nom l'indique, cela représente le reste des arguments passés à la fonction.</p>
+Ce n'est pas une réplique exacte de `new` parce qu'elle n'initialise pas la chaîne de prototype. La méthode `apply()` est difficile à illustrer, ce n'est pas quelque chose qu'on utilise très souvent, mais c'est utile de savoir qu'elle existe. Dans ce fragment de code, on utilise le [reste des arguments](/fr/docs/Web/JavaScript/Reference/Functions/rest_parameters), représentés par `...args`. Comme son nom l'indique, cela représente le reste des arguments passés à la fonction.
 
-<p>Appeler</p>
+Appeler
 
-<pre class="brush: js">let bill = trivialNew(Personne, ["William", "Orange"]);</pre>
+```js
+let bill = trivialNew(Personne, ["William", "Orange"]);
+```
 
-<p>est donc quasiment équivalent à :</p>
+est donc quasiment équivalent à :
 
-<pre class="brush: js">let bill = new Personne("William", "Orange");</pre>
+```js
+let bill = new Personne("William", "Orange");
+```
 
-<p><code>apply()</code> possède une fonction proche, appelée <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Function/call"><code>call</code></a>, qui permet de définir la valeur de <code>this</code> mais qui prend une liste d'arguments plutôt qu'un tableau.</p>
+`apply()` possède une fonction proche, appelée [`call`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Function/call), qui permet de définir la valeur de `this` mais qui prend une liste d'arguments plutôt qu'un tableau.
 
-<pre class="brush: js">
+```js
 function nomMajuscule() {
   return this.nom.toUpperCase();
 }
@@ -991,13 +971,13 @@ let s = new Personne("Simon", "Willison");
 nomMajuscule.call(s); // correspond à:
 s.nomMajuscule = nomMajuscule;
 s.nomMajuscule();
-</pre>
+```
 
-<h3 id="inner_functions">Les fonctions internes</h3>
+### Les fonctions internes
 
-<p>Comme nous l'avons déjà vu, les déclarations de fonctions JavaScript peuvent se trouver à l'intérieur d'autres fonctions. Un détail important des fonctions définies à l'intérieur d'autres fonctions est qu'elles peuvent accéder à des variables de leur fonction parente :</p>
+Comme nous l'avons déjà vu, les déclarations de fonctions JavaScript peuvent se trouver à l'intérieur d'autres fonctions. Un détail important des fonctions définies à l'intérieur d'autres fonctions est qu'elles peuvent accéder à des variables de leur fonction parente :
 
-<pre class="brush: js">
+```js
 function parentFunc() {
   let a = 1;
   function fonctionImbriquee() {
@@ -1005,17 +985,18 @@ function parentFunc() {
     return a + b;
   }
   return fonctionImbriquee(); // 5
-}</pre>
+}
+```
 
-<p>Cela peut s'avérer très utile dans l'écriture de code plus facilement maintenable. Si une fonction A dépend d'une ou deux autres fonctions B et C qui ne sont utiles à aucun autre endroit de votre code, on peut imbriquer ces fonctions utilitaires B et C à l'intérieur de la fonction A. Cela diminue le nombre de fonctions se trouvant dans la portée globale, ce qui est toujours une bonne chose.</p>
+Cela peut s'avérer très utile dans l'écriture de code plus facilement maintenable. Si une fonction A dépend d'une ou deux autres fonctions B et C qui ne sont utiles à aucun autre endroit de votre code, on peut imbriquer ces fonctions utilitaires B et C à l'intérieur de la fonction A. Cela diminue le nombre de fonctions se trouvant dans la portée globale, ce qui est toujours une bonne chose.
 
-<p>C'est également un bon moyen de se préserver de l'attrait trompeur des variables globales. Lorsqu'on écrit du code complexe, il est souvent tentant d'utiliser des variables globales pour partager des valeurs entre différentes fonctions, ce qui mène à du code difficile à maintenir. Les fonctions internes peuvent partager des variables avec leur parent, de sorte que vous pouvez utiliser ce mécanisme pour coupler des fonctions ensemble lorsque cela a un sens, sans pour autant polluer l'espace de noms global. Ce sont ainsi des «&nbsp;globales locales&nbsp;». Cette technique doit être utilisée parcimonieusement, mais il est utile de s'en souvenir.</p>
+C'est également un bon moyen de se préserver de l'attrait trompeur des variables globales. Lorsqu'on écrit du code complexe, il est souvent tentant d'utiliser des variables globales pour partager des valeurs entre différentes fonctions, ce qui mène à du code difficile à maintenir. Les fonctions internes peuvent partager des variables avec leur parent, de sorte que vous pouvez utiliser ce mécanisme pour coupler des fonctions ensemble lorsque cela a un sens, sans pour autant polluer l'espace de noms global. Ce sont ainsi des « globales locales ». Cette technique doit être utilisée parcimonieusement, mais il est utile de s'en souvenir.
 
-<h2 id="closures">Les fermetures (<em>Closures</em>)</h2>
+## Les fermetures (_Closures_)
 
-<p>Cela nous amène à l'une des abstractions les plus spectaculaires que JavaScript a à nous offrir. C'est également un des concepts les plus déroutants. Que fait ce fragment de code ?</p>
+Cela nous amène à l'une des abstractions les plus spectaculaires que JavaScript a à nous offrir. C'est également un des concepts les plus déroutants. Que fait ce fragment de code ?
 
-<pre class="brush: js">
+```js
 function creerAdditionneur(a) {
   return function(b) {
     return a + b;
@@ -1025,21 +1006,21 @@ let ajoute5 = creerAdditionneur(5);
 let ajoute20 = creerAdditionneur(20);
 ajoute5(6); // ?
 ajoute20(7); // ?
-</pre>
+```
 
-<p>Le nom de la fonction <code>creerAdditionneur</code> devrait vous donner un indice : elle crée de nouveaux additionneurs sous forme de fonctions qui, quand elles sont appelées avec un paramètre, l'ajoutent à celui avec lequel elles ont été créées.</p>
+Le nom de la fonction `creerAdditionneur` devrait vous donner un indice : elle crée de nouveaux additionneurs sous forme de fonctions qui, quand elles sont appelées avec un paramètre, l'ajoutent à celui avec lequel elles ont été créées.
 
-<p>Ce qui se passe ici est sensiblement la même chose qu'avec les fonctions internes dont nous avons parlé précédemment : une fonction définie à l'intérieur d'une autre fonction a accès aux variables de sa fonction extérieure. La seule différence ici est que la fonction extérieure a déjà renvoyé son résultat, et le bon sens semblerait vouloir être que ses variables locales n'existent plus. Mai<em>s</em> elles existent <em>encore</em> ; autrement les additionneurs présentés ci-dessus ne fonctionneraient pas. Ce n'est pas tout, il y a même deux « copies » différentes des variables locales de <code>creerAdditionneur</code> : une dans laquelle <code>a</code> vaut 5 et une autre dans laquelle <code>a</code> vaut 20. Quel est donc le résultat de ces appels de fonction ?</p>
+Ce qui se passe ici est sensiblement la même chose qu'avec les fonctions internes dont nous avons parlé précédemment : une fonction définie à l'intérieur d'une autre fonction a accès aux variables de sa fonction extérieure. La seule différence ici est que la fonction extérieure a déjà renvoyé son résultat, et le bon sens semblerait vouloir être que ses variables locales n'existent plus. Mai*s* elles existent _encore_ ; autrement les additionneurs présentés ci-dessus ne fonctionneraient pas. Ce n'est pas tout, il y a même deux « copies » différentes des variables locales de `creerAdditionneur` : une dans laquelle `a` vaut 5 et une autre dans laquelle `a` vaut 20. Quel est donc le résultat de ces appels de fonction ?
 
-<pre class="brush: js">
+```js
 ajoute5(6); // renvoie 11
 ajoute20(7); // renvoie 27
-</pre>
+```
 
-<p>Voici ce qui se passe en réalité. Lorsque JavaScript exécute une fonction, un objet de portée est créé pour conserver les variables locales créées au sein de cette fonction. Il est initialisé avec les variables passées en paramètres à la fonction. Cela ressemble à l'objet global dans lequel toutes les variables et fonctions globales se trouvent, mais avec quelques différences importantes : premièrement, un nouvel objet de portée est créé chaque fois qu'une fonction commence à s'exécuter, et deuxièmement, contrairement à l'objet global (qui est accessible via <code>this</code> et qui, dans le navigateur, correspond à l'objet <code>window</code>), on ne peut pas directement accéder à ces objets de portée depuis le code JavaScript. Il n'existe pas de mécanisme permettant de parcourir les propriétés de l'objet de la portée courante par exemple.</p>
+Voici ce qui se passe en réalité. Lorsque JavaScript exécute une fonction, un objet de portée est créé pour conserver les variables locales créées au sein de cette fonction. Il est initialisé avec les variables passées en paramètres à la fonction. Cela ressemble à l'objet global dans lequel toutes les variables et fonctions globales se trouvent, mais avec quelques différences importantes : premièrement, un nouvel objet de portée est créé chaque fois qu'une fonction commence à s'exécuter, et deuxièmement, contrairement à l'objet global (qui est accessible via `this` et qui, dans le navigateur, correspond à l'objet `window`), on ne peut pas directement accéder à ces objets de portée depuis le code JavaScript. Il n'existe pas de mécanisme permettant de parcourir les propriétés de l'objet de la portée courante par exemple.
 
-<p>Donc, quand <code>creerAdditionneur()</code> est appelée, une portée est créée avec une propriété : <code>a</code>, qui est l'argument passé à la fonction <code>creerAdditionneur()</code>. Celle-ci renvoie alors une fonction nouvellement créée. Normalement, le ramasse-miettes de JavaScript devrait supprimer l'objet de portée créé pour <code>creerAdditionneur()</code> à ce moment, mais la fonction renvoyée garde une référence vers cet objet de portée. Par conséquent, il ne sera pas supprimé par le ramasse-miettes tant qu'il y a toujours des références à l'objet de type fonction que <code>creerAdditionneur()</code> a renvoyé.</p>
+Donc, quand `creerAdditionneur()` est appelée, une portée est créée avec une propriété : `a`, qui est l'argument passé à la fonction `creerAdditionneur()`. Celle-ci renvoie alors une fonction nouvellement créée. Normalement, le ramasse-miettes de JavaScript devrait supprimer l'objet de portée créé pour `creerAdditionneur()` à ce moment, mais la fonction renvoyée garde une référence vers cet objet de portée. Par conséquent, il ne sera pas supprimé par le ramasse-miettes tant qu'il y a toujours des références à l'objet de type fonction que `creerAdditionneur()` a renvoyé.
 
-<p>Les objets de portée forment une chaîne appelée chaîne de portée, similaire à la chaîne de prototypes utilisée par le système d'objets de JavaScript.</p>
+Les objets de portée forment une chaîne appelée chaîne de portée, similaire à la chaîne de prototypes utilisée par le système d'objets de JavaScript.
 
-<p>Une <strong>fermeture</strong> est la combinaison d'une fonction et de la portée de l'objet dans lequel elle a été créée. Les fermetures vous permettent de sauvegarder l'état — en tant que telles, elles peuvent souvent être utilisées à la place des objets. Vous pouvez trouver <a href="https://stackoverflow.com/questions/111102/how-do-javascript-closures-work">plusieurs excellentes introductions aux fermetures dans cet article</a>.</p>
+Une **fermeture** est la combinaison d'une fonction et de la portée de l'objet dans lequel elle a été créée. Les fermetures vous permettent de sauvegarder l'état — en tant que telles, elles peuvent souvent être utilisées à la place des objets. Vous pouvez trouver [plusieurs excellentes introductions aux fermetures dans cet article](https://stackoverflow.com/questions/111102/how-do-javascript-closures-work).
diff --git a/files/fr/web/javascript/about_javascript/index.md b/files/fr/web/javascript/about_javascript/index.md
index 3cdf73b473..9df9e079ce 100644
--- a/files/fr/web/javascript/about_javascript/index.md
+++ b/files/fr/web/javascript/about_javascript/index.md
@@ -8,50 +8,46 @@ tags:
 translation_of: Web/JavaScript/About_JavaScript
 original_slug: Web/JavaScript/A_propos
 ---
-<div>{{jsSidebar}}</div>
+{{jsSidebar}}
 
-<h2 id="Qu'est-ce_que_JavaScript">Qu'est-ce que JavaScript ?</h2>
+## Qu'est-ce que JavaScript ?
 
-<p><a class="external" href="https://fr.wikipedia.org/wiki/JavaScript">JavaScript</a>®, souvent abrégé en JS, est le langage de script développé par Netscape utilisé dans des millions de pages web et d'applications serveur dans le monde entier. Le JavaScript de Netscape est une extension du langage de script standard ECMA-262 Edition 3 (ECMAScript), ne différant que légèrement des standards publiés. JavaScript est un langage léger, interprété, orienté objet (les fonctions étant des objets à part entière). Il est <a href="https://fr.wikipedia.org/wiki/Programmation_orient%C3%A9e_prototype">orienté prototype</a>, multi-paradigme étant dynamique, impératif et fonctionnel à la fois</p>
+[JavaScript](https://fr.wikipedia.org/wiki/JavaScript)®, souvent abrégé en JS, est le langage de script développé par Netscape utilisé dans des millions de pages web et d'applications serveur dans le monde entier. Le JavaScript de Netscape est une extension du langage de script standard ECMA-262 Edition 3 (ECMAScript), ne différant que légèrement des standards publiés. JavaScript est un langage léger, interprété, orienté objet (les fonctions étant des objets à part entière). Il est [orienté prototype](https://fr.wikipedia.org/wiki/Programmation_orient%C3%A9e_prototype), multi-paradigme étant dynamique, impératif et fonctionnel à la fois
 
-<p>Contrairement à une conception populaire, <em>JavaScript n'est pas « du Java interprété »</em>. En quelques mots, JavaScript est un langage de script dynamique utilisant une construction d'objets basée sur des prototypes. La syntaxe de base est volontairement similaire à Java et à C++ pour réduire le nombre de concepts nouveaux à assimiler par un débutant. Les structures de contrôle, telles que les instructions <code>if</code>, les boucles <code>for</code> et <code>while</code>, les blocs <code>switch</code> et <code>try..catch</code> fonctionnent de la même manière que dans ces langages (ou presque).</p>
+Contrairement à une conception populaire, _JavaScript n'est pas « du Java interprété »_. En quelques mots, JavaScript est un langage de script dynamique utilisant une construction d'objets basée sur des prototypes. La syntaxe de base est volontairement similaire à Java et à C++ pour réduire le nombre de concepts nouveaux à assimiler par un débutant. Les structures de contrôle, telles que les instructions `if`, les boucles `for` et `while`, les blocs `switch` et `try..catch` fonctionnent de la même manière que dans ces langages (ou presque).
 
-<p>JavaScript peut être employé en tant que langage <a class="external" href="https://fr.wikipedia.org/wiki/Programmation_procédurale">procédural</a> ou <a class="external" href="https://fr.wikipedia.org/wiki/Programmation_orientée_objet">orienté objet</a>. Les objets sont créés par le programme et des méthodes et des propriétés lui sont attachés lors de l'exécution, contrairement aux définitions de classes courantes dans les langages compilés comme C++ et Java. Une fois qu'un objet a été construit, il peut servir de modèle (ou prototype) pour créer des objets similaires.</p>
+JavaScript peut être employé en tant que langage [procédural](https://fr.wikipedia.org/wiki/Programmation_procédurale) ou [orienté objet](https://fr.wikipedia.org/wiki/Programmation_orientée_objet). Les objets sont créés par le programme et des méthodes et des propriétés lui sont attachés lors de l'exécution, contrairement aux définitions de classes courantes dans les langages compilés comme C++ et Java. Une fois qu'un objet a été construit, il peut servir de modèle (ou prototype) pour créer des objets similaires.
 
-<p>Parmi les capacités dynamiques de JavaScript, on peut citer la construction d'objets à l'exécution, les listes de paramètres variables, les fonctions comme variables, la création des scripts dynamique (via <code><a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/eval">eval</a></code>), le parcours d'objets (via <a href="/fr/docs/Web/JavaScript/Reference/Instructions/for...in"><code>for ... in</code></a>), et la récupération du code source (les programmes JavaScript peuvent décompiler les corps de fonction pour retrouver le code source).</p>
+Parmi les capacités dynamiques de JavaScript, on peut citer la construction d'objets à l'exécution, les listes de paramètres variables, les fonctions comme variables, la création des scripts dynamique (via [`eval`](/fr/docs/Web/JavaScript/Reference/Objets_globaux/eval)), le parcours d'objets (via [`for ... in`](/fr/docs/Web/JavaScript/Reference/Instructions/for...in)), et la récupération du code source (les programmes JavaScript peuvent décompiler les corps de fonction pour retrouver le code source).
 
-<p>Pour une description approfondie de la programation en JavaScript, consultez les liens de la section <a href="#Ressources_JavaScript">ressources JavaScript</a> ci-dessous.</p>
+Pour une description approfondie de la programation en JavaScript, consultez les liens de la section [ressources JavaScript](#Ressources_JavaScript) ci-dessous.
 
-<h2 id="Les_implémentations_de_JavaScript_disponibles">Les implémentations de JavaScript disponibles</h2>
+## Les implémentations de JavaScript disponibles
 
-<p>Mozilla héberge deux implémentations de JavaScript. La première <strong>au monde</strong> est celle créée par Brendan Eich chez Netscape, et depuis mise à jour pour se conformer à la cinquième édition d'ECMA-262 (aussi appelé ECMAScript 5). Ce moteur, portant le nom de code <a href="/fr/docs/SpiderMonkey">SpiderMonkey</a>, est implémenté en C. Le moteur <a href="/fr/docs/Rhino">Rhino</a>, créé principalement par Norris Boyd (également chez Netscape) est une implémentation de JavaScript en Java. Comme SpiderMonkey, Rhino suit la spécification ECMA-262 Edition 5.</p>
+Mozilla héberge deux implémentations de JavaScript. La première **au monde** est celle créée par Brendan Eich chez Netscape, et depuis mise à jour pour se conformer à la cinquième édition d'ECMA-262 (aussi appelé ECMAScript 5). Ce moteur, portant le nom de code [SpiderMonkey](/fr/docs/SpiderMonkey), est implémenté en C. Le moteur [Rhino](/fr/docs/Rhino), créé principalement par Norris Boyd (également chez Netscape) est une implémentation de JavaScript en Java. Comme SpiderMonkey, Rhino suit la spécification ECMA-262 Edition 5.
 
-<p>Plusieurs optimisations ont été apportées au moteur JavaScript au fur et à mesure, parmi lesquelles on peut citer : TraceMonkey (Firefox 3.5), JägerMonkey (Firefox 4) et IonMonkey.</p>
+Plusieurs optimisations ont été apportées au moteur JavaScript au fur et à mesure, parmi lesquelles on peut citer : TraceMonkey (Firefox 3.5), JägerMonkey (Firefox 4) et IonMonkey.
 
-<p>En plus de ces implémentations, il existe d'autres moteurs JavaScript largement utilisés comme :</p>
+En plus de ces implémentations, il existe d'autres moteurs JavaScript largement utilisés comme :
 
-<ul>
- <li><a class="external external-icon" href="https://code.google.com/p/v8/" title="https://code.google.com/p/v8/">V8</a> de Google, qui est utilisé dans le navigateur Google Chrome et dans les versions récentes du navigateur Opéra.</li>
- <li><a class="external external-icon" href="https://www.webkit.org/projects/javascript/index.html" title="https://www.webkit.org/projects/javascript/index.html">JavaScriptCore</a> (SquirrelFish/Nitro) utilisé dans certains navigateurs WebKit tels que Safari, d'Apple.</li>
- <li><a class="external external-icon" href="https://my.opera.com/ODIN/blog/carakan-faq" title="https://my.opera.com/ODIN/blog/carakan-faq">Carakan</a> est utilisé dans les anciennes versions d'Opera.</li>
- <li>Le moteur <a class="external external-icon" href="https://en.wikipedia.org/wiki/Chakra_%28JScript_engine%29" title="https://en.wikipedia.org/wiki/Chakra_%28JScript_engine%29">Chakra</a> est utilisé dans Internet Explorer (bien que le langage qu'il implémente soit formellement appelé « JScript » pour des raisons de droits des marques).</li>
-</ul>
+- [V8](https://code.google.com/p/v8/ "https://code.google.com/p/v8/") de Google, qui est utilisé dans le navigateur Google Chrome et dans les versions récentes du navigateur Opéra.
+- [JavaScriptCore](https://www.webkit.org/projects/javascript/index.html "https://www.webkit.org/projects/javascript/index.html") (SquirrelFish/Nitro) utilisé dans certains navigateurs WebKit tels que Safari, d'Apple.
+- [Carakan](https://my.opera.com/ODIN/blog/carakan-faq "https://my.opera.com/ODIN/blog/carakan-faq") est utilisé dans les anciennes versions d'Opera.
+- Le moteur [Chakra](https://en.wikipedia.org/wiki/Chakra_%28JScript_engine%29 "https://en.wikipedia.org/wiki/Chakra_%28JScript_engine%29") est utilisé dans Internet Explorer (bien que le langage qu'il implémente soit formellement appelé « JScript » pour des raisons de droits des marques).
 
-<p>Chacun des moteurs JavaScript de Mozilla expose une API publique que les applications peuvent appeler pour utiliser JavaScript. L'environnement hôte le plus courant pour JavaScript est, de loin, un navigateur Web. Les navigateurs utilisent typiquement l'API publique pour créer des « objets hôtes », reflétant le <a href="/fr/docs/DOM">DOM</a> en JavaScript.</p>
+Chacun des moteurs JavaScript de Mozilla expose une API publique que les applications peuvent appeler pour utiliser JavaScript. L'environnement hôte le plus courant pour JavaScript est, de loin, un navigateur Web. Les navigateurs utilisent typiquement l'API publique pour créer des « objets hôtes », reflétant le [DOM](/fr/docs/DOM) en JavaScript.
 
-<p>Une autre utilisation courante de JavaScript est d'être un langage de script côté serveur (Web). Un serveur web JavaScript exposerait, lui, des objets hôtes représentant les requêtes HTTP et leurs réponses, qui peuvent ensuite être manipulées par un programme JavaScript pour générer dynamiquement des pages Web.</p>
+Une autre utilisation courante de JavaScript est d'être un langage de script côté serveur (Web). Un serveur web JavaScript exposerait, lui, des objets hôtes représentant les requêtes HTTP et leurs réponses, qui peuvent ensuite être manipulées par un programme JavaScript pour générer dynamiquement des pages Web.
 
-<h2 id="Ressources_JavaScript">Ressources JavaScript</h2>
+## Ressources JavaScript
 
-<dl>
- <dt><a href="/fr/docs/SpiderMonkey">SpiderMonkey</a></dt>
- <dd>Informations concernant l'intégration du moteur JavaScript en C/C++ (SpiderMonkey).</dd>
- <dt><a href="/fr/docs/Rhino">Rhino</a></dt>
- <dd>Informations concernant l'intégration du moteur JavaScript en Java (Rhino).</dd>
- <dt><a href="/fr/docs/Web/JavaScript/Language_Resources">Ressources sur le langage JavaScript</a></dt>
- <dd>Liens vers les standards JavaScript publiées.</dd>
- <dt><a href="/fr/docs/Web/JavaScript/Une_réintroduction_à_JavaScript">Une réintroduction à JavaScript</a></dt>
- <dd><a href="/fr/docs/Web/JavaScript/Guide">Le guide JavaScript</a> et <a href="/fr/docs/Web/JavaScript/Reference">la référence JavaScript</a></dd>
-</dl>
+- [SpiderMonkey](/fr/docs/SpiderMonkey)
+  - : Informations concernant l'intégration du moteur JavaScript en C/C++ (SpiderMonkey).
+- [Rhino](/fr/docs/Rhino)
+  - : Informations concernant l'intégration du moteur JavaScript en Java (Rhino).
+- [Ressources sur le langage JavaScript](/fr/docs/Web/JavaScript/Language_Resources)
+  - : Liens vers les standards JavaScript publiées.
+- [Une réintroduction à JavaScript](/fr/docs/Web/JavaScript/Une_réintroduction_à_JavaScript)
+  - : [Le guide JavaScript](/fr/docs/Web/JavaScript/Guide) et [la référence JavaScript](/fr/docs/Web/JavaScript/Reference)
 
-<p>JavaScript® est une marque déposée d'Oracle aux États-Unis et dans d'autres pays.</p>
+JavaScript® est une marque déposée d'Oracle aux États-Unis et dans d'autres pays.
diff --git a/files/fr/web/javascript/closures/index.md b/files/fr/web/javascript/closures/index.md
index 85a39326f2..08f3ae7970 100644
--- a/files/fr/web/javascript/closures/index.md
+++ b/files/fr/web/javascript/closures/index.md
@@ -7,34 +7,37 @@ tags:
   - JavaScript
 translation_of: Web/JavaScript/Closures
 ---
-<div>{{jsSidebar("Intermediate")}}</div>
+{{jsSidebar("Intermediate")}}
 
-<p>Une <strong>fermeture </strong>est la paire formée d'une fonction et des références à son état environnant (<strong>l'environnement lexical</strong>). En d'autres termes, une fermeture donne accès à la portée d'une fonction externe à partir d'une fonction interne (on dit aussi que la fonction « capture son environnement »). En JavaScript, une fermeture est créée chaque fois qu'une fonction est créée.</p>
+Une **fermeture** est la paire formée d'une fonction et des références à son état environnant (**l'environnement lexical**). En d'autres termes, une fermeture donne accès à la portée d'une fonction externe à partir d'une fonction interne (on dit aussi que la fonction « capture son environnement »). En JavaScript, une fermeture est créée chaque fois qu'une fonction est créée.
 
-<h2 id="Portée">Portée</h2>
+## Portée
 
-<p>Dans l'exemple suivant :</p>
+Dans l'exemple suivant :
 
-<pre class="brush: js">function init() {
+```js
+function init() {
   var nom = "Mozilla"; // nom est une variable locale de init
   function afficheNom() { // afficheNom est une fonction interne de init
     console.log(nom); // ici nom est une variable libre (définie dans la fonction parente)
   }
   afficheNom();
 };
-init();</pre>
+init();
+```
 
-<p>La fonction <code>init</code> créé une variable locale <code>nom</code> et une fonction interne <code>afficheNom</code>. La fonction interne est seulement visible de l'intérieur de <code>init</code>. Contrairement à <code>init</code>, <code>afficheNom</code> ne possède pas de variable locale propre, mais elle utilise la variable <code>nom</code> de la fonction parente (ceci dit <code>afficheNom</code> pourrait utiliser ses variables locales propres si elle en avait).</p>
+La fonction `init` créé une variable locale `nom` et une fonction interne `afficheNom`. La fonction interne est seulement visible de l'intérieur de `init`. Contrairement à `init`, `afficheNom` ne possède pas de variable locale propre, mais elle utilise la variable `nom` de la fonction parente (ceci dit `afficheNom` pourrait utiliser ses variables locales propres si elle en avait).
 
-<p>{{JSFiddleEmbed("https://jsfiddle.net/78dg25ax/", "js,result", 250)}}</p>
+{{JSFiddleEmbed("https://jsfiddle.net/78dg25ax/", "js,result", 250)}}
 
-<p>Vous pouvez exécuter le code sur cette <a href="https://jsfiddle.net/4U5VD/">page</a> pour voir son fonctionnement. On a ici un exemple de portée lexicale : en JavaScript, la portée d'une variable est définie par son emplacement dans le code source (elle apparaît de façon <em>lexicale</em>), les fonctions imbriquées ont ainsi accès aux variables déclarées dans les portées parentes.</p>
+Vous pouvez exécuter le code sur cette [page](https://jsfiddle.net/4U5VD/) pour voir son fonctionnement. On a ici un exemple de portée lexicale : en JavaScript, la portée d'une variable est définie par son emplacement dans le code source (elle apparaît de façon _lexicale_), les fonctions imbriquées ont ainsi accès aux variables déclarées dans les portées parentes.
 
-<h2 id="Fermeture">Fermeture</h2>
+## Fermeture
 
-<p>Étudions l'exemple suivant :</p>
+Étudions l'exemple suivant :
 
-<pre class="brush: js">function creerFonction() {
+```js
+function creerFonction() {
   var nom = "Mozilla";
   function afficheNom() {
     console.log(nom);
@@ -44,17 +47,18 @@ init();</pre>
 
 var maFonction = creerFonction();
 maFonction();
-</pre>
+```
 
-<p>Ce code produit le même résultat que l'appel à <code>init()</code> étudié précédemment : "Mozilla" est affiché dans la console. L'intérêt de ce code est qu'une fermeture contenant la fonction <code>afficheNom</code> est renvoyée par la fonction parente, avant d'être exécutée.</p>
+Ce code produit le même résultat que l'appel à `init()` étudié précédemment : "Mozilla" est affiché dans la console. L'intérêt de ce code est qu'une fermeture contenant la fonction `afficheNom` est renvoyée par la fonction parente, avant d'être exécutée.
 
-<p>Le code continue à fonctionner, ce qui peut paraître contre-intuitif au regard de la syntaxe utilisée. Usuellement, les variables locales d'une fonction n'existent que pendant l'exécution d'une fonction. Une fois que <code>creerFonction()</code> a fini son exécution, on aurait pû penser que la variable <code>nom</code> n'est plus accessible. Cependant, le code fonctionne : en JavaScript, la variable est donc accessible d'une certaine façon.</p>
+Le code continue à fonctionner, ce qui peut paraître contre-intuitif au regard de la syntaxe utilisée. Usuellement, les variables locales d'une fonction n'existent que pendant l'exécution d'une fonction. Une fois que `creerFonction()` a fini son exécution, on aurait pû penser que la variable `nom` n'est plus accessible. Cependant, le code fonctionne : en JavaScript, la variable est donc accessible d'une certaine façon.
 
-<p>L'explication est la suivante : <code>maFonction</code> est une fermeture. La fermeture combine la fonction <code>afficheNom</code> et son environnement. Cet environnement est composé de toutes les variables locales accessibles (dans la portée) à la création de la fermeture. Ici <code>maFonction</code> est une fermeture qui contient la fonction <code>afficheNom</code> et une référence à la variable <code>var nom = "Mozilla"</code> qui existait lorsque la fermeture a été créée. L'instance de <code>afficheNom</code> conserve une référence à son environnement lexical, dans lequel <code>nom</code>  existe. Pour cette raison, lorsque <code>maFonction</code> est invoquée, la variable <code>nom</code> reste disponible et "Mozilla" est transmis à <code>console.log</code>.</p>
+L'explication est la suivante : `maFonction` est une fermeture. La fermeture combine la fonction `afficheNom` et son environnement. Cet environnement est composé de toutes les variables locales accessibles (dans la portée) à la création de la fermeture. Ici `maFonction` est une fermeture qui contient la fonction `afficheNom` et une référence à la variable `var nom = "Mozilla"` qui existait lorsque la fermeture a été créée. L'instance de `afficheNom` conserve une référence à son environnement lexical, dans lequel `nom`  existe. Pour cette raison, lorsque `maFonction` est invoquée, la variable `nom` reste disponible et "Mozilla" est transmis à `console.log`.
 
-<p>Voici un exemple un peu plus intéressant—une fonction <code>ajouterA</code> :</p>
+Voici un exemple un peu plus intéressant—une fonction `ajouterA` :
 
-<pre class="brush: js">function ajouterA(x) {
+```js
+function ajouterA(x) {
   return function(y) {
     return x + y;
   };
@@ -65,23 +69,24 @@ var ajouter_10 = ajouterA(10);
 
 console.log(ajouter_5(2));  // 7
 console.log(ajouter_10(2)); // 12
-</pre>
+```
 
-<p>On définit une fonction <code>ajouterA(x)</code> avec un seul argument <code>x</code> et qui renvoie une fonction anonyme. La fonction anonyme a un seul argument <code>y</code>, et renvoie la somme de <code>x</code> et <code>y</code>.</p>
+On définit une fonction `ajouterA(x)` avec un seul argument `x` et qui renvoie une fonction anonyme. La fonction anonyme a un seul argument `y`, et renvoie la somme de `x` et `y`.
 
-<p>La fonction <code>ajouterA</code> permet de créer des fermetures qui font la somme de leur argument et d'un nombre fixé. Dans l'exemple ci-dessus, on crée  <code>ajouter_5</code> et <code>ajouter_10</code>. Elles partagent la même fonction, mais des environnements différents. Dans <code>ajouter_5</code>, <code>x</code> vaut 5 ; dans <code>ajouter_10</code>, <code>x</code> vaut 10.</p>
+La fonction `ajouterA` permet de créer des fermetures qui font la somme de leur argument et d'un nombre fixé. Dans l'exemple ci-dessus, on crée  `ajouter_5` et `ajouter_10`. Elles partagent la même fonction, mais des environnements différents. Dans `ajouter_5`, `x` vaut 5 ; dans `ajouter_10`, `x` vaut 10.
 
-<h2 id="Les_fermetures_en_pratique">Les fermetures en pratique</h2>
+## Les fermetures en pratique
 
-<p>On a vu la théorie décrivant les fermetures. Est-ce qu'elles sont utiles pour autant ? Une fermeture permet d'associer des données (l'environnement) avec une fonction qui agit sur ces données. On peut faire un parallèle avec la programmation orientée objet car les objets permettent d'associer des données (les propriétés) avec des méthodes.</p>
+On a vu la théorie décrivant les fermetures. Est-ce qu'elles sont utiles pour autant ? Une fermeture permet d'associer des données (l'environnement) avec une fonction qui agit sur ces données. On peut faire un parallèle avec la programmation orientée objet car les objets permettent d'associer des données (les propriétés) avec des méthodes.
 
-<p>Ainsi, on peut utiliser une fermeture pour tout endroit où on utiliserait un objet et ce avec une seule méthode.</p>
+Ainsi, on peut utiliser une fermeture pour tout endroit où on utiliserait un objet et ce avec une seule méthode.
 
-<p>Beaucoup de code JavaScript utilisé sur le Web gère des événements : on définit un comportement, puis on l'attache à un événement déclenché par l'utilisateur (tel un clic ou une frappe clavier). Notre code est généralement une fonction de rappel (ou <em>callback</em>) exécutée en réponse à l'événement.</p>
+Beaucoup de code JavaScript utilisé sur le Web gère des événements : on définit un comportement, puis on l'attache à un événement déclenché par l'utilisateur (tel un clic ou une frappe clavier). Notre code est généralement une fonction de rappel (ou _callback_) exécutée en réponse à l'événement.
 
-<p>Voici un exemple concret : si on souhaite ajouter des boutons à une page afin d'ajuster la taille du texte, on pourrait définir la taille de police de l'élément <code>body</code> en pixels, et celles des autres éléments relativement à cette première taille grâce à l'unité <code>em</code> :</p>
+Voici un exemple concret : si on souhaite ajouter des boutons à une page afin d'ajuster la taille du texte, on pourrait définir la taille de police de l'élément `body` en pixels, et celles des autres éléments relativement à cette première taille grâce à l'unité `em` :
 
-<pre class="brush: css">body {
+```css
+body {
   font-family: Helvetica, Arial, sans-serif;
   font-size: 12px;
 }
@@ -92,13 +97,14 @@ h1 {
 h2 {
   font-size: 1.2em;
 }
-</pre>
+```
 
-<p>Les boutons vont ensuite changer la taille de la police de l'élément <code>body</code>, ce changement étant répercuté aux autres éléments grâce aux unités relatives.</p>
+Les boutons vont ensuite changer la taille de la police de l'élément `body`, ce changement étant répercuté aux autres éléments grâce aux unités relatives.
 
-<p>Voici le code JavaScript qui correspond :</p>
+Voici le code JavaScript qui correspond :
 
-<pre class="brush: js">function fabriqueRedimensionneur(taille) {
+```js
+function fabriqueRedimensionneur(taille) {
   return function() {
     document.body.style.fontSize = taille + 'px';
   };
@@ -107,31 +113,34 @@ h2 {
 var taille12 = fabriqueRedimensionneur(12);
 var taille14 = fabriqueRedimensionneur(14);
 var taille16 = fabriqueRedimensionneur(16);
-</pre>
+```
 
-<p><code>taille12</code>, <code>taille14</code>, et <code>taille16</code> sont désormais des fermetures qui peuvent, respectivement, redimensionner le texte de l'élément <code>body</code> à 12, 14, ou 16 pixels. On peut les attacher aux boutons de la façon suivantes :</p>
+`taille12`, `taille14`, et `taille16` sont désormais des fermetures qui peuvent, respectivement, redimensionner le texte de l'élément `body` à 12, 14, ou 16 pixels. On peut les attacher aux boutons de la façon suivantes :
 
-<pre class="brush: js">document.getElementById('taille-12').onclick = taille12;
+```js
+document.getElementById('taille-12').onclick = taille12;
 document.getElementById('taille-14').onclick = taille14;
 document.getElementById('taille-16').onclick = taille16;
-</pre>
+```
 
-<pre class="brush: html">&lt;a href="#" id="taille-12"&gt;12&lt;/a&gt;
-&lt;a href="#" id="taille-14"&gt;14&lt;/a&gt;
-&lt;a href="#" id="taille-16"&gt;16&lt;/a&gt;
-</pre>
+```html
+<a href="#" id="taille-12">12</a>
+<a href="#" id="taille-14">14</a>
+<a href="#" id="taille-16">16</a>
+```
 
-<p>{{JSFiddleEmbed("https://jsfiddle.net/vnkuZ/7726", "js,result", 200)}}</p>
+{{JSFiddleEmbed("https://jsfiddle.net/vnkuZ/7726", "js,result", 200)}}
 
-<h2 id="Émuler_des_méthodes_privées_avec_des_fermetures">Émuler des méthodes privées avec des fermetures</h2>
+## Émuler des méthodes privées avec des fermetures
 
-<p>Certains langages de programmation, comme Java, permettent d'avoir des méthodes privées, c'est-à-dire qu'on ne peut les utiliser qu'au sein de la même classe.</p>
+Certains langages de programmation, comme Java, permettent d'avoir des méthodes privées, c'est-à-dire qu'on ne peut les utiliser qu'au sein de la même classe.
 
-<p>JavaScript ne permet pas de faire cela de façon native. En revanche, on peut émuler ce comportement grâce aux fermetures. Les méthodes privées ne sont pas seulement utiles en termes de restriction d'accès au code, elles permettent également de gérer un espace de nom (<em>namespace</em>) global qui isole les méthodes secondaires de l'interface publique du code ainsi rendu plus propre.</p>
+JavaScript ne permet pas de faire cela de façon native. En revanche, on peut émuler ce comportement grâce aux fermetures. Les méthodes privées ne sont pas seulement utiles en termes de restriction d'accès au code, elles permettent également de gérer un espace de nom (_namespace_) global qui isole les méthodes secondaires de l'interface publique du code ainsi rendu plus propre.
 
-<p>Voici comment définir une fonction publique accédant à des fonctions et des variables privées en utilisant des fermetures. Cette façon de procéder est également connue comme le patron de conception <a href="https://en.wikipedia.org/wiki/Module_pattern">module</a> :</p>
+Voici comment définir une fonction publique accédant à des fonctions et des variables privées en utilisant des fermetures. Cette façon de procéder est également connue comme le patron de conception [module](https://en.wikipedia.org/wiki/Module_pattern) :
 
-<pre class="brush: js">var compteur = (function() {
+```js
+var compteur = (function() {
   var compteurPrive = 0;
   function changeValeur(val) {
     compteurPrive += val;
@@ -155,17 +164,18 @@ compteur.increment();
 console.log(compteur.valeur()); /* Affiche 2 */
 compteur.decrement();
 console.log(compteur.valeur()); /* Affiche 1 */
-</pre>
+```
 
-<p>Il y a beaucoup de différences par rapport aux exemples précédents. Au lieu de retourner une simple fonction, on retourne un objet anonyme qui contient 3 fonctions. Et ces 3 fonctions partagent le même environnement. L'objet retourné est affecté à la variable <code>compteur</code>, et les 3 fonctions sont alors accessibles sous les noms <code>compteur.increment</code>, <code>compteur.decrement</code>, et <code>compteur.valeur</code>.</p>
+Il y a beaucoup de différences par rapport aux exemples précédents. Au lieu de retourner une simple fonction, on retourne un objet anonyme qui contient 3 fonctions. Et ces 3 fonctions partagent le même environnement. L'objet retourné est affecté à la variable `compteur`, et les 3 fonctions sont alors accessibles sous les noms `compteur.increment`, `compteur.decrement`, et `compteur.valeur`.
 
-<p>L'environnement partagé vient du corps de la fonction anonyme qui est exécutée dès sa définition complète. L'environnement en question contient deux éléments privés : une variable <code>compteurPrive</code> et une fonction <code>changeValeur</code>. Aucun de ces deux éléments ne peut être utilisé en dehors de la fonction anonyme ; seules les trois fonctions renvoyées par la fonction anonyme sont publiques.</p>
+L'environnement partagé vient du corps de la fonction anonyme qui est exécutée dès sa définition complète. L'environnement en question contient deux éléments privés : une variable `compteurPrive` et une fonction `changeValeur`. Aucun de ces deux éléments ne peut être utilisé en dehors de la fonction anonyme ; seules les trois fonctions renvoyées par la fonction anonyme sont publiques.
 
-<p>Ces trois fonctions publiques sont des fermetures qui partagent le même environnement. Grâce à la portée lexicale, chacune a accès à<code> compteurPrive</code> et à <code>changeValeur</code>.</p>
+Ces trois fonctions publiques sont des fermetures qui partagent le même environnement. Grâce à la portée lexicale, chacune a accès à` compteurPrive` et à `changeValeur`.
 
-<p>On remarquera qu'on définit une fonction anonyme qui crée un compteur puis qu'on l'appelle immédiatement pour assigner le résultat à la variable <code>compteur</code>. On pourrait stocker cette fonction dans une variable puis l'appeler plusieurs fois afin de créer plusieurs compteurs.</p>
+On remarquera qu'on définit une fonction anonyme qui crée un compteur puis qu'on l'appelle immédiatement pour assigner le résultat à la variable `compteur`. On pourrait stocker cette fonction dans une variable puis l'appeler plusieurs fois afin de créer plusieurs compteurs.
 
-<pre class="brush: js">var creerCompteur = function() {
+```js
+var creerCompteur = function() {
   var compteurPrive = 0;
   function changeValeur(val) {
     compteurPrive += val;
@@ -192,23 +202,25 @@ console.log(compteur1.valeur()); /* Affiche 2 */
 compteur1.decrement();
 console.log(compteur1.valeur()); /* Affiche 1 */
 console.log(compteur2.valeur()); /* Affiche 0 */
-</pre>
+```
 
-<p>Ici on peut voir que chacun des deux compteurs est indépendant de l'autre. Un nouvel environnement est instancié à chaque appel <code>creerCompteur()</code>.</p>
+Ici on peut voir que chacun des deux compteurs est indépendant de l'autre. Un nouvel environnement est instancié à chaque appel `creerCompteur()`.
 
-<p>L'utilisation de fermetures permet ainsi de bénéficier de certains concepts liés à la programmation orientée objet comme l'encapsulation et la dissimulation de données.</p>
+L'utilisation de fermetures permet ainsi de bénéficier de certains concepts liés à la programmation orientée objet comme l'encapsulation et la dissimulation de données.
 
-<h2 id="Les_fermetures_et_les_boucles_attention_au_mélange">Les fermetures et les boucles : attention au mélange</h2>
+## Les fermetures et les boucles : attention au mélange
 
-<p>Avant que le mot clé <a href="/fr/docs/Web/JavaScript/Reference/Instructions/let"><code>let</code></a> ne soit introduit avec ECMAScript 2015, un problème se posait fréquemment lorsqu'on manipulait des fermetures au sein d'une boucle. Par exemple :</p>
+Avant que le mot clé [`let`](/fr/docs/Web/JavaScript/Reference/Instructions/let) ne soit introduit avec ECMAScript 2015, un problème se posait fréquemment lorsqu'on manipulait des fermetures au sein d'une boucle. Par exemple :
 
-<pre class="brush: html">&lt;p id="aide"&gt;Des aides seront affichées ici&lt;/p&gt;
-&lt;p&gt;E-mail : &lt;input type="text" id="email" name="email"&gt;&lt;/p&gt;
-&lt;p&gt;Nom : &lt;input type="text" id="nom" name="nom"&gt;&lt;/p&gt;
-&lt;p&gt;Âge : &lt;input type="text" id="âge" name="âge"&gt;&lt;/p&gt;
-</pre>
+```html
+<p id="aide">Des aides seront affichées ici</p>
+<p>E-mail : <input type="text" id="email" name="email"></p>
+<p>Nom : <input type="text" id="nom" name="nom"></p>
+<p>Âge : <input type="text" id="âge" name="âge"></p>
+```
 
-<pre class="brush: js">function afficherAide(aide) {
+```js
+function afficherAide(aide) {
   document.getElementById('aide').innerHTML = aide;
 }
 
@@ -219,7 +231,7 @@ function preparerAide() {
       {'id': 'âge', 'aide': 'Votre âge (plus de 16 ans requis)'}
     ];
 
-  for (var i = 0; i &lt; texteAide.length; i++) {
+  for (var i = 0; i < texteAide.length; i++) {
     var item = texteAide[i];
     document.getElementById(item.id).onfocus = function() {
       afficherAide(item.aide);
@@ -228,17 +240,18 @@ function preparerAide() {
 }
 
 preparerAide();
-</pre>
+```
 
-<p>{{JSFiddleEmbed("https://jsfiddle.net/v7gjv/8164/", "", 200)}}</p>
+{{JSFiddleEmbed("https://jsfiddle.net/v7gjv/8164/", "", 200)}}
 
-<p>Lorsqu'on essaie ce code, on s'aperçoit qu'il ne fonctionne pas exactement comme on le souhaitait : en effet, quelque soit le champ sur lequel on se situe, c'est toujours le message d'aide concernant l'âge qui s'affiche.</p>
+Lorsqu'on essaie ce code, on s'aperçoit qu'il ne fonctionne pas exactement comme on le souhaitait : en effet, quelque soit le champ sur lequel on se situe, c'est toujours le message d'aide concernant l'âge qui s'affiche.
 
-<p>La cause de ce problème est que les fonctions attachées à <code>onfocus</code> sont des fermetures qui partagent le même environnement. À chaque itération de boucle, l'environnement de la fermeture créée contient une référence sur la même instance de la variable <code>item</code>. Ainsi, lorsque la fonction de rappel de <code>onfocus</code> est exécutée, la boucle a déjà été effectuée entièrement, et la variable <code>item</code> partagée par les trois fermetures pointe sur le dernier élément de <code>texteAide</code>.</p>
+La cause de ce problème est que les fonctions attachées à `onfocus` sont des fermetures qui partagent le même environnement. À chaque itération de boucle, l'environnement de la fermeture créée contient une référence sur la même instance de la variable `item`. Ainsi, lorsque la fonction de rappel de `onfocus` est exécutée, la boucle a déjà été effectuée entièrement, et la variable `item` partagée par les trois fermetures pointe sur le dernier élément de `texteAide`.
 
-<p>Une solution consiste à utiliser plus de fermetures et à appliquer une fabrique de fonction comme on a vu précédemment :</p>
+Une solution consiste à utiliser plus de fermetures et à appliquer une fabrique de fonction comme on a vu précédemment :
 
-<pre class="brush: js">function afficheAide(aide) {
+```js
+function afficheAide(aide) {
   document.getElementById('aide').innerHTML = aide;
 }
 
@@ -255,18 +268,19 @@ function prepareAide() {
       {'id': 'âge', 'aide': 'Your age (you must be over 16)'}
     ];
 
-  for (var i = 0; i &lt; texteAide.length; i++) {
+  for (var i = 0; i < texteAide.length; i++) {
     var item = texteAide[i];
     document.getElementById(item.id).onfocus = creerCallbackAide(item.aide);
   }
 }
 
 prepareAide();
-</pre>
+```
 
-<p>Voici une autre solution qui permet de ne pas utiliser plus de fermetures :</p>
+Voici une autre solution qui permet de ne pas utiliser plus de fermetures :
 
-<pre class="brush: js">function afficheAide(aide) {
+```js
+function afficheAide(aide) {
   document.getElementById('aide').innerHTML = aide;
 }
 
@@ -277,7 +291,7 @@ function prepareAide() {
       {'id': 'âge', 'aide': 'Votre âge (vous devez être majeur)'}
     ];
 
-  for (var i = 0; i &lt; texteAide.length; i++) {
+  for (var i = 0; i < texteAide.length; i++) {
     let item = texteAide[i];
     document.getElementById(item.id).onfocus = function() {
       afficheAide(item.aide);
@@ -285,15 +299,17 @@ function prepareAide() {
   }
 }
 
-prepareAide();</pre>
+prepareAide();
+```
 
-<p>Dans ce fragment de code, nous avons utilisé <code>let</code> au lieu de <code>var</code> afin que chaque fermeture soit liée avec les variable de bloc.</p>
+Dans ce fragment de code, nous avons utilisé `let` au lieu de `var` afin que chaque fermeture soit liée avec les variable de bloc.
 
-<p>{{JSFiddleEmbed("https://jsfiddle.net/v7gjv/9573/", "", 300)}}</p>
+{{JSFiddleEmbed("https://jsfiddle.net/v7gjv/9573/", "", 300)}}
 
-<p>Autrement, on aurait pu utiliser <code>forEach()</code> afin de parcourir le tableau <code>texteAide</code> et attacher un gestionnaire d'évènement sur chaque {{htmlelement("div")}} :</p>
+Autrement, on aurait pu utiliser `forEach()` afin de parcourir le tableau `texteAide` et attacher un gestionnaire d'évènement sur chaque {{htmlelement("div")}} :
 
-<pre class="brush: js">function afficheAide(aide) {
+```js
+function afficheAide(aide) {
   document.getElementById('aide').innerHTML = aide;
 }
 
@@ -311,17 +327,19 @@ function prepareAide() {
   });
 }
 
-prepareAide();</pre>
+prepareAide();
+```
 
-<h2 id="Les_performances_et_les_fermetures">Les performances et les fermetures</h2>
+## Les performances et les fermetures
 
-<p>Il est mal avisé de créer des fonctions imbriquées et des fermetures sans utilité. En effet, cela peut dégrader les performances en termes de vitesse d'exécution et de consommation de mémoire.</p>
+Il est mal avisé de créer des fonctions imbriquées et des fermetures sans utilité. En effet, cela peut dégrader les performances en termes de vitesse d'exécution et de consommation de mémoire.
 
-<p>Quand, par exemple, on crée un nouvel objet, les méthodes devraient être associées au prototype de l'objet et non pas définies dans le constructeur de l'objet. De cette façon, on évite que les méthodes soient réassignées à chaque fois qu'un nouvel objet est créé.</p>
+Quand, par exemple, on crée un nouvel objet, les méthodes devraient être associées au prototype de l'objet et non pas définies dans le constructeur de l'objet. De cette façon, on évite que les méthodes soient réassignées à chaque fois qu'un nouvel objet est créé.
 
-<p>Voici un exemple de la mauvaise façon de procéder :</p>
+Voici un exemple de la mauvaise façon de procéder :
 
-<pre class="example-bad brush: js">function MonObjet(nom, message) {
+```js example-bad
+function MonObjet(nom, message) {
   this.nom = nom.toString();
   this.message = message.toString();
   this.getNom = function() {
@@ -332,11 +350,12 @@ prepareAide();</pre>
     return this.message;
   };
 }
-</pre>
+```
 
-<p>Le fragment de code précédent ne tire pas partie des avantages des fermetures. Il pourrait être mieux écrit ainsi :</p>
+Le fragment de code précédent ne tire pas partie des avantages des fermetures. Il pourrait être mieux écrit ainsi :
 
-<pre class="brush: js">function MonObjet(nom, message) {
+```js
+function MonObjet(nom, message) {
   this.nom = nom.toString();
   this.message = message.toString();
 }
@@ -348,11 +367,12 @@ MonObjet.prototype = {
     return this.message;
   }
 };
-</pre>
+```
 
-<p>Cependant, redéfinir le prototype est déconseillé, donc encore meilleur serait d'ajouter les méthodes :</p>
+Cependant, redéfinir le prototype est déconseillé, donc encore meilleur serait d'ajouter les méthodes :
 
-<pre class="brush: js">function MonObjet(nom, message) {
+```js
+function MonObjet(nom, message) {
   this.nom = nom.toString();
   this.message = message.toString();
 }
@@ -362,6 +382,6 @@ MonObjet.prototype.getNom = function() {
 MonObjet.prototype.getMessage = function() {
   return this.message;
 };
-</pre>
+```
 
-<p>Les deux derniers exemples permettent de voir que le prototype hérité est partagé par tous les objets construits et que les méthodes n'ont pas besoin d'être reconstruites pour chaque création d'objet. Veuillez consulter la page sur <a href="/fr/docs/Web/JavaScript/Guide/Le_mod%C3%A8le_objet_JavaScript_en_d%C3%A9tails">le modèle objet JavaScript en détails</a> pour plus d'informations.</p>
+Les deux derniers exemples permettent de voir que le prototype hérité est partagé par tous les objets construits et que les méthodes n'ont pas besoin d'être reconstruites pour chaque création d'objet. Veuillez consulter la page sur [le modèle objet JavaScript en détails](/fr/docs/Web/JavaScript/Guide/Le_mod%C3%A8le_objet_JavaScript_en_d%C3%A9tails) pour plus d'informations.
diff --git a/files/fr/web/javascript/data_structures/index.md b/files/fr/web/javascript/data_structures/index.md
index 7390a819aa..fc7e9c5b42 100644
--- a/files/fr/web/javascript/data_structures/index.md
+++ b/files/fr/web/javascript/data_structures/index.md
@@ -8,313 +8,204 @@ tags:
 translation_of: Web/JavaScript/Data_structures
 original_slug: Web/JavaScript/Structures_de_données
 ---
-<div>{{jsSidebar("More")}}</div>
+{{jsSidebar("More")}}
 
-<p>Les langages de programmation disposent de structures de données natives. Selon les langages, les structures mises à disposition peuvent être différentes. Dans cet article, on listera les structures de données natives en JavaScript. On détaillera leurs propriétés et les façons de les utiliser voire de les combiner. Dans certains cas, on comparera ces structures avec celles d'autres langages.</p>
+Les langages de programmation disposent de structures de données natives. Selon les langages, les structures mises à disposition peuvent être différentes. Dans cet article, on listera les structures de données natives en JavaScript. On détaillera leurs propriétés et les façons de les utiliser voire de les combiner. Dans certains cas, on comparera ces structures avec celles d'autres langages.
 
-<h2 id="Un_typage_dynamique">Un typage dynamique</h2>
+## Un typage dynamique
 
-<p>JavaScript est un langage dont le typage est <em>faible</em> et <em>dynamique</em>. Cela signifie qu'il n'est pas nécessaire de déclarer le type d'une variable avant de l'utiliser. Le type de la variable sera automatiquement déterminé lorsque le programme sera exécuté. Cela signifie également que la même variable pourra avoir différents types au cours de son existence :</p>
+JavaScript est un langage dont le typage est _faible_ et _dynamique_. Cela signifie qu'il n'est pas nécessaire de déclarer le type d'une variable avant de l'utiliser. Le type de la variable sera automatiquement déterminé lorsque le programme sera exécuté. Cela signifie également que la même variable pourra avoir différents types au cours de son existence :
 
-<pre class="brush: js">var toto = 42;       // toto est un nombre
+```js
+var toto = 42;       // toto est un nombre
     toto = "machin"; // toto est une chaîne de caractères désormais
     toto = true;     // et maintenant, toto est un booléen
-</pre>
+```
 
-<h2 id="Les_types_de_données">Les types de données</h2>
+## Les types de données
 
-<p>Le dernier standard ECMAScript définit 8 types de données :</p>
+Le dernier standard ECMAScript définit 8 types de données :
 
-<ul>
- <li>Sept types de données {{Glossary("Primitive", "primitifs")}}:
-  <ul>
-   <li>{{Glossary("Boolean", "Booléen")}}</li>
-   <li>{{Glossary("Null")}}</li>
-   <li>{{Glossary("Undefined")}}</li>
-   <li>{{Glossary("Number", "Nombre")}}</li>
-   <li>{{Glossary("BigInt")}} (proposition pour ES2020)</li>
-   <li>{{Glossary("String", "Chaîne de caractères")}} (String)</li>
-   <li>{{Glossary("Symbol", "Symbole")}} (type introduit avec ECMAScript 6)</li>
-  </ul>
- </li>
- <li>et le type {{Glossary("Object", "Objet")}}</li>
-</ul>
+- Sept types de données {{Glossary("Primitive", "primitifs")}}:
 
-<h2 id="Les_valeurs_primitives">Les valeurs primitives</h2>
+  - {{Glossary("Boolean", "Booléen")}}
+  - {{Glossary("Null")}}
+  - {{Glossary("Undefined")}}
+  - {{Glossary("Number", "Nombre")}}
+  - {{Glossary("BigInt")}} (proposition pour ES2020)
+  - {{Glossary("String", "Chaîne de caractères")}} (String)
+  - {{Glossary("Symbol", "Symbole")}} (type introduit avec ECMAScript 6)
 
-<p>Tous les types, sauf les objets, définissent des valeurs immuables (qu'on ne peut modifier). Ainsi, contrairement au C, les chaînes de caractères sont immuables en JavaScript. Les valeurs immuables pour chacun de ces types sont appelées « valeurs primitives ».</p>
+- et le type {{Glossary("Object", "Objet")}}
 
-<h3 id="Le_type_booléen">Le type booléen</h3>
+## Les valeurs primitives
 
-<p>Un booléen représente le résultat d'une assertion logique et peut avoir deux valeurs : <code>true</code> (pour le vrai logique) et <code>false</code> (pour le faux logique) (voir {{jsxref("Boolean")}} pour plus de détails sur la représentation objet de ce type).</p>
+Tous les types, sauf les objets, définissent des valeurs immuables (qu'on ne peut modifier). Ainsi, contrairement au C, les chaînes de caractères sont immuables en JavaScript. Les valeurs immuables pour chacun de ces types sont appelées « valeurs primitives ».
 
-<h3 id="Le_type_nul">Le type nul</h3>
+### Le type booléen
 
-<p>Le type nul ne possède qu'une valeur : <code>null</code>. Voir {{jsxref("null")}} et {{Glossary("Null")}} pour plus d'informations.</p>
+Un booléen représente le résultat d'une assertion logique et peut avoir deux valeurs : `true` (pour le vrai logique) et `false` (pour le faux logique) (voir {{jsxref("Boolean")}} pour plus de détails sur la représentation objet de ce type).
 
-<h3 id="Le_type_indéfini">Le type indéfini</h3>
+### Le type nul
 
-<p>Une variable à laquelle on n'a pas affecté de valeur vaudra <code>undefined</code>. Voir {{jsxref("undefined")}} et {{Glossary("Undefined")}} pour plus d'informations.</p>
+Le type nul ne possède qu'une valeur : `null`. Voir {{jsxref("null")}} et {{Glossary("Null")}} pour plus d'informations.
 
-<h3 id="Le_type_nombre">Le type nombre</h3>
+### Le type indéfini
 
-<p>ECMAScript possède deux types numériques natifs : <code>Number</code> et <code>BigInt</code> (cf. ci-après)</p>
+Une variable à laquelle on n'a pas affecté de valeur vaudra `undefined`. Voir {{jsxref("undefined")}} et {{Glossary("Undefined")}} pour plus d'informations.
 
-<p>Le type <code>Number</code> est géré pour représenter les nombres : <a href="https://en.wikipedia.org/wiki/Double_precision_floating-point_format">les nombres flottants à précision double, représentés sur 64 bits, selon le format IEEE 754</a> (les nombres compris entre -(2^53 -1) et 2^53 -1). <strong>Il n'y a donc pas de type à part pour représenter les nombres entiers</strong>. En plus de sa capacité à représenter les nombres décimaux, le type nombre possède trois valeurs symboliques : <code>+<a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Infinity">Infinity</a></code>, <code>-Infinity</code>, et {{jsxref("NaN")}} (<em>Not A Number</em> en anglais, qui signifie « n'est pas un nombre »).</p>
+### Le type nombre
 
-<p>Afin de vérifier que des valeurs sont supérieures/inférieures à <code>+/-Infinity</code>, on peut utiliser les constantes {{jsxref("Number.MAX_VALUE")}} et {{jsxref("Number.MIN_VALUE")}}. À partir d'ECMAScript 6, on peut également vérifier si un nombre est/sera compris dans l'intervalle de représentation pour les nombres flottants à précision double en utilisant la méthode {{jsxref("Number.isSafeInteger()")}} ainsi que les valeurs {{jsxref("Number.MAX_SAFE_INTEGER")}} et {{jsxref("Number.MIN_SAFE_INTEGER")}}. En dehors de cet intervalle et pour JavaScript, on considère que les nombres ne sont plus représentés correctement. On manipule alors une approximation de la valeur sous forme d'un nombre à virgule flottante à précision double.</p>
+ECMAScript possède deux types numériques natifs : `Number` et `BigInt` (cf. ci-après)
 
-<p>Le type nombre possède un seul entier pouvant être représenté de deux façons différentes : 0 qui peut être représenté par -0 et +0. ("0" étant un alias pour +0). En pratique, cela n'a généralement aucun impact et<code> +0 === -0</code> vaut bien <code>true</code>. Malgré tout, on peut observer certaines différences quand on divise par zéro :</p>
+Le type `Number` est géré pour représenter les nombres : [les nombres flottants à précision double, représentés sur 64 bits, selon le format IEEE 754](https://en.wikipedia.org/wiki/Double_precision_floating-point_format) (les nombres compris entre -(2^53 -1) et 2^53 -1). **Il n'y a donc pas de type à part pour représenter les nombres entiers**. En plus de sa capacité à représenter les nombres décimaux, le type nombre possède trois valeurs symboliques : `+Infinity`, `-Infinity`, et {{jsxref("NaN")}} (_Not A Number_ en anglais, qui signifie « n'est pas un nombre »).
 
-<pre class="brush: js">42 / +0
+Afin de vérifier que des valeurs sont supérieures/inférieures à `+/-Infinity`, on peut utiliser les constantes {{jsxref("Number.MAX_VALUE")}} et {{jsxref("Number.MIN_VALUE")}}. À partir d'ECMAScript 6, on peut également vérifier si un nombre est/sera compris dans l'intervalle de représentation pour les nombres flottants à précision double en utilisant la méthode {{jsxref("Number.isSafeInteger()")}} ainsi que les valeurs {{jsxref("Number.MAX_SAFE_INTEGER")}} et {{jsxref("Number.MIN_SAFE_INTEGER")}}. En dehors de cet intervalle et pour JavaScript, on considère que les nombres ne sont plus représentés correctement. On manipule alors une approximation de la valeur sous forme d'un nombre à virgule flottante à précision double.
+
+Le type nombre possède un seul entier pouvant être représenté de deux façons différentes : 0 qui peut être représenté par -0 et +0. ("0" étant un alias pour +0). En pratique, cela n'a généralement aucun impact et` +0 === -0` vaut bien `true`. Malgré tout, on peut observer certaines différences quand on divise par zéro :
+
+```js
+42 / +0
 // Infinity
 
 42 / -0
 // -Infinity
-</pre>
+```
 
-<p>Dans la plupart des cas, un nombre représente sa propre valeur, malgré tout les <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_binaires">opérateurs binaires</a> peuvent être utilisés pour représenter plusieurs valeurs booléennes grâce à un seul nombre (on parle alors de <a href="https://fr.wikipedia.org/wiki/Masquage">masque de bits</a>). Ceci est généralement une mauvaise pratique (lisibilité, maintenabilité) bien que ça puisse être utile lorsqu'on souhaite minimiser le nombre de bits qu'on utilise.</p>
+Dans la plupart des cas, un nombre représente sa propre valeur, malgré tout les [opérateurs binaires](/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_binaires) peuvent être utilisés pour représenter plusieurs valeurs booléennes grâce à un seul nombre (on parle alors de [masque de bits](https://fr.wikipedia.org/wiki/Masquage)). Ceci est généralement une mauvaise pratique (lisibilité, maintenabilité) bien que ça puisse être utile lorsqu'on souhaite minimiser le nombre de bits qu'on utilise.
 
-<h3 id="Le_type_BigInt">Le type <code>BigInt</code></h3>
+### Le type `BigInt`
 
-<p>Le type {{jsxref("BigInt")}} permet de représenter des entiers avec une précision arbitraire. Avec ce type, on peut donc manipuler des entiers plus grands que ceux représentables avec <em>Number</em>. Pour créer un grand entier, on ajoutera un <code>n</code> après l'entier ou on appellera le constructeur {{jsxref("BigInt")}}.</p>
+Le type {{jsxref("BigInt")}} permet de représenter des entiers avec une précision arbitraire. Avec ce type, on peut donc manipuler des entiers plus grands que ceux représentables avec _Number_. Pour créer un grand entier, on ajoutera un `n` après l'entier ou on appellera le constructeur {{jsxref("BigInt")}}.
 
-<p>La plus grande valeur représentable avec le type <em>Number</em> est accessible avec la constante {{jsxref("Number.MAX_VALUE")}}. Avec l'apparition de <code>BigInt</code>, on peut représenter et manipuler des entiers plus grands.</p>
+La plus grande valeur représentable avec le type _Number_ est accessible avec la constante {{jsxref("Number.MAX_VALUE")}}. Avec l'apparition de `BigInt`, on peut représenter et manipuler des entiers plus grands.
 
-<pre class="brush: js">const x = 2n ** 53n;
+```js
+const x = 2n ** 53n;
 9007199254740992n;
 const y = x + 1n;
 9007199254740993n
-</pre>
-
-<p>À l'instar des nombres classiques, on peut utiliser les opérateurs <code>+</code>,  <code>*</code>, <code>-</code>, <code>**</code> et <code>%</code>. Un grand entier ne sera pas strictement égal à un nombre mais on pourra avoir une égalité faible.</p>
-
-<p>Un grand entier se comportera comme un nombre lorsqu'il est converti en booléen avec <code>if</code>, <code>||</code>, <code>&amp;&amp;</code>, <code>Boolean</code> et <code>!</code>.</p>
-
-<p>Il n'est pas possible d'utiliser des grands entiers et des nombres de façon interchangeable. Une exception {{jsxref("TypeError")}} sera déclenchée en cas d'incompatibilité.</p>
-
-<h3 id="Le_type_chaîne_de_caractères_String">Le type chaîne de caractères (<em>String</em>)</h3>
-
-<p>Ce type JavaScript est utilisé afin de représenter des données textuelles. C'est un ensemble d'« éléments » de valeurs entières non-signées représentées sur 16 bits. Chaque élément occupe une position au sein de cette chaîne de caractères. Le premier élément est situé à l'indice 0, le deuxième à l'indice 1 et ainsi de suite. La longueur d'une chaîne de caractères correspond au nombre d'éléments qu'elle contient.</p>
-
-<p>À la différence des chaînes de caractères dans le langage C, les chaînes de caractères JavaScript sont immuables. Cela signifie qu'une fois qu'une chaîne est créée, il est impossible de la modifier. En revanche, il est toujours possible de créer une autre chaîne basée sur la première grâce à des opérations. Par exemple :</p>
-
-<ul>
- <li>Un fragment de la chaîne originelle en sélectionnant certaines lettres ou en utilisant {{jsxref("String.substr()")}}.</li>
- <li>Une concaténation de deux chaînes de caractères en utilisant l'opérateur de concaténation (<code>+</code>) ou {{jsxref("String.concat()")}}.</li>
-</ul>
-
-<h4 id="Attention_à_ne_pas_utiliser_les_chaînes_pour_tout_et_nimporte_quoi_!">Attention à ne pas utiliser les chaînes pour tout et n'importe quoi !</h4>
-
-<p>Ça peut être tentant de vouloir utiliser des chaînes afin de représenter des données complexes. En revanche, les avantages de cette méthode ne sont que très superficiels :</p>
-
-<ul>
- <li>On peut facilement construire des chaînes complexes grâce à la concaténation.</li>
- <li>On peut déboguer rapidement le contenu des chaînes de caractères.</li>
- <li>Les chaînes de caractères sont utilisées à de multiples endroits dans beaucoup d'API (<a href="/fr/docs/Web/API/HTMLInputElement">champs de saisie</a>, valeurs en <a href="/fr/docs/Storage">stockage local</a>, réponses {{ domxref("XMLHttpRequest") }} avec <code>responseText</code>, etc.).</li>
-</ul>
-
-<p>En utilisant des conventions, il peut être possible de représenter n'importe quelle donnée sous forme d'une chaîne de caractères, en revanche cela n'est souvent pas la meilleure façon. (Par exemple, avec un séparateur, on pourrait émuler le comportement d'un tableau en « interdisant » que ce séparateur soit utilisé pour éléments, etc. on pourrait ensuite définir un caractère d'échappement, qui serait à son tour inutilisable dans les chaînes : toutes ces pseudo-conventions entraîneront de lourdes conséquences en termes de maintenance.)</p>
-
-<p>En résumé, les chaînes doivent être utilisées pour les données textuelles. Pour des données plus complexes, utilisez une abstraction adéquate et analysez/parsez les chaînes que vous recevez d'autres API.</p>
-
-<h3 id="Le_type_symbole">Le type symbole</h3>
-
-<p>Les symboles sont une nouveautés du langage, apportée par ECMAScript 6. Un symbole est une valeur primitive <strong>unique</strong> et <strong>immuable</strong> pouvant être utilisée comme clé pour propriété d'un objet (voir ci-après). Dans d'autres langages de programmation, les symboles sont appelés atomes. Pour plus de détails, voir les pages {{Glossary("Symbol","Symbole")}} et le constructeur {{jsxref("Symbol")}} JavaScript.</p>
-
-<h2 id="Les_objets">Les objets</h2>
-
-<p>En informatique, un objet est une valeur conservée en mémoire à laquelle on fait référence grâce à un {{Glossary("Identifier", "identifiant")}}.</p>
-
-<h3 id="Propriétés">Propriétés</h3>
-
-<p>En JavaScript, les objets peuvent être considérés comme des collections de propriétés. En utilisant <a href="/fr/docs/Web/JavaScript/Guide/Valeurs,_variables,_et_littéraux#Les_litt.C3.A9raux_objets">un littéral objet</a>, il est possible d'initialiser un ensemble limité de propriétés ; d'autres propriétés peuvent ensuite être ajoutées et/ou retirées. Les valeurs des propriétés peuvent être de n'importe quel type, y compris des objets. Cela permet de construire des structures de données complexes. Les propriétés sont identifiées grâce à une « clé ». Une clé peut être une chaîne de caractères ou un symbole.</p>
-
-<p>Il existe deux types de propriétés qui ont certains attributs : des propriétés de données (<em>data property</em>) et des propriétés d'accesseur.</p>
-
-<h4 id="Propriétés_de_données">Propriétés de données</h4>
-
-<p>Elles associent une clé avec une valeur et possèdent les attributs suivants :</p>
-
-<table class="standard-table">
- <caption>Attributs d'une propriété de données</caption>
- <tbody>
-  <tr>
-   <th>Attribut</th>
-   <th>Type</th>
-   <th>Description</th>
-   <th>Valeur par défaut</th>
-  </tr>
-  <tr>
-   <td>[[Value]]</td>
-   <td>N'importe quelle valeur JavaScript</td>
-   <td>La valeur obtenue lorsqu'on accède à la propriété.</td>
-   <td><code>undefined</code></td>
-  </tr>
-  <tr>
-   <td>[[Writable]]</td>
-   <td>Booléen</td>
-   <td>S'il vaut <code>false</code>, la valeur de la propriété (l'attribut [[Value]]) ne peut être changé.</td>
-   <td><code>false</code></td>
-  </tr>
-  <tr>
-   <td>[[Enumerable]]</td>
-   <td>Booléen</td>
-   <td>S'il vaut <code>true</code>, la propriété pourra être listée par une boucle <code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/for...in">for...in</a></code>. Voir également <a href="/fr/docs/Web/JavaScript/Caract%C3%A8re_%C3%A9num%C3%A9rable_des_propri%C3%A9t%C3%A9s_et_rattachement">l'article sur le caractère énumérable des propriétés</a>.</td>
-   <td><code>false</code></td>
-  </tr>
-  <tr>
-   <td>[[Configurable]]</td>
-   <td>Booléen</td>
-   <td>S'il vaut <code>false</code>, la propriété ne pourra pas être supprimée, elle ne pourra pas être changée en accesseur et les attributs autres que [[Value]] et [[Writable]] ne pourront pas être modifiés.</td>
-   <td><code>false</code></td>
-  </tr>
- </tbody>
-</table>
-
-<table class="standard-table">
- <caption>Attributes obsolètes (faisaient partie d'ECMAScript 3, renommés avec ECMAScript 5)</caption>
- <tbody>
-  <tr>
-   <th>Attribut</th>
-   <th>Type</th>
-   <th>Description</th>
-  </tr>
-  <tr>
-   <td>Read-only</td>
-   <td>Booléen</td>
-   <td>État symétrique pour l'attribut ES5 [[Writable]].</td>
-  </tr>
-  <tr>
-   <td>DontEnum</td>
-   <td>Booléen</td>
-   <td>État symétrique pour l'attribut ES5 [[Enumerable]].</td>
-  </tr>
-  <tr>
-   <td>DontDelete</td>
-   <td>Booléen</td>
-   <td>État symétrique pour l'attribut ES5 [[Configurable]].</td>
-  </tr>
- </tbody>
-</table>
-
-<h4 id="Propriétés_daccesseur">Propriétés d'accesseur</h4>
-
-<p>Ces propriétés associent une clé avec une ou deux fonctions accesseur et mutateur qui permettent de récupérer ou d'enregistrer une valeur. Elles possèdent les attributs suivants :</p>
-
-<table class="standard-table">
- <caption>Attributs d'une propriété d'accesseur</caption>
- <tbody>
-  <tr>
-   <th>Attribut</th>
-   <th>Type</th>
-   <th>Description</th>
-   <th>Valeur par défaut</th>
-  </tr>
-  <tr>
-   <td>[[Get]]</td>
-   <td>Un objet <code>Function</code> ou <code>undefined</code></td>
-   <td>La fonction qui est appelée sans argument afin de récupérer la valeur de la propriété quand on souhaite y accéder. Voir aussi la page sur <a href="/fr/docs/Web/JavaScript/Reference/Fonctions/get"><code>get</code></a>.</td>
-   <td><code>undefined</code></td>
-  </tr>
-  <tr>
-   <td>[[Set]]</td>
-   <td>Un objet <code>Function</code> ou <code>undefined</code></td>
-   <td>La fonction, appelée avec un argument qui contient la valeur qu'on souhaite affecter à la valeur et qui est exécutée à chaque fois qu'on souhaite modifier la valeur. Voir aussi la page sur <a href="/fr/docs/Web/JavaScript/Reference/Fonctions/set"><code>set</code></a>.</td>
-   <td><code>undefined</code></td>
-  </tr>
-  <tr>
-   <td>[[Enumerable]]</td>
-   <td>Booléen</td>
-   <td>S'il vaut <code>true</code>, la propriété sera listée dans les boucles <code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/for...in">for...in</a></code>.</td>
-   <td><code>false</code></td>
-  </tr>
-  <tr>
-   <td>[[Configurable]]</td>
-   <td>Booléen</td>
-   <td>S'il vaut <code>false</code>, la propriété ne pourra pas être supprimée et ne pourra pas être transformée en une propriété de données.</td>
-   <td><code>false</code></td>
-  </tr>
- </tbody>
-</table>
-
-<div class="note">
-<p><strong>Note :</strong> Les attributs sont généralement utilisés par le moteur JavaScript plutôt qu'explicitement dans les scripts. Il est impossible d'y accéder directement (plus d'informations sur {{jsxref("Object.defineProperty()")}}. C'est pour cela que l'attribut est décrit entre double crochets (comme dans la spécification ECMAScript) plutôt qu'entre crochets simples qui pourraient laisser penser à une propriété « classique ».</p>
-</div>
-
-<h3 id="Les_objets_«_normaux_»_et_les_fonctions">Les objets « normaux » et les fonctions</h3>
-
-<p>Un objet JavaScript est un ensemble de correspondances entre des clés et des valeurs. Les clés sont représentées par des chaînes ou des symboles ({{jsxref("Symbol")}}). Les valeurs peuvent être de n'importe quel type. Grâce à cela, les objets peuvent, naturellement, être utilisés comme<a class="external" href="https://fr.wikipedia.org/wiki/Table_de_hachage"> tables de hachage</a>.</p>
-
-<p>Les fonctions sont des objets classiques à la seule différence qu'on peut les appeler.</p>
-
-<h3 id="Les_dates">Les dates</h3>
-
-<p>Lorsqu'on souhaite représenter des dates, il est tout indiqué d'utiliser le type utilitaire natif <a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Date"><code>Date</code></a> de JavaScript.</p>
-
-<h3 id="Les_collections_indexées_les_tableaux_Arrays_et_les_tableaux_typés_Typed_Arrays">Les collections indexées : les tableaux (<em>Arrays</em>) et les tableaux typés (<em>Typed Arrays</em>)</h3>
-
-<p><a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Array">Les tableaux</a> (ou <em>Arrays</em> en anglais) sont des objets natifs qui permettent d'organiser des valeurs numérotées et qui ont une relation particulière avec la propriété <code>length</code>. De plus, les tableaux héritent de <code>Array.prototype</code> qui permet de bénéficier de plusieurs méthodes pour manipuler les tableaux. Par exemple, <code><a href="/fr/docs/JavaScript/Reference/Objets_globaux/Array/indexOf">indexOf</a></code> qui permet de rechercher une valeur dans le tableau ou <code><a href="/fr/docs/JavaScript/Reference/Global_Objects/Array/push">push</a></code> qui permet d'ajouter un élément au tableau. Les tableaux sont donc indiqués quand on souhaite représenter des listes de valeurs ou d'objets.</p>
-
-<p><a href="/fr/docs/JavaScript/Tableaux_typ%C3%A9s">Les tableaux typés</a> (<em>Typed Arrays</em> en anglais) ont été ajoutés avec ECMAScript 6 et offrent une vue sous forme d'un tableau pour manipuler des tampons de données binaires. Le tableau qui suit illustre les types de données équivalents en C :</p>
-
-<p>{{page("fr/docs/Web/JavaScript/Reference/Objets_globaux/TypedArray", "Les_objets_TypedArray", "", 0, 3)}}</p>
-
-<h3 id="Les_collections_avec_clés_Maps_Sets_WeakMaps_WeakSets">Les collections avec clés : Maps, Sets, WeakMaps, WeakSets</h3>
-
-<p>Ces structures de données utilisent des clés pour référencer des objets. Elles ont été introduites avec ECMAScript 6. {{jsxref("Set")}} et {{jsxref("WeakSet")}} représentent des ensembles d'objets, {{jsxref("Map")}} et {{jsxref("WeakMap")}} associent une valeur à un objet. Il est possible d'énumérer les valeurs contenues dans un objet Map mais pas dans un objet WeakMap. Les WeakMaps quant à eux permettent certaines optimisations dans la gestion de la mémoire et le travail du ramasse-miettes.</p>
-
-<p>Il est possible d'implémenter les Maps et Sets grâce à ECMAScript 5. Cependant, comme les objets ne peuvent pas être comparés (avec une relation d'ordre par exemple), la complexité obtenue pour rechercher un élément serait nécessairement linéaire. Les implémentations natives (y compris celle des WeakMaps) permettent d'obtenir des performances logarithmiques voire constantes.</p>
-
-<p>Généralement, si on voulait lier des données à un nœud DOM, on pouvait utiliser les attributs <code>data-*</code> ou définir les propriétés à un même l'objet. Malheureusement, cela rendait les données disponibles à n'importe quel script fonctionnant dans le même contexte. Les Maps et WeakMaps permettent de gérer plus simplement une liaison « privée » entre des données et un objet.</p>
-
-<h3 id="Les_données_structurées_JSON">Les données structurées : JSON</h3>
-
-<p>JSON (JavaScript Object Notation) est un format d'échange de données léger, dérivé de JavaScript et utilisé par plusieurs langages de programmation. JSON permet ainsi de construire des structures de données universelles pouvant être échangées entre programmes. Pour plus d'informations, voir les pages {{Glossary("JSON")}} et {{jsxref("JSON")}}.</p>
-
-<h3 id="Les_autres_objets_de_la_bibliothèque_standard">Les autres objets de la bibliothèque standard</h3>
-
-<p>JavaScript possède une bibliothèque standard d'objets natifs. Veuillez lire la <a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux">référence</a> pour en savoir plus sur ces objets.</p>
-
-<h2 id="Déterminer_le_type_des_objets_grâce_à_lopérateur_typeof">Déterminer le type des objets grâce à l'opérateur <code>typeof</code></h2>
-
-<p>L'opérateur <code>typeof</code> peut vous aider à déterminer le type d'une variable. Pour plus d'informations et sur les cas particuliers, voir la page de la référence sur <a href="/fr/docs/JavaScript/Reference/R%C3%A9f%C3%A9rence_JavaScript/Op%C3%A9rateurs/Op%C3%A9rateurs_sp%C3%A9ciaux/L'op%C3%A9rateur_typeof">cet opérateur</a>.</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.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-8', 'Types')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES2015', '#sec-ecmascript-data-types-and-values', 'ECMAScript Data Types and Values')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Ajout des symboles ({{jsxref("Symbol")}}).</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-ecmascript-data-types-and-values', 'ECMAScript Data Types and Values')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li><a class="link-https" href="https://github.com/nzakas/computer-science-in-javascript/">Un ensemble de structures de données usuelles et d'algorithmes classiques, en JavaScript, par Nicholas Zakas</a> (en anglais)</li>
- <li><a href="https://github.com/monmohan/DataStructures_In_Javascript">Implémentations de différentes structures de données et utilitaires de recherche en JavaScript</a> (en anglais)</li>
-</ul>
+```
+
+À l'instar des nombres classiques, on peut utiliser les opérateurs `+`,  `*`, `-`, `**` et `%`. Un grand entier ne sera pas strictement égal à un nombre mais on pourra avoir une égalité faible.
+
+Un grand entier se comportera comme un nombre lorsqu'il est converti en booléen avec `if`, `||`, `&&`, `Boolean` et `!`.
+
+Il n'est pas possible d'utiliser des grands entiers et des nombres de façon interchangeable. Une exception {{jsxref("TypeError")}} sera déclenchée en cas d'incompatibilité.
+
+### Le type chaîne de caractères (_String_)
+
+Ce type JavaScript est utilisé afin de représenter des données textuelles. C'est un ensemble d'« éléments » de valeurs entières non-signées représentées sur 16 bits. Chaque élément occupe une position au sein de cette chaîne de caractères. Le premier élément est situé à l'indice 0, le deuxième à l'indice 1 et ainsi de suite. La longueur d'une chaîne de caractères correspond au nombre d'éléments qu'elle contient.
+
+À la différence des chaînes de caractères dans le langage C, les chaînes de caractères JavaScript sont immuables. Cela signifie qu'une fois qu'une chaîne est créée, il est impossible de la modifier. En revanche, il est toujours possible de créer une autre chaîne basée sur la première grâce à des opérations. Par exemple :
+
+- Un fragment de la chaîne originelle en sélectionnant certaines lettres ou en utilisant {{jsxref("String.substr()")}}.
+- Une concaténation de deux chaînes de caractères en utilisant l'opérateur de concaténation (`+`) ou {{jsxref("String.concat()")}}.
+
+#### Attention à ne pas utiliser les chaînes pour tout et n'importe quoi !
+
+Ça peut être tentant de vouloir utiliser des chaînes afin de représenter des données complexes. En revanche, les avantages de cette méthode ne sont que très superficiels :
+
+- On peut facilement construire des chaînes complexes grâce à la concaténation.
+- On peut déboguer rapidement le contenu des chaînes de caractères.
+- Les chaînes de caractères sont utilisées à de multiples endroits dans beaucoup d'API ([champs de saisie](/fr/docs/Web/API/HTMLInputElement), valeurs en [stockage local](/fr/docs/Storage), réponses {{ domxref("XMLHttpRequest") }} avec `responseText`, etc.).
+
+En utilisant des conventions, il peut être possible de représenter n'importe quelle donnée sous forme d'une chaîne de caractères, en revanche cela n'est souvent pas la meilleure façon. (Par exemple, avec un séparateur, on pourrait émuler le comportement d'un tableau en « interdisant » que ce séparateur soit utilisé pour éléments, etc. on pourrait ensuite définir un caractère d'échappement, qui serait à son tour inutilisable dans les chaînes : toutes ces pseudo-conventions entraîneront de lourdes conséquences en termes de maintenance.)
+
+En résumé, les chaînes doivent être utilisées pour les données textuelles. Pour des données plus complexes, utilisez une abstraction adéquate et analysez/parsez les chaînes que vous recevez d'autres API.
+
+### Le type symbole
+
+Les symboles sont une nouveautés du langage, apportée par ECMAScript 6. Un symbole est une valeur primitive **unique** et **immuable** pouvant être utilisée comme clé pour propriété d'un objet (voir ci-après). Dans d'autres langages de programmation, les symboles sont appelés atomes. Pour plus de détails, voir les pages {{Glossary("Symbol","Symbole")}} et le constructeur {{jsxref("Symbol")}} JavaScript.
+
+## Les objets
+
+En informatique, un objet est une valeur conservée en mémoire à laquelle on fait référence grâce à un {{Glossary("Identifier", "identifiant")}}.
+
+### Propriétés
+
+En JavaScript, les objets peuvent être considérés comme des collections de propriétés. En utilisant [un littéral objet](/fr/docs/Web/JavaScript/Guide/Valeurs,_variables,_et_littéraux#Les_litt.C3.A9raux_objets), il est possible d'initialiser un ensemble limité de propriétés ; d'autres propriétés peuvent ensuite être ajoutées et/ou retirées. Les valeurs des propriétés peuvent être de n'importe quel type, y compris des objets. Cela permet de construire des structures de données complexes. Les propriétés sont identifiées grâce à une « clé ». Une clé peut être une chaîne de caractères ou un symbole.
+
+Il existe deux types de propriétés qui ont certains attributs : des propriétés de données (_data property_) et des propriétés d'accesseur.
+
+#### Propriétés de données
+
+Elles associent une clé avec une valeur et possèdent les attributs suivants :
+
+| Attribut         | Type                               | Description                                                                                                                                                                                                                                                                                                          | Valeur par défaut |
+| ---------------- | ---------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------- |
+| [[Value]]        | N'importe quelle valeur JavaScript | La valeur obtenue lorsqu'on accède à la propriété.                                                                                                                                                                                                                                                                   | `undefined`       |
+| [[Writable]]     | Booléen                            | S'il vaut `false`, la valeur de la propriété (l'attribut [[Value]]) ne peut être changé.                                                                                                                                                                                                                             | `false`           |
+| [[Enumerable]]   | Booléen                            | S'il vaut `true`, la propriété pourra être listée par une boucle [`for...in`](/fr/docs/Web/JavaScript/Reference/Instructions/for...in). Voir également [l'article sur le caractère énumérable des propriétés](/fr/docs/Web/JavaScript/Caract%C3%A8re_%C3%A9num%C3%A9rable_des_propri%C3%A9t%C3%A9s_et_rattachement). | `false`           |
+| [[Configurable]] | Booléen                            | S'il vaut `false`, la propriété ne pourra pas être supprimée, elle ne pourra pas être changée en accesseur et les attributs autres que [[Value]] et [[Writable]] ne pourront pas être modifiés.                                                                                                                      | `false`           |
+
+| Attribut   | Type    | Description                                           |
+| ---------- | ------- | ----------------------------------------------------- |
+| Read-only  | Booléen | État symétrique pour l'attribut ES5 [[Writable]].     |
+| DontEnum   | Booléen | État symétrique pour l'attribut ES5 [[Enumerable]].   |
+| DontDelete | Booléen | État symétrique pour l'attribut ES5 [[Configurable]]. |
+
+#### Propriétés d'accesseur
+
+Ces propriétés associent une clé avec une ou deux fonctions accesseur et mutateur qui permettent de récupérer ou d'enregistrer une valeur. Elles possèdent les attributs suivants :
+
+| Attribut         | Type                               | Description                                                                                                                                                                                                                                            | Valeur par défaut |
+| ---------------- | ---------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ----------------- |
+| [[Get]]          | Un objet `Function` ou `undefined` | La fonction qui est appelée sans argument afin de récupérer la valeur de la propriété quand on souhaite y accéder. Voir aussi la page sur [`get`](/fr/docs/Web/JavaScript/Reference/Fonctions/get).                                                    | `undefined`       |
+| [[Set]]          | Un objet `Function` ou `undefined` | La fonction, appelée avec un argument qui contient la valeur qu'on souhaite affecter à la valeur et qui est exécutée à chaque fois qu'on souhaite modifier la valeur. Voir aussi la page sur [`set`](/fr/docs/Web/JavaScript/Reference/Fonctions/set). | `undefined`       |
+| [[Enumerable]]   | Booléen                            | S'il vaut `true`, la propriété sera listée dans les boucles [`for...in`](/fr/docs/Web/JavaScript/Reference/Instructions/for...in).                                                                                                                     | `false`           |
+| [[Configurable]] | Booléen                            | S'il vaut `false`, la propriété ne pourra pas être supprimée et ne pourra pas être transformée en une propriété de données.                                                                                                                            | `false`           |
+
+> **Note :** Les attributs sont généralement utilisés par le moteur JavaScript plutôt qu'explicitement dans les scripts. Il est impossible d'y accéder directement (plus d'informations sur {{jsxref("Object.defineProperty()")}}. C'est pour cela que l'attribut est décrit entre double crochets (comme dans la spécification ECMAScript) plutôt qu'entre crochets simples qui pourraient laisser penser à une propriété « classique ».
+
+### Les objets « normaux » et les fonctions
+
+Un objet JavaScript est un ensemble de correspondances entre des clés et des valeurs. Les clés sont représentées par des chaînes ou des symboles ({{jsxref("Symbol")}}). Les valeurs peuvent être de n'importe quel type. Grâce à cela, les objets peuvent, naturellement, être utilisés comme[ tables de hachage](https://fr.wikipedia.org/wiki/Table_de_hachage).
+
+Les fonctions sont des objets classiques à la seule différence qu'on peut les appeler.
+
+### Les dates
+
+Lorsqu'on souhaite représenter des dates, il est tout indiqué d'utiliser le type utilitaire natif [`Date`](/fr/docs/Web/JavaScript/Reference/Objets_globaux/Date) de JavaScript.
+
+### Les collections indexées : les tableaux (_Arrays_) et les tableaux typés (_Typed Arrays_)
+
+[Les tableaux](/fr/docs/Web/JavaScript/Reference/Objets_globaux/Array) (ou _Arrays_ en anglais) sont des objets natifs qui permettent d'organiser des valeurs numérotées et qui ont une relation particulière avec la propriété `length`. De plus, les tableaux héritent de `Array.prototype` qui permet de bénéficier de plusieurs méthodes pour manipuler les tableaux. Par exemple, [`indexOf`](/fr/docs/JavaScript/Reference/Objets_globaux/Array/indexOf) qui permet de rechercher une valeur dans le tableau ou [`push`](/fr/docs/JavaScript/Reference/Global_Objects/Array/push) qui permet d'ajouter un élément au tableau. Les tableaux sont donc indiqués quand on souhaite représenter des listes de valeurs ou d'objets.
+
+[Les tableaux typés](/fr/docs/JavaScript/Tableaux_typ%C3%A9s) (_Typed Arrays_ en anglais) ont été ajoutés avec ECMAScript 6 et offrent une vue sous forme d'un tableau pour manipuler des tampons de données binaires. Le tableau qui suit illustre les types de données équivalents en C :
+
+{{page("fr/docs/Web/JavaScript/Reference/Objets_globaux/TypedArray", "Les_objets_TypedArray", "", 0, 3)}}
+
+### Les collections avec clés : Maps, Sets, WeakMaps, WeakSets
+
+Ces structures de données utilisent des clés pour référencer des objets. Elles ont été introduites avec ECMAScript 6. {{jsxref("Set")}} et {{jsxref("WeakSet")}} représentent des ensembles d'objets, {{jsxref("Map")}} et {{jsxref("WeakMap")}} associent une valeur à un objet. Il est possible d'énumérer les valeurs contenues dans un objet Map mais pas dans un objet WeakMap. Les WeakMaps quant à eux permettent certaines optimisations dans la gestion de la mémoire et le travail du ramasse-miettes.
+
+Il est possible d'implémenter les Maps et Sets grâce à ECMAScript 5. Cependant, comme les objets ne peuvent pas être comparés (avec une relation d'ordre par exemple), la complexité obtenue pour rechercher un élément serait nécessairement linéaire. Les implémentations natives (y compris celle des WeakMaps) permettent d'obtenir des performances logarithmiques voire constantes.
+
+Généralement, si on voulait lier des données à un nœud DOM, on pouvait utiliser les attributs `data-*` ou définir les propriétés à un même l'objet. Malheureusement, cela rendait les données disponibles à n'importe quel script fonctionnant dans le même contexte. Les Maps et WeakMaps permettent de gérer plus simplement une liaison « privée » entre des données et un objet.
+
+### Les données structurées : JSON
+
+JSON (JavaScript Object Notation) est un format d'échange de données léger, dérivé de JavaScript et utilisé par plusieurs langages de programmation. JSON permet ainsi de construire des structures de données universelles pouvant être échangées entre programmes. Pour plus d'informations, voir les pages {{Glossary("JSON")}} et {{jsxref("JSON")}}.
+
+### Les autres objets de la bibliothèque standard
+
+JavaScript possède une bibliothèque standard d'objets natifs. Veuillez lire la [référence](/fr/docs/Web/JavaScript/Reference/Objets_globaux) pour en savoir plus sur ces objets.
+
+## Déterminer le type des objets grâce à l'opérateur `typeof`
+
+L'opérateur `typeof` peut vous aider à déterminer le type d'une variable. Pour plus d'informations et sur les cas particuliers, voir la page de la référence sur [cet opérateur](/fr/docs/JavaScript/Reference/R%C3%A9f%C3%A9rence_JavaScript/Op%C3%A9rateurs/Op%C3%A9rateurs_sp%C3%A9ciaux/L'op%C3%A9rateur_typeof).
+
+## Spécifications
+
+| Spécification                                                                                                                        | État                         | Commentaires                                       |
+| ------------------------------------------------------------------------------------------------------------------------------------ | ---------------------------- | -------------------------------------------------- |
+| {{SpecName('ES1')}}                                                                                                             | {{Spec2('ES1')}}         | Définition initiale.                               |
+| {{SpecName('ES5.1', '#sec-8', 'Types')}}                                                                                 | {{Spec2('ES5.1')}}     |                                                    |
+| {{SpecName('ES2015', '#sec-ecmascript-data-types-and-values', 'ECMAScript Data Types and Values')}} | {{Spec2('ES2015')}}     | Ajout des symboles ({{jsxref("Symbol")}}). |
+| {{SpecName('ESDraft', '#sec-ecmascript-data-types-and-values', 'ECMAScript Data Types and Values')}} | {{Spec2('ESDraft')}} |                                                    |
+
+## Voir aussi
+
+- [Un ensemble de structures de données usuelles et d'algorithmes classiques, en JavaScript, par Nicholas Zakas](https://github.com/nzakas/computer-science-in-javascript/) (en anglais)
+- [Implémentations de différentes structures de données et utilitaires de recherche en JavaScript](https://github.com/monmohan/DataStructures_In_Javascript) (en anglais)
diff --git a/files/fr/web/javascript/enumerability_and_ownership_of_properties/index.md b/files/fr/web/javascript/enumerability_and_ownership_of_properties/index.md
index a2a24711a8..cad3505a3d 100644
--- a/files/fr/web/javascript/enumerability_and_ownership_of_properties/index.md
+++ b/files/fr/web/javascript/enumerability_and_ownership_of_properties/index.md
@@ -8,161 +8,332 @@ tags:
 translation_of: Web/JavaScript/Enumerability_and_ownership_of_properties
 original_slug: Web/JavaScript/Caractère_énumérable_des_propriétés_et_rattachement
 ---
-<div>{{JsSidebar("More")}}</div>
+{{JsSidebar("More")}}
 
-<p>Les propriétés dites « énumérables » sont celles pour lesquelles la caractéristique interne <code>[[Enumerable]]</code> vaut <code>true</code>. C'est le cas par défaut pour les propriétés qui sont créées grâce à une affectation simple ou grâce à un initialisateur de propriété. Les propriétés définies avec des méthodes analogues à {{jsxref("Object.defineProperty()")}} auront <code>[[Enumerable]]</code> à <code>false</code>). Les propriétés énumérables sont celles qui seront parcourues dans une boucle {{jsxref("Instructions/for...in","for..in")}} (sauf si le nom de la propriété est un {{jsxref("Symbol")}}).</p>
+Les propriétés dites « énumérables » sont celles pour lesquelles la caractéristique interne `[[Enumerable]]` vaut `true`. C'est le cas par défaut pour les propriétés qui sont créées grâce à une affectation simple ou grâce à un initialisateur de propriété. Les propriétés définies avec des méthodes analogues à {{jsxref("Object.defineProperty()")}} auront `[[Enumerable]]` à `false`). Les propriétés énumérables sont celles qui seront parcourues dans une boucle {{jsxref("Instructions/for...in","for..in")}} (sauf si le nom de la propriété est un {{jsxref("Symbol")}}).
 
-<p>Le rattachement des propriétés est détérminé selon que la propriété est directement rattachée à l'objet et non à sa chaîne de prototypes. Il est également possible de récupérer l'ensemble des propriétés d'un objet. Dans le tableau suivant, on détaille les moyens possibles pour détecter, parcourir, énumérer, récupérer les propriétés d'un objet.</p>
+Le rattachement des propriétés est détérminé selon que la propriété est directement rattachée à l'objet et non à sa chaîne de prototypes. Il est également possible de récupérer l'ensemble des propriétés d'un objet. Dans le tableau suivant, on détaille les moyens possibles pour détecter, parcourir, énumérer, récupérer les propriétés d'un objet.
 
 <table>
- <caption>Caractère énumérable et rattachement - méthodes natives pour détecter, récupérer et parcourir les propriétés</caption>
- <tbody>
-  <tr>
-   <th>Fonctionnalité</th>
-   <th>Rattachement direct à l'objet</th>
-   <th>Rattachement direct à l'objet et sur la chaîne de prototypes</th>
-   <th>Uniquement sur la chaîne de prototypes</th>
-  </tr>
-  <tr>
-   <td>Détection</td>
-   <td>
-    <table>
-     <thead>
-      <tr>
-       <th scope="col">Énumérables</th>
-       <th scope="col">Non-énumérables</th>
-       <th scope="col">Toutes</th>
-      </tr>
-     </thead>
-     <tbody>
-      <tr>
-       <td>
-        <p><code><a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object/propertyIsEnumerable">propertyIsEnumerable()</a></code></p>
-
-        <p><code><a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object/hasOwnProperty">hasOwnProperty()</a></code></p>
-       </td>
-       <td><code><a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object/hasOwnProperty">hasOwnProperty()</a> - </code>en utilisant <code><a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object/propertyIsEnumerable">propertyIsEnumerable()</a></code> afin d'exclure les propriétés énumérables</td>
-       <td><code><a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object/hasOwnProperty">hasOwnProperty()</a></code></td>
-      </tr>
-     </tbody>
-    </table>
-   </td>
-   <td>
-    <table>
-     <thead>
-      <tr>
-       <th scope="col">Énumerables</th>
-       <th scope="col">Non-énumérables</th>
-       <th scope="col">Toutes</th>
-      </tr>
-     </thead>
-     <tbody>
-      <tr>
-       <td>Cette fonctionnalité n'est pas disponible sans code supplémentaire.</td>
-       <td>Cette fonctionnalité n'est pas disponible sans code supplémentaire.</td>
-       <td><code><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_in">in</a></code></td>
-      </tr>
-     </tbody>
-    </table>
-   </td>
-   <td>Cette fonctionnalité n'est pas disponible sans code supplémentaire.</td>
-  </tr>
-  <tr>
-   <td>Récupération</td>
-   <td>
-    <table>
-     <thead>
-      <tr>
-       <th scope="col">Énumérables</th>
-       <th scope="col">Non-énumérables</th>
-       <th scope="col">Toutes</th>
-      </tr>
-     </thead>
-     <tbody>
-      <tr>
-       <td>
-        <p><code><a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object/keys">Object.keys()</a></code></p>
-
-        <p><code><a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object/getOwnPropertyNames">getOwnPropertyNames()</a></code></p>
-
-        <p><code><a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object/getOwnPropertySymbols">getOwnPropertySymbols()</a></code></p>
-       </td>
-       <td><code><a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object/getOwnPropertyNames">getOwnPropertyNames()</a></code> <code>- <a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object/getOwnPropertySymbols">getOwnPropertySymbols()</a> </code>en utilisant <code><a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object/propertyIsEnumerable">propertyIsEnumerable()</a></code> afin d'exclure les propriétés énumérables</td>
-       <td>
-        <p><code><a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object/getOwnPropertyNames">getOwnPropertyNames()</a></code></p>
-
-        <p><code><a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object/getOwnPropertySymbols">getOwnPropertySymbols()</a></code></p>
-       </td>
-      </tr>
-     </tbody>
-    </table>
-   </td>
-   <td>Cette fonctionnalité n'est pas disponible sans code supplémentaire.</td>
-   <td>Cette fonctionnalité n'est pas disponible sans code supplémentaire.</td>
-  </tr>
-  <tr>
-   <td>Parcours</td>
-   <td>
-    <table>
-     <thead>
-      <tr>
-       <th scope="col">Énumérables</th>
-       <th scope="col">Non-énumérables</th>
-       <th scope="col">Toutes</th>
-      </tr>
-     </thead>
-     <tbody>
-      <tr>
-       <td>
-        <p><code><a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object/keys">Object.keys()</a></code></p>
-
-        <p><code><a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object/getOwnPropertyNames">getOwnPropertyNames()</a></code></p>
-
-        <p><code><a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object/getOwnPropertySymbols">getOwnPropertySymbols()</a></code></p>
-       </td>
-       <td><code><a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object/getOwnPropertyNames">getOwnPropertyNames()</a> - <a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object/getOwnPropertySymbols">getOwnPropertySymbols()</a></code>en utilisant <code><a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object/propertyIsEnumerable">propertyIsEnumerable()</a></code> afin d'exclure les propriétés énumérables</td>
-       <td>
-        <p><code><a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object/getOwnPropertyNames">getOwnPropertyNames()</a></code></p>
-
-        <p><code><a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object/getOwnPropertySymbols">getOwnPropertySymbols()</a></code></p>
-       </td>
-      </tr>
-     </tbody>
-    </table>
-   </td>
-   <td>
-    <table>
-     <thead>
-      <tr>
-       <th scope="col">Énumerables</th>
-       <th scope="col">Non-énumérables</th>
-       <th scope="col">Toutes</th>
-      </tr>
-     </thead>
-     <tbody>
-      <tr>
-       <td><code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/for...in">for..in</a></code></td>
-       <td>Cette fonctionnalité n'est pas disponible sans code supplémentaire.</td>
-       <td>Cette fonctionnalité n'est pas disponible sans code supplémentaire.</td>
-      </tr>
-     </tbody>
-    </table>
-   </td>
-   <td>Cette fonctionnalité n'est pas disponible sans code supplémentaire.</td>
-  </tr>
- </tbody>
+  <caption>
+    Caractère énumérable et rattachement - méthodes natives pour détecter,
+    récupérer et parcourir les propriétés
+  </caption>
+  <tbody>
+    <tr>
+      <th>Fonctionnalité</th>
+      <th>Rattachement direct à l'objet</th>
+      <th>Rattachement direct à l'objet et sur la chaîne de prototypes</th>
+      <th>Uniquement sur la chaîne de prototypes</th>
+    </tr>
+    <tr>
+      <td>Détection</td>
+      <td>
+        <table>
+          <thead>
+            <tr>
+              <th scope="col">Énumérables</th>
+              <th scope="col">Non-énumérables</th>
+              <th scope="col">Toutes</th>
+            </tr>
+          </thead>
+          <tbody>
+            <tr>
+              <td>
+                <p>
+                  <code
+                    ><a
+                      href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object/propertyIsEnumerable"
+                      >propertyIsEnumerable()</a
+                    ></code
+                  >
+                </p>
+                <p>
+                  <code
+                    ><a
+                      href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object/hasOwnProperty"
+                      >hasOwnProperty()</a
+                    ></code
+                  >
+                </p>
+              </td>
+              <td>
+                <code
+                  ><a
+                    href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object/hasOwnProperty"
+                    >hasOwnProperty()</a
+                  >
+                  - </code
+                >en utilisant <code
+                  ><a
+                    href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object/propertyIsEnumerable"
+                    >propertyIsEnumerable()</a
+                  ></code
+                >
+                afin d'exclure les propriétés énumérables
+              </td>
+              <td>
+                <code
+                  ><a
+                    href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object/hasOwnProperty"
+                    >hasOwnProperty()</a
+                  ></code
+                >
+              </td>
+            </tr>
+          </tbody>
+        </table>
+      </td>
+      <td>
+        <table>
+          <thead>
+            <tr>
+              <th scope="col">Énumerables</th>
+              <th scope="col">Non-énumérables</th>
+              <th scope="col">Toutes</th>
+            </tr>
+          </thead>
+          <tbody>
+            <tr>
+              <td>
+                Cette fonctionnalité n'est pas disponible sans code
+                supplémentaire.
+              </td>
+              <td>
+                Cette fonctionnalité n'est pas disponible sans code
+                supplémentaire.
+              </td>
+              <td>
+                <code
+                  ><a
+                    href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_in"
+                    >in</a
+                  ></code
+                >
+              </td>
+            </tr>
+          </tbody>
+        </table>
+      </td>
+      <td>
+        Cette fonctionnalité n'est pas disponible sans code supplémentaire.
+      </td>
+    </tr>
+    <tr>
+      <td>Récupération</td>
+      <td>
+        <table>
+          <thead>
+            <tr>
+              <th scope="col">Énumérables</th>
+              <th scope="col">Non-énumérables</th>
+              <th scope="col">Toutes</th>
+            </tr>
+          </thead>
+          <tbody>
+            <tr>
+              <td>
+                <p>
+                  <code
+                    ><a
+                      href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object/keys"
+                      >Object.keys()</a
+                    ></code
+                  >
+                </p>
+                <p>
+                  <code
+                    ><a
+                      href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object/getOwnPropertyNames"
+                      >getOwnPropertyNames()</a
+                    ></code
+                  >
+                </p>
+                <p>
+                  <code
+                    ><a
+                      href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object/getOwnPropertySymbols"
+                      >getOwnPropertySymbols()</a
+                    ></code
+                  >
+                </p>
+              </td>
+              <td>
+                <code
+                  ><a
+                    href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object/getOwnPropertyNames"
+                    >getOwnPropertyNames()</a
+                  ></code
+                >
+                <code
+                  >- <a
+                    href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object/getOwnPropertySymbols"
+                    >getOwnPropertySymbols()</a
+                  > </code
+                >en utilisant <code
+                  ><a
+                    href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object/propertyIsEnumerable"
+                    >propertyIsEnumerable()</a
+                  ></code
+                >
+                afin d'exclure les propriétés énumérables
+              </td>
+              <td>
+                <p>
+                  <code
+                    ><a
+                      href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object/getOwnPropertyNames"
+                      >getOwnPropertyNames()</a
+                    ></code
+                  >
+                </p>
+                <p>
+                  <code
+                    ><a
+                      href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object/getOwnPropertySymbols"
+                      >getOwnPropertySymbols()</a
+                    ></code
+                  >
+                </p>
+              </td>
+            </tr>
+          </tbody>
+        </table>
+      </td>
+      <td>
+        Cette fonctionnalité n'est pas disponible sans code supplémentaire.
+      </td>
+      <td>
+        Cette fonctionnalité n'est pas disponible sans code supplémentaire.
+      </td>
+    </tr>
+    <tr>
+      <td>Parcours</td>
+      <td>
+        <table>
+          <thead>
+            <tr>
+              <th scope="col">Énumérables</th>
+              <th scope="col">Non-énumérables</th>
+              <th scope="col">Toutes</th>
+            </tr>
+          </thead>
+          <tbody>
+            <tr>
+              <td>
+                <p>
+                  <code
+                    ><a
+                      href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object/keys"
+                      >Object.keys()</a
+                    ></code
+                  >
+                </p>
+                <p>
+                  <code
+                    ><a
+                      href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object/getOwnPropertyNames"
+                      >getOwnPropertyNames()</a
+                    ></code
+                  >
+                </p>
+                <p>
+                  <code
+                    ><a
+                      href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object/getOwnPropertySymbols"
+                      >getOwnPropertySymbols()</a
+                    ></code
+                  >
+                </p>
+              </td>
+              <td>
+                <code
+                  ><a
+                    href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object/getOwnPropertyNames"
+                    >getOwnPropertyNames()</a
+                  >
+                  -
+                  <a
+                    href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object/getOwnPropertySymbols"
+                    >getOwnPropertySymbols()</a
+                  ></code
+                >en utilisant <code
+                  ><a
+                    href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object/propertyIsEnumerable"
+                    >propertyIsEnumerable()</a
+                  ></code
+                >
+                afin d'exclure les propriétés énumérables
+              </td>
+              <td>
+                <p>
+                  <code
+                    ><a
+                      href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object/getOwnPropertyNames"
+                      >getOwnPropertyNames()</a
+                    ></code
+                  >
+                </p>
+                <p>
+                  <code
+                    ><a
+                      href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object/getOwnPropertySymbols"
+                      >getOwnPropertySymbols()</a
+                    ></code
+                  >
+                </p>
+              </td>
+            </tr>
+          </tbody>
+        </table>
+      </td>
+      <td>
+        <table>
+          <thead>
+            <tr>
+              <th scope="col">Énumerables</th>
+              <th scope="col">Non-énumérables</th>
+              <th scope="col">Toutes</th>
+            </tr>
+          </thead>
+          <tbody>
+            <tr>
+              <td>
+                <code
+                  ><a
+                    href="/fr/docs/Web/JavaScript/Reference/Instructions/for...in"
+                    >for..in</a
+                  ></code
+                >
+              </td>
+              <td>
+                Cette fonctionnalité n'est pas disponible sans code
+                supplémentaire.
+              </td>
+              <td>
+                Cette fonctionnalité n'est pas disponible sans code
+                supplémentaire.
+              </td>
+            </tr>
+          </tbody>
+        </table>
+      </td>
+      <td>
+        Cette fonctionnalité n'est pas disponible sans code supplémentaire.
+      </td>
+    </tr>
+  </tbody>
 </table>
 
-<h2 id="Obtenir_les_propriétés_selon_leur_caractère_énumérable_et_selon_leur_rattachement">Obtenir les propriétés selon leur caractère énumérable et selon leur rattachement</h2>
+## Obtenir les propriétés selon leur caractère énumérable et selon leur rattachement
 
-<p>Dans la plupart des cas, ce n'est pas l'algorithme le plus efficace mais il est présenté ici à des fins explicatives.</p>
+Dans la plupart des cas, ce n'est pas l'algorithme le plus efficace mais il est présenté ici à des fins explicatives.
 
-<ul>
- <li>On peut détecter la présence d'une propriété grâce à <code>RecuperateurDePropriete.laMethodeSouhaitee(obj).indexOf(prop) &gt; -1</code></li>
- <li>On peut parcourir les propriétés souhaitées avec <code>RecuperateurDePropriete.laMethodeSouhaitee(obj).forEach(function (value, prop) {});</code> (on peut aussi utiliser <code>filter()</code>, <code>map()</code>, etc.)</li>
-</ul>
+- On peut détecter la présence d'une propriété grâce à `RecuperateurDePropriete.laMethodeSouhaitee(obj).indexOf(prop) > -1`
+- On peut parcourir les propriétés souhaitées avec `RecuperateurDePropriete.laMethodeSouhaitee(obj).forEach(function (value, prop) {});` (on peut aussi utiliser `filter()`, `map()`, etc.)
 
-<pre class="brush: js">var RecuperateurDePropriete = {
+```js
+var RecuperateurDePropriete = {
     getOwnEnumerables: function (obj) {
         return this._getPropertyNames(obj, true, false, this._enumerable);
          // On pourrait également utiliser for..in qu'on filtre avec hasOwnProperty
@@ -211,7 +382,7 @@ original_slug: Web/JavaScript/Caractère_énumérable_des_propriétés_et_rattac
         do {
             if (iterateSelfBool) {
                 Object.getOwnPropertyNames(obj).forEach(function (prop) {
-                    if (props.indexOf(prop) === -1 &amp;&amp; includePropCb(obj, prop)) {
+                    if (props.indexOf(prop) === -1 && includePropCb(obj, prop)) {
                         props.push(prop);
                     }
                 });
@@ -224,102 +395,101 @@ original_slug: Web/JavaScript/Caractère_énumérable_des_propriétés_et_rattac
 
         return props;
     }
-};</pre>
+};
+```
 
-<h2 id="Tableau_de_détection">Tableau de détection</h2>
+## Tableau de détection
 
 <table>
- <thead>
-  <tr>
-   <th scope="row"></th>
-   <th scope="col"><code>in</code></th>
-   <th scope="col"><code>for..in</code></th>
-   <th scope="col"><code>obj.hasOwnProperty()</code></th>
-   <th scope="col"><code>obj.propertyIsEnumerable()</code></th>
-   <th scope="col"><code>Object.keys()</code></th>
-   <th scope="col"><code>Object.getOwnPropertyNames()</code></th>
-   <th scope="col"><code>Object.getOwnPropertyDescriptors()</code></th>
-   <th scope="col"><code>Reflect.ownKeys()</code></th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <th scope="row">Propriétés énumérables</th>
-   <td>true</td>
-   <td>true</td>
-   <td>true</td>
-   <td>true</td>
-   <td>true</td>
-   <td>true</td>
-   <td>true</td>
-   <td>true</td>
-  </tr>
-  <tr>
-   <th scope="row">Propriétés non-énumérables</th>
-   <td>true</td>
-   <td>false</td>
-   <td>true</td>
-   <td>false</td>
-   <td>false</td>
-   <td>true</td>
-   <td>true</td>
-   <td>true</td>
-  </tr>
-  <tr>
-   <th scope="row">Propriétés dont les clés sont des symboles</th>
-   <td>true</td>
-   <td>false</td>
-   <td>true</td>
-   <td>false</td>
-   <td>false</td>
-   <td>false</td>
-   <td>true</td>
-   <td>true</td>
-  </tr>
-  <tr>
-   <th scope="row">Propriétés héritées et énumérables</th>
-   <td>true</td>
-   <td>true</td>
-   <td>false</td>
-   <td>false</td>
-   <td>false</td>
-   <td>false</td>
-   <td>false</td>
-   <td>false</td>
-  </tr>
-  <tr>
-   <th scope="row">Propriétés héritées et non-énumérables</th>
-   <td>true</td>
-   <td>false</td>
-   <td>false</td>
-   <td>false</td>
-   <td>false</td>
-   <td>false</td>
-   <td>false</td>
-   <td>false</td>
-  </tr>
-  <tr>
-   <th scope="row">Propriétés héritées dont les clés sont des symboles</th>
-   <td>true</td>
-   <td>false</td>
-   <td>false</td>
-   <td>false</td>
-   <td>false</td>
-   <td>false</td>
-   <td>false</td>
-   <td>false</td>
-  </tr>
- </tbody>
+  <thead>
+    <tr>
+      <th scope="row"></th>
+      <th scope="col"><code>in</code></th>
+      <th scope="col"><code>for..in</code></th>
+      <th scope="col"><code>obj.hasOwnProperty()</code></th>
+      <th scope="col"><code>obj.propertyIsEnumerable()</code></th>
+      <th scope="col"><code>Object.keys()</code></th>
+      <th scope="col"><code>Object.getOwnPropertyNames()</code></th>
+      <th scope="col"><code>Object.getOwnPropertyDescriptors()</code></th>
+      <th scope="col"><code>Reflect.ownKeys()</code></th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <th scope="row">Propriétés énumérables</th>
+      <td>true</td>
+      <td>true</td>
+      <td>true</td>
+      <td>true</td>
+      <td>true</td>
+      <td>true</td>
+      <td>true</td>
+      <td>true</td>
+    </tr>
+    <tr>
+      <th scope="row">Propriétés non-énumérables</th>
+      <td>true</td>
+      <td>false</td>
+      <td>true</td>
+      <td>false</td>
+      <td>false</td>
+      <td>true</td>
+      <td>true</td>
+      <td>true</td>
+    </tr>
+    <tr>
+      <th scope="row">Propriétés dont les clés sont des symboles</th>
+      <td>true</td>
+      <td>false</td>
+      <td>true</td>
+      <td>false</td>
+      <td>false</td>
+      <td>false</td>
+      <td>true</td>
+      <td>true</td>
+    </tr>
+    <tr>
+      <th scope="row">Propriétés héritées et énumérables</th>
+      <td>true</td>
+      <td>true</td>
+      <td>false</td>
+      <td>false</td>
+      <td>false</td>
+      <td>false</td>
+      <td>false</td>
+      <td>false</td>
+    </tr>
+    <tr>
+      <th scope="row">Propriétés héritées et non-énumérables</th>
+      <td>true</td>
+      <td>false</td>
+      <td>false</td>
+      <td>false</td>
+      <td>false</td>
+      <td>false</td>
+      <td>false</td>
+      <td>false</td>
+    </tr>
+    <tr>
+      <th scope="row">Propriétés héritées dont les clés sont des symboles</th>
+      <td>true</td>
+      <td>false</td>
+      <td>false</td>
+      <td>false</td>
+      <td>false</td>
+      <td>false</td>
+      <td>false</td>
+      <td>false</td>
+    </tr>
+  </tbody>
 </table>
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li><code><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_in">in</a></code></li>
- <li><code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/for...in">for..in</a></code></li>
- <li>{{jsxref("Object.hasOwnProperty()")}}</li>
- <li>{{jsxref("Object.propertyIsEnumerable()")}}</li>
- <li>{{jsxref("Object.getOwnPropertyNames()")}}</li>
- <li>{{jsxref("Object.keys()")}}</li>
- <li>{{jsxref("Object.getOwnPropertyDescriptors()")}}</li>
-</ul>
+- [`in`](/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_in)
+- [`for..in`](/fr/docs/Web/JavaScript/Reference/Instructions/for...in)
+- {{jsxref("Object.hasOwnProperty()")}}
+- {{jsxref("Object.propertyIsEnumerable()")}}
+- {{jsxref("Object.getOwnPropertyNames()")}}
+- {{jsxref("Object.keys()")}}
+- {{jsxref("Object.getOwnPropertyDescriptors()")}}
diff --git a/files/fr/web/javascript/equality_comparisons_and_sameness/index.md b/files/fr/web/javascript/equality_comparisons_and_sameness/index.md
index d61690d512..7e47857033 100644
--- a/files/fr/web/javascript/equality_comparisons_and_sameness/index.md
+++ b/files/fr/web/javascript/equality_comparisons_and_sameness/index.md
@@ -8,54 +8,45 @@ tags:
 translation_of: Web/JavaScript/Equality_comparisons_and_sameness
 original_slug: Web/JavaScript/Les_différents_tests_d_égalité
 ---
-<div>{{jsSidebar("Intermediate")}}</div>
-
-<p>JavaScript fournit trois opérations permettant de comparer des valeurs :</p>
-
-<ul>
- <li>L'égalité stricte (ou identité ou « triple égal ») utilisant <code><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_comparaison#.C3.89galit.C3.A9_stricte_(.3D.3D.3D)">===</a></code>,</li>
- <li>L'égalité faible (ou « double égal ») utilisant <code><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_comparaison#.C3.89galit.C3.A9_simple_(.3D.3D)">==</a></code>,</li>
- <li>{{jsxref("Object.is")}} (ajouté avec ECMAScript 2015).</li>
-</ul>
-
-<p>Ces trois opérations sont associées à quatre algorithmes d'égalité (depuis ES2015) :</p>
-
-<ul>
- <li><a href="#faible">La comparaison d'égalité abstraite (<code>==</code>)</a></li>
- <li><a href="#stricte">La comparaison d'égalité stricte (<code>===</code>)</a>
-  <ul>
-   <li>Utilisée par {{jsxref("Array.indexOf")}} et {{jsxref("Array.lastIndexOf")}} et la sensibilité à la casse</li>
-  </ul>
- </li>
- <li><a href="#SameValueZero"><em>SameValueZero</em> (l'égalité de valeurs nulles)</a>
-  <ul>
-   <li>Utilisée par les constructeurs {{jsxref("TypedArray")}} et {{jsxref("ArrayBuffer")}} et par les opérations associées à {{jsxref("Map")}} et {{jsxref("Set")}}. Depuis ES2016, cet algorithme est également utilisé par {{jsxref("String.includes")}} et {{jsxref("Array.includes")}}</li>
-  </ul>
- </li>
- <li><a href="#sameValue"><em>SameValue</em> (l'égalité de valeurs)</a>
-  <ul>
-   <li>Utilisée partout ailleurs</li>
-  </ul>
- </li>
-</ul>
-
-<p>Selon la comparaison qu'on souhaite effectuer, on choisira une de ces opérations.</p>
-
-<p>En résumé :</p>
-
-<ul>
- <li>L'égalité faible (<code>==</code>) effectuera une conversion des deux éléments à comparer avant d'effectuer la comparaison</li>
- <li>L'égalité stricte (<code>===</code>) effectuera la même comparaison mais sans conversion préalable (elle renverra toujours false si les types des deux valeurs comparées sont différents)</li>
- <li>Enfin <code>Object.is()</code> se comportera comme l'égalité stricte sauf pour les valeurs <code>NaN</code>, <code>-0</code> et <code>+0</code> : pour <code>Object.is()</code>, <code>-0</code> et <code>+0</code> seront différents mais on aura <code>Object.is(NaN, NaN)</code> qui sera <code>true</code>. (Généralement, quand on compare <code>NaN</code> avec <code>NaN</code> en utilisant l'égalité stricte ou l'égalité faible, cela donne <code>false</code> afin de respecter la norme IEEE 754.)</li>
-</ul>
-
-<p>On notera que pour ces trois opérations, la comparaison s'effectue sur les valeurs des éléments qu'on compare, aucune de ces opérations ne permet de comparer la structure des paramètres. Pour des objets non primitifs, <code>x</code> et <code>y</code> qui ont la même structure mais qui sont des objets distincs, chacune des opérations présentées ci-avant sera évaluée à <code>false</code>.</p>
-
-<h2 id="Légalité_stricte_avec">L'égalité stricte avec <code>===</code></h2>
-
-<p>L'égalité stricte compare deux valeurs et teste leur égalité. Aucune des valeurs n'est convertie implicitement en une autre valeur avant que la comparaison soit effectuée. Si les valeurs sont typées différemment, elles sont considérées comme différentes. Si les valeurs sont de même type et ne sont pas des nombres, elles sont considérées égales si elles ont la même valeur. Si les deux valeurs sont des nombres, elles sont égales si elles ont la même valeur et que cette valeur n'est pas NaN ou si l'une vaut +0 et l'autre -0.</p>
-
-<pre class="brush: js">var num = 0;
+{{jsSidebar("Intermediate")}}
+
+JavaScript fournit trois opérations permettant de comparer des valeurs :
+
+- L'égalité stricte (ou identité ou « triple égal ») utilisant [`===`](</fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_comparaison#.C3.89galit.C3.A9_stricte_(.3D.3D.3D)>),
+- L'égalité faible (ou « double égal ») utilisant [`==`](</fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_comparaison#.C3.89galit.C3.A9_simple_(.3D.3D)>),
+- {{jsxref("Object.is")}} (ajouté avec ECMAScript 2015).
+
+Ces trois opérations sont associées à quatre algorithmes d'égalité (depuis ES2015) :
+
+- [La comparaison d'égalité abstraite (`==`)](#faible)
+- [La comparaison d'égalité stricte (`===`)](#stricte)
+
+  - Utilisée par {{jsxref("Array.indexOf")}} et {{jsxref("Array.lastIndexOf")}} et la sensibilité à la casse
+
+- [_SameValueZero_ (l'égalité de valeurs nulles)](#SameValueZero)
+
+  - Utilisée par les constructeurs {{jsxref("TypedArray")}} et {{jsxref("ArrayBuffer")}} et par les opérations associées à {{jsxref("Map")}} et {{jsxref("Set")}}. Depuis ES2016, cet algorithme est également utilisé par {{jsxref("String.includes")}} et {{jsxref("Array.includes")}}
+
+- [_SameValue_ (l'égalité de valeurs)](#sameValue)
+
+  - Utilisée partout ailleurs
+
+Selon la comparaison qu'on souhaite effectuer, on choisira une de ces opérations.
+
+En résumé :
+
+- L'égalité faible (`==`) effectuera une conversion des deux éléments à comparer avant d'effectuer la comparaison
+- L'égalité stricte (`===`) effectuera la même comparaison mais sans conversion préalable (elle renverra toujours false si les types des deux valeurs comparées sont différents)
+- Enfin `Object.is()` se comportera comme l'égalité stricte sauf pour les valeurs `NaN`, `-0` et `+0` : pour `Object.is()`, `-0` et `+0` seront différents mais on aura `Object.is(NaN, NaN)` qui sera `true`. (Généralement, quand on compare `NaN` avec `NaN` en utilisant l'égalité stricte ou l'égalité faible, cela donne `false` afin de respecter la norme IEEE 754.)
+
+On notera que pour ces trois opérations, la comparaison s'effectue sur les valeurs des éléments qu'on compare, aucune de ces opérations ne permet de comparer la structure des paramètres. Pour des objets non primitifs, `x` et `y` qui ont la même structure mais qui sont des objets distincs, chacune des opérations présentées ci-avant sera évaluée à `false`.
+
+## L'égalité stricte avec `===`
+
+L'égalité stricte compare deux valeurs et teste leur égalité. Aucune des valeurs n'est convertie implicitement en une autre valeur avant que la comparaison soit effectuée. Si les valeurs sont typées différemment, elles sont considérées comme différentes. Si les valeurs sont de même type et ne sont pas des nombres, elles sont considérées égales si elles ont la même valeur. Si les deux valeurs sont des nombres, elles sont égales si elles ont la même valeur et que cette valeur n'est pas NaN ou si l'une vaut +0 et l'autre -0.
+
+```js
+var num = 0;
 var obj = new String("0");
 var str = "0";
 
@@ -69,99 +60,100 @@ console.log(obj === str); // false
 console.log(null === undefined); // false
 console.log(obj === null); // false
 console.log(obj === undefined); // false
-</pre>
+```
 
-<p>Ce test d'égalité stricte est presque toujours la meilleure des opérations à considérer pour ces tests. Excepté pour les nombres, la sémantique utilisée est simple : une valeur est uniquement égale à elle-même. En ce qui concerne les nombres, il y a deux cas aux limites à considérer. Le premier cas concerne le nombre zéro positif ou négatif. Cela peut être utile dans la représentation de problèmes mathématiques mais ne constitue pas une différence pour de nombreuses situations : le test d'égalité stricte considère que ce sont les mêmes valeurs. Le second cas concerne la valeur « n'est pas un nombre », <code>NaN</code> (pour « not a number » en anglais) permettant de représenter certaines entités mathématiques : la somme des deux infinis (positif et négatif) par exemple. Le test d'égalité stricte considère que <code>NaN</code> est différent de toutes les valeurs, y compris lui-même. (N.B. : Le seul cas de figure pour lequel on a <code>(x !== x)</code> qui renvoie <code>true</code> est lorsque x vaut <code>NaN</code>.)</p>
+Ce test d'égalité stricte est presque toujours la meilleure des opérations à considérer pour ces tests. Excepté pour les nombres, la sémantique utilisée est simple : une valeur est uniquement égale à elle-même. En ce qui concerne les nombres, il y a deux cas aux limites à considérer. Le premier cas concerne le nombre zéro positif ou négatif. Cela peut être utile dans la représentation de problèmes mathématiques mais ne constitue pas une différence pour de nombreuses situations : le test d'égalité stricte considère que ce sont les mêmes valeurs. Le second cas concerne la valeur « n'est pas un nombre », `NaN` (pour « not a number » en anglais) permettant de représenter certaines entités mathématiques : la somme des deux infinis (positif et négatif) par exemple. Le test d'égalité stricte considère que `NaN` est différent de toutes les valeurs, y compris lui-même. (N.B. : Le seul cas de figure pour lequel on a `(x !== x)` qui renvoie `true` est lorsque x vaut `NaN`.)
 
-<h2 id="Légalité_faible_avec">L'égalité faible avec <code>==</code></h2>
+## L'égalité faible avec `==`
 
-<p>Le test d'égalité faible compare deux valeurs <em>après</em> les avoir converties en valeurs d'un même type. Une fois converties (la conversion peut s'effectuer pour l'une ou les deux valeurs), la comparaison finale est la même que celle effectuée par <code>===</code>. L'égalité faible est <em>symétrique </em>: <code>A == B</code> aura toujours la même signification que <code>B == A</code> pour toute valeur de A et B.</p>
+Le test d'égalité faible compare deux valeurs _après_ les avoir converties en valeurs d'un même type. Une fois converties (la conversion peut s'effectuer pour l'une ou les deux valeurs), la comparaison finale est la même que celle effectuée par `===`. L'égalité faible est _symétrique_ : `A == B` aura toujours la même signification que `B == A` pour toute valeur de A et B.
 
-<p>La comparaison d'égalité est effectuée comme suit pour des opérandes de différents types :</p>
+La comparaison d'égalité est effectuée comme suit pour des opérandes de différents types :
 
 <table class="standard-table">
- <thead>
-  <tr>
-   <th scope="row"></th>
-   <th colspan="7" scope="col">Opérande B</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <th scope="row"></th>
-   <td></td>
-   <td>Undefined</td>
-   <td>Null</td>
-   <td>Number</td>
-   <td>String</td>
-   <td>Boolean</td>
-   <td>Object</td>
-  </tr>
-  <tr>
-   <th colspan="1" rowspan="6" scope="row">Opérande A</th>
-   <td>Undefined</td>
-   <td><code>true</code></td>
-   <td><code>true</code></td>
-   <td><code>false</code></td>
-   <td><code>false</code></td>
-   <td><code>false</code></td>
-   <td><code>false</code></td>
-  </tr>
-  <tr>
-   <td>Null</td>
-   <td><code>true</code></td>
-   <td><code>true</code></td>
-   <td><code>false</code></td>
-   <td><code>false</code></td>
-   <td><code>false</code></td>
-   <td><code>false</code></td>
-  </tr>
-  <tr>
-   <td>Number</td>
-   <td><code>false</code></td>
-   <td><code>false</code></td>
-   <td><code>A === B</code></td>
-   <td><code>A === ToNumber(B)</code></td>
-   <td><code>A === ToNumber(B)</code></td>
-   <td><code>A == ToPrimitive(B)</code></td>
-  </tr>
-  <tr>
-   <td>String</td>
-   <td><code>false</code></td>
-   <td><code>false</code></td>
-   <td><code>ToNumber(A) === B</code></td>
-   <td><code>A === B</code></td>
-   <td><code>ToNumber(A) === ToNumber(B)</code></td>
-   <td><code>A == ToPrimitive(B)</code></td>
-  </tr>
-  <tr>
-   <td>Boolean</td>
-   <td><code>false</code></td>
-   <td><code>false</code></td>
-   <td><code>ToNumber(A) === B</code></td>
-   <td><code>ToNumber(A) === ToNumber(B)</code></td>
-   <td><code>A === B</code></td>
-   <td><code>false</code></td>
-  </tr>
-  <tr>
-   <td>Object</td>
-   <td><code>false</code></td>
-   <td><code>false</code></td>
-   <td><code>ToPrimitive(A) == B</code></td>
-   <td><code>ToPrimitive(A) == B</code></td>
-   <td><code>ToPrimitive(A) == ToNumber(B)</code></td>
-   <td>
-    <p><code>A === B</code></p>
-   </td>
-  </tr>
- </tbody>
+  <thead>
+    <tr>
+      <th scope="row"></th>
+      <th colspan="7" scope="col">Opérande B</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <th scope="row"></th>
+      <td></td>
+      <td>Undefined</td>
+      <td>Null</td>
+      <td>Number</td>
+      <td>String</td>
+      <td>Boolean</td>
+      <td>Object</td>
+    </tr>
+    <tr>
+      <th colspan="1" rowspan="6" scope="row">Opérande A</th>
+      <td>Undefined</td>
+      <td><code>true</code></td>
+      <td><code>true</code></td>
+      <td><code>false</code></td>
+      <td><code>false</code></td>
+      <td><code>false</code></td>
+      <td><code>false</code></td>
+    </tr>
+    <tr>
+      <td>Null</td>
+      <td><code>true</code></td>
+      <td><code>true</code></td>
+      <td><code>false</code></td>
+      <td><code>false</code></td>
+      <td><code>false</code></td>
+      <td><code>false</code></td>
+    </tr>
+    <tr>
+      <td>Number</td>
+      <td><code>false</code></td>
+      <td><code>false</code></td>
+      <td><code>A === B</code></td>
+      <td><code>A === ToNumber(B)</code></td>
+      <td><code>A === ToNumber(B)</code></td>
+      <td><code>A == ToPrimitive(B)</code></td>
+    </tr>
+    <tr>
+      <td>String</td>
+      <td><code>false</code></td>
+      <td><code>false</code></td>
+      <td><code>ToNumber(A) === B</code></td>
+      <td><code>A === B</code></td>
+      <td><code>ToNumber(A) === ToNumber(B)</code></td>
+      <td><code>A == ToPrimitive(B)</code></td>
+    </tr>
+    <tr>
+      <td>Boolean</td>
+      <td><code>false</code></td>
+      <td><code>false</code></td>
+      <td><code>ToNumber(A) === B</code></td>
+      <td><code>ToNumber(A) === ToNumber(B)</code></td>
+      <td><code>A === B</code></td>
+      <td><code>false</code></td>
+    </tr>
+    <tr>
+      <td>Object</td>
+      <td><code>false</code></td>
+      <td><code>false</code></td>
+      <td><code>ToPrimitive(A) == B</code></td>
+      <td><code>ToPrimitive(A) == B</code></td>
+      <td><code>ToPrimitive(A) == ToNumber(B)</code></td>
+      <td>
+        <p><code>A === B</code></p>
+      </td>
+    </tr>
+  </tbody>
 </table>
 
-<p>Dans le tableau ci-dessus, l'expression <code>ToNumber(A)</code> correspond à une tentative de convertir l'argument en un nombre avant la comparaison. Le résultat obtenu est équivalent à <code>+A</code> (l'opérateur unaire +). <code>ToPrimitive(A)</code> correspond à une tentative de convertir l'argument en une valeur primitive grâce à plusieurs méthodes comme <code>A.toString</code> et <code>A.valueOf</code>.</p>
+Dans le tableau ci-dessus, l'expression `ToNumber(A)` correspond à une tentative de convertir l'argument en un nombre avant la comparaison. Le résultat obtenu est équivalent à `+A` (l'opérateur unaire +). `ToPrimitive(A)` correspond à une tentative de convertir l'argument en une valeur primitive grâce à plusieurs méthodes comme `A.toString` et `A.valueOf`.
 
-<p>Selon ECMAScript, au sens de l'égalité faible, tous les objets sont différents de <code>undefined</code> et de <code>null</code>. Cependant, la plupart des navigateurs autorisent, dans certains contextes, unensemble restreint d'objets (notamment l'objet <code>document.all</code>), à agir comme s'ils émulaient la valeur <code>undefined</code>. L'égalité faible est un de ces contextes. Pour tous les autres cas, un objet ne sera jamais approximativement égal à <code>undefined</code> ou à <code>null</code>.</p>
+Selon ECMAScript, au sens de l'égalité faible, tous les objets sont différents de `undefined` et de `null`. Cependant, la plupart des navigateurs autorisent, dans certains contextes, unensemble restreint d'objets (notamment l'objet `document.all`), à agir comme s'ils émulaient la valeur `undefined`. L'égalité faible est un de ces contextes. Pour tous les autres cas, un objet ne sera jamais approximativement égal à `undefined` ou à `null`.
 
-<pre class="brush: js">var num = 0;
+```js
+var num = 0;
 var obj = new String("0");
 var str = "0";
 
@@ -178,284 +170,97 @@ console.log(null == undefined); // true
 // sauf dans certains cas exceptionnels
 console.log(obj == null);
 console.log(obj == undefined);
-</pre>
+```
 
-<p>Certains développeurs considèrent que ce n'est jamais une bonne idée d'utiliser l'égalilté faible. Le résultat d'une comparaison utilisant l'égalité stricte est plus simple à appréhender et à prédire, de plus il n'y a aucune conversion implicite ce qui rend le test plus rapide.</p>
+Certains développeurs considèrent que ce n'est jamais une bonne idée d'utiliser l'égalilté faible. Le résultat d'une comparaison utilisant l'égalité stricte est plus simple à appréhender et à prédire, de plus il n'y a aucune conversion implicite ce qui rend le test plus rapide.
 
-<h2 id="Égalité_de_valeurs">Égalité de valeurs</h2>
+## Égalité de valeurs
 
-<p>L'égalité de valeurs répond à un dernier cas d'utilisation : savoir si deux valeurs sont fonctionnellement identiques pour tout contexte. (Ce cas d'utilisation est un exemple du <a href="https://fr.wikipedia.org/wiki/Principe_de_substitution_de_Liskov">principe de substitution de Liskov</a>). On retrouve ce cas lorsqu'on essaie de changer une propriété immuable :</p>
+L'égalité de valeurs répond à un dernier cas d'utilisation : savoir si deux valeurs sont fonctionnellement identiques pour tout contexte. (Ce cas d'utilisation est un exemple du [principe de substitution de Liskov](https://fr.wikipedia.org/wiki/Principe_de_substitution_de_Liskov)). On retrouve ce cas lorsqu'on essaie de changer une propriété immuable :
 
-<pre class="brush: js">// Ajouter la propriété immuable NEGATIVE_ZERO au constructor Number.
+```js
+// Ajouter la propriété immuable NEGATIVE_ZERO au constructor Number.
 Object.defineProperty(Number, "NEGATIVE_ZERO",
                       { value: -0, writable: false, configurable: false, enumerable: false });
 
 function attemptMutation(v) {
   Object.defineProperty(Number, "NEGATIVE_ZERO", { value: v });
 }
-</pre>
+```
 
-<p><code>Object.defineProperty</code> lancera une exception pour tout changement de la propriété qui serait réellement un changement. Rien ne se passera si aucun changement n'est nécessaire. Ainsi, si <code>v</code> vaut <code>-0</code>, aucun changement n'est nécessaire et il n'y aura pas d'erreur. Mais si <code>v</code> vaut <code>+0</code>, <code>Number.NEGATIVE_ZERO</code> n'aurait plus la même valeur immuable. De façon interne à l'implémentation, la nouvelle valeur est comparée avec la valeur courante en utilisant une égalité de valeurs.</p>
+`Object.defineProperty` lancera une exception pour tout changement de la propriété qui serait réellement un changement. Rien ne se passera si aucun changement n'est nécessaire. Ainsi, si `v` vaut `-0`, aucun changement n'est nécessaire et il n'y aura pas d'erreur. Mais si `v` vaut `+0`, `Number.NEGATIVE_ZERO` n'aurait plus la même valeur immuable. De façon interne à l'implémentation, la nouvelle valeur est comparée avec la valeur courante en utilisant une égalité de valeurs.
 
-<p>L'égalité de valeurs peut être testée grâce à la méthode {{jsxref("Object.is")}}.</p>
+L'égalité de valeurs peut être testée grâce à la méthode {{jsxref("Object.is")}}.
 
-<h2 id="Égalité_de_valeurs_nulles">Égalité de valeurs nulles</h2>
+## Égalité de valeurs nulles
 
-<p>On utilise la même égalité que l'égalité de valeur et on considère que <code>+0</code> et <code>-0</code> sont égaux.</p>
+On utilise la même égalité que l'égalité de valeur et on considère que `+0` et `-0` sont égaux.
 
-<h2 id="Égalité_abstraite_égalité_stricte_et_valeurs_identiques_la_spécification">Égalité abstraite, égalité stricte et valeurs identiques : la spécification</h2>
+## Égalité abstraite, égalité stricte et valeurs identiques : la spécification
 
-<p>Selon ES5, la comparaison effectuée par <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_comparaison#.C3.89galit.C3.A9_simple_(.3D.3D)"><code>==</code></a> est décrite dans <a href="https://ecma-international.org/ecma-262/5.1/#sec-11.9.3">la section 11.9.3 sur l'algorithme d'égalité abstraite (<em>Abstract Equality Algorithm</em>)</a>. La comparaison donnée par <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_comparaison#.C3.89galit.C3.A9_stricte_(.3D.3D.3D)"><code>===</code></a> est décrite dans <a href="https://ecma-international.org/ecma-262/5.1/#sec-11.9.6">la section 11.9.6 sur l'algorithme d'égalité stricte (<em>Strict Equality Algorithm</em>)</a>. Ces documents sont en anglais mais sont tout à fait abordables, ne pas hésiter à les consulter (conseil : d'abord commencer par l'algorithme d'égalité stricte). ES5 décrit également, dans <a href="https://ecma-international.org/ecma-262/5.1/#sec-9.12">la section 9.12 sur l'algorithme SameValue</a>, l'opération utilisée en interne par le moteur JavaScript. Cet algorithme est principalement basé sur l'algorithme d'égalité stricte : 11.9.6.4 et 9.12.4 diffèrent en ce qui concerne les nombres. ES6 (ECMAScript 2015) permet d'utiliser cet algorithme grâce à la méthode {{jsxref("Object.is")}}.</p>
+Selon ES5, la comparaison effectuée par [`==`](</fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_comparaison#.C3.89galit.C3.A9_simple_(.3D.3D)>) est décrite dans [la section 11.9.3 sur l'algorithme d'égalité abstraite (_Abstract Equality Algorithm_)](https://ecma-international.org/ecma-262/5.1/#sec-11.9.3). La comparaison donnée par [`===`](</fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_comparaison#.C3.89galit.C3.A9_stricte_(.3D.3D.3D)>) est décrite dans [la section 11.9.6 sur l'algorithme d'égalité stricte (_Strict Equality Algorithm_)](https://ecma-international.org/ecma-262/5.1/#sec-11.9.6). Ces documents sont en anglais mais sont tout à fait abordables, ne pas hésiter à les consulter (conseil : d'abord commencer par l'algorithme d'égalité stricte). ES5 décrit également, dans [la section 9.12 sur l'algorithme SameValue](https://ecma-international.org/ecma-262/5.1/#sec-9.12), l'opération utilisée en interne par le moteur JavaScript. Cet algorithme est principalement basé sur l'algorithme d'égalité stricte : 11.9.6.4 et 9.12.4 diffèrent en ce qui concerne les nombres. ES6 (ECMAScript 2015) permet d'utiliser cet algorithme grâce à la méthode {{jsxref("Object.is")}}.
 
-<p>Dans ces documents, on peut voir que l'algorithme d'égalité stricte est un sous-ensemble de l'algorithme d'égalité abstraite (exception faite de la vérification du type) car 11.9.6.2–7 correspond exactement à 11.9.3.1.a–f.</p>
+Dans ces documents, on peut voir que l'algorithme d'égalité stricte est un sous-ensemble de l'algorithme d'égalité abstraite (exception faite de la vérification du type) car 11.9.6.2–7 correspond exactement à 11.9.3.1.a–f.
 
-<h2 id="Un_modèle_pour_mieux_comprendre">Un modèle pour mieux comprendre ?</h2>
+## Un modèle pour mieux comprendre ?
 
-<p>Avant ES6 (ECMAScript 2015), il était courant de dire que l'égalité stricte avec le triple égal était une version « améliorée » de l'égalité faible (double égal) et vice versa. En effet, l'égalité faible ajoute une étape de conversion des types qui n'est pas fournie par l'égalité stricte (ce qui permet d'avoir <code>6 == "6"</code>). On peut aussi dire que l'égalité stricte est une version améliorée de l'égalité simple car elle ajoute une fonctionnalité de vérification des types. Selon votre approche et votre problème, une de ces égalités se prêtera mieux à la résolution.</p>
+Avant ES6 (ECMAScript 2015), il était courant de dire que l'égalité stricte avec le triple égal était une version « améliorée » de l'égalité faible (double égal) et vice versa. En effet, l'égalité faible ajoute une étape de conversion des types qui n'est pas fournie par l'égalité stricte (ce qui permet d'avoir `6 == "6"`). On peut aussi dire que l'égalité stricte est une version améliorée de l'égalité simple car elle ajoute une fonctionnalité de vérification des types. Selon votre approche et votre problème, une de ces égalités se prêtera mieux à la résolution.
 
-<p>Cependant, ce « modèle de pensées » ne peut pas être étendu avec l'arrivée d'{{jsxref("Object.is")}} avec ES6 (ECMAScript 2015). En effet <code>Object.is()</code> n'est pas plus « faible » que l'égalité faible ou plus « stricte » que l'égalité stricte et il n'est pas non plus quelque part entre les deux. Dans le tableau de comparaison ci-après, on voit que la différence provient avant tout de la façon dont {{jsxref("Object.is")}} gère {{jsxref("NaN")}}. On note ici que si <code>Object.is(NaN, NaN)</code> valait <code>false</code>, on pourrait dire qu'<code>Object.is()</code> est plus stricte que == ou === car elle distingue <code>-0</code> et <code>+0</code>. Cependant, ce n'est pas le cas et on a bien <code>Object.is(NaN,NaN)</code> qui vaut <code>true</code>. C'est pour cette raison qu'il faut considérer {{jsxref("Object.is")}} selon ses caractéristiques spécifiques plutôt que comme une version plus faible ou plus stricte des autres opérateurs d'égalité.</p>
+Cependant, ce « modèle de pensées » ne peut pas être étendu avec l'arrivée d'{{jsxref("Object.is")}} avec ES6 (ECMAScript 2015). En effet `Object.is()` n'est pas plus « faible » que l'égalité faible ou plus « stricte » que l'égalité stricte et il n'est pas non plus quelque part entre les deux. Dans le tableau de comparaison ci-après, on voit que la différence provient avant tout de la façon dont {{jsxref("Object.is")}} gère {{jsxref("NaN")}}. On note ici que si `Object.is(NaN, NaN)` valait `false`, on pourrait dire qu'`Object.is()` est plus stricte que == ou === car elle distingue `-0` et `+0`. Cependant, ce n'est pas le cas et on a bien `Object.is(NaN,NaN)` qui vaut `true`. C'est pour cette raison qu'il faut considérer {{jsxref("Object.is")}} selon ses caractéristiques spécifiques plutôt que comme une version plus faible ou plus stricte des autres opérateurs d'égalité.
 
-<table class="standard-table">
- <caption>Comparaisons d'égalité</caption>
- <thead>
-  <tr>
-   <th scope="col">x</th>
-   <th scope="col">y</th>
-   <th scope="col"><code>==</code></th>
-   <th scope="col"><code>===</code></th>
-   <th scope="col"><code>Object.is</code></th>
-   <th scope="col"><code>SameValueZero</code></th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td><code>undefined</code></td>
-   <td><code>undefined</code></td>
-   <td><code>true</code></td>
-   <td><code>true</code></td>
-   <td><code>true</code></td>
-   <td><code>true</code></td>
-  </tr>
-  <tr>
-   <td><code>null</code></td>
-   <td><code>null</code></td>
-   <td><code>true</code></td>
-   <td><code>true</code></td>
-   <td><code>true</code></td>
-   <td><code>true</code></td>
-  </tr>
-  <tr>
-   <td><code>true</code></td>
-   <td><code>true</code></td>
-   <td><code>true</code></td>
-   <td><code>true</code></td>
-   <td><code>true</code></td>
-   <td><code>true</code></td>
-  </tr>
-  <tr>
-   <td><code>false</code></td>
-   <td><code>false</code></td>
-   <td><code>true</code></td>
-   <td><code>true</code></td>
-   <td><code>true</code></td>
-   <td><code>true</code></td>
-  </tr>
-  <tr>
-   <td><code>'toto'</code></td>
-   <td><code>'toto'</code></td>
-   <td><code>true</code></td>
-   <td><code>true</code></td>
-   <td><code>true</code></td>
-   <td><code>true</code></td>
-  </tr>
-  <tr>
-   <td><code>0</code></td>
-   <td><code>0</code></td>
-   <td><code>true</code></td>
-   <td><code>true</code></td>
-   <td><code>true</code></td>
-   <td><code>true</code></td>
-  </tr>
-  <tr>
-   <td><code>+0</code></td>
-   <td><code>-0</code></td>
-   <td><code>true</code></td>
-   <td><code>true</code></td>
-   <td><code>false</code></td>
-   <td><code>true</code></td>
-  </tr>
-  <tr>
-   <td><code>+0</code></td>
-   <td><code>0</code></td>
-   <td><code>true</code></td>
-   <td><code>true</code></td>
-   <td><code>true</code></td>
-   <td><code>true</code></td>
-  </tr>
-  <tr>
-   <td><code>-0</code></td>
-   <td><code>0</code></td>
-   <td><code>true</code></td>
-   <td><code>true</code></td>
-   <td><code>false</code></td>
-   <td><code>true</code></td>
-  </tr>
-  <tr>
-   <td><code>0</code></td>
-   <td><code>false</code></td>
-   <td><code>true</code></td>
-   <td><code>false</code></td>
-   <td><code>false</code></td>
-   <td><code>false</code></td>
-  </tr>
-  <tr>
-   <td><code>""</code></td>
-   <td><code>false</code></td>
-   <td><code>true</code></td>
-   <td><code>false</code></td>
-   <td><code>false</code></td>
-   <td><code>false</code></td>
-  </tr>
-  <tr>
-   <td><code>""</code></td>
-   <td><code>0</code></td>
-   <td><code>true</code></td>
-   <td><code>false</code></td>
-   <td><code>false</code></td>
-   <td><code>false</code></td>
-  </tr>
-  <tr>
-   <td><code>'0'</code></td>
-   <td><code>0</code></td>
-   <td><code>true</code></td>
-   <td><code>false</code></td>
-   <td><code>false</code></td>
-   <td><code>false</code></td>
-  </tr>
-  <tr>
-   <td><code>'17'</code></td>
-   <td><code>17</code></td>
-   <td><code>true</code></td>
-   <td><code>false</code></td>
-   <td><code>false</code></td>
-   <td><code>false</code></td>
-  </tr>
-  <tr>
-   <td><code>[1, 2]</code></td>
-   <td><code>'1,2'</code></td>
-   <td><code>true</code></td>
-   <td><code>false</code></td>
-   <td><code>false</code></td>
-   <td><code>false</code></td>
-  </tr>
-  <tr>
-   <td><code>new String('toto')</code></td>
-   <td><code>'toto'</code></td>
-   <td><code>true</code></td>
-   <td><code>false</code></td>
-   <td><code>false</code></td>
-   <td><code>false</code></td>
-  </tr>
-  <tr>
-   <td><code>null</code></td>
-   <td><code>undefined</code></td>
-   <td><code>true</code></td>
-   <td><code>false</code></td>
-   <td><code>false</code></td>
-   <td><code>false</code></td>
-  </tr>
-  <tr>
-   <td><code>null</code></td>
-   <td><code>false</code></td>
-   <td><code>false</code></td>
-   <td><code>false</code></td>
-   <td><code>false</code></td>
-   <td><code>false</code></td>
-  </tr>
-  <tr>
-   <td><code>undefined</code></td>
-   <td><code>false</code></td>
-   <td><code>false</code></td>
-   <td><code>false</code></td>
-   <td><code>false</code></td>
-   <td><code>false</code></td>
-  </tr>
-  <tr>
-   <td><code>{ toto: 'truc' }</code></td>
-   <td><code>{ toto: 'truc' }</code></td>
-   <td><code>false</code></td>
-   <td><code>false</code></td>
-   <td><code>false</code></td>
-   <td><code>false</code></td>
-  </tr>
-  <tr>
-   <td><code>new String('toto')</code></td>
-   <td><code>new String('toto')</code></td>
-   <td><code>false</code></td>
-   <td><code>false</code></td>
-   <td><code>false</code></td>
-   <td><code>false</code></td>
-  </tr>
-  <tr>
-   <td><code>0</code></td>
-   <td><code>null</code></td>
-   <td><code>false</code></td>
-   <td><code>false</code></td>
-   <td><code>false</code></td>
-   <td><code>false</code></td>
-  </tr>
-  <tr>
-   <td><code>0</code></td>
-   <td><code>NaN</code></td>
-   <td><code>false</code></td>
-   <td><code>false</code></td>
-   <td><code>false</code></td>
-   <td><code>false</code></td>
-  </tr>
-  <tr>
-   <td><code>'toto'</code></td>
-   <td><code>NaN</code></td>
-   <td><code>false</code></td>
-   <td><code>false</code></td>
-   <td><code>false</code></td>
-   <td><code>false</code></td>
-  </tr>
-  <tr>
-   <td><code>NaN</code></td>
-   <td><code>NaN</code></td>
-   <td><code>false</code></td>
-   <td><code>false</code></td>
-   <td><code>true</code></td>
-   <td><code>true</code></td>
-  </tr>
- </tbody>
-</table>
+| x                    | y                    | `==`    | `===`   | `Object.is` | `SameValueZero` |
+| -------------------- | -------------------- | ------- | ------- | ----------- | --------------- |
+| `undefined`          | `undefined`          | `true`  | `true`  | `true`      | `true`          |
+| `null`               | `null`               | `true`  | `true`  | `true`      | `true`          |
+| `true`               | `true`               | `true`  | `true`  | `true`      | `true`          |
+| `false`              | `false`              | `true`  | `true`  | `true`      | `true`          |
+| `'toto'`             | `'toto'`             | `true`  | `true`  | `true`      | `true`          |
+| `0`                  | `0`                  | `true`  | `true`  | `true`      | `true`          |
+| `+0`                 | `-0`                 | `true`  | `true`  | `false`     | `true`          |
+| `+0`                 | `0`                  | `true`  | `true`  | `true`      | `true`          |
+| `-0`                 | `0`                  | `true`  | `true`  | `false`     | `true`          |
+| `0`                  | `false`              | `true`  | `false` | `false`     | `false`         |
+| `""`                 | `false`              | `true`  | `false` | `false`     | `false`         |
+| `""`                 | `0`                  | `true`  | `false` | `false`     | `false`         |
+| `'0'`                | `0`                  | `true`  | `false` | `false`     | `false`         |
+| `'17'`               | `17`                 | `true`  | `false` | `false`     | `false`         |
+| `[1, 2]`             | `'1,2'`              | `true`  | `false` | `false`     | `false`         |
+| `new String('toto')` | `'toto'`             | `true`  | `false` | `false`     | `false`         |
+| `null`               | `undefined`          | `true`  | `false` | `false`     | `false`         |
+| `null`               | `false`              | `false` | `false` | `false`     | `false`         |
+| `undefined`          | `false`              | `false` | `false` | `false`     | `false`         |
+| `{ toto: 'truc' }`   | `{ toto: 'truc' }`   | `false` | `false` | `false`     | `false`         |
+| `new String('toto')` | `new String('toto')` | `false` | `false` | `false`     | `false`         |
+| `0`                  | `null`               | `false` | `false` | `false`     | `false`         |
+| `0`                  | `NaN`                | `false` | `false` | `false`     | `false`         |
+| `'toto'`             | `NaN`                | `false` | `false` | `false`     | `false`         |
+| `NaN`                | `NaN`                | `false` | `false` | `true`      | `true`          |
+
+## Quand utiliser {{jsxref("Object.is")}} et quand utiliser l'égalité stricte
+
+En plus de la façon dont {{jsxref("Object.is")}} traite `NaN`, la spécificité d'`Object.is()` réside dans sa façon de traiter les valeurs proches de zéro. Dans des cas d'utilisation où on a besoin d'effectuer de la méta-programmation, notamment pour imiter certaines caractéristiques de {{jsxref("Object.defineProperty")}}. Si le scénario d'utilisation ne nécessite pas ce comportement, il est conseillé d'utiliser [`===`](</fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_comparaison#.C3.89galit.C3.A9_stricte_(.3D.3D.3D)>). Même si on souhaite pouvoir comparer `NaN` avec lui-même et que ce test vaille `true`, il sera plus simple d'utiliser la méthode {{jsxref("isNaN")}} disponible avec les versions antérieures d'ECMAScript. En effet, cela évite d'avoir à traiter des cas plus complexes où il faudrait gérer les signes des zéros dans les différentes comparaisons.
+
+Voici une liste (non exhaustive) d'opérateurs et de méthodes natives qui peuvent entraîner l'apparition des valeurs `-0` et `+0` dans le code :
+
+- [`-` (négation unaire)](/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_arithmétiques#Négation_unaire)
 
-<h2 id="Quand_utiliser_jsxrefObject.is_et_quand_utiliser_légalité_stricte">Quand utiliser {{jsxref("Object.is")}} et quand utiliser l'égalité stricte</h2>
+  - : Si on prend l'opposé de `0`, on aura, bien entendu,`-0`. Cependant, avec les expressions, cela peut faire que la valeur `-0` se glisse dans les variables sans qu'on s'en rende compte. Par exemple :
 
-<p>En plus de la façon dont {{jsxref("Object.is")}} traite <code>NaN</code>, la spécificité d'<code>Object.is()</code> réside dans sa façon de traiter les valeurs proches de zéro. Dans des cas d'utilisation où on a besoin d'effectuer de la méta-programmation, notamment pour imiter certaines caractéristiques de {{jsxref("Object.defineProperty")}}. Si le scénario d'utilisation ne nécessite pas ce comportement, il est conseillé d'utiliser <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_comparaison#.C3.89galit.C3.A9_stricte_(.3D.3D.3D)"><code>===</code></a>. Même si on souhaite pouvoir comparer <code>NaN</code> avec lui-même et que ce test vaille <code>true</code>, il sera plus simple d'utiliser la méthode {{jsxref("isNaN")}} disponible avec les versions antérieures d'ECMAScript. En effet, cela évite d'avoir à traiter des cas plus complexes où il faudrait gérer les signes des zéros dans les différentes comparaisons.</p>
+    ```js
+        let forceArrêt = obj.masse * -obj.vitesse
+        ```
 
-<p>Voici une liste (non exhaustive) d'opérateurs et de méthodes natives qui peuvent entraîner l'apparition des valeurs <code>-0</code> et <code>+0</code> dans le code :</p>
+    Si `obj.vitesse` vaut `0` (ou est évalué à `0`), un `-0` sera introduit, ce qui fera que `forceArrêt` pourra être négative.
 
-<dl>
- <dt><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_arithmétiques#Négation_unaire"><code>-</code> (négation unaire)</a></dt>
- <dd>
- <p>Si on prend l'opposé de <code>0</code>, on aura, bien entendu,<code>-0</code>. Cependant, avec les expressions, cela peut faire que la valeur <code>-0</code> se glisse dans les variables sans qu'on s'en rende compte. Par exemple :</p>
- <pre class="brush:js">let forceArrêt = obj.masse * -obj.vitesse</pre>
- <p>Si <code>obj.vitesse</code> vaut <code>0</code> (ou est évalué à <code>0</code>), un <code>-0</code> sera introduit, ce qui fera que <code>forceArrêt</code> pourra être négative.</p>
- </dd>
- <dt>{{jsxref("Math.atan2")}}, {{jsxref("Math.ceil")}}, {{jsxref("Math.pow")}}, {{jsxref("Math.round")}}</dt>
- <dd>Ces méthodes peuvent introduire <code>-0</code> dans une expression lors de leur évaluation, même si <code>-0</code> ne faisait pas partie des paramètres. Par exemple, si on utilise <code>Math.pow()</code> pour élever {{jsxref("Infinity", "-Infinity")}} à une puissance négative, on obtiendra <code>-0</code> pour une puissance impaire. Pour plus de détails, voir la documentation de chaque méthode.</dd>
- <dt>{{jsxref("Math.floor")}}, {{jsxref("Math.max")}}, {{jsxref("Math.min")}}, {{jsxref("Math.sin")}}, {{jsxref("Math.sqrt")}}, {{jsxref("Math.tan")}}</dt>
- <dd>Ces méthodes peuvent renvoyer <code>-0</code> dans certains cas où <code>-0</code> est passé en paramètre. Par exemple, <code>Math.min(-0, +0)</code> fournira <code>-0</code>. Pour plus de détails, voir la documentation de chaque méthode.</dd>
- <dt><code><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_binaires#.7E_.28NON_binaire.29">~</a></code>, <code><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_binaires#.3C.3C_.28d.C3.A9calage_.C3.A0_gauche.29">&lt;&lt;</a></code>, <code><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_binaires#.3E.3E_.28d.C3.A9calage_.C3.A0_droite_avec_propagation_du_signe.29">&gt;&gt;</a></code></dt>
- <dd>Chacun de ces opérateurs utilise l'algorithme ToInt32 interne au moteur JavaScript. Étant donné qu'il n'y a qu'une seule représentation pour 0 sur les entiers exprimés avec le type interne sur 32 bits, <code>-0</code> ne sera pas invariant pour deux opérations symétriques : <code>Object.is(~~(-0), -0)</code> et <code>Object.is(-0 &lt;&lt; 2 &gt;&gt; 2, -0)</code> renverront tous les deux <code>false</code>.</dd>
-</dl>
+- {{jsxref("Math.atan2")}}, {{jsxref("Math.ceil")}}, {{jsxref("Math.pow")}}, {{jsxref("Math.round")}}
+  - : Ces méthodes peuvent introduire `-0` dans une expression lors de leur évaluation, même si `-0` ne faisait pas partie des paramètres. Par exemple, si on utilise `Math.pow()` pour élever {{jsxref("Infinity", "-Infinity")}} à une puissance négative, on obtiendra `-0` pour une puissance impaire. Pour plus de détails, voir la documentation de chaque méthode.
+- {{jsxref("Math.floor")}}, {{jsxref("Math.max")}}, {{jsxref("Math.min")}}, {{jsxref("Math.sin")}}, {{jsxref("Math.sqrt")}}, {{jsxref("Math.tan")}}
+  - : Ces méthodes peuvent renvoyer `-0` dans certains cas où `-0` est passé en paramètre. Par exemple, `Math.min(-0, +0)` fournira `-0`. Pour plus de détails, voir la documentation de chaque méthode.
+- [`~`](/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_binaires#.7E_.28NON_binaire.29), [`<<`](/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_binaires#.3C.3C_.28d.C3.A9calage_.C3.A0_gauche.29), [`>>`](/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_binaires#.3E.3E_.28d.C3.A9calage_.C3.A0_droite_avec_propagation_du_signe.29)
+  - : Chacun de ces opérateurs utilise l'algorithme ToInt32 interne au moteur JavaScript. Étant donné qu'il n'y a qu'une seule représentation pour 0 sur les entiers exprimés avec le type interne sur 32 bits, `-0` ne sera pas invariant pour deux opérations symétriques : `Object.is(~~(-0), -0)` et `Object.is(-0 << 2 >> 2, -0)` renverront tous les deux `false`.
 
-<p>Si on utilise {{jsxref("Object.is")}} et qu'on ne souhaite pas gérer les cas aux limites autour de zéro, cela peut avoir des effet indésirés. En revanche, si on souhaite effectivement comparer <code>-0</code> et <code>+0</code>, c'est la méthode à adopter.</p>
+Si on utilise {{jsxref("Object.is")}} et qu'on ne souhaite pas gérer les cas aux limites autour de zéro, cela peut avoir des effet indésirés. En revanche, si on souhaite effectivement comparer `-0` et `+0`, c'est la méthode à adopter.
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li><a href="https://dorey.github.io/JavaScript-Equality-Table/">Tableau des comparaisons en JavaScript</a></li>
-</ul>
+- [Tableau des comparaisons en JavaScript](https://dorey.github.io/JavaScript-Equality-Table/)
diff --git a/files/fr/web/javascript/eventloop/index.md b/files/fr/web/javascript/eventloop/index.md
index d349d9d056..967b2e0ea8 100644
--- a/files/fr/web/javascript/eventloop/index.md
+++ b/files/fr/web/javascript/eventloop/index.md
@@ -8,23 +8,24 @@ tags:
 translation_of: Web/JavaScript/EventLoop
 original_slug: Web/JavaScript/Concurrence_et_boucle_des_événements
 ---
-<div>{{jsSidebar("Advanced")}}</div>
+{{jsSidebar("Advanced")}}
 
-<p>JavaScript gère la concurrence grâce à une « boucle d'événements ». Ce modèle est différent de la gestion faite par des langages comme C ou Java.</p>
+JavaScript gère la concurrence grâce à une « boucle d'événements ». Ce modèle est différent de la gestion faite par des langages comme C ou Java.
 
-<h2 id="Notions_liées_à_lexécution">Notions liées à l'exécution</h2>
+## Notions liées à l'exécution
 
-<p>Les sections qui suivent décrivent un modèle théorique. En réalité, les moteurs JavaScript implémentent et optimisent fortement la sémantique décrite ici.</p>
+Les sections qui suivent décrivent un modèle théorique. En réalité, les moteurs JavaScript implémentent et optimisent fortement la sémantique décrite ici.
 
-<h3 id="Représentation_visuelle">Représentation visuelle</h3>
+### Représentation visuelle
 
-<p><img alt="Stack, heap, queue" src="the_javascript_runtime_environment_example.svg"></p>
+![Stack, heap, queue](the_javascript_runtime_environment_example.svg)
 
-<h3 id="La_pile_dappels_stack">La pile d'appels (<em>stack</em>)</h3>
+### La pile d'appels (_stack_)
 
-<p>Les appels de fonction forment une pile de cadre (<em>frames</em>).</p>
+Les appels de fonction forment une pile de cadre (_frames_).
 
-<pre class="brush: js notranslate">function f(b){
+```js
+function f(b){
   var a = 12;
   return a + b + 35;
 }
@@ -35,47 +36,48 @@ function g(x){
 }
 
 console.log(g(21)); // affichera 131
-</pre>
+```
 
-<p>Lors de l'appel à <code>g</code>, on crée un premier cadre contenant les arguments de <code>g</code> ainsi que les variables locales. Quand <code>g</code> appelle <code>f</code>, un deuxième cadre est créé et placé sur le premier et contient les arguments de <code>f</code> ainsi que les variables locales. Lorsque <code>f</code> a fini et renvoyé son résultat, le cadre correspondant (celui qui est sur le dessus) est retiré de la pile (il reste donc le cadre lié à l'appel de <code>g</code>). Quand <code>g</code> a fini grâce aux informations transmises, la pile devient vide.</p>
+Lors de l'appel à `g`, on crée un premier cadre contenant les arguments de `g` ainsi que les variables locales. Quand `g` appelle `f`, un deuxième cadre est créé et placé sur le premier et contient les arguments de `f` ainsi que les variables locales. Lorsque `f` a fini et renvoyé son résultat, le cadre correspondant (celui qui est sur le dessus) est retiré de la pile (il reste donc le cadre lié à l'appel de `g`). Quand `g` a fini grâce aux informations transmises, la pile devient vide.
 
-<h3 id="Le_tas_heap">Le tas (<em>heap</em>)</h3>
+### Le tas (_heap_)
 
-<p>Les objets sont alloués en mémoire dans un tas qui désigne une zone de la mémoire sans structure particulière.</p>
+Les objets sont alloués en mémoire dans un tas qui désigne une zone de la mémoire sans structure particulière.
 
-<h3 id="La_file_queue">La file (<em>queue</em>)</h3>
+### La file (_queue_)
 
-<p>Un environnement d'exécution JavaScript (<em>runtime</em>) contient une queue de messages à traiter. Chaque message est associé à une fonction. Lorsque la pile est vide ou a suffisamment d'espace, on retire un message de la queue et on le traite. Le traitement consiste à appeler la fonction associée au message (et donc à créer le cadre dans la pile d'appel). Le traitement d'un message est fini lorsque la pile d'appels redevient vide.</p>
+Un environnement d'exécution JavaScript (_runtime_) contient une queue de messages à traiter. Chaque message est associé à une fonction. Lorsque la pile est vide ou a suffisamment d'espace, on retire un message de la queue et on le traite. Le traitement consiste à appeler la fonction associée au message (et donc à créer le cadre dans la pile d'appel). Le traitement d'un message est fini lorsque la pile d'appels redevient vide.
 
-<h2 id="La_boucle_dévénements">La boucle d'événements</h2>
+## La boucle d'événements
 
-<p>La boucle d'événement tire principalement son nom de son implémentation. Celle-ci ressemble à :</p>
+La boucle d'événement tire principalement son nom de son implémentation. Celle-ci ressemble à :
 
-<pre class="brush: js notranslate">while (queue.attendreMessage()){
+```js
+while (queue.attendreMessage()){
   queue.traiterProchainMessage();
-}</pre>
+}
+```
 
-<p><code>queue.attendreMessage</code> est un fonction synchrone qui attend un message même s'il n'y en a aucun à traiter.</p>
+`queue.attendreMessage` est un fonction synchrone qui attend un message même s'il n'y en a aucun à traiter.
 
-<h3 id="Traiter_de_A_à_Z_run-to-completion">Traiter de A à Z (<em>run-to-completion</em>)</h3>
+### Traiter de A à Z (_run-to-completion_)
 
-<p>Chaque message sera traité complètement avant tout autre message. Cela permet de savoir que, lorsqu'une fonction s'exécute, on ne peut pas observer l'exécution d'un autre code qui prendrait le pas (modifiant les données de la fonction par exemple). Le modèle de <em>thread</em> utilisé par le langage C, par exemple, que la fonction puisse être interrompue à tout moment pour permettre à un autre <em>thread</em> d'exécuter un autre code.</p>
+Chaque message sera traité complètement avant tout autre message. Cela permet de savoir que, lorsqu'une fonction s'exécute, on ne peut pas observer l'exécution d'un autre code qui prendrait le pas (modifiant les données de la fonction par exemple). Le modèle de _thread_ utilisé par le langage C, par exemple, que la fonction puisse être interrompue à tout moment pour permettre à un autre _thread_ d'exécuter un autre code.
 
-<p>Ce modèle possède un désavantage : lorsqu'un message prend trop de temps à être traité, l'application ne peut plus gérer les interactions utilisateur comme les clics ou le défilement. Généralement, le navigateur affiche alors « Le script met trop de temps à répondre ». Une bonne pratique consiste à rendre le traîtement de message le plus court possible et à découper le message problématique en plusieurs messages.</p>
+Ce modèle possède un désavantage : lorsqu'un message prend trop de temps à être traité, l'application ne peut plus gérer les interactions utilisateur comme les clics ou le défilement. Généralement, le navigateur affiche alors « Le script met trop de temps à répondre ». Une bonne pratique consiste à rendre le traîtement de message le plus court possible et à découper le message problématique en plusieurs messages.
 
-<h3 id="Lajout_de_messages">L'ajout de messages</h3>
+### L'ajout de messages
 
-<p>Dans les navigateurs web, des messages sont ajoutés à chaque fois qu'un événement se produit et qu'un gestionnaire d'événements y est attaché. S'il n'y a pas d'écouteur (<em>listener</em>) pour intercepter l'événement, il est perdu. Ainsi, si on clique un élément qui possède un gestionnaire d'événements pour les clics, un message sera ajouté (il en va de même avec les autres événements).</p>
+Dans les navigateurs web, des messages sont ajoutés à chaque fois qu'un événement se produit et qu'un gestionnaire d'événements y est attaché. S'il n'y a pas d'écouteur (_listener_) pour intercepter l'événement, il est perdu. Ainsi, si on clique un élément qui possède un gestionnaire d'événements pour les clics, un message sera ajouté (il en va de même avec les autres événements).
 
-<p>La fonction <code><a href="/fr/docs/DOM/window.setTimeout">setTimeout</a></code> est appelée avec deux arguments : un message à la suite de la queue et la durée à attendre (optionnelle, par défaut elle vaut 0). La durée représente le temps minimal à attendre avant que le message soit placé dans la queue. S'il n'y a pas d'autre message dans la queue, le message sera traîté directement. En revanche, s'il y a d'autres messages auparavant, le message de <code>setTimeout</code> devra attendre la fin du traîtement des messages précédents déjà présents dans la queue. C'est pourquoi le deuxième argument de cette fonction indique une durée minimum et non une durée garantie.</p>
+La fonction [`setTimeout`](/fr/docs/DOM/window.setTimeout) est appelée avec deux arguments : un message à la suite de la queue et la durée à attendre (optionnelle, par défaut elle vaut 0). La durée représente le temps minimal à attendre avant que le message soit placé dans la queue. S'il n'y a pas d'autre message dans la queue, le message sera traîté directement. En revanche, s'il y a d'autres messages auparavant, le message de `setTimeout` devra attendre la fin du traîtement des messages précédents déjà présents dans la queue. C'est pourquoi le deuxième argument de cette fonction indique une durée minimum et non une durée garantie.
 
-<div class="warning">
-<p><strong>Attention :</strong> L'argument passé pour le délai à <code>setTimeout</code> ne correspond pas au temps exact. Cela correspond au délai minimum et non à un délai garanti. Par exemple <code>setTimeout(maFonction(),100);</code> indique uniquement que <code>maFonction</code> sera lancé <strong>au moins</strong> après 100 millisecondes.</p>
-</div>
+> **Attention :** L'argument passé pour le délai à `setTimeout` ne correspond pas au temps exact. Cela correspond au délai minimum et non à un délai garanti. Par exemple `setTimeout(maFonction(),100);` indique uniquement que `maFonction` sera lancé **au moins** après 100 millisecondes.
 
-<p>Voici un exemple qui illustre ce concept (<code>setTimeout</code> ne s'exécute pas immédiatement après la fin du <em>timer</em>) :</p>
+Voici un exemple qui illustre ce concept (`setTimeout` ne s'exécute pas immédiatement après la fin du _timer_) :
 
-<pre class="brush: js notranslate">const s = new Date().getSeconds();
+```js
+const s = new Date().getSeconds();
 
 setTimeout(function() {
   // prints
@@ -83,22 +85,23 @@ setTimeout(function() {
 }, 500);
 
 while(true) {
-  if(new Date().getSeconds() - s &gt;= 2) {
+  if(new Date().getSeconds() - s >= 2) {
     console.log("Ouf, on a bouclé pendant 2 secondes");
     break;
   }
 }
-</pre>
+```
 
-<h3 id="Zéro_délai">Zéro délai</h3>
+### Zéro délai
 
-<p>Un délai à zéro ne signifie pas que le callback sera déclenché après zéro milliseconde. Appeler <code><a href="https://developer.mozilla.org/fr/docs/Web/API/WindowOrWorkerGlobalScope/setTimeout" title="The documentation about this has not yet been written; please consider contributing!">setTimeout</a></code> avec un délai de <code>0</code> (zéro) milliseconde n'éxécute pas le callback après l'interval donné.</p>
+Un délai à zéro ne signifie pas que le callback sera déclenché après zéro milliseconde. Appeler [`setTimeout`](https://developer.mozilla.org/fr/docs/Web/API/WindowOrWorkerGlobalScope/setTimeout "The documentation about this has not yet been written; please consider contributing!") avec un délai de `0` (zéro) milliseconde n'éxécute pas le callback après l'interval donné.
 
-<p>L'exécution dépend du nombre de taches en attente dans la queue. Dans l'exemple ci-dessous, le message <code>'ceci est juste un message'</code> sera affiché dans la console avant que le message dans le callback soit traité, parce que le délai est le temps <em>minimum</em> requis par l'environnement d'exécution (runtime) pour traiter la demande (pas un temps <em>garanti</em>).</p>
+L'exécution dépend du nombre de taches en attente dans la queue. Dans l'exemple ci-dessous, le message `'ceci est juste un message'` sera affiché dans la console avant que le message dans le callback soit traité, parce que le délai est le temps *minimum* requis par l'environnement d'exécution (runtime) pour traiter la demande (pas un temps _garanti_).
 
-<p>Fondamentalement, <code>setTimeout</code> doit attendre la fin de tout le code pour les messages en file d'attente, même si vous avez spécifié une limite de temps particulière pour votre setTimeout.</p>
+Fondamentalement, `setTimeout` doit attendre la fin de tout le code pour les messages en file d'attente, même si vous avez spécifié une limite de temps particulière pour votre setTimeout.
 
-<pre class="brush: js notranslate">(function() {
+```js
+(function() {
 
   console.log('ceci est le début');
 
@@ -120,36 +123,22 @@ while(true) {
 // "ceci est juste un message"
 // "ceci est la fin"
 // "Callback 1: ceci est un msg depuis le callback"
-// "Callback 2: ceci est un msg depuis le callback"</pre>
-
-<h3 id="La_communication_entre_plusieurs_environnements_dexécution">La communication entre plusieurs environnements d'exécution</h3>
-
-<p>Un web worker ou une <code>iframe</code> d'origine multiple (<em>cross origin</em>) possède sa propre pile, son propre tas et sa propre queue de messages. Deux environnements d'exécution distincts peuvent uniquement communiquer via des messages envoyés par la méthode <a href="/fr/docs/Web/API/window.postMessage"><code>postMessage</code></a>. Cette méthode permet d'ajouter un message à un autre environnement d'exécution si celui-ci « écoute » les événements <code>message</code>.</p>
-
-<h2 id="Non_bloquant">Non bloquant</h2>
-
-<p>Le modèle de la boucle d'événement possède une caractéristique intéressante : JavaScript, à  la différence d'autres langages, ne bloque jamais. La gestion des entrées-sorties (<em>I/O</em>) est généralement traitée par des événements et des callbacks. Ainsi, quand l'application attend le résultat d'une requête <a href="/fr/docs/IndexedDB">IndexedDB</a> ou d'une requête <a href="/fr/docs/XMLHttpRequest">XHR</a>, il reste possible de traiter d'autres éléments comme les saisies utilisateur.</p>
-
-<p>Il existe certaines exceptions historiques comme <code>alert</code> ou des appels XHR synchrones. C'est une bonne pratique que de les éviter. Attention, <a href="https://stackoverflow.com/questions/2734025/is-javascript-guaranteed-to-be-single-threaded/2734311#2734311">certaines exceptions existent</a> (mais relèvent généralement de bugs d'implémentation).</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('HTML WHATWG', 'webappapis.html#event-loops', 'Event loops')}}</td>
-   <td>{{Spec2('HTML WHATWG')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><a href="https://nodejs.org/en/docs/guides/event-loop-timers-and-nexttick/#what-is-the-event-loop">Boucle d'évènements pour Node.js</a></td>
-   <td>Standard évolutif</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
+// "Callback 2: ceci est un msg depuis le callback"
+```
+
+### La communication entre plusieurs environnements d'exécution
+
+Un web worker ou une `iframe` d'origine multiple (_cross origin_) possède sa propre pile, son propre tas et sa propre queue de messages. Deux environnements d'exécution distincts peuvent uniquement communiquer via des messages envoyés par la méthode [`postMessage`](/fr/docs/Web/API/window.postMessage). Cette méthode permet d'ajouter un message à un autre environnement d'exécution si celui-ci « écoute » les événements `message`.
+
+## Non bloquant
+
+Le modèle de la boucle d'événement possède une caractéristique intéressante : JavaScript, à  la différence d'autres langages, ne bloque jamais. La gestion des entrées-sorties (_I/O_) est généralement traitée par des événements et des callbacks. Ainsi, quand l'application attend le résultat d'une requête [IndexedDB](/fr/docs/IndexedDB) ou d'une requête [XHR](/fr/docs/XMLHttpRequest), il reste possible de traiter d'autres éléments comme les saisies utilisateur.
+
+Il existe certaines exceptions historiques comme `alert` ou des appels XHR synchrones. C'est une bonne pratique que de les éviter. Attention, [certaines exceptions existent](https://stackoverflow.com/questions/2734025/is-javascript-guaranteed-to-be-single-threaded/2734311#2734311) (mais relèvent généralement de bugs d'implémentation).
+
+## Spécifications
+
+| Spécification                                                                                                                | É tat                            | Commentaires |
+| ---------------------------------------------------------------------------------------------------------------------------- | -------------------------------- | ------------ |
+| {{SpecName('HTML WHATWG', 'webappapis.html#event-loops', 'Event loops')}}                             | {{Spec2('HTML WHATWG')}} |              |
+| [Boucle d'évènements pour Node.js](https://nodejs.org/en/docs/guides/event-loop-timers-and-nexttick/#what-is-the-event-loop) | Standard évolutif                |              |
diff --git a/files/fr/web/javascript/guide/control_flow_and_error_handling/index.md b/files/fr/web/javascript/guide/control_flow_and_error_handling/index.md
index 59ec009395..8e9f0a7d3a 100644
--- a/files/fr/web/javascript/guide/control_flow_and_error_handling/index.md
+++ b/files/fr/web/javascript/guide/control_flow_and_error_handling/index.md
@@ -15,68 +15,75 @@ tags:
 translation_of: Web/JavaScript/Guide/Control_flow_and_error_handling
 original_slug: Web/JavaScript/Guide/Contrôle_du_flux_Gestion_des_erreurs
 ---
-<div>{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/Grammar_and_types", "Web/JavaScript/Guide/Loops_and_iteration")}}</div>
+{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/Grammar_and_types", "Web/JavaScript/Guide/Loops_and_iteration")}}
 
-<p>JavaScript supporte nativement un ensemble d'instructions. Ces instructions permettent de définir les logiques des algorithmes, le flux des informations, etc. Ce chapitre fournit un aperçu sur le fonctionnement de ces différentes instructions JavaScript.</p>
+JavaScript supporte nativement un ensemble d'instructions. Ces instructions permettent de définir les logiques des algorithmes, le flux des informations, etc. Ce chapitre fournit un aperçu sur le fonctionnement de ces différentes instructions JavaScript.
 
-<p>Les <a href="/fr/docs/Web/JavaScript/Reference/Statements">Références de JavaScript</a> contiennent plus de détails sur les différentes instructions décrites dans ce chapitre.</p>
+Les [Références de JavaScript](/fr/docs/Web/JavaScript/Reference/Statements) contiennent plus de détails sur les différentes instructions décrites dans ce chapitre.
 
-<p>Toute expression est une instruction, voir la page <a href="/fr/docs/Web/JavaScript/Guide/Expressions_and_Operators">Expressions et opérateurs</a> pour plus d'informations sur les expressions. En JavaScript, le point-virgule (<code>;</code>) est utilisé afin de séparer des instructions dans le code.</p>
+Toute expression est une instruction, voir la page [Expressions et opérateurs](/fr/docs/Web/JavaScript/Guide/Expressions_and_Operators) pour plus d'informations sur les expressions. En JavaScript, le point-virgule (`;`) est utilisé afin de séparer des instructions dans le code.
 
-<h2 id="block_statement">Les blocs d'instruction</h2>
+## Les blocs d'instruction
 
-<p>L'instruction la plus simple est l'instruction de bloc qui permet de regrouper des instructions. Un bloc est délimité par une paire d'accolades :</p>
+L'instruction la plus simple est l'instruction de bloc qui permet de regrouper des instructions. Un bloc est délimité par une paire d'accolades :
 
-<pre class="brush: js">{
+```js
+{
    instruction_1;
    instruction_2;
    ⋮
    instruction_n;
-}</pre>
+}
+```
 
-<h3 id="example">Exemple</h3>
+### Exemple
 
-<p>Les instructions de blocs sont souvent utilisées avec les instructions conditionnelles et itératives telles que <code>if</code>, <code>for</code>, <code>while</code>.</p>
+Les instructions de blocs sont souvent utilisées avec les instructions conditionnelles et itératives telles que `if`, `for`, `while`.
 
-<pre class="brush: js">while (x &lt; 10) {
+```js
+while (x < 10) {
   x++;
-}</pre>
-
-<p>Ici, <code>{ x++; }</code> représente le bloc.</p>
-
-<div class="note">
-  <p><strong>Note :</strong> En JavaScript, avant ECMAScript 2015 (aussi appelé ES6), les blocs <strong>n'introduisaient pas de nouvelles portées</strong>. Les variables introduites dans le bloc avec l'instruction <code>var</code> font partie de la portée de la fonction englobante ou du script. Les effets de leur définition persistent en dehors du bloc. Les blocs seuls utilisés avec <code>var</code> (et non <code>let</code>) pourront laisser penser que ce bloc se comportera comme en C ou en Java. Par exemple :</p>
-
-  <pre class="brush: js">var x = 1;
-{
-  var x = 2;
 }
-console.log(x); // affichera 2</pre>
+```
 
-  <p>Cella affichera 2 car l'instruction <code>var x</code> contenue dans le bloc fait partie de la même portée que l'instruction <code>var x</code> écrite avant le bloc. En C ou en Java, le code équivalent à cet exemple aurait produit 1.</p>
+Ici, `{ x++; }` représente le bloc.
 
-  <p>Cela a évolué avec ECMAScript 2015 (ES6). Les instructions <code>let</code>et <code>const</code> permettent de déclarer des variables dont la portée est celle du bloc courant. Voir les pages des références <a href="/fr/docs/Web/JavaScript/Reference/Statements/let"><code>let</code></a> et <a href="/fr/docs/Web/JavaScript/Reference/Statements/const"><code>const</code></a>.</p>
-</div>
+> **Note :** En JavaScript, avant ECMAScript 2015 (aussi appelé ES6), les blocs **n'introduisaient pas de nouvelles portées**. Les variables introduites dans le bloc avec l'instruction `var` font partie de la portée de la fonction englobante ou du script. Les effets de leur définition persistent en dehors du bloc. Les blocs seuls utilisés avec `var` (et non `let`) pourront laisser penser que ce bloc se comportera comme en C ou en Java. Par exemple :
+>
+> ```js
+> var x = 1;
+> {
+>   var x = 2;
+> }
+> console.log(x); // affichera 2
+> ```
+>
+> Cella affichera 2 car l'instruction `var x` contenue dans le bloc fait partie de la même portée que l'instruction `var x` écrite avant le bloc. En C ou en Java, le code équivalent à cet exemple aurait produit 1.
+>
+> Cela a évolué avec ECMAScript 2015 (ES6). Les instructions `let`et `const` permettent de déclarer des variables dont la portée est celle du bloc courant. Voir les pages des références [`let`](/fr/docs/Web/JavaScript/Reference/Statements/let) et [`const`](/fr/docs/Web/JavaScript/Reference/Statements/const).
 
-<h2 id="conditional_statements">Les instructions conditionnelles</h2>
+## Les instructions conditionnelles
 
-<p>Une instruction conditionnelle est un ensemble de commandes qui s'exécutent si une condition donnée est vérifiée. JavaScript possède deux instructions conditionnelles : <code>if...else</code> et <code>switch</code>.</p>
+Une instruction conditionnelle est un ensemble de commandes qui s'exécutent si une condition donnée est vérifiée. JavaScript possède deux instructions conditionnelles : `if...else` et `switch`.
 
-<h3 id="if...else_statement">Instruction <code>if...else</code></h3>
+### Instruction `if...else`
 
-<p>On utilise l'instruction <code>if</code> lorsqu'on souhaite exécuter une instruction si une condition logique est vérifiée (vraie). La clause <code>else</code> est optionnelle et permet de préciser les instructions à exécuter si la condition logique n'est pas vérifiée (l'assertion est fausse). Voici un exemple qui illustre l'utilisation de l'instruction <code>if</code> :</p>
+On utilise l'instruction `if` lorsqu'on souhaite exécuter une instruction si une condition logique est vérifiée (vraie). La clause `else` est optionnelle et permet de préciser les instructions à exécuter si la condition logique n'est pas vérifiée (l'assertion est fausse). Voici un exemple qui illustre l'utilisation de l'instruction `if` :
 
-<pre class="brush: js">if (condition) {
+```js
+if (condition) {
   instruction_1;
 } else {
   instruction_2;
-}</pre>
+}
+```
 
-<p><code>condition</code> peut correspondre à n'importe quelle expression qui est évaluée à <code>true</code> (vrai) ou <code>false</code> (faux). Voir la page sur les <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Boolean#description">booléens</a> pour plus d'informations sur les évaluations qui fournissent les valeurs <code>true</code> ou <code>false</code>. Si la <code>condition</code> vaut <code>true</code>, <code>instruction_1</code> est exécutée, sinon <code>instruction_2</code> sera exécutée. <code>instruction_1</code> et <code>instruction_2</code> peuvent correspondre à n'importe quelle instruction, y compris d'autres instructions <code>if</code>.</p>
+`condition` peut correspondre à n'importe quelle expression qui est évaluée à `true` (vrai) ou `false` (faux). Voir la page sur les [booléens](/fr/docs/Web/JavaScript/Reference/Global_Objects/Boolean#description) pour plus d'informations sur les évaluations qui fournissent les valeurs `true` ou `false`. Si la `condition` vaut `true`, `instruction_1` est exécutée, sinon `instruction_2` sera exécutée. `instruction_1` et `instruction_2` peuvent correspondre à n'importe quelle instruction, y compris d'autres instructions `if`.
 
-<p>Si on doit tester différentes conditions les unes à la suite des autres, il est possible d'utiliser <code>else if</code> pour lier les différents tests. On l'utilise de la façon suivante :</p>
+Si on doit tester différentes conditions les unes à la suite des autres, il est possible d'utiliser `else if` pour lier les différents tests. On l'utilise de la façon suivante :
 
-<pre class="brush: js">if (condition_1) {
+```js
+if (condition_1) {
   instruction_1;
 } else if (condition_2) {
   instruction_2;
@@ -84,66 +91,72 @@ console.log(x); // affichera 2</pre>
   instruction_n;
 } else {
   dernière_instruction;
-}</pre>
+}
+```
 
-<p>Afin d'exécuter plusieurs instructions, on peut les regrouper grâce aux blocs (<code>{ ... }</code>) vus précédemment. C'est une bonne pratique que de les utiliser, surtout si on imbrique plusieurs instructions <code>if</code> les unes dans les autres:</p>
+Afin d'exécuter plusieurs instructions, on peut les regrouper grâce aux blocs (`{ ... }`) vus précédemment. C'est une bonne pratique que de les utiliser, surtout si on imbrique plusieurs instructions `if` les unes dans les autres:
 
-<h4 id="best_practice">Meilleure pratique</h4>
+#### Meilleure pratique
 
-<p>En général, il est bon de toujours utiliser des instructions de type bloc —<em>surtout</em> lorsqu'on imbrique des instructions <code>if</code> :</p>
+En général, il est bon de toujours utiliser des instructions de type bloc —_surtout_ lorsqu'on imbrique des instructions `if` :
 
-<pre class="brush: js">if (condition) {
+```js
+if (condition) {
   instruction_1_exécutée_si_condition_vraie;
   instruction_2_exécutée_si_condition_vraie;
 } else {
   instruction_3_exécutée_si_condition_fausse;
   instruction_4_exécutée_si_condition_fausse;
-}</pre>
+}
+```
 
-<p>Attention à ne pas utiliser des instructions d'affectation dans les expressions conditionnelles. On peut, en effet, très facilement confondre l'affectation et le test d'égalité en lisant le code.</p>
+Attention à ne pas utiliser des instructions d'affectation dans les expressions conditionnelles. On peut, en effet, très facilement confondre l'affectation et le test d'égalité en lisant le code.
 
-<p>Voici un exemple de ce qu'il ne faut <strong>pas</strong> faire :</p>
+Voici un exemple de ce qu'il ne faut **pas** faire :
 
-<pre class="example-bad brush: js">if (x = y) {
+```js example-bad
+if (x = y) {
   /* exécuter des instructions */
-}</pre>
+}
+```
 
-<p>Ici, on ne teste pas si x vaut y, on affecte la valeur de y à x ! Si vous devez à tout prix utiliser une affectation dans une expression conditionnelle, une bonne pratique sera d'ajouter des parenthèses en plus autour de l'affectation. Par exemple :</p>
+Ici, on ne teste pas si x vaut y, on affecte la valeur de y à x ! Si vous devez à tout prix utiliser une affectation dans une expression conditionnelle, une bonne pratique sera d'ajouter des parenthèses en plus autour de l'affectation. Par exemple :
 
-<pre class="example-good brush: js">if ((x = y)) {
+```js example-good
+if ((x = y)) {
   /* exécuter des instructions */
 }
-</pre>
+```
 
-<h4 id="falsy_values">Valeurs équivalentes à false dans un contexte booléen (<em>falsy</em> values)</h4>
+#### Valeurs équivalentes à false dans un contexte booléen (_falsy_ values)
 
-<p>Les valeurs suivantes sont évaluées à <code>false</code> (également connues sous le nom de <a href="/fr/docs/Glossary/Falsy">valeurs Falsy</a>) :</p>
+Les valeurs suivantes sont évaluées à `false` (également connues sous le nom de [valeurs Falsy](/fr/docs/Glossary/Falsy)) :
 
-<ul>
- <li><code>false</code></li>
- <li><code>undefined</code></li>
- <li><code>null</code></li>
- <li><code>0</code></li>
- <li><code>NaN</code></li>
- <li>la chaîne de caractères vide (<code>""</code>)</li>
-</ul>
+- `false`
+- `undefined`
+- `null`
+- `0`
+- `NaN`
+- la chaîne de caractères vide (`""`)
 
-<p>Les autres valeurs, y compris les objets, seront équivalents à <code>true</code>.</p>
+Les autres valeurs, y compris les objets, seront équivalents à `true`.
 
-<div class="warning">
-  <p><strong>Attention :</strong> Ne pas confondre les valeurs booléennes « primitives » <code>true</code> et <code>false</code> avec les valeurs créées grâce à un objet <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Boolean"><code>Boolean</code></a>.</p>
-  <p>Par exemple, on aura :</p>
-  
-  <pre class="brush: js">var b = new Boolean(false);
-  if (b) // cette condition est bien vérifiée !
-  if (b === true) // cette condition n'est pas vérifiée !</pre>
-</div>
+> **Attention :** Ne pas confondre les valeurs booléennes « primitives » `true` et `false` avec les valeurs créées grâce à un objet [`Boolean`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Boolean).
+>
+> Par exemple, on aura :
+>
+> ```js
+> var b = new Boolean(false);
+>   if (b) // cette condition est bien vérifiée !
+>   if (b === true) // cette condition n'est pas vérifiée !
+> ```
 
-<h4 id="example_2">Exemple</h4>
+#### Exemple
 
-<p>Dans l'exemple qui suit, la fonction<code> checkData </code>renvoie <code>true</code> si une chaîne de caractères mesure trois caractères. Sinon, elle affiche une alerte et renvoie <code>false</code>.</p>
+Dans l'exemple qui suit, la fonction` checkData `renvoie `true` si une chaîne de caractères mesure trois caractères. Sinon, elle affiche une alerte et renvoie `false`.
 
-<pre class="brush: js">function checkData(maChaîne) {
+```js
+function checkData(maChaîne) {
   if (maChaîne.length == 3) {
     return true;
   } else {
@@ -151,15 +164,17 @@ console.log(x); // affichera 2</pre>
       maChaîne + " n'est pas valide.");
     return false;
   }
-}</pre>
+}
+```
 
-<h3 id="switch_statement">L'instruction <code>switch</code></h3>
+### L'instruction `switch`
 
-<p>L'instruction <code>switch</code> permet à un programme d'évaluer une expression et d'effectuer des instructions en fonction des différents cas de figures correspondants aux différentes valeurs. Si un cas correspond au résultat de l'évaluation, le programme exécute l'instruction associée.</p>
+L'instruction `switch` permet à un programme d'évaluer une expression et d'effectuer des instructions en fonction des différents cas de figures correspondants aux différentes valeurs. Si un cas correspond au résultat de l'évaluation, le programme exécute l'instruction associée.
 
-<p>Voici un exemple utilisant une instruction <code>switch</code> :</p>
+Voici un exemple utilisant une instruction `switch` :
 
-<pre class="brush: js">switch (expression) {
+```js
+switch (expression) {
   case label_1:
     instructions_1
     [break;]
@@ -171,30 +186,27 @@ console.log(x); // affichera 2</pre>
     instructions_par_defaut
     [break;]
 }
-</pre>
+```
 
-<p>JavaScript évalue l'instruction de commutation ci-dessus comme suit :</p>
+JavaScript évalue l'instruction de commutation ci-dessus comme suit :
 
-<ul>
-  <li>Le programme recherche d'abord une clause <code>case</code> dont l'étiquette correspond à la valeur de l'expression, puis il transfère le contrôle à cette clause, en exécutant les instructions associées.</li>
-  <li>Si aucune étiquette correspondante n'est trouvée, le programme recherche la clause optionnelle <code>default</code> :
-    <ul>
-      <li>Si une clause <code>default</code> est trouvée, le programme transfère le contrôle à cette clause, exécutant les déclarations associées.</li>
-      <li>Si aucune clause <code>default</code> n'est trouvée, le programme reprend l'exécution à l'instruction qui suit la fin de <code>switch</code>.</li>
-      <li>(Par convention, la clause <code>default</code> est écrite comme la dernière clause, mais il n'est pas nécessaire que ce soit le cas).</li>
-    </ul>
-  </li>
-</ul>
+- Le programme recherche d'abord une clause `case` dont l'étiquette correspond à la valeur de l'expression, puis il transfère le contrôle à cette clause, en exécutant les instructions associées.
+- Si aucune étiquette correspondante n'est trouvée, le programme recherche la clause optionnelle `default` :
 
-<h4 id="break_statements">L'instruction break</h4>
+  - Si une clause `default` est trouvée, le programme transfère le contrôle à cette clause, exécutant les déclarations associées.
+  - Si aucune clause `default` n'est trouvée, le programme reprend l'exécution à l'instruction qui suit la fin de `switch`.
+  - (Par convention, la clause `default` est écrite comme la dernière clause, mais il n'est pas nécessaire que ce soit le cas).
 
-<p>L'instruction optionnelle <code>break</code>, éventuellement contenue pour chaque clause <code>case</code>, permet de ne pas exécuter les instructions pour les cas suivants. Si <code>break</code> n'est pas utilisé, le programme continuera son exécution avec les autres instructions contenues dans l'instruction <code>switch</code>.</p>
+#### L'instruction break
 
-<h5 id="example_3">Exemple</h5>
+L'instruction optionnelle `break`, éventuellement contenue pour chaque clause `case`, permet de ne pas exécuter les instructions pour les cas suivants. Si `break` n'est pas utilisé, le programme continuera son exécution avec les autres instructions contenues dans l'instruction `switch`.
 
-<p>Dans l'exemple suivant, si <code>fruit</code> vaut "Banane", le programme exécutera les instructions associées. Quand <code>break</code> est rencontré, le programme passe aux instructions décrites après <code>switch</code>. Ici, si <code>break</code> n'était pas présent, les instructions pour le cas "Cerise" auraient également été exécutées.</p>
+##### Exemple
 
-<pre class="brush: js">switch (fruit) {
+Dans l'exemple suivant, si `fruit` vaut "Banane", le programme exécutera les instructions associées. Quand `break` est rencontré, le programme passe aux instructions décrites après `switch`. Ici, si `break` n'était pas présent, les instructions pour le cas "Cerise" auraient également été exécutées.
+
+```js
+switch (fruit) {
   case "Orange":
     console.log("Les oranges sont à 60 centimes le kilo.");
     break;
@@ -213,45 +225,44 @@ console.log(x); // affichera 2</pre>
   default:
     console.log("Désolé, nous n'avons pas de " + fruittype + ".");
 }
-console.log("Souhaitez-vous autre chose ?");</pre>
+console.log("Souhaitez-vous autre chose ?");
+```
 
-<h2 id="exception_handling_statements">Les instructions pour gérer les exceptions</h2>
+## Les instructions pour gérer les exceptions
 
-<p>Il est possible de lever des exceptions avec l'instruction <code>throw</code> et de les gérer (les intercepter) avec des instructions <code>try...catch</code>.</p>
+Il est possible de lever des exceptions avec l'instruction `throw` et de les gérer (les intercepter) avec des instructions `try...catch`.
 
-<ul>
-  <li><a href="#throw_statement">L'instruction throw</a></li>
-  <li><a href="#try...catch_statement">L'instruction <code>try...catch</code></a></li>
-</ul>
+- [L'instruction throw](#throw_statement)
+- [L'instruction `try...catch`](#try...catch_statement)
 
-<h3 id="exception_types">Les types d'exception</h3>
+### Les types d'exception
 
-<p>En JavaScript, n'importe quel objet peut être signalé comme une exception. Cependant, afin de respecter certaines conventions et de bénéficier de certaines informations, on pourra utiliser les types destinés à cet effet :</p>
+En JavaScript, n'importe quel objet peut être signalé comme une exception. Cependant, afin de respecter certaines conventions et de bénéficier de certaines informations, on pourra utiliser les types destinés à cet effet :
 
-<ul>
- <li><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Error#error_types">Les exceptions ECMAScript</a></li>
- <li><a href="/fr/docs/Web/API/DOMException"><code>DOMException</code></a> et <a href="/fr/docs/Web/API/DOMError"><code>DOMError</code></a></li>
-</ul>
+- [Les exceptions ECMAScript](/fr/docs/Web/JavaScript/Reference/Global_Objects/Error#error_types)
+- [`DOMException`](/fr/docs/Web/API/DOMException) et [`DOMError`](/fr/docs/Web/API/DOMError)
 
-<h3 id="throw_statement">L'instruction <code>throw</code></h3>
+### L'instruction `throw`
 
-<p>L'instruction <code>throw</code> est utilisée afin de signaler une exception. Lorsqu'on signale une exception, on définit une expression qui contient la valeur à renvoyer pour l'exception :</p>
+L'instruction `throw` est utilisée afin de signaler une exception. Lorsqu'on signale une exception, on définit une expression qui contient la valeur à renvoyer pour l'exception :
 
-<pre class="brush: js">throw expression;</pre>
+```js
+throw expression;
+```
 
-<p>Il est possible d'utiliser n'importe quelle expression, sans restriction de type. Le fragment de code qui suit illustre les différentes possibilités :</p>
+Il est possible d'utiliser n'importe quelle expression, sans restriction de type. Le fragment de code qui suit illustre les différentes possibilités :
 
-<pre class="brush: js">throw "Erreur2";  //type String
+```js
+throw "Erreur2";  //type String
 throw 42;         //type Number
 throw true;       //type Boolean
 throw {toString: function () { return "je suis un objet !"; } };
-</pre>
+```
 
-<div class="note">
-  <p><strong>Note :</strong> Vous pouvez spécifier un objet lorsque vous lancez une exception. Vous pouvez alors faire référence aux propriétés de l'objet dans le bloc <code>catch</code>.</p>
-</div>
+> **Note :** Vous pouvez spécifier un objet lorsque vous lancez une exception. Vous pouvez alors faire référence aux propriétés de l'objet dans le bloc `catch`.
 
-<pre class="brush: js">// On crée le constructeur pour cet objet
+```js
+// On crée le constructeur pour cet objet
 function ExceptionUtilisateur(message) {
   this.message = message;
   this.name = "ExceptionUtilisateur";
@@ -265,19 +276,21 @@ ExceptionUtilisateur.prototype.toString = function() {
 
 // On crée une instance pour ce type d'objet
 // et on renvoie une exception avec cette instance
-throw new ExceptionUtilisateur("La valeur fournie est trop élevée.");</pre>
+throw new ExceptionUtilisateur("La valeur fournie est trop élevée.");
+```
 
-<h3 id="try...catch_statement">L'instruction <code>try...catch</code></h3>
+### L'instruction `try...catch`
 
-<p>L'instruction <code>try...catch</code> permet de définir un bloc d'instructions qu'on essaye (<em>try</em> en anglais) d'exécuter, ainsi qu'une ou plusieurs instructions à utiliser en cas d'erreur lorsqu'une exception se produit. Si une exception est signalée, l'instruction <code>try...catch</code> permettra de l' « attraper » (<em>catch</em> en anglais) et de définir ce qui se passe dans ce cas.</p>
+L'instruction `try...catch` permet de définir un bloc d'instructions qu'on essaye (_try_ en anglais) d'exécuter, ainsi qu'une ou plusieurs instructions à utiliser en cas d'erreur lorsqu'une exception se produit. Si une exception est signalée, l'instruction `try...catch` permettra de l' « attraper » (_catch_ en anglais) et de définir ce qui se passe dans ce cas.
 
-<p>L'instruction <code>try...catch</code> se compose d'un bloc <code>try</code> qui contient une ou plusieurs instructions et blocs <code>catch</code> qui contiennent les instructions à exécuter lorsqu'une exception se produit dans le bloc <code>try</code>.</p>
+L'instruction `try...catch` se compose d'un bloc `try` qui contient une ou plusieurs instructions et blocs `catch` qui contiennent les instructions à exécuter lorsqu'une exception se produit dans le bloc `try`.
 
-<p>Autrement dit, dans la plupart des cas pour le programme, on veut que les instructions du bloc <code>try</code> se déroulent normalement et en cas de problème, on passe le contrôle au bloc <code>catch</code>. Si une instruction contenue dans le bloc <code>try</code> renvoie une exception, le contrôle sera immédiatement transféré au bloc <code>catch</code>. Si aucune exception n'est signalée au sein du bloc <code>try</code>, le bloc <code>catch</code> ne sera pas utilisé. Cette instruction peut comporter un bloc <code>finally</code> qui s'exécute après les blocs <code>try</code> et <code>catch</code> mais avant les instructions suivant l'instruction <code>try...catch</code>.</p>
+Autrement dit, dans la plupart des cas pour le programme, on veut que les instructions du bloc `try` se déroulent normalement et en cas de problème, on passe le contrôle au bloc `catch`. Si une instruction contenue dans le bloc `try` renvoie une exception, le contrôle sera immédiatement transféré au bloc `catch`. Si aucune exception n'est signalée au sein du bloc `try`, le bloc `catch` ne sera pas utilisé. Cette instruction peut comporter un bloc `finally` qui s'exécute après les blocs `try` et `catch` mais avant les instructions suivant l'instruction `try...catch`.
 
-<p>Dans l'exemple qui suit, on utilise une instruction <code>try...catch</code>. On définit une fonction qui prend un nombre et renvoie le nom du mois correspondant à ce nombre. Si la valeur fournie n'est pas comprise entre 1 et 12, on signale une exception avec la valeur <code>"NuméroMoisInvalide"</code>. Lorsque cette exception est gérée dans le bloc <code>catch</code>, la variable <code>nomMois</code> recevra la valeur <code>"inconnu"</code>.</p>
+Dans l'exemple qui suit, on utilise une instruction `try...catch`. On définit une fonction qui prend un nombre et renvoie le nom du mois correspondant à ce nombre. Si la valeur fournie n'est pas comprise entre 1 et 12, on signale une exception avec la valeur `"NuméroMoisInvalide"`. Lorsque cette exception est gérée dans le bloc `catch`, la variable `nomMois` recevra la valeur `"inconnu"`.
 
-<pre class="brush: js">function getNomMois(numMois) {
+```js
+function getNomMois(numMois) {
   numMois = numMois - 1; // On décale de 1 car les indices du tableaux commencent à 0
   var mois = ["Janvier", "Février", "Mars", "Avril" ,"Mai", "Juin", "Juillet",
               "Août", "Septembre", "Octobre", "Novembre", "Décembre"];
@@ -293,44 +306,48 @@ try { // les instructions à essayer si tout se passe bien
 } catch (e) {
   nomMois = "inconnu";
   gestionErreurLog(e); // on gère l'erreur avec une fonction
-}</pre>
+}
+```
 
-<h4 id="the_catch_block">Le bloc <code>catch</code></h4>
+#### Le bloc `catch`
 
-<p>Un bloc <code>catch</code> peut être utilisé afin de gérer les exceptions pouvant être générées par les instructions du bloc <code>try</code>.</p>
+Un bloc `catch` peut être utilisé afin de gérer les exceptions pouvant être générées par les instructions du bloc `try`.
 
-<pre class="brush: js">catch (ident) {
+```js
+catch (ident) {
   statements
-}</pre>
+}
+```
 
-<p>Le bloc <code>catch</code> définit un identifiant (<code>ident</code> dans le fragment de code précédent) qui contiendra la valeur passée par l'instruction <code>throw</code>. Cet identifiant peut être utilisé afin de récupérer des informations sur l'exception qui a été signalée.</p>
+Le bloc `catch` définit un identifiant (`ident` dans le fragment de code précédent) qui contiendra la valeur passée par l'instruction `throw`. Cet identifiant peut être utilisé afin de récupérer des informations sur l'exception qui a été signalée.
 
-<p>JavaScript crée cet identifiant lorsque le contrôle passe au bloc <code>catch</code>. L'identifiant ne « vit » qu'à l'intérieur du bloc <code>catch</code> et une fois que l'exécution du bloc <code>catch</code> est terminée, l'identifiant n'est plus disponible.</p>
+JavaScript crée cet identifiant lorsque le contrôle passe au bloc `catch`. L'identifiant ne « vit » qu'à l'intérieur du bloc `catch` et une fois que l'exécution du bloc `catch` est terminée, l'identifiant n'est plus disponible.
 
-<p>Dans l'exemple suivant, le code renvoie une exception. Lorsque celle-ci est signalée, le contrôle passe au bloc <code>catch</code>.</p>
+Dans l'exemple suivant, le code renvoie une exception. Lorsque celle-ci est signalée, le contrôle passe au bloc `catch`.
 
-<pre class="brush: js">try {
+```js
+try {
   throw "monException"; // on génère une exception
 } catch (e) {
   // les instructions utilisées pour gérer les exceptions
   enregistrerErreurs(e); // on passe l'objet représentant l'exception à une fonction utilisée pour gérer les erreurs
-}</pre>
+}
+```
 
-<div class="note">
-  <p><strong>Note :</strong> Quand on souhaite afficher des erreurs dans la console, on privilégiera <a href="/fr/docs/Web/API/Console/error"><code>console.error()</code></a> plutôt que <a href="/fr/docs/Web/API/Console/log"><code>console.log()</code></a>. En effet, cette première méthode est plus adaptée et indiquera plus d'informations.</p>
-</div>
+> **Note :** Quand on souhaite afficher des erreurs dans la console, on privilégiera [`console.error()`](/fr/docs/Web/API/Console/error) plutôt que [`console.log()`](/fr/docs/Web/API/Console/log). En effet, cette première méthode est plus adaptée et indiquera plus d'informations.
 
-<h4 id="the_finally_block">Le bloc <code>finally</code></h4>
+#### Le bloc `finally`
 
-<p>Le bloc <code>finally</code> contient les instructions à exécuter après les blocs <code>try</code> et <code>catch</code> mais avant l'instruction suivant le <code>try...catch...finally</code>.</p>
+Le bloc `finally` contient les instructions à exécuter après les blocs `try` et `catch` mais avant l'instruction suivant le `try...catch...finally`.
 
-<p>Le bloc <code>finally</code> est exécuté dans tous les cas, <strong>qu'une exception ait été levée ou non</strong>. Si une exception est signalée et qu'il n'y a pas de bloc <code>catch</code> pour la gérer, les instructions du bloc <code>finally</code> seront tout de même exécutées.</p>
+Le bloc `finally` est exécuté dans tous les cas, **qu'une exception ait été levée ou non**. Si une exception est signalée et qu'il n'y a pas de bloc `catch` pour la gérer, les instructions du bloc `finally` seront tout de même exécutées.
 
-<p>Le bloc <code>finally</code> peut être utilisé afin de finir proprement l'exécution malgré une exception. On peut, par exemple, devoir libérer une ressource, ou fermer un flux, etc.</p>
+Le bloc `finally` peut être utilisé afin de finir proprement l'exécution malgré une exception. On peut, par exemple, devoir libérer une ressource, ou fermer un flux, etc.
 
-<p>Dans l'exemple suivant, on écrit dans un fichier, si une exception se produit lors de l'écriture, on utilisera le bloc <code>finally</code> afin de bien fermer le flux vers le fichier avant la fin du script.</p>
+Dans l'exemple suivant, on écrit dans un fichier, si une exception se produit lors de l'écriture, on utilisera le bloc `finally` afin de bien fermer le flux vers le fichier avant la fin du script.
 
-<pre class="brush: js">ouvrirFichier();
+```js
+ouvrirFichier();
 try {
   écrireFichier(données); // Une erreur peut se produire
 } catch(e) {
@@ -338,11 +355,12 @@ try {
 } finally {
   fermerFichier(); // On n'oublie jamais de fermer le flux.
 }
-</pre>
+```
 
-<p>Si le bloc <code>finally</code> renvoie une valeur, cette valeur sera considérée comme la valeur de retour pour tout l'ensemble <code>try-catch-finally</code>, quelles que soient les instructions <code>return</code> éventuellement utilisées dans les blocs <code>try</code> et <code>catch</code> :</p>
+Si le bloc `finally` renvoie une valeur, cette valeur sera considérée comme la valeur de retour pour tout l'ensemble `try-catch-finally`, quelles que soient les instructions `return` éventuellement utilisées dans les blocs `try` et `catch` :
 
-<pre class="brush: js">function f() {
+```js
+function f() {
   try {
     console.log(0);
     throw "bug";
@@ -360,11 +378,12 @@ try {
   console.log(5); // Ne pourra jamais être exécuté
 }
 f(); // affiche 0, 1, 3 puis renvoie false
-</pre>
+```
 
-<p>Lorsqu'on surcharge les valeurs de retour avec le bloc <code>finally</code>, cela s'applique également aux exceptions qui sont levées (ou retransmises) au sein du bloc <code>catch</code> :</p>
+Lorsqu'on surcharge les valeurs de retour avec le bloc `finally`, cela s'applique également aux exceptions qui sont levées (ou retransmises) au sein du bloc `catch` :
 
-<pre class="brush: js">function f() {
+```js
+function f() {
   try {
     throw "problème";
   } catch(e) {
@@ -387,32 +406,32 @@ try {
 }
 
 // Sortie
-// "problème" interne attrapé</pre>
+// "problème" interne attrapé
+```
 
-<h4 id="nesting_try...catch_statements">Imbriquer des instructions <code>try...catch</code></h4>
+#### Imbriquer des instructions `try...catch`
 
-<p>Il est possible d'imbriquer une ou plusieurs instructions <code>try...catch</code>.</p>
+Il est possible d'imbriquer une ou plusieurs instructions `try...catch`.
 
-<p>Si un bloc <code>try</code> interne n'a <em>pas</em> de bloc <code>catch</code> correspondant :</p>
+Si un bloc `try` interne n'a _pas_ de bloc `catch` correspondant :
 
-<ol>
-  <li>il <em>doit</em> contenir un bloc <code>finally</code>, et</li>
-  <li>le bloc <code>try...catch</code> de l'instruction <code>catch</code> englobante est vérifié pour une correspondance.</li>
-</ol>
+1.  il _doit_ contenir un bloc `finally`, et
+2.  le bloc `try...catch` de l'instruction `catch` englobante est vérifié pour une correspondance.
 
-<p>Pour plus d'informations, voir <a href="/fr/docs/Web/JavaScript/Référence/Statements/try...catch#nested_try-blocks">nested try-blocks</a> sur la page de référence <code><a href="/fr/docs/Web/JavaScript/Référence/Statements/try...catch">try...catch</a></code>.</p>
+Pour plus d'informations, voir [nested try-blocks](/fr/docs/Web/JavaScript/Référence/Statements/try...catch#nested_try-blocks) sur la page de référence [`try...catch`](/fr/docs/Web/JavaScript/Référence/Statements/try...catch).
 
-<h3 id="utilizing_error_objects">Utiliser les objets d'erreur</h3>
+### Utiliser les objets d'erreur
 
-<p>En fonction du type d'erreur qui est créée, on pourra utiliser les propriétés <code>name</code> et <code>message</code> afin d'obtenir plus d'informations.</p>
+En fonction du type d'erreur qui est créée, on pourra utiliser les propriétés `name` et `message` afin d'obtenir plus d'informations.
 
-<p>Généralement on a <code>name</code> qui fournit le type d'erreur rencontrée (ex : <code>DOMException</code> ou <code>Error</code>). La propriété <code>message</code>, quant à elle fournit un message descriptif de l'erreur (qu'on utilisera généralement lorsqu'on voudra convertir/afficher le texte correspondant à une erreur).</p>
+Généralement on a `name` qui fournit le type d'erreur rencontrée (ex : `DOMException` ou `Error`). La propriété `message`, quant à elle fournit un message descriptif de l'erreur (qu'on utilisera généralement lorsqu'on voudra convertir/afficher le texte correspondant à une erreur).
 
-<p>Si vous construisez des erreurs, vous pouvez utiliser le constructeur <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Error"><code>Error</code></a> afin de disposer de ces propriétés.</p>
+Si vous construisez des erreurs, vous pouvez utiliser le constructeur [`Error`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Error) afin de disposer de ces propriétés.
 
-<p>Ainsi, on pourra avoir :</p>
+Ainsi, on pourra avoir :
 
-<pre class="brush: js">function causerErreurs() {
+```js
+function causerErreurs() {
   if (toutEstSourceDErreurs()) {
     throw (new Error('mon message'));
   } else {
@@ -425,6 +444,7 @@ try {
 } catch (e) {
   console.error(e.name);// affiche 'Error'
   console.error(e.message); // affiche 'mon message' ou un message d'erreur JavaScript
-}</pre>
+}
+```
 
-<div>{{PreviousNext("Web/JavaScript/Guide/Grammar_and_types", "Web/JavaScript/Guide/Loops_and_iteration")}}</div>
+{{PreviousNext("Web/JavaScript/Guide/Grammar_and_types", "Web/JavaScript/Guide/Loops_and_iteration")}}
diff --git a/files/fr/web/javascript/guide/details_of_the_object_model/index.md b/files/fr/web/javascript/guide/details_of_the_object_model/index.md
index 8cf9bf50ff..0176da2600 100644
--- a/files/fr/web/javascript/guide/details_of_the_object_model/index.md
+++ b/files/fr/web/javascript/guide/details_of_the_object_model/index.md
@@ -9,53 +9,50 @@ tags:
 translation_of: Web/JavaScript/Guide/Details_of_the_Object_Model
 original_slug: Web/JavaScript/Guide/Le_modèle_objet_JavaScript_en_détails
 ---
-<div>{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/Working_with_Objects", "Web/JavaScript/Guide/Using_promises")}}</div>
+{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/Working_with_Objects", "Web/JavaScript/Guide/Using_promises")}}
 
-<p>JavaScript est un langage orienté objet basé sur des prototypes, plutôt que sur des classes. En raison de cette base différente, il peut être moins évident de comprendre comment JavaScript vous permet de créer des hiérarchies d'objets et d'avoir un héritage des propriétés et de leurs valeurs. Ce chapitre tente de clarifier la situation.</p>
+JavaScript est un langage orienté objet basé sur des prototypes, plutôt que sur des classes. En raison de cette base différente, il peut être moins évident de comprendre comment JavaScript vous permet de créer des hiérarchies d'objets et d'avoir un héritage des propriétés et de leurs valeurs. Ce chapitre tente de clarifier la situation.
 
-<p>Ce chapitre part du principe que vous avez déjà une certaine connaissance de JavaScript et que vous avez utilisé des fonctions JavaScript pour créer des objets simples.</p>
+Ce chapitre part du principe que vous avez déjà une certaine connaissance de JavaScript et que vous avez utilisé des fonctions JavaScript pour créer des objets simples.
 
-<h2 id="class-based_vs._prototype-based_languages">Langages basés sur des classes ou des prototypes</h2>
+## Langages basés sur des classes ou des prototypes
 
-<p>Les langages orientés objets, basés sur des classes, tels que Java et C++, sont fondés sur le concept de deux entités distinctes : les classes et les instances.</p>
+Les langages orientés objets, basés sur des classes, tels que Java et C++, sont fondés sur le concept de deux entités distinctes : les classes et les instances.
 
-<ul>
-  <li>Une <em>classe</em> définit toutes les propriétés qui caractérisent un certain ensemble d'objets (en considérant les méthodes et les champs en Java, ou les membres en C++, comme des propriétés). Une classe est abstraite par opposition à un membre particulier d'un ensemble d'objets qu'elle décrit. Par exemple, la classe <code>Employee</code> pourrait représenter l'ensemble de tous les employés.</li>
-  <li>Une <em>instance</em>, par contre, est l'instanciation d'une classe. Par exemple, <code>Victoria</code> pourrait être une instance de la classe <code>Employee</code>, représentant un individu particulier en tant qu'employé. Une instance possède exactement les mêmes propriétés que sa classe parente (ni plus, ni moins).</li>
-</ul>
+- Une _classe_ définit toutes les propriétés qui caractérisent un certain ensemble d'objets (en considérant les méthodes et les champs en Java, ou les membres en C++, comme des propriétés). Une classe est abstraite par opposition à un membre particulier d'un ensemble d'objets qu'elle décrit. Par exemple, la classe `Employee` pourrait représenter l'ensemble de tous les employés.
+- Une _instance_, par contre, est l'instanciation d'une classe. Par exemple, `Victoria` pourrait être une instance de la classe `Employee`, représentant un individu particulier en tant qu'employé. Une instance possède exactement les mêmes propriétés que sa classe parente (ni plus, ni moins).
 
-<p>Un langage basé sur des prototypes, tel que JavaScript, ne fait pas cette distinction : il a des objets. Un langage basé sur des prototypes possède la notion d'un <em>objet prototypique</em>, un objet utilisé comme modèle à partir duquel on peut obtenir les propriétés initiales d'un nouvel objet. Tout objet peut spécifier ses propres propriétés, soit lors de sa création, soit au moment de l'exécution. En outre, tout objet peut être associé en tant que <em>prototype</em> d'un autre objet, permettant au second objet de partager les propriétés du premier.</p>
+Un langage basé sur des prototypes, tel que JavaScript, ne fait pas cette distinction : il a des objets. Un langage basé sur des prototypes possède la notion d'un _objet prototypique_, un objet utilisé comme modèle à partir duquel on peut obtenir les propriétés initiales d'un nouvel objet. Tout objet peut spécifier ses propres propriétés, soit lors de sa création, soit au moment de l'exécution. En outre, tout objet peut être associé en tant que _prototype_ d'un autre objet, permettant au second objet de partager les propriétés du premier.
 
-<h3 id="defining_a_class">La définition d'une classe</h3>
+### La définition d'une classe
 
-<p>Dans les langages basés sur les classes, vous définissez une classe en utilisant une <em>définition de classe</em> distincte. Dans cette définition, vous pouvez spécifier des méthodes spéciales, appelées <em>constructeur</em> (et écrites « constructor »), pour créer des instances de la classe. Une méthode constructrice peut spécifier des valeurs initiales pour les propriétés de l'instance et effectuer d'autres traitements appropriés au moment de la création. Vous utilisez l'opérateur <code>new</code> en association avec la méthode constructrice pour créer des instances de la classe.</p>
+Dans les langages basés sur les classes, vous définissez une classe en utilisant une _définition de classe_ distincte. Dans cette définition, vous pouvez spécifier des méthodes spéciales, appelées _constructeur_ (et écrites « constructor »), pour créer des instances de la classe. Une méthode constructrice peut spécifier des valeurs initiales pour les propriétés de l'instance et effectuer d'autres traitements appropriés au moment de la création. Vous utilisez l'opérateur `new` en association avec la méthode constructrice pour créer des instances de la classe.
 
-<p>JavaScript suit un modèle similaire, mais ne dispose pas d'une définition de classe distincte de celle du constructeur. Au lieu de cela, vous définissez une fonction de construction pour créer des objets avec un ensemble initial particulier de propriétés et de valeurs. Toute fonction JavaScript peut être utilisée comme constructeur. Vous utilisez l'opérateur <code>new</code> avec une fonction « constructor » pour créer un nouvel objet.</p>
+JavaScript suit un modèle similaire, mais ne dispose pas d'une définition de classe distincte de celle du constructeur. Au lieu de cela, vous définissez une fonction de construction pour créer des objets avec un ensemble initial particulier de propriétés et de valeurs. Toute fonction JavaScript peut être utilisée comme constructeur. Vous utilisez l'opérateur `new` avec une fonction « constructor » pour créer un nouvel objet.
 
-<div class="note">
-  <p><strong>Note :</strong> ECMAScript 2015 introduit une <a href="/fr/docs/Web/JavaScript/Reference/Classes">déclaration de classe</a> :</p>
-  
-  <blockquote>
-    <p>Les classes JavaScript, introduites dans ECMAScript 2015, sont principalement un enrichissement syntaxique de l'héritage basé sur les prototypes existant dans JavaScript. La syntaxe des classes n'introduit pas un nouveau modèle d'héritage orienté objet dans JavaScript.</p>
-  </blockquote>
-</div>
+> **Note :** ECMAScript 2015 introduit une [déclaration de classe](/fr/docs/Web/JavaScript/Reference/Classes) :
+>
+> > Les classes JavaScript, introduites dans ECMAScript 2015, sont principalement un enrichissement syntaxique de l'héritage basé sur les prototypes existant dans JavaScript. La syntaxe des classes n'introduit pas un nouveau modèle d'héritage orienté objet dans JavaScript.
 
-<h3 id="subclasses_and_inheritance">Classes enfants et héritage</h3>
+### Classes enfants et héritage
 
-<p>Dans un langage basé sur les classes, vous créez une hiérarchie de classes par le biais des définitions de classes. Dans une définition de classe, vous pouvez spécifier que la nouvelle classe est une <em>classe enfant</em> d'une classe déjà existante. La classe enfant hérite de toutes les propriétés de la classe parente et peut en plus ajouter de nouvelles propriétés ou modifier celles héritées. Par exemple, supposons que la classe <code>Employee</code> ne comprend que les propriétés <code>name</code> (« nom ») et <code>dept</code> (« département »), et que <code>Manager</code> est une classe enfant de <code>Employee</code> qui ajoute la propriété <code>reports</code> (« rapports »). Dans ce cas, une instance de la classe <code>Manager</code> aurait les trois propriétés : <code>name</code>, <code>dept</code>, et <code>reports</code>.</p>
+Dans un langage basé sur les classes, vous créez une hiérarchie de classes par le biais des définitions de classes. Dans une définition de classe, vous pouvez spécifier que la nouvelle classe est une _classe enfant_ d'une classe déjà existante. La classe enfant hérite de toutes les propriétés de la classe parente et peut en plus ajouter de nouvelles propriétés ou modifier celles héritées. Par exemple, supposons que la classe `Employee` ne comprend que les propriétés `name` (« nom ») et `dept` (« département »), et que `Manager` est une classe enfant de `Employee` qui ajoute la propriété `reports` (« rapports »). Dans ce cas, une instance de la classe `Manager` aurait les trois propriétés : `name`, `dept`, et `reports`.
 
-<p>JavaScript met en œuvre l'héritage en vous permettant d'associer un objet prototypique à n'importe quelle fonction de construction. Ainsi, vous pouvez créer exactement l'exemple <code>Employee</code> — <code>Manager</code>, mais vous utilisez une terminologie légèrement différente. D'abord, vous définissez la fonction du constructeur <code>Employee</code>, en spécifiant les propriétés <code>name</code> et <code>dept</code>. Ensuite, vous définissez la fonction du constructeur <code>Manager</code>, en appelant le constructeur <code>Employee</code> et en spécifiant la propriété <code>reports</code>. Enfin, vous attribuez un nouvel objet dérivé de <code>Employee.prototype</code> comme <code>prototype</code> pour la fonction du constructeur <code>Manager</code>. Ensuite, lorsque vous créez un nouveau <code>Manager</code>, il hérite des propriétés <code>name</code> et <code>dept</code> de l'objet <code>Employee</code>.</p>
+JavaScript met en œuvre l'héritage en vous permettant d'associer un objet prototypique à n'importe quelle fonction de construction. Ainsi, vous pouvez créer exactement l'exemple `Employee` — `Manager`, mais vous utilisez une terminologie légèrement différente. D'abord, vous définissez la fonction du constructeur `Employee`, en spécifiant les propriétés `name` et `dept`. Ensuite, vous définissez la fonction du constructeur `Manager`, en appelant le constructeur `Employee` et en spécifiant la propriété `reports`. Enfin, vous attribuez un nouvel objet dérivé de `Employee.prototype` comme `prototype` pour la fonction du constructeur `Manager`. Ensuite, lorsque vous créez un nouveau `Manager`, il hérite des propriétés `name` et `dept` de l'objet `Employee`.
 
-<h3 id="adding_and_removing_properties">Ajouter ou retirer des propriétés</h3>
+### Ajouter ou retirer des propriétés
 
-<p>Dans les langages basés sur les classes, vous créez généralement une classe au moment de la compilation, puis vous instanciez, des instances de la classe, soit au moment de la compilation, soit au moment de l'exécution. Vous ne pouvez pas modifier le nombre ou le type de propriétés d'une classe après avoir défini cette dernière. En JavaScript, cependant, au moment de l'exécution, vous pouvez ajouter ou supprimer des propriétés de tout objet. Si vous ajoutez une propriété à un objet qui est utilisé comme prototype pour un ensemble d'objets, les objets dont il est le prototype obtiennent également la nouvelle propriété.</p>
+Dans les langages basés sur les classes, vous créez généralement une classe au moment de la compilation, puis vous instanciez, des instances de la classe, soit au moment de la compilation, soit au moment de l'exécution. Vous ne pouvez pas modifier le nombre ou le type de propriétés d'une classe après avoir défini cette dernière. En JavaScript, cependant, au moment de l'exécution, vous pouvez ajouter ou supprimer des propriétés de tout objet. Si vous ajoutez une propriété à un objet qui est utilisé comme prototype pour un ensemble d'objets, les objets dont il est le prototype obtiennent également la nouvelle propriété.
 
-<h3 id="summary_of_differences">Résumé des différences</h3>
+### Résumé des différences
 
-<p>Le tableau suivant donne un bref résumé de certaines de ces différences. Le reste de ce chapitre décrit les détails de l'utilisation des constructeurs et prototypes JavaScript pour créer une hiérarchie d'objets et les compare à la façon dont vous le feriez en Java.</p>
+Le tableau suivant donne un bref résumé de certaines de ces différences. Le reste de ce chapitre décrit les détails de l'utilisation des constructeurs et prototypes JavaScript pour créer une hiérarchie d'objets et les compare à la façon dont vous le feriez en Java.
 
 <table class="standard-table">
-  <caption>Comparaison des systèmes d'objets basés sur des classes (Java) et des prototypes (JavaScript)</caption>
+  <caption>
+    Comparaison des systèmes d'objets basés sur des classes (Java) et des
+    prototypes (JavaScript)
+  </caption>
   <thead>
     <tr>
       <th scope="row">Catégorie</th>
@@ -71,8 +68,14 @@ original_slug: Web/JavaScript/Guide/Le_modèle_objet_JavaScript_en_détails
     </tr>
     <tr>
       <th scope="row">Définition</th>
-      <td>Définir une classe avec une définition de classe ; instancier une classe avec des méthodes de construction.</td>
-      <td>Définir et créer un ensemble d'objets avec des fonctions de construction.</td>
+      <td>
+        Définir une classe avec une définition de classe ; instancier une classe
+        avec des méthodes de construction.
+      </td>
+      <td>
+        Définir et créer un ensemble d'objets avec des fonctions de
+        construction.
+      </td>
     </tr>
     <tr>
       <th scope="row">Création d'un nouvel objet</th>
@@ -81,8 +84,14 @@ original_slug: Web/JavaScript/Guide/Le_modèle_objet_JavaScript_en_détails
     </tr>
     <tr>
       <th scope="row">Construction de la hiérarchie des objets</th>
-      <td>Construire une hiérarchie d'objets en utilisant des définitions de classes pour définir des classes enfants à partir de classes existantes.</td>
-      <td>Construire une hiérarchie d'objets en assignant un objet comme prototype associé à une fonction de construction.</td>
+      <td>
+        Construire une hiérarchie d'objets en utilisant des définitions de
+        classes pour définir des classes enfants à partir de classes existantes.
+      </td>
+      <td>
+        Construire une hiérarchie d'objets en assignant un objet comme prototype
+        associé à une fonction de construction.
+      </td>
     </tr>
     <tr>
       <th scope="row">Modèle d'héritage</th>
@@ -91,66 +100,80 @@ original_slug: Web/JavaScript/Guide/Le_modèle_objet_JavaScript_en_détails
     </tr>
     <tr>
       <th scope="row">Extension des propriétés</th>
-      <td>La définition de la classe spécifie <em>toutes</em> les propriétés de toutes les instances d'une classe. Impossible d'ajouter des propriétés dynamiquement au moment de l'exécution.</td>
-      <td>La fonction ou le prototype du constructeur spécifie un <em>ensemble initial</em> de propriétés. On peut ajouter ou supprimer dynamiquement des propriétés à des objets individuels ou à l'ensemble des objets.</td>
+      <td>
+        La définition de la classe spécifie <em>toutes</em> les propriétés de
+        toutes les instances d'une classe. Impossible d'ajouter des propriétés
+        dynamiquement au moment de l'exécution.
+      </td>
+      <td>
+        La fonction ou le prototype du constructeur spécifie un
+        <em>ensemble initial</em> de propriétés. On peut ajouter ou supprimer
+        dynamiquement des propriétés à des objets individuels ou à l'ensemble
+        des objets.
+      </td>
     </tr>
   </tbody>
 </table>
 
-<h2 id="the_employee_example">L'exemple de l'employé</h2>
+## L'exemple de l'employé
 
-<p>Le reste de ce chapitre utilise la hiérarchie des employés présentée dans la figure suivante.</p>
+Le reste de ce chapitre utilise la hiérarchie des employés présentée dans la figure suivante.
 
-<p><img alt="" src="figure8.1.png"></p>
+![](figure8.1.png)
 
-<p>Cela montre une hiérarchie d'objets avec les objets suivants :</p>
+Cela montre une hiérarchie d'objets avec les objets suivants :
 
-<ul>
-  <li><code>Employee</code> possède les propriétés <code>name</code> (« le nom » dont la valeur par défaut est la chaîne de caractères vide) et <code>dept</code> (« le département » dont la valeur par défaut est « général »).</li>
-  <li><code>Manager</code> est basé sur <code>Employee</code>. Il ajoute la propriété <code>reports</code> (« les rapports » dont la valeur par défaut est un tableau vide, destiné à avoir pour valeur un tableau d'objets <code>Employee</code>).</li>
-  <li><code>WorkerBee</code> est également basé sur <code>Employee</code>. Il ajoute la propriété <code>projects</code> (« les projets » dont la valeur par défaut est un tableau vide, destiné à avoir pour valeur un tableau de chaînes de caractères).</li>
-  <li><code>SalesPerson</code> est basé sur <code>WorkerBee</code>. Il ajoute la propriété <code>quota</code> (dont la valeur par défaut est 100). Il surcharge la propriété <code>dept</code> avec la valeur « ventes », indiquant que tous les vendeurs sont dans le même département.</li>
-  <li><code>Engineer</code> est basé sur <code>WorkerBee</code>. Il ajoute la propriété <code>machine</code> (dont la valeur par défaut est une chaîne de caractères vide) et surcharge également la propriété <code>dept</code> avec la valeur «&nbsp;ingénierie&nbsp;».</li>
-</ul>
+- `Employee` possède les propriétés `name` (« le nom » dont la valeur par défaut est la chaîne de caractères vide) et `dept` (« le département » dont la valeur par défaut est « général »).
+- `Manager` est basé sur `Employee`. Il ajoute la propriété `reports` (« les rapports » dont la valeur par défaut est un tableau vide, destiné à avoir pour valeur un tableau d'objets `Employee`).
+- `WorkerBee` est également basé sur `Employee`. Il ajoute la propriété `projects` (« les projets » dont la valeur par défaut est un tableau vide, destiné à avoir pour valeur un tableau de chaînes de caractères).
+- `SalesPerson` est basé sur `WorkerBee`. Il ajoute la propriété `quota` (dont la valeur par défaut est 100). Il surcharge la propriété `dept` avec la valeur « ventes », indiquant que tous les vendeurs sont dans le même département.
+- `Engineer` est basé sur `WorkerBee`. Il ajoute la propriété `machine` (dont la valeur par défaut est une chaîne de caractères vide) et surcharge également la propriété `dept` avec la valeur « ingénierie ».
 
-<h2 id="creating_the_hierarchy">La création de la hiérarchie</h2>
+## La création de la hiérarchie
 
-<p>Il existe plusieurs façons de définir des fonctions constructrices appropriées pour mettre en œuvre la hiérarchie des employés. La façon dont vous choisissez de les définir dépend en grande partie de ce que vous voulez être en mesure de faire dans votre application.</p>
+Il existe plusieurs façons de définir des fonctions constructrices appropriées pour mettre en œuvre la hiérarchie des employés. La façon dont vous choisissez de les définir dépend en grande partie de ce que vous voulez être en mesure de faire dans votre application.
 
-<p>Cette section montre comment utiliser des définitions très simples (et comparativement peu flexibles) pour démontrer comment faire fonctionner l'héritage. Dans ces définitions, vous ne pouvez spécifier aucune valeur de propriété lorsque vous créez un objet. L'objet nouvellement créé reçoit les valeurs par défaut, que vous pouvez modifier ultérieurement.</p>
+Cette section montre comment utiliser des définitions très simples (et comparativement peu flexibles) pour démontrer comment faire fonctionner l'héritage. Dans ces définitions, vous ne pouvez spécifier aucune valeur de propriété lorsque vous créez un objet. L'objet nouvellement créé reçoit les valeurs par défaut, que vous pouvez modifier ultérieurement.
 
-<p>Dans une application réelle, vous définiriez probablement des constructeurs qui vous permettent de fournir des valeurs de propriété au moment de la création de l'objet (voir <a href="#more_flexible_constructors">Des constructeurs plus flexibles</a> pour plus d'informations). Pour l'instant, ces définitions simples démontrent comment l'héritage se produit.</p>
+Dans une application réelle, vous définiriez probablement des constructeurs qui vous permettent de fournir des valeurs de propriété au moment de la création de l'objet (voir [Des constructeurs plus flexibles](#more_flexible_constructors) pour plus d'informations). Pour l'instant, ces définitions simples démontrent comment l'héritage se produit.
 
-<p>Les définitions suivantes en Java et en JavaScript de <code>Employee</code> sont similaires. La seule différence est que vous devez spécifier le type de chaque propriété en Java mais pas en JavaScript (ceci est dû au fait que Java est un <a href="https://en.wikipedia.org/wiki/Strong_and_weak_typing">langage fortement typé</a> <small>(en anglais)</small> alors que JavaScript est un langage faiblement typé).</p>
+Les définitions suivantes en Java et en JavaScript de `Employee` sont similaires. La seule différence est que vous devez spécifier le type de chaque propriété en Java mais pas en JavaScript (ceci est dû au fait que Java est un [langage fortement typé](https://en.wikipedia.org/wiki/Strong_and_weak_typing) (en anglais) alors que JavaScript est un langage faiblement typé).
 
-<h4 id="javascript_using_this_may_cause_an_error_for_the_following_examples">JavaScript (l'utilisation de cette option peut provoquer une erreur pour les exemples suivants)</h4>
+#### JavaScript (l'utilisation de cette option peut provoquer une erreur pour les exemples suivants)
 
-<pre class="brush: js">class Employee {
+```js
+class Employee {
   constructor() {
     this.name = '';
     this.dept = 'général';
   }
-}</pre>
+}
+```
 
-<h4 id="javascript_**_use_this_instead">JavaScript ** (utilisez plutôt ceci)</h4>
+#### JavaScript \*\* (utilisez plutôt ceci)
 
-<pre class="brush: js">function Employee() {
+```js
+function Employee() {
     this.name = '';
     this.dept = 'général';
-}</pre>
+}
+```
 
-<h4 id="java">Java</h4>
+#### Java
 
-<pre class="brush: java">public class Employee {
+```java
+public class Employee {
    public String name = "";
    public String dept = "général";
-}</pre>
+}
+```
 
-<p>Les définitions de <code>Manager</code> et de <code>WorkerBee</code> montrent la différence dans la façon de spécifier l'objet immédiatement supérieur dans la chaîne d'héritage. En JavaScript, vous ajoutez une instance prototypique comme valeur de la propriété <code>prototype</code> de la fonction du constructeur, puis vous surchargez le <code>prototype.constructor</code> de la fonction du constructeur. Vous pouvez le faire à tout moment après avoir défini le constructeur. En Java, vous spécifiez la superclasse dans la définition de la classe. Vous ne pouvez pas modifier la superclasse en dehors de la définition de la classe.</p>
+Les définitions de `Manager` et de `WorkerBee` montrent la différence dans la façon de spécifier l'objet immédiatement supérieur dans la chaîne d'héritage. En JavaScript, vous ajoutez une instance prototypique comme valeur de la propriété `prototype` de la fonction du constructeur, puis vous surchargez le `prototype.constructor` de la fonction du constructeur. Vous pouvez le faire à tout moment après avoir défini le constructeur. En Java, vous spécifiez la superclasse dans la définition de la classe. Vous ne pouvez pas modifier la superclasse en dehors de la définition de la classe.
 
-<h4 id="javascript">JavaScript</h4>
+#### JavaScript
 
-<pre class="brush: js">function Manager() {
+```js
+function Manager() {
   Employee.call(this); // On étend l'objet parent
   this.reports = []; // On définit une propriété unique à Manager
 }
@@ -163,11 +186,12 @@ function WorkerBee() {
 }
 WorkerBee.prototype = Object.create(Employee.prototype); // On définit le constructeur dans prototype
 WorkerBee.prototype.constructor = WorkerBee; // On surchage le constructeur
-</pre>
+```
 
-<h4 id="java_2">Java</h4>
+#### Java
 
-<pre class="brush: java">// La classe Manager étend la classe parente Employee
+```java
+// La classe Manager étend la classe parente Employee
 public class Manager extends Employee {
    public Employee[] reports = new Employee[0]; // On définit une propriété unique à Manager
 }
@@ -176,13 +200,14 @@ public class Manager extends Employee {
 public class WorkerBee extends Employee {
    public String[] projects = new String[0]; // On définit une propriété unique à WorkerBee
 }
-</pre>
+```
 
-<p>Les définitions <code>Engineer</code> et <code>SalesPerson</code> créent des objets qui descendent de <code>WorkerBee</code> et donc de <code>Employee</code>. Un objet de ces types possède les propriétés de tous les objets situés au-dessus de lui dans la hiérarchie. En outre, ces définitions remplacent la valeur héritée de la propriété <code>dept</code> par de nouvelles valeurs spécifiques à ces objets.</p>
+Les définitions `Engineer` et `SalesPerson` créent des objets qui descendent de `WorkerBee` et donc de `Employee`. Un objet de ces types possède les propriétés de tous les objets situés au-dessus de lui dans la hiérarchie. En outre, ces définitions remplacent la valeur héritée de la propriété `dept` par de nouvelles valeurs spécifiques à ces objets.
 
-<h4 id="javascript_2">JavaScript</h4>
+#### JavaScript
 
-<pre class="brush: js">function SalesPerson() {
+```js
+function SalesPerson() {
    WorkerBee.call(this); // On étend l'objet WorkerBee
    this.dept = 'ventes'; // On réécrit la valeur de « dept »
    this.quota = 100; // On ajoute une propriété unique à SalesPerson
@@ -196,11 +221,13 @@ function Engineer() {
    this.machine = ''; // On ajoute une propriété unique à Engineer
 }
 Engineer.prototype = Object.create(WorkerBee.prototype);
-Engineer.prototype.constructor = Engineer;</pre>
+Engineer.prototype.constructor = Engineer;
+```
 
-<h4 id="java_3">Java</h4>
+#### Java
 
-<pre class="brush: java">// La classe a pour classe parente WorkerBee
+```java
+// La classe a pour classe parente WorkerBee
 public class SalesPerson extends WorkerBee {
    public String dept = "ventes"; // On réécrit la valeur de « dept »
    public double quota = 100.0; // On ajoute une propriété unique à SalesPerson
@@ -210,25 +237,25 @@ public class SalesPerson extends WorkerBee {
 public class Engineer extends WorkerBee {
    public String dept = "ingénierie"; // On réécrit la valeur de « dept »
    public String machine = ""; // On ajoute une propriété unique à Engineer
-}</pre>
+}
+```
 
-<p>À l'aide de ces définitions, vous pouvez créer des instances de ces objets qui obtiennent les valeurs par défaut de leurs propriétés. La figure suivante illustre l'utilisation de ces définitions JavaScript pour créer de nouveaux objets et montre les valeurs des propriétés de ces nouveaux objets.</p>
+À l'aide de ces définitions, vous pouvez créer des instances de ces objets qui obtiennent les valeurs par défaut de leurs propriétés. La figure suivante illustre l'utilisation de ces définitions JavaScript pour créer de nouveaux objets et montre les valeurs des propriétés de ces nouveaux objets.
 
-<div class="note">
-  <p><strong>Note :</strong> Le terme <em>instance</em> a une signification technique spécifique dans les langages basés sur les classes. Dans ces langages, une instance est une instanciation individuelle d'une classe et est fondamentalement différente d'une classe. En JavaScript, « instance » n'a pas cette signification technique car JavaScript ne fait pas cette différence entre classes et instances. Toutefois, en parlant de JavaScript, le terme « instance » peut être utilisé de manière informelle pour désigner un objet créé à l'aide d'une fonction de construction particulière. Ainsi, dans cet exemple, vous pourriez dire de manière informelle que <code>jane</code> est une instance de <code>Engineer</code>. De même, bien que les termes <i>parent</i> (« Parent »), <i>child</i> (« Enfant »), <i>ancestor</i> (« Ancêtre ») et <i>descendant</i> (« Descendant ») n'aient pas de signification formelle en JavaScript ; vous pouvez les utiliser de manière informelle pour vous référer à des objets supérieurs ou inférieurs dans la chaîne des prototypes.</p>
-</div>
+> **Note :** Le terme _instance_ a une signification technique spécifique dans les langages basés sur les classes. Dans ces langages, une instance est une instanciation individuelle d'une classe et est fondamentalement différente d'une classe. En JavaScript, « instance » n'a pas cette signification technique car JavaScript ne fait pas cette différence entre classes et instances. Toutefois, en parlant de JavaScript, le terme « instance » peut être utilisé de manière informelle pour désigner un objet créé à l'aide d'une fonction de construction particulière. Ainsi, dans cet exemple, vous pourriez dire de manière informelle que `jane` est une instance de `Engineer`. De même, bien que les termes _parent_ (« Parent »), _child_ (« Enfant »), _ancestor_ (« Ancêtre ») et _descendant_ (« Descendant ») n'aient pas de signification formelle en JavaScript ; vous pouvez les utiliser de manière informelle pour vous référer à des objets supérieurs ou inférieurs dans la chaîne des prototypes.
 
-<h3 id="creating_objects_with_simple_definitions">Création d'objets avec des définitions simples</h3>
+### Création d'objets avec des définitions simples
 
-<h4 id="object_hierarchy">Hiérarchie des objets</h4>
+#### Hiérarchie des objets
 
-<p>La hiérarchie suivante est créée à l'aide du code situé ci-dessous.</p>
+La hiérarchie suivante est créée à l'aide du code situé ci-dessous.
 
-<p><img src="figure8.3.png"></p>
+![](figure8.3.png)
 
-<h4 id="individual_objects_jim_sally_mark_fred_jane_etc._instances_created_from_constructor">Objets individuels = Jim, Sally, Mark, Fred, Jane, etc.<br>« Instances » créées à partir du constructeur</h4>
+#### Objets individuels = Jim, Sally, Mark, Fred, Jane, etc.<br>« Instances » créées à partir du constructeur
 
-<pre class="brush: js">let jim = new Employee;
+```js
+let jim = new Employee;
 // Les parenthèses peuvent être omises si
 // le constructeur ne prend pas d'arguments.
 // jim.name correspond à ''
@@ -255,65 +282,78 @@ let jane = new Engineer;
 // jane.dept correspond à 'ingénierie'
 // jane.projects correspond à []
 // jane.machine correspond à ''
-</pre>
+```
 
-<h2 id="object_properties">Les propriétés d'un objet</h2>
+## Les propriétés d'un objet
 
-<p>Cette section explique comment les objets héritent des propriétés d'autres objets dans la chaîne des prototypes et ce qui se passe lorsque vous ajoutez une propriété au moment de l'exécution.</p>
+Cette section explique comment les objets héritent des propriétés d'autres objets dans la chaîne des prototypes et ce qui se passe lorsque vous ajoutez une propriété au moment de l'exécution.
 
-<h3 id="inheriting_properties">L'héritage de propriétés</h3>
+### L'héritage de propriétés
 
-<p>Supposons que vous créez l'objet <code>mark</code> comme un <code>WorkerBee</code> avec l'instruction suivante :</p>
+Supposons que vous créez l'objet `mark` comme un `WorkerBee` avec l'instruction suivante :
 
-<pre class="brush: js">let mark = new WorkerBee;</pre>
+```js
+let mark = new WorkerBee;
+```
 
-<p>Lorsque JavaScript voit l'opérateur <code>new</code>, il crée un nouvel objet générique et définit implicitement la valeur de la propriété interne [[Prototype]] à la valeur de <code>WorkerBee.prototype</code> et passe ce nouvel objet comme valeur du mot-clé <em><code>this</code></em> à la fonction du constructeur <code>WorkerBee</code>. La propriété interne [[Prototype]] détermine la chaîne de prototypes utilisée pour retourner les valeurs des propriétés. Une fois ces propriétés définies, JavaScript renvoie le nouvel objet et l'instruction d'affectation définit la variable <code>mark</code> à cet objet.</p>
+Lorsque JavaScript voit l'opérateur `new`, il crée un nouvel objet générique et définit implicitement la valeur de la propriété interne \[\[Prototype]] à la valeur de `WorkerBee.prototype` et passe ce nouvel objet comme valeur du mot-clé _`this`_ à la fonction du constructeur `WorkerBee`. La propriété interne \[\[Prototype]] détermine la chaîne de prototypes utilisée pour retourner les valeurs des propriétés. Une fois ces propriétés définies, JavaScript renvoie le nouvel objet et l'instruction d'affectation définit la variable `mark` à cet objet.
 
-<p>Ce processus ne met pas explicitement des valeurs dans l'objet <code>mark</code> (valeurs <em>locales</em>) pour les propriétés que <code>mark</code> hérite de la chaîne de prototypes. Lorsque vous demandez la valeur d'une propriété, JavaScript vérifie d'abord si la valeur existe dans cet objet. Si c'est le cas, cette valeur est retournée. Si la valeur n'existe pas localement, JavaScript vérifie la chaîne des prototypes (en utilisant la propriété interne [[Prototype]]). Si un objet de la chaîne des prototypes possède une valeur pour la propriété, cette valeur est renvoyée. Si aucune propriété de ce type n'est trouvée, JavaScript indique que l'objet ne possède pas la propriété. Ainsi, l'objet <code>mark</code> possède les propriétés et valeurs suivantes :</p>
+Ce processus ne met pas explicitement des valeurs dans l'objet `mark` (valeurs _locales_) pour les propriétés que `mark` hérite de la chaîne de prototypes. Lorsque vous demandez la valeur d'une propriété, JavaScript vérifie d'abord si la valeur existe dans cet objet. Si c'est le cas, cette valeur est retournée. Si la valeur n'existe pas localement, JavaScript vérifie la chaîne des prototypes (en utilisant la propriété interne \[\[Prototype]]). Si un objet de la chaîne des prototypes possède une valeur pour la propriété, cette valeur est renvoyée. Si aucune propriété de ce type n'est trouvée, JavaScript indique que l'objet ne possède pas la propriété. Ainsi, l'objet `mark` possède les propriétés et valeurs suivantes :
 
-<pre class="brush: js">mark.name = '';
+```js
+mark.name = '';
 mark.dept = 'général';
-mark.projects = [];</pre>
+mark.projects = [];
+```
 
-<p>L'objet <code>mark</code> se voit attribuer des valeurs locales pour les propriétés <code>name</code> et <code>dept</code> par le constructeur <code>Employee</code>. Une valeur locale lui est attribuée pour la propriété <code>projects</code> par le constructeur <code>WorkerBee</code>. On obtient ainsi l'héritage des propriétés et de leurs valeurs en JavaScript. Certaines subtilités de ce processus sont abordées dans <a href="#property_inheritance_revisited">L'héritage des propriétés, revisité</a>.</p>
+L'objet `mark` se voit attribuer des valeurs locales pour les propriétés `name` et `dept` par le constructeur `Employee`. Une valeur locale lui est attribuée pour la propriété `projects` par le constructeur `WorkerBee`. On obtient ainsi l'héritage des propriétés et de leurs valeurs en JavaScript. Certaines subtilités de ce processus sont abordées dans [L'héritage des propriétés, revisité](#property_inheritance_revisited).
 
-<p>Comme ces constructeurs ne vous permettent pas de fournir des valeurs spécifiques à une instance, ces informations sont génériques. Les valeurs des propriétés sont celles par défaut partagées par tous les nouveaux objets créés à partir de <code>WorkerBee</code>. Vous pouvez, bien sûr, modifier les valeurs de n'importe laquelle de ces propriétés. Ainsi, vous pourriez donner des informations spécifiques pour <code>mark</code> comme suit :</p>
+Comme ces constructeurs ne vous permettent pas de fournir des valeurs spécifiques à une instance, ces informations sont génériques. Les valeurs des propriétés sont celles par défaut partagées par tous les nouveaux objets créés à partir de `WorkerBee`. Vous pouvez, bien sûr, modifier les valeurs de n'importe laquelle de ces propriétés. Ainsi, vous pourriez donner des informations spécifiques pour `mark` comme suit :
 
-<pre class="brush: js">mark.name = 'Mark Eting';
+```js
+mark.name = 'Mark Eting';
 mark.dept = 'admin';
-mark.projects = ['navigateur'];</pre>
+mark.projects = ['navigateur'];
+```
 
-<h3 id="adding_properties">L'ajout de propriétés</h3>
+### L'ajout de propriétés
 
-<p>En JavaScript, vous pouvez ajouter des propriétés à tout objet au moment de l'exécution. Vous n'êtes pas contraint d'utiliser uniquement les propriétés fournies par la fonction du constructeur. Pour ajouter une propriété spécifique à un seul objet, vous attribuez une valeur à l'objet, comme suit :</p>
+En JavaScript, vous pouvez ajouter des propriétés à tout objet au moment de l'exécution. Vous n'êtes pas contraint d'utiliser uniquement les propriétés fournies par la fonction du constructeur. Pour ajouter une propriété spécifique à un seul objet, vous attribuez une valeur à l'objet, comme suit :
 
-<pre class="brush: js">mark.bonus = 3000;</pre>
+```js
+mark.bonus = 3000;
+```
 
-<p>Maintenant, l'objet <code>mark</code> possède une propriété <code>bonus</code>, mais aucun autre objet <code>WorkerBee</code> ne possède cette propriété.</p>
+Maintenant, l'objet `mark` possède une propriété `bonus`, mais aucun autre objet `WorkerBee` ne possède cette propriété.
 
-<p>Si vous ajoutez une nouvelle propriété à un objet qui est utilisé comme prototype pour une fonction du constructeur, vous ajoutez cette propriété à tous les objets qui héritent des propriétés du prototype. Par exemple, vous pouvez ajouter une propriété <code>specialty</code> à tous les employés avec l'instruction suivante :</p>
+Si vous ajoutez une nouvelle propriété à un objet qui est utilisé comme prototype pour une fonction du constructeur, vous ajoutez cette propriété à tous les objets qui héritent des propriétés du prototype. Par exemple, vous pouvez ajouter une propriété `specialty` à tous les employés avec l'instruction suivante :
 
-<pre class="brush: js">Employee.prototype.specialty = 'aucune';</pre>
+```js
+Employee.prototype.specialty = 'aucune';
+```
 
-<p>Dès que JavaScript exécute cette instruction, l'objet <code>mark</code> possède également la propriété <code>specialty</code> avec la valeur <code>"aucune"</code>. La figure suivante montre l'effet de l'ajout de cette propriété au prototype <code>Employee</code>, puis de sa surcharge pour le prototype <code>Engineer</code>.</p>
+Dès que JavaScript exécute cette instruction, l'objet `mark` possède également la propriété `specialty` avec la valeur `"aucune"`. La figure suivante montre l'effet de l'ajout de cette propriété au prototype `Employee`, puis de sa surcharge pour le prototype `Engineer`.
 
-<p><img alt="Ajout de propriétés" src="figure8.4.png"></p>
+![Ajout de propriétés](figure8.4.png)
 
-<h2 id="more_flexible_constructors">Des constructeurs plus flexibles</h2>
+## Des constructeurs plus flexibles
 
-<p>Les fonctions correctrices présentées jusqu'à présent ne vous permettent pas de spécifier les valeurs des propriétés lorsque vous créez une instance. Comme avec Java, vous pouvez fournir des arguments aux constructeurs pour initialiser les valeurs des propriétés des instances. La figure suivante montre une façon de le faire.</p>
+Les fonctions correctrices présentées jusqu'à présent ne vous permettent pas de spécifier les valeurs des propriétés lorsque vous créez une instance. Comme avec Java, vous pouvez fournir des arguments aux constructeurs pour initialiser les valeurs des propriétés des instances. La figure suivante montre une façon de le faire.
 
-<p><img alt="Spécifier des propriétés dans un constructeur, prise 1" src="figure8.5.png"></p>
+![Spécifier des propriétés dans un constructeur, prise 1](figure8.5.png)
 
-<p>Les paires d'exemples suivantes montrent les définitions Java et JavaScript de ces objets.</p>
+Les paires d'exemples suivantes montrent les définitions Java et JavaScript de ces objets.
 
-<pre class="brush: js">// JavaScript
+```js
+// JavaScript
 function Employee(name, dept) {
   this.name = name || ''; // L'argument donné OU la valeur par défaut
   this.dept = dept || 'général'; // L'argument donné OU la valeur par défaut
-}</pre>
+}
+```
 
-<pre class="brush: java">// Java
+```java
+// Java
 public class Employee {
   public String name;
   public String dept;
@@ -330,15 +370,19 @@ public class Employee {
     this.name = name;
     this.dept = dept;
   }
-}</pre>
+}
+```
 
-<pre class="brush: js">// JavaScript
+```js
+// JavaScript
 function WorkerBee(projs) {
   this.projects = projs || []; // L'argument donné OU la valeur par défaut
 }
-WorkerBee.prototype = new Employee;</pre>
+WorkerBee.prototype = new Employee;
+```
 
-<pre class="brush: java">// Java
+```java
+// Java
 public class WorkerBee extends Employee {
    public String[] projects;
    // On assigne une valeur par défaut à la propriété
@@ -349,16 +393,20 @@ public class WorkerBee extends Employee {
    public WorkerBee (String[] projs) {
       projects = projs;
    }
-}</pre>
+}
+```
 
-<pre class="brush: js">// JavaScript
+```js
+// JavaScript
 function Engineer(mach) {
   this.dept = 'engineering'; // On réécrit la valeur de « dept »
   this.machine = mach || ''; // L'argument donné OU la valeur par défaut
 }
-Engineer.prototype = new WorkerBee;</pre>
+Engineer.prototype = new WorkerBee;
+```
 
-<pre class="brush: java">// Java
+```java
+// Java
 public class Engineer extends WorkerBee {
    public String machine;
    public Engineer () {
@@ -369,74 +417,83 @@ public class Engineer extends WorkerBee {
       dept = "engineering"; // On réécrit la valeur de « dept »
       machine = mach; // On assigne l'argument donné à la propriété
    }
-}</pre>
+}
+```
 
-<p>Ces définitions JavaScript utilisent un idiome spécial pour définir les valeurs par défaut :</p>
+Ces définitions JavaScript utilisent un idiome spécial pour définir les valeurs par défaut :
 
-<pre class="brush: js">this.nom = nom || "";</pre>
+```js
+this.nom = nom || "";
+```
 
-<p>L'opérateur logique OU de JavaScript (<code>||</code>) évalue son premier argument. Si cet argument se transforme en vrai, l'opérateur le retourne. Sinon, l'opérateur renvoie la valeur du deuxième argument. Par conséquent, cette ligne de code teste pour voir si <code>name</code> a une valeur utile pour la propriété <code>name</code>. Si c'est le cas, elle définit <code>this.name</code> à cette valeur. Sinon, elle définit <code>this.name</code> à la chaîne de caractères vide. Ce chapitre utilise cet idiome par souci de concision ; cependant, il peut être déroutant au premier abord.</p>
+L'opérateur logique OU de JavaScript (`||`) évalue son premier argument. Si cet argument se transforme en vrai, l'opérateur le retourne. Sinon, l'opérateur renvoie la valeur du deuxième argument. Par conséquent, cette ligne de code teste pour voir si `name` a une valeur utile pour la propriété `name`. Si c'est le cas, elle définit `this.name` à cette valeur. Sinon, elle définit `this.name` à la chaîne de caractères vide. Ce chapitre utilise cet idiome par souci de concision ; cependant, il peut être déroutant au premier abord.
 
-<div class="note">
-  <p><strong>Note :</strong> Cela peut ne pas fonctionner comme prévu si la fonction du constructeur est appelée avec des arguments qui se convertissent en <code>false</code> (comme <code>0</code> (zéro) et la chaîne vide (<code>""</code>)). Dans ce cas, la valeur par défaut sera choisie.</p>
-</div>
+> **Note :** Cela peut ne pas fonctionner comme prévu si la fonction du constructeur est appelée avec des arguments qui se convertissent en `false` (comme `0` (zéro) et la chaîne vide (`""`)). Dans ce cas, la valeur par défaut sera choisie.
 
-<p>Avec ces définitions, lorsque vous créez une instance d'un objet, vous pouvez spécifier des valeurs pour les propriétés définies localement. Vous pouvez utiliser l'instruction suivante pour créer un nouvel <code>Engineer</code> :</p>
+Avec ces définitions, lorsque vous créez une instance d'un objet, vous pouvez spécifier des valeurs pour les propriétés définies localement. Vous pouvez utiliser l'instruction suivante pour créer un nouvel `Engineer` :
 
-<pre class="brush: js">let jane = new Engineer('belau');</pre>
+```js
+let jane = new Engineer('belau');
+```
 
-<p>Les propriétés de <code>Jane</code> sont maintenant :</p>
+Les propriétés de `Jane` sont maintenant :
 
-<pre class="brush: js">jane.name == '';
+```js
+jane.name == '';
 jane.dept == 'engineering';
 jane.projects == [];
-jane.machine == 'belau';</pre>
+jane.machine == 'belau';
+```
 
-<p>Remarquez qu'avec ces définitions, vous ne pouvez pas spécifier une valeur initiale pour une propriété héritée telle que <code>name</code>. Si vous voulez spécifier une valeur initiale pour les propriétés héritées en JavaScript, vous devez ajouter du code supplémentaire à la fonction du constructeur.</p>
+Remarquez qu'avec ces définitions, vous ne pouvez pas spécifier une valeur initiale pour une propriété héritée telle que `name`. Si vous voulez spécifier une valeur initiale pour les propriétés héritées en JavaScript, vous devez ajouter du code supplémentaire à la fonction du constructeur.
 
-<p>Jusqu'à présent, la fonction du constructeur a créé un objet générique, puis a spécifié les propriétés et valeurs locales du nouvel objet. Vous pouvez demander au constructeur d'ajouter d'autres propriétés en appelant directement la fonction du constructeur d'un objet situé plus haut dans la chaîne des prototypes. La figure suivante montre ces nouvelles définitions.</p>
+Jusqu'à présent, la fonction du constructeur a créé un objet générique, puis a spécifié les propriétés et valeurs locales du nouvel objet. Vous pouvez demander au constructeur d'ajouter d'autres propriétés en appelant directement la fonction du constructeur d'un objet situé plus haut dans la chaîne des prototypes. La figure suivante montre ces nouvelles définitions.
 
-<p><img alt="Spécifier des propriétés dans un constructeur, prise 2" src="figure8.6.png"></p>
+![Spécifier des propriétés dans un constructeur, prise 2](figure8.6.png)
 
-<p>Examinons l'une de ces définitions en détails. Voici la nouvelle définition pour le constructeur <code>Engineer</code> :</p>
+Examinons l'une de ces définitions en détails. Voici la nouvelle définition pour le constructeur `Engineer` :
 
-<pre class="brush: js">function Engineer(name, projs, mach) {
+```js
+function Engineer(name, projs, mach) {
   this.base = WorkerBee;
   this.base(name, 'ingénierie', projs);
   this.machine = mach || '';
-}</pre>
+}
+```
 
-<p>Supposons que vous créez un nouvel objet <code>Engineer</code> comme suit :</p>
+Supposons que vous créez un nouvel objet `Engineer` comme suit :
 
-<pre class="brush: js">let jane = new Engineer('Jane Dupont', ['navigateur', 'javascript'], 'belau');
-</pre>
+```js
+let jane = new Engineer('Jane Dupont', ['navigateur', 'javascript'], 'belau');
+```
 
-<p>JavaScript suit les étapes suivantes :</p>
+JavaScript suit les étapes suivantes :
 
-<ol>
-  <li>L'opérateur <code>new</code> crée un objet générique et définit sa propriété <code>__proto__</code> à <code>Engineer.prototype</code>.</li>
-  <li>L'opérateur <code>new</code> transmet le nouvel objet au constructeur <code>Engineer</code> comme valeur du mot clé <code>this</code>.</li>
-  <li>Le constructeur crée une nouvelle propriété appelée <code>base</code> pour cet objet et affecte la valeur du constructeur <code>WorkerBee</code> à la propriété <code>base</code>. Cela fait du constructeur <code>WorkerBee</code> une méthode de l'objet <code>Engineer</code>. Le nom de la propriété <code>base</code> n'est pas spécial. Vous pouvez utiliser n'importe quel nom de propriété légal ; <code>base</code> est évocateur de son but.</li>
-  <li>Le constructeur appelle la méthode <code>base</code>, en passant comme arguments deux des arguments passés au constructeur (<code>"Jane Dupont"</code> et <code>["navigateur", "javascript"]</code>) et également la chaîne <code>"ingénierie"</code>. L'utilisation explicite de <code>"ingénierie"</code> dans le constructeur indique que tous les objets <code>Engineer</code> ont la même valeur pour la propriété <code>dept</code> héritée, et cette valeur remplace la valeur héritée de <code>Employee</code>.</li>
-  <li>Parce que <code>base</code> est une méthode de <code>Engineer</code>, dans l'appel à <code>base</code>, JavaScript lie le mot-clé <code>this</code> à l'objet créé à l'étape 1. Ainsi, la fonction <code>WorkerBee</code> transmet à son tour les arguments <code>"Jane Dupont"</code> et <code>"ingénierie"</code> à la fonction du constructeur <code>Employee</code>. Au retour de la fonction du constructeur <code>Employee</code>, la fonction <code>WorkerBee</code> utilise l'argument restant pour définir la propriété <code>projects</code>.</li>
-  <li>Au retour de la méthode <code>base</code>, le constructeur <code>Engineer</code> initialise la propriété <code>machine</code> de l'objet à <code>"belau"</code>.</li>
-  <li>Au retour du constructeur, JavaScript affecte le nouvel objet à la variable <code>jane</code>.</li>
-</ol>
+1.  L'opérateur `new` crée un objet générique et définit sa propriété `__proto__` à `Engineer.prototype`.
+2.  L'opérateur `new` transmet le nouvel objet au constructeur `Engineer` comme valeur du mot clé `this`.
+3.  Le constructeur crée une nouvelle propriété appelée `base` pour cet objet et affecte la valeur du constructeur `WorkerBee` à la propriété `base`. Cela fait du constructeur `WorkerBee` une méthode de l'objet `Engineer`. Le nom de la propriété `base` n'est pas spécial. Vous pouvez utiliser n'importe quel nom de propriété légal ; `base` est évocateur de son but.
+4.  Le constructeur appelle la méthode `base`, en passant comme arguments deux des arguments passés au constructeur (`"Jane Dupont"` et `["navigateur", "javascript"]`) et également la chaîne `"ingénierie"`. L'utilisation explicite de `"ingénierie"` dans le constructeur indique que tous les objets `Engineer` ont la même valeur pour la propriété `dept` héritée, et cette valeur remplace la valeur héritée de `Employee`.
+5.  Parce que `base` est une méthode de `Engineer`, dans l'appel à `base`, JavaScript lie le mot-clé `this` à l'objet créé à l'étape 1. Ainsi, la fonction `WorkerBee` transmet à son tour les arguments `"Jane Dupont"` et `"ingénierie"` à la fonction du constructeur `Employee`. Au retour de la fonction du constructeur `Employee`, la fonction `WorkerBee` utilise l'argument restant pour définir la propriété `projects`.
+6.  Au retour de la méthode `base`, le constructeur `Engineer` initialise la propriété `machine` de l'objet à `"belau"`.
+7.  Au retour du constructeur, JavaScript affecte le nouvel objet à la variable `jane`.
 
-<p>Vous pourriez penser que, ayant appelé le constructeur <code>WorkerBee</code> à partir de l'intérieur du constructeur <code>Engineer</code>, vous avez mis en place l'héritage de manière appropriée pour les objets <code>Engineer</code>. Ce n'est pas le cas. L'appel du constructeur <code>WorkerBee</code> garantit qu'un objet <code>Engineer</code> commence avec les propriétés spécifiées dans toutes les fonctions des constructeurs qui sont appelées. Cependant, si vous ajoutez ultérieurement des propriétés aux prototypes <code>Employee</code> ou <code>WorkerBee</code>, ces propriétés ne sont pas héritées par l'objet <code>Engineer</code>. Par exemple, supposons que vous ayez les déclarations suivantes :</p>
+Vous pourriez penser que, ayant appelé le constructeur `WorkerBee` à partir de l'intérieur du constructeur `Engineer`, vous avez mis en place l'héritage de manière appropriée pour les objets `Engineer`. Ce n'est pas le cas. L'appel du constructeur `WorkerBee` garantit qu'un objet `Engineer` commence avec les propriétés spécifiées dans toutes les fonctions des constructeurs qui sont appelées. Cependant, si vous ajoutez ultérieurement des propriétés aux prototypes `Employee` ou `WorkerBee`, ces propriétés ne sont pas héritées par l'objet `Engineer`. Par exemple, supposons que vous ayez les déclarations suivantes :
 
-<pre class="brush: js">function Engineer(name, projs, mach) {
+```js
+function Engineer(name, projs, mach) {
   this.base = WorkerBee;
   this.base(name, 'ingénierie', projs);
   this.machine = mach || '';
 }
 
 let jane = new Engineer('Jane Dupont', ['navigateur', 'javascript'], 'belau');
-Employee.prototype.specialty = 'aucune';</pre>
+Employee.prototype.specialty = 'aucune';
+```
 
-<p>L'objet <code>jane</code> n'hérite pas de la propriété <code>specialty</code>. Vous devez encore configurer explicitement le prototype pour assurer un héritage dynamique. Supposons plutôt que vous ayez ces déclarations :</p>
+L'objet `jane` n'hérite pas de la propriété `specialty`. Vous devez encore configurer explicitement le prototype pour assurer un héritage dynamique. Supposons plutôt que vous ayez ces déclarations :
 
-<pre class="brush: js">function Engineer(name, projs, mach) {
+```js
+function Engineer(name, projs, mach) {
   this.base = WorkerBee;
   this.base(name, 'ingénierie', projs);
   this.machine = mach || '';
@@ -444,43 +501,47 @@ Employee.prototype.specialty = 'aucune';</pre>
 
 Engineer.prototype = new WorkerBee;
 let jane = new Engineer('Jane Dupont', ['navigateur', 'javascript'], 'belau');
-Employee.prototype.specialty = 'aucune';</pre>
+Employee.prototype.specialty = 'aucune';
+```
 
-<p>Maintenant la valeur de la propriété <code>jane</code> de l'objet <code>specialty</code> est « aucune ».</p>
+Maintenant la valeur de la propriété `jane` de l'objet `specialty` est « aucune ».
 
-<p>Une autre façon d'hériter est d'utiliser les méthodes <code><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Function/call">call()</a></code> / <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Function/apply"><code>apply()</code></a>. Les méthodes ci-dessous sont équivalentes :</p>
+Une autre façon d'hériter est d'utiliser les méthodes [`call()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Function/call) / [`apply()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Function/apply). Les méthodes ci-dessous sont équivalentes :
 
-<pre class="brush: js">function Engineer(name, projs, mach) {
+```js
+function Engineer(name, projs, mach) {
   this.base = WorkerBee;
   this.base(name, 'ingénierie', projs);
   this.machine = mach || '';
-}</pre>
+}
+```
 
-<pre class="brush: js">function Engineer(name, projs, mach) {
+```js
+function Engineer(name, projs, mach) {
   WorkerBee.call(this, name, 'ingénierie', projs);
   this.machine = mach || '';
-}</pre>
+}
+```
 
-<p>L'utilisation de la méthode JavaScript <code>call()</code> rend une implémentation plus propre car <code>base</code> n'est plus nécessaire.</p>
+L'utilisation de la méthode JavaScript `call()` rend une implémentation plus propre car `base` n'est plus nécessaire.
 
-<h2 id="property_inheritance_revisited">L'héritage des propriétés,  revisité</h2>
+## L'héritage des propriétés, revisité
 
-<p>Les sections précédentes ont décrit comment les constructeurs et prototypes JavaScript fournissent des hiérarchies et de l'héritage. Cette section aborde certaines subtilités qui n'étaient pas nécessairement apparentes dans les discussions précédentes.</p>
+Les sections précédentes ont décrit comment les constructeurs et prototypes JavaScript fournissent des hiérarchies et de l'héritage. Cette section aborde certaines subtilités qui n'étaient pas nécessairement apparentes dans les discussions précédentes.
 
-<h3 id="local_versus_inherited_values">Valeurs locales et valeurs héritées</h3>
+### Valeurs locales et valeurs héritées
 
-<p>Lorsque vous accédez à une propriété d'objet, JavaScript effectue les étapes suivantes, comme décrit précédemment dans ce chapitre :</p>
+Lorsque vous accédez à une propriété d'objet, JavaScript effectue les étapes suivantes, comme décrit précédemment dans ce chapitre :
 
-<ol>
-  <li>Vérifiez si la valeur existe localement. Si c'est le cas, elle est retournée.</li>
-  <li>S'il n'y a pas de valeur locale, vérifiez la chaîne de prototypes (en utilisant la propriété <code>__proto__</code>).</li>
-  <li>Si un objet de la chaîne de prototypes possède une valeur pour la propriété spécifiée, renvoyer cette valeur.</li>
-  <li>Si aucune propriété de ce type n'est trouvée, l'objet ne possède pas cette propriété.</li>
-</ol>
+1.  Vérifiez si la valeur existe localement. Si c'est le cas, elle est retournée.
+2.  S'il n'y a pas de valeur locale, vérifiez la chaîne de prototypes (en utilisant la propriété `__proto__`).
+3.  Si un objet de la chaîne de prototypes possède une valeur pour la propriété spécifiée, renvoyer cette valeur.
+4.  Si aucune propriété de ce type n'est trouvée, l'objet ne possède pas cette propriété.
 
-<p>Le résultat de ces étapes dépend de la façon dont vous définissez les choses en cours de route. L'exemple original avait ces définitions :</p>
+Le résultat de ces étapes dépend de la façon dont vous définissez les choses en cours de route. L'exemple original avait ces définitions :
 
-<pre class="brush: js">function Employee() {
+```js
+function Employee() {
   this.name = '';
   this.dept = 'général';
 }
@@ -488,29 +549,37 @@ Employee.prototype.specialty = 'aucune';</pre>
 function WorkerBee() {
   this.projects = [];
 }
-WorkerBee.prototype = new Employee;</pre>
+WorkerBee.prototype = new Employee;
+```
 
-<p>Avec ces définitions, supposons que vous créez <code>amy</code> comme une instance de <code>WorkerBee</code> avec l'instruction suivante :</p>
+Avec ces définitions, supposons que vous créez `amy` comme une instance de `WorkerBee` avec l'instruction suivante :
 
-<pre class="brush: js">let amy = new WorkerBee;</pre>
+```js
+let amy = new WorkerBee;
+```
 
-<p>L'objet <code>amy</code> possède une propriété locale, <code>projects</code>. Les valeurs des propriétés <code>name</code> et <code>dept</code> ne sont pas locales à <code>amy</code> et héritent donc dans la propriété <code>amy</code> de l'objet <code>__proto__</code>. Ainsi, <code>amy</code> possède ces valeurs de propriétés :</p>
+L'objet `amy` possède une propriété locale, `projects`. Les valeurs des propriétés `name` et `dept` ne sont pas locales à `amy` et héritent donc dans la propriété `amy` de l'objet `__proto__`. Ainsi, `amy` possède ces valeurs de propriétés :
 
-<pre class="brush: js">amy.name == '';
+```js
+amy.name == '';
 amy.dept == 'général';
-amy.projects == [];</pre>
+amy.projects == [];
+```
 
-<p>Supposons maintenant que vous modifiez la valeur de la propriété <code>name</code> dans le prototype associé à <code>Employee</code> :</p>
+Supposons maintenant que vous modifiez la valeur de la propriété `name` dans le prototype associé à `Employee` :
 
-<pre class="brush: js">Employee.prototype.name = 'Inconnu·e';</pre>
+```js
+Employee.prototype.name = 'Inconnu·e';
+```
 
-<p>À première vue, on pourrait s'attendre à ce que cette nouvelle valeur se propage vers le bas à toutes les instances de <code>Employee</code>. Cependant, ce n'est pas le cas.</p>
+À première vue, on pourrait s'attendre à ce que cette nouvelle valeur se propage vers le bas à toutes les instances de `Employee`. Cependant, ce n'est pas le cas.
 
-<p>Lorsque vous créez <em>n'importe quelle</em> instance de l'objet <code>Employee</code>, cette instance obtient une <strong>valeur locale</strong> pour la propriété <code>name</code> (la chaîne de caractères vide). Cela signifie que lorsque vous définissez le prototype de <code>WorkerBee</code> en créant un nouvel objet <code>Employee</code>, <code>WorkerBee.prototype</code> a une valeur locale pour la propriété <code>name</code>. Par conséquent, lorsque JavaScript recherche la propriété <code>name</code> de l'objet <code>amy</code> (une instance de <code>WorkerBee</code>), JavaScript trouve la valeur locale de cette propriété dans <code>WorkerBee.prototype</code>. Il ne cherche donc pas plus haut dans la chaîne jusqu'à <code>Employee.prototype</code>.</p>
+Lorsque vous créez _n'importe quelle_ instance de l'objet `Employee`, cette instance obtient une **valeur locale** pour la propriété `name` (la chaîne de caractères vide). Cela signifie que lorsque vous définissez le prototype de `WorkerBee` en créant un nouvel objet `Employee`, `WorkerBee.prototype` a une valeur locale pour la propriété `name`. Par conséquent, lorsque JavaScript recherche la propriété `name` de l'objet `amy` (une instance de `WorkerBee`), JavaScript trouve la valeur locale de cette propriété dans `WorkerBee.prototype`. Il ne cherche donc pas plus haut dans la chaîne jusqu'à `Employee.prototype`.
 
-<p>Si vous souhaitez modifier la valeur d'une propriété d'un objet au moment de l'exécution et que la nouvelle valeur soit héritée par tous les descendants de l'objet, vous ne pouvez pas définir la propriété dans la fonction du constructeur de l'objet. Vous devez plutôt l'ajouter au prototype associé au constructeur. Par exemple, supposons que vous remplaciez le code précédent par le suivant :</p>
+Si vous souhaitez modifier la valeur d'une propriété d'un objet au moment de l'exécution et que la nouvelle valeur soit héritée par tous les descendants de l'objet, vous ne pouvez pas définir la propriété dans la fonction du constructeur de l'objet. Vous devez plutôt l'ajouter au prototype associé au constructeur. Par exemple, supposons que vous remplaciez le code précédent par le suivant :
 
-<pre class="brush: js">function Employee() {
+```js
+function Employee() {
   this.dept = 'général'; // Notez que this.name (une variable locale) n'apparaît pas ici
 }
 Employee.prototype.name = ''; // Un seul exemplaire
@@ -522,38 +591,46 @@ WorkerBee.prototype = new Employee;
 
 let amy = new WorkerBee;
 
-Employee.prototype.name = 'Inconnu·e';</pre>
+Employee.prototype.name = 'Inconnu·e';
+```
+
+Dans ce cas, la propriété `name` de `amy` devient « Inconnu·e ».
+
+Comme le montrent ces exemples, si vous souhaitez définir des valeurs par défaut pour les propriétés d'un objet et que vous voulez pouvoir modifier ces valeurs au moment de l'exécution, vous devez définir les propriétés dans le prototype du constructeur, et non dans la fonction du constructeur elle-même.
 
-<p>Dans ce cas, la propriété <code>name</code> de <code>amy</code> devient « Inconnu·e ».</p>
+### Déterminer les relations entre les instances
 
-<p>Comme le montrent ces exemples, si vous souhaitez définir des valeurs par défaut pour les propriétés d'un objet et que vous voulez pouvoir modifier ces valeurs au moment de l'exécution, vous devez définir les propriétés dans le prototype du constructeur, et non dans la fonction du constructeur elle-même.</p>
+La recherche de propriétés en JavaScript s'effectue dans les propriétés propres d'un objet et, si le nom de la propriété n'est pas trouvé, elle s'effectue dans la propriété spéciale de l'objet `__proto__`. Cette opération se poursuit de manière récursive ; le processus est appelé « recherche dans la chaîne des prototypes ».
 
-<h3 id="determining_instance_relationships">Déterminer les relations entre les instances</h3>
+La propriété spéciale `__proto__` est définie lorsqu'un objet est construit ; elle prend la valeur de la propriété `prototype` du constructeur. Ainsi, l'expression `new Riri()` crée un objet avec `__proto__ == Riri.prototype`. Par conséquent, les modifications apportées aux propriétés de `Riri.prototype` modifient la recherche de propriétés pour tous les objets qui ont été créés par `new Riri()`.
 
-<p>La recherche de propriétés en JavaScript s'effectue dans les propriétés propres d'un objet et, si le nom de la propriété n'est pas trouvé, elle s'effectue dans la propriété spéciale de l'objet <code>__proto__</code>. Cette opération se poursuit de manière récursive ; le processus est appelé « recherche dans la chaîne des prototypes ».</p>
+Chaque objet a une propriété `__proto__` (sauf `Object`) ; chaque fonction a une propriété `prototype`. Les objets peuvent donc être liés par « héritage de prototype » à d'autres objets. Vous pouvez tester l'héritage en comparant le `__proto__` d'un objet avec l'objet `prototype` d'une fonction. JavaScript fournit un raccourci : l'opérateur `instanceof` teste un objet par rapport à une fonction et renvoie vrai si l'objet hérite du prototype de la fonction. Par exemple,
 
-<p>La propriété spéciale <code>__proto__</code> est définie lorsqu'un objet est construit ; elle prend la valeur de la propriété <code>prototype</code> du constructeur. Ainsi, l'expression <code>new Riri()</code> crée un objet avec <code>__proto__ == Riri.prototype</code>. Par conséquent, les modifications apportées aux propriétés de <code>Riri.prototype</code> modifient la recherche de propriétés pour tous les objets qui ont été créés par <code>new Riri()</code>.</p>
+```js
+let f = new Riri();
+let isTrue = (f instanceof Riri);
+```
 
-<p>Chaque objet a une propriété <code>__proto__</code> (sauf <code>Object</code>) ; chaque fonction a une propriété <code>prototype</code>. Les objets peuvent donc être liés par « héritage de prototype » à d'autres objets. Vous pouvez tester l'héritage en comparant le <code>__proto__</code> d'un objet avec l'objet <code>prototype</code> d'une fonction. JavaScript fournit un raccourci : l'opérateur <code>instanceof</code> teste un objet par rapport à une fonction et renvoie vrai si l'objet hérite du prototype de la fonction. Par exemple,</p>
+Pour un exemple plus détaillé, supposons que vous ayez le même ensemble de définitions que celui présenté dans [Héritage des propriétés](#inheriting_properties). Créez un objet `Engineer` comme suit :
 
-<pre class="brush: js">let f = new Riri();
-let isTrue = (f instanceof Riri);</pre>
-  
-<p>Pour un exemple plus détaillé, supposons que vous ayez le même ensemble de définitions que celui présenté dans <a href="#inheriting_properties">Héritage des propriétés</a>. Créez un objet <code>Engineer</code> comme suit :</p>
-  
-<pre class="brush: js">let chris = new Engineer('Chris Anthème', ['jsd'], 'fiji');</pre>
+```js
+let chris = new Engineer('Chris Anthème', ['jsd'], 'fiji');
+```
 
-<p>Avec cet objet, les affirmations suivantes sont toutes vraies :</p>
+Avec cet objet, les affirmations suivantes sont toutes vraies :
 
-<pre class="brush: js">chris.__proto__ == Engineer.prototype;
+```js
+chris.__proto__ == Engineer.prototype;
 chris.__proto__.__proto__ == WorkerBee.prototype;
 chris.__proto__.__proto__.__proto__ == Employee.prototype;
 chris.__proto__.__proto__.__proto__.__proto__ == Object.prototype;
-chris.__proto__.__proto__.__proto__.__proto__.__proto__ == null;</pre>
+chris.__proto__.__proto__.__proto__.__proto__.__proto__ == null;
+```
 
-<p>Compte tenu de cela, vous pourriez écrire une fonction <code>instanceOf</code> comme suit :</p>
+Compte tenu de cela, vous pourriez écrire une fonction `instanceOf` comme suit :
 
-<pre class="brush: js">function instanceOf(object, constructor) {
+```js
+function instanceOf(object, constructor) {
    object = object.__proto__;
    while (object != null) {
       if (object == constructor.prototype)
@@ -564,43 +641,51 @@ chris.__proto__.__proto__.__proto__.__proto__.__proto__ == null;</pre>
       object = object.__proto__;
    }
    return false;
-}</pre>
+}
+```
 
-<div class="note">
-  <p><strong>Note :</strong> L'implémentation ci-dessus vérifie le type de l'objet par rapport à « xml » afin de contourner une bizarrerie de la façon dont les objets XML sont représentés dans les versions récentes de JavaScript. Voir <a href="https://bugzilla.mozilla.org/show_bug.cgi?id=634150">bug 634150</a> si vous voulez connaître les détails.</p>
-</div>
+> **Note :** L'implémentation ci-dessus vérifie le type de l'objet par rapport à « xml » afin de contourner une bizarrerie de la façon dont les objets XML sont représentés dans les versions récentes de JavaScript. Voir [bug 634150](https://bugzilla.mozilla.org/show_bug.cgi?id=634150) si vous voulez connaître les détails.
 
-<p>En utilisant la fonction <code>instanceOf</code> définie ci-dessus, ces expressions sont vraies :</p>
+En utilisant la fonction `instanceOf` définie ci-dessus, ces expressions sont vraies :
 
-<pre class="brush: js">instanceOf(chris, Engineer)
+```js
+instanceOf(chris, Engineer)
 instanceOf(chris, WorkerBee)
 instanceOf(chris, Employee)
-instanceOf(chris, Object)</pre>
+instanceOf(chris, Object)
+```
 
-<p>Mais l'expression suivante est fausse :</p>
+Mais l'expression suivante est fausse :
 
-<pre class="brush: js">instanceOf(chris, SalesPerson)</pre>
+```js
+instanceOf(chris, SalesPerson)
+```
 
-<h3 id="global_information_in_constructors">Les informations globales dans les constructeurs</h3>
+### Les informations globales dans les constructeurs
 
-<p>Lorsque vous créez des constructeurs, vous devez faire attention si vous définissez des informations globales dans le constructeur. Par exemple, supposons que vous souhaitez qu'un identifiant unique soit automatiquement attribué à chaque nouvel employé. Vous pourriez utiliser la définition suivante pour <code>Employee</code> :</p>
+Lorsque vous créez des constructeurs, vous devez faire attention si vous définissez des informations globales dans le constructeur. Par exemple, supposons que vous souhaitez qu'un identifiant unique soit automatiquement attribué à chaque nouvel employé. Vous pourriez utiliser la définition suivante pour `Employee` :
 
-<pre class="brush: js">let idCounter = 1; // On définit un compteur d'identifiant
+```js
+let idCounter = 1; // On définit un compteur d'identifiant
 
 function Employee(name, dept) {
   this.name = name || '';
   this.dept = dept || 'général';
   this.id = idCounter++; // On assigne la valeur et on incrémente le compteur
-}</pre>
+}
+```
 
-<p>Avec cette définition, lorsque vous créez un nouvel <code>Employee</code>, le constructeur lui attribue l'ID suivant dans la séquence, puis incrémente le compteur d'ID global. Ainsi, si votre déclaration est la suivante, <code>victoria.id</code> vaut 1 et <code>harry.id</code> vaut 2 :</p>
+Avec cette définition, lorsque vous créez un nouvel `Employee`, le constructeur lui attribue l'ID suivant dans la séquence, puis incrémente le compteur d'ID global. Ainsi, si votre déclaration est la suivante, `victoria.id` vaut 1 et `harry.id` vaut 2 :
 
-<pre class="brush: js">let victoria = new Employee('Victoria Lamar', 'pubs');
-let harry = new Employee('Harry Stocrate', 'ventes');</pre>
+```js
+let victoria = new Employee('Victoria Lamar', 'pubs');
+let harry = new Employee('Harry Stocrate', 'ventes');
+```
 
-<p>À première vue, cela semble correct. Cependant, <code>idCounter</code> est incrémenté à chaque fois qu'un objet <code>Employee</code> est créé, pour quelque raison que ce soit. Si vous créez toute la hiérarchie <code>Employee</code> présentée dans ce chapitre, le constructeur <code>Employee</code> est appelé chaque fois que vous mettez en place un prototype. Supposons que vous ayez le code suivant :</p>
+À première vue, cela semble correct. Cependant, `idCounter` est incrémenté à chaque fois qu'un objet `Employee` est créé, pour quelque raison que ce soit. Si vous créez toute la hiérarchie `Employee` présentée dans ce chapitre, le constructeur `Employee` est appelé chaque fois que vous mettez en place un prototype. Supposons que vous ayez le code suivant :
 
-<pre class="brush: js">let idCounter = 1;
+```js
+let idCounter = 1;
 
 function Employee(name, dept) {
   this.name = name || '';
@@ -620,13 +705,15 @@ Engineer.prototype = new WorkerBee;
 function SalesPerson(name, projs, quota) {...}
 SalesPerson.prototype = new WorkerBee;
 
-let mac = new Engineer('Mac Fly');</pre>
+let mac = new Engineer('Mac Fly');
+```
 
-<p>Supposons en outre que les définitions omises ici possèdent la propriété <code>base</code> et appellent le constructeur situé au-dessus d'elles dans la chaîne des prototypes. Dans ce cas, au moment où l'objet <code>mac</code> est créé, <code>mac.id</code> est 5.</p>
+Supposons en outre que les définitions omises ici possèdent la propriété `base` et appellent le constructeur situé au-dessus d'elles dans la chaîne des prototypes. Dans ce cas, au moment où l'objet `mac` est créé, `mac.id` est 5.
 
-<p>Selon l'application, il peut être important ou non que le compteur ait été incrémenté ces fois supplémentaires. Si vous vous souciez de la valeur exacte de ce compteur, une solution possible consiste à utiliser plutôt le constructeur suivant :</p>
+Selon l'application, il peut être important ou non que le compteur ait été incrémenté ces fois supplémentaires. Si vous vous souciez de la valeur exacte de ce compteur, une solution possible consiste à utiliser plutôt le constructeur suivant :
 
-<pre class="brush: js">function Employee(name, dept) {
+```js
+function Employee(name, dept) {
   this.name = name || '';
   this.dept = dept || 'general';
   // Ceci est une écriture raccourcie de l'opérateur if
@@ -635,24 +722,27 @@ let mac = new Engineer('Mac Fly');</pre>
     this.id = idCounter++;
   }
 }
-</pre>
+```
 
-<p>Lorsque vous créez une instance de <code>Employee</code> pour l'utiliser comme prototype, vous ne fournissez pas d'arguments au constructeur. En utilisant cette définition du constructeur, lorsque vous ne fournissez pas d'arguments, le constructeur n'attribue pas de valeur à l'id et ne met pas à jour le compteur. Par conséquent, pour qu'un <code>Employee</code> obtienne un id, vous devez spécifier un nom pour l'employé. Dans cet exemple, <code>mac.id</code> serait 1.</p>
+Lorsque vous créez une instance de `Employee` pour l'utiliser comme prototype, vous ne fournissez pas d'arguments au constructeur. En utilisant cette définition du constructeur, lorsque vous ne fournissez pas d'arguments, le constructeur n'attribue pas de valeur à l'id et ne met pas à jour le compteur. Par conséquent, pour qu'un `Employee` obtienne un id, vous devez spécifier un nom pour l'employé. Dans cet exemple, `mac.id` serait 1.
 
-<p>Vous pouvez également créer une copie de l'objet prototype de l'employé pour l'affecter à WorkerBee :</p>
+Vous pouvez également créer une copie de l'objet prototype de l'employé pour l'affecter à WorkerBee :
 
-<pre class="brush: js">WorkerBee.prototype = Object.create(Employee.prototype);
-// au lieu de WorkerBee.prototype = new Employee</pre>
+```js
+WorkerBee.prototype = Object.create(Employee.prototype);
+// au lieu de WorkerBee.prototype = new Employee
+```
 
-<h3 id="no_multiple_inheritance">Pas d'héritage multiple</h3>
+### Pas d'héritage multiple
 
-<p>Certains langages orientés objets permettent l'héritage multiple. C'est-à-dire qu'un objet peut hériter des propriétés et des valeurs d'objets parents non apparentés. JavaScript ne prend pas en charge l'héritage multiple.</p>
+Certains langages orientés objets permettent l'héritage multiple. C'est-à-dire qu'un objet peut hériter des propriétés et des valeurs d'objets parents non apparentés. JavaScript ne prend pas en charge l'héritage multiple.
 
-<p>L'héritage des valeurs des propriétés se produit au moment de l'exécution, lorsque JavaScript recherche une valeur dans la chaîne de prototypes d'un objet. Comme un objet n'a qu'un seul prototype associé, JavaScript ne peut pas hériter dynamiquement de plus d'une chaîne de prototypes.</p>
+L'héritage des valeurs des propriétés se produit au moment de l'exécution, lorsque JavaScript recherche une valeur dans la chaîne de prototypes d'un objet. Comme un objet n'a qu'un seul prototype associé, JavaScript ne peut pas hériter dynamiquement de plus d'une chaîne de prototypes.
 
-<p>En JavaScript, vous pouvez faire en sorte qu'une fonction de construction appelle plusieurs autres fonctions de construction en son sein. Cela donne l'illusion d'un héritage multiple. Par exemple, considérez les déclarations suivantes :</p>
+En JavaScript, vous pouvez faire en sorte qu'une fonction de construction appelle plusieurs autres fonctions de construction en son sein. Cela donne l'illusion d'un héritage multiple. Par exemple, considérez les déclarations suivantes :
 
-<pre class="brush: js">function Hobbyist(hobby) {
+```js
+function Hobbyist(hobby) {
   this.hobby = hobby || 'plongée';
 }
 
@@ -666,20 +756,24 @@ function Engineer(name, projs, mach, hobby) {
 Engineer.prototype = new WorkerBee;
 
 let dennis = new Engineer('Dennis Ah', ['collaborateur'], 'hugo');
-</pre>
+```
 
-<p>Supposons en outre que la définition de <code>WorkerBee</code> soit celle utilisée précédemment dans ce chapitre. Dans ce cas, l'objet <code>dennis</code> possède ces propriétés :</p>
+Supposons en outre que la définition de `WorkerBee` soit celle utilisée précédemment dans ce chapitre. Dans ce cas, l'objet `dennis` possède ces propriétés :
 
-<pre class="brush: js">dennis.name == 'Dennis Ah';
+```js
+dennis.name == 'Dennis Ah';
 dennis.dept == 'ingénierie';
 dennis.projects == ['collaborateur'];
 dennis.machine == 'hugo';
-dennis.hobby == 'plongée';</pre>
+dennis.hobby == 'plongée';
+```
 
-<p>Donc <code>dennis</code> obtient bien la propriété <code>hobby</code> du constructeur <code>Hobbyist</code>. Cependant, supposons que vous ajoutez ensuite une propriété au prototype du constructeur <code>Hobbyist</code> :</p>
+Donc `dennis` obtient bien la propriété `hobby` du constructeur `Hobbyist`. Cependant, supposons que vous ajoutez ensuite une propriété au prototype du constructeur `Hobbyist` :
 
-<pre class="brush: js">Hobbyist.prototype.equipment = ['masque', 'palmes', 'régulateur', 'bcd'];</pre>
+```js
+Hobbyist.prototype.equipment = ['masque', 'palmes', 'régulateur', 'bcd'];
+```
 
-<p>L'objet <code>dennis</code> n'héritera pas de cette nouvelle propriété.</p>
+L'objet `dennis` n'héritera pas de cette nouvelle propriété.
 
-<div>{{PreviousNext("Web/JavaScript/Guide/Working_with_Objects", "Web/JavaScript/Guide/Using_promises")}}</div>
+{{PreviousNext("Web/JavaScript/Guide/Working_with_Objects", "Web/JavaScript/Guide/Using_promises")}}
diff --git a/files/fr/web/javascript/guide/expressions_and_operators/index.md b/files/fr/web/javascript/guide/expressions_and_operators/index.md
index d9837ef8e4..531199cc8a 100644
--- a/files/fr/web/javascript/guide/expressions_and_operators/index.md
+++ b/files/fr/web/javascript/guide/expressions_and_operators/index.md
@@ -10,135 +10,71 @@ tags:
 translation_of: Web/JavaScript/Guide/Expressions_and_Operators
 original_slug: Web/JavaScript/Guide/Expressions_et_Opérateurs
 ---
-<p>{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/Fonctions", "Web/JavaScript/Guide/Nombres_et_dates")}}</p>
+{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/Fonctions", "Web/JavaScript/Guide/Nombres_et_dates")}}
 
-<p>Ce chapitre décrit les expressions et les opérateurs en JavaScript, il inclut des notions sur les opérateurs d'affectation, de comparaison, les opérateurs arithmétiques, binaires, logiques, ceux qui s'appliquent sur les chaînes de caractères ainsi que les opérateurs spéciaux.</p>
+Ce chapitre décrit les expressions et les opérateurs en JavaScript, il inclut des notions sur les opérateurs d'affectation, de comparaison, les opérateurs arithmétiques, binaires, logiques, ceux qui s'appliquent sur les chaînes de caractères ainsi que les opérateurs spéciaux.
 
-<p>Une liste complète et détaillée des opérateurs JavaScript est disponible dans <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs">la référence JavaScript</a>.</p>
+Une liste complète et détaillée des opérateurs JavaScript est disponible dans [la référence JavaScript](/fr/docs/Web/JavaScript/Reference/Opérateurs).
 
-<h2 id="Opérateurs">Opérateurs</h2>
+## Opérateurs
 
-<p>JavaScript possède différents types d'opérateurs. Cette section décrit les opérateurs et certaines informations sur les priorités entre opérateurs.</p>
+JavaScript possède différents types d'opérateurs. Cette section décrit les opérateurs et certaines informations sur les priorités entre opérateurs.
 
-<ul>
- <li><a href="/fr/docs/Web/JavaScript/Guide/Expressions_et_Opérateurs#Opérateurs_d'affectation">Les opérateurs d'affectation</a></li>
- <li><a href="/fr/docs/Web/JavaScript/Guide/Expressions_et_Opérateurs#Opérateurs_de_comparaison">Les opérateurs de comparaison</a></li>
- <li><a href="/fr/docs/Web/JavaScript/Guide/Expressions_et_Opérateurs#Opérateurs_arithmétiques">Les opérateurs arithmétiques</a></li>
- <li><a href="/fr/docs/Web/JavaScript/Guide/Expressions_et_Opérateurs#Opérateurs_binaires">Les opérateurs binaires</a></li>
- <li><a href="/fr/docs/Web/JavaScript/Guide/Expressions_et_Opérateurs#Opérateurs_logiques">Les opérateurs logiques</a></li>
- <li><a href="/fr/docs/Web/JavaScript/Guide/Expressions_et_Opérateurs#Opérateurs_de_chaînes_de_caractères">Les opérateurs de chaînes</a></li>
- <li><a href="/fr/docs/Web/JavaScript/Guide/Expressions_et_Opérateurs#Opérateur_conditionnel_ternaire">L'opérateur (ternaire) conditionnel</a></li>
- <li><a href="/fr/docs/Web/JavaScript/Guide/Expressions_et_Opérateurs#La_virgule_comme_opérateur">L'opérateur virgule</a></li>
- <li><a href="/fr/docs/Web/JavaScript/Guide/Expressions_et_Opérateurs#Opérateurs_unaires">Les opérateurs unaires</a></li>
- <li><a href="/fr/docs/Web/JavaScript/Guide/Expressions_et_Opérateurs#Opérateurs_relationnels">Les opérateurs relationnels</a></li>
-</ul>
+- [Les opérateurs d'affectation](/fr/docs/Web/JavaScript/Guide/Expressions_et_Opérateurs#Opérateurs_d'affectation)
+- [Les opérateurs de comparaison](/fr/docs/Web/JavaScript/Guide/Expressions_et_Opérateurs#Opérateurs_de_comparaison)
+- [Les opérateurs arithmétiques](/fr/docs/Web/JavaScript/Guide/Expressions_et_Opérateurs#Opérateurs_arithmétiques)
+- [Les opérateurs binaires](/fr/docs/Web/JavaScript/Guide/Expressions_et_Opérateurs#Opérateurs_binaires)
+- [Les opérateurs logiques](/fr/docs/Web/JavaScript/Guide/Expressions_et_Opérateurs#Opérateurs_logiques)
+- [Les opérateurs de chaînes](/fr/docs/Web/JavaScript/Guide/Expressions_et_Opérateurs#Opérateurs_de_chaînes_de_caractères)
+- [L'opérateur (ternaire) conditionnel](/fr/docs/Web/JavaScript/Guide/Expressions_et_Opérateurs#Opérateur_conditionnel_ternaire)
+- [L'opérateur virgule](/fr/docs/Web/JavaScript/Guide/Expressions_et_Opérateurs#La_virgule_comme_opérateur)
+- [Les opérateurs unaires](/fr/docs/Web/JavaScript/Guide/Expressions_et_Opérateurs#Opérateurs_unaires)
+- [Les opérateurs relationnels](/fr/docs/Web/JavaScript/Guide/Expressions_et_Opérateurs#Opérateurs_relationnels)
 
-<p>JavaScript utilise des opérateurs <em>binaires</em> et <em>unaires</em>, ainsi qu'un opérateur ternaire spécial (l'opérateur conditionnel). Un opérateur binaire utilise deux opérandes, un précédant l'opérateur et un lui succédant :</p>
+JavaScript utilise des opérateurs _binaires_ et _unaires_, ainsi qu'un opérateur ternaire spécial (l'opérateur conditionnel). Un opérateur binaire utilise deux opérandes, un précédant l'opérateur et un lui succédant :
 
-<pre class="syntaxbox"><em>opérande1</em> <em>opérateur</em> <em>opérande2</em>
-</pre>
+    opérande1 opérateur opérande2
 
-<p>Par exemple : « <code>3+4</code> » ou « <code>x*y</code> ».</p>
+Par exemple : « `3+4` » ou « `x*y` ».
 
-<p>Un opérateur unaire ne nécessite qu'un opérande, avant ou après l'opérateur :</p>
+Un opérateur unaire ne nécessite qu'un opérande, avant ou après l'opérateur :
 
-<pre class="syntaxbox"><em>opérateur</em> <em>opérand</em>e</pre>
+    opérateur opérande
 
-<p>ou</p>
+ou
 
-<pre class="syntaxbox"><em>opérande</em> <em>opérateur</em></pre>
+    opérande opérateur
 
-<p>Comme « <code>x++</code> » ou « <code>++x</code> ».</p>
+Comme « `x++` » ou « `++x` ».
 
-<h3 id="Opérateurs_daffectation">Opérateurs d'affectation</h3>
+### Opérateurs d'affectation
 
-<p>Un <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_d_affectation">opérateur d'affectation</a> assigne une valeur à son opérande gauche, valeur basée sur celle de l'opérande droit. L'opérateur d'affectation simple est le signe égal (=), il assigne la valeur de l'opérande droit à l'opérande gauche. Autrement dit, avec « x = y » on affecte la valeur y à x.</p>
+Un [opérateur d'affectation](/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_d_affectation) assigne une valeur à son opérande gauche, valeur basée sur celle de l'opérande droit. L'opérateur d'affectation simple est le signe égal (=), il assigne la valeur de l'opérande droit à l'opérande gauche. Autrement dit, avec « x = y » on affecte la valeur y à x.
 
-<p>D'autres opérateurs d'affectation sont des raccourcis correspondant à certaines opérations composées, ils sont énumérés dans le tableau qui suit :</p>
+D'autres opérateurs d'affectation sont des raccourcis correspondant à certaines opérations composées, ils sont énumérés dans le tableau qui suit :
 
-<table class="standard-table">
- <caption>Opérateurs d'affectation</caption>
- <thead>
-  <tr>
-   <th scope="col">Nom</th>
-   <th scope="col">Opérateur composé</th>
-   <th scope="col">Signification</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td><a href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateurs_d_affectation#Affectation">Affectation</a></td>
-   <td><code>x = y</code></td>
-   <td><code>x = y</code></td>
-  </tr>
-  <tr>
-   <td><a href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateurs_d_affectation#Affectation_apr%C3%A8s_addition">Affectation après addition</a></td>
-   <td><code>x += y</code></td>
-   <td><code>x = x + y</code></td>
-  </tr>
-  <tr>
-   <td><a href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateurs_d_affectation#Affectation_apr%C3%A8s_soustraction">Affectation après soustraction</a></td>
-   <td><code>x -= y</code></td>
-   <td><code>x = x - y</code></td>
-  </tr>
-  <tr>
-   <td><a href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateurs_d_affectation#Affectation_apr%C3%A8s_multiplication">Affectation après multiplication</a></td>
-   <td><code>x *= y</code></td>
-   <td><code>x = x * y</code></td>
-  </tr>
-  <tr>
-   <td><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_d_affectation#Affectation_après_division">Affectation après division</a></td>
-   <td><code>x /= y</code></td>
-   <td><code>x = x / y</code></td>
-  </tr>
-  <tr>
-   <td><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_d_affectation#Affectation_du_reste">Affectation du reste</a></td>
-   <td><code>x %= y</code></td>
-   <td><code>x = x % y</code></td>
-  </tr>
-  <tr>
-   <td><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_d_affectation#Affectation_après_exponentiation">Affectation après exponentiation</a>{{experimental_inline}}</td>
-   <td><code>x **=y</code></td>
-   <td><code>x = x ** y</code></td>
-  </tr>
-  <tr>
-   <td><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_d_affectation#Affectation_après_décalage_à_gauche">Affectation après décalage à gauche</a></td>
-   <td><code>x &lt;&lt;= y</code></td>
-   <td><code>x = x &lt;&lt; y</code></td>
-  </tr>
-  <tr>
-   <td><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_d_affectation#Affectation_après_décalage_à_droite">Affectation après décalage à droite</a></td>
-   <td><code>x &gt;&gt;= y</code></td>
-   <td><code>x = x &gt;&gt; y</code></td>
-  </tr>
-  <tr>
-   <td><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_d_affectation#Affectation_après_décalage_à_droite_non-signé">Affectation après décalage à droite non signé</a></td>
-   <td><code>x &gt;&gt;&gt;= y</code></td>
-   <td><code>x = x &gt;&gt;&gt; y</code></td>
-  </tr>
-  <tr>
-   <td><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_d_affectation#Affectation_après_ET_binaire">Affectation après ET binaire</a></td>
-   <td><code>x &amp;= y</code></td>
-   <td><code>x = x &amp; y</code></td>
-  </tr>
-  <tr>
-   <td><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_d_affectation#Affectation_après_OU_exclusif_(XOR)_binaire">Affectation après OU exclusif binaire</a></td>
-   <td><code>x ^= y</code></td>
-   <td><code>x = x ^ y</code></td>
-  </tr>
-  <tr>
-   <td><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_d_affectation#Affectation_après_OU_binaire">Affectation après OU binaire</a></td>
-   <td><code>x |= y</code></td>
-   <td><code>x = x | y</code></td>
-  </tr>
- </tbody>
-</table>
+| Nom                                                                                                                                                                        | Opérateur composé | Signification |
+| -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------- | ------------- |
+| [Affectation](/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateurs_d_affectation#Affectation)                                                                 | `x = y`           | `x = y`       |
+| [Affectation après addition](/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateurs_d_affectation#Affectation_apr%C3%A8s_addition)                              | `x += y`          | `x = x + y`   |
+| [Affectation après soustraction](/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateurs_d_affectation#Affectation_apr%C3%A8s_soustraction)                      | `x -= y`          | `x = x - y`   |
+| [Affectation après multiplication](/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateurs_d_affectation#Affectation_apr%C3%A8s_multiplication)                  | `x *= y`          | `x = x * y`   |
+| [Affectation après division](/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_d_affectation#Affectation_après_division)                                             | `x /= y`          | `x = x / y`   |
+| [Affectation du reste](/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_d_affectation#Affectation_du_reste)                                                         | `x %= y`          | `x = x % y`   |
+| [Affectation après exponentiation](/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_d_affectation#Affectation_après_exponentiation){{experimental_inline}} | `x **=y`          | `x = x ** y`  |
+| [Affectation après décalage à gauche](/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_d_affectation#Affectation_après_décalage_à_gauche)                           | `x <<= y`         | `x = x << y`  |
+| [Affectation après décalage à droite](/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_d_affectation#Affectation_après_décalage_à_droite)                           | `x >>= y`         | `x = x >> y`  |
+| [Affectation après décalage à droite non signé](/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_d_affectation#Affectation_après_décalage_à_droite_non-signé)       | `x >>>= y`        | `x = x >>> y` |
+| [Affectation après ET binaire](/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_d_affectation#Affectation_après_ET_binaire)                                         | `x &= y`          | `x = x & y`   |
+| [Affectation après OU exclusif binaire](</fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_d_affectation#Affectation_après_OU_exclusif_(XOR)_binaire>)               | `x ^= y`          | `x = x ^ y`   |
+| [Affectation après OU binaire](/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_d_affectation#Affectation_après_OU_binaire)                                         | `x \|= y`         | `x = x \| y`  |
 
-<h4 id="Décomposition">Décomposition</h4>
+#### Décomposition
 
-<p>Lors d'affectations plus complexes, on peut utiliser <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Affecter_par_décomposition">l'affectation par décomposition</a>. C'est une expression qui permet d'extraire des données depuis des tableaux ou des objets avec une syntaxe symétrique de littéraux de tableaux ou d'objets pour affecter des variables.</p>
+Lors d'affectations plus complexes, on peut utiliser [l'affectation par décomposition](/fr/docs/Web/JavaScript/Reference/Opérateurs/Affecter_par_décomposition). C'est une expression qui permet d'extraire des données depuis des tableaux ou des objets avec une syntaxe symétrique de littéraux de tableaux ou d'objets pour affecter des variables.
 
-<pre class="brush: js">var toto = ["un", "deux", "trois"];
+```js
+var toto = ["un", "deux", "trois"];
 
 // sans décomposition
 var un = toto[0];
@@ -146,422 +82,578 @@ var deux = toto[1];
 var trois = toto[2];
 
 // avec la décomposition
-var [un, deux, trois] = toto;</pre>
+var [un, deux, trois] = toto;
+```
 
-<h3 id="Opérateurs_de_comparaison">Opérateurs de comparaison</h3>
+### Opérateurs de comparaison
 
-<p>Un <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_comparaison">opérateur de comparaison</a> compare ses deux opérandes et renvoie un valeur booléenne correspondant au résultat de la comparaison (vraie ou fausse). Les opérandes peuvent être des nombres, des chaînes de caractères, des booléens ou des objets. Les chaînes de caractères sont comparées selon l'ordre lexicographique usuel en utilisant les valeurs Unicode. Dans la plupart des cas, si les deux opérandes ne sont pas du même type, JavaScript tentera de les convertir vers un type approprié. Cette méthode aboutira souvent à une comparaison numérique. Les seules exceptions à cette conversion implicite sont les opérateurs <code>===</code> et <code>!==</code> , qui testent des égalités et inégalités strictes. Ces opérateurs n'effectuent pas de conversion de type. Le tableau qui suit décrit les opérateurs de comparaisons relativement à ce fragment de code :</p>
+Un [opérateur de comparaison](/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_comparaison) compare ses deux opérandes et renvoie un valeur booléenne correspondant au résultat de la comparaison (vraie ou fausse). Les opérandes peuvent être des nombres, des chaînes de caractères, des booléens ou des objets. Les chaînes de caractères sont comparées selon l'ordre lexicographique usuel en utilisant les valeurs Unicode. Dans la plupart des cas, si les deux opérandes ne sont pas du même type, JavaScript tentera de les convertir vers un type approprié. Cette méthode aboutira souvent à une comparaison numérique. Les seules exceptions à cette conversion implicite sont les opérateurs `===` et `!==` , qui testent des égalités et inégalités strictes. Ces opérateurs n'effectuent pas de conversion de type. Le tableau qui suit décrit les opérateurs de comparaisons relativement à ce fragment de code :
 
-<pre class="brush: js">var var1 = 3;
+```js
+var var1 = 3;
 var var2 = 4;
-</pre>
+```
 
 <table class="standard-table">
- <caption>Opérateurs de comparaison</caption>
- <thead>
-  <tr>
-   <th scope="col">Opérateur</th>
-   <th scope="col">Description</th>
-   <th scope="col">Exemples qui renvoient <code>true</code></th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td><a href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateurs_de_comparaison#.C3.89galit.C3.A9_simple_(.3D.3D)">Égalité</a> (<code>==</code>)</td>
-   <td>Renvoie <code>true</code> si les opérandes sont égaux après conversion en valeurs de mêmes types.</td>
-   <td><code>3 == var1</code>
-    <p><code>"3" == var1</code></p>
-    <code>3 == '3'</code></td>
-  </tr>
-  <tr>
-   <td><a href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateurs_de_comparaison#In.C3.A9galit.C3.A9_simple_(!.3D)">Inégalité</a> (<code>!=</code>)</td>
-   <td>Renvoie <code>true</code> si les opérandes sont différents.</td>
-   <td><code>var1 != 4<br>
-    var2 != "3"</code></td>
-  </tr>
-  <tr>
-   <td><a href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateurs_de_comparaison#.C3.89galit.C3.A9_stricte_(.3D.3D.3D)">Égalité stricte </a>(<code>===</code>)</td>
-   <td>Renvoie <code>true</code> si les opérandes sont égaux et de même type. Voir {{jsxref("Object.is","Object.is()")}} et <a href="/fr/docs/JavaScript/Guide/%C3%89galit%C3%A9_en_JavaScript">égalité de type en JavaScript</a>.</td>
-   <td><code>3 === var1</code></td>
-  </tr>
-  <tr>
-   <td><a href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateurs_de_comparaison#In.C3.A9galit.C3.A9_stricte_(!.3D.3D)">Inégalité stricte</a> (<code>!==</code>)</td>
-   <td>Renvoie <code>true</code> si les opérandes ne sont pas égaux ou s'ils ne sont pas de même type.</td>
-   <td><code>var1 !== "3"<br>
-    3 !== '3'</code></td>
-  </tr>
-  <tr>
-   <td><a href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateurs_de_comparaison#Sup.C3.A9rieur_strict_(%3E)">Supériorité stricte</a> (<code>&gt;</code>)</td>
-   <td>Renvoie <code>true</code> si l'opérande gauche est supérieur (strictement) à l'opérande droit.</td>
-   <td><code>var2 &gt; var1<br>
-    "12" &gt; 2</code></td>
-  </tr>
-  <tr>
-   <td><a href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateurs_de_comparaison#Sup.C3.A9rieur_ou_.C3.A9gal_(%3E.3D)">Supériorité ou égalité</a> (<code>&gt;=</code>)</td>
-   <td>Renvoie <code>true</code> si l'opérande gauche est supérieur ou égal à l'opérande droit.</td>
-   <td><code>var2 &gt;= var1<br>
-    var1 &gt;= 3</code></td>
-  </tr>
-  <tr>
-   <td><a href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateurs_de_comparaison#Inf.C3.A9rieur_strict_(%3C)">Infériorité stricte</a> (<code>&lt;</code>)</td>
-   <td>Renvoie <code>true</code> si l'opérande gauche est inférieur (strictement) à l'opérande droit.</td>
-   <td><code>var1 &lt; var2<br>
-    "2" &lt; "12"</code></td>
-  </tr>
-  <tr>
-   <td><a href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateurs_de_comparaison#Inf.C3.A9rieur_ou_.C3.A9gal_(%3C.3D)">Infériorité ou égalité</a> (<code>&lt;=</code>)</td>
-   <td>Renvoie <code>true</code> si l'opérande gauche est inférieur ou égal à l'opérande droit.</td>
-   <td><code>var1 &lt;= var2<br>
-    var2 &lt;= 5</code></td>
-  </tr>
- </tbody>
+  <caption>
+    Opérateurs de comparaison
+  </caption>
+  <thead>
+    <tr>
+      <th scope="col">Opérateur</th>
+      <th scope="col">Description</th>
+      <th scope="col">Exemples qui renvoient <code>true</code></th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td>
+        <a
+          href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateurs_de_comparaison#.C3.89galit.C3.A9_simple_(.3D.3D)"
+          >Égalité</a
+        >
+        (<code>==</code>)
+      </td>
+      <td>
+        Renvoie <code>true</code> si les opérandes sont égaux après conversion
+        en valeurs de mêmes types.
+      </td>
+      <td>
+        <code>3 == var1</code>
+        <p><code>"3" == var1</code></p>
+        <code>3 == '3'</code>
+      </td>
+    </tr>
+    <tr>
+      <td>
+        <a
+          href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateurs_de_comparaison#In.C3.A9galit.C3.A9_simple_(!.3D)"
+          >Inégalité</a
+        >
+        (<code>!=</code>)
+      </td>
+      <td>Renvoie <code>true</code> si les opérandes sont différents.</td>
+      <td>
+        <code>var1 != 4<br />var2 != "3"</code>
+      </td>
+    </tr>
+    <tr>
+      <td>
+        <a
+          href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateurs_de_comparaison#.C3.89galit.C3.A9_stricte_(.3D.3D.3D)"
+          >Égalité stricte </a
+        >(<code>===</code>)
+      </td>
+      <td>
+        Renvoie <code>true</code> si les opérandes sont égaux et de même type.
+        Voir {{jsxref("Object.is","Object.is()")}} et
+        <a href="/fr/docs/JavaScript/Guide/%C3%89galit%C3%A9_en_JavaScript"
+          >égalité de type en JavaScript</a
+        >.
+      </td>
+      <td><code>3 === var1</code></td>
+    </tr>
+    <tr>
+      <td>
+        <a
+          href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateurs_de_comparaison#In.C3.A9galit.C3.A9_stricte_(!.3D.3D)"
+          >Inégalité stricte</a
+        >
+        (<code>!==</code>)
+      </td>
+      <td>
+        Renvoie <code>true</code> si les opérandes ne sont pas égaux ou s'ils ne
+        sont pas de même type.
+      </td>
+      <td>
+        <code>var1 !== "3"<br />3 !== '3'</code>
+      </td>
+    </tr>
+    <tr>
+      <td>
+        <a
+          href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateurs_de_comparaison#Sup.C3.A9rieur_strict_(%3E)"
+          >Supériorité stricte</a
+        >
+        (<code>></code>)
+      </td>
+      <td>
+        Renvoie <code>true</code> si l'opérande gauche est supérieur
+        (strictement) à l'opérande droit.
+      </td>
+      <td>
+        <code>var2 > var1<br />"12" > 2</code>
+      </td>
+    </tr>
+    <tr>
+      <td>
+        <a
+          href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateurs_de_comparaison#Sup.C3.A9rieur_ou_.C3.A9gal_(%3E.3D)"
+          >Supériorité ou égalité</a
+        >
+        (<code>>=</code>)
+      </td>
+      <td>
+        Renvoie <code>true</code> si l'opérande gauche est supérieur ou égal à
+        l'opérande droit.
+      </td>
+      <td>
+        <code>var2 >= var1<br />var1 >= 3</code>
+      </td>
+    </tr>
+    <tr>
+      <td>
+        <a
+          href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateurs_de_comparaison#Inf.C3.A9rieur_strict_(%3C)"
+          >Infériorité stricte</a
+        >
+        (<code>&#x3C;</code>)
+      </td>
+      <td>
+        Renvoie <code>true</code> si l'opérande gauche est inférieur
+        (strictement) à l'opérande droit.
+      </td>
+      <td>
+        <code>var1 &#x3C; var2<br />"2" &#x3C; "12"</code>
+      </td>
+    </tr>
+    <tr>
+      <td>
+        <a
+          href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateurs_de_comparaison#Inf.C3.A9rieur_ou_.C3.A9gal_(%3C.3D)"
+          >Infériorité ou égalité</a
+        >
+        (<code>&#x3C;=</code>)
+      </td>
+      <td>
+        Renvoie <code>true</code> si l'opérande gauche est inférieur ou égal à
+        l'opérande droit.
+      </td>
+      <td>
+        <code>var1 &#x3C;= var2<br />var2 &#x3C;= 5</code>
+      </td>
+    </tr>
+  </tbody>
 </table>
 
-<div class="note">
-<p><strong>Note :</strong> <code>=&gt;</code> n'est pas un opérateur. Il s'agit de la notation utilisée pour <a href="/fr/docs/Web/JavaScript/Reference/Fonctions/Fonctions_fl%C3%A9ch%C3%A9es">les fonctions fléchées</a>.</p>
-</div>
+> **Note :** `=>` n'est pas un opérateur. Il s'agit de la notation utilisée pour [les fonctions fléchées](/fr/docs/Web/JavaScript/Reference/Fonctions/Fonctions_fl%C3%A9ch%C3%A9es).
 
-<h3 id="Opérateurs_arithmétiques">Opérateurs arithmétiques</h3>
+### Opérateurs arithmétiques
 
-<p>Les <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_arithmétiques">opérateurs arithmétiques</a> ont pour opérandes des valeurs numériques (des littéraux ou des variables) et renvoient une valeur numérique. Les opérateurs arithmétiques standards sont l'addition (+), la soustraction (-), la multiplication (*), et la division (/). Ces opérateurs fonctionnent comme pour la plupart des langages de programmation lorsqu'ils sont utilisés avec des nombres décimaux (on notera que la division par zéro a pour résultat {{jsxref("Infinity")}}). Ainsi :</p>
+Les [opérateurs arithmétiques](/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_arithmétiques) ont pour opérandes des valeurs numériques (des littéraux ou des variables) et renvoient une valeur numérique. Les opérateurs arithmétiques standards sont l'addition (+), la soustraction (-), la multiplication (\*), et la division (/). Ces opérateurs fonctionnent comme pour la plupart des langages de programmation lorsqu'ils sont utilisés avec des nombres décimaux (on notera que la division par zéro a pour résultat {{jsxref("Infinity")}}). Ainsi :
 
-<pre class="brush: js">1 / 2; // 0.5
+```js
+1 / 2; // 0.5
 1 / 2 == 1.0 / 2.0; // true
-</pre>
+```
 
-<p>En plus des opérations arithmétiques standards (+,-,*,/), JavaScript fournit également d'autres opérateurs arithmétiques, listés dans le tableau qui suit :</p>
+En plus des opérations arithmétiques standards (+,-,\*,/), JavaScript fournit également d'autres opérateurs arithmétiques, listés dans le tableau qui suit :
 
 <table class="fullwidth-table">
- <caption>Opérateurs arithmétiques</caption>
- <thead>
-  <tr>
-   <th scope="col">Opérateur</th>
-   <th scope="col">Description</th>
-   <th scope="col">Exemple</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td><a href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateurs_arithm%C3%A9tiques#Reste_(.25)">Reste</a> (<code>%</code>)<br>
-     </td>
-   <td>Opérateur binaire. Renvoie le reste entier de la division entre les deux opérandes.</td>
-   <td>12 % 5 renvoie 2.</td>
-  </tr>
-  <tr>
-   <td><a href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateurs_arithm%C3%A9tiques#Incr.C3.A9ment_(.2B.2B)">Incrément</a> (<code>++</code>)</td>
-   <td>Opérateur unaire. Ajoute un à son opérande. S'il est utilisé en préfixe (<code>++x</code>), il renvoie la valeur de l'opérande après avoir ajouté un, s'il est utilisé comme opérateur de suffixe (<code>x++</code>), il renvoie la valeur de l'opérande avant d'ajouter un.</td>
-   <td>Si <code>x</code> vaut 3, <code>++x</code> incrémente <code>x</code> à 4 et renvoie 4, <code>x++</code> renvoie 3 et seulement ensuite ajoute un à <code>x</code>.</td>
-  </tr>
-  <tr>
-   <td><a href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateurs_arithm%C3%A9tiques#D.C3.A9cr.C3.A9ment_(--)">Décrément</a> (<code>--</code>)</td>
-   <td>Opérateur unaire. Il soustrait un à son opérande. Il fonctionne de manière analogue à l'opérateur d'incrément.</td>
-   <td>Si <code>x</code> vaut 3, <code>--x</code> décrémente <code>x</code> à 2 puis renvoie2, <code>x--</code> renvoie 3 puis décrémente la valeur de <code>x</code>.</td>
-  </tr>
-  <tr>
-   <td><a href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateurs_arithm%C3%A9tiques#N.C3.A9gation_unaire_(-)">Négation unaire</a> (<code>-</code>)</td>
-   <td>Opérateur unaire. Renvoie la valeur opposée de l'opérande.</td>
-   <td>Si <code>x</code> vaut 3, alors <code>-x</code> renvoie -3.</td>
-  </tr>
-  <tr>
-   <td><a href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateurs_arithm%C3%A9tiques#Plus_unaire_(.2B)">Plus unaire </a>(<code>+</code>)</td>
-   <td>Opérateur unaire. Si l'opérande n'est pas un nombre, il tente de le convertir en une valeur numérique.</td>
-   <td>
-    <p><code>+"3"</code> renvoie <code>3</code>.</p>
-
-    <p><code>+true</code> renvoie <code>1</code>.</p>
-   </td>
-  </tr>
-  <tr>
-   <td><a href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateurs_arithm%C3%A9tiques#Exponentiation">Opérateur d'exponentiation</a> (**) (puissance) {{experimental_inline}}</td>
-   <td>Calcule un nombre (base) élevé à une puissance donnée (soit <code>base^puissance</code>)</td>
-   <td>
-    <p><code>2 ** 3</code> renvoie <code>8</code></p>
-
-    <p><code>10 ** -1</code> renvoie <code>0.1</code></p>
-   </td>
-  </tr>
- </tbody>
+  <caption>
+    Opérateurs arithmétiques
+  </caption>
+  <thead>
+    <tr>
+      <th scope="col">Opérateur</th>
+      <th scope="col">Description</th>
+      <th scope="col">Exemple</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td>
+        <a
+          href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateurs_arithm%C3%A9tiques#Reste_(.25)"
+          >Reste</a
+        >
+        (<code>%</code>)<br /> 
+      </td>
+      <td>
+        Opérateur binaire. Renvoie le reste entier de la division entre les deux
+        opérandes.
+      </td>
+      <td>12 % 5 renvoie 2.</td>
+    </tr>
+    <tr>
+      <td>
+        <a
+          href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateurs_arithm%C3%A9tiques#Incr.C3.A9ment_(.2B.2B)"
+          >Incrément</a
+        >
+        (<code>++</code>)
+      </td>
+      <td>
+        Opérateur unaire. Ajoute un à son opérande. S'il est utilisé en préfixe
+        (<code>++x</code>), il renvoie la valeur de l'opérande après avoir
+        ajouté un, s'il est utilisé comme opérateur de suffixe
+        (<code>x++</code>), il renvoie la valeur de l'opérande avant d'ajouter
+        un.
+      </td>
+      <td>
+        Si <code>x</code> vaut 3, <code>++x</code> incrémente <code>x</code> à 4
+        et renvoie 4, <code>x++</code> renvoie 3 et seulement ensuite ajoute un
+        à <code>x</code>.
+      </td>
+    </tr>
+    <tr>
+      <td>
+        <a
+          href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateurs_arithm%C3%A9tiques#D.C3.A9cr.C3.A9ment_(--)"
+          >Décrément</a
+        >
+        (<code>--</code>)
+      </td>
+      <td>
+        Opérateur unaire. Il soustrait un à son opérande. Il fonctionne de
+        manière analogue à l'opérateur d'incrément.
+      </td>
+      <td>
+        Si <code>x</code> vaut 3, <code>--x</code> décrémente <code>x</code> à 2
+        puis renvoie2, <code>x--</code> renvoie 3 puis décrémente la valeur de
+        <code>x</code>.
+      </td>
+    </tr>
+    <tr>
+      <td>
+        <a
+          href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateurs_arithm%C3%A9tiques#N.C3.A9gation_unaire_(-)"
+          >Négation unaire</a
+        >
+        (<code>-</code>)
+      </td>
+      <td>Opérateur unaire. Renvoie la valeur opposée de l'opérande.</td>
+      <td>Si <code>x</code> vaut 3, alors <code>-x</code> renvoie -3.</td>
+    </tr>
+    <tr>
+      <td>
+        <a
+          href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateurs_arithm%C3%A9tiques#Plus_unaire_(.2B)"
+          >Plus unaire </a
+        >(<code>+</code>)
+      </td>
+      <td>
+        Opérateur unaire. Si l'opérande n'est pas un nombre, il tente de le
+        convertir en une valeur numérique.
+      </td>
+      <td>
+        <p><code>+"3"</code> renvoie <code>3</code>.</p>
+        <p><code>+true</code> renvoie <code>1</code>.</p>
+      </td>
+    </tr>
+    <tr>
+      <td>
+        <a
+          href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateurs_arithm%C3%A9tiques#Exponentiation"
+          >Opérateur d'exponentiation</a
+        >
+        (**) (puissance) {{experimental_inline}}
+      </td>
+      <td>
+        Calcule un nombre (base) élevé à une puissance donnée (soit
+        <code>base^puissance</code>)
+      </td>
+      <td>
+        <p><code>2 ** 3</code> renvoie <code>8</code></p>
+        <p><code>10 ** -1</code> renvoie <code>0.1</code></p>
+      </td>
+    </tr>
+  </tbody>
 </table>
 
-<h3 id="Opérateurs_binaires">Opérateurs binaires</h3>
+### Opérateurs binaires
 
-<p>Les <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_binaires">opérateurs binaires</a> voient leurs opérandes comme des ensembles de 32 bits (des zéros et des uns), et non pas comme des nombres décimaux, octaux ou hexadécimaux. Ainsi, le nombre décimal neuf aura une représentation binaire de 1001. Les opérateurs binaires effectuent des opérations sur des représentations binaires mais renvoies des valeurs numériques JavaScript standards.</p>
+Les [opérateurs binaires](/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_binaires) voient leurs opérandes comme des ensembles de 32 bits (des zéros et des uns), et non pas comme des nombres décimaux, octaux ou hexadécimaux. Ainsi, le nombre décimal neuf aura une représentation binaire de 1001. Les opérateurs binaires effectuent des opérations sur des représentations binaires mais renvoies des valeurs numériques JavaScript standards.
 
-<p>Le tableau qui suit résume les opérateurs binaires JavaScript :</p>
+Le tableau qui suit résume les opérateurs binaires JavaScript :
 
-<table class="standard-table">
- <caption>Opérateurs binaires</caption>
- <thead>
-  <tr>
-   <th scope="col">Opérateur</th>
-   <th scope="col">Utilisation</th>
-   <th scope="col">Description</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td><a href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateurs_binaires#&amp;_.28ET_binaire.29">AND (ET) binaire</a></td>
-   <td><code>a &amp; b</code></td>
-   <td>Renvoie un 1 à chaque position binaire pour laquelle les bits des deux opérandes sont à 1.</td>
-  </tr>
-  <tr>
-   <td><a href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateurs_binaires#|_.28OU_binaire.29">OR (OU) binaire</a></td>
-   <td><code>a | b</code></td>
-   <td>Renvoie un zéro à chaque position binaire pour laquelle les bits des deux opérandes sont à 0.</td>
-  </tr>
-  <tr>
-   <td><a href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateurs_binaires#.5E_.28XOR_binaire.29">XOR (OU exclusif) binaire</a></td>
-   <td><code>a ^ b</code></td>
-   <td>Renvoie un zéro à chaque position binaire pour laquelle les bits sont les mêmes (et un 1 pour chacun des bits qui est différent).</td>
-  </tr>
-  <tr>
-   <td><a href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateurs_binaires#.7E_.28NON_binaire.29">NOT (NON) binaire</a></td>
-   <td><code>~ a</code></td>
-   <td>Inverse les bits de l'opérande.</td>
-  </tr>
-  <tr>
-   <td><a href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateurs_binaires#.3C.3C_.28d.C3.A9calage_.C3.A0_gauche.29">Décalage binaire à gauche</a></td>
-   <td><code>a &lt;&lt; b</code></td>
-   <td>Décale la représentation binaire de <code>b</code> bits sur la gauche et complète avec des zéros à droite.</td>
-  </tr>
-  <tr>
-   <td><a href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateurs_binaires#.3E.3E_.28d.C3.A9calage_.C3.A0_droite_avec_propagation_du_signe.29">Décalage binaire à droite</a></td>
-   <td><code>a &gt;&gt; b</code></td>
-   <td>Décale la représentation binaire de <code>b</code> bits sur la droite en ignorant les bits perdus.</td>
-  </tr>
-  <tr>
-   <td><a href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateurs_binaires#.3E.3E.3E_.28d.C3.A9calage_.C3.A0_droite_avec_insertion_de_z.C3.A9ros.29">Décalage binaire à droite en complétant avec des zéros</a></td>
-   <td><code>a &gt;&gt;&gt; b</code></td>
-   <td>Décale la représentation binaire de <code>b</code> bits sur la droite en ignorant les bits perdus et ajoute des zéros sur la gauche.</td>
-  </tr>
- </tbody>
-</table>
+| Opérateur                                                                                                                                                                                                     | Utilisation | Description                                                                                                                       |
+| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| [AND (ET) binaire](/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateurs_binaires#&_.28ET_binaire.29)                                                                                             | `a & b`     | Renvoie un 1 à chaque position binaire pour laquelle les bits des deux opérandes sont à 1.                                        |
+| [OR (OU) binaire](/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateurs_binaires#|_.28OU_binaire.29)                                                                                              | `a \| b`    | Renvoie un zéro à chaque position binaire pour laquelle les bits des deux opérandes sont à 0.                                     |
+| [XOR (OU exclusif) binaire](/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateurs_binaires#.5E_.28XOR_binaire.29)                                                                                 | `a ^ b`     | Renvoie un zéro à chaque position binaire pour laquelle les bits sont les mêmes (et un 1 pour chacun des bits qui est différent). |
+| [NOT (NON) binaire](/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateurs_binaires#.7E_.28NON_binaire.29)                                                                                         | `~ a`       | Inverse les bits de l'opérande.                                                                                                   |
+| [Décalage binaire à gauche](/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateurs_binaires#.3C.3C_.28d.C3.A9calage_.C3.A0_gauche.29)                                                              | `a << b`    | Décale la représentation binaire de `b` bits sur la gauche et complète avec des zéros à droite.                                   |
+| [Décalage binaire à droite](/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateurs_binaires#.3E.3E_.28d.C3.A9calage_.C3.A0_droite_avec_propagation_du_signe.29)                                    | `a >> b`    | Décale la représentation binaire de `b` bits sur la droite en ignorant les bits perdus.                                           |
+| [Décalage binaire à droite en complétant avec des zéros](/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateurs_binaires#.3E.3E.3E_.28d.C3.A9calage_.C3.A0_droite_avec_insertion_de_z.C3.A9ros.29) | `a >>> b`   | Décale la représentation binaire de `b` bits sur la droite en ignorant les bits perdus et ajoute des zéros sur la gauche.         |
 
-<h4 id="Opérateurs_binaires_logiques">Opérateurs binaires logiques</h4>
+#### Opérateurs binaires logiques
 
-<p>Les opérateurs binaires logiques fonctionnent de cette façon :</p>
+Les opérateurs binaires logiques fonctionnent de cette façon :
 
-<ul>
- <li>Les opérandes sont convertis en entiers sur 32 bits et exprimés comme une série de bits (des 1 et des 0). Les nombres sur plus de 32 bits voient leurs bits supplémentaires supprimés :
-  <pre class="brush: js">Avant : 11100110111110100000000000000110000000000001
-Après :             10100000000000000110000000000001</pre>
- </li>
- <li>Chaque bit du premier opérande est associé avec le bit correspondant du second opérande (le premier bit du premier opérande avec le premier bit du second opérande, le second avec le second et ainsi de suite)</li>
- <li>L'opérateur est appliqué pour chaque paire de bits ainsi constituée et le résultat est reconstruit sous forme binaire.</li>
-</ul>
+- Les opérandes sont convertis en entiers sur 32 bits et exprimés comme une série de bits (des 1 et des 0). Les nombres sur plus de 32 bits voient leurs bits supplémentaires supprimés :
 
-<p>Le chiffre neuf est par exemple représenté comme 1001, et le nombre quinze comme 1111. Ainsi, quand les opérateurs binaires sont appliqués sur ces valeurs, on a les résultats qui suivent :</p>
+  ```js
+    Avant : 11100110111110100000000000000110000000000001
+    Après :             10100000000000000110000000000001
+    ```
 
-<table class="standard-table">
- <caption>Exemples utilisant les opérateurs binaires</caption>
- <thead>
-  <tr>
-   <th scope="col">Expression</th>
-   <th scope="col">Résultat</th>
-   <th scope="col">Description binaire</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td><code>15 &amp; 9</code></td>
-   <td><code>9</code></td>
-   <td><code>1111 &amp; 1001 = 1001</code></td>
-  </tr>
-  <tr>
-   <td><code>15 | 9</code></td>
-   <td><code>15</code></td>
-   <td><code>1111 | 1001 = 1111</code></td>
-  </tr>
-  <tr>
-   <td><code>15 ^ 9</code></td>
-   <td><code>6</code></td>
-   <td><code>1111 ^ 1001 = 0110</code></td>
-  </tr>
-  <tr>
-   <td><code>~15</code></td>
-   <td><code>-16</code></td>
-   <td><code>~</code><code>00000000...</code><code>00001111 = </code><code>1111</code><code>1111</code><code>...</code><code>11110000</code></td>
-  </tr>
-  <tr>
-   <td><code>~9</code></td>
-   <td><code>-10</code></td>
-   <td><code>~</code><code>00000000</code><code>...</code><code>0000</code><code>1001 = </code><code>1111</code><code>1111</code><code>...</code><code>1111</code><code>0110</code></td>
-  </tr>
- </tbody>
-</table>
+- Chaque bit du premier opérande est associé avec le bit correspondant du second opérande (le premier bit du premier opérande avec le premier bit du second opérande, le second avec le second et ainsi de suite)
+- L'opérateur est appliqué pour chaque paire de bits ainsi constituée et le résultat est reconstruit sous forme binaire.
 
-<p>Il faut remarquer que tous les bits sont échangés lorsque l'opérateur binaire NOT est utilisé. Il est donc utile de savoir que les valeurs dont le bit le plus fort (le plus à gauche) vaut 1 sont des nombres négatifs (représentation en complément à deux). L'évaluation de <code>~x</code> aura le même résultat que l'évaluation de <code>-x - 1</code>.</p>
+Le chiffre neuf est par exemple représenté comme 1001, et le nombre quinze comme 1111. Ainsi, quand les opérateurs binaires sont appliqués sur ces valeurs, on a les résultats qui suivent :
 
-<h4 id="Opérateurs_binaires_de_décalage">Opérateurs binaires de décalage</h4>
+| Expression | Résultat | Description binaire                                               |
+| ---------- | -------- | ----------------------------------------------------------------- |
+| `15 & 9`   | `9`      | `1111 & 1001 = 1001`                                              |
+| `15 \| 9`  | `15`     | `1111 \| 1001 = 1111`                                             |
+| `15 ^ 9`   | `6`      | `1111 ^ 1001 = 0110`                                              |
+| `~15`      | `-16`    | ` ~``00000000...`` 00001111 = ``1111``1111``...``11110000 `       |
+| `~9`       | `-10`    | ` ~``00000000``...``0000`` 1001 = ``1111``1111``...``1111``0110 ` |
 
-<p>Les opérateurs binaires de décalage utilisent deux opérandes : le premier indiquant la quantité à décaler et le second indiquant de combien de bits on décale le premier opérande. La direction du décalage est spécifiée grâce à l'opérateur.</p>
+Il faut remarquer que tous les bits sont échangés lorsque l'opérateur binaire NOT est utilisé. Il est donc utile de savoir que les valeurs dont le bit le plus fort (le plus à gauche) vaut 1 sont des nombres négatifs (représentation en complément à deux). L'évaluation de `~x` aura le même résultat que l'évaluation de `-x - 1`.
 
-<p>Les opérateurs binaires de décalage convertissent leurs opérandes en entiers sur 32 bits et renvoient un résultat dont le type est le même que l'opérande gauche.</p>
+#### Opérateurs binaires de décalage
 
-<p>Les opérateurs de décalage sont énumérés dans le tableau qui suit.</p>
+Les opérateurs binaires de décalage utilisent deux opérandes : le premier indiquant la quantité à décaler et le second indiquant de combien de bits on décale le premier opérande. La direction du décalage est spécifiée grâce à l'opérateur.
+
+Les opérateurs binaires de décalage convertissent leurs opérandes en entiers sur 32 bits et renvoient un résultat dont le type est le même que l'opérande gauche.
+
+Les opérateurs de décalage sont énumérés dans le tableau qui suit.
 
 <table class="fullwidth-table">
- <caption>Opérateurs binaires de décalage</caption>
- <thead>
-  <tr>
-   <th scope="col">Opérateur</th>
-   <th scope="col">Description</th>
-   <th scope="col">Exemple</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_binaires#&lt;&lt;_(décalage_à_gauche)">Décalage à gauche (<code>&lt;&lt;</code>)</a></td>
-   <td>Cet opérateur décale le premier opérande d'un nombre de bits donné sur la gauche. Les bits en trop sont ignorés et des bits à zéro sont introduits à droite.</td>
-   <td><code>9&lt;&lt;2</code> renvoie 36, car 1001, décalé de 2 bits à gauche, devient  100100, dont la représentation en base 10 est  36.</td>
-  </tr>
-  <tr>
-   <td><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_binaires#>>_(décalage_à_droite_avec_propagation_du_signe)">Décalage à droite avec propagation du signe (<code>&gt;&gt;</code>)</a></td>
-   <td>Cet opérateur décale le premier opérande d'un nombre de bits donné sur la droite. Les bits en trop sont ignorés et des bits correspondants au bit de signe sont introduits à gauche.</td>
-   <td><code>9&gt;&gt;2</code> renvoie 2, car 1001, décalé de 2 bits à droite, devient 10 représentant 2. De même  <code>-9&gt;&gt;2</code> renvoie -3, car le signe est préservé.</td>
-  </tr>
-  <tr>
-   <td><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_binaires#>>>_(décalage_à_droite_avec_insertion_de_zéros)">Décalage à droite avec zéros (<code>&gt;&gt;&gt;</code>)</a></td>
-   <td>Cet opérateur décale le premier opérande d'un nombre de bits donné sur la droite. Les bits en trop sont ignorés et des bits à 0 sont introduits à gauche.</td>
-   <td><code>19&gt;&gt;&gt;2</code> renvoie 4, car 10011, décalé de 2 bits, devient 100 qui représente 4. Pour les nombres positifs, cet opérateur et l'opérateur précédent renvoient les mêmes résultats.</td>
-  </tr>
- </tbody>
+  <caption>
+    Opérateurs binaires de décalage
+  </caption>
+  <thead>
+    <tr>
+      <th scope="col">Opérateur</th>
+      <th scope="col">Description</th>
+      <th scope="col">Exemple</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td>
+        <a
+          href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_binaires#<<_(décalage_à_gauche)"
+          >Décalage à gauche (<code>&#x3C;&#x3C;</code>)</a
+        >
+      </td>
+      <td>
+        Cet opérateur décale le premier opérande d'un nombre de bits donné sur
+        la gauche. Les bits en trop sont ignorés et des bits à zéro sont
+        introduits à droite.
+      </td>
+      <td>
+        <code>9&#x3C;&#x3C;2</code> renvoie 36, car 1001, décalé de 2 bits à
+        gauche, devient  100100, dont la représentation en base 10 est  36.
+      </td>
+    </tr>
+    <tr>
+      <td>
+        <a
+          href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_binaires#>>_(décalage_à_droite_avec_propagation_du_signe)"
+          >Décalage à droite avec propagation du signe (<code>>></code>)</a
+        >
+      </td>
+      <td>
+        Cet opérateur décale le premier opérande d'un nombre de bits donné sur
+        la droite. Les bits en trop sont ignorés et des bits correspondants au
+        bit de signe sont introduits à gauche.
+      </td>
+      <td>
+        <code>9>>2</code> renvoie 2, car 1001, décalé de 2 bits à droite,
+        devient 10 représentant 2. De même  <code>-9>>2</code> renvoie -3, car
+        le signe est préservé.
+      </td>
+    </tr>
+    <tr>
+      <td>
+        <a
+          href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_binaires#>>>_(décalage_à_droite_avec_insertion_de_zéros)"
+          >Décalage à droite avec zéros (<code>>>></code>)</a
+        >
+      </td>
+      <td>
+        Cet opérateur décale le premier opérande d'un nombre de bits donné sur
+        la droite. Les bits en trop sont ignorés et des bits à 0 sont introduits
+        à gauche.
+      </td>
+      <td>
+        <code>19>>>2</code> renvoie 4, car 10011, décalé de 2 bits, devient 100
+        qui représente 4. Pour les nombres positifs, cet opérateur et
+        l'opérateur précédent renvoient les mêmes résultats.
+      </td>
+    </tr>
+  </tbody>
 </table>
 
-<h3 id="Opérateurs_logiques">Opérateurs logiques</h3>
+### Opérateurs logiques
 
-<p>Les <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_logiques">opérateurs logiques</a> sont généralement utilisés avec des valeurs booléennes. Dans ce cas, il renvoient une valeur booléenne. Les opérateurs <code>&amp;&amp;</code> et <code>||</code> renvoient en fait une valeurs d'un des opérandes et si ces opérateurs sont utilisés avec des valeurs non-booléennées, ils pourront renvoyer une valeur non-booléenne. Les opérateurs logiques sont décrits dans le tableau qui suit.</p>
+Les [opérateurs logiques](/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_logiques) sont généralement utilisés avec des valeurs booléennes. Dans ce cas, il renvoient une valeur booléenne. Les opérateurs `&&` et `||` renvoient en fait une valeurs d'un des opérandes et si ces opérateurs sont utilisés avec des valeurs non-booléennées, ils pourront renvoyer une valeur non-booléenne. Les opérateurs logiques sont décrits dans le tableau qui suit.
 
 <table class="fullwidth-table">
- <caption>Opérateurs logiques</caption>
- <thead>
-  <tr>
-   <th scope="col">Opérateur</th>
-   <th scope="col">Usage</th>
-   <th scope="col">Description</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td><a href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateurs_logiques#Logical_AND_.28&amp;&amp;.29">ET logique</a> (<code>&amp;&amp;</code>)</td>
-   <td><code>expr1 &amp;&amp; expr2</code></td>
-   <td>Renvoie <code>expr1</code> s'il peut être converti à false, sinon renvoie <code>expr2</code>. Dans le cas où on utilise des opérandes booléens, <code>&amp;&amp;</code> renvoie <code>true</code> si les deux opérandes valent <code>true</code>, <code>false</code> sinon.</td>
-  </tr>
-  <tr>
-   <td><a href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateurs_logiques#OU_logique_(.7C.7C)">OU logique</a> (<code>||</code>)</td>
-   <td><code>expr1 || expr2</code></td>
-   <td>Renvoie <code>expr1</code> s'il peut être converti à <code>true</code>, sinon renvoie <code>expr2</code>. Dans le cas où on utilise des opérandes booléens, <code>||</code> renvoie <code>true</code> si l'un des opérandes vaut <code>true</code>, si les deux valent <code>false</code>, il renvoie <code>false</code>.</td>
-  </tr>
-  <tr>
-   <td><a href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateurs_logiques#Logical_NOT_.28.21.29">NON logique </a>(<code>!</code>)</td>
-   <td><code>!expr</code></td>
-   <td>Renvoie <code>false</code> si son unique opérande peut être converti en <code>true</code>, sinon il renvoie <code>true</code>.</td>
-  </tr>
- </tbody>
+  <caption>
+    Opérateurs logiques
+  </caption>
+  <thead>
+    <tr>
+      <th scope="col">Opérateur</th>
+      <th scope="col">Usage</th>
+      <th scope="col">Description</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td>
+        <a
+          href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateurs_logiques#Logical_AND_.28&#x26;&#x26;.29"
+          >ET logique</a
+        >
+        (<code>&#x26;&#x26;</code>)
+      </td>
+      <td><code>expr1 &#x26;&#x26; expr2</code></td>
+      <td>
+        Renvoie <code>expr1</code> s'il peut être converti à false, sinon
+        renvoie <code>expr2</code>. Dans le cas où on utilise des opérandes
+        booléens, <code>&#x26;&#x26;</code> renvoie <code>true</code> si les
+        deux opérandes valent <code>true</code>, <code>false</code> sinon.
+      </td>
+    </tr>
+    <tr>
+      <td>
+        <a
+          href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateurs_logiques#OU_logique_(.7C.7C)"
+          >OU logique</a
+        >
+        (<code>||</code>)
+      </td>
+      <td><code>expr1 || expr2</code></td>
+      <td>
+        Renvoie <code>expr1</code> s'il peut être converti à <code>true</code>,
+        sinon renvoie <code>expr2</code>. Dans le cas où on utilise des
+        opérandes booléens, <code>||</code> renvoie <code>true</code> si l'un
+        des opérandes vaut <code>true</code>, si les deux valent
+        <code>false</code>, il renvoie <code>false</code>.
+      </td>
+    </tr>
+    <tr>
+      <td>
+        <a
+          href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateurs_logiques#Logical_NOT_.28.21.29"
+          >NON logique </a
+        >(<code>!</code>)
+      </td>
+      <td><code>!expr</code></td>
+      <td>
+        Renvoie <code>false</code> si son unique opérande peut être converti en
+        <code>true</code>, sinon il renvoie <code>true</code>.
+      </td>
+    </tr>
+  </tbody>
 </table>
 
-<p>Les exemples d'expressions qui peuvent être converties à <code>false</code> sont celles qui sont évaluées à <code>null</code>, 0, <code>NaN</code>, la chaîne de caractères vide (""), ou <code>undefined</code>.</p>
+Les exemples d'expressions qui peuvent être converties à `false` sont celles qui sont évaluées à `null`, 0, `NaN`, la chaîne de caractères vide (""), ou `undefined`.
 
-<p>Le code qui suit montre des exemples de l'utilisation de l'opérateur logique ET (&amp;&amp;).</p>
+Le code qui suit montre des exemples de l'utilisation de l'opérateur logique ET (&&).
 
-<pre class="brush: js">var a1 =   true &amp;&amp; true;     // t &amp;&amp; t renvoie true
-var a2 =   true &amp;&amp; false;    // t &amp;&amp; f renvoie false
-var a3 =  false &amp;&amp; true;     // f &amp;&amp; t renvoie false
-var a4 =  false &amp;&amp; (3 == 4); // f &amp;&amp; f renvoie false
-var a5 = "Chat" &amp;&amp; "Chien";  // t &amp;&amp; t renvoie Chien
-var a6 =  false &amp;&amp; "Chat";   // f &amp;&amp; t renvoie false
-var a7 = "Chat" &amp;&amp; false;    // t &amp;&amp; f renvoie false
-</pre>
+```js
+var a1 =   true && true;     // t && t renvoie true
+var a2 =   true && false;    // t && f renvoie false
+var a3 =  false && true;     // f && t renvoie false
+var a4 =  false && (3 == 4); // f && f renvoie false
+var a5 = "Chat" && "Chien";  // t && t renvoie Chien
+var a6 =  false && "Chat";   // f && t renvoie false
+var a7 = "Chat" && false;    // t && f renvoie false
+```
 
-<p>Les exemples suivants montrent l'utilisation de l'opérateur logique OU (||).</p>
+Les exemples suivants montrent l'utilisation de l'opérateur logique OU (||).
 
-<pre class="brush: js">var o1 =   true || true;     // t || t renvoie true
+```js
+var o1 =   true || true;     // t || t renvoie true
 var o2 =  false || true;     // f || t renvoie true
 var o3 =   true || false;    // t || f renvoie true
 var o4 =  false || (3 == 4); // f || f renvoie false
 var o5 = "Chat" || "Chien";  // t || t renvoie Chat
 var o6 =  false || "Chat";   // f || t renvoie Chat
 var o7 = "Chat" || false;    // t || f renvoie Chat
-</pre>
+```
 
-<p>Les exemples suivants montrent l'utilisation de l'opérateur logique NON (!).</p>
+Les exemples suivants montrent l'utilisation de l'opérateur logique NON (!).
 
-<pre class="brush: js">var n1 = !true;   // !t renvoie false
+```js
+var n1 = !true;   // !t renvoie false
 var n2 = !false;  // !f renvoie true
 var n3 = !"Chat"; // !t renvoie false
-</pre>
+```
 
-<h4 id="Evaluation_rapide">Evaluation rapide</h4>
+#### Evaluation rapide
 
-<p>Les expressions logiques sont évaluées de gauche à droite. Cette évaluation utilise des tests pour savoir s'il est possible d'utiliser des « raccourcis » correspondant aux règles suivantes :</p>
+Les expressions logiques sont évaluées de gauche à droite. Cette évaluation utilise des tests pour savoir s'il est possible d'utiliser des « raccourcis » correspondant aux règles suivantes :
 
-<ul>
- <li><code>false</code> &amp;&amp; <em>n'importe quoi</em> sera évalué à <code>false</code>.</li>
- <li><code>true</code> || <em>n'importe quoi </em>sera évalué à <code>true</code>.</li>
-</ul>
+- `false` && _n'importe quoi_ sera évalué à `false`.
+- `true` || _n'importe quoi_ sera évalué à `true`.
 
-<p>Les règles logiques garantissent la validité de ces évaluations, il faut noter que le second opérande n'est pas du tout évalué, empêchant ainsi les effets de bords cachés, liés à cette évaluation.</p>
+Les règles logiques garantissent la validité de ces évaluations, il faut noter que le second opérande n'est pas du tout évalué, empêchant ainsi les effets de bords cachés, liés à cette évaluation.
 
-<h3 id="Opérateurs_de_chaînes_de_caractères">Opérateurs de chaînes de caractères</h3>
+### Opérateurs de chaînes de caractères
 
-<p>En plus des opérateurs de comparaisons qui peuvent être utilisés sur des chaînes de caractères, il existe l'opérateur de concaténation (+) permettant de concaténer deux chaînes de caractères. Le résultat de cette opération est la fusion des deux opérandes en une même chaîne de caractères. Ainsi :</p>
+En plus des opérateurs de comparaisons qui peuvent être utilisés sur des chaînes de caractères, il existe l'opérateur de concaténation (+) permettant de concaténer deux chaînes de caractères. Le résultat de cette opération est la fusion des deux opérandes en une même chaîne de caractères. Ainsi :
 
-<pre class="brush: js">console.log("ma " + "chaîne"); // affichera "ma chaîne" dans la console</pre>
+```js
+console.log("ma " + "chaîne"); // affichera "ma chaîne" dans la console
+```
 
-<p>L'opérateur court += peut également être utilisé pour concaténer des chaînes. Par exemple :</p>
+L'opérateur court += peut également être utilisé pour concaténer des chaînes. Par exemple :
 
-<pre class="brush: js">var maChaîne = "alpha";
+```js
+var maChaîne = "alpha";
 maChaîne += "bet"; // l'expression sera évaluée en "alphabet"
-                   // et cette valeur sera affectée à maChaîne</pre>
+                   // et cette valeur sera affectée à maChaîne
+```
 
-<h3 id="Opérateur_conditionnel_ternaire">Opérateur conditionnel ternaire</h3>
+### Opérateur conditionnel ternaire
 
-<p>L'<a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_conditionnel">opérateur conditionnel</a> est le seul opérateur JavaScript qui utilise trois opérandes. L'expression utilisant l'opérateur peut prendre une valeur parmi deux selon une condition donnée. Cet opérateur s'utilise avec la syntaxe suivante :</p>
+L'[opérateur conditionnel](/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_conditionnel) est le seul opérateur JavaScript qui utilise trois opérandes. L'expression utilisant l'opérateur peut prendre une valeur parmi deux selon une condition donnée. Cet opérateur s'utilise avec la syntaxe suivante :
 
-<pre class="syntaxbox"><em>condition</em> ? <em>val1</em> : <em>val2</em>
-</pre>
+    condition ? val1 : val2
 
-<p>Si <code>condition</code> vaut <code>true</code>, l'opérateur vaudra <code>val1</code>. Sinon il vaudra <code>val2</code>. Il est possible d'utiliser l'opérateur conditionnel aux mêmes endroits qu'un opérateur standard.</p>
+Si `condition` vaut `true`, l'opérateur vaudra `val1`. Sinon il vaudra `val2`. Il est possible d'utiliser l'opérateur conditionnel aux mêmes endroits qu'un opérateur standard.
 
-<p>On peut par exemple avoir :</p>
+On peut par exemple avoir :
 
-<pre class="brush: js">var statut = (âge &gt;= 18) ? "adulte" : "mineur";
-</pre>
+```js
+var statut = (âge >= 18) ? "adulte" : "mineur";
+```
 
-<p>Cette instruction assigne la valeur "adulte" à la variable <code>status</code> si la variable <code>âge</code> est supérieure ou égale à 18. Sinon, on lui affecte la valeur "mineur".</p>
+Cette instruction assigne la valeur "adulte" à la variable `status` si la variable `âge` est supérieure ou égale à 18. Sinon, on lui affecte la valeur "mineur".
 
-<h3 id="La_virgule_comme_opérateur">La virgule comme opérateur</h3>
+### La virgule comme opérateur
 
-<p>L'<a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_virgule">opérateur virgule</a> (<code>,</code>) évalue ses deux opérandes et renvoie la valeur du second opérande. Cet opérateur est principalement utilisé dans les boucles for pour permettre à plusieurs variables d'être modifiées à chaque itération de la boucle.</p>
+L'[opérateur virgule](/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_virgule) (`,`) évalue ses deux opérandes et renvoie la valeur du second opérande. Cet opérateur est principalement utilisé dans les boucles for pour permettre à plusieurs variables d'être modifiées à chaque itération de la boucle.
 
-<p>Ainsi, si on a un tableau à 2 dimensions avec 10 lignes et colonnes, on peut utiliser la virgule comme opérateur pour incrémenter deux variables à la fois. Le code qui suit imprime les valeurs contenues sur la diagonale du tableau :</p>
+Ainsi, si on a un tableau à 2 dimensions avec 10 lignes et colonnes, on peut utiliser la virgule comme opérateur pour incrémenter deux variables à la fois. Le code qui suit imprime les valeurs contenues sur la diagonale du tableau :
 
-<pre class="brush: js">var x = [0,1,2,3,4,5,6,7,8,9]
+```js
+var x = [0,1,2,3,4,5,6,7,8,9]
 var a = [x, x, x, x, x];
 
-for (var i = 0, j = 9; i &lt;= j; i++, j--)
+for (var i = 0, j = 9; i <= j; i++, j--)
   console.log("a[" + i + "][" + j + "]= " + a[i][j]);
-</pre>
+```
 
-<h3 id="Opérateurs_unaires">Opérateurs unaires</h3>
+### Opérateurs unaires
 
-<h4 id="delete"><code>delete</code></h4>
+#### `delete`
 
-<p>L'opérateur <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_delete">delete</a> supprime un objet, une propriété d'un objet ou un élément d'un tableau à partir de sa position dans le tableau. La syntaxe de cet opérateur est la suivante :</p>
+L'opérateur [delete](/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_delete) supprime un objet, une propriété d'un objet ou un élément d'un tableau à partir de sa position dans le tableau. La syntaxe de cet opérateur est la suivante :
 
-<pre class="brush: js">delete monObjet;
+```js
+delete monObjet;
 delete monObjet.propriété;
 delete monObjet[index];
 delete propriété; // uniquement valide au sein d'une instruction with
-</pre>
+```
 
-<p>où on a <code>monObjet</code> qui est le nom de l'objet, <code>propriété</code> qui est une propriété existante et <code>index</code> un entier indiquant la position d'un élément dans un tableau.</p>
+où on a `monObjet` qui est le nom de l'objet, `propriété` qui est une propriété existante et `index` un entier indiquant la position d'un élément dans un tableau.
 
-<p>La quatrième instruction n'est valide qu'au sein d'une instruction <code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/with">with</a></code> et permet de supprimer une propriété d'un objet.</p>
+La quatrième instruction n'est valide qu'au sein d'une instruction [`with`](/fr/docs/Web/JavaScript/Reference/Instructions/with) et permet de supprimer une propriété d'un objet.
 
-<p>Il est possible d'utiliser l'opérateur <code>delete</code> pour supprimer les variables déclarées implicitement mais pas celles déclarées avec <code>var</code>. Si l'opérateur fonctionne correctement, il change la propriété ou l'élément vers la valeur <code>undefined</code>. L'opérateur <code>delete</code> renvoie <code>true</code> si l'opération de suppression est possible, <code>false</code> sinon.</p>
+Il est possible d'utiliser l'opérateur `delete` pour supprimer les variables déclarées implicitement mais pas celles déclarées avec `var`. Si l'opérateur fonctionne correctement, il change la propriété ou l'élément vers la valeur `undefined`. L'opérateur `delete` renvoie `true` si l'opération de suppression est possible, `false` sinon.
 
-<pre class="brush: js">x = 42;
+```js
+x = 42;
 var y = 43;
 monobj = new Number();
 monobj.h = 4;    // création de la propriété h
@@ -570,146 +662,143 @@ delete y;        // renvoie false (suppression impossible si déclaration avec v
 delete Math.PI;  // renvoie false (suppression impossible pour les propriétés pré-définies)
 delete monobj.h; // renvoie true (suppression possible des propriétés définies par l'utilisateur)
 delete monobj;   // renvoie true (suppression possible si déclaration implicite)
-</pre>
+```
 
-<h5 id="Suppression_déléments_dun_tableau">Suppression d'éléments d'un tableau</h5>
+##### Suppression d'éléments d'un tableau
 
-<p>Lorsqu'on supprime un élément d'un tableau, la longueur du tableau n'est pas modifiée. Ainsi, si on supprime <code>a[3]</code>, <code>a[4]</code> restera <code>a[4]</code> (même position et valeur) alors que <code>a[3]</code> sera <code>undefined</code>.</p>
+Lorsqu'on supprime un élément d'un tableau, la longueur du tableau n'est pas modifiée. Ainsi, si on supprime `a[3]`, `a[4]` restera `a[4]` (même position et valeur) alors que `a[3]` sera `undefined`.
 
-<p>Lorsque l'opérateur <code>delete</code> supprime un élément d'un tableau, cet élément n'appartient plus au tableau. Dans l'exemple qui suit, <code>arbres[3]</code> est supprimé mais il est toujours accessible et renvoie <code>undefined</code>.</p>
+Lorsque l'opérateur `delete` supprime un élément d'un tableau, cet élément n'appartient plus au tableau. Dans l'exemple qui suit, `arbres[3]` est supprimé mais il est toujours accessible et renvoie `undefined`.
 
-<pre class="brush: js">var arbres = new Array("sequoia", "laurier", "cèdre", "chêne", "érable");
+```js
+var arbres = new Array("sequoia", "laurier", "cèdre", "chêne", "érable");
 delete arbres[3];
 if (3 in arbres) {
   // Ceci ne sera pas exécuté
 }
-</pre>
+```
 
-<p>Pour qu'un élément continue à exister mais qu'il vaille <code>undefined</code>, on utilisera le mot-clé<code> undefined</code> plutôt que l'opérateur <code>delete</code>. Dans l'exemple qui suit, arbres<code>[3]</code> est modifié pour valoir <code>undefined</code> et l'élément du tableau continue à exister :</p>
+Pour qu'un élément continue à exister mais qu'il vaille `undefined`, on utilisera le mot-clé` undefined` plutôt que l'opérateur `delete`. Dans l'exemple qui suit, arbres`[3]` est modifié pour valoir `undefined` et l'élément du tableau continue à exister :
 
-<pre class="brush: js">var arbres = new Array("sequoia", "laurier", "cèdre", "chêne", "érable");
+```js
+var arbres = new Array("sequoia", "laurier", "cèdre", "chêne", "érable");
 arbres[3] = undefined;
 if (3 in arbres) {
   // Ceci sera exécuté
 }
-</pre>
+```
 
-<h4 id="typeof"><code>typeof</code></h4>
+#### `typeof`
 
-<p>L'<a href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/L_op%C3%A9rateur_typeof">opérateur <code>typeof</code></a> peut être utilisé de deux façons distinctes :</p>
+L'[opérateur `typeof`](/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/L_op%C3%A9rateur_typeof) peut être utilisé de deux façons distinctes :
 
-<ol>
- <li>
-  <pre class="syntaxbox">typeof opérande</pre>
- </li>
- <li>
-  <pre class="syntaxbox">typeof (opérande)
-</pre>
- </li>
-</ol>
+1.       typeof opérande
+2.       typeof (opérande)
 
-<p>L'opérateur <code>typeof</code> renvoie une chaîne de caractères indiquant le type de l'opérande (qui n'est pas évalué). <code>opérande</code> correspond à la chaîne de caractère, la variable, le mot-clé ou l'objet dont on souhaite renvoyer le type. L'utilisation des parenthèses est facultative.</p>
+L'opérateur `typeof` renvoie une chaîne de caractères indiquant le type de l'opérande (qui n'est pas évalué). `opérande` correspond à la chaîne de caractère, la variable, le mot-clé ou l'objet dont on souhaite renvoyer le type. L'utilisation des parenthèses est facultative.
 
-<p>Soient les définitions de variables suivantes :</p>
+Soient les définitions de variables suivantes :
 
-<pre class="brush: js">var maFonction = new Function("5 + 2");
+```js
+var maFonction = new Function("5 + 2");
 var forme = "round";
 var taille = 1;
 var toto = ["Pomme", "Poire", "Orange"];
 var jour = new Date();
-</pre>
+```
 
-<p>L'opérateur <code>typeof</code> renverra les résultats suivants :</p>
+L'opérateur `typeof` renverra les résultats suivants :
 
-<pre class="brush: js">typeof maFonction; // renvoie "function"
+```js
+typeof maFonction; // renvoie "function"
 typeof forme;      // renvoie "string"
 typeof taille;     // renvoie "number"
 typeof toto;       // renvoie "object"
 typeof jour;       // renvoie "object"
 typeof inexistant; // renvoie "undefined"
-</pre>
+```
 
-<p>En ce qui concerne les mots-clés <code>true</code> et <code>null</code>, l'opérateur <code>typeof</code> renvoie les résultats suivants :</p>
+En ce qui concerne les mots-clés `true` et `null`, l'opérateur `typeof` renvoie les résultats suivants :
 
-<pre class="brush: js">typeof true; // renvoie "boolean"
+```js
+typeof true; // renvoie "boolean"
 typeof null; // renvoie "object"
-</pre>
+```
 
-<p>Pour une chaîne de caractères ou un nombre, <code>typeof</code> renvoie les résultats suivants :</p>
+Pour une chaîne de caractères ou un nombre, `typeof` renvoie les résultats suivants :
 
-<pre class="brush: js">typeof 62;            // renvoie "number"
+```js
+typeof 62;            // renvoie "number"
 typeof 'Hello world'; // renvoie "string"
-</pre>
+```
 
-<p>L'opérateur <code>typeof</code>, lorsqu'il est utilisé avec des propriétés, renvoie le type de valeur contenue dans la propriété :</p>
+L'opérateur `typeof`, lorsqu'il est utilisé avec des propriétés, renvoie le type de valeur contenue dans la propriété :
 
-<pre class="brush: js">typeof document.lastModified; // renvoie "string"
+```js
+typeof document.lastModified; // renvoie "string"
 typeof window.length;         // renvoie "number"
 typeof Math.LN2;              // renvoie "number"
-</pre>
+```
 
-<p>Pour les méthodes et les fonctions, l'opérateur <code>typeof</code> renvoie les résultats suivants :</p>
+Pour les méthodes et les fonctions, l'opérateur `typeof` renvoie les résultats suivants :
 
-<pre class="brush: js">typeof blur;        // renvoie "function"
+```js
+typeof blur;        // renvoie "function"
 typeof eval;        // renvoie "function"
 typeof parseInt;    // renvoie "function"
 typeof shape.split; // renvoie "function"
-</pre>
+```
 
-<p>Pour les objets pré-définis, l'opérateur <code>typeof</code> fonctionne ainsi :</p>
+Pour les objets pré-définis, l'opérateur `typeof` fonctionne ainsi :
 
-<pre class="brush: js">typeof Date;     // renvoie "function"
+```js
+typeof Date;     // renvoie "function"
 typeof Function; // renvoie "function"
 typeof Math;     // renvoie "object"
 typeof Option;   // renvoie "function"
 typeof String;   // renvoie "function"
-</pre>
+```
 
-<h4 id="void"><code>void</code></h4>
+#### `void`
 
-<p>L'<a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_void">opérateur <code>void</code></a> peut être utilisé de deux façons :</p>
+L'[opérateur `void`](/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_void) peut être utilisé de deux façons :
 
-<ol>
- <li>
-  <pre class="syntaxbox">void (expression)
-</pre>
- </li>
- <li>
-  <pre class="syntaxbox">void expression
-</pre>
- </li>
-</ol>
+1.       void (expression)
+2.       void expression
 
-<p>L'opérateur <code>void</code> indique qu'une expression doit être évaluée sans retourner de valeur. <code>expression</code> étant une expression JavaScript à évaluer. Les parenthèses sont facultatives mais les utiliser permet d'avoir une meilleur lisibilité du code.</p>
+L'opérateur `void` indique qu'une expression doit être évaluée sans retourner de valeur. `expression` étant une expression JavaScript à évaluer. Les parenthèses sont facultatives mais les utiliser permet d'avoir une meilleur lisibilité du code.
 
-<p>L'opérateur <code>void</code> peut être utilisé pour spécifier une expression comme un lien hypertexte, l'expression est évaluée mais n'est pas chargée à la place du document actuel.</p>
+L'opérateur `void` peut être utilisé pour spécifier une expression comme un lien hypertexte, l'expression est évaluée mais n'est pas chargée à la place du document actuel.
 
-<p>Le fragment de code  qui suit crée un lien hypertexte qui ne fait rien lorsque l'utilisateur clique dessus. Lorsqu'on clique sur le lien, <code>void(0)</code> est évalué à <code>undefined</code>, n'ayant aucun effet.</p>
+Le fragment de code  qui suit crée un lien hypertexte qui ne fait rien lorsque l'utilisateur clique dessus. Lorsqu'on clique sur le lien, `void(0)` est évalué à `undefined`, n'ayant aucun effet.
 
-<pre class="brush: html">&lt;A HREF="javascript:void(0)"&gt;Cliquer ici pour ne rien faire&lt;/A&gt;
-</pre>
+```html
+<A HREF="javascript:void(0)">Cliquer ici pour ne rien faire</A>
+```
 
-<p>Le code suivant crée un lien hypertexte qui envoie un formulaire lorsque l'utilisateur clique dessus.</p>
+Le code suivant crée un lien hypertexte qui envoie un formulaire lorsque l'utilisateur clique dessus.
 
-<pre class="brush: html">&lt;A HREF="javascript:void(document.form.submit())"&gt;
-Cliquer ici pour envoyer&lt;/A&gt;</pre>
+```html
+<A HREF="javascript:void(document.form.submit())">
+Cliquer ici pour envoyer</A>
+```
 
-<h3 id="Opérateurs_relationnels">Opérateurs relationnels</h3>
+### Opérateurs relationnels
 
-<p>Un opérateur relationnel compare ses opérandes et renvoie une valeur booléenne selon que le résultat de la comparaison est vrai ou faux.</p>
+Un opérateur relationnel compare ses opérandes et renvoie une valeur booléenne selon que le résultat de la comparaison est vrai ou faux.
 
-<h4 id="in"><code>in</code></h4>
+#### `in`
 
-<p>L'<a href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/L_op%C3%A9rateur_in">opérateur <code>in</code></a> renvoie <code>true</code> si la propriété indiquée fait partie de l'objet donné. Cet opérateur s'utilise avec la syntaxe suivante :</p>
+L'[opérateur `in`](/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/L_op%C3%A9rateur_in) renvoie `true` si la propriété indiquée fait partie de l'objet donné. Cet opérateur s'utilise avec la syntaxe suivante :
 
-<pre class="syntaxbox">nomOuNumeroPropriete in monObjet
-</pre>
+    nomOuNumeroPropriete in monObjet
 
-<p>avec <code>nomOuNumeroPropriete</code> qui est une chaîne de caractères, une expression numérique ou un symbole correspondant au nom d'une propriété ou un indice de tableau, <code>monObjet</code> est le nom d'un objet.</p>
+avec `nomOuNumeroPropriete` qui est une chaîne de caractères, une expression numérique ou un symbole correspondant au nom d'une propriété ou un indice de tableau, `monObjet` est le nom d'un objet.
 
-<p>Les exemples qui suivent utilisent cet opérateur <code>in</code>.</p>
+Les exemples qui suivent utilisent cet opérateur `in`.
 
-<pre class="brush: js">// Tableaux
+```js
+// Tableaux
 var arbres = new Array("sequoia", "laurier", "cèdre", "chêne", "érable");
 0 in arbres;         // renvoie true
 3 in arbres;         // renvoie true
@@ -727,161 +816,105 @@ var myString = new String("coral");
 var maVoiture = {fabricant: "Honda", modèle: "Accord", year: 1998};
 "fabricant" in maVoiture; // renvoie true
 "modèle" in maVoiture;    // renvoie true
-</pre>
+```
 
-<h4 id="instanceof"><code>instanceof</code></h4>
+#### `instanceof`
 
-<p>L'<a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/instanceof">opérateur instanceof</a> renvoie <code>true</code> si l'objet donné est du type spécifié. Cet opérateur s'utilise avec la syntaxe suivante :</p>
+L'[opérateur instanceof](/fr/docs/Web/JavaScript/Reference/Opérateurs/instanceof) renvoie `true` si l'objet donné est du type spécifié. Cet opérateur s'utilise avec la syntaxe suivante :
 
-<pre class="syntaxbox">nomObjet instanceof typeObjet
-</pre>
+    nomObjet instanceof typeObjet
 
-<p>avec <code>nomObjet</code> qui est le nom de l'objet dont on souhaite comparer le type à <code>typeObjet</code>, <code>typeObjet</code> étant un type d'objet tel que {{jsxref("Date")}} ou {{jsxref("Array")}}.</p>
+avec `nomObjet` qui est le nom de l'objet dont on souhaite comparer le type à `typeObjet`, `typeObjet` étant un type d'objet tel que {{jsxref("Date")}} ou {{jsxref("Array")}}.
 
-<p><code>instanceof</code> peut être utilisé pour confirmer le type d'un objet pendant l'exécution. Ainsi, on peut gérer les exceptions en prévoyant différents cas pour différents types d'exception éventuellement levées.</p>
+`instanceof` peut être utilisé pour confirmer le type d'un objet pendant l'exécution. Ainsi, on peut gérer les exceptions en prévoyant différents cas pour différents types d'exception éventuellement levées.
 
-<p>Dans l'exemple qui suit, le code utilise l'opérateur <code>instanceof</code> afin de déterminer si <code>jour</code> est un objet <code>Date</code>. C'est le cas, les instructions contenues dans le bloc après l'instruction <code>if</code> sont donc exécutées.</p>
+Dans l'exemple qui suit, le code utilise l'opérateur `instanceof` afin de déterminer si `jour` est un objet `Date`. C'est le cas, les instructions contenues dans le bloc après l'instruction `if` sont donc exécutées.
 
-<pre class="brush: js">var jour = new Date(2007, 01, 22);
+```js
+var jour = new Date(2007, 01, 22);
 if (jour instanceof Date) {
   // instructions à exécuter
 }
-</pre>
+```
 
-<h3 id="Précédence_des_opérateurs">Précédence des opérateurs</h3>
+### Précédence des opérateurs
 
-<p>La <em>précédence</em> des opérateurs indique l'ordre dans lequel ils sont appliqués lors de l'évaluation d'une expression. L'utilisation de parenthèses permet de surcharger la relation de précédence.</p>
+La _précédence_ des opérateurs indique l'ordre dans lequel ils sont appliqués lors de l'évaluation d'une expression. L'utilisation de parenthèses permet de surcharger la relation de précédence.
 
-<p>Le tableau qui suit décrit les précédences des opérateurs, dans l'ordre décroissant.</p>
+Le tableau qui suit décrit les précédences des opérateurs, dans l'ordre décroissant.
 
-<table class="standard-table">
- <caption>Précédence des opérateurs</caption>
- <thead>
-  <tr>
-   <th scope="col">Type d'opérateur</th>
-   <th scope="col">Opérateurs individuels</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td>membre</td>
-   <td><code>. []</code></td>
-  </tr>
-  <tr>
-   <td>appel/création d'instance</td>
-   <td><code>() new</code></td>
-  </tr>
-  <tr>
-   <td>négation/incrémentation</td>
-   <td><code>! ~ - + ++ -- typeof void delete</code></td>
-  </tr>
-  <tr>
-   <td>multiplication/division</td>
-   <td><code>* / %</code></td>
-  </tr>
-  <tr>
-   <td>addition/soustraction</td>
-   <td><code>+ -</code></td>
-  </tr>
-  <tr>
-   <td>décalage binaire</td>
-   <td><code>&lt;&lt; &gt;&gt; &gt;&gt;&gt;</code></td>
-  </tr>
-  <tr>
-   <td>relationnel</td>
-   <td><code>&lt; &lt;= &gt; &gt;= in instanceof</code></td>
-  </tr>
-  <tr>
-   <td>égalité</td>
-   <td><code>== != === !==</code></td>
-  </tr>
-  <tr>
-   <td>ET binaire</td>
-   <td><code>&amp;</code></td>
-  </tr>
-  <tr>
-   <td>OU exclusif binaire</td>
-   <td><code>^</code></td>
-  </tr>
-  <tr>
-   <td>OU binaire</td>
-   <td><code>|</code></td>
-  </tr>
-  <tr>
-   <td>ET logique</td>
-   <td><code>&amp;&amp;</code></td>
-  </tr>
-  <tr>
-   <td>OU logique</td>
-   <td><code>||</code></td>
-  </tr>
-  <tr>
-   <td>conditionnel</td>
-   <td><code>?:</code></td>
-  </tr>
-  <tr>
-   <td>assignation</td>
-   <td><code>= += -= *= /= %= &lt;&lt;= &gt;&gt;= &gt;&gt;&gt;= &amp;= ^= |=</code></td>
-  </tr>
-  <tr>
-   <td>virgule</td>
-   <td><code>,</code></td>
-  </tr>
- </tbody>
-</table>
+| Type d'opérateur          | Opérateurs individuels                    |
+| ------------------------- | ----------------------------------------- |
+| membre                    | `. []`                                    |
+| appel/création d'instance | `() new`                                  |
+| négation/incrémentation   | `! ~ - + ++ -- typeof void delete`        |
+| multiplication/division   | `* / %`                                   |
+| addition/soustraction     | `+ -`                                     |
+| décalage binaire          | `<< >> >>>`                               |
+| relationnel               | `< <= > >= in instanceof`                 |
+| égalité                   | `== != === !==`                           |
+| ET binaire                | `&`                                       |
+| OU exclusif binaire       | `^`                                       |
+| OU binaire                | `\|`                                      |
+| ET logique                | `&&`                                      |
+| OU logique                | `\|\|`                                    |
+| conditionnel              | `?:`                                      |
+| assignation               | `= += -= *= /= %= <<= >>= >>>= &= ^= \|=` |
+| virgule                   | `,`                                       |
 
-<p>Une version plus détaillée de cette table peut être trouvée dans la <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Précédence_des_opérateurs#Table">référence JavaScript</a>.</p>
+Une version plus détaillée de cette table peut être trouvée dans la [référence JavaScript](/fr/docs/Web/JavaScript/Reference/Opérateurs/Précédence_des_opérateurs#Table).
 
-<h2 id="Expressions">Expressions</h2>
+## Expressions
 
-<p>Un expression correspond à une unité de code valide qui est résolue en une valeur.</p>
+Un expression correspond à une unité de code valide qui est résolue en une valeur.
 
-<p>D'un point de vue syntaxique, toute expression valide se résout en une valeur. D'un point de vue conceptuel cependant, il y a deux types d'expressions : celles avec des effets de bord (qui, par exemple, affectent une valeur à une variable) et celles qui, d'une certaine façon, sont évaluées et sont résolues en une valeur.</p>
+D'un point de vue syntaxique, toute expression valide se résout en une valeur. D'un point de vue conceptuel cependant, il y a deux types d'expressions : celles avec des effets de bord (qui, par exemple, affectent une valeur à une variable) et celles qui, d'une certaine façon, sont évaluées et sont résolues en une valeur.
 
-<p>L'expression <code>x = 7</code> affecte une valeur (premier type). Dans celle-ci, on utilise l'opérateur <code>=</code> pour affecter la valeur 7 à la variable <code>x</code>. L'expression elle-même est évaluée à 7.</p>
+L'expression `x = 7` affecte une valeur (premier type). Dans celle-ci, on utilise l'opérateur `=` pour affecter la valeur 7 à la variable `x`. L'expression elle-même est évaluée à 7.
 
-<p>Le code <code>3 + 4</code> correspond au second type d'expression. On utilise ici l'opérateur <code>+</code> pour ajouter trois à quatre sans affecter le résultat (7) à une variable.</p>
+Le code `3 + 4` correspond au second type d'expression. On utilise ici l'opérateur `+` pour ajouter trois à quatre sans affecter le résultat (7) à une variable.
 
-<p>Les expressions JavaScript peuvent être rangées selon différentes catégories :</p>
+Les expressions JavaScript peuvent être rangées selon différentes catégories :
 
-<ul>
- <li>Arithmétiques : l'expression est évaluée en un nombre (par exemple 3.14159)</li>
- <li>Textuelles : l'expression est évaluée en une chaîne de caractères</li>
- <li>Logiques : l'expression est évaluée en <code>true</code> ou <code>false</code></li>
- <li>Primaires : Les mots-clés basiques et les expressions générales en JavaScript</li>
- <li>Expressions vers la gauche : Les valeurs à gauche sont la cible d'une affectation</li>
-</ul>
+- Arithmétiques : l'expression est évaluée en un nombre (par exemple 3.14159)
+- Textuelles : l'expression est évaluée en une chaîne de caractères
+- Logiques : l'expression est évaluée en `true` ou `false`
+- Primaires : Les mots-clés basiques et les expressions générales en JavaScript
+- Expressions vers la gauche : Les valeurs à gauche sont la cible d'une affectation
 
-<h3 id="Expressions_primaires">Expressions primaires</h3>
+### Expressions primaires
 
-<p>Ces expressions correspondent aux mots-clés et aux expressions générales en JavaScript.</p>
+Ces expressions correspondent aux mots-clés et aux expressions générales en JavaScript.
 
-<h4 id="this"><code>this</code></h4>
+#### `this`
 
-<p>Le <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_this">mot-clé <code>this</code></a> permet de faire référence à l'objet courant. En général, on l'utilise au sein d'une méthode pour faire référence à l'objet qui a utilisé la méthode. Il s'utilise de cette façon :</p>
+Le [mot-clé `this`](/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_this) permet de faire référence à l'objet courant. En général, on l'utilise au sein d'une méthode pour faire référence à l'objet qui a utilisé la méthode. Il s'utilise de cette façon :
 
-<pre class="syntaxbox">this["nomPropriété"]
-this.nomPropriété</pre>
+    this["nomPropriété"]
+    this.nomPropriété
 
-<p>Soit une fonction qui valide un objet si sa propriété <code>value</code> est comprise entre deux valeurs :</p>
+Soit une fonction qui valide un objet si sa propriété `value` est comprise entre deux valeurs :
 
-<pre class="brush: js">function valide(obj, valMin, valMax){
-  if ((obj.value &lt; valMin) || (obj.value &gt; valMax))
+```js
+function valide(obj, valMin, valMax){
+  if ((obj.value < valMin) || (obj.value > valMax))
     console.log("Valeur incorrecte !");
 }
-</pre>
+```
 
-<p>Il est possible d'appeler <code>valide</code> pour chaque gestionnaire d'événement <code>onChange</code> des éléments du formulaire, et d'utiliser le mot-clé <code>this</code> pour passer l'élément même en argument :</p>
+Il est possible d'appeler `valide` pour chaque gestionnaire d'événement `onChange` des éléments du formulaire, et d'utiliser le mot-clé `this` pour passer l'élément même en argument :
 
-<pre class="brush: html">&lt;p&gt;Entrez un nombre entre 18 et 99 :&lt;/p&gt;
-&lt;input type="text" nom="age" size=3 onChange="valide(this, 18, 99);"&gt;
-</pre>
+```html
+<p>Entrez un nombre entre 18 et 99 :</p>
+<input type="text" nom="age" size=3 onChange="valide(this, 18, 99);">
+```
 
-<h4 id="Opérateur_de_groupement">Opérateur de groupement</h4>
+#### Opérateur de groupement
 
-<p>L'opérateur de groupement <code>( )</code> permet de contrôler la précédence de l'évaluation dans les expressions. On peut ainsi forcer l'évaluation d'une addition avant l'évaluation d'une multiplication ou d'une division.</p>
+L'opérateur de groupement `( )` permet de contrôler la précédence de l'évaluation dans les expressions. On peut ainsi forcer l'évaluation d'une addition avant l'évaluation d'une multiplication ou d'une division.
 
-<pre class="brush: js">var a = 1;
+```js
+var a = 1;
 var b = 2;
 var c = 3;
 
@@ -896,40 +929,44 @@ a + (b * c); // 7
 
 // ce qui équivaut à :
 a * c + b * c; // 9
-</pre>
+```
 
-<h3 id="Expressions_vers_la_gauche">Expressions vers la gauche</h3>
+### Expressions vers la gauche
 
-<p>Les valeurs à gauches de ces expressions sont la cible d'une affectation.</p>
+Les valeurs à gauches de ces expressions sont la cible d'une affectation.
 
-<h4 id="new"><code>new</code></h4>
+#### `new`
 
-<p>L'<a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_new">opérateur <code>new</code></a> permet de créer une instance d'un objet défini par l'utilisateur ou d'un objet dont le type est un des types d'objets natifs. Cet opérateur utilise la syntaxe suivante :</p>
+L'[opérateur `new`](/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_new) permet de créer une instance d'un objet défini par l'utilisateur ou d'un objet dont le type est un des types d'objets natifs. Cet opérateur utilise la syntaxe suivante :
 
-<pre class="brush: js">var nomObjet = new typeObjet([param1, param2, ..., paramN]);
-</pre>
+```js
+var nomObjet = new typeObjet([param1, param2, ..., paramN]);
+```
 
-<h4 id="super">super</h4>
+#### super
 
-<p>Le <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/super">mot-clé <code>super</code></a> est utilisé afin d'appeler des fonctions disponibles sur un objet parent. Il peut notamment être utilisé avec les <a href="/fr/docs/Web/JavaScript/Reference/Classes">classes</a> pour appeler le constructeur parent.</p>
+Le [mot-clé `super`](/fr/docs/Web/JavaScript/Reference/Opérateurs/super) est utilisé afin d'appeler des fonctions disponibles sur un objet parent. Il peut notamment être utilisé avec les [classes](/fr/docs/Web/JavaScript/Reference/Classes) pour appeler le constructeur parent.
 
-<pre class="syntaxbox">super([arguments]); // invoque le constructeur parent
-super.functionParent([arguments]);
-</pre>
+    super([arguments]); // invoque le constructeur parent
+    super.functionParent([arguments]);
 
-<h4 id="Opérateur_de_décomposition">Opérateur de décomposition</h4>
+#### Opérateur de décomposition
 
-<p>L'<a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateur_de_décomposition">opérateur de décomposition</a> permet de développer une expression là où plusieurs argument (pour les appels de fonction) ou plusieurs éléments (pour les littéraux de tableaux) sont attendus.</p>
+L'[opérateur de décomposition](/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateur_de_décomposition) permet de développer une expression là où plusieurs argument (pour les appels de fonction) ou plusieurs éléments (pour les littéraux de tableaux) sont attendus.
 
-<p>Par exemple, si on a tableau et qu'on souhaite créer un nouveau tableau qui contient l'ancien, on peut soit utiliser une combinaison des méthodes <code>push</code>, <code>splice</code>, <code>concat</code>, soit utiliser la syntaxe de décomposition qui s'avère plus concise :</p>
+Par exemple, si on a tableau et qu'on souhaite créer un nouveau tableau qui contient l'ancien, on peut soit utiliser une combinaison des méthodes `push`, `splice`, `concat`, soit utiliser la syntaxe de décomposition qui s'avère plus concise :
 
-<pre class="brush: js">var parts = ['shoulders', 'knees'];
-var lyrics = ['head', ...parts, 'and', 'toes'];</pre>
+```js
+var parts = ['shoulders', 'knees'];
+var lyrics = ['head', ...parts, 'and', 'toes'];
+```
 
-<p>L'opérateur de décomposition fonctionne de façon semblable avec les appels de fonction :</p>
+L'opérateur de décomposition fonctionne de façon semblable avec les appels de fonction :
 
-<pre class="brush: js">function f(x, y, z) { }
+```js
+function f(x, y, z) { }
 var args = [0, 1, 2];
-f(...args);</pre>
+f(...args);
+```
 
-<p>{{PreviousNext("Web/JavaScript/Guide/Fonctions", "Web/JavaScript/Guide/Nombres_et_dates")}}</p>
+{{PreviousNext("Web/JavaScript/Guide/Fonctions", "Web/JavaScript/Guide/Nombres_et_dates")}}
diff --git a/files/fr/web/javascript/guide/functions/index.md b/files/fr/web/javascript/guide/functions/index.md
index 972c9f6286..3c909fba2c 100644
--- a/files/fr/web/javascript/guide/functions/index.md
+++ b/files/fr/web/javascript/guide/functions/index.md
@@ -9,41 +9,42 @@ tags:
 translation_of: Web/JavaScript/Guide/Functions
 original_slug: Web/JavaScript/Guide/Fonctions
 ---
-<p>{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/Boucles_et_it%C3%A9ration", "Web/JavaScript/Guide/Expressions_et_Op%C3%A9rateurs")}}</p>
+{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/Boucles_et_it%C3%A9ration", "Web/JavaScript/Guide/Expressions_et_Op%C3%A9rateurs")}}
 
-<p>Les fonctions font partie des briques fondamentales de JavaScript. Une fonction est une procédure JavaScript, un ensemble d'instructions effectuant une tâche ou calculant une valeur. Afin d'utiliser une fonction, il est nécessaire de l'avoir auparavant définie au sein de la portée dans laquelle on souhaite l'appeler.</p>
+Les fonctions font partie des briques fondamentales de JavaScript. Une fonction est une procédure JavaScript, un ensemble d'instructions effectuant une tâche ou calculant une valeur. Afin d'utiliser une fonction, il est nécessaire de l'avoir auparavant définie au sein de la portée dans laquelle on souhaite l'appeler.
 
-<p>On pourra également lire <a href="/fr/docs/Web/JavaScript/Reference/Fonctions">le chapitre de la référence JavaScript sur les fonctions</a> pour étudier plus en détails ce concept</p>
+On pourra également lire [le chapitre de la référence JavaScript sur les fonctions](/fr/docs/Web/JavaScript/Reference/Fonctions) pour étudier plus en détails ce concept
 
-<h2 id="Définir_des_fonctions">Définir des fonctions</h2>
+## Définir des fonctions
 
-<h3 id="Les_déclarations_de_fonctions">Les déclarations de fonctions</h3>
+### Les déclarations de fonctions
 
-<p>Une <strong>définition de fonction</strong> (aussi appelée <strong>déclaration de fonction</strong> ou <strong>instruction de fonction</strong>) est construite avec le mot-clé <a href="/fr/docs/Web/JavaScript/Reference/Instructions/function"><code>function</code></a>, suivi par :</p>
+Une **définition de fonction** (aussi appelée **déclaration de fonction** ou **instruction de fonction**) est construite avec le mot-clé [`function`](/fr/docs/Web/JavaScript/Reference/Instructions/function), suivi par :
 
-<ul>
- <li>Le nom de la fonction.</li>
- <li>Une liste d'arguments à passer à la fonction, entre parenthèses et séparés par des virgules.</li>
- <li>Les instructions JavaScript définissant la fonction, entre accolades, <code>{ }</code>.</li>
-</ul>
+- Le nom de la fonction.
+- Une liste d'arguments à passer à la fonction, entre parenthèses et séparés par des virgules.
+- Les instructions JavaScript définissant la fonction, entre accolades, `{ }`.
 
-<p>Le code suivant, par exemple, définit une fonction intitulée <code>carré</code> :</p>
+Le code suivant, par exemple, définit une fonction intitulée `carré` :
 
-<pre class="brush: js">function carré(nombre) {
+```js
+function carré(nombre) {
   return nombre * nombre;
 }
-</pre>
+```
 
-<p>La fonction <code>carré</code> prend un seul argument, appelé <code>nombre</code>. La fonction est composée d'une seule instruction qui renvoie l'argument de la fonction (<code>nombre</code>) multiplié par lui-même. L'instruction <a href="/fr/docs/Web/JavaScript/Reference/Instructions/return"><code>return</code></a> spécifie la valeur qui est renvoyée par la fonction.</p>
+La fonction `carré` prend un seul argument, appelé `nombre`. La fonction est composée d'une seule instruction qui renvoie l'argument de la fonction (`nombre`) multiplié par lui-même. L'instruction [`return`](/fr/docs/Web/JavaScript/Reference/Instructions/return) spécifie la valeur qui est renvoyée par la fonction.
 
-<pre class="brush: js">return nombre * nombre;
-</pre>
+```js
+return nombre * nombre;
+```
 
-<p>Les paramètres primitifs (comme les nombres) sont passés à la fonction <strong>par valeur</strong>. La valeur est passée à la fonction mais si cette dernière change la valeur du paramètre, cela n'aura pas d'impact au niveau global ou au niveau de ce qui a appelé la fonction.</p>
+Les paramètres primitifs (comme les nombres) sont passés à la fonction **par valeur**. La valeur est passée à la fonction mais si cette dernière change la valeur du paramètre, cela n'aura pas d'impact au niveau global ou au niveau de ce qui a appelé la fonction.
 
-<p>Si l'argument passé à la fonction est un objet (une valeur non-primitive, comme un objet {{jsxref("Array")}} ou un objet défini par l'utilisateur), et que la fonction change les propriétés de cet objet, ces changements seront visibles en dehors de la fonction. Par exemple :</p>
+Si l'argument passé à la fonction est un objet (une valeur non-primitive, comme un objet {{jsxref("Array")}} ou un objet défini par l'utilisateur), et que la fonction change les propriétés de cet objet, ces changements seront visibles en dehors de la fonction. Par exemple :
 
-<pre class="brush: js">function maFonction(monObjet) {
+```js
+function maFonction(monObjet) {
   monObjet.fabricant = "Toyota";
 }
 
@@ -55,13 +56,12 @@ x = mavoiture.fabricant;     // x aura la valeur "Honda"
 maFonction(mavoiture);
 y = mavoiture.fabricant; // y aura la valeur "Toyota"
                          // (la propriété fabricant a été modifiée par la fonction)
-</pre>
+```
 
-<div class="note">
-<p><strong>Note :</strong> Affecter un nouvel objet au paramètre n'aura <strong>pas</strong> d'effet en dehors de la fonction car cela revient à changer la valeur du paramètre plutôt que la valeur d'une des propriétés de l'objet. Par exemple :</p>
-</div>
+> **Note :** Affecter un nouvel objet au paramètre n'aura **pas** d'effet en dehors de la fonction car cela revient à changer la valeur du paramètre plutôt que la valeur d'une des propriétés de l'objet. Par exemple :
 
-<pre class="brush: js">function maFonction(monObjet) {
+```js
+function maFonction(monObjet) {
   monObjet = {fabricant: "Ford", modèle: "Focus", année: 2006};
 }
 
@@ -72,78 +72,86 @@ x = mavoiture.fabricant;     // x reçoit la valeur "Honda"
 
 maFonction(mavoiture);
 y = mavoiture.fabricant;     // y reçoit la valeur "Honda"
-</pre>
+```
 
-<p>Dans le premier exemple, l'objet <code>mavoiture </code>était passé à la fonction <code>maFonction</code> qui le modifiait. Dans le second exemple, la fonction n'a pas modifié l'objet qui avait été passé en argument, elle a créé une nouvelle variable locale, possédant le même nom que l'objet global passé en argument : il n'y a donc pas de modifications sur cet objet global.</p>
+Dans le premier exemple, l'objet `mavoiture `était passé à la fonction `maFonction` qui le modifiait. Dans le second exemple, la fonction n'a pas modifié l'objet qui avait été passé en argument, elle a créé une nouvelle variable locale, possédant le même nom que l'objet global passé en argument : il n'y a donc pas de modifications sur cet objet global.
 
-<h3 id="Les_expressions_de_fonction">Les expressions de fonction</h3>
+### Les expressions de fonction
 
-<p>Syntaxiquement, la déclaration de fonction utilisée ci-dessus est une instruction. On peut également créer une fonction grâce à une <strong><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_function">expression de fonction</a></strong>. De telles fonctions peuvent être <strong>anonymes</strong> (ne pas avoir de nom correspondant). La fonction <code>carré </code>aurait pu être définie de la façon suivante :</p>
+Syntaxiquement, la déclaration de fonction utilisée ci-dessus est une instruction. On peut également créer une fonction grâce à une **[expression de fonction](/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_function)**. De telles fonctions peuvent être **anonymes** (ne pas avoir de nom correspondant). La fonction `carré `aurait pu être définie de la façon suivante :
 
-<pre class="brush: js">var carré = function (nombre) { return nombre * nombre };
-var x = carré(4); //x reçoit la valeur 16</pre>
+```js
+var carré = function (nombre) { return nombre * nombre };
+var x = carré(4); //x reçoit la valeur 16
+```
 
-<p>Cependant, un nom peut être utilisé dans une expression de fonction, ce afin de l'utiliser dans la fonction (récursivité) ou afin de l'identifier dans les appels tracés par un éventuel débogueur :</p>
+Cependant, un nom peut être utilisé dans une expression de fonction, ce afin de l'utiliser dans la fonction (récursivité) ou afin de l'identifier dans les appels tracés par un éventuel débogueur :
 
-<pre class="brush: js">var factorielle = function fac(n) { return n &lt; 2 ? 1 : n * fac(n - 1) };
+```js
+var factorielle = function fac(n) { return n < 2 ? 1 : n * fac(n - 1) };
 
 console.log(factorielle(3));
-</pre>
+```
 
-<p>Les expressions de fonction sont pratiques lorsqu'il s'agit de passer une fonction comme argument d'une autre fonction. Dans l'exemple qui suit, la fonction <code>map</code> est définie et appelée avec une fonction anonyme comme premier argument :</p>
+Les expressions de fonction sont pratiques lorsqu'il s'agit de passer une fonction comme argument d'une autre fonction. Dans l'exemple qui suit, la fonction `map` est définie et appelée avec une fonction anonyme comme premier argument :
 
-<pre class="brush: js">function map(f, a) {
+```js
+function map(f, a) {
   var resultat = []; // Créer un nouveau tableau Array
   for (var i = 0; i != a.length; i++)
     resultat[i] = f(a[i]);
   return resultat;
 }
-</pre>
+```
 
-<p>Le code suivant applique la fonction <code>cube</code> sur chacun des éléments du tableau :</p>
+Le code suivant applique la fonction `cube` sur chacun des éléments du tableau :
 
-<pre class="brush: js">var cube = function(x) { return x * x * x}; // Une expression de fonction
+```js
+var cube = function(x) { return x * x * x}; // Une expression de fonction
 map(cube, [0, 1, 2, 5, 10]);
-</pre>
+```
 
-<p>Le résultat de la dernière instruction est le tableau [0, 1, 8, 125, 1000].</p>
+Le résultat de la dernière instruction est le tableau \[0, 1, 8, 125, 1000].
 
-<p>En JavaScript, une fonction peut être définie selon une condition. Le fragment de code qui suit définit une fonction seulement si <code>num</code> vaut 0 :</p>
+En JavaScript, une fonction peut être définie selon une condition. Le fragment de code qui suit définit une fonction seulement si `num` vaut 0 :
 
-<pre class="brush: js">var maFonction;
+```js
+var maFonction;
 if (num === 0){
   maFonction = function(monObjet) {
     monObjet.fabricant = "Toyota"
   }
-}</pre>
+}
+```
 
-<p>Une autre façon de définir des fonctions est d'utiliser le constructeur de l'objet {{jsxref("Function")}} afin de créer des fonctions à partir d'une chaîne lors de l'exécution, de la même façon que {{jsxref("Objets_globaux/eval", "eval()")}}.</p>
+Une autre façon de définir des fonctions est d'utiliser le constructeur de l'objet {{jsxref("Function")}} afin de créer des fonctions à partir d'une chaîne lors de l'exécution, de la même façon que {{jsxref("Objets_globaux/eval", "eval()")}}.
 
-<p>Une <strong>méthode</strong> est une fonction étant une propriété d'un objet. Vous trouverez plus de détails sur ces éléments dans le chapitre suivant du guide : <a href="/fr/docs/JavaScript/Guide/Utiliser_les_objets">Utiliser les objets</a>.</p>
+Une **méthode** est une fonction étant une propriété d'un objet. Vous trouverez plus de détails sur ces éléments dans le chapitre suivant du guide : [Utiliser les objets](/fr/docs/JavaScript/Guide/Utiliser_les_objets).
 
-<h2 id="Appeler_des_fonctions">Appeler des fonctions</h2>
+## Appeler des fonctions
 
-<p>La seule définition d'une fonction ne permet pas d'exécuter la fonction. Cela permet de lui donner un nom et de définir ce qui doit être fait lorsque la fonction est appelée. <strong>Appeler</strong> la fonction permet d'effectuer les actions des instructions avec les paramètres indiqués. Par exemple, si on définit la fonction <code>carré</code>, on peut l'appeler de la façon suivante :</p>
+La seule définition d'une fonction ne permet pas d'exécuter la fonction. Cela permet de lui donner un nom et de définir ce qui doit être fait lorsque la fonction est appelée. **Appeler** la fonction permet d'effectuer les actions des instructions avec les paramètres indiqués. Par exemple, si on définit la fonction `carré`, on peut l'appeler de la façon suivante :
 
-<pre class="brush: js">carré(5);
-</pre>
+```js
+carré(5);
+```
 
-<p>Cette instruction appellera la fonction avec un argument valant 5. La fonction exécute ses instructions et renvoie la valeur 25.</p>
+Cette instruction appellera la fonction avec un argument valant 5. La fonction exécute ses instructions et renvoie la valeur 25.
 
-<p>Les fonctions doivent appartenir à la portée dans laquelle elles sont appelées. En revanche, la déclaration d'une fonction peut être faite après l'appel :</p>
+Les fonctions doivent appartenir à la portée dans laquelle elles sont appelées. En revanche, la déclaration d'une fonction peut être faite après l'appel :
 
-<pre class="brush: js">console.log(carré(5));
+```js
+console.log(carré(5));
 /* ... */
 function carré(n) { return n*n }
-</pre>
+```
 
-<p>La portée d'une fonction est la fonction dans laquelle elle est déclarée ou le programme entier si elle est déclarée au niveau le plus haut.</p>
+La portée d'une fonction est la fonction dans laquelle elle est déclarée ou le programme entier si elle est déclarée au niveau le plus haut.
 
-<div class="note">
-<p><strong>Note :</strong> Cela ne fonctionne que si la définition de la fonction utilise la syntaxe précédente (<code>function nomFonction(){}</code>). Le code ci-dessous ne fonctionnera pas :</p>
-</div>
+> **Note :** Cela ne fonctionne que si la définition de la fonction utilise la syntaxe précédente (`function nomFonction(){}`). Le code ci-dessous ne fonctionnera pas :
 
-<pre class="example-bad brush: js">console.log(carré); // La fonction carré est remontée/hoisted mais vaut undefined
+```js example-bad
+console.log(carré); // La fonction carré est remontée/hoisted mais vaut undefined
 console.log(carré(5)); // TypeError: carré is not a function
 var carré = function (n) {
   return n * n;
@@ -157,37 +165,40 @@ console.log(carré2(5)); // TypeError: carré2 is not a function
 let carré2 = function (n) {
   return n * n;
 }
-</pre>
+```
 
-<p>Les arguments d'une fonction ne sont pas limités aux chaînes de caractères et aux nombres. Il est possible de passer des objets. La fonction <code>show_props</code> (définie dans le chapitre sur <a href="/fr/docs/JavaScript/Guide/Utiliser_les_objets">l'utilisation des objets</a>) est un exemple de fonction utilisant un argument qui est un objet.</p>
+Les arguments d'une fonction ne sont pas limités aux chaînes de caractères et aux nombres. Il est possible de passer des objets. La fonction `show_props` (définie dans le chapitre sur [l'utilisation des objets](/fr/docs/JavaScript/Guide/Utiliser_les_objets)) est un exemple de fonction utilisant un argument qui est un objet.
 
-<p>Une fonction peut être récursive, c'est-à-dire qu'elle peut s'appeler elle-même. Voici la fonction qui calcule récursivement la factorielle d'un nombre :</p>
+Une fonction peut être récursive, c'est-à-dire qu'elle peut s'appeler elle-même. Voici la fonction qui calcule récursivement la factorielle d'un nombre :
 
-<pre class="brush: js">function factorielle(n){
+```js
+function factorielle(n){
   if ((n === 0) || (n === 1))
     return 1;
   else
     return (n * factorielle(n - 1));
 }
-</pre>
+```
 
-<p>On peut ensuite calculer les factorielles des nombres 1 à 5 :</p>
+On peut ensuite calculer les factorielles des nombres 1 à 5 :
 
-<pre class="brush: js">var a, b, c, d, e;
+```js
+var a, b, c, d, e;
 a = factorielle(1); // a reçoit la valeur 1
 b = factorielle(2); // b reçoit la valeur 2
 c = factorielle(3); // c reçoit la valeur 6
 d = factorielle(4); // d reçoit la valeur 24
 e = factorielle(5); // e reçoit la valeur 120
-</pre>
+```
 
-<p>Il existe d'autres façons d'appeler des fonctions. Il existe souvent des cas où une fonction doit être appelée dynamiquement, où le nombre d'arguments peut varier, où le contexte de l'appel d'une fonction doit être créé en fonction d'un objet déterminé lors de l'exécution. Les fonctions sont des objets, en tant que tels, elles possèdent des méthodes (voir la page sur l'objet {{jsxref("Function")}}). L'une d'entre elles, {{jsxref("Function.apply","apply()")}} peut être utilisée pour réaliser le dernier cas de figure (exécution d'une fonction avec un objet déterminé à l'exécution).</p>
+Il existe d'autres façons d'appeler des fonctions. Il existe souvent des cas où une fonction doit être appelée dynamiquement, où le nombre d'arguments peut varier, où le contexte de l'appel d'une fonction doit être créé en fonction d'un objet déterminé lors de l'exécution. Les fonctions sont des objets, en tant que tels, elles possèdent des méthodes (voir la page sur l'objet {{jsxref("Function")}}). L'une d'entre elles, {{jsxref("Function.apply","apply()")}} peut être utilisée pour réaliser le dernier cas de figure (exécution d'une fonction avec un objet déterminé à l'exécution).
 
-<h2 id="Portée_d'une_fonction">Portée d'une fonction</h2>
+## Portée d'une fonction
 
-<p>On ne peut pas accéder aux variables définies dans une fonction en dehors de cette fonction : ces variables n'existent que dans la portée de la fonction. En revanche, une fonction peut accéder aux différentes variables et fonctions qui appartiennent à la portée dans laquelle elle est définie. Une fonction définie dans une autre fonction peut également accéder à toutes les variables de la fonction « parente » et à toute autre variable accessible depuis la fonction « parente ».</p>
+On ne peut pas accéder aux variables définies dans une fonction en dehors de cette fonction : ces variables n'existent que dans la portée de la fonction. En revanche, une fonction peut accéder aux différentes variables et fonctions qui appartiennent à la portée dans laquelle elle est définie. Une fonction définie dans une autre fonction peut également accéder à toutes les variables de la fonction « parente » et à toute autre variable accessible depuis la fonction « parente ».
 
-<pre class="brush: js">// Les variables suivantes sont globales
+```js
+// Les variables suivantes sont globales
 var num1 = 20,
     num2 = 3,
     nom = "Licorne";
@@ -212,112 +223,117 @@ function getScore () {
 }
 
 getScore(); // Renvoie "Licorne a marqué 5"
-</pre>
+```
 
-<h2 id="Portée_et_pile_de_fonctions">Portée et pile de fonctions</h2>
+## Portée et pile de fonctions
 
-<h3 id="La_récursivité">La récursivité</h3>
+### La récursivité
 
-<p>Une fonction peut faire référence à elle-même et s'appeler elle-même. Il existe trois moyens pour qu'une fonction fasse référence à elle-même :</p>
+Une fonction peut faire référence à elle-même et s'appeler elle-même. Il existe trois moyens pour qu'une fonction fasse référence à elle-même :
 
-<ol>
- <li>Le nom de la fonction</li>
- <li><code><a href="/fr/docs/Web/JavaScript/Reference/Fonctions/arguments/callee">arguments.callee</a></code></li>
- <li>Une variable de la portée qui fait référence à la fonction</li>
-</ol>
+1.  Le nom de la fonction
+2.  [`arguments.callee`](/fr/docs/Web/JavaScript/Reference/Fonctions/arguments/callee)
+3.  Une variable de la portée qui fait référence à la fonction
 
-<p>Par exemple, avec la définition de fonction suivante :</p>
+Par exemple, avec la définition de fonction suivante :
 
-<pre class="brush: js">var toto = function truc() {
+```js
+var toto = function truc() {
    // les instructions de la fonction
-};</pre>
+};
+```
 
-<p>Dans le corps de la fonction, ces trois éléments seront équivalents :</p>
+Dans le corps de la fonction, ces trois éléments seront équivalents :
 
-<ol>
- <li><code>truc()</code></li>
- <li><code>arguments.callee()</code></li>
- <li><code>toto()</code></li>
-</ol>
+1.  `truc()`
+2.  `arguments.callee()`
+3.  `toto()`
 
-<p>Une fonction qui s'appelle elle-même est appelée une fonction <em>récursive</em>. Sous certains aspects, une récursion est semblable à une boucle : toutes les deux exécutent le même code plusieurs fois et toutes les deux requièrent une condition d'arrêt (pour éviter une boucle ou une récursion infinie). Par exemple, ce fragment de code utilisant une boucle :</p>
+Une fonction qui s'appelle elle-même est appelée une fonction _récursive_. Sous certains aspects, une récursion est semblable à une boucle : toutes les deux exécutent le même code plusieurs fois et toutes les deux requièrent une condition d'arrêt (pour éviter une boucle ou une récursion infinie). Par exemple, ce fragment de code utilisant une boucle :
 
-<pre class="brush: js">var x = 0;
-while (x &lt; 10) { // "x &lt; 10" représente la condition d'arrêt
+```js
+var x = 0;
+while (x < 10) { // "x < 10" représente la condition d'arrêt
   // faire quelque chose
   x++;
-}</pre>
+}
+```
 
-<p>pourra être converti en une fonction récursive de la façon suivante :</p>
+pourra être converti en une fonction récursive de la façon suivante :
 
-<pre class="brush: js">function boucle(x) {
-  if (x &gt;= 10) // "x &gt;= 10" représente la condition d'arrêt (équivalent à "!(x &lt; 10)")
+```js
+function boucle(x) {
+  if (x >= 10) // "x >= 10" représente la condition d'arrêt (équivalent à "!(x < 10)")
     return;
   // faire quelque chose
   boucle(x + 1); // l'appel récursif
 }
-boucle(0);</pre>
+boucle(0);
+```
 
-<p>Malgré cela, certains algorithmes ne peuvent pas être convertis en boucles itératives. Ainsi, récupérer l'ensemble des nœuds d'un arbre (le <a href="/fr/docs/Web/API/Référence_du_DOM_Gecko">DOM</a> par exemple) se fait plus simplement en utilisant la récursivité :</p>
+Malgré cela, certains algorithmes ne peuvent pas être convertis en boucles itératives. Ainsi, récupérer l'ensemble des nœuds d'un arbre (le [DOM](/fr/docs/Web/API/Référence_du_DOM_Gecko) par exemple) se fait plus simplement en utilisant la récursivité :
 
-<pre class="brush: js">function parcourirArbre(noeud) {
+```js
+function parcourirArbre(noeud) {
   if (noeud === null) //
     return;
   // faire quelque chose avec le noeud
-  for (var i = 0; i &lt; noeud.childNodes.length; i++) {
+  for (var i = 0; i < noeud.childNodes.length; i++) {
     parcourirArbre(noeud.childNodes[i]);
   }
-}</pre>
+}
+```
 
-<p>Contrairement à l'exemple précédent avec la fonction <code>boucle</code>, ici, chaque appel récursif entraîne lui-même plusieurs appels (et non un seul).</p>
+Contrairement à l'exemple précédent avec la fonction `boucle`, ici, chaque appel récursif entraîne lui-même plusieurs appels (et non un seul).
 
-<p>Théoriquement, il est possible de convertir tout algorithme récursif en un algorithme non récursif (avec des boucles par exemple). Généralement, la logique obtenue est plus complexe et nécessite l'utilisation d'une <a href="https://fr.wikipedia.org/wiki/Pile_%28informatique%29">pile</a>. La récursivité utilise également une pile, la pile de fonction.</p>
+Théoriquement, il est possible de convertir tout algorithme récursif en un algorithme non récursif (avec des boucles par exemple). Généralement, la logique obtenue est plus complexe et nécessite l'utilisation d'une [pile](https://fr.wikipedia.org/wiki/Pile_%28informatique%29). La récursivité utilise également une pile, la pile de fonction.
 
-<p>Ce type de « comportement » peut-être observé avec l'exemple suivant :</p>
+Ce type de « comportement » peut-être observé avec l'exemple suivant :
 
-<pre class="brush: js">function toto(i) {
-  if (i &lt; 0)
+```js
+function toto(i) {
+  if (i < 0)
     return;
   console.log('début : ' + i);
   toto(i - 1);
   console.log('fin : ' + i);
 }
-toto(3);</pre>
+toto(3);
+```
 
-<p>qui affichera :</p>
+qui affichera :
 
-<pre class="brush: js">début : 3
+```js
+début : 3
 début : 2
 début : 1
 début : 0
 fin : 0
 fin : 1
 fin : 2
-fin : 3</pre>
+fin : 3
+```
 
-<h3 id="Fonctions_imbriquées_et_fermetures">Fonctions imbriquées et fermetures</h3>
+### Fonctions imbriquées et fermetures
 
-<p>Il est possible d'imbriquer une fonction dans une autre fonction. La portée de la fonction fille (celle qui est imbriquée) n'est pas contenue dans la portée de la fonction parente. En revanche, la fonction fille bénéficie bien des informations de la fonction parente grâce à sa portée. On a ce qu'on appelle une fermeture (<em>closure</em> en anglais). Une fermeture est une expression (généralement une fonction) qui accède à des variables libres ainsi qu'à un environnement qui lie ces variables (ce qui « ferme » l'expression).</p>
+Il est possible d'imbriquer une fonction dans une autre fonction. La portée de la fonction fille (celle qui est imbriquée) n'est pas contenue dans la portée de la fonction parente. En revanche, la fonction fille bénéficie bien des informations de la fonction parente grâce à sa portée. On a ce qu'on appelle une fermeture (_closure_ en anglais). Une fermeture est une expression (généralement une fonction) qui accède à des variables libres ainsi qu'à un environnement qui lie ces variables (ce qui « ferme » l'expression).
 
-<p>Une fonction imbriquée étant une fermeture, cela signifie qu'une fonction imbriquée peut en quelque sorte hériter des arguments et des variables de la fonction parente.</p>
+Une fonction imbriquée étant une fermeture, cela signifie qu'une fonction imbriquée peut en quelque sorte hériter des arguments et des variables de la fonction parente.
 
-<p>En résumé :</p>
+En résumé :
 
-<ul>
- <li>La fonction imbriquée ne peut être utilisée qu'à partir des instructions de la fonction parente.</li>
-</ul>
+- La fonction imbriquée ne peut être utilisée qu'à partir des instructions de la fonction parente.
 
-<ul>
- <li>La fonction imbriquée forme une fermeture : elle peut utiliser les arguments et les variables de la fonction parente. En revanche, la fonction parente ne peut pas utiliser les arguments et les variables de la fonction fille.</li>
-</ul>
+<!---->
 
-<div class="note">
-<p><strong>Note :</strong> Sur les fermetures, voir également <a href="/fr/docs/Web/JavaScript/Closures">l'article à ce sujet</a>.</p>
-</div>
+- La fonction imbriquée forme une fermeture : elle peut utiliser les arguments et les variables de la fonction parente. En revanche, la fonction parente ne peut pas utiliser les arguments et les variables de la fonction fille.
 
-<p>L'exemple qui suit illustre l'imbrication de fonctions :</p>
+> **Note :** Sur les fermetures, voir également [l'article à ce sujet](/fr/docs/Web/JavaScript/Closures).
 
-<pre class="brush: js">function ajouteCarrés(a, b) {
+L'exemple qui suit illustre l'imbrication de fonctions :
+
+```js
+function ajouteCarrés(a, b) {
   function carré(x) {
     return x * x;
   }
@@ -325,11 +341,13 @@ fin : 3</pre>
 }
 a = ajouteCarrés(2,3); // renvoie 13
 b = ajouteCarrés(3,4); // renvoie 25
-c = ajouteCarrés(4,5); // renvoie 41</pre>
+c = ajouteCarrés(4,5); // renvoie 41
+```
 
-<p>La fonction interne étant une fermeture, on peut appeler la fonction parente afin de définir les arguments pour la fonction englobante et ceux de la fonction fille :</p>
+La fonction interne étant une fermeture, on peut appeler la fonction parente afin de définir les arguments pour la fonction englobante et ceux de la fonction fille :
 
-<pre class="brush: js">function parente(x) {
+```js
+function parente(x) {
   function fille(y) {
     return x + y;
   }
@@ -338,21 +356,23 @@ c = ajouteCarrés(4,5); // renvoie 41</pre>
 fn_fille = parente(3); // Fournit une fonction qui ajoute 3 à ce qu'on lui donnera
 résultat = fn_fille(5); // renvoie 8
 
-résultat1 = parente(3)(5); // renvoie 8</pre>
+résultat1 = parente(3)(5); // renvoie 8
+```
 
-<h3 id="Préservation_des_variables">Préservation des variables</h3>
+### Préservation des variables
 
-<p>Dans l'exemple précédent, <code>x</code> a été « préservé » lorsque la fonction <code>fille</code> a été renvoyée. Une fermeture conserve les arguments et les variables de chaque portée qu'elle référence. Chaque appel à la fonction parente pouvant fournir un contexte différents selon les arguments, cela entraînera la création d'une nouvelle fermeture. La mémoire associée ne pourra être libérée que lorsque la fonction <code>fille</code> ne sera plus accessible.</p>
+Dans l'exemple précédent, `x` a été « préservé » lorsque la fonction `fille` a été renvoyée. Une fermeture conserve les arguments et les variables de chaque portée qu'elle référence. Chaque appel à la fonction parente pouvant fournir un contexte différents selon les arguments, cela entraînera la création d'une nouvelle fermeture. La mémoire associée ne pourra être libérée que lorsque la fonction `fille` ne sera plus accessible.
 
-<p>Ce mode de fonctionnement n'est pas différent de celui des références vers les objets. Cependant, il est souvent plus compliqué à détecter car les références ne sont pas définies explicitement dans le code et car il n'est pas possible de les inspecter.</p>
+Ce mode de fonctionnement n'est pas différent de celui des références vers les objets. Cependant, il est souvent plus compliqué à détecter car les références ne sont pas définies explicitement dans le code et car il n'est pas possible de les inspecter.
 
-<h3 id="Imbriquer_plusieurs_fonctions">Imbriquer plusieurs fonctions</h3>
+### Imbriquer plusieurs fonctions
 
-<p>Il est possible d'imbriquer des fonctions sur plus de deux niveaux, par exemple, on peut avoir une fonction A qui contient une fonction B qui contient une fonction C. Les fonctions B et C sont des fermetures et B peut accéder à la portée de A, C peut accéder à la portée de B. Ainsi, C accède à la portée de B qui lui accède à la portée de A, C accède donc à la portée de A (transitivité). Les fermetures peuvent donc contenir plusieurs portées, c'est ce qu'on appelle le <em>chaînage</em> de portées.</p>
+Il est possible d'imbriquer des fonctions sur plus de deux niveaux, par exemple, on peut avoir une fonction A qui contient une fonction B qui contient une fonction C. Les fonctions B et C sont des fermetures et B peut accéder à la portée de A, C peut accéder à la portée de B. Ainsi, C accède à la portée de B qui lui accède à la portée de A, C accède donc à la portée de A (transitivité). Les fermetures peuvent donc contenir plusieurs portées, c'est ce qu'on appelle le _chaînage_ de portées.
 
-<p>Par exemple :</p>
+Par exemple :
 
-<pre class="brush: js">function A(x) {
+```js
+function A(x) {
   function B(y) {
     function C(z) {
       console.log(x + y + z);
@@ -361,38 +381,40 @@ résultat1 = parente(3)(5); // renvoie 8</pre>
   }
   B(2);
 }
-A(1); // affichera 6 (1 + 2 + 3)</pre>
+A(1); // affichera 6 (1 + 2 + 3)
+```
 
-<p>Dans cet exemple <code>C</code> accède au <code>y</code> de <code>B</code> et au <code>x</code> de <code>A</code>. Ceci est rendu possible car :</p>
+Dans cet exemple `C` accède au `y` de `B` et au `x` de `A`. Ceci est rendu possible car :
 
-<ol>
- <li><code>B</code> est une fermeture qui contient <code>A</code>, autrement dit <code>B</code> peut accéder aux arguments et aux variables de <code>A</code>.</li>
- <li><code>C</code> est une fermeture qui contient <code>B</code>.</li>
- <li>La fermeture de <code>B</code> contient <code>A</code> donc la fermeture de <code>C</code> contient <code>A</code>, <code>C</code> peut ainsi accéder aux arguments et aux variables de <code>B</code> <em>et</em> <code>A</code>. On dit que <code>C</code> <em>chaîne</em> les portées de <code>B</code> et de <code>A</code> (dans cet ordre).</li>
-</ol>
+1.  `B` est une fermeture qui contient `A`, autrement dit `B` peut accéder aux arguments et aux variables de `A`.
+2.  `C` est une fermeture qui contient `B`.
+3.  La fermeture de `B` contient `A` donc la fermeture de `C` contient `A`, `C` peut ainsi accéder aux arguments et aux variables de `B` _et_ `A`. On dit que `C` _chaîne_ les portées de `B` et de `A` (dans cet ordre).
 
-<p>La réciproque n'est pas vraie. <code>A</code> ne peut pas accéder à <code>C</code>, car <code>A</code> ne peut pas accéder aux arguments ou aux variables de <code>B</code>, or <code>C</code> est une variable de <code>B</code>. De cette façon, <code>C</code> reste privée en dehors de <code>B</code>.</p>
+La réciproque n'est pas vraie. `A` ne peut pas accéder à `C`, car `A` ne peut pas accéder aux arguments ou aux variables de `B`, or `C` est une variable de `B`. De cette façon, `C` reste privée en dehors de `B`.
 
-<h3 id="Conflits_de_nommage">Conflits de nommage</h3>
+### Conflits de nommage
 
-<p>Lorsque deux arguments ou variables des portées d'une fermeture ont le même nom, il y a un conflit de noms. Dans ces cas, ce sera la portée la plus imbriquée qui prendra la priorité sur le nom, la portée la plus « externe » aura la priorité la plus faible pour les noms de variables. Du point de vue de la chaîne des portées, la première portée sur la chaîne est la portée la plus imbriquée et la dernière est la portée située le plus à l'extérieur :</p>
+Lorsque deux arguments ou variables des portées d'une fermeture ont le même nom, il y a un conflit de noms. Dans ces cas, ce sera la portée la plus imbriquée qui prendra la priorité sur le nom, la portée la plus « externe » aura la priorité la plus faible pour les noms de variables. Du point de vue de la chaîne des portées, la première portée sur la chaîne est la portée la plus imbriquée et la dernière est la portée située le plus à l'extérieur :
 
-<pre class="brush: js">function externe() {
+```js
+function externe() {
   var x = 10;
   function interne(x) {
     return x;
   }
   return interne;
 }
-résultat = externe()(20); // renvoie 20 et pas 10</pre>
+résultat = externe()(20); // renvoie 20 et pas 10
+```
 
-<p>Le conflit se produit à l'instruction <code>return x</code> entre le paramètre x de la fonction <code>interne</code> et la variable <code>x</code> de la fonction <code>externe</code>. La chaîne de portée est ici {<code>interne</code>, <code>externe</code>, objet global}. Ainsi, le paramètre <code>x</code> de <code>interne</code> a la priorité sur la variable <code>x</code> de la fonction <code>externe</code>, le résultat obtenu est donc 20 et non 10.</p>
+Le conflit se produit à l'instruction `return x` entre le paramètre x de la fonction `interne` et la variable `x` de la fonction `externe`. La chaîne de portée est ici {`interne`, `externe`, objet global}. Ainsi, le paramètre `x` de `interne` a la priorité sur la variable `x` de la fonction `externe`, le résultat obtenu est donc 20 et non 10.
 
-<h2 id="Fermetures_(closures)">Fermetures (<em>closures</em>)</h2>
+## Fermetures (_closures_)
 
-<p>Les fermetures sont l'une des fonctionnalités les plus intéressantes de JavaScript. Comme on l'a vu précédemment, JavaScript permet d'imbriquer des fonctions et la fonction interne aura accès aux variables et paramètres de la fonction parente. À l'inverse, la fonction parente ne pourra pas accéder aux variables liées à la fonction interne. Cela fournit une certaine sécurité pour les variables de la fonction interne. De plus, si la fonction interne peut exister plus longtemps que la fonction parente, les variables et fonctions de la fonction parente pourront exister au travers de la fonction interne. On crée une fermeture lorsque la fonction interne est disponible en dehors de la fonction parente.</p>
+Les fermetures sont l'une des fonctionnalités les plus intéressantes de JavaScript. Comme on l'a vu précédemment, JavaScript permet d'imbriquer des fonctions et la fonction interne aura accès aux variables et paramètres de la fonction parente. À l'inverse, la fonction parente ne pourra pas accéder aux variables liées à la fonction interne. Cela fournit une certaine sécurité pour les variables de la fonction interne. De plus, si la fonction interne peut exister plus longtemps que la fonction parente, les variables et fonctions de la fonction parente pourront exister au travers de la fonction interne. On crée une fermeture lorsque la fonction interne est disponible en dehors de la fonction parente.
 
-<pre class="brush: js">var animal = function(nom) {   // La fonction externe utilise un paramètre "nom"
+```js
+var animal = function(nom) {   // La fonction externe utilise un paramètre "nom"
   var getNom = function () {
     return nom;                // La fonction interne accède à la variable "nom" de la fonction externe
   }
@@ -401,11 +423,13 @@ résultat = externe()(20); // renvoie 20 et pas 10</pre>
 
 monAnimal = animal("Licorne");
 
-monAnimal();                   // Renvoie "Licorne"</pre>
+monAnimal();                   // Renvoie "Licorne"
+```
 
-<p>Bien entendu, dans la pratique, les cas peuvent être plus complexes. On peut renvoyer un objet qui contient des méthodes manipulant les variables internes de la fonction parente.</p>
+Bien entendu, dans la pratique, les cas peuvent être plus complexes. On peut renvoyer un objet qui contient des méthodes manipulant les variables internes de la fonction parente.
 
-<pre class="brush: js">var créerAnimal  = function (nom) {
+```js
+var créerAnimal  = function (nom) {
   var sexe;
 
   return {
@@ -422,7 +446,7 @@ monAnimal();                   // Renvoie "Licorne"</pre>
     },
 
     setSexe: function(nouveauSexe) {
-      if (typeof nouveauSexe == "string" &amp;&amp; (nouveauSexe.toLowerCase() == "mâle" || nouveauSexe.toLowerCase() == "femelle")) {
+      if (typeof nouveauSexe == "string" && (nouveauSexe.toLowerCase() == "mâle" || nouveauSexe.toLowerCase() == "femelle")) {
         sexe = nouveauSexe;
       }
     }
@@ -435,126 +459,141 @@ animal.getNom();        // Licorne
 animal.setNom("Bobby");
 animal.setSexe("mâle");
 animal.getSexe();       // mâle
-animal.getNom();        // Bobby</pre>
+animal.getNom();        // Bobby
+```
 
-<p>Dans le code précédent, la variable <code>nom</code> est de la fonction externe est accessible depuis les fonctions internes. Il est impossible d'accéder aux variables internes en dehors des fonctions internes. Les variables internes agissent comme des coffres-forts pour les fonctions internes. Elles permettent d'avoir un accès persistent et encapsulé aux données internes. Pour les fonctions, il n'est pas nécessaire de les affecter à une variable ou même de les nommer.</p>
+Dans le code précédent, la variable `nom` est de la fonction externe est accessible depuis les fonctions internes. Il est impossible d'accéder aux variables internes en dehors des fonctions internes. Les variables internes agissent comme des coffres-forts pour les fonctions internes. Elles permettent d'avoir un accès persistent et encapsulé aux données internes. Pour les fonctions, il n'est pas nécessaire de les affecter à une variable ou même de les nommer.
 
-<pre class="brush: js">var getCode = (function (){
-  var codeAPI = "0]Eal(eh&amp;2";    // Un code qu'on ne souhaite pas diffuser ni modifier
+```js
+var getCode = (function (){
+  var codeAPI = "0]Eal(eh&2";    // Un code qu'on ne souhaite pas diffuser ni modifier
 
   return function () {
     return codeAPI;
   };
 })();
 
-getCode();    // Renvoie la valeur du code</pre>
+getCode();    // Renvoie la valeur du code
+```
 
-<p>Il y a malgré tout quelques pièges auxquels il faut faire attention lorsqu'on utilise les fermetures. Si une fonction imbriquée définit une variable avec le même nom que le nom d'une variable de la portée externe, il n'y aura plus aucun moyen d'accéder à la variable.</p>
+Il y a malgré tout quelques pièges auxquels il faut faire attention lorsqu'on utilise les fermetures. Si une fonction imbriquée définit une variable avec le même nom que le nom d'une variable de la portée externe, il n'y aura plus aucun moyen d'accéder à la variable.
 
-<pre class="brush: js">var créerAnimal = function(nom) {  // La fonction externe définit une variable appelée "nom"
+```js
+var créerAnimal = function(nom) {  // La fonction externe définit une variable appelée "nom"
   return {
     setNom: function(nom) {    // La fonction imbriquée définit une variable appelée "nom"
       nom = nom;               // ??? comment accéder à la variable "nom" définie par la fonction externe
     }
   }
-}</pre>
+}
+```
 
-<p>L<code>'opérateur </code><a href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/L_op%C3%A9rateur_this"><code>this</code></a> doit être traité avec précaution dans les fermetures. Attention, <code>this</code> fait référence au contexte où la fonction est appelée et non à l'endroit où il est défini.</p>
+L`'opérateur `[`this`](/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/L_op%C3%A9rateur_this) doit être traité avec précaution dans les fermetures. Attention, `this` fait référence au contexte où la fonction est appelée et non à l'endroit où il est défini.
 
-<h2 id="Utiliser_l'objet_arguments">Utiliser l'objet <code>arguments</code></h2>
+## Utiliser l'objet `arguments`
 
-<p>Les arguments d'une fonction sont maintenus dans un objet semblable à un tableau. Dans une fonction, il est possible d'utiliser les arguments passés à la fonction de la façon suivante :</p>
+Les arguments d'une fonction sont maintenus dans un objet semblable à un tableau. Dans une fonction, il est possible d'utiliser les arguments passés à la fonction de la façon suivante :
 
-<pre class="brush: js">arguments[i]</pre>
+```js
+arguments[i]
+```
 
-<p>où <code>i</code> représente l'index ordinal de l'argument (le premier argument ayant un indice à 0). On accède donc au premier argument avec <code>arguments[0]</code>. Le nombre total d'arguments est fourni grâce à <code>arguments.length</code>.</p>
+où `i` représente l'index ordinal de l'argument (le premier argument ayant un indice à 0). On accède donc au premier argument avec `arguments[0]`. Le nombre total d'arguments est fourni grâce à `arguments.length`.
 
-<p>En utilisant l'objet <code>arguments</code>, il est possible de recenser les arguments supplémentaires fournis à la fonction si jamais il y a plus d'arguments fournis que requis. Cet objet est souvent utile si on ne connaît pas le nombre d'arguments passés à la fonction. La propriété <code>arguments.length</code> permet de déterminer le nombre d'arguments réellement passés à la fonction. On peut donc ensuite accéder aux différents arguments en parcourant l'objet <code>arguments</code>.</p>
+En utilisant l'objet `arguments`, il est possible de recenser les arguments supplémentaires fournis à la fonction si jamais il y a plus d'arguments fournis que requis. Cet objet est souvent utile si on ne connaît pas le nombre d'arguments passés à la fonction. La propriété `arguments.length` permet de déterminer le nombre d'arguments réellement passés à la fonction. On peut donc ensuite accéder aux différents arguments en parcourant l'objet `arguments`.
 
-<p>Par exemple, on peut construire une fonction qui concatène plusieurs chaînes. Le seul argument formellement défini sera la chaîne utilisée pour concaténer les différentes chaînes. On peut définir la fonction de la façon suivante :</p>
+Par exemple, on peut construire une fonction qui concatène plusieurs chaînes. Le seul argument formellement défini sera la chaîne utilisée pour concaténer les différentes chaînes. On peut définir la fonction de la façon suivante :
 
-<pre class="brush: js">function monConcat(séparateur) {
+```js
+function monConcat(séparateur) {
    var result = ""; // on initialise la liste
    var i;
    // on parcourt les arguments
-   for (i = 1; i &lt; arguments.length; i++) {
+   for (i = 1; i < arguments.length; i++) {
       result += arguments[i] + séparateur;
    }
    return result;
-}</pre>
+}
+```
 
-<p>On peut passer autant d'arguments que nécessaire à cette fonction. Ils seront tous concaténés dans une chaîne finale. Ainsi, on aura :</p>
+On peut passer autant d'arguments que nécessaire à cette fonction. Ils seront tous concaténés dans une chaîne finale. Ainsi, on aura :
 
-<pre class="brush: js">// renverra "rouge, orange, bleu, "
+```js
+// renverra "rouge, orange, bleu, "
 monConcat(", ", "red", "orange", "blue");
 
 // renverra "éléphant; girafe; lion; singe; "
 monConcat("; ", "éléphant", "girafe", "lion", "singe");
 
 // renverra "sauge. basilic. origan. poivre. échalotte. "
-monConcat(". ", "sauge", "basilic", "origan", "poivre", "échalotte");</pre>
+monConcat(". ", "sauge", "basilic", "origan", "poivre", "échalotte");
+```
 
-<div class="note">
-<p><strong>Note :</strong> <code>arguments</code> est une variable « semblable » à un tableau. Mais ce n'est pas un tableau au sens strict. En effet, il possède un index numéroté ainsi qu'une propriété <code>length</code>. En revanche, il ne possède pas les méthodes classiques de manipulation des tableaux (Array).</p>
-</div>
+> **Note :** `arguments` est une variable « semblable » à un tableau. Mais ce n'est pas un tableau au sens strict. En effet, il possède un index numéroté ainsi qu'une propriété `length`. En revanche, il ne possède pas les méthodes classiques de manipulation des tableaux (Array).
 
-<p>Voir la page sur l'objet {{jsxref("Function")}} dans la référence JavaScript pour plus d'informations.</p>
+Voir la page sur l'objet {{jsxref("Function")}} dans la référence JavaScript pour plus d'informations.
 
-<h2 id="Paramètres_des_fonctions">Paramètres des fonctions</h2>
+## Paramètres des fonctions
 
-<p>À partir d'ECMAScript 2015, deux sortes de paramètres sont introduites : les paramètres par défaut et les paramètres du reste.</p>
+À partir d'ECMAScript 2015, deux sortes de paramètres sont introduites : les paramètres par défaut et les paramètres du reste.
 
-<h3 id="Les_paramètres_par_défaut">Les paramètres par défaut</h3>
+### Les paramètres par défaut
 
-<p>En JavaScript, par défaut, les paramètres des fonctions vaudront <code>undefined</code>. Il peut toutefois être utile de définir une valeur par défaut différente. Les paramètres par défaut permettent de répondre à ce besoin.</p>
+En JavaScript, par défaut, les paramètres des fonctions vaudront `undefined`. Il peut toutefois être utile de définir une valeur par défaut différente. Les paramètres par défaut permettent de répondre à ce besoin.
 
-<p>Avant ECMAScript 2015, la stratégie pour manipuler des valeurs par défaut adaptées était de tester si la valeur du paramètre était indéfinie puis de lui affecter la valeur souhaitée si c'était le cas. Par exemple, dans le code qui suit, on ne fournit pas de valeur pour <code>b</code> dans l'appel, la valeur sera <code>undefined</code> lors de l'évaluation de <code>a*b</code> et l'appel à <code>multiplier</code> aurait renvoyé <code>NaN</code>. Pour éviter ça, la deuxième ligne définit une valeur par défaut au cas où <code>b</code> n'est pas renseigné :</p>
+Avant ECMAScript 2015, la stratégie pour manipuler des valeurs par défaut adaptées était de tester si la valeur du paramètre était indéfinie puis de lui affecter la valeur souhaitée si c'était le cas. Par exemple, dans le code qui suit, on ne fournit pas de valeur pour `b` dans l'appel, la valeur sera `undefined` lors de l'évaluation de `a*b` et l'appel à `multiplier` aurait renvoyé `NaN`. Pour éviter ça, la deuxième ligne définit une valeur par défaut au cas où `b` n'est pas renseigné :
 
-<pre class="brush: js">function multiplier(a, b) {
+```js
+function multiplier(a, b) {
   b = typeof b !== 'undefined' ?  b : 1;
 
   return a*b;
 }
 
 multiplier(5); // 5
-</pre>
+```
 
-<p>Si on peut utiliser les paramètres par défaut, il n'est plus nécessaire de faire l'opération à l'intérieur du corps de la fonction, il suffit de déclarer que la valeur par défaut pour <code>b</code> est 1 dans la signature de la fonction :</p>
+Si on peut utiliser les paramètres par défaut, il n'est plus nécessaire de faire l'opération à l'intérieur du corps de la fonction, il suffit de déclarer que la valeur par défaut pour `b` est 1 dans la signature de la fonction :
 
-<pre class="brush: js">function multiplier(a, b = 1) {
+```js
+function multiplier(a, b = 1) {
   return a*b;
 }
 
-multiplier(5); // 5</pre>
+multiplier(5); // 5
+```
 
-<p>Pour plus de détails, voir <a href="/fr/docs/Web/JavaScript/Reference/Fonctions/Valeurs_par_défaut_des_arguments">la page sur les paramètres par défaut</a> dans la référence.</p>
+Pour plus de détails, voir [la page sur les paramètres par défaut](/fr/docs/Web/JavaScript/Reference/Fonctions/Valeurs_par_défaut_des_arguments) dans la référence.
 
-<h3 id="Les_paramètres_du_reste">Les paramètres du reste</h3>
+### Les paramètres du reste
 
-<p>La syntaxe des <a href="/fr/docs/Web/JavaScript/Reference/Fonctions/paramètres_du_reste">paramètres du reste</a> permet de représenter un nombre indéfini d'arguments contenus dans un tableau. Dans l'exemple suivant, on utilise les paramètres du reste pour collecter les arguments à partir du deuxième et jusqu'au dernier. Ces arguments sont multipliés par le premier. Dans cet exemple, on utilise une fonction fléchée, concept qui est présenté et illustré dans la section qui suit.</p>
+La syntaxe des [paramètres du reste](/fr/docs/Web/JavaScript/Reference/Fonctions/paramètres_du_reste) permet de représenter un nombre indéfini d'arguments contenus dans un tableau. Dans l'exemple suivant, on utilise les paramètres du reste pour collecter les arguments à partir du deuxième et jusqu'au dernier. Ces arguments sont multipliés par le premier. Dans cet exemple, on utilise une fonction fléchée, concept qui est présenté et illustré dans la section qui suit.
 
-<pre class="brush: js">function multiplier(facteur, ...lesArgs) {
-  return lesArgs.map(x =&gt; facteur * x);
+```js
+function multiplier(facteur, ...lesArgs) {
+  return lesArgs.map(x => facteur * x);
 }
 
 var arr = multiplier(2, 1, 2, 3);
-console.log(arr); // [2, 4, 6]</pre>
+console.log(arr); // [2, 4, 6]
+```
+
+## Fonctions fléchées
 
-<h2 id="Fonctions_fléchées">Fonctions fléchées</h2>
+[Une expression de fonction fléchée](/fr/docs/Web/JavaScript/Reference/Fonctions/Fonctions_fléchées) permet d'utiliser une syntaxe plus concise que les expressions de fonctions classiques. Une telle fonction ne possède alors pas de valeur propre pour [`this`](/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_this), [`arguments`](/fr/docs/Web/JavaScript/Reference/Fonctions/arguments), [`super`](/fr/docs/Web/JavaScript/Reference/Opérateurs/super) ou [`new.target`](/fr/docs/Web/JavaScript/Reference/Opérateurs/new.target). Les fonctions fléchées sont nécessairement anonymes.
 
-<p><a href="/fr/docs/Web/JavaScript/Reference/Fonctions/Fonctions_fléchées">Une expression de fonction fléchée</a> permet d'utiliser une syntaxe plus concise que les expressions de fonctions classiques. Une telle fonction ne possède alors pas de valeur propre pour <code><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_this">this</a></code>, <code><a href="/fr/docs/Web/JavaScript/Reference/Fonctions/arguments">arguments</a></code>, <code><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/super">super</a></code> ou <code><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/new.target">new.target</a></code>. Les fonctions fléchées sont nécessairement anonymes.</p>
+Les fonctions fléchées ont été introduites pour deux raisons principales : une syntaxe plus courte et l'absence de `this` rattaché à la fonction. Voir aussi [ce billet sur tech.mozfr.org sur les fonctions fléchées](https://tech.mozfr.org/post/2015/06/10/ES6-en-details-%3A-les-fonctions-flechees).
 
-<p>Les fonctions fléchées ont été introduites pour deux raisons principales : une syntaxe plus courte et l'absence de <code>this</code> rattaché à la fonction. Voir aussi <a href="https://tech.mozfr.org/post/2015/06/10/ES6-en-details-%3A-les-fonctions-flechees">ce billet sur tech.mozfr.org sur les fonctions fléchées</a>.</p>
 
-<p> </p>
 
-<p> </p>
 
-<h3 id="Concision_de_la_syntaxe">Concision de la syntaxe</h3>
 
-<p>Dans certaines constructions fonctionnelles, on peut apprécier une syntaxe courte. Par exemple, si on compare les deux dernières lignes de ce fragment de code :</p>
+### Concision de la syntaxe
 
-<pre class="brush: js">var a = [
+Dans certaines constructions fonctionnelles, on peut apprécier une syntaxe courte. Par exemple, si on compare les deux dernières lignes de ce fragment de code :
+
+```js
+var a = [
   "Hydrogen",
   "Helium",
   "Lithium",
@@ -563,14 +602,16 @@ console.log(arr); // [2, 4, 6]</pre>
 
 var a2 = a.map(function(s){ return s.length });
 console.log(a2); // affiche [8, 6, 7, 9]
-var a3 = a.map( s =&gt; s.length );
-console.log(a3); // affiche [8, 6, 7, 9]</pre>
+var a3 = a.map( s => s.length );
+console.log(a3); // affiche [8, 6, 7, 9]
+```
 
-<h3 id="Pas_de_this_distinct">Pas de <code>this</code> distinct</h3>
+### Pas de `this` distinct
 
-<p>Avant les fonctions fléchées, chaque nouvelle fonction définissait sa propre valeur <code><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_this">this</a></code> (un nouvel objet dans le cas d'un constructeur, <code>undefined</code> lors des appels en <a href="/fr/docs/Web/JavaScript/Reference/Strict_mode">mode strict</a>, l'objet courant dans le cas d'une méthode, etc.). Cela pouvait poser quelques problèmes avec un style de programmation orienté objet.</p>
+Avant les fonctions fléchées, chaque nouvelle fonction définissait sa propre valeur [`this`](/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_this) (un nouvel objet dans le cas d'un constructeur, `undefined` lors des appels en [mode strict](/fr/docs/Web/JavaScript/Reference/Strict_mode), l'objet courant dans le cas d'une méthode, etc.). Cela pouvait poser quelques problèmes avec un style de programmation orienté objet.
 
-<pre class="brush: js">function Personne() {
+```js
+function Personne() {
   // Le constructeur Personne() utilise `this` comme lui-même.
   this.âge = 0;
 
@@ -582,11 +623,13 @@ console.log(a3); // affiche [8, 6, 7, 9]</pre>
   }, 1000);
 }
 
-var p = new Personne();</pre>
+var p = new Personne();
+```
 
-<p>Avec ECMAScript 3/5, ce problème fut résolu avec l'affectation de la valeur de <code>this</code> dans une variable a variable that could be closed over.</p>
+Avec ECMAScript 3/5, ce problème fut résolu avec l'affectation de la valeur de `this` dans une variable a variable that could be closed over.
 
-<pre class="brush: js">function Personne() {
+```js
+function Personne() {
   var self = this; // Certains utilisent `that`, d'autres `self`.
                    // On utilisera l'un des deux et on pas
                    // l'autre pour être cohérent.
@@ -597,75 +640,52 @@ var p = new Personne();</pre>
     // qui est bien la valeur attendue liée à l'objet.
     self.âge++;
   }, 1000);
-}</pre>
+}
+```
 
-<p>On aurait aussi pu créer une fonction liée afin que la « bonne » valeur de <code>this</code> soit passée à la fonction <code>grandir()</code>.</p>
+On aurait aussi pu créer une fonction liée afin que la « bonne » valeur de `this` soit passée à la fonction `grandir()`.
 
-<p>Les fonctions fléchées capturent la valeur de <code>this</code> dans le contexte englobant et cela permet de manipuler la valeur pertinente ici :</p>
+Les fonctions fléchées capturent la valeur de `this` dans le contexte englobant et cela permet de manipuler la valeur pertinente ici :
 
-<pre class="brush: js">function Personne(){
+```js
+function Personne(){
   this.âge = 0;
 
-  setInterval(() =&gt; {
+  setInterval(() => {
     this.âge++; // this fait référence à l'objet personne
   }, 1000);
 }
 
-var p = new Personne();</pre>
-
-<h2 id="Fonctions_prédéfinies">Fonctions prédéfinies</h2>
-
-<p>JavaScript possède plusieurs fonctions natives, disponibles au plus haut niveau :</p>
-
-<dl>
- <dt>{{jsxref("Objets_globaux/eval","eval()")}}</dt>
- <dd>
- <p>La fonction <code><strong>eval()</strong></code> permet d'évaluer du code JavaScript contenu dans une chaîne de caractères.</p>
- </dd>
- <dt>{{jsxref("Objets_globaux/uneval","uneval()")}} {{non-standard_inline}}</dt>
- <dd>
- <p>La fonction <code><strong>uneval()</strong></code> crée une représentation sous la forme d'une chaîne de caractères pour le code source d'un objet.</p>
- </dd>
- <dt>{{jsxref("Objets_globaux/isFinite","isFinite()")}}</dt>
- <dd>
- <p>La fonction <code><strong>isFinite()</strong></code> détermine si la valeur passée est un nombre fini. Si nécessaire, le paramètre sera converti en un nombre.</p>
- </dd>
- <dt>{{jsxref("Objets_globaux/isNaN","isNaN()")}}</dt>
- <dd>
- <p>La fonction <code><strong>isNaN()</strong></code> détermine si une valeur est {{jsxref("NaN")}} ou non. Note : On pourra également utiliser {{jsxref("Number.isNaN()")}} défini avec ECMAScript 6 ou utiliser <code><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_typeof">typeof</a></code> afin de déterminer si la valeur est <em><strong>N</strong>ot-<strong>A</strong>-<strong>N</strong>umber</em>.</p>
- </dd>
- <dt>{{jsxref("Objets_globaux/parseFloat","parseFloat()")}}</dt>
- <dd>
- <p>La fonction <code><strong>parseFloat()</strong></code> convertit une chaîne de caractères en un nombre flottant.</p>
- </dd>
- <dt>{{jsxref("Objets_globaux/parseInt","parseInt()")}}</dt>
- <dd>
- <p>La fonction <code><strong>parseInt()</strong></code> convertit une chaîne de caractères et renvoie un entier dans la base donnée.</p>
- </dd>
- <dt>{{jsxref("Objets_globaux/decodeURI","decodeURI()")}}</dt>
- <dd>
- <p>La fonction <code><strong>decodeURI()</strong></code> décode un Uniform Resource Identifier (URI) créé par {{jsxref("Objets_globaux/encodeURI","encodeURI()")}} ou une méthode similaire.</p>
- </dd>
- <dt>{{jsxref("Objets_globaux/decodeURIComponent","decodeURIComponent()")}}</dt>
- <dd>
- <p>La fonction <code><strong>decodeURIComponent()</strong></code> décode un composant d'un Uniform Resource Identifier (URI) créé par {{jsxref("Objets_globaux/encodeURIComponent","encodeURIComponent")}} ou une méthode similaire.</p>
- </dd>
- <dt>{{jsxref("Objets_globaux/encodeURI","encodeURI()")}}</dt>
- <dd>
- <p>La fonction <code><strong>encodeURI()</strong></code> encode un Uniform Resource Identifier (URI) en remplaçant chaque exemplaire de certains caractères par un, deux, trois voire quatre séquences d'échappement représentant l'encodage UTF-8 du caractères (quatre séquences seront utilisées uniquement lorsque le caractère est composé d'une paire de deux demi-codets).</p>
- </dd>
- <dt>{{jsxref("Objets_globaux/encodeURIComponent","encodeURIComponent()")}}</dt>
- <dd>
- <p>La fonction <code><strong>encodeURIComponent()</strong></code> encode un composant d'un Uniform Resource Identifier (URI) en remplaçant chaque exemplaire de certains caractères par un, deux, trois voire quatre séquences d'échappement représentant l'encodage UTF-8 du caractères (quatre séquences seront utilisées uniquement lorsque le caractère est composé d'une paire de deux demi-codets).</p>
- </dd>
- <dt>{{jsxref("Objets_globaux/escape","escape()")}} {{deprecated_inline}}</dt>
- <dd>
- <p>La fonction dépréciée <code><strong>escape()</strong></code> calcule une nouvelle chaîne de caractères pour laquelle certains caractères ont été remplacés par leur séquence d'échappement hexadécimale. Les fonctions {{jsxref("Objets_globaux/encodeURI","encodeURI()")}} ou {{jsxref("Objets_globaux/encodeURIComponent","encodeURIComponent()")}} doivent être utilisées à la place.</p>
- </dd>
- <dt>{{jsxref("Objets_globaux/unescape","unescape()")}} {{deprecated_inline}}</dt>
- <dd>
- <p>La fonction dépréciée <code><strong>unescape()</strong></code> calcule une nouvelle chaîne de caractères pour laquelle les séquences d'échappement hexadécimales sont remplacées par les caractères qu'elles représentent. Les séquences d'échappement introduites peuvent provenir d'une fonction telle que {{jsxref("Objets_globaux/escape","escape()")}}. <code>unescape</code> est dépréciée et doit être remplacée par {{jsxref("Objets_globaux/decodeURI","decodeURI()")}} ou {{jsxref("Objets_globaux/decodeURIComponent","decodeURIComponent()")}}.</p>
- </dd>
-</dl>
-
-<p>{{PreviousNext("Web/JavaScript/Guide/Boucles_et_it%C3%A9ration", "Web/JavaScript/Guide/Expressions_et_Op%C3%A9rateurs")}}</p>
+var p = new Personne();
+```
+
+## Fonctions prédéfinies
+
+JavaScript possède plusieurs fonctions natives, disponibles au plus haut niveau :
+
+- {{jsxref("Objets_globaux/eval","eval()")}}
+  - : La fonction **`eval()`** permet d'évaluer du code JavaScript contenu dans une chaîne de caractères.
+- {{jsxref("Objets_globaux/uneval","uneval()")}} {{non-standard_inline}}
+  - : La fonction **`uneval()`** crée une représentation sous la forme d'une chaîne de caractères pour le code source d'un objet.
+- {{jsxref("Objets_globaux/isFinite","isFinite()")}}
+  - : La fonction **`isFinite()`** détermine si la valeur passée est un nombre fini. Si nécessaire, le paramètre sera converti en un nombre.
+- {{jsxref("Objets_globaux/isNaN","isNaN()")}}
+  - : La fonction **`isNaN()`** détermine si une valeur est {{jsxref("NaN")}} ou non. Note : On pourra également utiliser {{jsxref("Number.isNaN()")}} défini avec ECMAScript 6 ou utiliser [`typeof`](/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_typeof) afin de déterminer si la valeur est **\*N**ot-**A**-**N**umber\*.
+- {{jsxref("Objets_globaux/parseFloat","parseFloat()")}}
+  - : La fonction **`parseFloat()`** convertit une chaîne de caractères en un nombre flottant.
+- {{jsxref("Objets_globaux/parseInt","parseInt()")}}
+  - : La fonction **`parseInt()`** convertit une chaîne de caractères et renvoie un entier dans la base donnée.
+- {{jsxref("Objets_globaux/decodeURI","decodeURI()")}}
+  - : La fonction **`decodeURI()`** décode un Uniform Resource Identifier (URI) créé par {{jsxref("Objets_globaux/encodeURI","encodeURI()")}} ou une méthode similaire.
+- {{jsxref("Objets_globaux/decodeURIComponent","decodeURIComponent()")}}
+  - : La fonction **`decodeURIComponent()`** décode un composant d'un Uniform Resource Identifier (URI) créé par {{jsxref("Objets_globaux/encodeURIComponent","encodeURIComponent")}} ou une méthode similaire.
+- {{jsxref("Objets_globaux/encodeURI","encodeURI()")}}
+  - : La fonction **`encodeURI()`** encode un Uniform Resource Identifier (URI) en remplaçant chaque exemplaire de certains caractères par un, deux, trois voire quatre séquences d'échappement représentant l'encodage UTF-8 du caractères (quatre séquences seront utilisées uniquement lorsque le caractère est composé d'une paire de deux demi-codets).
+- {{jsxref("Objets_globaux/encodeURIComponent","encodeURIComponent()")}}
+  - : La fonction **`encodeURIComponent()`** encode un composant d'un Uniform Resource Identifier (URI) en remplaçant chaque exemplaire de certains caractères par un, deux, trois voire quatre séquences d'échappement représentant l'encodage UTF-8 du caractères (quatre séquences seront utilisées uniquement lorsque le caractère est composé d'une paire de deux demi-codets).
+- {{jsxref("Objets_globaux/escape","escape()")}} {{deprecated_inline}}
+  - : La fonction dépréciée **`escape()`** calcule une nouvelle chaîne de caractères pour laquelle certains caractères ont été remplacés par leur séquence d'échappement hexadécimale. Les fonctions {{jsxref("Objets_globaux/encodeURI","encodeURI()")}} ou {{jsxref("Objets_globaux/encodeURIComponent","encodeURIComponent()")}} doivent être utilisées à la place.
+- {{jsxref("Objets_globaux/unescape","unescape()")}} {{deprecated_inline}}
+  - : La fonction dépréciée **`unescape()`** calcule une nouvelle chaîne de caractères pour laquelle les séquences d'échappement hexadécimales sont remplacées par les caractères qu'elles représentent. Les séquences d'échappement introduites peuvent provenir d'une fonction telle que {{jsxref("Objets_globaux/escape","escape()")}}. `unescape` est dépréciée et doit être remplacée par {{jsxref("Objets_globaux/decodeURI","decodeURI()")}} ou {{jsxref("Objets_globaux/decodeURIComponent","decodeURIComponent()")}}.
+
+{{PreviousNext("Web/JavaScript/Guide/Boucles_et_it%C3%A9ration", "Web/JavaScript/Guide/Expressions_et_Op%C3%A9rateurs")}}
diff --git a/files/fr/web/javascript/guide/grammar_and_types/index.md b/files/fr/web/javascript/guide/grammar_and_types/index.md
index ce13618846..2205e65b20 100644
--- a/files/fr/web/javascript/guide/grammar_and_types/index.md
+++ b/files/fr/web/javascript/guide/grammar_and_types/index.md
@@ -7,85 +7,82 @@ tags:
 translation_of: Web/JavaScript/Guide/Grammar_and_types
 original_slug: Web/JavaScript/Guide/Types_et_grammaire
 ---
-<div> {{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/Introduction", "Web/JavaScript/Guide/Contrôle_du_flux_Gestion_des_erreurs")}}</div>
+{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/Introduction", "Web/JavaScript/Guide/Contrôle_du_flux_Gestion_des_erreurs")}}
 
-<p>Ce chapitre décrit les bases de la grammaire et des types de données JavaScript.</p>
+Ce chapitre décrit les bases de la grammaire et des types de données JavaScript.
 
-<h2 id="Les_bases_du_langage">Les bases du langage</h2>
+## Les bases du langage
 
-<p>JavaScript emprunte la plupart des éléments de sa syntaxe à Java, C et C++ mais sa syntaxe est également influencée par Awk, Perl et Python.</p>
+JavaScript emprunte la plupart des éléments de sa syntaxe à Java, C et C++ mais sa syntaxe est également influencée par Awk, Perl et Python.
 
-<p>JavaScript est <strong>sensible à la casse</strong> et utilise l'ensemble de caractères <strong>Unicode</strong>. On pourrait donc tout à fait utiliser le mot früh comme nom de variable :</p>
+JavaScript est **sensible à la casse** et utilise l'ensemble de caractères **Unicode**. On pourrait donc tout à fait utiliser le mot früh comme nom de variable :
 
-<pre class="brush: js">var früh = "toto";
+```js
+var früh = "toto";
 typeof Früh; // undefined car JavaScript est sensible à la casse
-</pre>
+```
 
-<p>En JavaScript, les instructions sont appelées ({{Glossary("Statement", "statements")}}) et sont séparées par des points-virgules.</p>
+En JavaScript, les instructions sont appelées ({{Glossary("Statement", "statements")}}) et sont séparées par des points-virgules.
 
-<p>Il n'est pas nécessaire d'inclure un point-virgule si l'on écrit une instruction sur une nouvelle ligne. Mais si vous voulez écrire plus d'une déclaration sur une seule ligne, alors elles doivent être séparées par un point-virgule. Ceci étant dit, la bonne pratique est d'inclure un point-virgule après chaque instruction. Les espaces, les tabulations et les caractères de nouvelles lignes sont considérés comme des blancs. Il existe aussi un ensemble de règles pour ajouter automatiquement des points-virgules à la fin des instructions (<a href="/fr/docs/Web/JavaScript/Reference/Grammaire_lexicale#Insertion_automatique_de_points-virgules">ASI</a> pour<em> Automatic Semicolon Insertion</em>). Cependant, il est conseillé de toujours ajouter des points-virgules à la fin des instructions afin d'éviter des effets de bord néfastes.</p>
+Il n'est pas nécessaire d'inclure un point-virgule si l'on écrit une instruction sur une nouvelle ligne. Mais si vous voulez écrire plus d'une déclaration sur une seule ligne, alors elles doivent être séparées par un point-virgule. Ceci étant dit, la bonne pratique est d'inclure un point-virgule après chaque instruction. Les espaces, les tabulations et les caractères de nouvelles lignes sont considérés comme des blancs. Il existe aussi un ensemble de règles pour ajouter automatiquement des points-virgules à la fin des instructions ([ASI](/fr/docs/Web/JavaScript/Reference/Grammaire_lexicale#Insertion_automatique_de_points-virgules) pour _Automatic Semicolon Insertion_). Cependant, il est conseillé de toujours ajouter des points-virgules à la fin des instructions afin d'éviter des effets de bord néfastes.
 
-<p>Le texte d'un code source JavaScript est analysé de gauche à droite et est converti en une série d'unités lexicales, de caractères de contrôle, de fins de lignes, de commentaires et de blancs. ECMAScript définit également certains mots-clés et littéraux. Pour plus d'informations, voir la page sur <a href="/fr/docs/Web/JavaScript/Reference/Grammaire_lexicale">la grammaire lexicale de JavaScript</a> dans la référence JavaScript.</p>
+Le texte d'un code source JavaScript est analysé de gauche à droite et est converti en une série d'unités lexicales, de caractères de contrôle, de fins de lignes, de commentaires et de blancs. ECMAScript définit également certains mots-clés et littéraux. Pour plus d'informations, voir la page sur [la grammaire lexicale de JavaScript](/fr/docs/Web/JavaScript/Reference/Grammaire_lexicale) dans la référence JavaScript.
 
-<h2 id="Commentaires">Commentaires</h2>
+## Commentaires
 
-<p>La syntaxe utilisée pour <strong>les commentaires</strong> est la même que celle utilisée par le C++ et d'autres langages :</p>
+La syntaxe utilisée pour **les commentaires** est la même que celle utilisée par le C++ et d'autres langages :
 
-<pre class="brush: js">// un commentaire sur une ligne
+```js
+// un commentaire sur une ligne
 
 /* un commentaire plus
    long sur plusieurs lignes
  */
 
 /* Par contre on ne peut pas /* imbriquer des commentaires */ SyntaxError */
-</pre>
+```
 
-<div class="blockIndicator note">
-<p><strong>Note :</strong> Vous pourrez également rencontrer une troisième forme de commentaires au début de certains fichiers JavaScript comme <code>#!/usr/bin/env node</code>. Ce type de commentaire indique le chemin d'un interpréteur JavaScript spécifique pour exécuter le script. Pour plus de détails, voir la page sur <a href="/fr/docs/Web/JavaScript/Reference/Grammaire_lexicale#Commentaire_d'environnement_(hashbang)">les commentaires d'environnement</a>.</p>
-</div>
+> **Note :** Vous pourrez également rencontrer une troisième forme de commentaires au début de certains fichiers JavaScript comme `#!/usr/bin/env node`. Ce type de commentaire indique le chemin d'un interpréteur JavaScript spécifique pour exécuter le script. Pour plus de détails, voir la page sur [les commentaires d'environnement](</fr/docs/Web/JavaScript/Reference/Grammaire_lexicale#Commentaire_d'environnement_(hashbang)>).
 
-<h2 id="Déclarations">Déclarations</h2>
+## Déclarations
 
-<p>Il existe trois types de déclarations de variable en JavaScript.</p>
+Il existe trois types de déclarations de variable en JavaScript.
 
-<dl>
- <dt>{{jsxref("Instructions/var", "var")}}</dt>
- <dd>On déclare une variable, éventuellement en initialisant sa valeur.</dd>
- <dt>{{jsxref("Instructions/let", "let")}}</dt>
- <dd>On déclare une variable dont la portée est celle du bloc courant, éventuellement en initialisant sa valeur.</dd>
- <dt>{{jsxref("Instructions/const", "const")}}</dt>
- <dd>On déclare une constante nommée, dont la portée est celle du bloc courant, accessible en lecture seule.</dd>
-</dl>
+- {{jsxref("Instructions/var", "var")}}
+  - : On déclare une variable, éventuellement en initialisant sa valeur.
+- {{jsxref("Instructions/let", "let")}}
+  - : On déclare une variable dont la portée est celle du bloc courant, éventuellement en initialisant sa valeur.
+- {{jsxref("Instructions/const", "const")}}
+  - : On déclare une constante nommée, dont la portée est celle du bloc courant, accessible en lecture seule.
 
-<h3 id="Variables">Variables</h3>
+### Variables
 
-<p>Les variables sont utilisées comme des noms symboliques désignant les valeurs utilisées dans l'application. Les noms des variables sont appelés <em>identifiants</em>. Ces identifiants doivent respecter certaines règles.</p>
+Les variables sont utilisées comme des noms symboliques désignant les valeurs utilisées dans l'application. Les noms des variables sont appelés _identifiants_. Ces identifiants doivent respecter certaines règles.
 
-<p>Un identifiant JavaScript doit commencer par une lettre, un tiret bas (_) ou un symbole dollar ($). Les caractères qui suivent peuvent être des chiffres (0 à 9).<br>
-À noter : puisque Javascript est sensible aux majuscules et minuscules: les lettres peuvent comprendre les caractères de « A » à « Z » (en majuscule) mais aussi les caractères  de « a » à « z » (en minuscule).</p>
+Un identifiant JavaScript doit commencer par une lettre, un tiret bas (\_) ou un symbole dollar ($). Les caractères qui suivent peuvent être des chiffres (0 à 9).
+À noter : puisque Javascript est sensible aux majuscules et minuscules: les lettres peuvent comprendre les caractères de « A » à « Z » (en majuscule) mais aussi les caractères  de « a » à « z » (en minuscule).
 
-<p>On peut aussi utiliser la plupart lettres Unicode ou ISO 8859-1 (comme å et ü, pour plus de détails, voir <a href="https://mathiasbynens.be/notes/javascript-identifiers-es6">ce billet de blog, en anglais</a>) au sein des identifiants. Il est également possible d'utiliser les \uXXXX <a href="#littéraux chaînes">séquences d'échappement Unicode</a> comme caractères dans les identifiants.</p>
+On peut aussi utiliser la plupart lettres Unicode ou ISO 8859-1 (comme å et ü, pour plus de détails, voir [ce billet de blog, en anglais](https://mathiasbynens.be/notes/javascript-identifiers-es6)) au sein des identifiants. Il est également possible d'utiliser les \uXXXX [séquences d'échappement Unicode](<#littéraux chaînes>) comme caractères dans les identifiants.
 
-<p>Voici des exemples d'identifiants valides : <code>Nombre_touches</code>, <code>temp99</code>, <code>$credit</code>, et <code>_nom</code>.</p>
+Voici des exemples d'identifiants valides : `Nombre_touches`, `temp99`, `$credit`, et `_nom`.
 
-<h3 id="Déclaration_de_variables">Déclaration de variables</h3>
+### Déclaration de variables
 
-<p>Il est possible de déclarer des variables de plusieurs façons :</p>
+Il est possible de déclarer des variables de plusieurs façons :
 
-<ul>
- <li>En utilisant le mot-clé {{jsxref("Instructions/var","var")}}, par exemple : <code>var x = 42</code>. Cette syntaxe peut être utilisée pour déclarer des variables <a href="#Portées">locales ou globales</a> selon le contexte d'exécution.</li>
- <li>En utilisant le mot-clé {{jsxref("Instructions/const","const")}} ou le mot-clé {{jsxref("Instructions/let","let")}}, par exemple avec <code>let y = 13</code>. Cette syntaxe peut être utilisée pour déclarer une variable dont la portée sera celle du bloc. Voir le paragraphe sur <a href="#Portées">les portées des variables</a> ci-après.</li>
-</ul>
+- En utilisant le mot-clé {{jsxref("Instructions/var","var")}}, par exemple : `var x = 42`. Cette syntaxe peut être utilisée pour déclarer des variables [locales ou globales](#Portées) selon le contexte d'exécution.
+- En utilisant le mot-clé {{jsxref("Instructions/const","const")}} ou le mot-clé {{jsxref("Instructions/let","let")}}, par exemple avec `let y = 13`. Cette syntaxe peut être utilisée pour déclarer une variable dont la portée sera celle du bloc. Voir le paragraphe sur [les portées des variables](#Portées) ci-après.
 
-<p>Il est également possible d'affecter une valeur à une variable sans utiliser de mot-clé (ex. <code>x = 42</code>). Cela créera une variable globale non-déclarée. Cette forme génèrera également un avertissement avec <a href="/fr/docs/Web/JavaScript/Reference/Strict_mode">le mode strict</a>. Attention, les variables globales non-déclarées peuvent mener à des comportements inattendus et sont considérées comme une mauvaise pratique.</p>
+Il est également possible d'affecter une valeur à une variable sans utiliser de mot-clé (ex. `x = 42`). Cela créera une variable globale non-déclarée. Cette forme génèrera également un avertissement avec [le mode strict](/fr/docs/Web/JavaScript/Reference/Strict_mode). Attention, les variables globales non-déclarées peuvent mener à des comportements inattendus et sont considérées comme une mauvaise pratique.
 
-<h3 id="Évaluation_de_variables">Évaluation de variables</h3>
+### Évaluation de variables
 
-<p>Une variable déclarée grâce à l'instruction <code>var</code> ou <code>let</code> sans valeur initiale définie vaudra {{jsxref("undefined")}}.</p>
+Une variable déclarée grâce à l'instruction `var` ou `let` sans valeur initiale définie vaudra {{jsxref("undefined")}}.
 
-<p>Tenter d'accéder à une variable qui n'a pas été déclarée ou tenter d'accéder à un identifiant déclaré avec <code>let</code> avant son initialisation provoquera l'envoi d'une exception {{jsxref("ReferenceError")}}.</p>
+Tenter d'accéder à une variable qui n'a pas été déclarée ou tenter d'accéder à un identifiant déclaré avec `let` avant son initialisation provoquera l'envoi d'une exception {{jsxref("ReferenceError")}}.
 
-<pre class="brush: js">var a;
+```js
+var a;
 console.log("La valeur de a est " + a); // La valeur de a est undefined
 
 console.log("La valeur de b est " + b); // La valeur de b est undefined
@@ -95,61 +92,70 @@ console.log("La valeur de x est " + x); // signale une exception ReferenceError
 let x;
 let y;
 console.log("La valeur de y est " + y); // La valeur de y est undefined
-</pre>
+```
 
-<p>Il est possible d'utiliser <code>undefined</code> pour déterminer si une variable possède une valeur. Dans l'exemple qui suit, la condition de l'instruction <code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/if...else">if</a></code> sera validée car la variable n'a pas été initialisée (elle a simplement été déclarée) :</p>
+Il est possible d'utiliser `undefined` pour déterminer si une variable possède une valeur. Dans l'exemple qui suit, la condition de l'instruction [`if`](/fr/docs/Web/JavaScript/Reference/Instructions/if...else) sera validée car la variable n'a pas été initialisée (elle a simplement été déclarée) :
 
-<pre class="brush: js">var input;
+```js
+var input;
 if (input === undefined){
   faireCeci();
 } else {
   faireCela();
 }
-</pre>
+```
 
-<p>La valeur <code>undefined</code> se comporte comme le booléen <code>false</code> lorsqu'elle est utilisée dans un contexte booléen. Ainsi, le fragment de code qui suit exécutera la fonction <code>maFonction</code> puisque le premier élément de <code>monTableau</code> n'est pas défini :</p>
+La valeur `undefined` se comporte comme le booléen `false` lorsqu'elle est utilisée dans un contexte booléen. Ainsi, le fragment de code qui suit exécutera la fonction `maFonction` puisque le premier élément de `monTableau` n'est pas défini :
 
-<pre class="brush: js">var monTableau = new Array();
+```js
+var monTableau = new Array();
 if (!monTableau[0]){
   maFunction();
 }
-</pre>
+```
 
-<p>La valeur <code>undefined</code> est convertie en {{jsxref("NaN")}} (pour <em>Not a Number</em> : « n'est pas un nombre ») lorsqu'elle est utilisée dans un contexte numérique.</p>
+La valeur `undefined` est convertie en {{jsxref("NaN")}} (pour _Not a Number_ : « n'est pas un nombre ») lorsqu'elle est utilisée dans un contexte numérique.
 
-<pre class="brush: js">var a;
-a + 2; // NaN</pre>
+```js
+var a;
+a + 2; // NaN
+```
 
-<p>Une variable valant <code>null</code> sera toujours considérée comme 0 dans un contexte numérique et comme <code>false</code> dans un contexte booléen. Par exemple, on aura :</p>
+Une variable valant `null` sera toujours considérée comme 0 dans un contexte numérique et comme `false` dans un contexte booléen. Par exemple, on aura :
 
-<pre class="brush: js">var n = null;
-console.log(n * 32); // Le log affichera 0</pre>
+```js
+var n = null;
+console.log(n * 32); // Le log affichera 0
+```
 
-<h3 id="Les_portées_de_variables">Les portées de variables</h3>
+### Les portées de variables
 
-<p>Lorsqu'une variable est déclarée avec <code>var</code> en dehors des fonctions, elle est appelée variable <em>global</em>e car elle est disponible pour tout le code contenu dans le document. Lorsqu'une variable est déclarée dans une fonction, elle est appelée variable <em>locale</em> car elle n'est disponible qu'au sein de cette fonction.</p>
+Lorsqu'une variable est déclarée avec `var` en dehors des fonctions, elle est appelée variable *global*e car elle est disponible pour tout le code contenu dans le document. Lorsqu'une variable est déclarée dans une fonction, elle est appelée variable _locale_ car elle n'est disponible qu'au sein de cette fonction.
 
-<p>Avant ECMAScript 2015 (ES6), JavaScript ne définissait pas de portée pour une <a href="/fr/docs/Web/JavaScript/Reference/Instructions/bloc">instruction de bloc</a> ; les éléments du bloc seront locaux pour le code qui contient le bloc (que ce soit une fonction ou le contexte global). Ainsi, l'exemple qui suit affichera 5 car la portée de <code>x</code> est la fonction (ou le contexte global) dans lequel <code>x</code> est déclaré, pas le bloc (correspondant à l'instruction <code>if</code> dans ce cas) :</p>
+Avant ECMAScript 2015 (ES6), JavaScript ne définissait pas de portée pour une [instruction de bloc](/fr/docs/Web/JavaScript/Reference/Instructions/bloc) ; les éléments du bloc seront locaux pour le code qui contient le bloc (que ce soit une fonction ou le contexte global). Ainsi, l'exemple qui suit affichera 5 car la portée de `x` est la fonction (ou le contexte global) dans lequel `x` est déclaré, pas le bloc (correspondant à l'instruction `if` dans ce cas) :
 
-<pre class="brush: js">if (true) {
+```js
+if (true) {
   var x = 5;
 }
 console.log(x); // x vaut 5
-</pre>
+```
 
-<p>La déclaration {{jsxref("Instructions/let","let")}}, introduite avec ECMAScript 2015, ajoute un nouveau comportement :</p>
+La déclaration {{jsxref("Instructions/let","let")}}, introduite avec ECMAScript 2015, ajoute un nouveau comportement :
 
-<pre class="brush: js">if (true) {
+```js
+if (true) {
   let y = 5;
 }
 console.log(y); // ReferenceError: y is not defined
-</pre>
+```
 
-<h3 id="Remontée_de_variables_(hoisting)">Remontée de variables (<em>hoisting</em>)</h3>
+### Remontée de variables (_hoisting_)
 
-<p>Une autre chose peut paraître étrange en JavaScript : il est possible, sans recevoir d'exception, de faire référence à une variable qui est déclarée plus tard. Ce concept est appelé « remontée » (<em>hoisting</em> en anglais) car, d'une certaine façon, les variables sont remontées en haut de la fonction ou de l'instruction. En revanche, les variables qui n'ont pas encore été initialisées renverront la valeur <code>undefined</code>. Ainsi, même si on déclare une variable et qu'on l'initialise après l'avoir utilisée ou y avoir fait référence, la valeur utilisée « la plus haute » sera toujours <code>undefined</code>.</p>
+Une autre chose peut paraître étrange en JavaScript : il est possible, sans recevoir d'exception, de faire référence à une variable qui est déclarée plus tard. Ce concept est appelé « remontée » (_hoisting_ en anglais) car, d'une certaine façon, les variables sont remontées en haut de la fonction ou de l'instruction. En revanche, les variables qui n'ont pas encore été initialisées renverront la valeur `undefined`. Ainsi, même si on déclare une variable et qu'on l'initialise après l'avoir utilisée ou y avoir fait référence, la valeur utilisée « la plus haute » sera toujours `undefined`.
 
-<pre class="brush: js">/**
+```js
+/**
  * Exemple 1
  */
 console.log(x === undefined); // donne "true"
@@ -165,11 +171,12 @@ var maVar = "ma valeur";
   console.log(maVar); // undefined
   var maVar = "valeur locale";
 })();
-</pre>
+```
 
-<p>Les exemples précédents peuvent être reformulés plus explicitement ainsi :</p>
+Les exemples précédents peuvent être reformulés plus explicitement ainsi :
 
-<pre class="brush: js">/**
+```js
+/**
  * Exemple 1
  */
 var x;
@@ -186,22 +193,25 @@ var maVar = "ma valeur";
   console.log(maVar); // undefined
   maVar = "valeur locale";
 })();
-</pre>
+```
 
-<p>C'est pourquoi il est conseillé de placer les instructions <code>var</code> dès que possible dans le code. De plus, cette bonne pratique aide à rendre le code plus lisible.</p>
+C'est pourquoi il est conseillé de placer les instructions `var` dès que possible dans le code. De plus, cette bonne pratique aide à rendre le code plus lisible.
 
-<p>Avec ECMAScript 2015, <code>let (const)</code> <strong>remontera la variable en haut du bloc mais ne l'initialisera pas</strong>. Aussi, si on fait référence à la variable dans le bloc avant la déclaration, on obtient une {{jsxref("ReferenceError")}} car la variable est dans une « zone morte temporelle ». entre le début du bloc et le traitement de la déclaration</p>
+Avec ECMAScript 2015, `let (const)` **remontera la variable en haut du bloc mais ne l'initialisera pas**. Aussi, si on fait référence à la variable dans le bloc avant la déclaration, on obtient une {{jsxref("ReferenceError")}} car la variable est dans une « zone morte temporelle ». entre le début du bloc et le traitement de la déclaration
 
-<pre class="brush: js">function faire_quelquechose() {
+```js
+function faire_quelquechose() {
   console.log(toto); // ReferenceError
   let toto = 2;
-}</pre>
+}
+```
 
-<h3 id="Remontée_de_fonctions">Remontée de fonctions</h3>
+### Remontée de fonctions
 
-<p>En ce qui concerne les fonctions, seules les déclarations de fonctions sont remontées. Pour les expressions de fonctions, il n'y a pas de telle remontée car la variable associée n'a pas encore été affectée avec la valeur finale (comme vu avant) :</p>
+En ce qui concerne les fonctions, seules les déclarations de fonctions sont remontées. Pour les expressions de fonctions, il n'y a pas de telle remontée car la variable associée n'a pas encore été affectée avec la valeur finale (comme vu avant) :
 
-<pre class="brush: js">/* Déclaration de fonction */
+```js
+/* Déclaration de fonction */
 toto();  // "truc"
 function toto(){
   console.log("truc");
@@ -212,28 +222,30 @@ machin();      // erreur TypeError : machin n'est pas une fonction
 var machin = function() {
   console.log("titi");
 }
-</pre>
+```
 
-<h3 id="Les_variables_globales">Les variables globales</h3>
+### Les variables globales
 
-<p>Les variables globales sont en réalité des propriétés de l'<em>objet global</em>. Dans les pages web, l'objet global est {{domxref("window")}}, et on peut donc accéder ou modifier la valeur de variables globales en utilisant la syntaxe suivante : <code>window.<em>variable</em></code> .</p>
+Les variables globales sont en réalité des propriétés de l'_objet global_. Dans les pages web, l'objet global est {{domxref("window")}}, et on peut donc accéder ou modifier la valeur de variables globales en utilisant la syntaxe suivante : `window.variable` .
 
-<p>Ainsi, il est possible d'accéder à des variables déclarées dans une fenêtre ou dans un cadre depuis une autre fenêtre ou depuis un autre cadre (<em>frame</em>) en spécifiant son nom. Si, par exemple, une variable appelée <code>numTéléphone</code> est déclarée dans un document <code>FRAMESET</code>, il est possible d'y faire référence, depuis un cadre fils, avec la syntaxe <code>parent.numTéléphone</code>.</p>
+Ainsi, il est possible d'accéder à des variables déclarées dans une fenêtre ou dans un cadre depuis une autre fenêtre ou depuis un autre cadre (_frame_) en spécifiant son nom. Si, par exemple, une variable appelée `numTéléphone` est déclarée dans un document `FRAMESET`, il est possible d'y faire référence, depuis un cadre fils, avec la syntaxe `parent.numTéléphone`.
 
-<h3 id="Constantes">Constantes</h3>
+### Constantes
 
-<p>Il est possible de créer des constantes en lecture seule en utilisant le mot-clé {{jsxref("Instructions/const","const")}}. La syntaxe d'un identifiant pour une constante est la même que pour les variables (elle doit débuter avec une lettre, un tiret du bas, un symbole dollar et peut contenir des caractères numériques, alphabétiques et des tirets bas voire des caractères Unicode).</p>
+Il est possible de créer des constantes en lecture seule en utilisant le mot-clé {{jsxref("Instructions/const","const")}}. La syntaxe d'un identifiant pour une constante est la même que pour les variables (elle doit débuter avec une lettre, un tiret du bas, un symbole dollar et peut contenir des caractères numériques, alphabétiques et des tirets bas voire des caractères Unicode).
 
-<pre class="brush: js">const préfixe = '212';
-</pre>
+```js
+const préfixe = '212';
+```
 
-<p>Une constante ne peut pas changer de valeur grâce à une affectation ou être re-déclarée pendant l'exécution du script.</p>
+Une constante ne peut pas changer de valeur grâce à une affectation ou être re-déclarée pendant l'exécution du script.
 
-<p>Les règles de portée des constantes sont les mêmes que pour les variables, à l'exception du mot-clé <code>const</code> qui est obligatoire. S'il est oublié, l'identifiant sera considéré comme celui d'une variable.</p>
+Les règles de portée des constantes sont les mêmes que pour les variables, à l'exception du mot-clé `const` qui est obligatoire. S'il est oublié, l'identifiant sera considéré comme celui d'une variable.
 
-<p>Il est impossible de déclarer une constante avec le même nom qu'une autre variable ou fonction dans la même portée.</p>
+Il est impossible de déclarer une constante avec le même nom qu'une autre variable ou fonction dans la même portée.
 
-<pre class="example-bad brush: js">// Renverra une erreur
+```js example-bad
+// Renverra une erreur
 function f() {};
 const f = 5;
 
@@ -244,216 +256,210 @@ function f() {
 
   //instructions
 }
-</pre>
+```
 
-<p>Cependant, les propriétés des objets qui sont affectés comme constantes ne sont pas protégées, on pourra ainsi exécuter sans problème le code suivant :</p>
+Cependant, les propriétés des objets qui sont affectés comme constantes ne sont pas protégées, on pourra ainsi exécuter sans problème le code suivant :
 
-<pre class="brush: js">const MON_OBJET = {"clé": "valeur"};
-MON_OBJET.clé = "autreValeur";</pre>
+```js
+const MON_OBJET = {"clé": "valeur"};
+MON_OBJET.clé = "autreValeur";
+```
 
-<p>De même, le contenu d'un tableau peut être modifié sans alerte :</p>
+De même, le contenu d'un tableau peut être modifié sans alerte :
 
-<pre class="brush: js">const MON_TABLEAU = ["HTML", "CSS"];
+```js
+const MON_TABLEAU = ["HTML", "CSS"];
 MON_TABLEAU.push("JavaScript");
 console.log(MON_TABLEAU); // ["HTML", "CSS", "JavaScript"]
-</pre>
+```
 
-<h2 id="Structures_de_données_et_types">Structures de données et types</h2>
+## Structures de données et types
 
-<h3 id="Types_de_données">Types de données</h3>
+### Types de données
 
-<p>La dernière version du standard ECMAScript définit sept types de données :</p>
+La dernière version du standard ECMAScript définit sept types de données :
 
-<ul>
- <li>Six types de données primitifs :
-  <ul>
-   <li>Type booléen : <code>true</code> et <code>false</code>.</li>
-   <li>Type nul (<code>null</code>), un mot-clé spécial pour indiquer une valeur nulle (au sens informatique). JavaScript étant sensible à la casse, <code>null</code> n'est pas <code>Null</code>, <code>NULL</code>, ou toute autre variante.</li>
-   <li>Un type pour les valeurs indéfinies (<code>undefined</code>).</li>
-   <li>Un type pour les nombres entiers ou décimaux. Par exemple : <code>42</code> ou <code>3.14159</code>.</li>
-   <li>Un type pour représenter les grands nombres entiers <code>BigInt</code>, par exemple <code>9007199254740992n</code>.</li>
-   <li>Un type pour les chaînes de caractères, une séquence de caractères qui représente une valeur textuelle. Par exemple : "Coucou"</li>
-   <li>Un type pour les symboles, apparus avec ECMAScript 2015 (ES6). Ce type est utilisé pour représenter des données immuables et uniques.</li>
-  </ul>
- </li>
- <li>et un type pour les objets (<em>Object</em>)</li>
-</ul>
+- Six types de données primitifs :
 
-<p>Bien que cette description couvre peu de types de données, ceux-ci vous permettent d'implémenter une grande variété de fonctions au sein de vos applications. <a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object">Les objets</a> et <a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Function">les fonctions</a> sont parmi les briques fondamentales du langage. On peut considérer, à première vue, les objets comme des conteneurs de valeurs et de fonctions pour une application.</p>
+  - Type booléen : `true` et `false`.
+  - Type nul (`null`), un mot-clé spécial pour indiquer une valeur nulle (au sens informatique). JavaScript étant sensible à la casse, `null` n'est pas `Null`, `NULL`, ou toute autre variante.
+  - Un type pour les valeurs indéfinies (`undefined`).
+  - Un type pour les nombres entiers ou décimaux. Par exemple : `42` ou `3.14159`.
+  - Un type pour représenter les grands nombres entiers `BigInt`, par exemple `9007199254740992n`.
+  - Un type pour les chaînes de caractères, une séquence de caractères qui représente une valeur textuelle. Par exemple : "Coucou"
+  - Un type pour les symboles, apparus avec ECMAScript 2015 (ES6). Ce type est utilisé pour représenter des données immuables et uniques.
 
-<h3 id="Conversion_de_types_de_données">Conversion de types de données</h3>
+- et un type pour les objets (_Object_)
 
-<p>JavaScript est un langage à typage dynamique. Cela signifie qu'il n'est pas nécessaire de spécifier le type de données d'une variable lors de sa déclaration. Les types de données sont convertis automatiquement durant l'exécution du script. Ainsi, il est possible de définir une variable de cette façon :</p>
+Bien que cette description couvre peu de types de données, ceux-ci vous permettent d'implémenter une grande variété de fonctions au sein de vos applications. [Les objets](/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object) et [les fonctions](/fr/docs/Web/JavaScript/Reference/Objets_globaux/Function) sont parmi les briques fondamentales du langage. On peut considérer, à première vue, les objets comme des conteneurs de valeurs et de fonctions pour une application.
 
-<div>
-<pre class="brush: js">var réponse = 42;
-</pre>
-</div>
+### Conversion de types de données
 
-<p>Et plus tard, d'affecter une chaîne de caractères à cette même variable :</p>
+JavaScript est un langage à typage dynamique. Cela signifie qu'il n'est pas nécessaire de spécifier le type de données d'une variable lors de sa déclaration. Les types de données sont convertis automatiquement durant l'exécution du script. Ainsi, il est possible de définir une variable de cette façon :
 
-<div>
-<pre class="brush: js">réponse = "Merci pour le dîner...";
-</pre>
-</div>
+```js
+var réponse = 42;
+```
 
-<p>JavaScript utilisant un typage dynamique, cette dernière instruction ne renverra pas d'erreur.</p>
+Et plus tard, d'affecter une chaîne de caractères à cette même variable :
 
-<p>Lorsque des expressions impliquent des chaînes de caractères et des valeurs numériques ainsi que l'opérateur +, JavaScript convertit les nombres en chaînes de caractères :</p>
+```js
+réponse = "Merci pour le dîner...";
+```
 
-<pre class="brush: js">x = "La réponse est " + 42; // "La réponse est 42"
+JavaScript utilisant un typage dynamique, cette dernière instruction ne renverra pas d'erreur.
+
+Lorsque des expressions impliquent des chaînes de caractères et des valeurs numériques ainsi que l'opérateur +, JavaScript convertit les nombres en chaînes de caractères :
+
+```js
+x = "La réponse est " + 42; // "La réponse est 42"
 y = 42 + " est la réponse"; // "42 est la réponse"
-</pre>
+```
 
-<p>Avec des instructions impliquant d'autres opérateurs, JavaScript ne convertit pas nécessairement les valeurs numériques en chaînes de caractères. Ainsi, on aura :</p>
+Avec des instructions impliquant d'autres opérateurs, JavaScript ne convertit pas nécessairement les valeurs numériques en chaînes de caractères. Ainsi, on aura :
 
-<pre class="brush: js">"37" - 7; // 30
+```js
+"37" - 7; // 30
 "37" + 7; // "377"
-</pre>
+```
 
-<h3 id="Conversion_de_chaînes_de_caractères_en_nombres">Conversion de chaînes de caractères en nombres</h3>
+### Conversion de chaînes de caractères en nombres
 
-<p>Si un nombre est représenté en mémoire par une chaîne de caractères, il y a des méthodes pour effectuer la bonne conversion :</p>
+Si un nombre est représenté en mémoire par une chaîne de caractères, il y a des méthodes pour effectuer la bonne conversion :
 
-<ul>
- <li>{{jsxref("Objets_globaux/parseInt", "parseInt()")}}</li>
- <li>{{jsxref("Objets_globaux/parseFloat", "parseFloat()")}}</li>
-</ul>
+- {{jsxref("Objets_globaux/parseInt", "parseInt()")}}
+- {{jsxref("Objets_globaux/parseFloat", "parseFloat()")}}
 
-<p><code>parseInt</code> renverra uniquement des nombres entiers, étant ainsi inappropriée pour la manipulation de nombre décimaux. Une bonne pratique pour cette fonction est de toujours inclure l'argument qui indique dans quelle base numérique le résultat doit être renvoyé (base 2, base 10...).</p>
+`parseInt` renverra uniquement des nombres entiers, étant ainsi inappropriée pour la manipulation de nombre décimaux. Une bonne pratique pour cette fonction est de toujours inclure l'argument qui indique dans quelle base numérique le résultat doit être renvoyé (base 2, base 10...).
 
-<pre class="brush: js">parseInt("101", 2); // 5</pre>
+```js
+parseInt("101", 2); // 5
+```
 
-<h4 id="L'opérateur_unaire">L'opérateur + unaire</h4>
+#### L'opérateur + unaire
 
-<p>Une autre méthode pour récupérer un nombre à partir d'une chaîne de caractères consiste à utiliser l'opérateur +.</p>
+Une autre méthode pour récupérer un nombre à partir d'une chaîne de caractères consiste à utiliser l'opérateur +.
 
-<pre class="brush: js">"1.1" + "1.1" = "1.11.1"
+```js
+"1.1" + "1.1" = "1.11.1"
 +"1.1" = 1.1 // fonctionne seulement avec le + unaire
-</pre>
+```
 
-<h2 id="Littéraux">Littéraux</h2>
+## Littéraux
 
-<p>Les littéraux sont utilisés pour représenter des valeurs en JavaScript. Ce sont des valeurs fixes, pas des variables, qui sont fournies <em>littéralement</em> au script. Cette section décrit les différents types de littéraux :</p>
+Les littéraux sont utilisés pour représenter des valeurs en JavaScript. Ce sont des valeurs fixes, pas des variables, qui sont fournies _littéralement_ au script. Cette section décrit les différents types de littéraux :
 
-<ul>
- <li><a href="#littéraux tableaux">Littéraux de tableaux</a></li>
- <li><a href="#littéraux booléens">Littéraux booléens</a></li>
- <li><a href="#littéraux décimaux">Littéraux de nombres flottants</a></li>
- <li><a href="#littéraux numériques">Littéraux numériques</a></li>
- <li><a href="#littéraux objets">Littéraux d'objets</a></li>
- <li><a href="#regexp">Littéraux d'expressions rationnelles</a></li>
- <li><a href="#littéraux chaînes">Littéraux de chaînes de caractères</a></li>
-</ul>
+- [Littéraux de tableaux](<#littéraux tableaux>)
+- [Littéraux booléens](<#littéraux booléens>)
+- [Littéraux de nombres flottants](<#littéraux décimaux>)
+- [Littéraux numériques](<#littéraux numériques>)
+- [Littéraux d'objets](<#littéraux objets>)
+- [Littéraux d'expressions rationnelles](#regexp)
+- [Littéraux de chaînes de caractères](<#littéraux chaînes>)
 
-<h3 id="Les_littéraux_de_tableaux">Les littéraux de tableaux</h3>
+### Les littéraux de tableaux
 
-<p>Un littéral de tableau est une liste de zéro ou plusieurs expressions, dont chacune représente l'élément d'un tableau, encadrées par des crochets (<code>[]</code>). Lorsqu'un tableau est créé à partir d'un littéral, il est initialisé avec les valeurs spécifiées qui sont ses éléments, sa longueur correspondant au nombre d'arguments donnés.</p>
+Un littéral de tableau est une liste de zéro ou plusieurs expressions, dont chacune représente l'élément d'un tableau, encadrées par des crochets (`[]`). Lorsqu'un tableau est créé à partir d'un littéral, il est initialisé avec les valeurs spécifiées qui sont ses éléments, sa longueur correspondant au nombre d'arguments donnés.
 
-<p>L'exemple suivant crée ainsi le tableau <code>cafés</code> avec trois éléments et une taille égale à 3 :</p>
+L'exemple suivant crée ainsi le tableau `cafés` avec trois éléments et une taille égale à 3 :
 
-<pre class="brush: js">var cafés = ["Brésilien", "Colombien", "Kona"];
-</pre>
+```js
+var cafés = ["Brésilien", "Colombien", "Kona"];
+```
 
-<div class="note">
-<p><strong>Note :</strong> Un littéral de tableau est du type d'un initialisateur d'objets. Voir <a href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Initialisateur_objet">l'utilisation d'initialisateurs d'objets</a>.</p>
-</div>
+> **Note :** Un littéral de tableau est du type d'un initialisateur d'objets. Voir [l'utilisation d'initialisateurs d'objets](/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Initialisateur_objet).
 
-<p>Si un tableau est créé en utilisant un littéral dans un script du plus haut niveau, JavaScript interprète le tableau chaque fois qu'il évalue l'expression contenant le littéral. De plus, un littéral utilisé dans une fonction est créé chaque fois que la fonction est appelée.</p>
+Si un tableau est créé en utilisant un littéral dans un script du plus haut niveau, JavaScript interprète le tableau chaque fois qu'il évalue l'expression contenant le littéral. De plus, un littéral utilisé dans une fonction est créé chaque fois que la fonction est appelée.
 
-<p>Les littéraux de tableaux sont également des objets <code>Array</code>. Voir la page sur l'objet <code><a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Array">Array</a></code> pour plus de détails.</p>
+Les littéraux de tableaux sont également des objets `Array`. Voir la page sur l'objet [`Array`](/fr/docs/Web/JavaScript/Reference/Objets_globaux/Array) pour plus de détails.
 
-<h4 id="Les_virgules_supplémentaires">Les virgules supplémentaires</h4>
+#### Les virgules supplémentaires
 
-<p>Il n'est pas nécessaire de définir tous les éléments dans un littéral de tableau. Si vous utilisez deux virgules, l'une à la suite de l'autre, le tableau utilisera la valeur <code>undefined</code> pour les éléments non définis. L'exemple qui suit utilise le tableau poisson :</p>
+Il n'est pas nécessaire de définir tous les éléments dans un littéral de tableau. Si vous utilisez deux virgules, l'une à la suite de l'autre, le tableau utilisera la valeur `undefined` pour les éléments non définis. L'exemple qui suit utilise le tableau poisson :
 
-<pre class="brush: js">var poisson = ["Clown", , "Chat"];
-</pre>
+```js
+var poisson = ["Clown", , "Chat"];
+```
 
-<p>Ce tableau possède deux éléments ayant une valeur et un élément vide (<code>poisson[0]</code> vaut "Clown", <code>poisson[1]</code> vaut <code>undefined</code>, et <code>poisson[2]</code> vaut "Chat").</p>
+Ce tableau possède deux éléments ayant une valeur et un élément vide (`poisson[0]` vaut "Clown", `poisson[1]` vaut `undefined`, et `poisson[2]` vaut "Chat").
 
-<p>Si une virgule est ajoutée à la fin de la liste des éléments, elle est ignorée. Dans le prochain exemple, la longueur du tableau est égale à 3. Il n'y a pas d'élément <code>maListe[3]</code>. Les autres virgules indiquent un nouvel élément.</p>
+Si une virgule est ajoutée à la fin de la liste des éléments, elle est ignorée. Dans le prochain exemple, la longueur du tableau est égale à 3. Il n'y a pas d'élément `maListe[3]`. Les autres virgules indiquent un nouvel élément.
 
-<div class="note">
-<p><strong>Note :</strong> Avec d'anciennes versions de navigateurs, les virgules de fin peuvent causer des erreurs, il est fortement conseillé de les retirer.</p>
-</div>
+> **Note :** Avec d'anciennes versions de navigateurs, les virgules de fin peuvent causer des erreurs, il est fortement conseillé de les retirer.
 
-<pre class="brush: js">var maListe = ['maison', , 'école', ];
-</pre>
+```js
+var maListe = ['maison', , 'école', ];
+```
 
-<p>Dans l'exemple qui suit, la longueur du tableau est égale à 4 et <code>maListe[0]</code> et <code>maListe[2]</code> sont manquants.</p>
+Dans l'exemple qui suit, la longueur du tableau est égale à 4 et `maListe[0]` et `maListe[2]` sont manquants.
 
-<pre class="brush: js">var maListe = [ , 'maison', , 'école'];
-</pre>
+```js
+var maListe = [ , 'maison', , 'école'];
+```
 
-<p>Dans l'exemple qui suit, la longueur du tableau est égale à 4 et <code>maListe[1]</code> et <code>maListe[3]</code> sont manquants.</p>
+Dans l'exemple qui suit, la longueur du tableau est égale à 4 et `maListe[1]` et `maListe[3]` sont manquants.
 
-<pre class="brush: js">var maListe = ['maison', , 'école', , ];
-</pre>
+```js
+var maListe = ['maison', , 'école', , ];
+```
 
-<p>Comprendre le fonctionnement des virgules supplémentaires est important. Cependant, lorsque vous écrivez du code, veillez, dès que c'est possible, à déclarer les éléments manquants avec <code>undefined</code> : cela améliorera la lisibilité de votre code et il sera ainsi plus facile à maintenir.</p>
+Comprendre le fonctionnement des virgules supplémentaires est important. Cependant, lorsque vous écrivez du code, veillez, dès que c'est possible, à déclarer les éléments manquants avec `undefined` : cela améliorera la lisibilité de votre code et il sera ainsi plus facile à maintenir.
 
-<h3 id="Les_littéraux_booléens">Les littéraux booléens</h3>
+### Les littéraux booléens
 
-<p>Le type booléen possède deux valeurs littérales : <code>true</code> et <code>false</code>.</p>
+Le type booléen possède deux valeurs littérales : `true` et `false`.
 
-<p>Il ne faut pas confondre les valeurs <code>true</code> et <code>false</code> du type primitif booléen et les valeurs true et false de l'objet <code>Boolean</code>. L'objet <code>Boolean</code> permet de créer un objet autour du type de donnée booléen. Voir la page sur l'objet<a href="/fr/docs/JavaScript/Reference/Objets_globaux/Boolean"> <code>Boolean</code></a> pour plus d'informations.</p>
+Il ne faut pas confondre les valeurs `true` et `false` du type primitif booléen et les valeurs true et false de l'objet `Boolean`. L'objet `Boolean` permet de créer un objet autour du type de donnée booléen. Voir la page sur l'objet[ `Boolean`](/fr/docs/JavaScript/Reference/Objets_globaux/Boolean) pour plus d'informations.
 
-<h3 id="Les_littéraux_numériques">Les littéraux numériques</h3>
+### Les littéraux numériques
 
-<p>Les nombres {{jsxref("Number")}} et les grands entiers {{jsxref("BigInt")}} peuvent être exprimés en notation décimale (base 10), hexadécimale (base 16), octale (base 8) et binaire (base 2).</p>
+Les nombres {{jsxref("Number")}} et les grands entiers {{jsxref("BigInt")}} peuvent être exprimés en notation décimale (base 10), hexadécimale (base 16), octale (base 8) et binaire (base 2).
 
-<ul>
- <li>Les littéraux représentant des entiers décimaux sont une suite de chiffres qui ne commence pas par un 0 (zéro)</li>
- <li>Un 0 (zéro) en préfixe indique que le littéral est en notation octale. Ces nombres ne peuvent être composés que des chiffres de 0 (zéro) à 7 (sept).</li>
- <li>Un préfixe 0x (ou 0X) indique une notation hexadécimale. Les nombres hexadécimaux peuvent être composés de chiffres (0-9) et des lettres A à F (minuscules et majuscules) (la casse d'un caractère ne modifie pas sa valeur : <code>0xa = 0xA = 10</code> et <code>0xf = 0xF = 15</code>).</li>
- <li>Un préfixe 0b (ou 0B) indique une notation binaire. Les nombres binaires peuvent être composés de 0 ou de 1 uniquement.</li>
-</ul>
+- Les littéraux représentant des entiers décimaux sont une suite de chiffres qui ne commence pas par un 0 (zéro)
+- Un 0 (zéro) en préfixe indique que le littéral est en notation octale. Ces nombres ne peuvent être composés que des chiffres de 0 (zéro) à 7 (sept).
+- Un préfixe 0x (ou 0X) indique une notation hexadécimale. Les nombres hexadécimaux peuvent être composés de chiffres (0-9) et des lettres A à F (minuscules et majuscules) (la casse d'un caractère ne modifie pas sa valeur : `0xa = 0xA = 10` et `0xf = 0xF = 15`).
+- Un préfixe 0b (ou 0B) indique une notation binaire. Les nombres binaires peuvent être composés de 0 ou de 1 uniquement.
 
-<p>Voici des exemples pour ces littéraux :</p>
+Voici des exemples pour ces littéraux :
 
-<pre class="eval">0, 117, -345, 123456789123456789n (notation décimale, base 10)
-015, 0001, -077, 0o7777777777777n (notation octale, base 8)
-0x1123, 0x00111, -0xF1A7, 0x123456789ABCDEFn (notation hexadécimale, base 16)
-0b11, 0B0011, -0b11, 0b11101001010101010101n (notation binaire, base 2)
-</pre>
+    0, 117, -345, 123456789123456789n (notation décimale, base 10)
+    015, 0001, -077, 0o7777777777777n (notation octale, base 8)
+    0x1123, 0x00111, -0xF1A7, 0x123456789ABCDEFn (notation hexadécimale, base 16)
+    0b11, 0B0011, -0b11, 0b11101001010101010101n (notation binaire, base 2)
 
-<p>Pour plus d'informations, voir <a href="/fr/docs/Web/JavaScript/Reference/Grammaire_lexicale#Littéraux_numériques">les littéraux numériques dans la grammaire lexicale de JavaScript</a>.</p>
+Pour plus d'informations, voir [les littéraux numériques dans la grammaire lexicale de JavaScript](/fr/docs/Web/JavaScript/Reference/Grammaire_lexicale#Littéraux_numériques).
 
-<h3 id="Les_littéraux_de_nombres_décimaux">Les littéraux de nombres décimaux</h3>
+### Les littéraux de nombres décimaux
 
-<p>Un littéral de nombre décimal peut être composé de ces différentes parties :</p>
+Un littéral de nombre décimal peut être composé de ces différentes parties :
 
-<ul>
- <li>Un entier, pouvant être signé (précédé d'un « + » ou d'un « - »),</li>
- <li>Un point, séparateur décimal (« . »),</li>
- <li>La partie décimale (un autre nombre)</li>
- <li>Un exposant.</li>
-</ul>
+- Un entier, pouvant être signé (précédé d'un « + » ou d'un « - »),
+- Un point, séparateur décimal (« . »),
+- La partie décimale (un autre nombre)
+- Un exposant.
 
-<p>L'exposant est la partie du nombre décimal commençant par un « e » ou un « E », suivie d'un entier pouvant être signé (précédé d'un « + » ou d'un « - »). Un littéral de nombre décimal doit comporter au moins un chiffre et soit un point (séparateur décimal) soit un « e » ou un « E ».</p>
+L'exposant est la partie du nombre décimal commençant par un « e » ou un « E », suivie d'un entier pouvant être signé (précédé d'un « + » ou d'un « - »). Un littéral de nombre décimal doit comporter au moins un chiffre et soit un point (séparateur décimal) soit un « e » ou un « E ».
 
-<p>Des exemples sont : 3.1415, -3.1E12, .1e12, et 2E-12.</p>
+Des exemples sont : 3.1415, -3.1E12, .1e12, et 2E-12.
 
-<p>On peut raccourcir cette syntaxe en :</p>
+On peut raccourcir cette syntaxe en :
 
-<pre class="eval">[(+|-)][chiffres].[chiffres][(E|e)[(+|-)]chiffres]
-</pre>
+    [(+|-)][chiffres].[chiffres][(E|e)[(+|-)]chiffres]
 
-<p>Par exemple :</p>
+Par exemple :
 
-<pre class="eval">3.14
-2345.789
-.3333333333333333333
-</pre>
+    3.14
+    2345.789
+    .3333333333333333333
 
-<h3 id="Les_littéraux_d'objets">Les littéraux d'objets</h3>
+### Les littéraux d'objets
 
-<p>Un littéral d'objet - ou 'objet littéral' - est une liste de zéro ou plusieurs propriétés définies par des paires de noms/valeurs. Ces paires sont délimitées par des accolades (<code>{}</code>). N'utilisez pas un tel littéral en début d'instruction. En effet, l'accolade ouvrante sera mal interprétée (début de bloc) et causera une erreur ou un comportement incohérent.</p>
+Un littéral d'objet - ou 'objet littéral' - est une liste de zéro ou plusieurs propriétés définies par des paires de noms/valeurs. Ces paires sont délimitées par des accolades (`{}`). N'utilisez pas un tel littéral en début d'instruction. En effet, l'accolade ouvrante sera mal interprétée (début de bloc) et causera une erreur ou un comportement incohérent.
 
-<p>L'exemple qui suit montre l'utilisation d'un littéral d'objet. Le premier élément de l'objet <code>voiture</code> définit une propriété <code>maVoiture</code>, le deuxième élément : la propriété <code>getVoiture</code> invoque une fonction <code>(carTypes("Honda")),</code> le troisième élément, la propriété <code>special</code> utilise une variable existante (<code>soldes</code>).</p>
+L'exemple qui suit montre l'utilisation d'un littéral d'objet. Le premier élément de l'objet `voiture` définit une propriété `maVoiture`, le deuxième élément : la propriété `getVoiture` invoque une fonction `(carTypes("Honda")),` le troisième élément, la propriété `special` utilise une variable existante (`soldes`).
 
-<pre class="brush: js">var soldes = "Toyota";
+```js
+var soldes = "Toyota";
 
 function carTypes(nom) {
   return (nom === "Honda") ?
@@ -466,19 +472,21 @@ var voiture = { maVoiture: "Saturn", getVoiture: carTypes("Honda"), spécial: so
 console.log(voiture.maVoiture);   // Saturn
 console.log(voiture.getVoiture);  // Honda
 console.log(voiture.spécial); // Toyota
-</pre>
+```
 
-<p>Il est également possible d'utiliser un littéral numérique ou un littéral de chaîne de caractères pour désigner le nom d'une propriété ou pour imbriquer un objet dans un autre. L'exemple qui suit illustre cette possibilité :</p>
+Il est également possible d'utiliser un littéral numérique ou un littéral de chaîne de caractères pour désigner le nom d'une propriété ou pour imbriquer un objet dans un autre. L'exemple qui suit illustre cette possibilité :
 
-<pre class="brush: js">var voiture = { plusieursVoitures: {a: "Saab", b: "Jeep"}, 7: "Mazda" };
+```js
+var voiture = { plusieursVoitures: {a: "Saab", b: "Jeep"}, 7: "Mazda" };
 
 console.log(voiture.plusieursVoitures.b); // Jeep
 console.log(voiture[7]); // Mazda
-</pre>
+```
 
-<p>Les noms des propriétés d'objets peuvent être n'importe quelle chaîne de caractères, y compris la chaîne vide. Si le nom de la propriété n'est pas un <a href="/fr/docs/Web/JavaScript/Guide/Types_et_grammaire#Variables">identifiant</a> valide, il faudra qu'il soit placé entre guillemets. Les noms de propriétés qui ne sont pas des identifiants valides ne peuvent pas être utilisés pour accéder à la valeur en utilisant la notation pointée (objet.propriété). En revanche, il est possible d'y accéder avec la notation utilisant les crochets ("<code>[]</code>") comme pour les tableaux.</p>
+Les noms des propriétés d'objets peuvent être n'importe quelle chaîne de caractères, y compris la chaîne vide. Si le nom de la propriété n'est pas un [identifiant](/fr/docs/Web/JavaScript/Guide/Types_et_grammaire#Variables) valide, il faudra qu'il soit placé entre guillemets. Les noms de propriétés qui ne sont pas des identifiants valides ne peuvent pas être utilisés pour accéder à la valeur en utilisant la notation pointée (objet.propriété). En revanche, il est possible d'y accéder avec la notation utilisant les crochets ("`[]`") comme pour les tableaux.
 
-<pre class="brush: js">var nomsBizarres = {
+```js
+var nomsBizarres = {
   "": "Chaîne vide",
   "!": "Bang !"
 }
@@ -486,14 +494,14 @@ console.log(nomsBizarres."");   // SyntaxError: Unexpected string
 console.log(nomsBizarres[""]);  // Chaîne vide
 console.log(nomsBizarres.!);    // SyntaxError: Unexpected token !
 console.log(nomsBizarres["!"]); // Bang !
+```
 
-</pre>
-
-<h4 id="Augmentation_des_littéraux_d'objets_avec_ES2015ES6">Augmentation des littéraux d'objets avec ES2015/ES6</h4>
+#### Augmentation des littéraux d'objets avec ES2015/ES6
 
-<p>Avec ES2015, les littéraux d'objets permettent de définir le prototype lors de la construction de l'objet, permettent d'utiliser les affectations en notation raccourcie : <code>toto: toto</code>, de définir des méthodes, d'appeler les méthodes de l'objet parent avec <code>super</code> et d'utiliser des noms de propriétés calculées.</p>
+Avec ES2015, les littéraux d'objets permettent de définir le prototype lors de la construction de l'objet, permettent d'utiliser les affectations en notation raccourcie : `toto: toto`, de définir des méthodes, d'appeler les méthodes de l'objet parent avec `super` et d'utiliser des noms de propriétés calculées.
 
-<pre class="brush: js">var obj = {
+```js
+var obj = {
     // __proto__
     __proto__: lePrototypeDeLObjet,
     // Notation raccourcie pour ‘handler: handler’
@@ -504,50 +512,54 @@ console.log(nomsBizarres["!"]); // Bang !
      return "d " + super.toString();
     },
     // Noms de propriétés calculés dynamiquement
-    [ 'prop_' + (() =&gt; 42)() ]: 42
-};</pre>
+    [ 'prop_' + (() => 42)() ]: 42
+};
+```
 
-<p>Attention :</p>
+Attention :
 
-<pre class="brush: js">var toto = {a: "alpha", 2: "deux"};
+```js
+var toto = {a: "alpha", 2: "deux"};
 console.log(toto.a);    // alpha
 console.log(toto[2]);   // deux
 //console.log(toto.2);  // Erreur: parenthèse ) manquante après la liste d'argument
 //console.log(toto[a]); // Erreur: a n'est pas défini
 console.log(toto["a"]); // alpha
 console.log(toto["2"]); // deux
-</pre>
+```
 
-<h3 id="Les_littéraux_d'expressions_rationnelles">Les littéraux d'expressions rationnelles</h3>
+### Les littéraux d'expressions rationnelles
 
-<p>Un littéral d'<a href="/fr/docs/Web/JavaScript/Guide/Expressions_r%C3%A9guli%C3%A8res">expression rationnelle</a> est un motif encadré par deux barres obliques. Par exemple :</p>
+Un littéral d'[expression rationnelle](/fr/docs/Web/JavaScript/Guide/Expressions_r%C3%A9guli%C3%A8res) est un motif encadré par deux barres obliques. Par exemple :
 
-<pre class="brush: js">var re = /ab+c/;</pre>
+```js
+var re = /ab+c/;
+```
 
-<h3 id="Les_littéraux_de_chaînes_de_caractères">Les littéraux de chaînes de caractères</h3>
+### Les littéraux de chaînes de caractères
 
-<p>Un littéral de chaîne de caractères consiste en zéro ou plusieurs caractères encadrés par des guillemets droits doubles (<code>"</code>) ou des guillemets droits simples (<code>'</code>). Une chaîne de caractères doit être encadrée par des symboles du même type (guillemets droits doubles ou guillemets droits simples) :</p>
+Un littéral de chaîne de caractères consiste en zéro ou plusieurs caractères encadrés par des guillemets droits doubles (`"`) ou des guillemets droits simples (`'`). Une chaîne de caractères doit être encadrée par des symboles du même type (guillemets droits doubles ou guillemets droits simples) :
 
-<ul>
- <li><code>"toto"</code></li>
- <li><code>'truc'</code></li>
- <li><code>"1234"</code></li>
- <li><code>"Une ligne \n une autre ligne"</code></li>
- <li><code>"Aujourd'hui j'ai mangé une pomme"</code></li>
-</ul>
+- `"toto"`
+- `'truc'`
+- `"1234"`
+- `"Une ligne \n une autre ligne"`
+- `"Aujourd'hui j'ai mangé une pomme"`
 
-<p>Il est possible d'utiliser les méthodes de <a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/String"><code>String</code></a> sur un tel littéral. JavaScript convertira automatiquement le littéral en un objet <code>String</code>, appellera la méthode puis détruira l'objet <code>String</code>. On peut également utiliser la propriété <code>String.length</code> sur un littéral de chaîne de caractère :</p>
+Il est possible d'utiliser les méthodes de [`String`](/fr/docs/Web/JavaScript/Reference/Objets_globaux/String) sur un tel littéral. JavaScript convertira automatiquement le littéral en un objet `String`, appellera la méthode puis détruira l'objet `String`. On peut également utiliser la propriété `String.length` sur un littéral de chaîne de caractère :
 
-<pre class="brush: js">console.log("j'ai mangé une pomme".length)
+```js
+console.log("j'ai mangé une pomme".length)
 // Affichera le nombre de caractères (y compris les blancs).
 // Dans ce cas, 20.
-</pre>
+```
 
-<p>Il est préférable d'utiliser des littéraux de chaînes de caractères s'il n'est pas spécifiquement nécessaire d'utiliser un objet <code>String</code>. Voir la page sur l'objet <a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/String"><code>String</code></a> pour plus de détails sur les objets <code>String</code>.</p>
+Il est préférable d'utiliser des littéraux de chaînes de caractères s'il n'est pas spécifiquement nécessaire d'utiliser un objet `String`. Voir la page sur l'objet [`String`](/fr/docs/Web/JavaScript/Reference/Objets_globaux/String) pour plus de détails sur les objets `String`.
 
-<p>Avec ECMAScript 2015, on peut également utiliser des littéraux sous forme de <em>gabarits</em> (<em>templates</em>) en utilisant le caractère accent grave (`) comme séparateur. Les gabarits de chaînes de caractères sont semblables aux fonctionnalités d'interpolation existantes en Python, Perl, etc. Ces gabarits permettent d'utiliser des balises afin d'adapter la construction de chaînes.</p>
+Avec ECMAScript 2015, on peut également utiliser des littéraux sous forme de _gabarits_ (_templates_) en utilisant le caractère accent grave (\`) comme séparateur. Les gabarits de chaînes de caractères sont semblables aux fonctionnalités d'interpolation existantes en Python, Perl, etc. Ces gabarits permettent d'utiliser des balises afin d'adapter la construction de chaînes.
 
-<pre class="brush: js">// Littéral simple pour une chaîne
+```js
+// Littéral simple pour une chaîne
 `Un saut de ligne '\n' en JavaScript.`
 
 // On peut écrire une chaîne sur plusieurs
@@ -562,149 +574,102 @@ var nom = "Robert", jour = "aujourd'hui";
 // On peut construire un préfixe HTTP
 // afin de construire plus facilement
 // des requêtes via des substitutions
-POST`http://toto.org/truc?a=${a}&amp;b=${b}
+POST`http://toto.org/truc?a=${a}&b=${b}
      Content-Type: application/json
      X-Credentials: ${credentials}
      { "toto": ${toto},
-       "truc": ${truc}}`(myOnReadyStateChangeHandler);</pre>
-
-<h4 id="Utilisation_des_caractères_spéciaux">Utilisation des caractères spéciaux</h4>
-
-<p>En plus des caractères « classiques », il est possible d'insérer des caractères spéciaux dans les chaînes de caractères. Voici un exemple :</p>
-
-<pre class="brush: js">"une ligne \n une autre ligne"
-</pre>
-
-<p>Voici un tableau listant les caractères spéciaux qu'il est possible d'utiliser dans les chaînes de caractères JavaScript :</p>
-
-<table class="standard-table">
- <caption>Caractères spéciaux en JavaScript</caption>
- <thead>
-  <tr>
-   <th scope="col">Caractère</th>
-   <th scope="col">Signification</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td><code>\0</code></td>
-   <td>Octet null</td>
-  </tr>
-  <tr>
-   <td><code>\b</code></td>
-   <td>Retour arrière</td>
-  </tr>
-  <tr>
-   <td><code>\f</code></td>
-   <td>Saut de page</td>
-  </tr>
-  <tr>
-   <td><code>\n</code></td>
-   <td>Nouvelle ligne</td>
-  </tr>
-  <tr>
-   <td><code>\r</code></td>
-   <td>Retour chariot</td>
-  </tr>
-  <tr>
-   <td><code>\t</code></td>
-   <td>Tabulation</td>
-  </tr>
-  <tr>
-   <td><code>\v</code></td>
-   <td>Tabulation verticale</td>
-  </tr>
-  <tr>
-   <td><code>\'</code></td>
-   <td>Apostrophe ou guillemet droit simple</td>
-  </tr>
-  <tr>
-   <td><code>\"</code></td>
-   <td>Guillemet droit double</td>
-  </tr>
-  <tr>
-   <td><code>\\</code></td>
-   <td>Barre oblique inversée</td>
-  </tr>
-  <tr>
-   <td><code>\<em>XXX</em></code></td>
-   <td>Le caractère dont l'encodage Latin-1 est spécifié grâce à, au plus, 3 chiffres octaux<em> XXX</em> entre 0 et 377. \251, par exemple représente le caractère copyright.</td>
-  </tr>
-  <tr>
-  </tr>
-  <tr>
-   <td><code>\x<em>XX</em></code></td>
-   <td>Le caractère dont l'encodage Latin-1 est spécifié par deux chiffres hexadécimaux entre 00 et FF. Ainsi, \xA9 correspond à la séquence hexadécimale pour le caractère copyright.</td>
-  </tr>
-  <tr>
-  </tr>
-  <tr>
-   <td><code>\u<em>XXXX</em></code></td>
-   <td>Le caractère Unicode spécifié par quatre chiffres hexadécimaux <em>XXXX</em>. Ainsi, \u00A9 correspondra à la séquence Unicode du symbole copyright. Voir {{anch("Unicode escape sequences")}}.</td>
-  </tr>
-  <tr>
-   <td><code>\u{<em>XXXXX}</em></code></td>
-   <td>Échappement de codes Unicode. Par exemple, \u{2F804} est équivalent à la combinaison d'échappements « simples » \uD87E\uDC04.</td>
-  </tr>
- </tbody>
-</table>
-
-<h4 id="Les_caractères_d'échappement">Les caractères d'échappement</h4>
-
-<p>Pour les caractères qui ne font pas partie du tableau précédent, les barres obliques inversées (<em>backslash</em>) les précédant sont ignorées. Cependant, cet usage est obsolète et devrait être évité.</p>
-
-<p>En précédant d'une barre oblique inversée les guillemets droits doubles, on <em>échappe </em>ces caractères. Voici un exemple :</p>
-
-<pre class="brush: js">var citation = "Il lit \"Bug Jargal\" de V. Hugo.";
+       "truc": ${truc}}`(myOnReadyStateChangeHandler);
+```
+
+#### Utilisation des caractères spéciaux
+
+En plus des caractères « classiques », il est possible d'insérer des caractères spéciaux dans les chaînes de caractères. Voici un exemple :
+
+```js
+"une ligne \n une autre ligne"
+```
+
+Voici un tableau listant les caractères spéciaux qu'il est possible d'utiliser dans les chaînes de caractères JavaScript :
+
+| Caractère   | Signification                                                                                                                                                                                        |
+| ----------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `\0`        | Octet null                                                                                                                                                                                           |
+| `\b`        | Retour arrière                                                                                                                                                                                       |
+| `\f`        | Saut de page                                                                                                                                                                                         |
+| `\n`        | Nouvelle ligne                                                                                                                                                                                       |
+| `\r`        | Retour chariot                                                                                                                                                                                       |
+| `\t`        | Tabulation                                                                                                                                                                                           |
+| `\v`        | Tabulation verticale                                                                                                                                                                                 |
+| `\'`        | Apostrophe ou guillemet droit simple                                                                                                                                                                 |
+| `\"`        | Guillemet droit double                                                                                                                                                                               |
+| `\\`        | Barre oblique inversée                                                                                                                                                                               |
+| `\XXX`      | Le caractère dont l'encodage Latin-1 est spécifié grâce à, au plus, 3 chiffres octaux _XXX_ entre 0 et 377. \251, par exemple représente le caractère copyright.                                     |
+|             |                                                                                                                                                                                                      |
+| `\xXX`      | Le caractère dont l'encodage Latin-1 est spécifié par deux chiffres hexadécimaux entre 00 et FF. Ainsi, \xA9 correspond à la séquence hexadécimale pour le caractère copyright.                      |
+|             |                                                                                                                                                                                                      |
+| `\uXXXX`    | Le caractère Unicode spécifié par quatre chiffres hexadécimaux _XXXX_. Ainsi, \u00A9 correspondra à la séquence Unicode du symbole copyright. Voir {{anch("Unicode escape sequences")}}. |
+| `\u{XXXXX}` | Échappement de codes Unicode. Par exemple, \u{2F804} est équivalent à la combinaison d'échappements « simples » \uD87E\uDC04.                                                                        |
+
+#### Les caractères d'échappement
+
+Pour les caractères qui ne font pas partie du tableau précédent, les barres obliques inversées (_backslash_) les précédant sont ignorées. Cependant, cet usage est obsolète et devrait être évité.
+
+En précédant d'une barre oblique inversée les guillemets droits doubles, on _échappe_ ces caractères. Voici un exemple :
+
+```js
+var citation = "Il lit \"Bug Jargal\" de V. Hugo.";
 console.log(citation);
-</pre>
+```
 
-<p>Le résultat serait alors</p>
+Le résultat serait alors
 
-<pre class="eval">Il lit "Bug Jargal" de V. Hugo.</pre>
+    Il lit "Bug Jargal" de V. Hugo.
 
-<p>Pour inclure une barre oblique inversée dans une chaîne de caractères, il faut aussi l'échapper. Par exemple, pour stocker le chemin <code>c:\temp</code> dans une chaîne de caractères, on utilisera le code suivant :</p>
+Pour inclure une barre oblique inversée dans une chaîne de caractères, il faut aussi l'échapper. Par exemple, pour stocker le chemin `c:\temp` dans une chaîne de caractères, on utilisera le code suivant :
 
-<pre class="brush: js">var chemin = "c:\\temp";
-</pre>
+```js
+var chemin = "c:\\temp";
+```
 
-<p>Il est également possible d'échapper des sauts de lignes de la même façon. La barre oblique inversée et le saut de ligne seront alors ignorés dans la valeur de la chaîne de caractères.</p>
+Il est également possible d'échapper des sauts de lignes de la même façon. La barre oblique inversée et le saut de ligne seront alors ignorés dans la valeur de la chaîne de caractères.
 
-<pre class="brush: js">var str = "cette chaîne \
+```js
+var str = "cette chaîne \
 est cassée \
 sur plusieurs \
 lignes."
 console.log(str);   // cette chaîne est cassée sur plusieurs lignes.
-</pre>
+```
 
-<p>Avant ECMAScript 2015 (ES6), JavaScript ne disposait pas d'une syntaxe permettant de traiter les chaînes de caractères comme des contenus de fichier, il est possible d'ajouter un caractère de saut de ligne échappé et un saut de ligne en fin de ligne en utilisant cette façon :</p>
+Avant ECMAScript 2015 (ES6), JavaScript ne disposait pas d'une syntaxe permettant de traiter les chaînes de caractères comme des contenus de fichier, il est possible d'ajouter un caractère de saut de ligne échappé et un saut de ligne en fin de ligne en utilisant cette façon :
 
-<pre class="brush: js">var poème =
+```js
+var poème =
 "Les roses sont rouges,\n\
 Les violettes sont bleues.\n\
 Le miel est sucré,\n\
 Et moi je suis."
-</pre>
+```
 
-<p>Grâce à ES6, on peut utiliser des <a href="https://tech.mozfr.org/post/2015/05/27/ES6-en-details-%3A-les-gabarits-de-chaines-de-caracteres">littéraux de gabarits qui offrent de nouvelles fonctionnalités</a> dont une qui permet d'avoir des chaînes de caractères écrites sur plusieurs lignes :</p>
+Grâce à ES6, on peut utiliser des [littéraux de gabarits qui offrent de nouvelles fonctionnalités](https://tech.mozfr.org/post/2015/05/27/ES6-en-details-%3A-les-gabarits-de-chaines-de-caracteres) dont une qui permet d'avoir des chaînes de caractères écrites sur plusieurs lignes :
 
-<pre class="brush: js">var poème =
+```js
+var poème =
 `Les roses sont rouges,
 Les violettes sont bleues,
 Le miel est sucré,
-Et moi je suis.`</pre>
+Et moi je suis.`
+```
 
-<h2 id="En_savoir_plus">En savoir plus</h2>
+## En savoir plus
 
-<p>Ce chapitre est centré sur les bases de la syntaxe, les déclarations et les types utilisés en JavaScript. Pour en savoir plus sur les différents composants du langage, voir les chapitres suivants du guide:</p>
+Ce chapitre est centré sur les bases de la syntaxe, les déclarations et les types utilisés en JavaScript. Pour en savoir plus sur les différents composants du langage, voir les chapitres suivants du guide:
 
-<ul>
- <li><a href="/fr/docs/Web/JavaScript/Guide/Contrôle_du_flux_Gestion_des_erreurs">Contrôle du flux et gestion des erreurs</a></li>
- <li><a href="/fr/docs/Web/JavaScript/Guide/Boucles_et_itération">Boucles et itération</a></li>
- <li><a href="/fr/docs/Web/JavaScript/Guide/Fonctions">Fonctions</a></li>
- <li><a href="/fr/docs/Web/JavaScript/Guide/Expressions_et_Opérateurs">Expressions et opérateurs</a></li>
-</ul>
+- [Contrôle du flux et gestion des erreurs](/fr/docs/Web/JavaScript/Guide/Contrôle_du_flux_Gestion_des_erreurs)
+- [Boucles et itération](/fr/docs/Web/JavaScript/Guide/Boucles_et_itération)
+- [Fonctions](/fr/docs/Web/JavaScript/Guide/Fonctions)
+- [Expressions et opérateurs](/fr/docs/Web/JavaScript/Guide/Expressions_et_Opérateurs)
 
-<p>Dans le chapitre suivant, on abordera les structures conditionnelles, permettant de diriger le flux d'instructions et la gestion des erreurs.</p>
+Dans le chapitre suivant, on abordera les structures conditionnelles, permettant de diriger le flux d'instructions et la gestion des erreurs.
 
-<p>{{PreviousNext("Web/JavaScript/Guide/Introduction", "Web/JavaScript/Guide/Contrôle_du_flux_Gestion_des_erreurs")}}</p>
+{{PreviousNext("Web/JavaScript/Guide/Introduction", "Web/JavaScript/Guide/Contrôle_du_flux_Gestion_des_erreurs")}}
diff --git a/files/fr/web/javascript/guide/index.md b/files/fr/web/javascript/guide/index.md
index ef708eef08..bcf109d502 100644
--- a/files/fr/web/javascript/guide/index.md
+++ b/files/fr/web/javascript/guide/index.md
@@ -6,164 +6,131 @@ tags:
   - JavaScript
 translation_of: Web/JavaScript/Guide
 ---
-<div>{{jsSidebar("JavaScript Guide")}}</div>
-
-<p>Le guide JavaScript illustre comment utiliser <a href="/fr/docs/Web/JavaScript">JavaScript</a> et fournit un aperçu des fonctionnalités du langage. Pour des informations exhaustives à propos des fonctionnalités du langage, voir la <a href="/fr/docs/Web/JavaScript/Reference">référence JavaScript</a>.</p>
-
-<h2 id="Chapitres">Chapitres</h2>
-
-<p>Ce guide est divisé en plusieurs chapitres :</p>
-
-<h2 id="Introduction"><a href="/fr/docs/Web/JavaScript/Guide/Introduction">Introduction</a></h2>
-
-<ul>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Introduction#o.c3.b9_trouver_des_informations_concernant_javascript">À propos de ce guide</a></li>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Introduction#qu'est-ce_que_javascript_.3f">À propos de JavaScript</a></li>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Introduction#javascript_and_java">JavaScript et Java</a></li>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Introduction#javascript_and_the_ecmascript_specification">ECMAScript</a></li>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Introduction#d.c3.a9marrer_avec_javascript">Les outils</a></li>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Introduction#coucou_monde_(hello_world)">Hello World</a></li>
-</ul>
-
-<h2><a href="/fr/docs/Web/JavaScript/Guide/Grammar_and_types">Grammaire et types</a></h2>
-
-<ul>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Grammar_and_types#les_bases_du_langage">Syntaxe de base et commentaires</a></li>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Grammar_and_types#d.c3.a9clarations">Déclarations</a></li>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Grammar_and_types#les_port.c3.a9es_de_variables">Portées des variables</a></li>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Grammar_and_types#remont.c3.a9e_de_variables_(hoisting)">Remontée des variables</a></li>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Grammar_and_types#structures_de_donn.c3.a9es_et_types">Structures de données et types</a></li>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Grammar_and_types#litt.c3.a9raux">Littéraux</a></li>
-</ul>
-
-<h2><a href="/fr/docs/Web/JavaScript/Guide/Control_flow_and_error_handling">Contrôle du flux et gestion des erreurs</a></h2>
-
-<ul>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Contr%C3%B4le_du_flux_Gestion_des_erreurs#Instruction_if...else"><code>if...else</a></code></li>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Contr%C3%B4le_du_flux_Gestion_des_erreurs#L%27instruction_switch"><code>switch</a></code></li>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Contr%C3%B4le_du_flux_Gestion_des_erreurs#L%27instruction_try...catch"><code>try/catch/throw</a></code></li>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Contr%C3%B4le_du_flux_Gestion_des_erreurs#Utiliser_les_objets_Error">Objets <code>Error</code></a></li>
-</ul>
-
-<h2><a href="/fr/docs/Web/JavaScript/Guide/Loops_and_iteration">Itération et boucles</a></h2>
-
-<ul>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Boucles_et_it%C3%A9ration#L%27instruction_for"><code>for</code></a></li>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Boucles_et_it%C3%A9ration#L%27instruction_while"><code>while</code></a></li>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Boucles_et_it%C3%A9ration#L%27instruction_do...while"><code>do...while</code></a></li>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Boucles_et_it%C3%A9ration#L%27instruction_break"><code>break</code></a>/<a href="/fr/docs/Web/JavaScript/Guide/Boucles_et_it%C3%A9ration#L%27instruction_continue">continue</code></a></li>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Boucles_et_it%C3%A9ration#L%27instruction_for...in"><code>for..in</code></a></li>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Loops_and_iteration#l'instruction_for...of"><code>for..of</code></a></li>
-</ul>
-
-<h2><a href="/fr/docs/Web/JavaScript/Guide/Functions">Fonctions</a></h2>
-
-<ul>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Functions#d.c3.a9finir_des_fonctions">Définir des fonctions</a></li>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Functions#appeler_des_fonctions">Appeler des fonctions</a></li>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Functions#port.c3.a9e_d'une_fonction">Portées des fonctions</a></li>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Functions#fermetures_(closures)">Fermetures (<em>closures</em>)</a></li>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Functions#utiliser_l'objet_arguments">Arguments</a> et <a href="/fr/docs/Web/JavaScript/Guide/Functions#param.c3.a8tres_des_fonctions">paramètres</a></li>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Functions#fonctions_fl.c3.a9ch.c3.a9es">Fonctions fléchées</a></li>
-</ul>
-
-<h2><a href="/fr/docs/Web/JavaScript/Guide/Expressions_and_Operators">Expressions et opérateurs</a></h2>
-
-<ul>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Expressions_et_Op%C3%A9rateurs#Op.C3.A9rateurs_d%27affectation">Affectation</a> et <a href="/fr/docs/Web/JavaScript/Guide/Expressions_et_Op%C3%A9rateurs#Op.C3.A9rateurs_de_comparaison">comparaisons</a></li>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Expressions_and_Operators#op.c3.a9rateurs_arithm.c3.a9tiques">Opérateurs arithmétiques</a></li>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Expressions_et_Op%C3%A9rateurs#Op.C3.A9rateurs_binaires">Opérateurs binaires</a> et <a href="/fr/docs/Web/JavaScript/Guide/Expressions_et_Op%C3%A9rateurs#Op.C3.A9rateurs_logiques">logiques</a></li>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Expressions_et_Op%C3%A9rateurs#Op.C3.A9rateur_conditionnel_ternaire">Opérateur conditionnel</a></li>
-</ul>
-
-<h2><a href="/fr/docs/Web/JavaScript/Guide/Numbers_and_dates">Nombres et dates</a></h2>
-
-<ul>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Numbers_and_dates#nombres">Littéraux numériques</a></li>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Numbers_and_dates#l'objet_number">Objet <code>Number</code></a></li>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Numbers_and_dates#l'objet_math">Objet <code>Math</code></a></li>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Numbers_and_dates#l'objet_date">Objet <code>Date</code></a></li>
-</ul>
-
-<h2><a href="/fr/docs/Web/JavaScript/Guide/Text_formatting">Formatage du texte</a></h2>
-
-<ul>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Text_formatting#les_litt.c3.a9raux_de_cha.c3.aenes_de_caract.c3.a8res">Littéraux de chaînes de caractères</a></li>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Text_formatting#les_objets_string">Objet <code>String</code></a></li>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Text_formatting#les_litt%c3%a9raux_de_gabarits">Littéraux de gabarits</a></li>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Text_formatting#internationalisation">Internationalisation</a></li>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Text_formatting#les_expressions_rationnelles">Expressions rationnelles</a></li>
-</ul>
-
-
-<h2><a href="/fr/docs/Web/JavaScript/Guide/Indexed_collections#le_type_array">Collections indexées</a></h2>
-
-<ul>
-  <li><a href="/en-US/docs/Web/JavaScript/Guide/Indexed_collections#array_object">Tableaux</a></li>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Indexed_collections#les_tableaux_typ.c3.a9s">Tableaux typés</a></li>
-</ul>
-
-<h2><a href="/fr/docs/Web/JavaScript/Guide/Keyed_collections">Collections avec clés</a> - <code><a href="/fr/docs/Web/JavaScript/Guide/Keyed_collections#le_type_map">Map</a></code></h2>
-
-<ul>
-  <li><a href="/en-US/docs/Web/JavaScript/Guide/Keyed_collections#weakmap_object"><code>WeakMap</code></a></li>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Keyed_collections#le_type_set"><code>Set</code></a></li>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Keyed_collections#le_type_weakset"><code>WeakSet</code></a></li>
-</ul>
-
-<h2><a href="/fr/docs/Web/JavaScript/Guide/Working_with_Objects">Utiliser les objets</a></h2>
-
-<ul>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Working_with_Objects#les_objets_et_les_propri.c3.a9t.c3.a9s">Objets et propriétés</a></li>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Working_with_Objects#cr.c3.a9er_de_nouveaux_objets">Création d'objets</a></li>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Working_with_Objects#d.c3.a9finir_des_m.c3.a9thodes">Définition de méthodes</a></li>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Working_with_Objects#d.c3.a9finir_des_accesseurs_et_des_mutateurs_(getters_et_setters)">Accesseurs et mutateurs</a></li>
-</ul>
-
-<h2><a href="/fr/docs/Web/JavaScript/Guide/Details_of_the_Object_Model">Le modèle objet JavaScript en détails</a></h2>
-
-<ul>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Details_of_the_Object_Model#langages_de_prototypes_.2f_langages_de_classes">Modèle à base de prototypes</a></li>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Details_of_the_Object_Model#la_cr.c3.a9ation_de_la_hi.c3.a9rarchie">Créer des hiérarchies d'objets</a></li>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Details_of_the_Object_Model#l'h.c3.a9ritage_de_propri.c3.a9t.c3.a9s_.3a_les_subtilit.c3.a9s">Héritage</a></li>
-</ul>
-
-<h2><a href="/fr/docs/Web/JavaScript/Guide/Using_promises">Promesses</a></h2>
-
-<ul>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Using_promises#garanties">Garanties</a></li>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Using_promises#cha%c3%aenage_des_promesses">Chaînage</a></li>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Using_promises#propagation_des_erreurs">Propagation des erreurs</a></li>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Using_promises#composition">Composition</a></li>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Using_promises#gestion_du_temps">Gestion du temps</a></li>
-</ul>
-
-<h2><a href="/fr/docs/Web/JavaScript/Guide/Iterators_and_Generators">Itérateurs et générateurs</a></h2>
-
-<ul>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Iterators_and_Generators#it.c3.a9rateurs">Itérateurs</a></li>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Iterators_and_Generators#it.c3.a9rables">Itérables</a></li>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Iterators_and_Generators#g.c3.a9n.c3.a9rateurs">Générateurs</a></li>
-</ul>
-
-<h2><a href="/fr/docs/Web/JavaScript/Guide/Meta_programming">Métaprogrammation</a></h2>
-
-<ul>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Meta_programming#les_proxies"><code>Proxy</code></a></li>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Meta_programming#les_gestionnaires_et_les_trappes">Gestionnaires et trappes</a></li>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Meta_programming#proxies_r.c3.a9vocables">Proxy révocable</a></li>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Meta_programming#r.c3.a9flexion"><code>Reflect</code></a></li>
-</ul>
-
-<h2><a href="/fr/docs/Web/JavaScript/Guide/Modules">Modules JavaScript</a></h2>
-
-<ul>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Modules#exporting_module_features">Exporter</a></li>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Modules#importing_features_into_your_script">Importer</a></li>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Modules#default_exports_versus_named_exports">Exports par défaut</a></li>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Modules#renaming_imports_and_exports">Renommage</a></li>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Modules#aggregating_modules">Agrégation de modules</a></li>
-  <li><a href="/fr/docs/Web/JavaScript/Guide/Modules#dynamic_module_loading">Chargement dynamique de modules</a></li>
-</ul>
-
-<p>{{Next("Web/JavaScript/Guide/Introduction")}}</p>
+{{jsSidebar("JavaScript Guide")}}
+
+Le guide JavaScript illustre comment utiliser [JavaScript](/fr/docs/Web/JavaScript) et fournit un aperçu des fonctionnalités du langage. Pour des informations exhaustives à propos des fonctionnalités du langage, voir la [référence JavaScript](/fr/docs/Web/JavaScript/Reference).
+
+## Chapitres
+
+Ce guide est divisé en plusieurs chapitres :
+
+## [Introduction](/fr/docs/Web/JavaScript/Guide/Introduction)
+
+- [À propos de ce guide](/fr/docs/Web/JavaScript/Guide/Introduction#o.c3.b9_trouver_des_informations_concernant_javascript)
+- [À propos de JavaScript](/fr/docs/Web/JavaScript/Guide/Introduction#qu'est-ce_que_javascript_.3f)
+- [JavaScript et Java](/fr/docs/Web/JavaScript/Guide/Introduction#javascript_and_java)
+- [ECMAScript](/fr/docs/Web/JavaScript/Guide/Introduction#javascript_and_the_ecmascript_specification)
+- [Les outils](/fr/docs/Web/JavaScript/Guide/Introduction#d.c3.a9marrer_avec_javascript)
+- [Hello World](</fr/docs/Web/JavaScript/Guide/Introduction#coucou_monde_(hello_world)>)
+
+## [Grammaire et types](/fr/docs/Web/JavaScript/Guide/Grammar_and_types)
+
+- [Syntaxe de base et commentaires](/fr/docs/Web/JavaScript/Guide/Grammar_and_types#les_bases_du_langage)
+- [Déclarations](/fr/docs/Web/JavaScript/Guide/Grammar_and_types#d.c3.a9clarations)
+- [Portées des variables](/fr/docs/Web/JavaScript/Guide/Grammar_and_types#les_port.c3.a9es_de_variables)
+- [Remontée des variables](</fr/docs/Web/JavaScript/Guide/Grammar_and_types#remont.c3.a9e_de_variables_(hoisting)>)
+- [Structures de données et types](/fr/docs/Web/JavaScript/Guide/Grammar_and_types#structures_de_donn.c3.a9es_et_types)
+- [Littéraux](/fr/docs/Web/JavaScript/Guide/Grammar_and_types#litt.c3.a9raux)
+
+## [Contrôle du flux et gestion des erreurs](/fr/docs/Web/JavaScript/Guide/Control_flow_and_error_handling)
+
+- [`if...else`](/fr/docs/Web/JavaScript/Guide/Contr%C3%B4le_du_flux_Gestion_des_erreurs#Instruction_if...else)
+- [`switch`](/fr/docs/Web/JavaScript/Guide/Contr%C3%B4le_du_flux_Gestion_des_erreurs#L%27instruction_switch)
+- [`try/catch/throw`](/fr/docs/Web/JavaScript/Guide/Contr%C3%B4le_du_flux_Gestion_des_erreurs#L%27instruction_try...catch)
+- [Objets `Error`](/fr/docs/Web/JavaScript/Guide/Contr%C3%B4le_du_flux_Gestion_des_erreurs#Utiliser_les_objets_Error)
+
+## [Itération et boucles](/fr/docs/Web/JavaScript/Guide/Loops_and_iteration)
+
+- [`for`](/fr/docs/Web/JavaScript/Guide/Boucles_et_it%C3%A9ration#L%27instruction_for)
+- [`while`](/fr/docs/Web/JavaScript/Guide/Boucles_et_it%C3%A9ration#L%27instruction_while)
+- [`do...while`](/fr/docs/Web/JavaScript/Guide/Boucles_et_it%C3%A9ration#L%27instruction_do...while)
+- [`break`](/fr/docs/Web/JavaScript/Guide/Boucles_et_it%C3%A9ration#L%27instruction_break)/[continue](/fr/docs/Web/JavaScript/Guide/Boucles_et_it%C3%A9ration#L%27instruction_continue)
+- [`for..in`](/fr/docs/Web/JavaScript/Guide/Boucles_et_it%C3%A9ration#L%27instruction_for...in)
+- [`for..of`](/fr/docs/Web/JavaScript/Guide/Loops_and_iteration#l'instruction_for...of)
+
+## [Fonctions](/fr/docs/Web/JavaScript/Guide/Functions)
+
+- [Définir des fonctions](/fr/docs/Web/JavaScript/Guide/Functions#d.c3.a9finir_des_fonctions)
+- [Appeler des fonctions](/fr/docs/Web/JavaScript/Guide/Functions#appeler_des_fonctions)
+- [Portées des fonctions](/fr/docs/Web/JavaScript/Guide/Functions#port.c3.a9e_d'une_fonction)
+- [Fermetures (_closures_)](</fr/docs/Web/JavaScript/Guide/Functions#fermetures_(closures)>)
+- [Arguments](/fr/docs/Web/JavaScript/Guide/Functions#utiliser_l'objet_arguments) et [paramètres](/fr/docs/Web/JavaScript/Guide/Functions#param.c3.a8tres_des_fonctions)
+- [Fonctions fléchées](/fr/docs/Web/JavaScript/Guide/Functions#fonctions_fl.c3.a9ch.c3.a9es)
+
+## [Expressions et opérateurs](/fr/docs/Web/JavaScript/Guide/Expressions_and_Operators)
+
+- [Affectation](/fr/docs/Web/JavaScript/Guide/Expressions_et_Op%C3%A9rateurs#Op.C3.A9rateurs_d%27affectation) et [comparaisons](/fr/docs/Web/JavaScript/Guide/Expressions_et_Op%C3%A9rateurs#Op.C3.A9rateurs_de_comparaison)
+- [Opérateurs arithmétiques](/fr/docs/Web/JavaScript/Guide/Expressions_and_Operators#op.c3.a9rateurs_arithm.c3.a9tiques)
+- [Opérateurs binaires](/fr/docs/Web/JavaScript/Guide/Expressions_et_Op%C3%A9rateurs#Op.C3.A9rateurs_binaires) et [logiques](/fr/docs/Web/JavaScript/Guide/Expressions_et_Op%C3%A9rateurs#Op.C3.A9rateurs_logiques)
+- [Opérateur conditionnel](/fr/docs/Web/JavaScript/Guide/Expressions_et_Op%C3%A9rateurs#Op.C3.A9rateur_conditionnel_ternaire)
+
+## [Nombres et dates](/fr/docs/Web/JavaScript/Guide/Numbers_and_dates)
+
+- [Littéraux numériques](/fr/docs/Web/JavaScript/Guide/Numbers_and_dates#nombres)
+- [Objet `Number`](/fr/docs/Web/JavaScript/Guide/Numbers_and_dates#l'objet_number)
+- [Objet `Math`](/fr/docs/Web/JavaScript/Guide/Numbers_and_dates#l'objet_math)
+- [Objet `Date`](/fr/docs/Web/JavaScript/Guide/Numbers_and_dates#l'objet_date)
+
+## [Formatage du texte](/fr/docs/Web/JavaScript/Guide/Text_formatting)
+
+- [Littéraux de chaînes de caractères](/fr/docs/Web/JavaScript/Guide/Text_formatting#les_litt.c3.a9raux_de_cha.c3.aenes_de_caract.c3.a8res)
+- [Objet `String`](/fr/docs/Web/JavaScript/Guide/Text_formatting#les_objets_string)
+- [Littéraux de gabarits](/fr/docs/Web/JavaScript/Guide/Text_formatting#les_litt%c3%a9raux_de_gabarits)
+- [Internationalisation](/fr/docs/Web/JavaScript/Guide/Text_formatting#internationalisation)
+- [Expressions rationnelles](/fr/docs/Web/JavaScript/Guide/Text_formatting#les_expressions_rationnelles)
+
+## [Collections indexées](/fr/docs/Web/JavaScript/Guide/Indexed_collections#le_type_array)
+
+- [Tableaux](/en-US/docs/Web/JavaScript/Guide/Indexed_collections#array_object)
+- [Tableaux typés](/fr/docs/Web/JavaScript/Guide/Indexed_collections#les_tableaux_typ.c3.a9s)
+
+## [Collections avec clés](/fr/docs/Web/JavaScript/Guide/Keyed_collections) - [`Map`](/fr/docs/Web/JavaScript/Guide/Keyed_collections#le_type_map)
+
+- [`WeakMap`](/en-US/docs/Web/JavaScript/Guide/Keyed_collections#weakmap_object)
+- [`Set`](/fr/docs/Web/JavaScript/Guide/Keyed_collections#le_type_set)
+- [`WeakSet`](/fr/docs/Web/JavaScript/Guide/Keyed_collections#le_type_weakset)
+
+## [Utiliser les objets](/fr/docs/Web/JavaScript/Guide/Working_with_Objects)
+
+- [Objets et propriétés](/fr/docs/Web/JavaScript/Guide/Working_with_Objects#les_objets_et_les_propri.c3.a9t.c3.a9s)
+- [Création d'objets](/fr/docs/Web/JavaScript/Guide/Working_with_Objects#cr.c3.a9er_de_nouveaux_objets)
+- [Définition de méthodes](/fr/docs/Web/JavaScript/Guide/Working_with_Objects#d.c3.a9finir_des_m.c3.a9thodes)
+- [Accesseurs et mutateurs](</fr/docs/Web/JavaScript/Guide/Working_with_Objects#d.c3.a9finir_des_accesseurs_et_des_mutateurs_(getters_et_setters)>)
+
+## [Le modèle objet JavaScript en détails](/fr/docs/Web/JavaScript/Guide/Details_of_the_Object_Model)
+
+- [Modèle à base de prototypes](/fr/docs/Web/JavaScript/Guide/Details_of_the_Object_Model#langages_de_prototypes_.2f_langages_de_classes)
+- [Créer des hiérarchies d'objets](/fr/docs/Web/JavaScript/Guide/Details_of_the_Object_Model#la_cr.c3.a9ation_de_la_hi.c3.a9rarchie)
+- [Héritage](/fr/docs/Web/JavaScript/Guide/Details_of_the_Object_Model#l'h.c3.a9ritage_de_propri.c3.a9t.c3.a9s_.3a_les_subtilit.c3.a9s)
+
+## [Promesses](/fr/docs/Web/JavaScript/Guide/Using_promises)
+
+- [Garanties](/fr/docs/Web/JavaScript/Guide/Using_promises#garanties)
+- [Chaînage](/fr/docs/Web/JavaScript/Guide/Using_promises#cha%c3%aenage_des_promesses)
+- [Propagation des erreurs](/fr/docs/Web/JavaScript/Guide/Using_promises#propagation_des_erreurs)
+- [Composition](/fr/docs/Web/JavaScript/Guide/Using_promises#composition)
+- [Gestion du temps](/fr/docs/Web/JavaScript/Guide/Using_promises#gestion_du_temps)
+
+## [Itérateurs et générateurs](/fr/docs/Web/JavaScript/Guide/Iterators_and_Generators)
+
+- [Itérateurs](/fr/docs/Web/JavaScript/Guide/Iterators_and_Generators#it.c3.a9rateurs)
+- [Itérables](/fr/docs/Web/JavaScript/Guide/Iterators_and_Generators#it.c3.a9rables)
+- [Générateurs](/fr/docs/Web/JavaScript/Guide/Iterators_and_Generators#g.c3.a9n.c3.a9rateurs)
+
+## [Métaprogrammation](/fr/docs/Web/JavaScript/Guide/Meta_programming)
+
+- [`Proxy`](/fr/docs/Web/JavaScript/Guide/Meta_programming#les_proxies)
+- [Gestionnaires et trappes](/fr/docs/Web/JavaScript/Guide/Meta_programming#les_gestionnaires_et_les_trappes)
+- [Proxy révocable](/fr/docs/Web/JavaScript/Guide/Meta_programming#proxies_r.c3.a9vocables)
+- [`Reflect`](/fr/docs/Web/JavaScript/Guide/Meta_programming#r.c3.a9flexion)
+
+## [Modules JavaScript](/fr/docs/Web/JavaScript/Guide/Modules)
+
+- [Exporter](/fr/docs/Web/JavaScript/Guide/Modules#exporting_module_features)
+- [Importer](/fr/docs/Web/JavaScript/Guide/Modules#importing_features_into_your_script)
+- [Exports par défaut](/fr/docs/Web/JavaScript/Guide/Modules#default_exports_versus_named_exports)
+- [Renommage](/fr/docs/Web/JavaScript/Guide/Modules#renaming_imports_and_exports)
+- [Agrégation de modules](/fr/docs/Web/JavaScript/Guide/Modules#aggregating_modules)
+- [Chargement dynamique de modules](/fr/docs/Web/JavaScript/Guide/Modules#dynamic_module_loading)
+
+{{Next("Web/JavaScript/Guide/Introduction")}}
diff --git a/files/fr/web/javascript/guide/indexed_collections/index.md b/files/fr/web/javascript/guide/indexed_collections/index.md
index 739de18bcc..8e1f789563 100644
--- a/files/fr/web/javascript/guide/indexed_collections/index.md
+++ b/files/fr/web/javascript/guide/indexed_collections/index.md
@@ -8,131 +8,139 @@ tags:
 translation_of: Web/JavaScript/Guide/Indexed_collections
 original_slug: Web/JavaScript/Guide/Collections_indexées
 ---
-<div>{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/Expressions_régulières", "Web/JavaScript/Guide/Collections_avec_clés")}}</div>
+{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/Expressions_régulières", "Web/JavaScript/Guide/Collections_avec_clés")}}
 
-<p>Ce chapitre présente les collections de données qui sont ordonnées par un indice. Cela inclue les tableaux et les objets semblables à des tableaux que sont les objets {{jsxref("Array")}} et les objets {{jsxref("TypedArray")}}.</p>
+Ce chapitre présente les collections de données qui sont ordonnées par un indice. Cela inclue les tableaux et les objets semblables à des tableaux que sont les objets {{jsxref("Array")}} et les objets {{jsxref("TypedArray")}}.
 
-<h2 id="Le_type_Array">Le type <code>Array</code></h2>
+## Le type `Array`
 
-<p>Un <em>tableau</em> (<em>array</em> en anglais) est un ensemble ordonné de valeurs auxquelles on peut faire référence avec un nom et un indice. Par exemple, si on a un tableau <code>emp</code> qui contient les noms d'employés indexés par leurs numéros d'employé, on pourrait utiliser <code>emp[1]</code> pour accéder à l'employé n°1, <code>emp[2]</code> pour accéder au deuxième et ainsi de suite.</p>
+Un _tableau_ (_array_ en anglais) est un ensemble ordonné de valeurs auxquelles on peut faire référence avec un nom et un indice. Par exemple, si on a un tableau `emp` qui contient les noms d'employés indexés par leurs numéros d'employé, on pourrait utiliser `emp[1]` pour accéder à l'employé n°1, `emp[2]` pour accéder au deuxième et ainsi de suite.
 
-<p>JavaScript ne possède pas de type particulier pour représenter un tableau de données. En revanche, il est possible d'utiliser l'objet natif <code>Array</code> ainsi que ses méthodes pour manipuler des tableaux. L'objet <code>Array</code> possède plusieurs méthodes qui permettent de manipuler les tableaux pour les fusionner, les inverser, les trier, etc. Il possède une propriété de longueur ainsi que d'autres propriétés qui peuvent être utilisées avec les expressions rationnelles.</p>
+JavaScript ne possède pas de type particulier pour représenter un tableau de données. En revanche, il est possible d'utiliser l'objet natif `Array` ainsi que ses méthodes pour manipuler des tableaux. L'objet `Array` possède plusieurs méthodes qui permettent de manipuler les tableaux pour les fusionner, les inverser, les trier, etc. Il possède une propriété de longueur ainsi que d'autres propriétés qui peuvent être utilisées avec les expressions rationnelles.
 
-<h3 id="Créer_un_tableau">Créer un tableau</h3>
+### Créer un tableau
 
-<p>Les instructions qui suivent sont équivalentes et permettent de créer le même tableau :</p>
+Les instructions qui suivent sont équivalentes et permettent de créer le même tableau :
 
-<pre class="brush: js notranslate">var arr = new Array(élément0, élément1, ..., élémentN);
+```js
+var arr = new Array(élément0, élément1, ..., élémentN);
 var arr = Array(élément0, élément1, ..., élémentN);
 var arr = [élément0, élément1, ..., élémentN];
-</pre>
+```
 
-<p><code>élément0, élément1, ..., élémentN</code> est une liste de valeurs qui formeront les éléments du tableau. Lorsque ces valeurs sont définies, le tableau initialisera la valeur des éléments correspondants. La propriété <code>length</code> du tableau permet de connaître le nombre d'arguments du tableau.</p>
+`élément0, élément1, ..., élémentN` est une liste de valeurs qui formeront les éléments du tableau. Lorsque ces valeurs sont définies, le tableau initialisera la valeur des éléments correspondants. La propriété `length` du tableau permet de connaître le nombre d'arguments du tableau.
 
-<p>Parmi les instructions précédentes, une utilise des crochets, on appelle ceci un « littéral de tableau » ou un « initialisateur de tableau ». Cette notation est plus courte que les autres et est souvent préférée pour sa lisibilité. Pour plus d'informations sur cette notation, voir la page sur <a href="/fr/docs/Web/JavaScript/Guide/Types_et_grammaire">les littéraux de tableaux</a> pour plus détails.</p>
+Parmi les instructions précédentes, une utilise des crochets, on appelle ceci un « littéral de tableau » ou un « initialisateur de tableau ». Cette notation est plus courte que les autres et est souvent préférée pour sa lisibilité. Pour plus d'informations sur cette notation, voir la page sur [les littéraux de tableaux](/fr/docs/Web/JavaScript/Guide/Types_et_grammaire) pour plus détails.
 
-<p>Afin de créer un tableau de longueur non nulle mais sans aucun élément initialisé, on peut utiliser l'une des deux instructions suivantes :</p>
+Afin de créer un tableau de longueur non nulle mais sans aucun élément initialisé, on peut utiliser l'une des deux instructions suivantes :
 
-<pre class="brush: js notranslate">var arr = new Array(longueurTableau);
+```js
+var arr = new Array(longueurTableau);
 var arr = Array(longueurTableau);
 
 // Cela aura le même effet que :
 var arr = [];
 arr.length = longueurTableau;
-</pre>
+```
 
-<div class="note">
-<p><strong>Note :</strong> Dans le code ci-dessus <code>longueurTableau</code> doit être un nombre. Si ce n'est pas le cas, un tableau d'un seul élément (ayant la valeur fournie) sera créé. <code>arr.length</code> renverra <code>longueurTableau</code>, mais le tableau ne contiendra que des éléments « vides » non définis. Si on utilise une boucle {{jsxref("Instructions/for...in")}} sur ce tableau, on ne trouvera aucun élément.</p>
-</div>
+> **Note :** Dans le code ci-dessus `longueurTableau` doit être un nombre. Si ce n'est pas le cas, un tableau d'un seul élément (ayant la valeur fournie) sera créé. `arr.length` renverra `longueurTableau`, mais le tableau ne contiendra que des éléments « vides » non définis. Si on utilise une boucle {{jsxref("Instructions/for...in")}} sur ce tableau, on ne trouvera aucun élément.
 
-<p>On a vu comment créer un tableau, il est aussi possible d'affecter des tableaux à des propriétés d'objets (que ce soit lors de leur création ou pour les modifier) :</p>
+On a vu comment créer un tableau, il est aussi possible d'affecter des tableaux à des propriétés d'objets (que ce soit lors de leur création ou pour les modifier) :
 
-<pre class="brush: js notranslate">var obj = {};
+```js
+var obj = {};
 // ...
 obj.prop = [élément0, élément1, ..., élémentN];
 
 // OU
 var obj = {prop: [élément0, élément1, ...., élémentN]}
-</pre>
+```
 
-<p>Si on souhaite initialiser un tableau avec un seul élément et que cet élément est un nombre, il est nécessaire d'utiliser la notation littérale. En effet, si un nombre est passé à la fonction <code>Array()</code> pour construire le tableau, celui-ci sera interprété comme une longueur et non comme la valeur d'un élément.</p>
+Si on souhaite initialiser un tableau avec un seul élément et que cet élément est un nombre, il est nécessaire d'utiliser la notation littérale. En effet, si un nombre est passé à la fonction `Array()` pour construire le tableau, celui-ci sera interprété comme une longueur et non comme la valeur d'un élément.
 
-<pre class="brush: js notranslate">var arr1 = [42];      // Le tableau créé contient bien un élément qui vaut 42
+```js
+var arr1 = [42];      // Le tableau créé contient bien un élément qui vaut 42
 var arr2 = Array(42); // Crée un tableau sans élément
                       // mais dont arr.length vaut 42
 
 // Le code ci-dessus est équivalent à
 var arr = [];
 arr.length = 42 ;
-</pre>
+```
 
-<p>Si N est un nombre décimal dont la partie fractionnaire n'est pas nulle, tout appel à <code>Array(N)</code> renverra une exception <code>RangeError</code>. Par exemple :</p>
+Si N est un nombre décimal dont la partie fractionnaire n'est pas nulle, tout appel à `Array(N)` renverra une exception `RangeError`. Par exemple :
 
-<pre class="brush: js notranslate">var arr = Array(9.3);  // RangeError: Invalid array length
-</pre>
+```js
+var arr = Array(9.3);  // RangeError: Invalid array length
+```
 
-<p>Si on souhaite créer un tableau d'un seul élément et ce quel que soit le type de données, il sera préférable d'utiliser les littéraux de tableaux. Sinon, on peut créer un tableau vide puis lui ajouter un seul élément.</p>
+Si on souhaite créer un tableau d'un seul élément et ce quel que soit le type de données, il sera préférable d'utiliser les littéraux de tableaux. Sinon, on peut créer un tableau vide puis lui ajouter un seul élément.
 
-<p>Avec ES2015 (anciennement ECMAScript 6), on peut utiliser la méthode {{jsxref("Array.of")}} afin de créer un tableau composé d'un seul élément :</p>
+Avec ES2015 (anciennement ECMAScript 6), on peut utiliser la méthode {{jsxref("Array.of")}} afin de créer un tableau composé d'un seul élément :
 
-<pre class="brush: js notranslate">let monTableau = Array.of("Joconde"); // monTableau contient uniquement "Joconde"</pre>
+```js
+let monTableau = Array.of("Joconde"); // monTableau contient uniquement "Joconde"
+```
 
-<h3 id="Remplir_un_tableau">Remplir un tableau</h3>
+### Remplir un tableau
 
-<p>Il est possible de remplir un tableau en affectant des valeurs à ses éléments. Par exemple :</p>
+Il est possible de remplir un tableau en affectant des valeurs à ses éléments. Par exemple :
 
-<pre class="brush: js notranslate">var emp = [];
+```js
+var emp = [];
 emp[0] = "Casey Jones";
 emp[1] = "Phil Lesh";
 emp[2] = "August West";
-</pre>
+```
 
-<div class="note">
-<p><strong>Note :</strong> Si on utilise une valeur non entière pour désigner un élément du tableau, cela créera une propriété sur l'objet plutôt qu'un élément du tableau :</p>
+> **Note :** Si on utilise une valeur non entière pour désigner un élément du tableau, cela créera une propriété sur l'objet plutôt qu'un élément du tableau :
+>
+> ```js
+> var arr = [];
+> arr[3.4] = "Oranges";
+> console.log(arr.length);                // 0
+> console.log(arr.hasOwnProperty(3.4));   // true
+> ```
 
-<pre class="brush: js notranslate">var arr = [];
-arr[3.4] = "Oranges";
-console.log(arr.length);                // 0
-console.log(arr.hasOwnProperty(3.4));   // true
-</pre>
-</div>
+Il est aussi possible de remplir un tableau directement lors de sa création :
 
-<p>Il est aussi possible de remplir un tableau directement lors de sa création :</p>
-
-<pre class="brush: js notranslate">var monTableau = new Array("Coucou", maVar, 3.14159);
+```js
+var monTableau = new Array("Coucou", maVar, 3.14159);
 var monTableau = ["Mangue", "Pomme", "Orange"]
-</pre>
-
-<h3 id="Faire_référence_aux_éléments_dun_tableau">Faire référence aux éléments d'un tableau</h3>
+```
 
-<p>Il est possible de faire référence aux éléments d'un tableau en utilisant un nombre ordinal lié à l'élément. Ainsi, si on définit le tableau suivant :</p>
+### Faire référence aux éléments d'un tableau
 
-<pre class="brush: js notranslate">var monTableau = ["Air", "Eau", "Feu"];
-</pre>
+Il est possible de faire référence aux éléments d'un tableau en utilisant un nombre ordinal lié à l'élément. Ainsi, si on définit le tableau suivant :
 
-<p>On pourra accéder au premier élément du tableau en utilisant <code>monTableau[0]</code>, on accèdera au deuxième élément avec <code>monTableau[1]</code>. Les indices des éléments sont comptés à partir de 0.</p>
+```js
+var monTableau = ["Air", "Eau", "Feu"];
+```
 
-<div class="note">
-<p><strong>Note :</strong> Les crochets peuvent également être utilisés pour faire référence aux propriétés du tableau (les tableaux sont des objets JavaScript à part entière). On pourra donc avoir :</p>
+On pourra accéder au premier élément du tableau en utilisant `monTableau[0]`, on accèdera au deuxième élément avec `monTableau[1]`. Les indices des éléments sont comptés à partir de 0.
 
-<pre class="brush: js notranslate">var arr = ["un", "deux", "trois"];
-arr[2];         // "trois" - on accède à un élément du tableau
-arr["length"];  // 3 - on accède à une propriété du tableau
-</pre>
-</div>
+> **Note :** Les crochets peuvent également être utilisés pour faire référence aux propriétés du tableau (les tableaux sont des objets JavaScript à part entière). On pourra donc avoir :
+>
+> ```js
+> var arr = ["un", "deux", "trois"];
+> arr[2];         // "trois" - on accède à un élément du tableau
+> arr["length"];  // 3 - on accède à une propriété du tableau
+> ```
 
-<h3 id="Comprendre_la_propriété_length">Comprendre la propriété <code>length</code></h3>
+### Comprendre la propriété `length`
 
-<p>En termes d'implémentation, les tableaux JavaScript stockent leurs éléments comme des propriétés normales, l'indice étant utilisé comme nom pour désigner la valeur de la propriété. La propriété <code>length</code> est elle un peu spéciale : elle renvoie toujours la valeur du plus grand indice du tableau plus 1. Dans l'exemple suivant, "Biduche" est placé à l'indice 30, <code>chats.length</code> renvoie donc 30 + 1). On rappelle que les indices des tableaux JavaScript commencent à partir de 0 et pas à partir de 1. Cela signifie que la valeur de la propriété <code><code>length</code></code> sera plus grande, de 1, par rapport à l'indice le plus élevé :</p>
+En termes d'implémentation, les tableaux JavaScript stockent leurs éléments comme des propriétés normales, l'indice étant utilisé comme nom pour désigner la valeur de la propriété. La propriété `length` est elle un peu spéciale : elle renvoie toujours la valeur du plus grand indice du tableau plus 1. Dans l'exemple suivant, "Biduche" est placé à l'indice 30, `chats.length` renvoie donc 30 + 1). On rappelle que les indices des tableaux JavaScript commencent à partir de 0 et pas à partir de 1. Cela signifie que la valeur de la propriété `length` sera plus grande, de 1, par rapport à l'indice le plus élevé :
 
-<pre class="brush: js notranslate">var chats = [];
+```js
+var chats = [];
 chats[30] = ['Biduche'];
 console.log(chats.length); // 31
-</pre>
+```
 
-<p>Il est aussi possible d'affecter une valeur à la propriété <code>length</code>. Si la valeur fournie est inférieure au nombre d'éléments stockés, cela tronquera la tableau. Si la valeur est 0, cela videra le tableau :</p>
+Il est aussi possible d'affecter une valeur à la propriété `length`. Si la valeur fournie est inférieure au nombre d'éléments stockés, cela tronquera la tableau. Si la valeur est 0, cela videra le tableau :
 
-<pre class="brush: js notranslate">var chats = ['Marie', 'Toulouse', 'Berlioz'];
+```js
+var chats = ['Marie', 'Toulouse', 'Berlioz'];
 console.log(chats.length); // 3
 
 chats.length = 2;
@@ -142,47 +150,53 @@ chats.length = 0;
 console.log(chats); // affiche [], le tableau est vide
 
 chats.length = 3;
-console.log(chats); // [ &lt;3 empty slots&gt; ]
-</pre>
+console.log(chats); // [ <3 empty slots> ]
+```
 
-<h3 id="Parcourir_un_tableau">Parcourir un tableau</h3>
+### Parcourir un tableau
 
-<p>Un tableau est une structure de données qui se prête particulièrement aux boucles, on pourra utiliser ces dernières pour parcourir les éléments du tableau de façon itérative. Voici un exemple de parcours simple :</p>
+Un tableau est une structure de données qui se prête particulièrement aux boucles, on pourra utiliser ces dernières pour parcourir les éléments du tableau de façon itérative. Voici un exemple de parcours simple :
 
-<pre class="brush: js notranslate">var couleurs = ['rouge', 'vert', 'bleu'];
-for (var i = 0; i &lt; couleurs.length; i++) {
+```js
+var couleurs = ['rouge', 'vert', 'bleu'];
+for (var i = 0; i < couleurs.length; i++) {
   console.log(couleurs[i]);
 }
-</pre>
+```
 
-<p>Si on sait qu'aucun des éléments ne vaut <code>false</code> dans un contexte booléen (par exemple, si le tableau contient des nœuds du <a href="/fr/docs/Web/API/Référence_du_DOM_Gecko">DOM</a>), on peut utiliser une formulation encore plus concise :</p>
+Si on sait qu'aucun des éléments ne vaut `false` dans un contexte booléen (par exemple, si le tableau contient des nœuds du [DOM](/fr/docs/Web/API/Référence_du_DOM_Gecko)), on peut utiliser une formulation encore plus concise :
 
-<pre class="brush: js notranslate">var divs = document.getElementsByTagName('div');
+```js
+var divs = document.getElementsByTagName('div');
 for (var i = 0, div; div = divs[i]; i++) {
   /* On effectue un traitement sur les  div */
 }
-</pre>
+```
 
-<p>Cette syntaxe permet d'éviter d'avoir à vérifier la longueur du tableau et de gérer l'affectation de la variable <code>div</code> pour chaque élément du tableau.</p>
+Cette syntaxe permet d'éviter d'avoir à vérifier la longueur du tableau et de gérer l'affectation de la variable `div` pour chaque élément du tableau.
 
-<p>La méthode {{jsxref("Array.forEach", "forEach()")}} fournit une autre méthode pour parcourir un tableau :</p>
+La méthode {{jsxref("Array.forEach", "forEach()")}} fournit une autre méthode pour parcourir un tableau :
 
-<pre class="brush: js notranslate">var couleurs = ['rouge', 'vert', 'bleu'];
+```js
+var couleurs = ['rouge', 'vert', 'bleu'];
 couleurs.forEach(function(couleur) {
   console.log(couleur);
 });
-</pre>
+```
 
-<p>Avec les fonctions fléchées (apparues avec ES6 / ECMAScript 2015), on peut obtenir un code plus concis :</p>
+Avec les fonctions fléchées (apparues avec ES6 / ECMAScript 2015), on peut obtenir un code plus concis :
 
-<pre class="brush: js notranslate">var couleurs = ['rouge', 'vert', 'bleu'];
-couleurs.forEach(couleur =&gt; console.log(couleur));</pre>
+```js
+var couleurs = ['rouge', 'vert', 'bleu'];
+couleurs.forEach(couleur => console.log(couleur));
+```
 
-<p>La fonction passée comme argument à <code>forEach()</code> est exécutée une fois pour chacun des éléments du tableau (l'élément du tableau sera passé comme argument de cette fonction). Les éléments qui n'ont pas de valeur affectée ne sont pas parcourus lors d'une boucle <code>forEach</code>.</p>
+La fonction passée comme argument à `forEach()` est exécutée une fois pour chacun des éléments du tableau (l'élément du tableau sera passé comme argument de cette fonction). Les éléments qui n'ont pas de valeur affectée ne sont pas parcourus lors d'une boucle `forEach`.
 
-<p>On notera que les éléments ne sont pas parcourus lorsqu'ils n'ont pas eu de valeur d'affectée. Cependant, si on a affecté la valeur {{jsxref("undefined")}} de façon explicite à un élément, il sera pris en compte lors de la boucle :</p>
+On notera que les éléments ne sont pas parcourus lorsqu'ils n'ont pas eu de valeur d'affectée. Cependant, si on a affecté la valeur {{jsxref("undefined")}} de façon explicite à un élément, il sera pris en compte lors de la boucle :
 
-<pre class="brush: js notranslate">var tableau = ['premier', 'deuxième', , 'quatrième'];
+```js
+var tableau = ['premier', 'deuxième', , 'quatrième'];
 
 // affiche ['premier', 'deuxième', 'quatrième'];
 tableau.forEach(function(élément) {
@@ -196,231 +210,264 @@ var tableau = ['premier', 'deuxième', undefined, 'quatrième'];
 // renvoie ['premier', 'deuxième', undefined, 'quatrième'];
 tableau.forEach(function(élément) {
   console.log(élément);
-})</pre>
-
-<p>Étant donné que les éléments des tableaux sont stockés comme des propriétés classiques, il n'est pas conseillé d'utiliser des boucles {{jsxref("Instructions/for...in")}} pour parcourir les tableaux car cela listerait également les propriétés énumérables (en plus des éléments).</p>
-
-<h3 id="Méthodes_des_tableaux">Méthodes des tableaux</h3>
-
-<p>L'objet <code>Array</code> possède les méthodes suivantes :</p>
-
-<ul>
- <li>{{jsxref("Array.concat", "concat()")}} permet de fusionner deux ou plusieurs tableaux et de renvoyer le résultat dans un nouveau tableau :
-  <pre class="brush: js notranslate">var monTableau = new Array("1", "2", "3");
-monTableau = monTableau.concat("a", "b", "c"); // monTableau is now ["1", "2", "3", "a", "b", "c"]
-</pre>
- </li>
- <li>{{jsxref("Array.join", "join(délimiteur = ',')")}} permet de fusionner les éléments du tableau en une chaîne de caractères :
-  <pre class="brush: js notranslate">var monTableau = new Array("Air", "Eau", "Feu");
-var list = monTableau.join(" - "); // list sera "Air - Eau - Feu"
-</pre>
- </li>
- <li>{{jsxref("Array.push", "push()")}} permet d'ajouter un ou plusieurs éléments à la fin d'un tableau et renvoie la longueur du tableau :
-  <pre class="brush: js notranslate">var monTableau = new Array("1", "2");
-monTableau.push("3"); // monTableau vaut désormais ["1", "2", "3"]
-</pre>
- </li>
- <li>{{jsxref("Array.pop", "pop()")}} permet de retirer le dernier élément (le plus à droite) du tableau et renvoie cet élément :
-  <pre class="brush: js notranslate">var monTableau = new Array("1", "2", "3");
-var dernier = monTableau.pop(); // monTableau vaut désormais ["1", "2"], dernier = "3"
-</pre>
- </li>
- <li>{{jsxref("Array.shift", "shift()")}} retire le premier élément d'un tableau (le plus à gauche) et renvoie cet élément :
-  <pre class="brush: js notranslate">var monTableau = new Array("1", "2", "3");
-var premier = monTableau.shift(); // monTableau vaut désormais ["2", "3"], premier vaut "1"
-</pre>
- </li>
- <li>{{jsxref("Array.unshift", "unshift()")}} ajoute un ou plusieurs éléments au début du tableau et renvoie la longueur du tableau ainsi modifié :
-  <pre class="brush: js notranslate">var monTableau = new Array("1", "2", "3");
-monTableau.unshift("4", "5"); // monTableau devient ["4", "5", "1", "2", "3"]</pre>
- </li>
- <li>{{jsxref("Array.slice", "slice(indice_début, indice_fin)")}} extrait une portion d'un tableau et renvoie un nouveau tableau avec ce fragment :
-  <pre class="brush: js notranslate">var monTableau = new Array ("a", "b", "c", "d", "e");
-monTableau = monTableau.slice(1, 4); // extrait les éléments entre l'indice 1 et jusqu'à
-                                     // celui d'indice 3 (4-1), elle renvoie
-                                     // [ "b", "c", "d"]
-</pre>
- </li>
- <li>{{jsxref("Array.splice", "splice(indice, nbASupprimer, ajouterElement1, ajouterElement2, ...)")}} retire des éléments du tableau et (éventuellement) les remplace :
-  <pre class="brush: js notranslate">var monTableau = new Array ("1", "2", "3", "4", "5");
-monTableau.splice(1, 3, "a", "b", "c", "d"); // monTableau vaut désormais ["1", "a", "b", "c", "d", "5"]
-  // Le code remplace à partir de l'indice 1 (où il y avait la valeur "2"), supprime trois éléments puis
-  // insère les arguments fournis à la suite.
-</pre>
- </li>
- <li>{{jsxref("Array.reverse", "reverse()")}} transpose les éléments du tableau à même ce tableau : le premier élément devient le dernier, le dernier devient le premier et ainsi de suite :
-  <pre class="brush: js notranslate">var monTableau = new Array ("1", "2", "3");
-monTableau.reverse(); // monTableau vaut maintenant [ "3", "2", "1" ]
-</pre>
- </li>
- <li>{{jsxref("Array.sort", "sort()")}} trie les éléments d'un tableau à même ce tableau :
-  <pre class="brush: js notranslate">var monTableau = new Array("Air", "Feu", "Eau");
-monTableau.sort(); // trie le tableau [ "Air", "Eau", "Feu" ]
-</pre>
-
-  <p><code>sort()</code> peut également utiliser une fonction de rappel (<em>callback</em>) qui détermine comment les éléments sont comparés. La fonction compare deux arguments et renvoie une valeur selon les règles suivantes :</p>
-
-  <ul>
-   <li>Si <code>a</code> est inférieur à <code>b</code> selon l'ordre, renvoie -1 (ou un autre nombre négatif)</li>
-   <li>Si <code>a</code> est supérieur à <code>b</code> selon l'ordre, renvoie 1 (ou un autre nombre positif)</li>
-   <li>Si <code>a</code> et <code>b</code> sont considérés égaux, renvoie 0.</li>
-  </ul>
-
-  <p>Par exemple, on peut utilise la fonction suivante pour trier par rapport à la dernière lettre du mot :</p>
-
-  <pre class="brush: js notranslate">var sortFn = function(a, b){
-  if (a[a.length - 1] &lt; b[b.length - 1]) return -1;
-  if (a[a.length - 1] &gt; b[b.length - 1]) return 1;
-  if (a[a.length - 1] == b[b.length - 1]) return 0;
-}
-monTableau.sort(sortFn); // le tableau devient = ["Air","Feu","Eau"]</pre>
- </li>
-</ul>
-
-<p>Du code permettant d'émuler ces fonctions est disponible sur chacune des pages (<em>polyfill</em>). Le support natif de ces fonctionnalités dans les différents navigateurs peut être trouvé <a href="http://www.robertnyman.com/javascript/">ici</a><a href="http://www.robertnyman.com/javascript/">.</a></p>
-
-<ul>
- <li>{{jsxref("Array.indexOf", "indexOf(élémentRecherché[, indiceDépart])")}} recherche la valeur <code>élémentRecherché</code> dans le tableau et renvoie l'indice du premier élément qui correspond :
-
-  <pre class="brush: js notranslate">var a = ['a', 'b', 'a', 'b', 'a'];
-console.log(a.indexOf('b'));    // Affiche 1
-// On recherche après la première correspondance :
-console.log(a.indexOf('b', 2)); // Affiche 3
-console.log(a.indexOf('z'));    // Affiche -1 car 'z' n'a pas été trouvé
-</pre>
- </li>
- <li>{{jsxref("Array.lastIndexOf", "lastIndexOf(élémentRecherché[, fromIndex])")}} fonctionne comme <code>indexOf</code>, mais recherche à partir de la fin du tableau :
-  <pre class="brush: js notranslate">var a = ['a', 'b', 'c', 'd', 'a', 'b'];
-console.log(a.lastIndexOf('b'));    // Affiche 5
-// On continue la recherche après la première correspondance en fin de tableau
-console.log(a.lastIndexOf('b', 4)); // Affiche 1
-console.log(a.lastIndexOf('z'));    // Affiche -1
-</pre>
- </li>
- <li>{{jsxref("Array.forEach", "forEach(callback[, objetThis])")}} exécute la fonction <code>callback</code> sur chaque élément du tableau.
-  <pre class="brush: js notranslate">var a = ['a', 'b', 'c'];
-a.forEach(console.log); // Affichera la valeur de chaque élément dans la console
-</pre>
- </li>
- <li>{{jsxref("Array.map", "map(callback[, objetThis])")}} renvoie un nouveau tableau dont les éléments sont les images des éléments du tableau courant par la fonction <code>callback</code> :
-  <pre class="brush: js notranslate">var a1 = ['a', 'b', 'c'];
-var a2 = a1.map(function(item) { return item.toUpperCase(); });
-console.log(a2); // affichera A,B,C dans la console
-</pre>
- </li>
- <li>{{jsxref("Array.filter", "filter(callback[, objetThis])")}} renvoie un nouveau tableau qui contient les éléments du tableau courant pour lesquels <code>callback</code> a renvoyé <code>true</code>.
-  <pre class="brush: js notranslate">var a1 = ['a', 10, 'b', 20, 'c', 30];
-var a2 = a1.filter(function(item) { return typeof item == 'number'; });
-console.log(a2); // Affichera 10,20,30 dans la console
-</pre>
- </li>
- <li>{{jsxref("Array.every", "every(callback[, objetThis])")}} renvoie <code>true</code> si <code>callback</code> renvoie <code>true</code> pour chaque élément du tableau.
-  <pre class="brush: js notranslate">function isNumber(value){
-  return typeof value === 'number';
-}
-var a1 = [1, 2, 3];
-console.log(a1.every(isNumber)); // affiche true
-var a2 = [1, '2', 3];
-console.log(a2.every(isNumber)); // affiche false
-</pre>
- </li>
- <li>{{jsxref("Array.some", "some(callback[, objetThis])")}} renvoie <code>true</code> si <code>callback</code> renvoie <code>true</code> pour au moins un élément du tableau.
-  <pre class="brush: js notranslate">function isNumber(value){
-  return typeof value === 'number';
-}
-var a1 = [1, 2, 3];
-console.log(a1.some(isNumber)); // Affiche true
-var a2 = [1, '2', 3];
-console.log(a2.some(isNumber)); // Affiche true
-var a3 = ['1', '2', '3'];
-console.log(a3.some(isNumber)); // Affiche false
-</pre>
- </li>
-</ul>
+})
+```
+
+Étant donné que les éléments des tableaux sont stockés comme des propriétés classiques, il n'est pas conseillé d'utiliser des boucles {{jsxref("Instructions/for...in")}} pour parcourir les tableaux car cela listerait également les propriétés énumérables (en plus des éléments).
+
+### Méthodes des tableaux
+
+L'objet `Array` possède les méthodes suivantes :
+
+- {{jsxref("Array.concat", "concat()")}} permet de fusionner deux ou plusieurs tableaux et de renvoyer le résultat dans un nouveau tableau :
+
+  ```js
+    var monTableau = new Array("1", "2", "3");
+    monTableau = monTableau.concat("a", "b", "c"); // monTableau is now ["1", "2", "3", "a", "b", "c"]
+    ```
+
+- {{jsxref("Array.join", "join(délimiteur = ',')")}} permet de fusionner les éléments du tableau en une chaîne de caractères :
+
+  ```js
+    var monTableau = new Array("Air", "Eau", "Feu");
+    var list = monTableau.join(" - "); // list sera "Air - Eau - Feu"
+    ```
+
+- {{jsxref("Array.push", "push()")}} permet d'ajouter un ou plusieurs éléments à la fin d'un tableau et renvoie la longueur du tableau :
+
+  ```js
+    var monTableau = new Array("1", "2");
+    monTableau.push("3"); // monTableau vaut désormais ["1", "2", "3"]
+    ```
+
+- {{jsxref("Array.pop", "pop()")}} permet de retirer le dernier élément (le plus à droite) du tableau et renvoie cet élément :
+
+  ```js
+    var monTableau = new Array("1", "2", "3");
+    var dernier = monTableau.pop(); // monTableau vaut désormais ["1", "2"], dernier = "3"
+    ```
+
+- {{jsxref("Array.shift", "shift()")}} retire le premier élément d'un tableau (le plus à gauche) et renvoie cet élément :
+
+  ```js
+    var monTableau = new Array("1", "2", "3");
+    var premier = monTableau.shift(); // monTableau vaut désormais ["2", "3"], premier vaut "1"
+    ```
+
+- {{jsxref("Array.unshift", "unshift()")}} ajoute un ou plusieurs éléments au début du tableau et renvoie la longueur du tableau ainsi modifié :
+
+  ```js
+    var monTableau = new Array("1", "2", "3");
+    monTableau.unshift("4", "5"); // monTableau devient ["4", "5", "1", "2", "3"]
+    ```
+
+- {{jsxref("Array.slice", "slice(indice_début, indice_fin)")}} extrait une portion d'un tableau et renvoie un nouveau tableau avec ce fragment :
+
+  ```js
+    var monTableau = new Array ("a", "b", "c", "d", "e");
+    monTableau = monTableau.slice(1, 4); // extrait les éléments entre l'indice 1 et jusqu'à
+                                         // celui d'indice 3 (4-1), elle renvoie
+                                         // [ "b", "c", "d"]
+    ```
+
+- {{jsxref("Array.splice", "splice(indice, nbASupprimer, ajouterElement1, ajouterElement2, ...)")}} retire des éléments du tableau et (éventuellement) les remplace :
+
+  ```js
+    var monTableau = new Array ("1", "2", "3", "4", "5");
+    monTableau.splice(1, 3, "a", "b", "c", "d"); // monTableau vaut désormais ["1", "a", "b", "c", "d", "5"]
+      // Le code remplace à partir de l'indice 1 (où il y avait la valeur "2"), supprime trois éléments puis
+      // insère les arguments fournis à la suite.
+    ```
 
-<p>Les méthodes présentées ci-avant qui prennent une fonction de rappel (<em>callback</em>) en argument sont appelées méthodes itératives car elles parcourent le tableau de façon itérative. Chacune de ces méthodes peut prendre en compte un deuxième argument (optionnel) qui sera l'objet <code>this</code> pris en compte par le <em>callback</em>. Si ce deuxième argument n'est pas fourni, <code>this</code> vaudra la valeur de l'objet global.</p>
+- {{jsxref("Array.reverse", "reverse()")}} transpose les éléments du tableau à même ce tableau : le premier élément devient le dernier, le dernier devient le premier et ainsi de suite :
 
-<p>La fonction de rappel est appelée avec trois arguments : le premier étant la valeur de l'élément courant, le deuxième est l'indice de cet élément et le troisième représente le tableau lui-même. Les fonctions JavaScript ignorent les arguments supplémentaires qui ne sont pas déclarés explicitement dans la liste des paramètres, on peut donc utiliser une fonction prenant un seul argument comme fonction de rappel.</p>
+  ```js
+    var monTableau = new Array ("1", "2", "3");
+    monTableau.reverse(); // monTableau vaut maintenant [ "3", "2", "1" ]
+    ```
 
-<ul>
- <li>{{jsxref("Array.reduce", "reduce(callback[, valeurInitiale])")}} applique <code>callback(premièreValeur, secondeValeur)</code> au fur et à mesure sur le tableau pour le réduire en une seule valeur, c'est cette valeur qui est renvoyée par la fonction :
+- {{jsxref("Array.sort", "sort()")}} trie les éléments d'un tableau à même ce tableau :
 
-  <pre class="brush: js notranslate">var a = [10, 20, 30];
-var total = a.reduce(function(premier, deuxième) { return premier + deuxième; }, 0);
-console.log(total) // Affiche 60
-</pre>
- </li>
- <li>{{jsxref("Array.reduceRight", "reduceRight(callback[, valeurInitiale])")}} fonctionne comme <code>reduce()</code>, mais débute avec le dernier élément (parcourt le tableau de droite à gauche).</li>
-</ul>
+  ```js
+    var monTableau = new Array("Air", "Feu", "Eau");
+    monTableau.sort(); // trie le tableau [ "Air", "Eau", "Feu" ]
+    ```
 
-<p><code>reduce()</code> et <code>reduceRight()</code> sont à utiliser lorsqu'on souhaite n'obtenir qu'une seule valeur, récursivement, à partir des différents éléments du tableau. Pour plus d'informations sur l'utilisation d'une valeur d'initialisation pour ces deux fonctions, se référer à leurs pages : {{jsxref("Array.reduceRight")}} et {{jsxref("Array.reduce")}}</p>
+  `sort()` peut également utiliser une fonction de rappel (_callback_) qui détermine comment les éléments sont comparés. La fonction compare deux arguments et renvoie une valeur selon les règles suivantes :
 
-<h3 id="Tableaux_multi-dimensionnels">Tableaux multi-dimensionnels</h3>
+  - Si `a` est inférieur à `b` selon l'ordre, renvoie -1 (ou un autre nombre négatif)
+  - Si `a` est supérieur à `b` selon l'ordre, renvoie 1 (ou un autre nombre positif)
+  - Si `a` et `b` sont considérés égaux, renvoie 0.
 
-<p>Les tableaux peuvent être imbriqués les uns dans les autres. Cela signifie qu'un tableau peut avoir un élément dont la valeur est un tableau. En utilisant ce comportement, on peut donc créer des matrices, voire des tableaux à plusieurs dimensions.</p>
+  Par exemple, on peut utilise la fonction suivante pour trier par rapport à la dernière lettre du mot :
 
-<p>Par exemple, avec le code suivant :</p>
+  ```js
+    var sortFn = function(a, b){
+      if (a[a.length - 1] < b[b.length - 1]) return -1;
+      if (a[a.length - 1] > b[b.length - 1]) return 1;
+      if (a[a.length - 1] == b[b.length - 1]) return 0;
+    }
+    monTableau.sort(sortFn); // le tableau devient = ["Air","Feu","Eau"]
+    ```
 
-<pre class="brush: js notranslate">var a = new Array(4);
-for (i = 0; i &lt; 4; i++) {
+Du code permettant d'émuler ces fonctions est disponible sur chacune des pages (_polyfill_). Le support natif de ces fonctionnalités dans les différents navigateurs peut être trouvé [ici](http://www.robertnyman.com/javascript/)[.](http://www.robertnyman.com/javascript/)
+
+- {{jsxref("Array.indexOf", "indexOf(élémentRecherché[, indiceDépart])")}} recherche la valeur `élémentRecherché` dans le tableau et renvoie l'indice du premier élément qui correspond :
+
+  ```js
+    var a = ['a', 'b', 'a', 'b', 'a'];
+    console.log(a.indexOf('b'));    // Affiche 1
+    // On recherche après la première correspondance :
+    console.log(a.indexOf('b', 2)); // Affiche 3
+    console.log(a.indexOf('z'));    // Affiche -1 car 'z' n'a pas été trouvé
+    ```
+
+- {{jsxref("Array.lastIndexOf", "lastIndexOf(élémentRecherché[, fromIndex])")}} fonctionne comme `indexOf`, mais recherche à partir de la fin du tableau :
+
+  ```js
+    var a = ['a', 'b', 'c', 'd', 'a', 'b'];
+    console.log(a.lastIndexOf('b'));    // Affiche 5
+    // On continue la recherche après la première correspondance en fin de tableau
+    console.log(a.lastIndexOf('b', 4)); // Affiche 1
+    console.log(a.lastIndexOf('z'));    // Affiche -1
+    ```
+
+- {{jsxref("Array.forEach", "forEach(callback[, objetThis])")}} exécute la fonction `callback` sur chaque élément du tableau.
+
+  ```js
+    var a = ['a', 'b', 'c'];
+    a.forEach(console.log); // Affichera la valeur de chaque élément dans la console
+    ```
+
+- {{jsxref("Array.map", "map(callback[, objetThis])")}} renvoie un nouveau tableau dont les éléments sont les images des éléments du tableau courant par la fonction `callback` :
+
+  ```js
+    var a1 = ['a', 'b', 'c'];
+    var a2 = a1.map(function(item) { return item.toUpperCase(); });
+    console.log(a2); // affichera A,B,C dans la console
+    ```
+
+- {{jsxref("Array.filter", "filter(callback[, objetThis])")}} renvoie un nouveau tableau qui contient les éléments du tableau courant pour lesquels `callback` a renvoyé `true`.
+
+  ```js
+    var a1 = ['a', 10, 'b', 20, 'c', 30];
+    var a2 = a1.filter(function(item) { return typeof item == 'number'; });
+    console.log(a2); // Affichera 10,20,30 dans la console
+    ```
+
+- {{jsxref("Array.every", "every(callback[, objetThis])")}} renvoie `true` si `callback` renvoie `true` pour chaque élément du tableau.
+
+  ```js
+    function isNumber(value){
+      return typeof value === 'number';
+    }
+    var a1 = [1, 2, 3];
+    console.log(a1.every(isNumber)); // affiche true
+    var a2 = [1, '2', 3];
+    console.log(a2.every(isNumber)); // affiche false
+    ```
+
+- {{jsxref("Array.some", "some(callback[, objetThis])")}} renvoie `true` si `callback` renvoie `true` pour au moins un élément du tableau.
+
+  ```js
+    function isNumber(value){
+      return typeof value === 'number';
+    }
+    var a1 = [1, 2, 3];
+    console.log(a1.some(isNumber)); // Affiche true
+    var a2 = [1, '2', 3];
+    console.log(a2.some(isNumber)); // Affiche true
+    var a3 = ['1', '2', '3'];
+    console.log(a3.some(isNumber)); // Affiche false
+    ```
+
+Les méthodes présentées ci-avant qui prennent une fonction de rappel (_callback_) en argument sont appelées méthodes itératives car elles parcourent le tableau de façon itérative. Chacune de ces méthodes peut prendre en compte un deuxième argument (optionnel) qui sera l'objet `this` pris en compte par le _callback_. Si ce deuxième argument n'est pas fourni, `this` vaudra la valeur de l'objet global.
+
+La fonction de rappel est appelée avec trois arguments : le premier étant la valeur de l'élément courant, le deuxième est l'indice de cet élément et le troisième représente le tableau lui-même. Les fonctions JavaScript ignorent les arguments supplémentaires qui ne sont pas déclarés explicitement dans la liste des paramètres, on peut donc utiliser une fonction prenant un seul argument comme fonction de rappel.
+
+- {{jsxref("Array.reduce", "reduce(callback[, valeurInitiale])")}} applique `callback(premièreValeur, secondeValeur)` au fur et à mesure sur le tableau pour le réduire en une seule valeur, c'est cette valeur qui est renvoyée par la fonction :
+
+  ```js
+    var a = [10, 20, 30];
+    var total = a.reduce(function(premier, deuxième) { return premier + deuxième; }, 0);
+    console.log(total) // Affiche 60
+    ```
+
+- {{jsxref("Array.reduceRight", "reduceRight(callback[, valeurInitiale])")}} fonctionne comme `reduce()`, mais débute avec le dernier élément (parcourt le tableau de droite à gauche).
+
+`reduce()` et `reduceRight()` sont à utiliser lorsqu'on souhaite n'obtenir qu'une seule valeur, récursivement, à partir des différents éléments du tableau. Pour plus d'informations sur l'utilisation d'une valeur d'initialisation pour ces deux fonctions, se référer à leurs pages : {{jsxref("Array.reduceRight")}} et {{jsxref("Array.reduce")}}
+
+### Tableaux multi-dimensionnels
+
+Les tableaux peuvent être imbriqués les uns dans les autres. Cela signifie qu'un tableau peut avoir un élément dont la valeur est un tableau. En utilisant ce comportement, on peut donc créer des matrices, voire des tableaux à plusieurs dimensions.
+
+Par exemple, avec le code suivant :
+
+```js
+var a = new Array(4);
+for (i = 0; i < 4; i++) {
   a[i] = new Array(4);
-  for (j = 0; j &lt; 4; j++) {
+  for (j = 0; j < 4; j++) {
     a[i][j] = "[" + i + "," + j + "]";
   }
 }
-</pre>
+```
 
-<p>On pourra avoir le tableau suivant sur deux dimensions :</p>
+On pourra avoir le tableau suivant sur deux dimensions :
 
-<pre class="brush: js notranslate">Ligne 0 : [0,0] [0,1] [0,2] [0,3]
+```js
+Ligne 0 : [0,0] [0,1] [0,2] [0,3]
 Ligne 1 : [1,0] [1,1] [1,2] [1,3]
 Ligne 2 : [2,0] [2,1] [2,2] [2,3]
 Ligne 3 : [3,0] [3,1] [3,2] [3,3]
-</pre>
+```
 
-<h3 id="Les_tableaux_et_les_expressions_rationnelles">Les tableaux et les expressions rationnelles</h3>
+### Les tableaux et les expressions rationnelles
 
-<p>Lorsqu'un tableau est le résultat d'une correspondance entre une expression rationnelle et une chaîne de caractères, les éléments et propriétés du tableau fournissent des informations sur la correspondance. Les méthodes suivantes peuvent renvoyer un tableau : {{jsxref("Objets_globaux/RegExp/exec","RegExp.exec()")}}, {{jsxref("Objets_globaux/String/match/exec","String.match()")}},  {{jsxref("Objets_globaux/String/split","String.split()")}}. Pour plus d'informations sur les tableaux et les expressions rationnelles, voir le chapitre du guide JavaScript sur <a href="/fr/docs/Web/JavaScript/Guide/Expressions_régulières">les expressions rationnelles</a>.</p>
+Lorsqu'un tableau est le résultat d'une correspondance entre une expression rationnelle et une chaîne de caractères, les éléments et propriétés du tableau fournissent des informations sur la correspondance. Les méthodes suivantes peuvent renvoyer un tableau : {{jsxref("Objets_globaux/RegExp/exec","RegExp.exec()")}}, {{jsxref("Objets_globaux/String/match/exec","String.match()")}},  {{jsxref("Objets_globaux/String/split","String.split()")}}. Pour plus d'informations sur les tableaux et les expressions rationnelles, voir le chapitre du guide JavaScript sur [les expressions rationnelles](/fr/docs/Web/JavaScript/Guide/Expressions_régulières).
 
-<h3 id="Manipuler_des_objets_semblables_à_des_tableaux">Manipuler des objets semblables à des tableaux</h3>
+### Manipuler des objets semblables à des tableaux
 
-<p>Certains objets JavaScript tels que {{domxref("NodeList")}} (renvoyé par {{domxref("document.getElementsByTagName()")}}) ou l'objet <a href="/fr/docs/Web/JavaScript/Reference/Fonctions/arguments"><code>arguments</code></a> (disponible au sein d'une fonction) ressemblent à des tableaux mais n'en sont pas (ils n'ont pas toutes les méthodes décrites ci-avant par exemple). Ainsi, l'objet <code>arguments</code> fournit une propriété {{jsxref("Objets_globaux/Function/length","length")}} mais n'implémente pas la méthode {{jsxref("Array.forEach", "forEach()")}}.</p>
+Certains objets JavaScript tels que {{domxref("NodeList")}} (renvoyé par {{domxref("document.getElementsByTagName()")}}) ou l'objet [`arguments`](/fr/docs/Web/JavaScript/Reference/Fonctions/arguments) (disponible au sein d'une fonction) ressemblent à des tableaux mais n'en sont pas (ils n'ont pas toutes les méthodes décrites ci-avant par exemple). Ainsi, l'objet `arguments` fournit une propriété {{jsxref("Objets_globaux/Function/length","length")}} mais n'implémente pas la méthode {{jsxref("Array.forEach", "forEach()")}}.
 
-<p>Les méthodes du prototype des tableaux permettent d'utiliser les méthodes d'objets <code>Array</code> sur des objets semblables à des tableaux :</p>
+Les méthodes du prototype des tableaux permettent d'utiliser les méthodes d'objets `Array` sur des objets semblables à des tableaux :
 
-<pre class="brush: js notranslate"> function alertArguments() {
+```js
+ function alertArguments() {
    Array.prototype.forEach.call(arguments, function(item) {
      console.log(item);
    });
  }
-</pre>
+```
 
-<p>Il est possible d'utiliser ces méthodes génériques sur des chaînes de caractères :</p>
+Il est possible d'utiliser ces méthodes génériques sur des chaînes de caractères :
 
-<pre class="brush: js notranslate">Array.prototype.forEach.call("une chaîne", function(chr) {
+```js
+Array.prototype.forEach.call("une chaîne", function(chr) {
    console.log(chr);
-});</pre>
+});
+```
 
-<h2 id="Les_tableaux_typés">Les tableaux typés</h2>
+## Les tableaux typés
 
-<p><a href="/fr/docs/Web/JavaScript/Tableaux_typés">Les tableaux typés JavaScript</a> sont des objets semblables à des tableaux qui fournissent un moyen d'accéder à des données binaires. Comme on l'a vu ci-avant, les objets {{jsxref("Array")}} grandissent et rétrécissent dynamiquement et peuvent contenir n'importe quelle valeur JavaScript. Les moteurs JavaScript effectuent des optimisations afin que les tableaux puissent être utilisés rapidement. Cependant, avec le développement des applications web, les applications viennent à manipuler des données audio, vidéo, binaires et accèdent à des données brutes via les <a href="/fr/docs/WebSockets">WebSockets</a> d'autres outils. Il apparaît donc nécessaire d'avoir les outils JavaScript pertinents pour manipuler efficacement des données binaires, organisées au sein de tableaux typés.</p>
+[Les tableaux typés JavaScript](/fr/docs/Web/JavaScript/Tableaux_typés) sont des objets semblables à des tableaux qui fournissent un moyen d'accéder à des données binaires. Comme on l'a vu ci-avant, les objets {{jsxref("Array")}} grandissent et rétrécissent dynamiquement et peuvent contenir n'importe quelle valeur JavaScript. Les moteurs JavaScript effectuent des optimisations afin que les tableaux puissent être utilisés rapidement. Cependant, avec le développement des applications web, les applications viennent à manipuler des données audio, vidéo, binaires et accèdent à des données brutes via les [WebSockets](/fr/docs/WebSockets) d'autres outils. Il apparaît donc nécessaire d'avoir les outils JavaScript pertinents pour manipuler efficacement des données binaires, organisées au sein de tableaux typés.
 
-<h3 id="Les_vues_et_les_tampons_de_mémoire_buffers_larchitecture_des_tableaux_typés">Les vues et les tampons de mémoire (<em>buffers</em>) : l'architecture des tableaux typés</h3>
+### Les vues et les tampons de mémoire (_buffers_) : l'architecture des tableaux typés
 
-<p>Afin de permettre un maximum de flexibilité et d'efficacité, les tableaux typés JavaScript séparent l'implémentation entre <strong>les tampons (<em>buffers</em>)</strong> et <strong>les vues (<em>views</em>)</strong>. Un tampon de mémoire, implémenté par l'objet {{jsxref("ArrayBuffer")}}, est un objet représentant un fragment de données. Un tampon n'a pas de format a proprement parler et il ne fournit aucun mécanisme pour accéder à son contenu. Afin d'accéder à la mémoire contenu dans le tampon, on a besoin d'utiliser une vue. Une vue fournit un contexte, c'est-à-dire un type de donnée, un indice de départ et un nombre d'éléments, qui permet de traiter les données initiales comme un vrai tableau typé.</p>
+Afin de permettre un maximum de flexibilité et d'efficacité, les tableaux typés JavaScript séparent l'implémentation entre **les tampons (_buffers_)** et **les vues (_views_)**. Un tampon de mémoire, implémenté par l'objet {{jsxref("ArrayBuffer")}}, est un objet représentant un fragment de données. Un tampon n'a pas de format a proprement parler et il ne fournit aucun mécanisme pour accéder à son contenu. Afin d'accéder à la mémoire contenu dans le tampon, on a besoin d'utiliser une vue. Une vue fournit un contexte, c'est-à-dire un type de donnée, un indice de départ et un nombre d'éléments, qui permet de traiter les données initiales comme un vrai tableau typé.
 
-<p><img alt="Typed arrays in an ArrayBuffer" src="https://mdn.mozillademos.org/files/8629/typed_arrays.png"></p>
+![Typed arrays in an ArrayBuffer](https://mdn.mozillademos.org/files/8629/typed_arrays.png)
 
-<h3 id="ArrayBuffer"><code>ArrayBuffer</code></h3>
+### `ArrayBuffer`
 
-<p>Le type {{jsxref("ArrayBuffer")}} est un type de donnée utilisé pour représenter un tampon de données binaire générique dont la longueur est fixée. Un tampon de données ne peut pas être manipulé directement. Pour manipuler les données, il faut créer une vue sur le tableau typé ou un objet {{jsxref("DataView")}} qui représente le tampon dans un format spécifique et qui pourra être utilisé pour lire et écrire des informations du tampon.</p>
+Le type {{jsxref("ArrayBuffer")}} est un type de donnée utilisé pour représenter un tampon de données binaire générique dont la longueur est fixée. Un tampon de données ne peut pas être manipulé directement. Pour manipuler les données, il faut créer une vue sur le tableau typé ou un objet {{jsxref("DataView")}} qui représente le tampon dans un format spécifique et qui pourra être utilisé pour lire et écrire des informations du tampon.
 
-<h3 id="Les_vues_qui_sont_des_tableaux_typés">Les vues qui sont des tableaux typés</h3>
+### Les vues qui sont des tableaux typés
 
-<p>Les vues de tableaux typés possèdent des noms explicites et fournissent des vues pour les types numériques usuels tels que <code>Int8</code>, <code>Uint32</code>, <code>Float64</code> et ainsi de suite. Il existe un type de vue spécial qui est <code>Uint8ClampedArray</code>. Ce type ramène les différentes valeurs exploitées entre 0 et 255. Cela peut notamment être utile pour <a href="/fr/docs/Web/API/ImageData">le traitement des données d'un canvas</a>.</p>
+Les vues de tableaux typés possèdent des noms explicites et fournissent des vues pour les types numériques usuels tels que `Int8`, `Uint32`, `Float64` et ainsi de suite. Il existe un type de vue spécial qui est `Uint8ClampedArray`. Ce type ramène les différentes valeurs exploitées entre 0 et 255. Cela peut notamment être utile pour [le traitement des données d'un canvas](/fr/docs/Web/API/ImageData).
 
-<p>{{page("/fr/docs/Web/JavaScript/Reference/Objets_globaux/TypedArray", "Les_objets_TypedArray")}}</p>
+{{page("/fr/docs/Web/JavaScript/Reference/Objets_globaux/TypedArray", "Les_objets_TypedArray")}}
 
-<p>Pour plus d'informations sur les tableaux typés, voir <a href="/fr/docs/Web/JavaScript/Tableaux_typés">l'article de la référence</a> sur les différents objets {{jsxref("TypedArray")}}.</p>
+Pour plus d'informations sur les tableaux typés, voir [l'article de la référence](/fr/docs/Web/JavaScript/Tableaux_typés) sur les différents objets {{jsxref("TypedArray")}}.
 
-<p>{{PreviousNext("Web/JavaScript/Guide/Expressions_régulières", "Web/JavaScript/Guide/Collections_avec_clés")}}</p>
+{{PreviousNext("Web/JavaScript/Guide/Expressions_régulières", "Web/JavaScript/Guide/Collections_avec_clés")}}
diff --git a/files/fr/web/javascript/guide/introduction/index.md b/files/fr/web/javascript/guide/introduction/index.md
index 7d99c7a165..cc8794cc3e 100644
--- a/files/fr/web/javascript/guide/introduction/index.md
+++ b/files/fr/web/javascript/guide/introduction/index.md
@@ -8,131 +8,111 @@ tags:
   - JavaScript
 translation_of: Web/JavaScript/Guide/Introduction
 ---
-<div>{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide", "Web/JavaScript/Guide/Types_et_grammaire")}}</div>
+{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide", "Web/JavaScript/Guide/Types_et_grammaire")}}
 
-<p>Ce chapitre introduit JavaScript et présente certains de ses concepts fondamentaux.</p>
+Ce chapitre introduit JavaScript et présente certains de ses concepts fondamentaux.
 
-<h2 id="Ce_que_vous_devriez_déjà_savoir">Ce que vous devriez déjà savoir</h2>
+## Ce que vous devriez déjà savoir
 
-<p>Pour lire ce guide, il est conseillé d'avoir :</p>
+Pour lire ce guide, il est conseillé d'avoir :
 
-<ul>
- <li>Une compréhension générale du fonctionnement d'Internet et du <a href="https://developer.mozilla.org/fr/docs/Glossaire/World_Wide_Web">World Wide Web</a> .</li>
- <li>Une connaissance élémentaire du <em>HyperText Markup Language</em> ({{Glossary("HTML")}}).</li>
- <li>Une expérience préalable en programmation. Si vous débutez la programmation, vous pouvez utiliser l'un des tutoriels listés sur la page <a href="/fr/docs/Web/JavaScript">JavaScript</a>.</li>
-</ul>
+- Une compréhension générale du fonctionnement d'Internet et du [World Wide Web](https://developer.mozilla.org/fr/docs/Glossaire/World_Wide_Web) .
+- Une connaissance élémentaire du _HyperText Markup Language_ ({{Glossary("HTML")}}).
+- Une expérience préalable en programmation. Si vous débutez la programmation, vous pouvez utiliser l'un des tutoriels listés sur la page [JavaScript](/fr/docs/Web/JavaScript).
 
-<h2 id="Où_trouver_des_informations_concernant_JavaScript">Où trouver des informations concernant JavaScript</h2>
+## Où trouver des informations concernant JavaScript
 
-<p>La documentation MDN pour JavaScript comprend :</p>
+La documentation MDN pour JavaScript comprend :
 
-<ul>
- <li><a href="/fr/docs/Apprendre">Apprendre le Web</a> : cette section fournit des informations destinées aux débutants et présente les concepts de bases autour de la programmation et d'Internet.</li>
- <li><a href="/fr/docs/Web/JavaScript/Guide">Le guide JavaScript</a> (ce guide) fournit un aperçu du langage JavaScript et de ses objets.</li>
- <li><a href="/fr/docs/Web/JavaScript/Reference">La référence JavaScript</a> fournit une référence détaillée sur les fonctionnalités de JavaScript.</li>
-</ul>
+- [Apprendre le Web](/fr/docs/Apprendre) : cette section fournit des informations destinées aux débutants et présente les concepts de bases autour de la programmation et d'Internet.
+- [Le guide JavaScript](/fr/docs/Web/JavaScript/Guide) (ce guide) fournit un aperçu du langage JavaScript et de ses objets.
+- [La référence JavaScript](/fr/docs/Web/JavaScript/Reference) fournit une référence détaillée sur les fonctionnalités de JavaScript.
 
-<p>Si vous débutez en JavaScript, vous pouvez commencer par les articles de la section <a href="/fr/docs/Apprendre">Apprendre</a> et du <a href="/fr/docs/Web/JavaScript/Guide">Guide JavaScript</a>. Une fois que vous maîtrisez les briques de bases, vous pourrez utiliser <a href="/fr/docs/Web/JavaScript/Reference">la référence JavaScript</a> pour obtenir des informations détaillées sur chacun des objets natifs et des instructions.</p>
+Si vous débutez en JavaScript, vous pouvez commencer par les articles de la section [Apprendre](/fr/docs/Apprendre) et du [Guide JavaScript](/fr/docs/Web/JavaScript/Guide). Une fois que vous maîtrisez les briques de bases, vous pourrez utiliser [la référence JavaScript](/fr/docs/Web/JavaScript/Reference) pour obtenir des informations détaillées sur chacun des objets natifs et des instructions.
 
-<h2 id="Quest-ce_que_JavaScript">Qu'est-ce que JavaScript ?</h2>
+## Qu'est-ce que JavaScript ?
 
-<p>JavaScript est un langage de script, multi-plateforme et orienté objet. C'est un langage léger qui doit faire partie d'un environnement hôte (un navigateur web par exemple) pour qu'il puisse être utilisé sur les objets de cet environnement.</p>
+JavaScript est un langage de script, multi-plateforme et orienté objet. C'est un langage léger qui doit faire partie d'un environnement hôte (un navigateur web par exemple) pour qu'il puisse être utilisé sur les objets de cet environnement.
 
-<p>JavaScript contient une bibliothèque standard d'objets tels que <code>Array</code>, <code>Date</code>, et <code>Math</code>, ainsi qu'un ensemble d'éléments de langage tels que les opérateurs, les structures de contrôles et les instructions. Ces fonctionnalités centrales et natives de JavaScript peuvent être étendues de plusieurs façons en fournissant d'autres objets, par exemple :</p>
+JavaScript contient une bibliothèque standard d'objets tels que `Array`, `Date`, et `Math`, ainsi qu'un ensemble d'éléments de langage tels que les opérateurs, les structures de contrôles et les instructions. Ces fonctionnalités centrales et natives de JavaScript peuvent être étendues de plusieurs façons en fournissant d'autres objets, par exemple :
 
-<ul>
- <li><em>JavaScript côté client</em> étend ces éléments de base en fournissant des objets pour contrôler le navigateur et le <em>Document Object Model</em> (DOM). Par exemple, les extensions du langage côté client permettent de placer des éléments dans un formulaire HTML, de réagir aux événements déclenchés par l'utilisateur (les clics, la saisie d'un formulaire, les actions de navigation, etc.).</li>
- <li><em>JavaScript côte serveur</em> étend ces éléments de base avec des objets utiles pour le fonctionnement sur un serveur tels que la possibilité de communiquer avec une base de données, manipuler des fichiers, passer d'une application à une autre, etc.</li>
-</ul>
+- _JavaScript côté client_ étend ces éléments de base en fournissant des objets pour contrôler le navigateur et le _Document Object Model_ (DOM). Par exemple, les extensions du langage côté client permettent de placer des éléments dans un formulaire HTML, de réagir aux événements déclenchés par l'utilisateur (les clics, la saisie d'un formulaire, les actions de navigation, etc.).
+- _JavaScript côte serveur_ étend ces éléments de base avec des objets utiles pour le fonctionnement sur un serveur tels que la possibilité de communiquer avec une base de données, manipuler des fichiers, passer d'une application à une autre, etc.
 
-<h2 id="JavaScript_et_Java">JavaScript et Java</h2>
+## JavaScript et Java
 
-<p>JavaScript et Java se ressemblent sur certains aspects mais ils sont fondamentalement différents l'un de l'autre. Le langage JavaScript ressemble à Java mais n'est pas typé statiquement et le typage de JavaScript est faible (alors qu'il est fort en Java). La syntaxe des expressions JavaScript est très proche de celle du Java avec les conventions de nommage et les constructions conditionnelles par exemple : c'est une des raisons qui a fait que le langage LiveScript a été renommé en JavaScript.</p>
+JavaScript et Java se ressemblent sur certains aspects mais ils sont fondamentalement différents l'un de l'autre. Le langage JavaScript ressemble à Java mais n'est pas typé statiquement et le typage de JavaScript est faible (alors qu'il est fort en Java). La syntaxe des expressions JavaScript est très proche de celle du Java avec les conventions de nommage et les constructions conditionnelles par exemple : c'est une des raisons qui a fait que le langage LiveScript a été renommé en JavaScript.
 
-<p>À la différence de Java qui est un système compilé et dont les classes sont déclarées, JavaScript est traité lors de l'exécution et possède quelques types de données pour représenter les nombres, les booléens et les chaînes de caractères (entre autres). JavaScript utilise un modèle basé sur les prototypes pour représenter les liens entre les objets alors que Java utilise un modèle plus courant basé sur les classes. Les prototypes permettent d'avoir un héritage dynamique. Ainsi, les caractéristiques héritées par un objet peuvent varier dans le temps. JavaScript supporte également les fonctions qui sont des objets à part entière et qui peuvent être des propriétés d'autres objets.</p>
+À la différence de Java qui est un système compilé et dont les classes sont déclarées, JavaScript est traité lors de l'exécution et possède quelques types de données pour représenter les nombres, les booléens et les chaînes de caractères (entre autres). JavaScript utilise un modèle basé sur les prototypes pour représenter les liens entre les objets alors que Java utilise un modèle plus courant basé sur les classes. Les prototypes permettent d'avoir un héritage dynamique. Ainsi, les caractéristiques héritées par un objet peuvent varier dans le temps. JavaScript supporte également les fonctions qui sont des objets à part entière et qui peuvent être des propriétés d'autres objets.
 
-<p>JavaScript est un langage plutôt « libre » comparé au Java. Il n'est pas nécessaire de déclarer toutes les variables, classes et méthodes. Il n'est pas nécessaire de savoir si une méthode est publique, privée ou protégée et il n'y a pas d'interfaces à implémenter. Les variables, les paramètres et les valeurs de retour des fonctions ne sont pas explicitement typés.</p>
+JavaScript est un langage plutôt « libre » comparé au Java. Il n'est pas nécessaire de déclarer toutes les variables, classes et méthodes. Il n'est pas nécessaire de savoir si une méthode est publique, privée ou protégée et il n'y a pas d'interfaces à implémenter. Les variables, les paramètres et les valeurs de retour des fonctions ne sont pas explicitement typés.
 
-<p>Java est un langage de programmation utilisant les classes, conçus pour être exécuté rapidement et garantir la sûreté du typage. Cela signifie par exemple qu'il n'est pas possible de transformer un entier Java en un objet ou qu'on ne peut pas accéder à des caractéristiques privées en corrompant le bytecode Java. Le modèle de classes utilisé par Java signifie qu'un programme n'est constitué que de classes et de méthodes. Cet héritage à base de classes, associé au typage fort font qu'on obtient des structures et des hiérarchies d'objets fortement couplées. Pour ces raisons, Java peut apparaître comme un langage plus complexe que JavaScript.</p>
+Java est un langage de programmation utilisant les classes, conçus pour être exécuté rapidement et garantir la sûreté du typage. Cela signifie par exemple qu'il n'est pas possible de transformer un entier Java en un objet ou qu'on ne peut pas accéder à des caractéristiques privées en corrompant le bytecode Java. Le modèle de classes utilisé par Java signifie qu'un programme n'est constitué que de classes et de méthodes. Cet héritage à base de classes, associé au typage fort font qu'on obtient des structures et des hiérarchies d'objets fortement couplées. Pour ces raisons, Java peut apparaître comme un langage plus complexe que JavaScript.
 
-<p>À l'inverse, JavaScript est un descendant de langages plus légers, dynamiquement typés tels que HyperTalk et dBASE. Ces langages de scripts visent un public plus large avec une syntaxe plus simple, des fonctionnalités natives spécialisées et des prérequis minimaux pour pouvoir créer des objets.</p>
+À l'inverse, JavaScript est un descendant de langages plus légers, dynamiquement typés tels que HyperTalk et dBASE. Ces langages de scripts visent un public plus large avec une syntaxe plus simple, des fonctionnalités natives spécialisées et des prérequis minimaux pour pouvoir créer des objets.
 
-<table class="standard-table">
- <caption>Comparaison synthétique entre JavaScript et Java</caption>
- <thead>
-  <tr>
-   <th scope="col">JavaScript</th>
-   <th scope="col">Java</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td>Orienté objet. Aucune distinction entre les types et les objets. L'héritage est basé sur un mécanisme utilisant les prototypes et les propriétés et méthodes peuvent être ajoutées dynamiquement à n'importe quel objet.</td>
-   <td>Orienté objet, utilisant un modèle de classes. Les objets sont divisés entre les classes et les instances, l'héritage s'effectue via la hiérarchie des classes. Les classes et les instances ne peuvent pas recevoir de nouvelles propriétés ou méthodes dynamiquement.</td>
-  </tr>
-  <tr>
-   <td>Le type de données des variables n'est pas déclaré (typage dynamique).</td>
-   <td>Le type de données des variables doit être déclaré (typage statique).</td>
-  </tr>
- </tbody>
-</table>
+| JavaScript                                                                                                                                                                                                               | Java                                                                                                                                                                                                                                                                    |
+| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Orienté objet. Aucune distinction entre les types et les objets. L'héritage est basé sur un mécanisme utilisant les prototypes et les propriétés et méthodes peuvent être ajoutées dynamiquement à n'importe quel objet. | Orienté objet, utilisant un modèle de classes. Les objets sont divisés entre les classes et les instances, l'héritage s'effectue via la hiérarchie des classes. Les classes et les instances ne peuvent pas recevoir de nouvelles propriétés ou méthodes dynamiquement. |
+| Le type de données des variables n'est pas déclaré (typage dynamique).                                                                                                                                                   | Le type de données des variables doit être déclaré (typage statique).                                                                                                                                                                                                   |
 
-<p>Pour plus d'informations sur les différences entre JavaScript et Java, voir le chapitre sur <a href="/fr/docs/Web/JavaScript/Guide/Le_modèle_objet_JavaScript_en_détails">les détails du modèle objet JavaScript</a>.</p>
+Pour plus d'informations sur les différences entre JavaScript et Java, voir le chapitre sur [les détails du modèle objet JavaScript](/fr/docs/Web/JavaScript/Guide/Le_modèle_objet_JavaScript_en_détails).
 
-<h2 id="JavaScript_et_la_spécification_ECMAScript">JavaScript et la spécification ECMAScript</h2>
+## JavaScript et la spécification ECMAScript
 
-<p>JavaScript est standardisé par <a href="https://www.ecma-international.org/">Ecma International</a> — une association européenne de standardisation des systèmes d'information et de communication (ECMA étant historiquement un acronyme pour <em>European Computer Manufacturers Association</em>) qui délivre un langage de programmation standardisé, international appelé ECMAScript. Ce langage se comporte de la même façon pour toutes les applications qui supportent ce standard. Les entreprises peuvent utiliser ce langage standard afin de développer leur implémentation de JavaScript. Le standard ECMAScript est documenté avec la spécification ECMA-262. Voir la page <a href="/fr/docs/Web/JavaScript/Nouveautés_et_historique_de_JavaScript">Nouveautés de JavaScript</a> pour en savoir plus sur les différentes versions de JavaScript et les différentes éditions de la spécification ECMAScript.</p>
+JavaScript est standardisé par [Ecma International](https://www.ecma-international.org/) — une association européenne de standardisation des systèmes d'information et de communication (ECMA étant historiquement un acronyme pour _European Computer Manufacturers Association_) qui délivre un langage de programmation standardisé, international appelé ECMAScript. Ce langage se comporte de la même façon pour toutes les applications qui supportent ce standard. Les entreprises peuvent utiliser ce langage standard afin de développer leur implémentation de JavaScript. Le standard ECMAScript est documenté avec la spécification ECMA-262. Voir la page [Nouveautés de JavaScript](/fr/docs/Web/JavaScript/Nouveautés_et_historique_de_JavaScript) pour en savoir plus sur les différentes versions de JavaScript et les différentes éditions de la spécification ECMAScript.
 
-<p>Le standard ECMA-262 est également approuvé par l'<a href="https://www.iso.ch/">ISO</a> (<em>International Organization for Standardization</em>) sous ISO-16262. La spécification peut également être trouvée sur <a href="https://www.ecma-international.org/publications/standards/Ecma-262.htm">le site web d'Ecma International</a>. La spécification ECMAScript ne décrit pas le <em>Document Object Model</em> (DOM) qui est standardisé par le <a href="https://www.w3.org/">World Wide Web Consortium (W3C)</a> et <a href="https://whatwg.org">le WHATWG (Web Hypertext Application Technology Working Group)</a>. Le DOM définit la façon dont les documents HTML sont exposés aux scripts. Pour mieux comprendre les différentes technologies gravitant autour de JavaScript, voir l'article <a href="/fr/docs/Web/JavaScript/JavaScript_technologies_overview">Aperçu des technologies JavaScript</a>.</p>
+Le standard ECMA-262 est également approuvé par l'[ISO](https://www.iso.ch/) (_International Organization for Standardization_) sous ISO-16262. La spécification peut également être trouvée sur [le site web d'Ecma International](https://www.ecma-international.org/publications/standards/Ecma-262.htm). La spécification ECMAScript ne décrit pas le _Document Object Model_ (DOM) qui est standardisé par le [World Wide Web Consortium (W3C)](https://www.w3.org/) et [le WHATWG (Web Hypertext Application Technology Working Group)](https://whatwg.org). Le DOM définit la façon dont les documents HTML sont exposés aux scripts. Pour mieux comprendre les différentes technologies gravitant autour de JavaScript, voir l'article [Aperçu des technologies JavaScript](/fr/docs/Web/JavaScript/JavaScript_technologies_overview).
 
-<h3 id="Documentation_JavaScript_et_spécification_ECMAScript">Documentation JavaScript et spécification ECMAScript</h3>
+### Documentation JavaScript et spécification ECMAScript
 
-<p>La spécification ECMAScript est un ensemble de conditions à respecter pour implémenter ECMAScript : cela est utile lorsqu'on souhaite implémenter des fonctionnalités standard du langage au sein d'une implémentation ou d'un moteur ECMAScript (tel que SpiderMonkey pour Firefox, ou V8 pour Chrome).</p>
+La spécification ECMAScript est un ensemble de conditions à respecter pour implémenter ECMAScript : cela est utile lorsqu'on souhaite implémenter des fonctionnalités standard du langage au sein d'une implémentation ou d'un moteur ECMAScript (tel que SpiderMonkey pour Firefox, ou V8 pour Chrome).
 
-<p>La spécification ECMAScript n'a pas pour but d'aider les développeurs à écrire des scripts. La documentation JavaScript permet d'obtenir des informations pour écrire des scripts JavaScript.</p>
+La spécification ECMAScript n'a pas pour but d'aider les développeurs à écrire des scripts. La documentation JavaScript permet d'obtenir des informations pour écrire des scripts JavaScript.
 
-<p>La spécification ECMAScript utilise parfois une terminologie et une syntaxe qui peuvent sembler étranges aux yeux d'un développeur JavaScript. Bien que la description du langage diffère entre ECMAScript et la documentation JavaScript, le langage lui-même reste le même. JavaScript supporte l'ensemble des fonctionnalités mises en avant dans la spécification ECMAScript.</p>
+La spécification ECMAScript utilise parfois une terminologie et une syntaxe qui peuvent sembler étranges aux yeux d'un développeur JavaScript. Bien que la description du langage diffère entre ECMAScript et la documentation JavaScript, le langage lui-même reste le même. JavaScript supporte l'ensemble des fonctionnalités mises en avant dans la spécification ECMAScript.
 
-<p>La documentation JavaScript décrit les aspects du langage qui pourront être utilisés par les développeurs JavaScript.</p>
+La documentation JavaScript décrit les aspects du langage qui pourront être utilisés par les développeurs JavaScript.
 
-<h2 id="Démarrer_avec_JavaScript">Démarrer avec JavaScript</h2>
+## Démarrer avec JavaScript
 
-<p>Pour commencer à développer en JavaScript, c'est très simple : il suffit d'avoir un navigateur web récent. Ce guide inclut certaines fonctionnalités de JavaScript qui ne sont disponibles que dans les dernières versions de Firefox, il est donc recommandé d'utiliser une version de Firefox à jour pour essayer les exemples fournis.</p>
+Pour commencer à développer en JavaScript, c'est très simple : il suffit d'avoir un navigateur web récent. Ce guide inclut certaines fonctionnalités de JavaScript qui ne sont disponibles que dans les dernières versions de Firefox, il est donc recommandé d'utiliser une version de Firefox à jour pour essayer les exemples fournis.
 
-<p>L'outil Web Console intégré à Firefox est utile pour expérimenter avec JavaScript. Vous pouvez l'utiliser selon deux modes : le mode de saisie à une ligne et le mode de saisie multiligne.</p>
+L'outil Web Console intégré à Firefox est utile pour expérimenter avec JavaScript. Vous pouvez l'utiliser selon deux modes : le mode de saisie à une ligne et le mode de saisie multiligne.
 
-<h3 id="La_console_web">La console web</h3>
+### La console web
 
-<p>La <a href="/fr/docs/Outils/Web_Console">console web</a> affiche des informations sur la page actuellement chargée, elle dispose également d'une <a href="/fr/docs/Outils/Web_Console#L'interpr.C3.A9teur_de_lignes_de_commande">ligne de commande</a> qui peut être utilisée pour exécuter des expressions JavaScript dans la page actuelle.</p>
+La [console web](/fr/docs/Outils/Web_Console) affiche des informations sur la page actuellement chargée, elle dispose également d'une [ligne de commande](/fr/docs/Outils/Web_Console#L'interpr.C3.A9teur_de_lignes_de_commande) qui peut être utilisée pour exécuter des expressions JavaScript dans la page actuelle.
 
-<p>Pour ouvrir la console, dans le menu, sélectionner « Développement » puis « Console web » (en passant par la barre d'outils, ce sera « Outils » puis « Développement web » puis « Console web »). Avec le clavier, on pourra utiliser la combinaison de touche <kbd>Ctrl</kbd>+<kbd>Shift</kbd>+<kbd>K</kbd> sur Windows et Linux ou <kbd>Cmd</kbd>-<kbd>Option</kbd>-<kbd>K</kbd> sur Mac. Une fois lancée, la console apparaît en base de la fenêtre du navigateur. En bas de la zone occupée par la console, il y a une ligne de commande qui peut être utilisée pour saisir des instructions JavaScript, le résultat de ces instructions sera affiché dans le panneau au dessus :</p>
+Pour ouvrir la console, dans le menu, sélectionner « Développement » puis « Console web » (en passant par la barre d'outils, ce sera « Outils » puis « Développement web » puis « Console web »). Avec le clavier, on pourra utiliser la combinaison de touche <kbd>Ctrl</kbd>+<kbd>Shift</kbd>+<kbd>K</kbd> sur Windows et Linux ou <kbd>Cmd</kbd>-<kbd>Option</kbd>-<kbd>K</kbd> sur Mac. Une fois lancée, la console apparaît en base de la fenêtre du navigateur. En bas de la zone occupée par la console, il y a une ligne de commande qui peut être utilisée pour saisir des instructions JavaScript, le résultat de ces instructions sera affiché dans le panneau au dessus :
 
-<p><img alt="Console web" src="https://mdn.mozillademos.org/files/16569/2019-04-04_00-15-29.png"></p>
+![Console web](https://mdn.mozillademos.org/files/16569/2019-04-04_00-15-29.png)
 
+La console fonctionne exactement de la même manière que `eval` : la dernière expression saisie est retournée. Pour simplifier, on peut imaginer que chaque fois qu'une expression est saisie dans la console, elle est en fait entourée de `console.log` autour de `eval`, comme suit:
 
-<p>La console fonctionne exactement de la même manière que <code>eval</code> : la dernière expression saisie est retournée. Pour simplifier, on peut imaginer que chaque fois qu'une expression est saisie dans la console, elle est en fait entourée de <code>console.log</code> autour de <code>eval</code>, comme suit:</p>
-
-<pre class="brush: js">function saluer(votreNom) {
-  alert(&quot;Hello &quot; + votreNom)
+```js
+function saluer(votreNom) {
+  alert("Hello " + votreNom)
 }
 console.log(eval('3 + 5'))
-</pre>
+```
 
-<h3 id="EditeurMultiligne">Le mode éditeur multiligne</h3>
+### Le mode éditeur multiligne
 
-<p>La console est pratique quand il s'agit d'exécuter des instructions ligne par ligne. Cependant dès qu'on souhaite exécuter un script plus complexe de plusieurs lignes, la console devient vite limitée. Pour ça, on pourra utiliser <a href="/fr/docs/Tools/Web_Console/The_command_line_interpreter#le_mode_%C3%A9diteur_multiligne">le mode éditeur multiligne</a>.</p>
+La console est pratique quand il s'agit d'exécuter des instructions ligne par ligne. Cependant dès qu'on souhaite exécuter un script plus complexe de plusieurs lignes, la console devient vite limitée. Pour ça, on pourra utiliser [le mode éditeur multiligne](/fr/docs/Tools/Web_Console/The_command_line_interpreter#le_mode_%C3%A9diteur_multiligne).
 
-<h3 id="Coucou_monde_hello_world">Coucou monde (<em>hello world</em>)</h3>
+### Coucou monde (_hello world_)
 
-<p>Pour commencer à écrire du JavaScript, ouvrez votre console web en mode éditeur multiligne et écrivez votre premier « <em>Hello world</em> » en JavaScript.</p>
+Pour commencer à écrire du JavaScript, ouvrez votre console web en mode éditeur multiligne et écrivez votre premier « _Hello world_ » en JavaScript.
 
-<pre class="brush: js">function saluer(utilisateur) {
+```js
+function saluer(utilisateur) {
   return "Bonjour " + utilisateur;
 }
 
 saluer("Alice"); // "Bonjour Alice"
-</pre>
+```
 
-<p>Dans les pages qui suivent, ce guide introduira la syntaxe du langage JavaScript ainsi que ses fonctionnalités ; vous pourrez ainsi écrire des applications plus complexes.</p>
+Dans les pages qui suivent, ce guide introduira la syntaxe du langage JavaScript ainsi que ses fonctionnalités ; vous pourrez ainsi écrire des applications plus complexes.
 
-<p>{{PreviousNext("Web/JavaScript/Guide", "Web/JavaScript/Guide/Types_et_grammaire")}}</p>
+{{PreviousNext("Web/JavaScript/Guide", "Web/JavaScript/Guide/Types_et_grammaire")}}
diff --git a/files/fr/web/javascript/guide/iterators_and_generators/index.md b/files/fr/web/javascript/guide/iterators_and_generators/index.md
index 87d1a5c28a..19d2248042 100644
--- a/files/fr/web/javascript/guide/iterators_and_generators/index.md
+++ b/files/fr/web/javascript/guide/iterators_and_generators/index.md
@@ -8,37 +8,36 @@ tags:
 translation_of: Web/JavaScript/Guide/Iterators_and_Generators
 original_slug: Web/JavaScript/Guide/iterateurs_et_generateurs
 ---
-<div>{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/Utiliser_les_promesses", "Web/JavaScript/Guide/Métaprogrammation")}}</div>
+{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/Utiliser_les_promesses", "Web/JavaScript/Guide/Métaprogrammation")}}
 
-<p>Effectuer des traitements sur chacun des éléments d'une collection est une opération très fréquente. Il existe plusieurs outils natifs dans JavaScript pour parcourir une collection, les boucles <code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/for">for</a></code>, <code><a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Array/map">map()</a></code>, <code><a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Array/filter">filter()</a></code>. Les itérateurs et les générateurs font de ce concept d'itération une fonctionnalité principale du langage et permettent d'adapter et de personnaliser le comportement des boucles <code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/for...of">for...of</a></code>.</p>
+Effectuer des traitements sur chacun des éléments d'une collection est une opération très fréquente. Il existe plusieurs outils natifs dans JavaScript pour parcourir une collection, les boucles [`for`](/fr/docs/Web/JavaScript/Reference/Instructions/for), [`map()`](/fr/docs/Web/JavaScript/Reference/Objets_globaux/Array/map), [`filter()`](/fr/docs/Web/JavaScript/Reference/Objets_globaux/Array/filter). Les itérateurs et les générateurs font de ce concept d'itération une fonctionnalité principale du langage et permettent d'adapter et de personnaliser le comportement des boucles [`for...of`](/fr/docs/Web/JavaScript/Reference/Instructions/for...of).
 
-<p>Pour plus de détails sur les mécanismes d'itération, voir les pages suivantes :</p>
+Pour plus de détails sur les mécanismes d'itération, voir les pages suivantes :
 
-<ul>
- <li><a href="/fr/docs/Web/JavaScript/Reference/Les_protocoles_iteration">Les protocoles d'itération</a></li>
- <li>{{jsxref("Instructions/for...of","for...of")}}</li>
- <li>{{jsxref("Instructions/function*","function*")}} et {{jsxref("Generator")}}</li>
- <li>{{jsxref("Opérateurs/yield","yield")}} et {{jsxref("Opérateurs/yield*","yield*")}}</li>
-</ul>
+- [Les protocoles d'itération](/fr/docs/Web/JavaScript/Reference/Les_protocoles_iteration)
+- {{jsxref("Instructions/for...of","for...of")}}
+- {{jsxref("Instructions/function*","function*")}} et {{jsxref("Generator")}}
+- {{jsxref("Opérateurs/yield","yield")}} et {{jsxref("Opérateurs/yield*","yield*")}}
 
-<h2 id="Itérateurs">Itérateurs</h2>
+## Itérateurs
 
-<p>Un itérateur est un objet sachant comment accéder aux éléments d'une collection un par un et qui connait leur position dans la collection. En JavaScript, un itérateur expose une méthode <code>next()</code> qui retourne l'élément suivant dans la séquence. Cette méthode renvoie un objet possédant deux propriétés : <code>done</code> et <code>value</code>.</p>
+Un itérateur est un objet sachant comment accéder aux éléments d'une collection un par un et qui connait leur position dans la collection. En JavaScript, un itérateur expose une méthode `next()` qui retourne l'élément suivant dans la séquence. Cette méthode renvoie un objet possédant deux propriétés : `done` et `value`.
 
-<p>Un itérateur est "terminé" lorsque l'appel à la méthode <code>next()</code> renvoie un objet dont la propriété <code>done</code> vaut <code>true</code>.</p>
+Un itérateur est "terminé" lorsque l'appel à la méthode `next()` renvoie un objet dont la propriété `done` vaut `true`.
 
-<p>Une fois créé, un itérateur peut être utilisé explicitement en appelant sa méthode <code>next()</code>, ou implicitement en utilisant la boucle <code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/for...in">for...in</a></code>.</p>
+Une fois créé, un itérateur peut être utilisé explicitement en appelant sa méthode `next()`, ou implicitement en utilisant la boucle [`for...in`](/fr/docs/Web/JavaScript/Reference/Instructions/for...in).
 
-<p>Voici un exemple d'une fonction créant un itérateur qui parcourt l'intervalle défini par ses arguments (depuis <code>debut</code> (inclus) jusqu'à <code>end</code> (exclus) et avec <code>pas</code> comme incrément. La valeur finale qui est renvoyée correspond à la taille de la séquence créée</p>
+Voici un exemple d'une fonction créant un itérateur qui parcourt l'intervalle défini par ses arguments (depuis `debut` (inclus) jusqu'à `end` (exclus) et avec `pas` comme incrément. La valeur finale qui est renvoyée correspond à la taille de la séquence créée
 
-<pre class="brush: js">function creerIterateurIntervalle(debut = 0, fin = Infinity, pas = 1) {
+```js
+function creerIterateurIntervalle(debut = 0, fin = Infinity, pas = 1) {
   let prochainIndex = debut;
   let nbIterations = 0;
 
   const rangeIterator = {
     next: function() {
       let resultat;
-      if (prochainIndex &lt; fin) {
+      if (prochainIndex < fin) {
         resultat = { value: prochainIndex, done: false };
         prochainIndex += pas;
         nbIterations++;
@@ -48,11 +47,13 @@ original_slug: Web/JavaScript/Guide/iterateurs_et_generateurs
     }
   };
   return rangeIterator;
-}</pre>
+}
+```
 
-<p>On pourra alors utiliser cette fonction et l'itérateur de la façon suivante :</p>
+On pourra alors utiliser cette fonction et l'itérateur de la façon suivante :
 
-<pre class="brush: js">let it = creerIterateurIntervalle(1, 10, 2);
+```js
+let it = creerIterateurIntervalle(1, 10, 2);
 
 let resultat = it.next();
 while (!resultat.done) {
@@ -61,36 +62,38 @@ while (!resultat.done) {
 }
 
 console.log("La séquence parcourue contenait ", result.value, " éléments.");
-</pre>
+```
 
-<h2 id="Itérables">Itérables</h2>
+## Itérables
 
-<p>Un objet est considéré comme <strong>itérable</strong> s'il définit le comportement qu'il aura lors de l'itération (par exemple les valeurs qui seront utilisées dans une boucle {{jsxref("Instructions/for...of", "for...of")}}). Certains types natifs, tels qu'{{jsxref("Array")}} ou {{jsxref("Map")}}, possède un comportement par défaut pour les itérations, cependant d'autres types comme les Objets, ne possèdent pas ce comportement.</p>
+Un objet est considéré comme **itérable** s'il définit le comportement qu'il aura lors de l'itération (par exemple les valeurs qui seront utilisées dans une boucle {{jsxref("Instructions/for...of", "for...of")}}). Certains types natifs, tels qu'{{jsxref("Array")}} ou {{jsxref("Map")}}, possède un comportement par défaut pour les itérations, cependant d'autres types comme les Objets, ne possèdent pas ce comportement.
 
-<p>Pour qu'un objet soit <strong>itérable</strong>, un objet doit implémenter la méthode <strong>@@iterator</strong>, cela signifie que l'objet (ou un des objets de la <a href="/fr/docs/Web/JavaScript/Héritage_et_chaîne_de_prototypes">chaîne de prototypes</a>) doit avoir une propriété avec la clé {{jsxref("Symbol.iterator")}}. Cette fonction doit également, même si ce n'est pas une obligation, renvoyer une nouvel opérateur à chaque appel.</p>
+Pour qu'un objet soit **itérable**, un objet doit implémenter la méthode **@@iterator**, cela signifie que l'objet (ou un des objets de la [chaîne de prototypes](/fr/docs/Web/JavaScript/Héritage_et_chaîne_de_prototypes)) doit avoir une propriété avec la clé {{jsxref("Symbol.iterator")}}. Cette fonction doit également, même si ce n'est pas une obligation, renvoyer une nouvel opérateur à chaque appel.
 
-<h3 id="Itérables_personnalisés">Itérables personnalisés</h3>
+### Itérables personnalisés
 
-<p>Il est possible de définir ses propres itérables de cette façon :</p>
+Il est possible de définir ses propres itérables de cette façon :
 
-<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="Itérables_natifs">Itérables natifs</h3>
+### Itérables natifs
 
-<p>{{jsxref("String")}}, {{jsxref("Array")}}, {{jsxref("TypedArray")}}, {{jsxref("Map")}} et {{jsxref("Set")}} sont des itérables natifs car les prototypes de chacun ont tous une méthode {{jsxref("Symbol.iterator")}}.</p>
+{{jsxref("String")}}, {{jsxref("Array")}}, {{jsxref("TypedArray")}}, {{jsxref("Map")}} et {{jsxref("Set")}} sont des itérables natifs car les prototypes de chacun ont tous une méthode {{jsxref("Symbol.iterator")}}.
 
-<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>Certaines instructions ou expressions utilisent des itérables, par exemple les boucles {{jsxref("Instructions/for...of","for...of")}} et {{jsxref("Opérateurs/yield*","yield*")}}.</p>
+Certaines instructions ou expressions utilisent des itérables, par exemple les boucles {{jsxref("Instructions/for...of","for...of")}} et {{jsxref("Opérateurs/yield*","yield*")}}.
 
-<pre class="brush: js">for(let value of ["a", "b", "c"]){
+```js
+for(let value of ["a", "b", "c"]){
     console.log(value)
 }
 // "a"
@@ -107,16 +110,16 @@ gen().next() // { value:"a", done:false }
 
 [a, b, c] = new Set(["a", "b", "c"])
 a // "a"
+```
 
-</pre>
-
-<h2 id="Générateurs">Générateurs</h2>
+## Générateurs
 
-<p>Les itérateurs personnalisés sont un outil utile mais leur création peut s'avérer complexe et il faut maintenir leur état interne. Avec les générateurs, on peut définir une seule fonction qui est un algorithme itératif et qui peut maintenir son état.</p>
+Les itérateurs personnalisés sont un outil utile mais leur création peut s'avérer complexe et il faut maintenir leur état interne. Avec les générateurs, on peut définir une seule fonction qui est un algorithme itératif et qui peut maintenir son état.
 
-<p>Un générateur est un type de fonction spécial qui fonctionne comme une fabrique (<em>factory</em>) d'itérateurs. Une fonction devient un générateur lorsqu'elle contient une ou plusieurs expressions <code>yield</code> et qu'elle utilise la syntaxe <code>function*</code>.</p>
+Un générateur est un type de fonction spécial qui fonctionne comme une fabrique (_factory_) d'itérateurs. Une fonction devient un générateur lorsqu'elle contient une ou plusieurs expressions `yield` et qu'elle utilise la syntaxe `function*`.
 
-<pre class="brush: js">function* idMaker(){
+```js
+function* idMaker(){
   var index = 0;
   while(true)
     yield index++;
@@ -127,17 +130,19 @@ var gen = idMaker();
 console.log(gen.next().value); // 0
 console.log(gen.next().value); // 1
 console.log(gen.next().value); // 2
-// ...</pre>
+// ...
+```
 
-<h2 id="Générateurs_avancés">Générateurs avancés</h2>
+## Générateurs avancés
 
-<p>Les générateurs calculent les valeurs à fournir à la demande, ce qui leur permet de représenter efficacement des suites complexes à calculer, voire des séries infinies (comme vu dans l'exemple précédent).</p>
+Les générateurs calculent les valeurs à fournir à la demande, ce qui leur permet de représenter efficacement des suites complexes à calculer, voire des séries infinies (comme vu dans l'exemple précédent).
 
-<p>La méthode <code>next()</code> accepte également un argument qui pourra être utilisé pour modifier l'état interne du générateur. Une valeur passée à <code>next()</code> sera traitée comme le résultat de la dernière expression <code>yield</code> qui a interrompu le générateur. Une valeur passée au premier appel de <code>next()</code> sera toujours ignorée.</p>
+La méthode `next()` accepte également un argument qui pourra être utilisé pour modifier l'état interne du générateur. Une valeur passée à `next()` sera traitée comme le résultat de la dernière expression `yield` qui a interrompu le générateur. Une valeur passée au premier appel de `next()` sera toujours ignorée.
 
-<p>Par exemple, on peut avoir un générateur pour la suite de Fibonnaci et utiliser <code>next(x)</code> pour redémarrer la série :</p>
+Par exemple, on peut avoir un générateur pour la suite de Fibonnaci et utiliser `next(x)` pour redémarrer la série :
 
-<pre class="brush: js">function* fibonacci(){
+```js
+function* fibonacci(){
   var fn1 = 0;
   var fn2 = 1;
   while (true){
@@ -163,14 +168,15 @@ console.log(sequence.next().value);     // 8
 console.log(sequence.next(true).value); // 0
 console.log(sequence.next().value);     // 1
 console.log(sequence.next().value);     // 1
-console.log(sequence.next().value);     // 2</pre>
+console.log(sequence.next().value);     // 2
+```
 
-<p>Il est possible de forcer un générateur à lever une exception en utilisant la méthode <code>throw()</code> en lui passant la valeur de l'exception en argument. Cette exception sera levée depuis l'état actuel du générateur, comme si le <code>yield</code> qui était en attente avait été une instruction <code>throw <em>valeur</em></code>.</p>
+Il est possible de forcer un générateur à lever une exception en utilisant la méthode `throw()` en lui passant la valeur de l'exception en argument. Cette exception sera levée depuis l'état actuel du générateur, comme si le `yield` qui était en attente avait été une instruction `throw valeur`.
 
-<p>Si le mot-clé <code>yield</code> n'est pas trouvé lors de la levée de l'exception, l'exception sera propagée jusqu'à l'appel de <code>throw()</code>, les appels à <code>next()</code> qui suivent renverront une valeur dont la propriété <code>done</code> sera <code>true</code>.</p>
+Si le mot-clé `yield` n'est pas trouvé lors de la levée de l'exception, l'exception sera propagée jusqu'à l'appel de `throw()`, les appels à `next()` qui suivent renverront une valeur dont la propriété `done` sera `true`.
 
-<p>Si l'exception n'est pas interceptée dans le générateur, elle se propagera jusqu'à l'appel de <code>throw()</code> et les appels suivants de <code>next()</code> renverront un objet dont la propriété <code>done </code>vaut <code>true</code>.</p>
+Si l'exception n'est pas interceptée dans le générateur, elle se propagera jusqu'à l'appel de `throw()` et les appels suivants de `next()` renverront un objet dont la propriété `done `vaut `true`.
 
-<p>Les générateurs possèdent une méthode <code>return(valeur)</code> qui permet de renvoyer une valeur donnée et de terminer le générateur.</p>
+Les générateurs possèdent une méthode `return(valeur)` qui permet de renvoyer une valeur donnée et de terminer le générateur.
 
-<p>{{PreviousNext("Web/JavaScript/Guide/Utiliser_les_promesses", "Web/JavaScript/Guide/Métaprogrammation")}}</p>
+{{PreviousNext("Web/JavaScript/Guide/Utiliser_les_promesses", "Web/JavaScript/Guide/Métaprogrammation")}}
diff --git a/files/fr/web/javascript/guide/keyed_collections/index.md b/files/fr/web/javascript/guide/keyed_collections/index.md
index 9b93b1cc67..bef70f4b38 100644
--- a/files/fr/web/javascript/guide/keyed_collections/index.md
+++ b/files/fr/web/javascript/guide/keyed_collections/index.md
@@ -10,19 +10,20 @@ tags:
 translation_of: Web/JavaScript/Guide/Keyed_collections
 original_slug: Web/JavaScript/Guide/Collections_avec_clés
 ---
-<div>{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/Collections_indexées", "Web/JavaScript/Guide/Utiliser_les_objets")}}</div>
+{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/Collections_indexées", "Web/JavaScript/Guide/Utiliser_les_objets")}}
 
-<p>Ce chapitre présente les collections de données qui sont ordonnées avec une clé. Les objets <code>Map</code> et <code>Set</code> contiennent des éléments sur lesquels on peut itérer dans leur ordre d'insertion.</p>
+Ce chapitre présente les collections de données qui sont ordonnées avec une clé. Les objets `Map` et `Set` contiennent des éléments sur lesquels on peut itérer dans leur ordre d'insertion.
 
-<h2 id="Maps">Maps</h2>
+## Maps
 
-<h3 id="Le_type_Map">Le type <code>Map</code></h3>
+### Le type `Map`
 
-<p>ECMAScript 2015 introduit une nouvelle structure de données pour faire correspondre des données entre elle. Un objet {{jsxref("Map")}} représente une collection de données qui sont des correspondances entre des clés ou valeurs et pour lequel on peut itérer dans l'ordre d'insertion pour lister les différentes clés / valeurs.</p>
+ECMAScript 2015 introduit une nouvelle structure de données pour faire correspondre des données entre elle. Un objet {{jsxref("Map")}} représente une collection de données qui sont des correspondances entre des clés ou valeurs et pour lequel on peut itérer dans l'ordre d'insertion pour lister les différentes clés / valeurs.
 
-<p>Le code suivant illustre certaines opérations basiques avec <code>Map</code>. Pour plus d'informations sur cet objet, voir également la page de référence {{jsxref("Map")}}. Il est possible d'utiliser une boucle {{jsxref("Instructions/for...of","for...of")}} pour renvoyer un tableau <code>[clé, valeur]</code> à chaque itération.</p>
+Le code suivant illustre certaines opérations basiques avec `Map`. Pour plus d'informations sur cet objet, voir également la page de référence {{jsxref("Map")}}. Il est possible d'utiliser une boucle {{jsxref("Instructions/for...of","for...of")}} pour renvoyer un tableau `[clé, valeur]` à chaque itération.
 
-<pre class="brush: js">var sayings = new Map();
+```js
+var sayings = new Map();
 sayings.set("dog", "woof");
 sayings.set("cat", "meow");
 sayings.set("elephant", "toot");
@@ -36,38 +37,35 @@ for (var [key, value] of sayings) {
 }
 // "cat goes meow"
 // "elephant goes toot"
-</pre>
+```
 
-<h3 id="Comparaison_entre_les_types_Object_et_Map">Comparaison entre les types <code>Object</code> et <code>Map</code></h3>
+### Comparaison entre les types `Object` et `Map`
 
-<p>Habituellement, les objets {{jsxref("Object", "objets", "", 1)}} ont été utilisés pour faire correspondre des chaînes avec des valeurs. Les objets permettent d'associer des clés avec des valeurs, de récupérer ces valeurs, de supprimer des clés, de détecter si quelque chose est enregistré dans une clé. Le type <code>Map</code> possède cependant certains avantages pour être utilisés comme <em>maps</em>.</p>
+Habituellement, les objets {{jsxref("Object", "objets", "", 1)}} ont été utilisés pour faire correspondre des chaînes avec des valeurs. Les objets permettent d'associer des clés avec des valeurs, de récupérer ces valeurs, de supprimer des clés, de détecter si quelque chose est enregistré dans une clé. Le type `Map` possède cependant certains avantages pour être utilisés comme _maps_.
 
-<ul>
- <li>Les clés d'un objet de type <code>Object</code> sont des chaînes de caractères. Pour <code>Map</code>, une clé peut être une valeur de n'importe quel type.</li>
- <li>On peut simplement obtenir la taille d'un objet <code>Map</code> alors qu'il faut tenir compte manuellement du nombre de clés contenue dans un objet <code>Object</code>.</li>
- <li>Les itérations sur les <em>maps</em> se font dans l'ordre d'insertion des éléments.</li>
- <li>Un objet de type <code>Object</code> possède un prototype, il y a donc des clés par défaut déjà présentes dans l'objet. (cela peut être surchargé en utilisant <code>map = Object.create(null)</code>).</li>
-</ul>
+- Les clés d'un objet de type `Object` sont des chaînes de caractères. Pour `Map`, une clé peut être une valeur de n'importe quel type.
+- On peut simplement obtenir la taille d'un objet `Map` alors qu'il faut tenir compte manuellement du nombre de clés contenue dans un objet `Object`.
+- Les itérations sur les _maps_ se font dans l'ordre d'insertion des éléments.
+- Un objet de type `Object` possède un prototype, il y a donc des clés par défaut déjà présentes dans l'objet. (cela peut être surchargé en utilisant `map = Object.create(null)`).
 
-<p>Pour savoir si on doit utiliser le type <code>Map</code> ou le type <code>Object</code>, on peut considérer les aspects suivants :</p>
+Pour savoir si on doit utiliser le type `Map` ou le type `Object`, on peut considérer les aspects suivants :
 
-<ul>
- <li>On utilisera des <em>maps</em> plutôt que des objets lorsque les clés sont inconnues avant l'exécution et lorsque toutes les clés sont de même type et que les valeurs sont de même type.</li>
- <li>On utilisera des <em>maps</em> lorsque les clés peuvent être des valeurs primitives autres que des chaînes de caractères (en effet, les objets considèrent toutes leurs clés comme des chaînes en convertissant les valeurs).</li>
- <li>On utilisera des objets lorsqu'il y a une logique propre à des éléments individuels.</li>
-</ul>
+- On utilisera des _maps_ plutôt que des objets lorsque les clés sont inconnues avant l'exécution et lorsque toutes les clés sont de même type et que les valeurs sont de même type.
+- On utilisera des _maps_ lorsque les clés peuvent être des valeurs primitives autres que des chaînes de caractères (en effet, les objets considèrent toutes leurs clés comme des chaînes en convertissant les valeurs).
+- On utilisera des objets lorsqu'il y a une logique propre à des éléments individuels.
 
-<h3 id="Le_type_WeakMap">Le type <code>WeakMap</code></h3>
+### Le type `WeakMap`
 
-<p>L'objet {{jsxref("WeakMap")}} est une collection de paires clés/valeurs pour lesquelles <strong>les clés sont uniquement des objets</strong> (les valeurs peuvent être d'un type arbitraire). Les références vers les objets sont des références « faibles ». Cela signifie qu'elles seront collectées par le ramasse-miettes s'il n'y a pas d'autres références vers cet objet. L'API <code>WeakMap</code> offre les mêmes fonctionnalités que l'API <code>Map</code>.</p>
+L'objet {{jsxref("WeakMap")}} est une collection de paires clés/valeurs pour lesquelles **les clés sont uniquement des objets** (les valeurs peuvent être d'un type arbitraire). Les références vers les objets sont des références « faibles ». Cela signifie qu'elles seront collectées par le ramasse-miettes s'il n'y a pas d'autres références vers cet objet. L'API `WeakMap` offre les mêmes fonctionnalités que l'API `Map`.
 
-<p>La différence entre le type <code>Map</code> et le type <code>WeakMap</code> est que les clés d'un objet <code>WeakMap</code> ne sont pas énumérables (c'est-à-dire qu'on n'a pas de méthode pour donner la liste des clés). S'il en existait une, la liste dépendrait de l'état d'avancement du ramasse-miettes, ce qui introduirait un non-déterminisme.</p>
+La différence entre le type `Map` et le type `WeakMap` est que les clés d'un objet `WeakMap` ne sont pas énumérables (c'est-à-dire qu'on n'a pas de méthode pour donner la liste des clés). S'il en existait une, la liste dépendrait de l'état d'avancement du ramasse-miettes, ce qui introduirait un non-déterminisme.
 
-<p>Pour plus d'informations et d'exemples, voir également le paragraphe « Pourquoi WeakMap ? » sur l'article {{jsxref("WeakMap")}} de la référence.</p>
+Pour plus d'informations et d'exemples, voir également le paragraphe « Pourquoi WeakMap ? » sur l'article {{jsxref("WeakMap")}} de la référence.
 
-<p>Un cas d'utilisation des objets <code>WeakMap</code> est le stockage de données privées d'un objet ou pour cacher certains détails d'implémentation. L'exemple qui suit est tiré du billet de blog de Nick Fitzgerald <a href="http://fitzgeraldnick.com/weblog/53/">« Masquer des détails d'implémentation avec les WeakMaps ECMAScript 6 »</a>. Les données et méthodes privées sont stockées dans l'objet WeakMap <code>privates</code>. Tout ce qui est exposé par l'instance et le prototype est public. Tout ce qui est en dehors est inaccessible car <code>privates</code> n'est pas exporté depuis le module :</p>
+Un cas d'utilisation des objets `WeakMap` est le stockage de données privées d'un objet ou pour cacher certains détails d'implémentation. L'exemple qui suit est tiré du billet de blog de Nick Fitzgerald [« Masquer des détails d'implémentation avec les WeakMaps ECMAScript 6 »](http://fitzgeraldnick.com/weblog/53/). Les données et méthodes privées sont stockées dans l'objet WeakMap `privates`. Tout ce qui est exposé par l'instance et le prototype est public. Tout ce qui est en dehors est inaccessible car `privates` n'est pas exporté depuis le module :
 
-<pre class="brush: js">const privates = new WeakMap();
+```js
+const privates = new WeakMap();
 
 function Public() {
   const me = {
@@ -82,17 +80,18 @@ Public.prototype.method = function () {
 };
 
 module.exports = Public;
-</pre>
+```
 
-<h2 id="Les_ensembles">Les ensembles</h2>
+## Les ensembles
 
-<h3 id="Le_type_Set">Le type <code>Set</code></h3>
+### Le type `Set`
 
-<p>Les objets {{jsxref("Set")}} sont des ensembles de valeurs. Il est possible de les parcourir dans l'ordre d'insertion des éléments. Une valeur d'un élément <code>Set</code> ne peut y apparaître qu'une seule fois, il est unique pour cette instance de <code>Set</code>.</p>
+Les objets {{jsxref("Set")}} sont des ensembles de valeurs. Il est possible de les parcourir dans l'ordre d'insertion des éléments. Une valeur d'un élément `Set` ne peut y apparaître qu'une seule fois, il est unique pour cette instance de `Set`.
 
-<p>Le code suivant illustre certaines opérations basiques avec <code>Set</code>. Voir aussi la page {{jsxref("Set")}} pour plus d'exemples et l'API complète.</p>
+Le code suivant illustre certaines opérations basiques avec `Set`. Voir aussi la page {{jsxref("Set")}} pour plus d'exemples et l'API complète.
 
-<pre class="brush: js">var monEnsemble = new Set();
+```js
+var monEnsemble = new Set();
 monEnsemble.add(1);
 monEnsemble.add("du texte");
 monEnsemble.add("toto");
@@ -104,50 +103,45 @@ monEnsemble.size; // 2
 for (let item of monEnsemble) console.log(item);
 // 1
 // "du texte"
-</pre>
+```
 
-<h3 id="Convertir_des_tableaux_(Array)_en_ensembles_(Set)">Convertir des tableaux (<code>Array</code>) en ensembles (<code>Set</code>)</h3>
+### Convertir des tableaux (`Array`) en ensembles (`Set`)
 
-<p>Il est possible de créer un {{jsxref("Array")}} à partir d'un <code>Set</code> grâce à {{jsxref("Array.from")}} ou l'<a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateur_de_décomposition">opérateur de décomposition</a>. Pour effectuer la conversion dans l'autre sens, on peut utiliser le constructeur <code>Set</code> avec un argument de type <code>Array</code>. Encore une fois, les objets <code>Set</code> stockent des valeurs uniques, les éléments dupliqués dans un tableau seront supprimés lors de la conversion.</p>
+Il est possible de créer un {{jsxref("Array")}} à partir d'un `Set` grâce à {{jsxref("Array.from")}} ou l'[opérateur de décomposition](/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateur_de_décomposition). Pour effectuer la conversion dans l'autre sens, on peut utiliser le constructeur `Set` avec un argument de type `Array`. Encore une fois, les objets `Set` stockent des valeurs uniques, les éléments dupliqués dans un tableau seront supprimés lors de la conversion.
 
-<pre class="brush: js">Array.from(monSet);
+```js
+Array.from(monSet);
 [...monSet2];
 
 monSet2 = new Set([1,2,3,4]);
-</pre>
+```
 
-<h3 id="Comparaison_entre_Array_et_Set">Comparaison entre <code>Array</code> et <code>Set</code></h3>
+### Comparaison entre `Array` et `Set`
 
-<p>Historiquement, on représentait des ensembles avec des tableaux JavaScript. Ce nouveau type, <code>Set</code>, possède certains avantages :</p>
+Historiquement, on représentait des ensembles avec des tableaux JavaScript. Ce nouveau type, `Set`, possède certains avantages :
 
-<ul>
- <li>Lorsqu'on souhaite vérifier si un élément existe déjà dans un tableau, on est obligé d'utiliser {{jsxref("Array.indexOf", "indexOf")}} ce qui peut diminuer les performances.</li>
- <li>Les objets <code>Set</code> permettent de supprimer les éléments avec leur valeur. Avec un tableau, il faudrait « découper » le tableau sur l'indice de l'élément.</li>
- <li>Dans un tableau, la valeur {{jsxref("NaN")}} ne peut pas être trouvée avec la méthode <code>indexOf</code>.</li>
- <li>Les objets <code>Set</code> permettent de stocker des valeurs uniques, il n'est pas nécessaire d'effectuer des vérifications manuellement.</li>
-</ul>
+- Lorsqu'on souhaite vérifier si un élément existe déjà dans un tableau, on est obligé d'utiliser {{jsxref("Array.indexOf", "indexOf")}} ce qui peut diminuer les performances.
+- Les objets `Set` permettent de supprimer les éléments avec leur valeur. Avec un tableau, il faudrait « découper » le tableau sur l'indice de l'élément.
+- Dans un tableau, la valeur {{jsxref("NaN")}} ne peut pas être trouvée avec la méthode `indexOf`.
+- Les objets `Set` permettent de stocker des valeurs uniques, il n'est pas nécessaire d'effectuer des vérifications manuellement.
 
-<h3 id="Le_type_WeakSet">Le type <code>WeakSet</code></h3>
+### Le type `WeakSet`
 
-<p>Les objets {{jsxref("WeakSet")}} sont des ensembles d'objets. Un objet d'un <code>WeakSet</code> ne peut y apparaître qu'une seule fois maximum. On ne peut pas itérer sur les objets <code>WeakSet</code> (ils ne sont pas énumérables).</p>
+Les objets {{jsxref("WeakSet")}} sont des ensembles d'objets. Un objet d'un `WeakSet` ne peut y apparaître qu'une seule fois maximum. On ne peut pas itérer sur les objets `WeakSet` (ils ne sont pas énumérables).
 
-<p>Les principales différences avec l'objet {{jsxref("Set")}} sont :</p>
+Les principales différences avec l'objet {{jsxref("Set")}} sont :
 
-<ul>
- <li>Contrairement aux objets <code>Set</code>, les objets <code>WeakSet</code> sont des ensembles qui ne comprennent <strong>que des objets</strong>, les valeurs ne peuvent pas être d'un type arbitraire.</li>
- <li>Les objets <code>WeakSet</code> utilisent des références faibles vers les objets. Ainsi, s'il n'y a pas d'autres références vers l'objet stocké dans le <code>WeakSet</code>, celui-ci pourra être collecté par le ramasse-miettes pour libérer de la mémoire. Cela signifie également qu'on ne peut pas maintenir une liste des différents objets contenus dans l'ensemble : les objets <code>WeakSet</code> ne sont pas énumérables.</li>
-</ul>
+- Contrairement aux objets `Set`, les objets `WeakSet` sont des ensembles qui ne comprennent **que des objets**, les valeurs ne peuvent pas être d'un type arbitraire.
+- Les objets `WeakSet` utilisent des références faibles vers les objets. Ainsi, s'il n'y a pas d'autres références vers l'objet stocké dans le `WeakSet`, celui-ci pourra être collecté par le ramasse-miettes pour libérer de la mémoire. Cela signifie également qu'on ne peut pas maintenir une liste des différents objets contenus dans l'ensemble : les objets `WeakSet` ne sont pas énumérables.
 
-<p>Les cas d'utilisations pour les objets <code>WeakSet</code> objects sont relativement limités. Ils empêcheront toute fuite mémoire donc on pourra, de façon sécurisée, les utiliser avec des éléments DOM qui pourront être des clés (pour les utiliser par ailleurs, etc.).</p>
+Les cas d'utilisations pour les objets `WeakSet` objects sont relativement limités. Ils empêcheront toute fuite mémoire donc on pourra, de façon sécurisée, les utiliser avec des éléments DOM qui pourront être des clés (pour les utiliser par ailleurs, etc.).
 
-<h2 id="Égalité_des_clés_et_des_valeurs_avec_Map_et_Set">Égalité des clés et des valeurs avec <code>Map</code> et <code>Set</code></h2>
+## Égalité des clés et des valeurs avec `Map` et `Set`
 
-<p>L'égalité utilisée pour les clés des objets <code>Map</code> et celle utilisée pour les valeurs des objets <code>Set</code> sont les mêmes : elles sont basées sur <a href="https://tc39.github.io/ecma262/#sec-samevaluezero">l'algorithme suivant</a> :</p>
+L'égalité utilisée pour les clés des objets `Map` et celle utilisée pour les valeurs des objets `Set` sont les mêmes : elles sont basées sur [l'algorithme suivant](https://tc39.github.io/ecma262/#sec-samevaluezero) :
 
-<ul>
- <li>L'égalité fonctionne de la même façon qu'avec l'opérateur d'égalité stricte <code>===</code>.</li>
- <li><code>-0</code> et <code>+0</code> sont considérés égaux.</li>
- <li>{{jsxref("NaN")}} est considéré égal à lui-même (contrairement à ce qu'on obtient avec <code>===</code>).</li>
-</ul>
+- L'égalité fonctionne de la même façon qu'avec l'opérateur d'égalité stricte `===`.
+- `-0` et `+0` sont considérés égaux.
+- {{jsxref("NaN")}} est considéré égal à lui-même (contrairement à ce qu'on obtient avec `===`).
 
-<p>{{PreviousNext("Web/JavaScript/Guide/Collections_indexées", "Web/JavaScript/Guide/Utiliser_les_objets")}}</p>
+{{PreviousNext("Web/JavaScript/Guide/Collections_indexées", "Web/JavaScript/Guide/Utiliser_les_objets")}}
diff --git a/files/fr/web/javascript/guide/loops_and_iteration/index.md b/files/fr/web/javascript/guide/loops_and_iteration/index.md
index b3a7c80e31..c7b999b8b4 100644
--- a/files/fr/web/javascript/guide/loops_and_iteration/index.md
+++ b/files/fr/web/javascript/guide/loops_and_iteration/index.md
@@ -8,76 +8,73 @@ tags:
 translation_of: Web/JavaScript/Guide/Loops_and_iteration
 original_slug: Web/JavaScript/Guide/Boucles_et_itération
 ---
-<div>{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/Contr%C3%B4le_du_flux_Gestion_des_erreurs", "Web/JavaScript/Guide/Fonctions")}}</div>
+{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/Contr%C3%B4le_du_flux_Gestion_des_erreurs", "Web/JavaScript/Guide/Fonctions")}}
 
-<p>Les boucles permettent de répéter des actions simplement et rapidement. Ce chapitre du<a href="/fr/docs/Web/JavaScript/Guide"> guide JavaScript</a> présente les différentes instructions qu'il est possible d'utiliser en JavaScript pour effectuer des itérations.</p>
+Les boucles permettent de répéter des actions simplement et rapidement. Ce chapitre du[ guide JavaScript](/fr/docs/Web/JavaScript/Guide) présente les différentes instructions qu'il est possible d'utiliser en JavaScript pour effectuer des itérations.
 
-<p>Les boucles permettent de répéter des actions simplement et rapidement. Une boucle peut être vue comme une version informatique de « copier N lignes » ou de « faire X fois quelque chose ». Par exemple, en JavaScript, on pourrait traduire « Faire 5 pas vers l'est » avec cette boucle :</p>
+Les boucles permettent de répéter des actions simplement et rapidement. Une boucle peut être vue comme une version informatique de « copier N lignes » ou de « faire X fois quelque chose ». Par exemple, en JavaScript, on pourrait traduire « Faire 5 pas vers l'est » avec cette boucle :
 
-<pre class="brush: js">for (let pas = 0; pas &lt; 5; pas++) {
+```js
+for (let pas = 0; pas < 5; pas++) {
   // Ceci sera exécuté 5 fois
   // À chaque éxécution, la variable "pas" augmentera de 1
   // Lorsque'elle sera arrivée à 5, le boucle se terminera.
   console.log('Faire ' + pas + ' pas vers l\'est');
 }
-</pre>
-
-<p>Il y a différents types de boucles mais elles se ressemblent toutes au sens où elles répètent une action un certain nombre de fois (ce nombre peut éventuellement être zéro). Les différents types de boucles permettent d'utiliser différentes façon de commencer et de terminer une boucle. Chaque type de boucle pourra être utilisé en fonction de la situation et du problème que l'on cherche à résoudre.</p>
-
-<p>Voici les différentes boucles fournies par JavaScript :</p>
-
-<ul>
- <li>{{anch("Linstruction for")}}</li>
- <li>{{anch("Linstruction do...while")}}</li>
- <li>{{anch("Linstruction while")}}</li>
- <li>{{anch("Linstruction label")}}</li>
- <li>{{anch("Linstruction break")}}</li>
- <li>{{anch("Linstruction continue")}}</li>
- <li>{{anch("Linstruction for...in")}}</li>
- <li>{{anch("Linstruction for...of")}}</li>
-</ul>
-
-<h2 id="Linstruction_for">L'instruction for</h2>
-
-<p>Une boucle {{jsxref("statements/for", "for")}} répète des instructions jusqu'à ce qu'une condition donnée ne soit plus vérifiée. La boucle <code>for</code> JavaScript ressemble beaucoup à celle utilisée en C ou en Java. Une boucle <code>for</code> s'utilise de la façon suivante :</p>
-
-<pre class="syntaxbox">for ([expressionInitiale]; [condition]; [expressionIncrément])
-  instruction
-</pre>
-
-<p>Voici ce qui se passe quand une boucle <code>for</code> s'exécute :</p>
-
-<ol>
- <li>L'expression initiale <code>expressionInitiale</code> est exécutée si elle est présente. Généralement, on utilise cette expression pour initialiser un ou plusieurs compteurs dont on se servira dans la boucle. Il est possible d'utiliser des expressions plus complexes si besoin. Elle peut servir à déclarer des variables.</li>
- <li>L'expression <code>condition</code> est évaluée, si elle vaut <code>true</code>, les instructions contenues dans la boucle sont exécutées. Si la valeur de <code>condition</code> est <code>false</code>, la boucle <code>for</code> se termine. Si la condition est absente, elle est considérée comme <code>true</code>.</li>
- <li>L'instruction <code>instruction</code> est exécutée. Si l'on souhaite exécuter plusieurs instructions, on utilisera un bloc d'instructions (<code>{ ... }</code>) afin de les grouper.</li>
- <li>Si elle est présente, l'expression de mise à jour<code> expressionIncrément</code> est exécutée.</li>
- <li>On retourne ensuite à l'étape 2.</li>
-</ol>
-
-<h3 id="Exemple"><strong>Exemple</strong></h3>
-
-<p>La fonction suivante contient une instruction <code>for</code> qui compte le nombre d'options sélectionnées dans une liste déroulante (ici, un objet {{HTMLElement("select")}} permettant une sélection multiple). L'instruction <code>for</code> déclare une variable <code>i</code> et l'initialise à zéro. Elle vérifie que <code>i</code> est bien inférieur au nombre d'options et, pour chaque option, effectue un test conditionnel pour savoir si l'option est sélectionnée puis passe à l'option suivante en incrémentant la variable <code>i</code> pour chaque itération.</p>
-
-<pre class="brush: html">&lt;form name="selectForm"&gt;
-  &lt;p&gt;
-    &lt;label for="typesMusique"&gt;Veuillez choisir des genres musicaux, puis cliquez :&lt;/label&gt;
-    &lt;select id="typesMusique" name="typesMusique" multiple="multiple"&gt;
-      &lt;option selected="selected"&gt;R&amp;B&lt;/option&gt;
-      &lt;option&gt;Jazz&lt;/option&gt;
-      &lt;option&gt;Blues&lt;/option&gt;
-      &lt;option&gt;New Age&lt;/option&gt;
-      &lt;option&gt;Classique&lt;/option&gt;
-      &lt;option&gt;Opera&lt;/option&gt;
-    &lt;/select&gt;
-  &lt;/p&gt;
-  &lt;p&gt;&lt;button id="btn" type="button"&gt;Combien sont sélectionnés ?&lt;/button&gt;&lt;/p&gt;
-&lt;/form&gt;
-
-&lt;script&gt;
+```
+
+Il y a différents types de boucles mais elles se ressemblent toutes au sens où elles répètent une action un certain nombre de fois (ce nombre peut éventuellement être zéro). Les différents types de boucles permettent d'utiliser différentes façon de commencer et de terminer une boucle. Chaque type de boucle pourra être utilisé en fonction de la situation et du problème que l'on cherche à résoudre.
+
+Voici les différentes boucles fournies par JavaScript :
+
+- {{anch("Linstruction for")}}
+- {{anch("Linstruction do...while")}}
+- {{anch("Linstruction while")}}
+- {{anch("Linstruction label")}}
+- {{anch("Linstruction break")}}
+- {{anch("Linstruction continue")}}
+- {{anch("Linstruction for...in")}}
+- {{anch("Linstruction for...of")}}
+
+## L'instruction for
+
+Une boucle {{jsxref("statements/for", "for")}} répète des instructions jusqu'à ce qu'une condition donnée ne soit plus vérifiée. La boucle `for` JavaScript ressemble beaucoup à celle utilisée en C ou en Java. Une boucle `for` s'utilise de la façon suivante :
+
+    for ([expressionInitiale]; [condition]; [expressionIncrément])
+      instruction
+
+Voici ce qui se passe quand une boucle `for` s'exécute :
+
+1.  L'expression initiale `expressionInitiale` est exécutée si elle est présente. Généralement, on utilise cette expression pour initialiser un ou plusieurs compteurs dont on se servira dans la boucle. Il est possible d'utiliser des expressions plus complexes si besoin. Elle peut servir à déclarer des variables.
+2.  L'expression `condition` est évaluée, si elle vaut `true`, les instructions contenues dans la boucle sont exécutées. Si la valeur de `condition` est `false`, la boucle `for` se termine. Si la condition est absente, elle est considérée comme `true`.
+3.  L'instruction `instruction` est exécutée. Si l'on souhaite exécuter plusieurs instructions, on utilisera un bloc d'instructions (`{ ... }`) afin de les grouper.
+4.  Si elle est présente, l'expression de mise à jour` expressionIncrément` est exécutée.
+5.  On retourne ensuite à l'étape 2.
+
+### **Exemple**
+
+La fonction suivante contient une instruction `for` qui compte le nombre d'options sélectionnées dans une liste déroulante (ici, un objet {{HTMLElement("select")}} permettant une sélection multiple). L'instruction `for` déclare une variable `i` et l'initialise à zéro. Elle vérifie que `i` est bien inférieur au nombre d'options et, pour chaque option, effectue un test conditionnel pour savoir si l'option est sélectionnée puis passe à l'option suivante en incrémentant la variable `i` pour chaque itération.
+
+```html
+<form name="selectForm">
+  <p>
+    <label for="typesMusique">Veuillez choisir des genres musicaux, puis cliquez :</label>
+    <select id="typesMusique" name="typesMusique" multiple="multiple">
+      <option selected="selected">R&B</option>
+      <option>Jazz</option>
+      <option>Blues</option>
+      <option>New Age</option>
+      <option>Classique</option>
+      <option>Opera</option>
+    </select>
+  </p>
+  <p><button id="btn" type="button">Combien sont sélectionnés ?</button></p>
+</form>
+
+<script>
 function quantité(selectObject) {
   let qtéSélectionnée = 0;
-  for (let i = 0; i &lt; selectObject.options.length; i++) {
+  for (let i = 0; i < selectObject.options.length; i++) {
     if (selectObject.options[i].selected) {
       qtéSélectionnée++;
     }
@@ -89,133 +86,131 @@ let btn = document.getElementById("btn");
 btn.addEventListener("click", function(){
   alert('Nombre d\'options choisies : ' + quantité(document.selectForm.typesMusique))
 });
-&lt;/script&gt;
+</script>
+```
 
-</pre>
+## L'instruction `do...while`
 
-<h2 id="Linstruction_do...while">L'instruction <code>do...while</code></h2>
+L'instruction {{jsxref("statements/do...while", "do...while")}} permet de répéter un ensemble d'instructions jusqu'à ce qu'une condition donnée ne soit plus vérifiée. (_NdT_ : littéralement « do...while » signifie « faire... tant que »). Une instruction `do...while` s'utilise de la façon suivante :
 
-<p>L'instruction {{jsxref("statements/do...while", "do...while")}} permet de répéter un ensemble d'instructions jusqu'à ce qu'une condition donnée ne soit plus vérifiée. (<em>NdT</em> : littéralement « do...while » signifie « faire... tant que »). Une instruction <code>do...while</code> s'utilise de la façon suivante :</p>
+    do
+      instruction
+    while (condition);
 
-<pre class="syntaxbox">do
-  instruction
-while (condition);
-</pre>
+`instruction` est exécutée au moins une fois avant que la condition soit vérifiée. Pour utiliser plusieurs instructions à cet endroit, on utilisera une instruction de bloc (`{ ... }`) pour regrouper différentes instructions. Si la `condition` est vérifiée, l'instruction est à nouveau exécutée. À la fin de chaque exécution, la condition est vérifiée. Quand la condition n'est plus vérifiée (vaut `false` ou une valeur équivalente), l'exécution de l'instruction` do...while` est stoppée et le contrôle passe à l'instruction suivante.
 
-<p><code>instruction</code> est exécutée au moins une fois avant que la condition soit vérifiée. Pour utiliser plusieurs instructions à cet endroit, on utilisera une instruction de bloc (<code>{ ... }</code>) pour regrouper différentes instructions. Si la <code>condition</code> est vérifiée, l'instruction est à nouveau exécutée. À la fin de chaque exécution, la condition est vérifiée. Quand la condition n'est plus vérifiée (vaut <code>false</code> ou une valeur équivalente), l'exécution de l'instruction<code> do...while</code> est stoppée et le contrôle passe à l'instruction suivante.</p>
+### Exemple
 
-<h3 id="Exemple_2">Exemple</h3>
+Dans l'exemple qui suit, la boucle `do` est exécutée au moins une fois et répétée jusqu'à ce que `i` ne soit plus inférieur à 5.
 
-<p>Dans l'exemple qui suit, la boucle <code>do</code> est exécutée au moins une fois et répétée jusqu'à ce que <code>i</code> ne soit plus inférieur à 5.</p>
-
-<pre class="brush: js">let i = 0;
+```js
+let i = 0;
 do {
   i += 1;
   console.log(i);
-} while (i &lt; 5);</pre>
+} while (i < 5);
+```
 
-<h2 id="Linstruction_while">L'instruction <code>while</code></h2>
+## L'instruction `while`
 
-<p>Une instruction {{jsxref("statements/while", "while")}} permet d'exécuter une instruction tant qu'une condition donnée est vérifiée. Cette instruction <code>while</code> s'utilise de la façon suivante :</p>
+Une instruction {{jsxref("statements/while", "while")}} permet d'exécuter une instruction tant qu'une condition donnée est vérifiée. Cette instruction `while` s'utilise de la façon suivante :
 
-<pre class="syntaxbox">while (condition)
-  instruction
-</pre>
+    while (condition)
+      instruction
 
-<p>Si la condition n'est pas vérifiée, l'instruction<code> instruction</code> n'est pas exécutée et le contrôle passe directement à l'instruction suivant la boucle.</p>
+Si la condition n'est pas vérifiée, l'instruction` instruction` n'est pas exécutée et le contrôle passe directement à l'instruction suivant la boucle.
 
-<p>Le test de la condition s'effectue avant d'exécuter <code>instruction</code>. Si la condition renvoie <code>true</code> (ou une valeur équivalente), <code>instruction</code> sera exécutée et la condition sera testée à nouveau. Si la condition renvoie <code>false</code> (ou une valeur équivalente), l'exécution s'arrête et le contrôle est passé à l'instruction qui suit <code>while</code>.</p>
+Le test de la condition s'effectue avant d'exécuter `instruction`. Si la condition renvoie `true` (ou une valeur équivalente), `instruction` sera exécutée et la condition sera testée à nouveau. Si la condition renvoie `false` (ou une valeur équivalente), l'exécution s'arrête et le contrôle est passé à l'instruction qui suit `while`.
 
-<p>Pour pouvoir utiliser plusieurs instructions dans la boucle, on utilisera une instruction de bloc (<code>{ ... }</code>) afin de les regrouper.</p>
+Pour pouvoir utiliser plusieurs instructions dans la boucle, on utilisera une instruction de bloc (`{ ... }`) afin de les regrouper.
 
-<h3 id="Exemple_1">Exemple 1</h3>
+### Exemple 1
 
-<p>La boucle <code>while</code> qui suit permet d'effectuer des itérations tant que <code>n</code> est inférieur à 3 :</p>
+La boucle `while` qui suit permet d'effectuer des itérations tant que `n` est inférieur à 3 :
 
-<pre class="brush: js">let n = 0;
+```js
+let n = 0;
 let x = 0;
-while (n &lt; 3) {
+while (n < 3) {
   n++;
   x += n;
 }
-</pre>
+```
 
-<p>À chaque itération, la boucle incrémente <code>n</code> et ajoute la valeur de <code>n</code> à <code>x</code>. <code>x</code> et <code>n</code> prendront ainsi les valeurs suivantes :</p>
+À chaque itération, la boucle incrémente `n` et ajoute la valeur de `n` à `x`. `x` et `n` prendront ainsi les valeurs suivantes :
 
-<ul>
- <li>Après la première itération : <code>n</code> = 1 et <code>x</code> = 1</li>
- <li>Après la deuxième itération : <code>n</code> = 2 et <code>x</code> = 3</li>
- <li>Après la troisième itération : <code>n</code> = 3 et <code>x</code> = 6</li>
-</ul>
+- Après la première itération : `n` = 1 et `x` = 1
+- Après la deuxième itération : `n` = 2 et `x` = 3
+- Après la troisième itération : `n` = 3 et `x` = 6
 
-<p>Une fois la troisième itération effectuée, la condition <code>n &lt; 3</code> n'est plus vérifiée, par conséquent, la boucle se termine.</p>
+Une fois la troisième itération effectuée, la condition `n < 3` n'est plus vérifiée, par conséquent, la boucle se termine.
 
-<h3 id="Exemple_2_2">Exemple 2</h3>
+### Exemple 2
 
-<p>Attention à éviter les boucles infinies. Il faut bien s'assurer que la condition utilisée dans la boucle ne soit plus vérifiée à un moment donné. Si la condition est toujours vérifiée, la boucle se répétera sans jamais s'arrêter. Dans l'exemple qui suit, les instructions contenues dans la boucle <code>while</code> s'exécutent sans discontinuer car la condition est toujours vérifiée :</p>
+Attention à éviter les boucles infinies. Il faut bien s'assurer que la condition utilisée dans la boucle ne soit plus vérifiée à un moment donné. Si la condition est toujours vérifiée, la boucle se répétera sans jamais s'arrêter. Dans l'exemple qui suit, les instructions contenues dans la boucle `while` s'exécutent sans discontinuer car la condition est toujours vérifiée :
 
-<pre class="brush: js">while (true) {
+```js
+while (true) {
   console.log("Coucou monde !");
-}</pre>
+}
+```
 
-<h2 id="Linstruction_label">L'instruction <code>label</code></h2>
+## L'instruction `label`
 
-<p>Un {{jsxref("statements/label","label")}} (ou étiquette) permet de fournir un identifiant pour une instruction afin d'y faire référence depuis un autre endroit dans le programme. On peut ainsi identifier une boucle grâce à un label puis utiliser les instructions <code>break</code> ou <code>continue</code> pour indiquer si le programme doit interrompre ou poursuivre l'exécution de cette boucle.</p>
+Un {{jsxref("statements/label","label")}} (ou étiquette) permet de fournir un identifiant pour une instruction afin d'y faire référence depuis un autre endroit dans le programme. On peut ainsi identifier une boucle grâce à un label puis utiliser les instructions `break` ou `continue` pour indiquer si le programme doit interrompre ou poursuivre l'exécution de cette boucle.
 
-<p>On utilise un label de la façon suivante :</p>
+On utilise un label de la façon suivante :
 
-<pre class="syntaxbox">label:
-  instruction
-</pre>
+    label:
+      instruction
 
-<p>La valeur de <code><em>label</em></code> peut être n'importe quel identifiant JavaScript valide (et ne doit pas être un mot réservé pour le langage). L'<code><em>instruction</em></code> peut être n'importe quelle instruction JavaScript valide (y compris un bloc).</p>
+La valeur de `label` peut être n'importe quel identifiant JavaScript valide (et ne doit pas être un mot réservé pour le langage). L'`instruction` peut être n'importe quelle instruction JavaScript valide (y compris un bloc).
 
-<h3 id="Exemple_3">Exemple</h3>
+### Exemple
 
-<p>Dans cet exemple, on utilise un label <code>memoBoucle</code> pour identifier une boucle <code>while</code>.</p>
+Dans cet exemple, on utilise un label `memoBoucle` pour identifier une boucle `while`.
 
-<pre class="brush: js">memoBoucle:
+```js
+memoBoucle:
 while (memo == true) {
   faireQQC();
-}</pre>
+}
+```
 
-<div class="note">
-<p><strong>Note :</strong> Pour plus de détails sur cette instruction, voir la page de la référence JavaScript pour <a href="/fr/docs/Web/JavaScript/Reference/Instructions/label"><code>label</code></a>.</p>
-</div>
+> **Note :** Pour plus de détails sur cette instruction, voir la page de la référence JavaScript pour [`label`](/fr/docs/Web/JavaScript/Reference/Instructions/label).
 
-<h2 id="Linstruction_break">L'instruction <code>break</code></h2>
+## L'instruction `break`
 
-<p>L'instruction {{jsxref("statements/break","break")}} est utilisée pour finir l'exécution d'une boucle, d'une instruction <code>switch</code>, ou avec un label.</p>
+L'instruction {{jsxref("statements/break","break")}} est utilisée pour finir l'exécution d'une boucle, d'une instruction `switch`, ou avec un label.
 
-<ul>
- <li>Lorsque <code>break</code> est utilisé sans label, il provoque la fin de l'instruction <code>while</code>, <code>do-while</code>, <code>for</code>, ou <code>switch</code> dans laquelle il est inscrit (on finit l'instruction la plus imbriquée), le contrôle est ensuite passé à l'instruction suivante.</li>
- <li>Lorsque <code>break</code> est utilisé avec un label, il provoque la fin de l'instruction correspondante.</li>
-</ul>
+- Lorsque `break` est utilisé sans label, il provoque la fin de l'instruction `while`, `do-while`, `for`, ou `switch` dans laquelle il est inscrit (on finit l'instruction la plus imbriquée), le contrôle est ensuite passé à l'instruction suivante.
+- Lorsque `break` est utilisé avec un label, il provoque la fin de l'instruction correspondante.
 
-<p>La syntaxe de cette instruction possède donc deux formes :</p>
+La syntaxe de cette instruction possède donc deux formes :
 
-<ol>
- <li><code>break;</code></li>
- <li><code>break <em>label</em>;</code></li>
-</ol>
+1.  `break;`
+2.  `break label;`
 
-<p>La première forme permet d'interrompre la boucle la plus imbriquée (ou le <code>switch</code>) dans laquelle on se trouve. La seconde forme interrompt l'exécution d'une instruction identifiée par un label.</p>
+La première forme permet d'interrompre la boucle la plus imbriquée (ou le `switch`) dans laquelle on se trouve. La seconde forme interrompt l'exécution d'une instruction identifiée par un label.
 
-<h3 id="Exemple_1_2">Exemple <strong>1</strong></h3>
+### Exemple **1**
 
-<p>Dans l'exemple qui suit, on itère sur un tableau grâce à une boucle jusqu'à trouver un élément dont la valeur est <code>valeurTest </code>:</p>
+Dans l'exemple qui suit, on itère sur un tableau grâce à une boucle jusqu'à trouver un élément dont la valeur est `valeurTest `:
 
-<pre class="brush: js">for (i = 0; i &lt; a.length; i++) {
+```js
+for (i = 0; i < a.length; i++) {
   if (a[i] === valeurTest) {
     break;
   }
-}</pre>
+}
+```
 
-<h3 id="Exemple_2_3">Exemple 2</h3>
+### Exemple 2
 
-<p>Ici, on utilise <code>break</code> des deux façons : avec une instruction représentée par un label et sans.</p>
+Ici, on utilise `break` des deux façons : avec une instruction représentée par un label et sans.
 
-<pre class="brush: js">let x = 0;
+```js
+let x = 0;
 let z = 0;
 labelAnnuleBoucle: while (true) {
   console.log("Boucle externe : " + x);
@@ -224,38 +219,35 @@ labelAnnuleBoucle: while (true) {
   while (true) {
     console.log("Boucle interne : " + z);
     z += 1;
-    if (z === 10 &amp;&amp; x === 10) {
+    if (z === 10 && x === 10) {
       break labelAnnuleBoucle;
     } else if (z === 10) {
       break;
     }
   }
 }
-</pre>
+```
 
-<h2 id="Linstruction_continue">L'instruction <code>continue</code></h2>
+## L'instruction `continue`
 
-<p>L'instruction {{jsxref("statements/continue","continue")}} permet de reprendre une boucle <code>while</code>, <code>do-while</code>, <code>for</code>, ou une instruction <code>label</code>.</p>
+L'instruction {{jsxref("statements/continue","continue")}} permet de reprendre une boucle `while`, `do-while`, `for`, ou une instruction `label`.
 
-<ul>
- <li>Lorsque <code>continue</code> est utilisé sans label, l'itération courante de la boucle (celle la plus imbriquée) est terminée et la boucle passe à l'exécution de la prochaine itération. À la différence de l'instruction <code>break</code>, <code>continue</code> ne stoppe pas entièrement l'exécution de la boucle. Si elle est utilisée dans une boucle <code>while</code>, l'itération reprend au niveau de la condition d'arrêt. Dans une boucle <code>for</code>, l'itération reprend au niveau de l'expression d'incrément pour la boucle.</li>
- <li>Lorsque <code>continue</code> est utilisé avec un label, il est appliqué à l'instruction de boucle correspondante.</li>
-</ul>
+- Lorsque `continue` est utilisé sans label, l'itération courante de la boucle (celle la plus imbriquée) est terminée et la boucle passe à l'exécution de la prochaine itération. À la différence de l'instruction `break`, `continue` ne stoppe pas entièrement l'exécution de la boucle. Si elle est utilisée dans une boucle `while`, l'itération reprend au niveau de la condition d'arrêt. Dans une boucle `for`, l'itération reprend au niveau de l'expression d'incrément pour la boucle.
+- Lorsque `continue` est utilisé avec un label, il est appliqué à l'instruction de boucle correspondante.
 
-<p>L'instruction <code>continue</code> s'utilise donc de la façon suivante :</p>
+L'instruction `continue` s'utilise donc de la façon suivante :
 
-<ol>
- <li><code>continue;</code></li>
- <li><code>continue </code><em><code>label;</code></em></li>
-</ol>
+1.  `continue;`
+2.  `continue `_`label;`_
 
-<h3 id="Exemple_1_3">Exemple 1</h3>
+### Exemple 1
 
-<p>Dans l'exemple qui suit, on utilise une boucle <code>while</code> avec une instruction <code>continue</code> qui est exécutée lorsque <code>i</code> vaut 3. Ici, <code>n</code> prendra donc les valeurs 1, 3, 7 et 12.</p>
+Dans l'exemple qui suit, on utilise une boucle `while` avec une instruction `continue` qui est exécutée lorsque `i` vaut 3. Ici, `n` prendra donc les valeurs 1, 3, 7 et 12.
 
-<pre class="brush: js">let i = 0;
+```js
+let i = 0;
 let n = 0;
-while (i &lt; 5) {
+while (i < 5) {
   i++;
   if (i === 3) {
     continue;
@@ -264,23 +256,23 @@ while (i &lt; 5) {
   console.log(n);
 }
 // 1, 3, 7, 12
+```
 
-</pre>
+### Exemple 2
 
-<h3 id="Exemple_2_4">Exemple 2</h3>
+Dans l'exemple suivant, on a une instruction étiquetée `vérifIetJ` qui contient une autre instruction étiquetée `vérifJ`. Si l'instruction `continue` est utilisée, le programme reprend l'exécution au début de l'instruction `vérifJ`. Chaque fois que `continue` est utilisé, `vérifJ` réitère jusqu'à ce que sa condition renvoie `false`. Lorsque c'est le cas, le reste de l'instruction `vérifIetJ` est exécuté.
 
-<p>Dans l'exemple suivant, on a une instruction étiquetée <code>vérifIetJ</code> qui contient une autre instruction étiquetée <code>vérifJ</code>. Si l'instruction <code>continue</code> est utilisée, le programme reprend l'exécution au début de l'instruction <code>vérifJ</code>. Chaque fois que <code>continue</code> est utilisé, <code>vérifJ</code> réitère jusqu'à ce que sa condition renvoie <code>false</code>. Lorsque c'est le cas, le reste de l'instruction <code>vérifIetJ</code> est exécuté.</p>
+Si `continue` utilisait l'étiquette `vérifIetJ`, le programme continuerait au début de l'instruction `vérifIetJ`
 
-<p>Si <code>continue</code> utilisait l'étiquette <code>vérifIetJ</code>, le programme continuerait au début de l'instruction <code>vérifIetJ</code></p>
-
-<pre class="brush: js">let i = 0;
+```js
+let i = 0;
 let j = 8;
 
-vérifIetJ: while (i &lt; 4) {
+vérifIetJ: while (i < 4) {
   console.log("i : " + i);
   i += 1;
 
-  vérifJ: while (j &gt; 4) {
+  vérifJ: while (j > 4) {
     console.log("j : "+ j);
     j -= 1;
     if ((j % 2) === 0){
@@ -290,22 +282,23 @@ vérifIetJ: while (i &lt; 4) {
    }
    console.log("i = " + i);
    console.log("j = " + j);
-}</pre>
+}
+```
 
-<h2 id="Linstruction_for...in">L'instruction <code>for...in</code></h2>
+## L'instruction `for...in`
 
-<p>L'instruction {{jsxref("statements/for...in","for...in")}} permet d'itérer sur l'ensemble des propriétés énumérables d'un objet. Pour chaque propriété, JavaScript exécutera l'instruction indiquée. Cette instruction s'utilise de la façon suivante :</p>
+L'instruction {{jsxref("statements/for...in","for...in")}} permet d'itérer sur l'ensemble des propriétés énumérables d'un objet. Pour chaque propriété, JavaScript exécutera l'instruction indiquée. Cette instruction s'utilise de la façon suivante :
 
-<pre class="syntaxbox">for (variable in objet) {
-  instruction
-}
-</pre>
+    for (variable in objet) {
+      instruction
+    }
 
-<h3 id="Exemple_4">Exemple</h3>
+### Exemple
 
-<p>La fonction suivante prend comme argument un objet et le nom de cet objet. Elle parcourt ensuite les propriétés de l'objet et renvoie une chaîne de caractères qui liste les propriétés avec leurs noms et leurs valeurs respectives :</p>
+La fonction suivante prend comme argument un objet et le nom de cet objet. Elle parcourt ensuite les propriétés de l'objet et renvoie une chaîne de caractères qui liste les propriétés avec leurs noms et leurs valeurs respectives :
 
-<pre class="brush: js">function afficherProps(obj, nomObj) {
+```js
+function afficherProps(obj, nomObj) {
   var result = "";
   for (var i in obj) {
     result += nomObj + "." + i + " = " + obj[i] + "\n";
@@ -313,29 +306,31 @@ vérifIetJ: while (i &lt; 4) {
   result += "\n";
   return result;
 }
-</pre>
+```
 
-<p>Pour un objet <code>voiture</code> dont les propriétés sont <code>fabricant</code> et <code>modèle</code>, <code>result</code> serait :</p>
+Pour un objet `voiture` dont les propriétés sont `fabricant` et `modèle`, `result` serait :
 
-<pre class="brush: js">voiture.fabricant = Ford
+```js
+voiture.fabricant = Ford
 voiture.modèle = Mustang
-</pre>
+```
 
-<h3 id="Les_tableaux_arrays_et_for...in">Les tableaux (arrays) et <code>for...in</code></h3>
+### Les tableaux (arrays) et `for...in`
 
-<p>Bien qu'il soit tentant d'utiliser cette instruction pour parcourir les éléments d'un objet <code><a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Array">Array</a></code> , cela peut avoir des comportements inattendus. En effet, <code>for...in</code> permet de parcourir les propriétés définies par l'utilisateur ainsi que les éléments de tableau. Ainsi, si l'on modifie un objet <code>Array</code> en lui ajoutant des propriétés et/ou des méthodes, la boucle <code>for...in</code> renverra le nom de ces nouvelles propriétés en plus des indices des éléments du tableau. C'est pourquoi, il est préférable d'utiliser une boucle <code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/for">for</a></code> avec les indices du tableau pour parcourir ses éléments.</p>
+Bien qu'il soit tentant d'utiliser cette instruction pour parcourir les éléments d'un objet [`Array`](/fr/docs/Web/JavaScript/Reference/Objets_globaux/Array) , cela peut avoir des comportements inattendus. En effet, `for...in` permet de parcourir les propriétés définies par l'utilisateur ainsi que les éléments de tableau. Ainsi, si l'on modifie un objet `Array` en lui ajoutant des propriétés et/ou des méthodes, la boucle `for...in` renverra le nom de ces nouvelles propriétés en plus des indices des éléments du tableau. C'est pourquoi, il est préférable d'utiliser une boucle [`for`](/fr/docs/Web/JavaScript/Reference/Instructions/for) avec les indices du tableau pour parcourir ses éléments.
 
-<h2 id="Linstruction_for...of">L'instruction <code>for...of</code></h2>
+## L'instruction `for...of`
 
-<p>L'instruction {{jsxref("statements/for...of","for...of")}} crée une boucle qui fonctionne avec <a href="/fr/docs/Web/JavaScript/Reference/Les_protocoles_iteration">les objets itérables</a> (qui incluent {{jsxref("Array")}}, {{jsxref("Map")}}, {{jsxref("Set")}}, l'objet <code><a href="/fr/docs/Web/JavaScript/Reference/Fonctions/arguments">arguments</a></code>, etc.). La boucle appelle un mécanisme d'itération propre à l'objet utilisé et elle parcourt l'objet et les valeurs de ses différentes propriétés.</p>
+L'instruction {{jsxref("statements/for...of","for...of")}} crée une boucle qui fonctionne avec [les objets itérables](/fr/docs/Web/JavaScript/Reference/Les_protocoles_iteration) (qui incluent {{jsxref("Array")}}, {{jsxref("Map")}}, {{jsxref("Set")}}, l'objet [`arguments`](/fr/docs/Web/JavaScript/Reference/Fonctions/arguments), etc.). La boucle appelle un mécanisme d'itération propre à l'objet utilisé et elle parcourt l'objet et les valeurs de ses différentes propriétés.
 
-<pre class="syntaxbox">for (<em>variable</em> of <em>objet</em>) {
-  <em>instruction
-</em>}</pre>
+    for (variable of objet) {
+      instruction
+    }
 
-<p>Dans l'exemple suivant, on illustre la différence entre une boucle <code>for...of</code> et une boucle <code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/for...in">for...in</a></code>.  <code>for...in</code> parcourt les noms des propriétés d'un objet alors que <code>for...of</code> parcourt les <strong>valeurs</strong> des propriétés :</p>
+Dans l'exemple suivant, on illustre la différence entre une boucle `for...of` et une boucle [`for...in`](/fr/docs/Web/JavaScript/Reference/Instructions/for...in).  `for...in` parcourt les noms des propriétés d'un objet alors que `for...of` parcourt les **valeurs** des propriétés :
 
-<pre class="brush:js">let arr = [3, 5, 7];
+```js
+let arr = [3, 5, 7];
 arr.toto = "coucou";
 
 for (let i in arr) {
@@ -345,6 +340,6 @@ for (let i in arr) {
 for (let i of arr) {
   console.log(i); // affiche 3, 5, 7 dans la console
 }
-</pre>
+```
 
-<p>{{PreviousNext("Web/JavaScript/Guide/Contr%C3%B4le_du_flux_Gestion_des_erreurs", "Web/JavaScript/Guide/Fonctions")}}</p>
+{{PreviousNext("Web/JavaScript/Guide/Contr%C3%B4le_du_flux_Gestion_des_erreurs", "Web/JavaScript/Guide/Fonctions")}}
diff --git a/files/fr/web/javascript/guide/meta_programming/index.md b/files/fr/web/javascript/guide/meta_programming/index.md
index c126f53d88..8564629cd6 100644
--- a/files/fr/web/javascript/guide/meta_programming/index.md
+++ b/files/fr/web/javascript/guide/meta_programming/index.md
@@ -9,248 +9,360 @@ tags:
 translation_of: Web/JavaScript/Guide/Meta_programming
 original_slug: Web/JavaScript/Guide/Métaprogrammation
 ---
-<div>{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/iterateurs_et_generateurs","Web/JavaScript/Guide/Modules")}}</div>
+{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/iterateurs_et_generateurs","Web/JavaScript/Guide/Modules")}}
 
-<p>À partir d'ECMAScript 2015, JavaScript fournit les objets natifs {{jsxref("Proxy")}} et {{jsxref("Reflect")}}. Ces objets permettent d'intercepter et de définir des comportements spécifiques pour certaines opérations fondamentales du langage (par exemple la recherche d'une propriété, l'affectation, l'énumération, l'appel d'une fonction, etc.). Grâce à ces deux objets, il est possible d'interagir avec le langage lui-même (on parle alors de métaprogrammation).</p>
+À partir d'ECMAScript 2015, JavaScript fournit les objets natifs {{jsxref("Proxy")}} et {{jsxref("Reflect")}}. Ces objets permettent d'intercepter et de définir des comportements spécifiques pour certaines opérations fondamentales du langage (par exemple la recherche d'une propriété, l'affectation, l'énumération, l'appel d'une fonction, etc.). Grâce à ces deux objets, il est possible d'interagir avec le langage lui-même (on parle alors de métaprogrammation).
 
-<h2 id="Les_proxies">Les proxies</h2>
+## Les proxies
 
-<p>Introduits avec ECMAScript 2015, les objets {{jsxref("Proxy")}} permettent d'intercepter certaines opérations JavaScript et de définir le comportement à avoir quand celles-ci se produisent. Par exemple, on peut intercepter l'accès à une propriété d'un objet :</p>
+Introduits avec ECMAScript 2015, les objets {{jsxref("Proxy")}} permettent d'intercepter certaines opérations JavaScript et de définir le comportement à avoir quand celles-ci se produisent. Par exemple, on peut intercepter l'accès à une propriété d'un objet :
 
-<pre class="brush: js">var handler = {
+```js
+var handler = {
   get: function(cible, nom){
     return nom in cible ? cible[nom] : 42;
 }};
 var p = new Proxy({}, handler);
 p.a = 1;
 console.log(p.a, p.b); // 1, 42
-</pre>
+```
 
-<p>Ici, l'objet <code>Proxy</code> définit une <em>cible</em> (ici c'est un objet vide) et un gestionnaire (<em>handler</em>) qui implémente une <em>trappe</em> pour l'opération <em>get</em>. Ainsi, l'objet qui est « proxyfié » ne renverra pas <code>undefined</code> lorsqu'on tentera d'accéder à une propriété qui n'est pas définie, à la place le nombre 42 sera renvoyé.</p>
+Ici, l'objet `Proxy` définit une _cible_ (ici c'est un objet vide) et un gestionnaire (_handler_) qui implémente une _trappe_ pour l'opération _get_. Ainsi, l'objet qui est « proxyfié » ne renverra pas `undefined` lorsqu'on tentera d'accéder à une propriété qui n'est pas définie, à la place le nombre 42 sera renvoyé.
 
-<div class="note">
-<p><strong>Note :</strong> D'autres exemples sont disponibles sur la page de l'objet {{jsxref("Proxy")}}.</p>
-</div>
+> **Note :** D'autres exemples sont disponibles sur la page de l'objet {{jsxref("Proxy")}}.
 
-<h3 id="Terminologie">Terminologie</h3>
+### Terminologie
 
-<p>Lorsqu'on utilise les proxies et leurs fonctionnalités, on utilisera les termes suivants :</p>
+Lorsqu'on utilise les proxies et leurs fonctionnalités, on utilisera les termes suivants :
 
-<dl>
- <dt>{{jsxref("Objets_globaux/Proxy/handler","gestionnaire (handler)","","true")}}</dt>
- <dd>L'objet qui contient les trappes.</dd>
- <dt>trappes</dt>
- <dd>Les méthodes qui fournissent l'accès aux propriétés. Ce concept est analogue aux trappes utilisées dans les systèmes d'exploitations.</dd>
- <dt>cible</dt>
- <dd>L'objet que le proxy virtualise. C'est généralement un objet utilisé en arrière-plan pour stocker les informations. Les invariants (c'est-à-dire les éléments sémantiques qui doivent rester inchangés) concernant le caractère non-extensible de l'objet ou l'aspect non-configurable des propriétés sont vérifiés par rapport à cet objet cible.</dd>
- <dt>invariants</dt>
- <dd>Les éléments sémantiques qui ne doivent pas être modifiés par les opérations définies dans les proxies. Si un invariant n'est pas respecté au sein d'un gestionnaire, cela provoquera une exception {{jsxref("TypeError")}}.</dd>
-</dl>
+- {{jsxref("Objets_globaux/Proxy/handler","gestionnaire (handler)","","true")}}
+  - : L'objet qui contient les trappes.
+- trappes
+  - : Les méthodes qui fournissent l'accès aux propriétés. Ce concept est analogue aux trappes utilisées dans les systèmes d'exploitations.
+- cible
+  - : L'objet que le proxy virtualise. C'est généralement un objet utilisé en arrière-plan pour stocker les informations. Les invariants (c'est-à-dire les éléments sémantiques qui doivent rester inchangés) concernant le caractère non-extensible de l'objet ou l'aspect non-configurable des propriétés sont vérifiés par rapport à cet objet cible.
+- invariants
+  - : Les éléments sémantiques qui ne doivent pas être modifiés par les opérations définies dans les proxies. Si un invariant n'est pas respecté au sein d'un gestionnaire, cela provoquera une exception {{jsxref("TypeError")}}.
 
-<h2 id="Les_gestionnaires_et_les_trappes">Les gestionnaires et les trappes</h2>
+## Les gestionnaires et les trappes
 
-<p>Le tableau suivant résume les différentes trappes disponibles pour les objets <code>Proxy</code>. Pour plus d'explications et de détails, voir les différents <a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Proxy/handler">pages de la référence</a> sur chacun de ces concepts.</p>
+Le tableau suivant résume les différentes trappes disponibles pour les objets `Proxy`. Pour plus d'explications et de détails, voir les différents [pages de la référence](/fr/docs/Web/JavaScript/Reference/Objets_globaux/Proxy/handler) sur chacun de ces concepts.
 
 <table class="standard-table">
- <thead>
-  <tr>
-   <th>Gestionnaires / Trappes</th>
-   <th>Opérations interceptées</th>
-   <th>Invariants</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td>{{jsxref("Objets_globaux/Proxy/handler/getPrototypeOf", "handler.getPrototypeOf()")}}</td>
-   <td>{{jsxref("Object.getPrototypeOf()")}}<br>
-    {{jsxref("Reflect.getPrototypeOf()")}}<br>
-    {{jsxref("Object/proto", "__proto__")}}<br>
-    {{jsxref("Object.prototype.isPrototypeOf()")}}<br>
-    {{jsxref("Operators/instanceof", "instanceof")}}</td>
-   <td><code>getPrototypeOf</code> doit renvoyer un objet ou <code>null</code>.<br>
-    <br>
-    Si <code>cible</code> n'est pas extensible, <code>Object.getPrototypeOf(proxy)</code> doit renvoyer le même objet que <code>Object.getPrototypeOf(cible)</code>.</td>
-  </tr>
-  <tr>
-   <td>{{jsxref("Objets_globaux/Proxy/handler/setPrototypeOf", "handler.setPrototypeOf()")}}</td>
-   <td>{{jsxref("Object.setPrototypeOf()")}}<br>
-    {{jsxref("Reflect.setPrototypeOf()")}}</td>
-   <td>
-    <p>Si <code>cible</code> n'est pas extensible, le paramètre <code>prototype</code> doit être la même valeur que <code>Object.getPrototypeOf(cible)</code>.</p>
-   </td>
-  </tr>
-  <tr>
-   <td>{{jsxref("Objets_globaux/Proxy/handler/isExtensible", "handler.isExtensible()")}}</td>
-   <td>
-    <p>{{jsxref("Object.isExtensible()")}}</p>
-
-    <p>{{jsxref("Reflect.isExtensible()")}}</p>
-   </td>
-   <td>
-    <p><code>Object.isExtensible(proxy)</code> doit renvoyer la même valeur que <code>Object.isExtensible(target)</code>.</p>
-   </td>
-  </tr>
-  <tr>
-   <td>{{jsxref("Objets_globaux/Proxy/handler/preventExtensions", "handler.preventExtensions()")}}</td>
-   <td>
-    <p>{{jsxref("Object.preventExtensions()")}}</p>
-
-    <p>{{jsxref("Reflect.preventExtensions()")}}</p>
-   </td>
-   <td>
-    <p><code>Object.preventExtensions(proxy)</code> ne renvoie <code>true</code> que si <code>Object.isExtensible(proxy)</code> vaut <code>false</code>.</p>
-   </td>
-  </tr>
-  <tr>
-   <td>{{jsxref("Objets_globaux/Proxy/handler/getOwnPropertyDescriptor", "handler.getOwnPropertyDescriptor()")}}</td>
-   <td>
-    <p>{{jsxref("Object.getOwnPropertyDescriptor()")}}</p>
-
-    <p>{{jsxref("Reflect.getOwnPropertyDescriptor()")}}</p>
-   </td>
-   <td>
-    <p><code>getOwnPropertyDescriptor</code> doit renvoyer un objet ou <code>undefined</code>.</p>
-
-    <p>Une propriété ne peut pas être vue comme non-existante si elle existe comme une propriété propre non-configurable de l'objet cible.</p>
-
-    <p>Une propriété ne peut pas être vue comme non-existante si elle existe comme une propriété propre de la cible et que l'objet cible n'est pas extensible.</p>
-
-    <p>Une propriété ne peut pas être vue comme existante si elle n'existe pas comme une propriété propre de l'objet cible et que l'objet cible n'est pas extensible.</p>
-
-    <p>Une propriété ne peut pas être vue comme non-configurable si elle n'existe pas comme une propriété propre de l'objet cible ou si elle existe comme une propriété configurable propre de l'objet cible.</p>
-
-    <p>Le résultat de <code>Object.getOwnPropertyDescriptor(cible)</code> peut être appliqué à la cible en utilisant <code>Object.defineProperty</code> sans que cela ne lève d'exception.</p>
-   </td>
-  </tr>
-  <tr>
-   <td>{{jsxref("Objets_globaux/Proxy/handler/defineProperty", "handler.defineProperty()")}}</td>
-   <td>
-    <p>{{jsxref("Object.defineProperty()")}}</p>
-
-    <p>{{jsxref("Reflect.defineProperty()")}}</p>
-   </td>
-   <td>
-    <p>Une propriété ne peut pas être ajoutée si l'objet cible n'est pas extensible.</p>
-
-    <p>Une propriété ne peut pas être ajoutée ou être modifiée afin d'être non-configurable si elle n'existe pas comme une propriété propre de l'objet cible et qu'elle n'est pas non-configurable.</p>
-
-    <p>Une propriété peut ne pas être non-configurable si une propriété correspondante configurable existe sur l'objet cible.</p>
-
-    <p>Si une propriété possède une propriété correspondante sur l'objet cible, <code>Object.defineProperty(cible, prop, descripteur)</code> ne doit pas renvoyer d'exception.</p>
-
-    <p>En mode strict, si la valeur de retour de <code>defineProperty</code> est <code>false</code>, cela entraînera une exception {{jsxref("TypeError")}} exception.</p>
-   </td>
-  </tr>
-  <tr>
-   <td>{{jsxref("Objets_globaux/Proxy/handler/has", "handler.has()")}}</td>
-   <td>
-    <p>Requête d'une propriété : <code>toto in proxy</code></p>
-
-    <p>Requête d'une propriété héritée : <code>toto in Object.create(proxy)</code></p>
-
-    <p>{{jsxref("Reflect.has()")}}</p>
-   </td>
-   <td>
-    <p>Une propriété ne peut pas être vue comme non-existante si elle existe comme propriété propre non-configurable de l'objet cible.</p>
-
-    <p>Une propriété ne peut pas être vue comme non-existante si elle existe comme propriété propre de l'objet cible et que l'objet cible n'est pas extensible.</p>
-   </td>
-  </tr>
-  <tr>
-   <td>{{jsxref("Objets_globaux/Proxy/handler/get", "handler.get()")}}</td>
-   <td>
-    <p>Accès à une propriété : <code>proxy[toto]</code> et <code>proxy.truc</code></p>
-
-    <p>Accès à une propriété héritée : <code>Object.create(proxy)[toto]</code></p>
-
-    <p>{{jsxref("Reflect.get()")}}</p>
-   </td>
-   <td>
-    <p>La valeur rapportée pour la propriété doit être la même que la valeur de la propriété correspondante sur l'objet cible si celle-ci est une propriété de donnée non accessible en écriture et non-configurable..</p>
-
-    <p>La valeur rapportée pour une propriété doit être <code>undefined</code> si la propriété correspondante de l'objet cible est une propriété d'accesseur dont l'attribut [[Get]] vaut <code>undefined</code>.</p>
-   </td>
-  </tr>
-  <tr>
-   <td>{{jsxref("Objets_globaux/Proxy/handler/set", "handler.set()")}}</td>
-   <td>
-    <p>Affection d'une propriété : <code>proxy[toto] = truc</code> et <code>proxy.toto = truc</code><br>
-     <br>
-     Affectation d'une propriété héritée : <code>Object.create(proxy)[toto] = truc</code><br>
-     <br>
-     {{jsxref("Reflect.set()")}}</p>
-   </td>
-   <td>
-    <p>Il est impossible de modifier la valeur d'une propriété pour que celle-ci soit différente de la valeur de la propriété correspondante de l'objet cible si la propriété de l'objet cible est une propriété de donnée qui n'est pas accessible en écriture et qui n'est pas configurable.</p>
-
-    <p>Il est impossible de modifier la valeur d'une propriété si la propriété correspondante de l'objet cible est une propriété d'accesseur non-configurable dont l'attribut [[Set]] vaut <code>undefined</code>.</p>
-
-    <p>En mode strict, si le gestionnaire pour <code>set</code> renvoie <code>false</code>, cela provoquera une exception {{jsxref("TypeError")}}.</p>
-   </td>
-  </tr>
-  <tr>
-   <td>{{jsxref("Objets_globaux/Proxy/handler/deleteProperty", "handler.deleteProperty()")}}</td>
-   <td>
-    <p>Suppression d'une propriété : <code>delete proxy[toto]</code> et <code>delete proxy.toto</code><br>
-     <br>
-     {{jsxref("Reflect.deleteProperty()")}}</p>
-   </td>
-   <td>Une propriété ne peut pas être supprimée si elle existe comme une propriété propre non-configurable de l'objet cible.</td>
-  </tr>
-  <tr>
-   <td>{{jsxref("Objets_globaux/Proxy/handler/enumerate", "handler.enumerate()")}}</td>
-   <td>
-    <p>Lister les propriétés avec <code>for...in</code> : <code>for (var nom in proxy) {...}</code><br>
-     <br>
-     {{jsxref("Reflect.enumerate()")}}</p>
-   </td>
-   <td>La méthode <code>enumerate</code> doit renvoyer un objet.</td>
-  </tr>
-  <tr>
-   <td>{{jsxref("Objets_globaux/Proxy/handler/ownKeys", "handler.ownKeys()")}}</td>
-   <td>
-    <p>{{jsxref("Object.getOwnPropertyNames()")}}<br>
-     {{jsxref("Object.getOwnPropertySymbols()")}}<br>
-     {{jsxref("Object.keys()")}}<br>
-     {{jsxref("Reflect.ownKeys()")}}</p>
-   </td>
-   <td>
-    <p>Le résultat de <code>ownKeys</code> est une liste.<br>
-     <br>
-     Le type de chaque élément de la liste est soit une {{jsxref("String")}} soit un  {{jsxref("Symbol")}}.<br>
-     <br>
-     La liste résultatnte doit contenir les clés de toutes les propriétés non-configurables de l'objet cible.<br>
-     <br>
-     Si l'objet cible n'est pas extensible, la liste résultante doit contenir toutes les clés des propriétés propres de l'objet cibles et aucune autre valeur.</p>
-   </td>
-  </tr>
-  <tr>
-   <td>{{jsxref("Objets_globaux/Proxy/handler/apply", "handler.apply()")}}</td>
-   <td>
-    <p><code>proxy(..args)</code><br>
-     <br>
-     {{jsxref("Function.prototype.apply()")}} and {{jsxref("Function.prototype.call()")}}<br>
-     <br>
-     {{jsxref("Reflect.apply()")}}</p>
-   </td>
-   <td>Il n'y a pas d'invariant pour la méthode <code>handler.apply</code>.</td>
-  </tr>
-  <tr>
-   <td>{{jsxref("Objets_globaux/Proxy/handler/construct", "handler.construct()")}}</td>
-   <td>
-    <p><code>new proxy(...args)</code><br>
-     {{jsxref("Reflect.construct()")}}</p>
-   </td>
-   <td>Le résultat doit être un <code>Objet</code>.</td>
-  </tr>
- </tbody>
+  <thead>
+    <tr>
+      <th>Gestionnaires / Trappes</th>
+      <th>Opérations interceptées</th>
+      <th>Invariants</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td>
+        {{jsxref("Objets_globaux/Proxy/handler/getPrototypeOf", "handler.getPrototypeOf()")}}
+      </td>
+      <td>
+        {{jsxref("Object.getPrototypeOf()")}}<br />{{jsxref("Reflect.getPrototypeOf()")}}<br />{{jsxref("Object/proto", "__proto__")}}<br />{{jsxref("Object.prototype.isPrototypeOf()")}}<br />{{jsxref("Operators/instanceof", "instanceof")}}
+      </td>
+      <td>
+        <code>getPrototypeOf</code> doit renvoyer un objet ou
+        <code>null</code>.<br /><br />Si <code>cible</code> n'est pas
+        extensible, <code>Object.getPrototypeOf(proxy)</code> doit renvoyer le
+        même objet que <code>Object.getPrototypeOf(cible)</code>.
+      </td>
+    </tr>
+    <tr>
+      <td>
+        {{jsxref("Objets_globaux/Proxy/handler/setPrototypeOf", "handler.setPrototypeOf()")}}
+      </td>
+      <td>
+        {{jsxref("Object.setPrototypeOf()")}}<br />{{jsxref("Reflect.setPrototypeOf()")}}
+      </td>
+      <td>
+        <p>
+          Si <code>cible</code> n'est pas extensible, le paramètre
+          <code>prototype</code> doit être la même valeur que
+          <code>Object.getPrototypeOf(cible)</code>.
+        </p>
+      </td>
+    </tr>
+    <tr>
+      <td>
+        {{jsxref("Objets_globaux/Proxy/handler/isExtensible", "handler.isExtensible()")}}
+      </td>
+      <td>
+        <p>{{jsxref("Object.isExtensible()")}}</p>
+        <p>{{jsxref("Reflect.isExtensible()")}}</p>
+      </td>
+      <td>
+        <p>
+          <code>Object.isExtensible(proxy)</code> doit renvoyer la même valeur
+          que <code>Object.isExtensible(target)</code>.
+        </p>
+      </td>
+    </tr>
+    <tr>
+      <td>
+        {{jsxref("Objets_globaux/Proxy/handler/preventExtensions", "handler.preventExtensions()")}}
+      </td>
+      <td>
+        <p>{{jsxref("Object.preventExtensions()")}}</p>
+        <p>{{jsxref("Reflect.preventExtensions()")}}</p>
+      </td>
+      <td>
+        <p>
+          <code>Object.preventExtensions(proxy)</code> ne renvoie
+          <code>true</code> que si <code>Object.isExtensible(proxy)</code> vaut
+          <code>false</code>.
+        </p>
+      </td>
+    </tr>
+    <tr>
+      <td>
+        {{jsxref("Objets_globaux/Proxy/handler/getOwnPropertyDescriptor", "handler.getOwnPropertyDescriptor()")}}
+      </td>
+      <td>
+        <p>{{jsxref("Object.getOwnPropertyDescriptor()")}}</p>
+        <p>{{jsxref("Reflect.getOwnPropertyDescriptor()")}}</p>
+      </td>
+      <td>
+        <p>
+          <code>getOwnPropertyDescriptor</code> doit renvoyer un objet ou
+          <code>undefined</code>.
+        </p>
+        <p>
+          Une propriété ne peut pas être vue comme non-existante si elle existe
+          comme une propriété propre non-configurable de l'objet cible.
+        </p>
+        <p>
+          Une propriété ne peut pas être vue comme non-existante si elle existe
+          comme une propriété propre de la cible et que l'objet cible n'est pas
+          extensible.
+        </p>
+        <p>
+          Une propriété ne peut pas être vue comme existante si elle n'existe
+          pas comme une propriété propre de l'objet cible et que l'objet cible
+          n'est pas extensible.
+        </p>
+        <p>
+          Une propriété ne peut pas être vue comme non-configurable si elle
+          n'existe pas comme une propriété propre de l'objet cible ou si elle
+          existe comme une propriété configurable propre de l'objet cible.
+        </p>
+        <p>
+          Le résultat de
+          <code>Object.getOwnPropertyDescriptor(cible)</code> peut être appliqué
+          à la cible en utilisant <code>Object.defineProperty</code> sans que
+          cela ne lève d'exception.
+        </p>
+      </td>
+    </tr>
+    <tr>
+      <td>
+        {{jsxref("Objets_globaux/Proxy/handler/defineProperty", "handler.defineProperty()")}}
+      </td>
+      <td>
+        <p>{{jsxref("Object.defineProperty()")}}</p>
+        <p>{{jsxref("Reflect.defineProperty()")}}</p>
+      </td>
+      <td>
+        <p>
+          Une propriété ne peut pas être ajoutée si l'objet cible n'est pas
+          extensible.
+        </p>
+        <p>
+          Une propriété ne peut pas être ajoutée ou être modifiée afin d'être
+          non-configurable si elle n'existe pas comme une propriété propre de
+          l'objet cible et qu'elle n'est pas non-configurable.
+        </p>
+        <p>
+          Une propriété peut ne pas être non-configurable si une propriété
+          correspondante configurable existe sur l'objet cible.
+        </p>
+        <p>
+          Si une propriété possède une propriété correspondante sur l'objet
+          cible, <code>Object.defineProperty(cible, prop, descripteur)</code> ne
+          doit pas renvoyer d'exception.
+        </p>
+        <p>
+          En mode strict, si la valeur de retour de
+          <code>defineProperty</code> est <code>false</code>, cela entraînera
+          une exception {{jsxref("TypeError")}} exception.
+        </p>
+      </td>
+    </tr>
+    <tr>
+      <td>
+        {{jsxref("Objets_globaux/Proxy/handler/has", "handler.has()")}}
+      </td>
+      <td>
+        <p>Requête d'une propriété : <code>toto in proxy</code></p>
+        <p>
+          Requête d'une propriété héritée :
+          <code>toto in Object.create(proxy)</code>
+        </p>
+        <p>{{jsxref("Reflect.has()")}}</p>
+      </td>
+      <td>
+        <p>
+          Une propriété ne peut pas être vue comme non-existante si elle existe
+          comme propriété propre non-configurable de l'objet cible.
+        </p>
+        <p>
+          Une propriété ne peut pas être vue comme non-existante si elle existe
+          comme propriété propre de l'objet cible et que l'objet cible n'est pas
+          extensible.
+        </p>
+      </td>
+    </tr>
+    <tr>
+      <td>
+        {{jsxref("Objets_globaux/Proxy/handler/get", "handler.get()")}}
+      </td>
+      <td>
+        <p>
+          Accès à une propriété : <code>proxy[toto]</code> et
+          <code>proxy.truc</code>
+        </p>
+        <p>
+          Accès à une propriété héritée :
+          <code>Object.create(proxy)[toto]</code>
+        </p>
+        <p>{{jsxref("Reflect.get()")}}</p>
+      </td>
+      <td>
+        <p>
+          La valeur rapportée pour la propriété doit être la même que la valeur
+          de la propriété correspondante sur l'objet cible si celle-ci est une
+          propriété de donnée non accessible en écriture et non-configurable..
+        </p>
+        <p>
+          La valeur rapportée pour une propriété doit être
+          <code>undefined</code> si la propriété correspondante de l'objet cible
+          est une propriété d'accesseur dont l'attribut [[Get]] vaut
+          <code>undefined</code>.
+        </p>
+      </td>
+    </tr>
+    <tr>
+      <td>
+        {{jsxref("Objets_globaux/Proxy/handler/set", "handler.set()")}}
+      </td>
+      <td>
+        <p>
+          Affection d'une propriété : <code>proxy[toto] = truc</code> et
+          <code>proxy.toto = truc</code><br /><br />Affectation d'une propriété
+          héritée : <code>Object.create(proxy)[toto] = truc</code
+          ><br /><br />{{jsxref("Reflect.set()")}}
+        </p>
+      </td>
+      <td>
+        <p>
+          Il est impossible de modifier la valeur d'une propriété pour que
+          celle-ci soit différente de la valeur de la propriété correspondante
+          de l'objet cible si la propriété de l'objet cible est une propriété de
+          donnée qui n'est pas accessible en écriture et qui n'est pas
+          configurable.
+        </p>
+        <p>
+          Il est impossible de modifier la valeur d'une propriété si la
+          propriété correspondante de l'objet cible est une propriété
+          d'accesseur non-configurable dont l'attribut [[Set]] vaut
+          <code>undefined</code>.
+        </p>
+        <p>
+          En mode strict, si le gestionnaire pour <code>set</code> renvoie
+          <code>false</code>, cela provoquera une exception
+          {{jsxref("TypeError")}}.
+        </p>
+      </td>
+    </tr>
+    <tr>
+      <td>
+        {{jsxref("Objets_globaux/Proxy/handler/deleteProperty", "handler.deleteProperty()")}}
+      </td>
+      <td>
+        <p>
+          Suppression d'une propriété : <code>delete proxy[toto]</code> et
+          <code>delete proxy.toto</code
+          ><br /><br />{{jsxref("Reflect.deleteProperty()")}}
+        </p>
+      </td>
+      <td>
+        Une propriété ne peut pas être supprimée si elle existe comme une
+        propriété propre non-configurable de l'objet cible.
+      </td>
+    </tr>
+    <tr>
+      <td>
+        {{jsxref("Objets_globaux/Proxy/handler/enumerate", "handler.enumerate()")}}
+      </td>
+      <td>
+        <p>
+          Lister les propriétés avec <code>for...in</code> :
+          <code>for (var nom in proxy) {...}</code
+          ><br /><br />{{jsxref("Reflect.enumerate()")}}
+        </p>
+      </td>
+      <td>La méthode <code>enumerate</code> doit renvoyer un objet.</td>
+    </tr>
+    <tr>
+      <td>
+        {{jsxref("Objets_globaux/Proxy/handler/ownKeys", "handler.ownKeys()")}}
+      </td>
+      <td>
+        <p>
+          {{jsxref("Object.getOwnPropertyNames()")}}<br />{{jsxref("Object.getOwnPropertySymbols()")}}<br />{{jsxref("Object.keys()")}}<br />{{jsxref("Reflect.ownKeys()")}}
+        </p>
+      </td>
+      <td>
+        <p>
+          Le résultat de <code>ownKeys</code> est une liste.<br /><br />Le type
+          de chaque élément de la liste est soit une
+          {{jsxref("String")}} soit un  {{jsxref("Symbol")}}.<br /><br />La
+          liste résultatnte doit contenir les clés de toutes les propriétés
+          non-configurables de l'objet cible.<br /><br />Si l'objet cible n'est
+          pas extensible, la liste résultante doit contenir toutes les clés des
+          propriétés propres de l'objet cibles et aucune autre valeur.
+        </p>
+      </td>
+    </tr>
+    <tr>
+      <td>
+        {{jsxref("Objets_globaux/Proxy/handler/apply", "handler.apply()")}}
+      </td>
+      <td>
+        <p>
+          <code>proxy(..args)</code
+          ><br /><br />{{jsxref("Function.prototype.apply()")}} and
+          {{jsxref("Function.prototype.call()")}}<br /><br />{{jsxref("Reflect.apply()")}}
+        </p>
+      </td>
+      <td>
+        Il n'y a pas d'invariant pour la méthode <code>handler.apply</code>.
+      </td>
+    </tr>
+    <tr>
+      <td>
+        {{jsxref("Objets_globaux/Proxy/handler/construct", "handler.construct()")}}
+      </td>
+      <td>
+        <p>
+          <code>new proxy(...args)</code
+          ><br />{{jsxref("Reflect.construct()")}}
+        </p>
+      </td>
+      <td>Le résultat doit être un <code>Objet</code>.</td>
+    </tr>
+  </tbody>
 </table>
 
-<h2 id="Proxies_révocables">Proxies révocables</h2>
+## Proxies révocables
 
-<p>La méthode {{jsxref("Proxy.revocable()")}} est utilisée pour créer un objet <code>Proxy</code> qui puisse être révoqué. Cela signifie que que le proxy pourra être révoqué avec la fonction <code>revoke</code> et arrêtera le proxy. Après cet arrêt, toute opération sur le proxy entraînera une exception {{jsxref("TypeError")}}.</p>
+La méthode {{jsxref("Proxy.revocable()")}} est utilisée pour créer un objet `Proxy` qui puisse être révoqué. Cela signifie que que le proxy pourra être révoqué avec la fonction `revoke` et arrêtera le proxy. Après cet arrêt, toute opération sur le proxy entraînera une exception {{jsxref("TypeError")}}.
 
-<pre class="brush: js">var revocable = Proxy.revocable({}, {
+```js
+var revocable = Proxy.revocable({}, {
   get: function(cible, nom) {
     return "[[" + nom + "]]";
   }
@@ -263,17 +375,19 @@ revocable.revoke();
 console.log(proxy.toto); // déclenche une TypeError
 proxy.toto = 1;          // une TypeError encore
 delete proxy.toto;       // toujours une TypeError
-typeof proxy             // "object", typeof ne déclenche aucune trappe</pre>
+typeof proxy             // "object", typeof ne déclenche aucune trappe
+```
 
-<h2 id="Réflexion">Réflexion</h2>
+## Réflexion
 
-<p>{{jsxref("Reflect")}} est un objet natif qui fournit des méthodes pour les opérations JavaScript qui peuvent être interceptées. Ces méthodes sont les mêmes que celles gérées par les {{jsxref("Objets_globaux/Proxy/handler","gestionnaires de proxy","","true")}}. <code>Reflect</code> n'est pas un constructeur et ne peut pas être utilisé comme une fonction !</p>
+{{jsxref("Reflect")}} est un objet natif qui fournit des méthodes pour les opérations JavaScript qui peuvent être interceptées. Ces méthodes sont les mêmes que celles gérées par les {{jsxref("Objets_globaux/Proxy/handler","gestionnaires de proxy","","true")}}. `Reflect` n'est pas un constructeur et ne peut pas être utilisé comme une fonction !
 
-<p><code>Reflect</code> aide à transférer les opérations par défaut depuis le gestionnaire vers la cible.</p>
+`Reflect` aide à transférer les opérations par défaut depuis le gestionnaire vers la cible.
 
-<p>Par exemple, avec {{jsxref("Reflect.has()")}}, on obtient le comportement de l'opérateur <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_in"><code>in</code></a> sous forme d'une fonction :</p>
+Par exemple, avec {{jsxref("Reflect.has()")}}, on obtient le comportement de l'opérateur [`in`](/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_in) sous forme d'une fonction :
 
-<pre class="brush: js">Reflect.has(Object, "assign"); // true
-</pre>
+```js
+Reflect.has(Object, "assign"); // true
+```
 
-<p>{{PreviousNext("Web/JavaScript/Guide/iterateurs_et_generateurs","Web/JavaScript/Guide/Modules")}}</p>
+{{PreviousNext("Web/JavaScript/Guide/iterateurs_et_generateurs","Web/JavaScript/Guide/Modules")}}
diff --git a/files/fr/web/javascript/guide/modules/index.md b/files/fr/web/javascript/guide/modules/index.md
index aab9361aa6..1411ef6c26 100644
--- a/files/fr/web/javascript/guide/modules/index.md
+++ b/files/fr/web/javascript/guide/modules/index.md
@@ -9,87 +9,76 @@ tags:
   - import
 translation_of: Web/JavaScript/Guide/Modules
 ---
-<div>{{jsSidebar("JavaScript Guide")}}{{Previous("Web/JavaScript/Guide/Métaprogrammation")}}</div>
+{{jsSidebar("JavaScript Guide")}}{{Previous("Web/JavaScript/Guide/Métaprogrammation")}}
 
-<p>Ce guide aborde l'ensemble des notions vous permettant d'utiliser la syntaxe des modules en JavaScript.</p>
+Ce guide aborde l'ensemble des notions vous permettant d'utiliser la syntaxe des modules en JavaScript.
 
-<h2 id="Un_peu_de_contexte">Un peu de contexte</h2>
+## Un peu de contexte
 
-<p>Les programmes JavaScript ont commencé par être assez petits, réalisant des tâches isolées uniquement là où l'interactivité était nécessaire. Après plusieurs années, nous avons maintenant des applications complètes qui sont exécutées dans les navigateurs avec des codes complexes et volumineux. Des programmes JavaScript sont également exécutés dans d'autres contextes (<a href="/fr/docs/Glossaire/Node.js">Node.js</a> par exemple).</p>
+Les programmes JavaScript ont commencé par être assez petits, réalisant des tâches isolées uniquement là où l'interactivité était nécessaire. Après plusieurs années, nous avons maintenant des applications complètes qui sont exécutées dans les navigateurs avec des codes complexes et volumineux. Des programmes JavaScript sont également exécutés dans d'autres contextes ([Node.js](/fr/docs/Glossaire/Node.js) par exemple).
 
-<p>Il a donc été question de fournir un mécanisme pour diviser les programmes JavaScript en plusieurs modules qu'on pourrait importer les uns dans les autres. Cette fonctionnalité était présente dans Node.js depuis longtemps et plusieurs bibliothèques et <em>frameworks</em> JavaScript ont permis l'utilisation de modules (<a href="https://en.wikipedia.org/wiki/CommonJS">CommonJS</a>, <a href="https://github.com/amdjs/amdjs-api/blob/master/AMD.md">AMD</a>, <a href="https://requirejs.org/">RequireJS</a> ou, plus récemment, <a href="https://webpack.github.io/">Webpack</a> et <a href="https://babeljs.io/">Babel</a>).</p>
+Il a donc été question de fournir un mécanisme pour diviser les programmes JavaScript en plusieurs modules qu'on pourrait importer les uns dans les autres. Cette fonctionnalité était présente dans Node.js depuis longtemps et plusieurs bibliothèques et _frameworks_ JavaScript ont permis l'utilisation de modules ([CommonJS](https://en.wikipedia.org/wiki/CommonJS), [AMD](https://github.com/amdjs/amdjs-api/blob/master/AMD.md), [RequireJS](https://requirejs.org/) ou, plus récemment, [Webpack](https://webpack.github.io/) et [Babel](https://babeljs.io/)).
 
-<p>Bonne nouvelle, les navigateurs ont également commencé à prendre en charge ces fonctionnalités nativement. C'est le sujet de ce guide.</p>
+Bonne nouvelle, les navigateurs ont également commencé à prendre en charge ces fonctionnalités nativement. C'est le sujet de ce guide.
 
-<p>Cette implémentation permettra aux navigateurs d'optimiser le chargement des modules, rendant le fonctionnement plus efficace qu'une bibliothèque tierce avec un traitement côté client des allers-retours sur le réseau.</p>
+Cette implémentation permettra aux navigateurs d'optimiser le chargement des modules, rendant le fonctionnement plus efficace qu'une bibliothèque tierce avec un traitement côté client des allers-retours sur le réseau.
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>L'utilisation des modules natifs JavaScript repose sur les instructions <code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/import">import</a></code> and <code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/export">export</a></code> dont vous pouvez voir l'état de la compatibilité ici :</p>
+L'utilisation des modules natifs JavaScript repose sur les instructions [`import`](/fr/docs/Web/JavaScript/Reference/Instructions/import) and [`export`](/fr/docs/Web/JavaScript/Reference/Instructions/export) dont vous pouvez voir l'état de la compatibilité ici :
 
-<h3 id="import"><code>import</code></h3>
+### `import`
 
-<p>{{Compat("javascript.statements.import")}}</p>
+{{Compat("javascript.statements.import")}}
 
-<h3 id="export"><code>export</code></h3>
+### `export`
 
-<p>{{Compat("javascript.statements.export")}}</p>
+{{Compat("javascript.statements.export")}}
 
-<h2 id="Commençons_par_un_exemple">Commençons par un exemple</h2>
+## Commençons par un exemple
 
-<p>Pour illustrer le fonctionnement des modules, nous avons créé <a href="https://github.com/mdn/js-examples/tree/master/modules">un ensemble d'exemples disponibles sur GitHub</a>. Ces exemples illustrent un ensemble de modules pour créer un élément {{htmlelement("canvas")}} sur une page web puis dessiner (et afficher des informations) sur les différentes formes du canevas.</p>
+Pour illustrer le fonctionnement des modules, nous avons créé [un ensemble d'exemples disponibles sur GitHub](https://github.com/mdn/js-examples/tree/master/modules). Ces exemples illustrent un ensemble de modules pour créer un élément {{htmlelement("canvas")}} sur une page web puis dessiner (et afficher des informations) sur les différentes formes du canevas.
 
-<p>Ces opérations sont assez simples mais nous les avons choisies pour nous concentrer plutôt sur le fonctionnement des modules.</p>
+Ces opérations sont assez simples mais nous les avons choisies pour nous concentrer plutôt sur le fonctionnement des modules.
 
-<div class="note">
-<p><strong>Note :</strong> Si vous souhaitez télécharger les exemples et les exécuter en local, vous devrez utiliser un serveur web local.</p>
-</div>
+> **Note :** Si vous souhaitez télécharger les exemples et les exécuter en local, vous devrez utiliser un serveur web local.
 
-<h2 id="Structure_de_lexemple">Structure de l'exemple</h2>
+## Structure de l'exemple
 
-<p>Dans notre premier exemple (cf. <a href="https://github.com/mdn/js-examples/tree/master/modules/basic-modules">basic-modules</a>), nous avons l'arborescence de fichier suivante :</p>
+Dans notre premier exemple (cf. [basic-modules](https://github.com/mdn/js-examples/tree/master/modules/basic-modules)), nous avons l'arborescence de fichier suivante :
 
-<pre>index.html
-main.mjs
-modules/
-    canvas.mjs
-    square.mjs</pre>
+    index.html
+    main.mjs
+    modules/
+        canvas.mjs
+        square.mjs
 
-<div class="note">
-<p><strong>Note :</strong> Tous les exemples de ce guide suivent la même structure.</p>
-</div>
+> **Note :** Tous les exemples de ce guide suivent la même structure.
 
-<p>Le répertoire dédié aux modules contient deux modules :</p>
+Le répertoire dédié aux modules contient deux modules :
 
-<ul>
- <li><code>canvas.mjs</code> — responsable de fonctions pour gérer le canevas
+- `canvas.mjs` — responsable de fonctions pour gérer le canevas
 
-  <ul>
-   <li><code>create()</code> — crée un canevas avec les dimensions souhaitées (<code>width</code> /  <code>height</code>) à l'intérieur d'un élément {{htmlelement("div")}} doté d'un identifiant et qui est ajouté à l'intérieur d'un élément indiqué. Cette fonction renvoie l'objet contenant le contexte du canevas et l'identifiant du conteneur.</li>
-   <li><code>createReportList()</code> — crée une liste non ordonnée à l'intérieur d'un élément indiqué et dans lequel on affiche des données. Cette fonction renvoie l'identifiant de la liste.</li>
-  </ul>
- </li>
- <li><code>square.mjs</code> :
-  <ul>
-   <li><code>name</code> — une constante qui est une chaîne de caractères : <code>"square"</code>.</li>
-   <li><code>draw()</code> — dessine un carré avec une taille/position/couleur données sur le canevas indiqué. Cette fonction renvoie un objet contenant la taille du carré, sa position et sa couleur.</li>
-   <li><code>reportArea()</code> — écrit la surface d'un carré dans une liste donnée en fonction de la longueur de son côté.</li>
-   <li><code>reportPerimeter()</code> — écrit le périmètre d'un carré dans une liste donnée en fonction de la longueur de son côté.</li>
-  </ul>
- </li>
-</ul>
+  - `create()` — crée un canevas avec les dimensions souhaitées (`width` /  `height`) à l'intérieur d'un élément {{htmlelement("div")}} doté d'un identifiant et qui est ajouté à l'intérieur d'un élément indiqué. Cette fonction renvoie l'objet contenant le contexte du canevas et l'identifiant du conteneur.
+  - `createReportList()` — crée une liste non ordonnée à l'intérieur d'un élément indiqué et dans lequel on affiche des données. Cette fonction renvoie l'identifiant de la liste.
 
-<div class="note">
-<p><strong>Note :</strong> Pour les modules JavaScript natifs, l'extension <code>.mjs</code> a son importance car elle permet d'importer des fichiers avec un type MIME <code>javascript/esm</code> (on pourra utiliser une autre extension qui fournira le type MIME <code>application/javascript</code>) afin d'éviter les erreurs liées à la vérification des types MIME. L'extension <code>.mjs</code> est notamment utile afin de distinguer plus clairement les scripts « classiques » des modules et pourra être exploitée par d'autres outils. Pour plus de détails, voir <a href="https://v8.dev/features/modules#mjs">cette note de Google</a>.</p>
-</div>
+- `square.mjs` :
 
-<h2 id="Exporter_des_fonctionnalités">Exporter des fonctionnalités</h2>
+  - `name` — une constante qui est une chaîne de caractères : `"square"`.
+  - `draw()` — dessine un carré avec une taille/position/couleur données sur le canevas indiqué. Cette fonction renvoie un objet contenant la taille du carré, sa position et sa couleur.
+  - `reportArea()` — écrit la surface d'un carré dans une liste donnée en fonction de la longueur de son côté.
+  - `reportPerimeter()` — écrit le périmètre d'un carré dans une liste donnée en fonction de la longueur de son côté.
 
-<p>Pour commencer et afin d'utiliser les fonctionnalités d'un module, on devra les exporter. Pour cela, on utilisera l'instruction <code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/export">export</a></code>.</p>
+> **Note :** Pour les modules JavaScript natifs, l'extension `.mjs` a son importance car elle permet d'importer des fichiers avec un type MIME `javascript/esm` (on pourra utiliser une autre extension qui fournira le type MIME `application/javascript`) afin d'éviter les erreurs liées à la vérification des types MIME. L'extension `.mjs` est notamment utile afin de distinguer plus clairement les scripts « classiques » des modules et pourra être exploitée par d'autres outils. Pour plus de détails, voir [cette note de Google](https://v8.dev/features/modules#mjs).
 
-<p>La méthode la plus simple consiste à placer cette instruction devant chaque valeur qu'on souhaite exporter, par exemple :</p>
+## Exporter des fonctionnalités
 
-<pre class="brush: js">export const name = 'square';
+Pour commencer et afin d'utiliser les fonctionnalités d'un module, on devra les exporter. Pour cela, on utilisera l'instruction [`export`](/fr/docs/Web/JavaScript/Reference/Instructions/export).
+
+La méthode la plus simple consiste à placer cette instruction devant chaque valeur qu'on souhaite exporter, par exemple :
+
+```js
+export const name = 'square';
 
 export function draw(ctx, length, x, y, color) {
   ctx.fillStyle = color;
@@ -101,148 +90,165 @@ export function draw(ctx, length, x, y, color) {
     y: y,
     color: color
   };
-}</pre>
+}
+```
 
-<p>Il est possible d'exporter des fonctions, des variables (qu'elles soient définies avec <code>var</code>, <code>let</code> ou <code>const</code>) et aussi des classes (que nous verrons par la suite). Les valeurs exportées doivent être présentes au plus haut niveau du script, il n'est pas possible d'utiliser <code>export</code> dans une fonction.</p>
+Il est possible d'exporter des fonctions, des variables (qu'elles soient définies avec `var`, `let` ou `const`) et aussi des classes (que nous verrons par la suite). Les valeurs exportées doivent être présentes au plus haut niveau du script, il n'est pas possible d'utiliser `export` dans une fonction.
 
-<p>Une méthode plus concise consiste à exporter l'ensemble des valeurs grâce à une seule instruction située à la fin du fichier : les valeurs sont séparées par des virgules et la liste est délimitée entre accolades :</p>
+Une méthode plus concise consiste à exporter l'ensemble des valeurs grâce à une seule instruction située à la fin du fichier : les valeurs sont séparées par des virgules et la liste est délimitée entre accolades :
 
-<pre class="brush: js">export { name, draw, reportArea, reportPerimeter };</pre>
+```js
+export { name, draw, reportArea, reportPerimeter };
+```
 
-<h2 id="Importer_des_fonctionnalités">Importer des fonctionnalités</h2>
+## Importer des fonctionnalités
 
-<p>Lorsque des fonctionnalités sont exportées par un premier module, on peut les importer dans un script afin de les utiliser. Voici la méthode la plus simple pour ce faire :</p>
+Lorsque des fonctionnalités sont exportées par un premier module, on peut les importer dans un script afin de les utiliser. Voici la méthode la plus simple pour ce faire :
 
-<pre class="brush: js">import { name, draw, reportArea, reportPerimeter } from './modules/square.mjs';</pre>
+```js
+import { name, draw, reportArea, reportPerimeter } from './modules/square.mjs';
+```
 
-<p>On utilise ici l'instruction <code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/import">import</a></code>, suivi d'une liste d'identifiants séparées par des virgules et délimitée par des accolades, suivie du mot-clé <code>from</code> puis du chemin vers le fichier du module. Le chemin est relatif à la racine du site. Dans notre cas, pour <code>basic-module</code>, on écrira <code>/js-examples/modules/basic-modules</code>.</p>
+On utilise ici l'instruction [`import`](/fr/docs/Web/JavaScript/Reference/Instructions/import), suivi d'une liste d'identifiants séparées par des virgules et délimitée par des accolades, suivie du mot-clé `from` puis du chemin vers le fichier du module. Le chemin est relatif à la racine du site. Dans notre cas, pour `basic-module`, on écrira `/js-examples/modules/basic-modules`.
 
-<p>Ici, nous avons écrit le chemin d'une façon légèrement différente : on utilise le point (<code>.</code>) afin d'indiquer « l'emplacement courant », suivi du chemin vers le fichier. Cela permet d'éviter d'avoir à écrire l'intégralité du chemin à chaque fois, c'est aussi plus court et cela permet de déplacer le script et le modules sans avoir à modifier les scripts.</p>
+Ici, nous avons écrit le chemin d'une façon légèrement différente : on utilise le point (`.`) afin d'indiquer « l'emplacement courant », suivi du chemin vers le fichier. Cela permet d'éviter d'avoir à écrire l'intégralité du chemin à chaque fois, c'est aussi plus court et cela permet de déplacer le script et le modules sans avoir à modifier les scripts.
 
-<p>Ainsi :</p>
+Ainsi :
 
-<pre>/js-examples/modules/basic-modules/modules/square.mjs</pre>
+    /js-examples/modules/basic-modules/modules/square.mjs
 
-<p>devient :</p>
+devient :
 
-<pre>./modules/square.mjs</pre>
+    ./modules/square.mjs
 
-<p>Vous pouvez voir ces lignes dans <code><a href="https://github.com/mdn/js-examples/blob/master/modules/basic-modules/main.js">main.mjs</a></code>.</p>
+Vous pouvez voir ces lignes dans [`main.mjs`](https://github.com/mdn/js-examples/blob/master/modules/basic-modules/main.js).
 
-<div class="note">
-<p><strong>Note :</strong> Pour certains systèmes de module, on peut omettre l'extension de fichier et le point (c'est-à-dire qu'on peut écrire <code>'/modules/square'</code>). Cela ne fonctionne pas pour les modules JavaScript !</p>
-</div>
+> **Note :** Pour certains systèmes de module, on peut omettre l'extension de fichier et le point (c'est-à-dire qu'on peut écrire `'/modules/square'`). Cela ne fonctionne pas pour les modules JavaScript !
 
-<p>Une fois les fonctionnalités importées dans le script, vous pouvez utiliser les valeurs dans votre script. Dans <code>main.mjs</code>, après les lignes d'import, on trouvera :</p>
+Une fois les fonctionnalités importées dans le script, vous pouvez utiliser les valeurs dans votre script. Dans `main.mjs`, après les lignes d'import, on trouvera :
 
-<pre class="brush: js">let myCanvas = create('myCanvas', document.body, 480, 320);
+```js
+let myCanvas = create('myCanvas', document.body, 480, 320);
 let reportList = createReportList(myCanvas.id);
 
 let square1 = draw(myCanvas.ctx, 50, 50, 100, 'blue');
 reportArea(square1.length, reportList);
 reportPerimeter(square1.length, reportList);
-</pre>
+```
 
-<h2 id="Charger_le_module_via_le_document_HTML">Charger le module via le document HTML</h2>
+## Charger le module via le document HTML
 
-<p>Il faut ensuite pouvoir charger le script <code>main.mjs</code> sur la page HTML. Pour cela, nous allons voir qu'il y a quelques différences avec le chargement d'un script « classique ».</p>
+Il faut ensuite pouvoir charger le script `main.mjs` sur la page HTML. Pour cela, nous allons voir qu'il y a quelques différences avec le chargement d'un script « classique ».
 
-<p>Tout d'abord, il est nécessaire d'indiquer <code>type="module"</code> dans l'élément {{htmlelement("script")}} afin d'indiquer qu'on charge des modules :</p>
+Tout d'abord, il est nécessaire d'indiquer `type="module"` dans l'élément {{htmlelement("script")}} afin d'indiquer qu'on charge des modules :
 
-<pre class="brush: js">&lt;script type="module" src="main.mjs"&gt;&lt;/script&gt;</pre>
+```js
+<script type="module" src="main.mjs"></script>
+```
 
-<p>Le script qu'on importe ici agit comme le module de plus haut niveau. Si on oublie ce type, Firefox déclenchera une erreur "<em>SyntaxError: import declarations may only appear at top level of a module</em>".</p>
+Le script qu'on importe ici agit comme le module de plus haut niveau. Si on oublie ce type, Firefox déclenchera une erreur "_SyntaxError: import declarations may only appear at top level of a module_".
 
-<p>Les instructions <code>import</code> et <code>export</code> ne peuvent être utilisées qu'à l'intérieur de modules et pas à l'intérieur de scripts « classiques ».</p>
+Les instructions `import` et `export` ne peuvent être utilisées qu'à l'intérieur de modules et pas à l'intérieur de scripts « classiques ».
 
-<div class="note">
-<p><strong>Note :</strong> Il est aussi possible d'importer des modules dans des scripts qui sont déclarés en incise si on indique bien <code>type="module"</code>. On pourra donc écrire <code>&lt;script type="module"&gt; //code du script utilisant les modules ici &lt;/script&gt;</code>.</p>
-</div>
+> **Note :** Il est aussi possible d'importer des modules dans des scripts qui sont déclarés en incise si on indique bien `type="module"`. On pourra donc écrire `<script type="module"> //code du script utilisant les modules ici </script>`.
 
-<h2 id="Différences_entre_les_modules_et_les_scripts_«_classiques_»">Différences entre les modules et les scripts « classiques »</h2>
+## Différences entre les modules et les scripts « classiques »
 
-<ul>
- <li>Attention aux tests sur un environnement local : si vous chargez le fichier HTML directement depuis le système de fichier dans le navigateur (en double-cliquant dessus par exemple, ce qui donnera une URL <code>file://</code>), vous rencontrerez des erreurs CORS pour des raisons de sécurité. Il faut donc un serveur local afin de pouvoir tester.</li>
- <li>On pourra avoir un comportement différent entre un même script utilisé comme un module et un script utilisé de façon « classique ». En effet, les modules utilisent automatiquement <a href="/fr/docs/Web/JavaScript/Reference/Strict_mode">le mode strict</a>.</li>
- <li>Il n'est pas nécessaire d'utiliser l'attribut <code>defer</code> (voir <a href="/fr/docs/Web/HTML/Element/script#Attributs">les attributs de <code>&lt;script&gt;</code></a>) lors du chargement d'un module, ceux-ci sont automatiquement chargés à la demande.</li>
- <li>Enfin, les fonctionnalités importées ne sont disponibles qu'au sein de la portée du script qui les utilise ! Les valeurs importées ne sont manipulables que depuis le script, elles ne sont pas rattachées à la portée globale. On ne pourra par exemple pas y accéder depuis la console JavaScript. Bien que les erreurs soient toujours indiquées dans les outils de développement, certaines techniques de débogage ne seront pas disponibles.</li>
-</ul>
+- Attention aux tests sur un environnement local : si vous chargez le fichier HTML directement depuis le système de fichier dans le navigateur (en double-cliquant dessus par exemple, ce qui donnera une URL `file://`), vous rencontrerez des erreurs CORS pour des raisons de sécurité. Il faut donc un serveur local afin de pouvoir tester.
+- On pourra avoir un comportement différent entre un même script utilisé comme un module et un script utilisé de façon « classique ». En effet, les modules utilisent automatiquement [le mode strict](/fr/docs/Web/JavaScript/Reference/Strict_mode).
+- Il n'est pas nécessaire d'utiliser l'attribut `defer` (voir [les attributs de `<script>`](/fr/docs/Web/HTML/Element/script#Attributs)) lors du chargement d'un module, ceux-ci sont automatiquement chargés à la demande.
+- Enfin, les fonctionnalités importées ne sont disponibles qu'au sein de la portée du script qui les utilise ! Les valeurs importées ne sont manipulables que depuis le script, elles ne sont pas rattachées à la portée globale. On ne pourra par exemple pas y accéder depuis la console JavaScript. Bien que les erreurs soient toujours indiquées dans les outils de développement, certaines techniques de débogage ne seront pas disponibles.
 
-<h2 id="Exports_par_défaut_et_exports_nommés">Exports par défaut et exports nommés</h2>
+## Exports par défaut et exports nommés
 
-<p>Jusqu'à présent, nous avons utilisé des <strong>exports nommés</strong> — chaque valeur est exportée avec un nom et c'est ce nom qui est également utilisé lorsqu'on réalise l'import.</p>
+Jusqu'à présent, nous avons utilisé des **exports nommés** — chaque valeur est exportée avec un nom et c'est ce nom qui est également utilisé lorsqu'on réalise l'import.
 
-<p>Il existe également un <strong>export par défaut</strong> — conçu pour simplifier l'export d'une fonction par module et pour faciliter l'interopérabilité avec les systèmes de module CommonJS et AMD (pour plus d'informations, voir <a href="https://tech.mozfr.org/post/2015/08/21/ES6-en-details-%3A-les-modules">ES6 en détails : les modules</a>).</p>
+Il existe également un **export par défaut** — conçu pour simplifier l'export d'une fonction par module et pour faciliter l'interopérabilité avec les systèmes de module CommonJS et AMD (pour plus d'informations, voir [ES6 en détails : les modules](https://tech.mozfr.org/post/2015/08/21/ES6-en-details-%3A-les-modules)).
 
-<p>Prenons un exemple pour comprendre le fonctionnement des exports par défaut. Dans <code>square.mjs</code>, on a une fonction intitulée <code>randomSquare()</code> qui crée un carré avec une taille/couleur/position aléatoires. On souhaite exporter cette fonction par défaut et on écrit donc ceci à la fin du fichier :</p>
+Prenons un exemple pour comprendre le fonctionnement des exports par défaut. Dans `square.mjs`, on a une fonction intitulée `randomSquare()` qui crée un carré avec une taille/couleur/position aléatoires. On souhaite exporter cette fonction par défaut et on écrit donc ceci à la fin du fichier :
 
-<pre class="brush: js">export default randomSquare;</pre>
+```js
+export default randomSquare;
+```
 
-<p>On notera ici l'absence d'accolades.</p>
+On notera ici l'absence d'accolades.
 
-<p>On aurait également pu ajouter <code>export default</code> devant le mot-clé <code>function</code> et la définir comme fonction anonyme :</p>
+On aurait également pu ajouter `export default` devant le mot-clé `function` et la définir comme fonction anonyme :
 
-<pre class="brush: js">export default function(ctx) {
+```js
+export default function(ctx) {
   ...
-}</pre>
+}
+```
 
-<p>Dans le fichier <code>main.mjs</code>, on importe la fonction par défaut avec cette ligne</p>
+Dans le fichier `main.mjs`, on importe la fonction par défaut avec cette ligne
 
-<pre class="brush: js">import randomSquare from './modules/square.mjs';</pre>
+```js
+import randomSquare from './modules/square.mjs';
+```
 
-<p>On voit ici aussi l'absence d'accolade car il n'y a qu'un seul export par défaut possible par module (et ici, on sait qu'il s'agit de <code>randomSquare</code>). La ligne ci-avant est en fait une notation raccourcie équivalente à :</p>
+On voit ici aussi l'absence d'accolade car il n'y a qu'un seul export par défaut possible par module (et ici, on sait qu'il s'agit de `randomSquare`). La ligne ci-avant est en fait une notation raccourcie équivalente à :
 
-<pre class="brush: js">import {default as randomSquare} from './modules/square.mjs';</pre>
+```js
+import {default as randomSquare} from './modules/square.mjs';
+```
 
-<div class="note">
-<p><strong>Note :</strong> Pour en savoir plus sur le renommage des objets exportés, voir ci-après {{anch("Renommage des imports et des exports")}}.</p>
-</div>
+> **Note :** Pour en savoir plus sur le renommage des objets exportés, voir ci-après {{anch("Renommage des imports et des exports")}}.
 
-<h2 id="Gestion_des_conflits_de_nommage">Gestion des conflits de nommage</h2>
+## Gestion des conflits de nommage
 
-<p>Jusqu'à présent, notre exemple fonctionne. Mais que se passerait-il si nous ajoutions un module permettant de dessiner une autre forme comme un cercle ou un triangle ? Ces formes disposeraient sans doute également de fonctions telles que <code>draw()</code>, <code>reportArea()</code>, etc. Si on essaie d'importer ces fonctions avec les mêmes noms dans le module de plus haut niveau, nous allons avoir des conflits et des erreurs.</p>
+Jusqu'à présent, notre exemple fonctionne. Mais que se passerait-il si nous ajoutions un module permettant de dessiner une autre forme comme un cercle ou un triangle ? Ces formes disposeraient sans doute également de fonctions telles que `draw()`, `reportArea()`, etc. Si on essaie d'importer ces fonctions avec les mêmes noms dans le module de plus haut niveau, nous allons avoir des conflits et des erreurs.
 
-<p>Heureusement, il existe différentes façons de résoudre ce problème.</p>
+Heureusement, il existe différentes façons de résoudre ce problème.
 
-<h3 id="Renommage_des_imports_et_des_exports">Renommage des imports et des exports</h3>
+### Renommage des imports et des exports
 
-<p>Entre les accolades utilisées pour les instructions <code>import</code> et <code>export</code>, on peut utiliser le mot-clé <code>as</code> avec un autre nom afin de modifier le nom par lequel on souhaite identifier la fonctionnalité.</p>
+Entre les accolades utilisées pour les instructions `import` et `export`, on peut utiliser le mot-clé `as` avec un autre nom afin de modifier le nom par lequel on souhaite identifier la fonctionnalité.
 
-<p>Ainsi, les deux fragments qui suivent permettraient d'obtenir le même résultat de façons différentes :</p>
+Ainsi, les deux fragments qui suivent permettraient d'obtenir le même résultat de façons différentes :
 
-<pre class="brush: js">// dans module.mjs
+```js
+// dans module.mjs
 export {
   fonction1 as nouveauNomDeFonction,
   fonction2 as autreNouveauNomDeFonction
 };
 
 // dans main.mjs
-import { nouveauNomDeFonction, autreNouveauNomDeFonction } from './modules/module.mjs';</pre>
+import { nouveauNomDeFonction, autreNouveauNomDeFonction } from './modules/module.mjs';
+```
 
-<pre class="brush: js">// dans module.mjs
+```js
+// dans module.mjs
 export { fonction1, fonction2 };
 
 // dans main.mjs
 import { fonction1 as nouveauNomDeFonction,
-         fonction2 as autreNouveauNomDeFonction } from './modules/module.mjs';</pre>
+         fonction2 as autreNouveauNomDeFonction } from './modules/module.mjs';
+```
 
-<p>Prenons un exemple concret. Dans le répertoire <code><a href="https://github.com/mdn/js-examples/tree/master/modules/renaming">renaming</a></code>, vous verrez le même système de modules que précédemment auquel nous avons ajouté <code>circle.mjs</code> et <code>triangle.mjs</code> afin de dessiner et d'écrire des informations sur des cercles et des triangles.</p>
+Prenons un exemple concret. Dans le répertoire [`renaming`](https://github.com/mdn/js-examples/tree/master/modules/renaming), vous verrez le même système de modules que précédemment auquel nous avons ajouté `circle.mjs` et `triangle.mjs` afin de dessiner et d'écrire des informations sur des cercles et des triangles.
 
-<p>Dans chaque module, on exporte les fonctionnalités avec des noms identiques : l'instruction  <code>export</code> utilisée est la même à chaque fin de fichier :</p>
+Dans chaque module, on exporte les fonctionnalités avec des noms identiques : l'instruction  `export` utilisée est la même à chaque fin de fichier :
 
-<pre class="brush: js">export { name, draw, reportArea, reportPerimeter };</pre>
+```js
+export { name, draw, reportArea, reportPerimeter };
+```
 
-<p>Lorsqu'on importe les valeurs dans <code>main.mjs</code>, si on essaie d'utiliser</p>
+Lorsqu'on importe les valeurs dans `main.mjs`, si on essaie d'utiliser
 
-<pre class="brush: js">import { name, draw, reportArea, reportPerimeter } from './modules/square.mjs';
+```js
+import { name, draw, reportArea, reportPerimeter } from './modules/square.mjs';
 import { name, draw, reportArea, reportPerimeter } from './modules/circle.mjs';
-import { name, draw, reportArea, reportPerimeter } from './modules/triangle.mjs';</pre>
+import { name, draw, reportArea, reportPerimeter } from './modules/triangle.mjs';
+```
 
-<p>Le navigateur déclenchera une erreur telle que "<em>SyntaxError: redeclaration of import name</em>" (Firefox).</p>
+Le navigateur déclenchera une erreur telle que "_SyntaxError: redeclaration of import name_" (Firefox).
 
-<p>Pour éviter ce problème, on renomme les imports afin qu'ils soient uniques :</p>
+Pour éviter ce problème, on renomme les imports afin qu'ils soient uniques :
 
-<pre class="brush: js">import { name as squareName,
+```js
+import { name as squareName,
          draw as drawSquare,
          reportArea as reportSquareArea,
          reportPerimeter as reportSquarePerimeter } from './modules/square.mjs';
@@ -255,60 +261,76 @@ import { name as circleName,
 import { name as triangleName,
         draw as drawTriangle,
         reportArea as reportTriangleArea,
-        reportPerimeter as reportTrianglePerimeter } from './modules/triangle.mjs';</pre>
+        reportPerimeter as reportTrianglePerimeter } from './modules/triangle.mjs';
+```
 
-<p>On aurait pu également résoudre le problème dans les fichiers de chaque module.</p>
+On aurait pu également résoudre le problème dans les fichiers de chaque module.
 
-<pre class="brush: js">// dans square.mjs
+```js
+// dans square.mjs
 export { name as squareName,
          draw as drawSquare,
          reportArea as reportSquareArea,
-         reportPerimeter as reportSquarePerimeter };</pre>
+         reportPerimeter as reportSquarePerimeter };
+```
 
-<pre class="brush: js">// dans main.mjs
-import { squareName, drawSquare, reportSquareArea, reportSquarePerimeter } from './modules/square.mjs';</pre>
+```js
+// dans main.mjs
+import { squareName, drawSquare, reportSquareArea, reportSquarePerimeter } from './modules/square.mjs';
+```
 
-<p>Les deux approches fonctionnent. C'est à vous de choisir le style. Toutefois, il est souvent plus pratique d'effectuer le renommage à l'import, notamment lorsqu'on importe des fonctionnalités de modules tiers sur lesquels on n'a pas le contrôle.</p>
+Les deux approches fonctionnent. C'est à vous de choisir le style. Toutefois, il est souvent plus pratique d'effectuer le renommage à l'import, notamment lorsqu'on importe des fonctionnalités de modules tiers sur lesquels on n'a pas le contrôle.
 
-<h3 id="Créer_un_objet_module">Créer un objet module</h3>
+### Créer un objet module
 
-<p>La méthode précédente fonctionne mais reste « brouillonne ». Pour faire mieux, on peut importer l'ensemble des fonctionnalités de chaque module dans un objet, de la façon suivante :</p>
+La méthode précédente fonctionne mais reste « brouillonne ». Pour faire mieux, on peut importer l'ensemble des fonctionnalités de chaque module dans un objet, de la façon suivante :
 
-<pre class="brush: js">import * as Module from './modules/module.mjs';</pre>
+```js
+import * as Module from './modules/module.mjs';
+```
 
-<p>Cela récupère tous les exports disponibles depuis <code>module.mjs</code> et les transforme en propriétés et méthodes rattachées à l'objet <code>Module</code> qui fournit alors un espace de noms (<em>namespace</em>) :</p>
+Cela récupère tous les exports disponibles depuis `module.mjs` et les transforme en propriétés et méthodes rattachées à l'objet `Module` qui fournit alors un espace de noms (_namespace_) :
 
-<pre class="brush: js">Module.function1()
+```js
+Module.function1()
 Module.function2()
-etc.</pre>
+etc.
+```
 
-<p>Là encore, prenons un exemple concret avec le répertoire <a href="https://github.com/mdn/js-examples/tree/master/modules/module-objects">module-objects</a>. Il s'agit du même exemple que précédemment mais qui a été réécrit afin de tirer parti de cette syntaxe. Dans les modules, les exports sont tous écrits ainsi :</p>
+Là encore, prenons un exemple concret avec le répertoire [module-objects](https://github.com/mdn/js-examples/tree/master/modules/module-objects). Il s'agit du même exemple que précédemment mais qui a été réécrit afin de tirer parti de cette syntaxe. Dans les modules, les exports sont tous écrits ainsi :
 
-<pre class="brush: js">export { name, draw, reportArea, reportPerimeter };</pre>
+```js
+export { name, draw, reportArea, reportPerimeter };
+```
 
-<p>En revanche, pour les imports, on les récupère ainsi :</p>
+En revanche, pour les imports, on les récupère ainsi :
 
-<pre class="brush: js">import * as Canvas from './modules/canvas.mjs';
+```js
+import * as Canvas from './modules/canvas.mjs';
 
 import * as Square from './modules/square.mjs';
 import * as Circle from './modules/circle.mjs';
-import * as Triangle from './modules/triangle.mjs';</pre>
+import * as Triangle from './modules/triangle.mjs';
+```
 
-<p>Dans chaque cas, on peut accéder aux imports comme propriétés des objets ainsi créés :</p>
+Dans chaque cas, on peut accéder aux imports comme propriétés des objets ainsi créés :
 
-<pre class="brush: js">let square1 = Square.draw(myCanvas.ctx, 50, 50, 100, 'blue');
+```js
+let square1 = Square.draw(myCanvas.ctx, 50, 50, 100, 'blue');
 Square.reportArea(square1.length, reportList);
-Square.reportPerimeter(square1.length, reportList);</pre>
+Square.reportPerimeter(square1.length, reportList);
+```
 
-<p>On obtient alors un code plus lisible.</p>
+On obtient alors un code plus lisible.
 
-<h2 id="Classes_et_modules">Classes et modules</h2>
+## Classes et modules
 
-<p>Comme mentionné avant, il est possible d'importer et d'exporter des classes. Cette méthode peut aussi être utilisée afin d'éviter les conflits de nommage. Elle s'avère notamment utile lorsque vous utilisez déjà des classes pour construire vos objets (cela permet de garder une certaine cohérence dans le style).</p>
+Comme mentionné avant, il est possible d'importer et d'exporter des classes. Cette méthode peut aussi être utilisée afin d'éviter les conflits de nommage. Elle s'avère notamment utile lorsque vous utilisez déjà des classes pour construire vos objets (cela permet de garder une certaine cohérence dans le style).
 
-<p>Pour voir le résultat obtenu, vous pouvez consulter le répertoire <a href="https://github.com/mdn/js-examples/tree/master/modules/classes">classes</a> du dépôt où l'ensemble a été réécrit pour tirer parti des classes ECMAScript. Ainsi, <code><a href="https://github.com/mdn/js-examples/blob/master/modules/classes/modules/square.js">square.mjs</a></code> contient désormais l'ensemble des fonctionnalités via une classe :</p>
+Pour voir le résultat obtenu, vous pouvez consulter le répertoire [classes](https://github.com/mdn/js-examples/tree/master/modules/classes) du dépôt où l'ensemble a été réécrit pour tirer parti des classes ECMAScript. Ainsi, [`square.mjs`](https://github.com/mdn/js-examples/blob/master/modules/classes/modules/square.js) contient désormais l'ensemble des fonctionnalités via une classe :
 
-<pre class="brush: js">class Square {
+```js
+class Square {
   constructor(ctx, listId, length, x, y, color) {
     ...
   }
@@ -318,115 +340,132 @@ Square.reportPerimeter(square1.length, reportList);</pre>
   }
 
   ...
-}</pre>
+}
+```
 
-<p>Il suffit d'exporter cette classe :</p>
+Il suffit d'exporter cette classe :
 
-<pre class="brush: js">export { Square };</pre>
+```js
+export { Square };
+```
 
-<p>Puis de l'importer ainsi dans <code><a href="https://github.com/mdn/js-examples/blob/master/modules/classes/main.js">main.mjs</a></code> :</p>
+Puis de l'importer ainsi dans [`main.mjs`](https://github.com/mdn/js-examples/blob/master/modules/classes/main.js) :
 
-<pre class="brush: js">import { Square } from './modules/square.mjs';</pre>
+```js
+import { Square } from './modules/square.mjs';
+```
 
-<p>Ensuite, on peut utiliser cette classe afin de dessiner le carré :</p>
+Ensuite, on peut utiliser cette classe afin de dessiner le carré :
 
-<pre class="brush: js">let square1 = new Square(myCanvas.ctx, myCanvas.listId, 50, 50, 100, 'blue');
+```js
+let square1 = new Square(myCanvas.ctx, myCanvas.listId, 50, 50, 100, 'blue');
 square1.draw();
 square1.reportArea();
-square1.reportPerimeter();</pre>
+square1.reportPerimeter();
+```
 
-<h2 id="Agréger_des_modules">Agréger des modules</h2>
+## Agréger des modules
 
-<p>Il arrivera qu'on veuille agréger des modules entre eux. On peut avoir plusieurs niveaux de dépendances et vouloir simplifier les choses en combinant différents sous-modules en un seul module parent. Pour cela, on pourra utiliser la notation raccourcie suivante :</p>
+Il arrivera qu'on veuille agréger des modules entre eux. On peut avoir plusieurs niveaux de dépendances et vouloir simplifier les choses en combinant différents sous-modules en un seul module parent. Pour cela, on pourra utiliser la notation raccourcie suivante :
 
-<pre class="brush: js">export * from 'x.mjs'
-export { name } from 'x.mjs'</pre>
+```js
+export * from 'x.mjs'
+export { name } from 'x.mjs'
+```
 
-<p>Pour voir cela en pratique, vous pouvez consulter le répertoire <a href="https://github.com/mdn/js-examples/tree/master/modules/module-aggregation">module-aggregation</a>. Dans cet exemple (construit sur le précédent qui utilise les classes), on a un module supplémentaire intitulé <code>shapes.mjs</code> qui agrège les fonctionnalités fournies par <code>circle.mjs</code>, <code>square.mjs</code> et <code>triangle.mjs</code>. Les sous-modules ont également été déplacés dans un répertoire <code>shapes</code> situé dans un répertoire <code>modules</code>. L'arborescence utilisée est donc :</p>
+Pour voir cela en pratique, vous pouvez consulter le répertoire [module-aggregation](https://github.com/mdn/js-examples/tree/master/modules/module-aggregation). Dans cet exemple (construit sur le précédent qui utilise les classes), on a un module supplémentaire intitulé `shapes.mjs` qui agrège les fonctionnalités fournies par `circle.mjs`, `square.mjs` et `triangle.mjs`. Les sous-modules ont également été déplacés dans un répertoire `shapes` situé dans un répertoire `modules`. L'arborescence utilisée est donc :
 
-<pre>modules/
-  canvas.mjs
-  shapes.mjs
-  shapes/
-    circle.mjs
-    square.mjs
-    triangle.mjs</pre>
+    modules/
+      canvas.mjs
+      shapes.mjs
+      shapes/
+        circle.mjs
+        square.mjs
+        triangle.mjs
 
-<p>Dans chaque sous-module, l'export aura la même forme :</p>
+Dans chaque sous-module, l'export aura la même forme :
 
-<pre class="brush: js">export { Square };</pre>
+```js
+export { Square };
+```
 
-<p>Pour l'agrégation au sein de <code><a href="https://github.com/mdn/js-examples/blob/master/modules/module-aggregation/modules/shapes.js">shapes.mjs</a></code>, on écrit les lignes suivantes :</p>
+Pour l'agrégation au sein de [`shapes.mjs`](https://github.com/mdn/js-examples/blob/master/modules/module-aggregation/modules/shapes.js), on écrit les lignes suivantes :
 
-<pre class="brush: js">export { Square } from './shapes/square.mjs';
+```js
+export { Square } from './shapes/square.mjs';
 export { Triangle } from './shapes/triangle.mjs';
-export { Circle } from './shapes/circle.mjs';</pre>
+export { Circle } from './shapes/circle.mjs';
+```
 
-<p>On récupère ainsi l'ensemble des exports de chaque module et on les rend disponibles via <code>shapes.mjs</code>.</p>
+On récupère ainsi l'ensemble des exports de chaque module et on les rend disponibles via `shapes.mjs`.
 
-<div class="note">
-<p><strong>Note :</strong> Cette notation ne permet que de rediriger les exports via le fichier. Les objets importés/exportés n'existent pas vraiment dans <code>shapes.mjs</code> et on ne peut donc pas écrire de code <em>utile</em> qui les manipule.</p>
-</div>
+> **Note :** Cette notation ne permet que de rediriger les exports via le fichier. Les objets importés/exportés n'existent pas vraiment dans `shapes.mjs` et on ne peut donc pas écrire de code _utile_ qui les manipule.
 
-<p>Dans le fichier <code>main.mjs</code>, on pourra alors remplacer :</p>
+Dans le fichier `main.mjs`, on pourra alors remplacer :
 
-<pre class="brush: js">import { Square } from './modules/square.mjs';
+```js
+import { Square } from './modules/square.mjs';
 import { Circle } from './modules/circle.mjs';
-import { Triangle } from './modules/triangle.mjs';</pre>
+import { Triangle } from './modules/triangle.mjs';
+```
 
-<p>par :</p>
+par :
 
-<pre class="brush: js">import { Square, Circle, Triangle } from './modules/shapes.mjs';</pre>
+```js
+import { Square, Circle, Triangle } from './modules/shapes.mjs';
+```
 
-<h2 id="Chargement_dynamique_de_modules">Chargement dynamique de modules</h2>
+## Chargement dynamique de modules
 
-<p>Cette nouvelle fonctionnalité permet aux navigateurs de charger les modules lorsqu'ils sont nécessaires plutôt que de tout précharger en avance de phase. Cette méthode offre de nombreux avantages quant aux performances. Voyons comment cela fonctionne.</p>
+Cette nouvelle fonctionnalité permet aux navigateurs de charger les modules lorsqu'ils sont nécessaires plutôt que de tout précharger en avance de phase. Cette méthode offre de nombreux avantages quant aux performances. Voyons comment cela fonctionne.
 
-<p>Pour utiliser cette fonctionnalité, on pourra utiliser <code>import()</code> comme une fonction et lui passer le chemin du module en argument. Cette fonction renverra <a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Promise">une promesse</a>, qui sera résolue en un module objet donnant accès aux exports.</p>
+Pour utiliser cette fonctionnalité, on pourra utiliser `import()` comme une fonction et lui passer le chemin du module en argument. Cette fonction renverra [une promesse](/fr/docs/Web/JavaScript/Reference/Objets_globaux/Promise), qui sera résolue en un module objet donnant accès aux exports.
 
-<pre class="brush: js">import('./modules/monModule.mjs')
-  .then((module) =&gt; {
+```js
+import('./modules/monModule.mjs')
+  .then((module) => {
     // Faire qqc avec le module.
-  });</pre>
+  });
+```
 
-<p>Dans nos exemples, regardons le répertoire <a href="https://github.com/mdn/js-examples/tree/master/modules/dynamic-module-imports">dynamic-module-imports</a>, également basé sur les classes. Cette fois, on ne dessine rien au chargement de l'exemple mais on ajoute trois boutons — "Circle", "Square" et "Triangle" — qui, lorsqu'ils seront utilisés, chargeront dynamiquement les modules nécessaires et les utiliseront pour charger la forme associée.</p>
+Dans nos exemples, regardons le répertoire [dynamic-module-imports](https://github.com/mdn/js-examples/tree/master/modules/dynamic-module-imports), également basé sur les classes. Cette fois, on ne dessine rien au chargement de l'exemple mais on ajoute trois boutons — "Circle", "Square" et "Triangle" — qui, lorsqu'ils seront utilisés, chargeront dynamiquement les modules nécessaires et les utiliseront pour charger la forme associée.
 
-<p>Dans cet exemple, nous avons uniquement modifié <a href="https://github.com/mdn/js-examples/blob/master/modules/dynamic-module-imports/index.html">index.html</a> et <a href="https://github.com/mdn/js-examples/blob/master/modules/dynamic-module-imports/main.js">main.js</a> — les exports restent les mêmes.</p>
+Dans cet exemple, nous avons uniquement modifié [index.html](https://github.com/mdn/js-examples/blob/master/modules/dynamic-module-imports/index.html) et [main.js](https://github.com/mdn/js-examples/blob/master/modules/dynamic-module-imports/main.js) — les exports restent les mêmes.
 
-<p>Dans <code>main.js</code>, on récupère une référence à chaque bouton en utilisant <code><a href="/fr/docs/Web/API/Document/querySelector">document.querySelector()</a></code>. Par exemple :</p>
+Dans `main.js`, on récupère une référence à chaque bouton en utilisant [`document.querySelector()`](/fr/docs/Web/API/Document/querySelector). Par exemple :
 
-<pre class="brush: js">let squareBtn = document.querySelector('.square');</pre>
+```js
+let squareBtn = document.querySelector('.square');
+```
 
-<p>Ensuite, on attache un gestionnaire d'évènement à chaque bouton afin qu'on puisse appuyer dessus. Le module correspondant est alors chargé dynamiquement et utilisé pour dessiner la forme :</p>
+Ensuite, on attache un gestionnaire d'évènement à chaque bouton afin qu'on puisse appuyer dessus. Le module correspondant est alors chargé dynamiquement et utilisé pour dessiner la forme :
 
-<pre class="brush: js">squareBtn.addEventListener('click', () =&gt; {
-  import('./modules/square.mjs').then((Module) =&gt; {
+```js
+squareBtn.addEventListener('click', () => {
+  import('./modules/square.mjs').then((Module) => {
     let square1 = new Module.Square(myCanvas.ctx, myCanvas.listId, 50, 50, 100, 'blue');
     square1.draw();
     square1.reportArea();
     square1.reportPerimeter();
   })
-});</pre>
+});
+```
 
-<p>On voit ici que, parce que la promesse renvoie un objet module à la résolution, la classe est une propriété de cet objet et qu'il faut ajouter cet espace de nom devant le constructeur exporté pour l'utiliser. Autrement dit, avec cette méthode, on doit ajouter <code>Module.</code> devant <code>Square</code> (plutôt que d'utiliser uniquement <code>Square</code>).</p>
+On voit ici que, parce que la promesse renvoie un objet module à la résolution, la classe est une propriété de cet objet et qu'il faut ajouter cet espace de nom devant le constructeur exporté pour l'utiliser. Autrement dit, avec cette méthode, on doit ajouter `Module.` devant `Square` (plutôt que d'utiliser uniquement `Square`).
 
-<h2 id="Diagnostiquer_les_problèmes_avec_les_modules">Diagnostiquer les problèmes avec les modules</h2>
+## Diagnostiquer les problèmes avec les modules
 
-<p>Voici quelques notes pour aider à comprendre et à diagnostiquer les problèmes parfois rencontrés avec les modules. N'hésitez pas à ajouter vos conseils à cette liste si vous en avez.</p>
+Voici quelques notes pour aider à comprendre et à diagnostiquer les problèmes parfois rencontrés avec les modules. N'hésitez pas à ajouter vos conseils à cette liste si vous en avez.
 
-<ul>
- <li>Comme indiqué ci-avant, les fichiers <code>.mjs</code> doivent être chargés avec le type MIME <code>javascript/esm</code> (ou avec un autre type MIME compatible JavaScript tel que <code>application/javascript</code>), sinon on aura une erreur lors de la vérification du type MIME.</li>
- <li>Si on essaie de charger des fichiers HTML en local à l'aide d'une URL <code>file://</code>, on aura des erreurs CORS relatives à la sécurité. Pour tester les modules, on doit donc mettre en place un serveur (ou, par exemple, utiliser les pages GitHub).</li>
- <li><code>.mjs</code> est une extension relativement récente et certains systèmes d'exploitation ne la reconnaîtront pas et/ou tenteront de la remplacer (ex. macOS pourra silencieusement ajouter un <code>.js</code> après le <code>.mjs</code>). Dans ce cas, afficher les extensions de tous les fichiers par défaut pourra permettre de vérifier.</li>
-</ul>
+- Comme indiqué ci-avant, les fichiers `.mjs` doivent être chargés avec le type MIME `javascript/esm` (ou avec un autre type MIME compatible JavaScript tel que `application/javascript`), sinon on aura une erreur lors de la vérification du type MIME.
+- Si on essaie de charger des fichiers HTML en local à l'aide d'une URL `file://`, on aura des erreurs CORS relatives à la sécurité. Pour tester les modules, on doit donc mettre en place un serveur (ou, par exemple, utiliser les pages GitHub).
+- `.mjs` est une extension relativement récente et certains systèmes d'exploitation ne la reconnaîtront pas et/ou tenteront de la remplacer (ex. macOS pourra silencieusement ajouter un `.js` après le `.mjs`). Dans ce cas, afficher les extensions de tous les fichiers par défaut pourra permettre de vérifier.
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li><a href="https://tech.mozfr.org/post/2018/04/06/Une-plongee-illustree-dans-les-modules-ECMAScript">Une plongée illustrée dans les modules ECMAScript</a></li>
- <li><a href="https://tech.mozfr.org/post/2015/08/21/ES6-en-details-%3A-les-modules">ES6 en détails : les modules</a></li>
- <li><a href="https://developers.google.com/web/fundamentals/primers/modules#mjs">Utiliser les modules JavaScript sur le Web</a>, un article par Addy Osmani et Mathias Bynens (en anglais)</li>
- <li>Livre de Axel Rauschmayer (en anglais) : <a href="http://exploringjs.com/es6/ch_modules.html">Exploring JS: Modules</a></li>
-</ul>
+- [Une plongée illustrée dans les modules ECMAScript](https://tech.mozfr.org/post/2018/04/06/Une-plongee-illustree-dans-les-modules-ECMAScript)
+- [ES6 en détails : les modules](https://tech.mozfr.org/post/2015/08/21/ES6-en-details-%3A-les-modules)
+- [Utiliser les modules JavaScript sur le Web](https://developers.google.com/web/fundamentals/primers/modules#mjs), un article par Addy Osmani et Mathias Bynens (en anglais)
+- Livre de Axel Rauschmayer (en anglais) : [Exploring JS: Modules](http://exploringjs.com/es6/ch_modules.html)
 
-<p>{{Previous("Web/JavaScript/Guide/Métaprogrammation")}}</p>
+{{Previous("Web/JavaScript/Guide/Métaprogrammation")}}
diff --git a/files/fr/web/javascript/guide/numbers_and_dates/index.md b/files/fr/web/javascript/guide/numbers_and_dates/index.md
index c80c7ce65e..33d7e90ae3 100644
--- a/files/fr/web/javascript/guide/numbers_and_dates/index.md
+++ b/files/fr/web/javascript/guide/numbers_and_dates/index.md
@@ -7,25 +7,26 @@ tags:
 translation_of: Web/JavaScript/Guide/Numbers_and_dates
 original_slug: Web/JavaScript/Guide/Nombres_et_dates
 ---
-<div>{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/Expressions_et_Op%C3%A9rateurs", "Web/JavaScript/Guide/Formatage_du_texte")}}</div>
+{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/Expressions_et_Op%C3%A9rateurs", "Web/JavaScript/Guide/Formatage_du_texte")}}
 
-<p>Ce chapitre illustre le fonctionnement des nombres et des dates en JavaScript grâce aux concepts, objets et fonctions utilisables avec ce langage. Cela inclut notamment l'écriture de nombre selon différentes bases (décimale, binaire, hexadécimale) et l'utilisation de l'objet global {{jsxref("Math")}}.</p>
+Ce chapitre illustre le fonctionnement des nombres et des dates en JavaScript grâce aux concepts, objets et fonctions utilisables avec ce langage. Cela inclut notamment l'écriture de nombre selon différentes bases (décimale, binaire, hexadécimale) et l'utilisation de l'objet global {{jsxref("Math")}}.
 
-<h2 id="Nombres">Nombres</h2>
+## Nombres
 
-<p>Les nombres en JavaScript sont implémentés comme des <a href="https://en.wikipedia.org/wiki/Double-precision_floating-point_format">nombres sur 64 bits à précision double selon le format IEEE-754</a> qui est un standard pour la représentation des nombres flottants et qui permet d'avoir jusqu'à 16 chiffres significatifs. Le type numérique possède également trois valeurs spéciales symboliques : +{{jsxref("Infinity")}}, -{{jsxref("Infinity")}} et {{jsxref("NaN")}} (pour désigner une valeur qui n'est pas un nombre).</p>
+Les nombres en JavaScript sont implémentés comme des [nombres sur 64 bits à précision double selon le format IEEE-754](https://en.wikipedia.org/wiki/Double-precision_floating-point_format) qui est un standard pour la représentation des nombres flottants et qui permet d'avoir jusqu'à 16 chiffres significatifs. Le type numérique possède également trois valeurs spéciales symboliques : +{{jsxref("Infinity")}}, -{{jsxref("Infinity")}} et {{jsxref("NaN")}} (pour désigner une valeur qui n'est pas un nombre).
 
-<p>Le format IEEE-754 permet de représenter des valeurs entre ±2^−1022 et ±2^+1023, ce qui correspond à des valeurs entre ±10^−308 et ±10^+308 avec une précision sur 53 bits. Les nombres entiers compris sur l'intervalle ±2^53 − 1 peuvent être représentés exactement.</p>
+Le format IEEE-754 permet de représenter des valeurs entre ±2^−1022 et ±2^+1023, ce qui correspond à des valeurs entre ±10^−308 et ±10^+308 avec une précision sur 53 bits. Les nombres entiers compris sur l'intervalle ±2^53 − 1 peuvent être représentés exactement.
 
-<p>Le type {{jsxref("BigInt")}} est une addition récente à JavaScript qui permet de représenter de grands entiers. Toutefois, il n'est pas possible de mélanger les <code>BigInt</code> et les nombres ({{jsxref("Number")}}) dans les mêmes opérations et on ne peut pas utiliser l'objet {{jsxref("Math")}} avec les valeurs <code>BigInt</code>.</p>
+Le type {{jsxref("BigInt")}} est une addition récente à JavaScript qui permet de représenter de grands entiers. Toutefois, il n'est pas possible de mélanger les `BigInt` et les nombres ({{jsxref("Number")}}) dans les mêmes opérations et on ne peut pas utiliser l'objet {{jsxref("Math")}} avec les valeurs `BigInt`.
 
-<p>Voir également <a href="/fr/docs/Web/JavaScript/Structures_de_données">les types de données et structures JavaScript</a> pour l'articulation des types primitifs en JavaScript.</p>
+Voir également [les types de données et structures JavaScript](/fr/docs/Web/JavaScript/Structures_de_données) pour l'articulation des types primitifs en JavaScript.
 
-<p>Il est possible d'utiliser quatre types de littéraux numériques : décimal, binaire, octal et hexadécimal.</p>
+Il est possible d'utiliser quatre types de littéraux numériques : décimal, binaire, octal et hexadécimal.
 
-<h3 id="Les_nombres_décimaux">Les nombres décimaux</h3>
+### Les nombres décimaux
 
-<pre class="brush: js">1234567980;
+```js
+1234567980;
 42;
 
 // Attention à l'utilisation des zéros
@@ -35,310 +36,242 @@ original_slug: Web/JavaScript/Guide/Nombres_et_dates
 0777; // en mode non-strict, analysé en base octale,
       // ce qui correspond
       // à 511 en base décimale
-</pre>
+```
 
-<p>On voit ici que les littéraux numériques qui commencent par un zéro (<code>0</code>) et contiennent un chiffre strictement inférieur à 8 après ce 0 sont analysés comme étant exprimés en base octale.</p>
+On voit ici que les littéraux numériques qui commencent par un zéro (`0`) et contiennent un chiffre strictement inférieur à 8 après ce 0 sont analysés comme étant exprimés en base octale.
 
-<h3 id="Les_nombres_binaires">Les nombres binaires</h3>
+### Les nombres binaires
 
-<p>Pour utiliser des nombres binaires, on utilise un littéral qui commence par un 0 suivi d'un b minuscule ou majuscule (<code>0b</code> ou <code>0B</code>). Si les chiffres qui suivent ce préfixe ne sont pas des 0 ou des 1, une exception {{jsxref("SyntaxError")}} sera levée.</p>
+Pour utiliser des nombres binaires, on utilise un littéral qui commence par un 0 suivi d'un b minuscule ou majuscule (`0b` ou `0B`). Si les chiffres qui suivent ce préfixe ne sont pas des 0 ou des 1, une exception {{jsxref("SyntaxError")}} sera levée.
 
-<pre class="brush: js">var FLT_BITSIGNE = 0b10000000000000000000000000000000; // 2147483648
+```js
+var FLT_BITSIGNE = 0b10000000000000000000000000000000; // 2147483648
 var FLT_EXPOSANT = 0b01111111100000000000000000000000; // 2139095040
 var FLT_MANTISSE = 0B00000000011111111111111111111111; // 8388607
-</pre>
+```
 
-<h3 id="Les_nombres_octaux">Les nombres octaux</h3>
+### Les nombres octaux
 
-<p>Pour utiliser des nombres en base octale, on utilisera un préfixe avec un <code>0</code>. Si les nombres qui suivent ce 0 ne sont pas compris entre 0 et 7 (au sens strict), le nombre sera interprété comme un nombre décimal.</p>
+Pour utiliser des nombres en base octale, on utilisera un préfixe avec un `0`. Si les nombres qui suivent ce 0 ne sont pas compris entre 0 et 7 (au sens strict), le nombre sera interprété comme un nombre décimal.
 
-<pre class="brush: js">var n = 0755; // 493 en base 10
+```js
+var n = 0755; // 493 en base 10
 var m = 0644; // 420 en base 10
-</pre>
+```
 
-<p>En mode strict, ECMAScript 5 interdit cette syntaxe octale. Cette syntaxe ne fait pas partie d'ECMAScript 5 mais est supportée par la majorité des navigateurs. Avec ECMAScript 2015 (ES6), il est possible de représenter un nombre en notation octale grâce au préfixe "<code>0o</code>" :</p>
+En mode strict, ECMAScript 5 interdit cette syntaxe octale. Cette syntaxe ne fait pas partie d'ECMAScript 5 mais est supportée par la majorité des navigateurs. Avec ECMAScript 2015 (ES6), il est possible de représenter un nombre en notation octale grâce au préfixe "`0o`" :
 
-<pre class="brush: js">var a = 0o10; // Notation octale pour ES2015</pre>
+```js
+var a = 0o10; // Notation octale pour ES2015
+```
 
-<h3 id="Les_nombres_hexadécimaux">Les nombres hexadécimaux</h3>
+### Les nombres hexadécimaux
 
-<p>Pour utiliser des nombres exprimés en base hexadécimale, on utilisera un préfixe avec un zéro suivi d'un x majuscule ou minuscule (<code>0x</code> ou <code>0X</code>). Si les chiffres qui suivent ce préfixe ne sont pas 0123456789ABCDEF, cela provoquera une exception {{jsxref("SyntaxError")}}.</p>
+Pour utiliser des nombres exprimés en base hexadécimale, on utilisera un préfixe avec un zéro suivi d'un x majuscule ou minuscule (`0x` ou `0X`). Si les chiffres qui suivent ce préfixe ne sont pas 0123456789ABCDEF, cela provoquera une exception {{jsxref("SyntaxError")}}.
 
-<pre class="brush: js">0xFFFFFFFFFFFFFFFFF // 295147905179352830000
+```js
+0xFFFFFFFFFFFFFFFFF // 295147905179352830000
 0x123456789ABCDEF   // 81985529216486900
 0XA                 // 10
-</pre>
+```
 
-<h3 id="Notation_scientifique">Notation scientifique</h3>
+### Notation scientifique
 
-<pre class="brush: js">1E3   // 100
+```js
+1E3   // 100
 2e6   // 2000000
 0.1e2 // 10
-</pre>
+```
 
-<h2 id="Lobjet_Number">L'objet <code>Number</code></h2>
+## L'objet `Number`
 
-<p>L'objet {{jsxref("Number")}} possède certaines propriétés représentant les constantes numériques telles que : la valeur maximale représentable en JavaScript, une valeur spéciale pour dire que la valeur numérique n'est pas un nombre et l'infini. Ces valeurs ne peuvent pas être modifiées, on pourra les utiliser de la façon suivante :</p>
+L'objet {{jsxref("Number")}} possède certaines propriétés représentant les constantes numériques telles que : la valeur maximale représentable en JavaScript, une valeur spéciale pour dire que la valeur numérique n'est pas un nombre et l'infini. Ces valeurs ne peuvent pas être modifiées, on pourra les utiliser de la façon suivante :
 
-<pre class="brush: js">var plusGrandNombre = Number.MAX_VALUE;
+```js
+var plusGrandNombre = Number.MAX_VALUE;
 var plusPetitNombre = Number.MIN_VALUE;
 var infini = Number.POSITIVE_INFINITY;
 var infiniNégatif = Number.NEGATIVE_INFINITY;
 var pasUnNombre = Number.NaN;
-</pre>
+```
 
-<p>On utilisera toujours ces valeurs directement avec l'objet natif <code>Number</code> (et non pas avec les propriétés d'une instance d'un objet <code>Number</code> qu'on aurait créé).</p>
+On utilisera toujours ces valeurs directement avec l'objet natif `Number` (et non pas avec les propriétés d'une instance d'un objet `Number` qu'on aurait créé).
 
-<p>Le tableau qui suit liste certaines des propriétés de <code>Number</code>.</p>
+Le tableau qui suit liste certaines des propriétés de `Number`.
 
 <table class="standard-table">
- <caption>Propriétés de <code>Number</code></caption>
- <tbody>
-  <tr>
-   <th scope="col">Propriété</th>
-   <th scope="col">Description</th>
-  </tr>
-  <tr>
-   <td>{{jsxref("Number.MAX_VALUE")}}</td>
-   <td>Le plus grand nombre qu'on peut représenter en JavaScript (<code>±1.7976931348623157e+308</code>).</td>
-  </tr>
-  <tr>
-   <td>{{jsxref("Number.MIN_VALUE")}}</td>
-   <td>Le plus petit nombre qu'on peut représenter en JavaScript (<code>±5e-324</code>).</td>
-  </tr>
-  <tr>
-   <td>{{jsxref("Number.NaN")}}</td>
-   <td>Une valeur spéciale signifiant que la valeur n'est pas un nombre.</td>
-  </tr>
-  <tr>
-   <td>{{jsxref("Number.NEGATIVE_INFINITY")}}</td>
-   <td>L'infini négatif, renvoyé lorsqu'on dépasse la valeur minimale.</td>
-  </tr>
-  <tr>
-   <td>{{jsxref("Number.POSITIVE_INFINITY")}}</td>
-   <td>L'infini positif, renvoyé lorsqu'on dépasse la valeur maximale.</td>
-  </tr>
-  <tr>
-   <td>{{jsxref("Number.EPSILON")}}</td>
-   <td>La différence entre 1 et la première valeur supérieure à 1 qui puisse être représentée comme {{jsxref("Number")}}. (<code>2.220446049250313e-16</code>)</td>
-  </tr>
-  <tr>
-   <td>{{jsxref("Number.MIN_SAFE_INTEGER")}}</td>
-   <td>Le plus petit entier qu'on puisse représenter en JavaScript. (−2^53 + 1 ou <code>−9007199254740991</code>)</td>
-  </tr>
-  <tr>
-   <td>{{jsxref("Number.MAX_SAFE_INTEGER")}}</td>
-   <td>
-    <p>L'entier le plus grand qu'on puisse représenter en JavaScript (+2^53 − 1 ou <code>+9007199254740991</code>)</p>
-   </td>
-  </tr>
- </tbody>
+  <caption>
+    Propriétés de
+    <code>Number</code>
+  </caption>
+  <tbody>
+    <tr>
+      <th scope="col">Propriété</th>
+      <th scope="col">Description</th>
+    </tr>
+    <tr>
+      <td>{{jsxref("Number.MAX_VALUE")}}</td>
+      <td>
+        Le plus grand nombre qu'on peut représenter en JavaScript
+        (<code>±1.7976931348623157e+308</code>).
+      </td>
+    </tr>
+    <tr>
+      <td>{{jsxref("Number.MIN_VALUE")}}</td>
+      <td>
+        Le plus petit nombre qu'on peut représenter en JavaScript
+        (<code>±5e-324</code>).
+      </td>
+    </tr>
+    <tr>
+      <td>{{jsxref("Number.NaN")}}</td>
+      <td>Une valeur spéciale signifiant que la valeur n'est pas un nombre.</td>
+    </tr>
+    <tr>
+      <td>{{jsxref("Number.NEGATIVE_INFINITY")}}</td>
+      <td>L'infini négatif, renvoyé lorsqu'on dépasse la valeur minimale.</td>
+    </tr>
+    <tr>
+      <td>{{jsxref("Number.POSITIVE_INFINITY")}}</td>
+      <td>L'infini positif, renvoyé lorsqu'on dépasse la valeur maximale.</td>
+    </tr>
+    <tr>
+      <td>{{jsxref("Number.EPSILON")}}</td>
+      <td>
+        La différence entre 1 et la première valeur supérieure à 1 qui puisse
+        être représentée comme {{jsxref("Number")}}.
+        (<code>2.220446049250313e-16</code>)
+      </td>
+    </tr>
+    <tr>
+      <td>{{jsxref("Number.MIN_SAFE_INTEGER")}}</td>
+      <td>
+        Le plus petit entier qu'on puisse représenter en JavaScript. (−2^53 + 1
+        ou <code>−9007199254740991</code>)
+      </td>
+    </tr>
+    <tr>
+      <td>{{jsxref("Number.MAX_SAFE_INTEGER")}}</td>
+      <td>
+        <p>
+          L'entier le plus grand qu'on puisse représenter en JavaScript (+2^53 −
+          1 ou <code>+9007199254740991</code>)
+        </p>
+      </td>
+    </tr>
+  </tbody>
 </table>
 
-<table class="standard-table">
- <caption>Méthodes de <code>Number</code></caption>
- <tbody>
-  <tr>
-   <th>Méthode</th>
-   <th>Description</th>
-  </tr>
-  <tr>
-   <td>{{jsxref("Number.parseFloat()")}}</td>
-   <td>Analyse un argument qui est une chaîne de caractères et renvoie un nombre décimal. Cette méthode est équivalente à la fonction {{jsxref("parseFloat", "parseFloat()")}}.</td>
-  </tr>
-  <tr>
-   <td>{{jsxref("Number.parseInt()")}}</td>
-   <td>Analyse un argument qui est une chaîne de caractères et renvoie un entier exprimé dans une base donnée. Cette méthode est équivalente à la fonction {{jsxref("parseInt", "parseInt()")}}.</td>
-  </tr>
-  <tr>
-   <td>{{jsxref("Number.isFinite()")}}</td>
-   <td>Détermine si la valeur passée en argument est un nombre fini.</td>
-  </tr>
-  <tr>
-   <td>{{jsxref("Number.isInteger()")}}</td>
-   <td>Détermine si la valeur passée en argument est un nombre entier.</td>
-  </tr>
-  <tr>
-   <td>{{jsxref("Number.isNaN()")}}</td>
-   <td>Détermine si la valeur passée en argument est {{jsxref("NaN")}}. Cette version est plus robuste que la fonction globale {{jsxref("Objets_globaux/isNaN", "isNaN()")}}.</td>
-  </tr>
-  <tr>
-   <td>{{jsxref("Number.isSafeInteger()")}}</td>
-   <td>Détermine si la valeur fournie est un nombre qu'il est possible de représenter comme un entier sans perdre d'information.</td>
-  </tr>
- </tbody>
-</table>
+| Méthode                                          | Description                                                                                                                                                                                           |
+| ------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| {{jsxref("Number.parseFloat()")}}     | Analyse un argument qui est une chaîne de caractères et renvoie un nombre décimal. Cette méthode est équivalente à la fonction {{jsxref("parseFloat", "parseFloat()")}}.                  |
+| {{jsxref("Number.parseInt()")}}         | Analyse un argument qui est une chaîne de caractères et renvoie un entier exprimé dans une base donnée. Cette méthode est équivalente à la fonction {{jsxref("parseInt", "parseInt()")}}. |
+| {{jsxref("Number.isFinite()")}}         | Détermine si la valeur passée en argument est un nombre fini.                                                                                                                                         |
+| {{jsxref("Number.isInteger()")}}     | Détermine si la valeur passée en argument est un nombre entier.                                                                                                                                       |
+| {{jsxref("Number.isNaN()")}}             | Détermine si la valeur passée en argument est {{jsxref("NaN")}}. Cette version est plus robuste que la fonction globale {{jsxref("Objets_globaux/isNaN", "isNaN()")}}.          |
+| {{jsxref("Number.isSafeInteger()")}} | Détermine si la valeur fournie est un nombre qu'il est possible de représenter comme un entier sans perdre d'information.                                                                             |
 
-<p>Le prototype de <code>Number</code> fournit certaines méthodes pour exprimer les valeurs représentées par les objets <code>Number</code> dans différents formats. Le tableau suivant liste certaines de ces méthodes de <code>Number.prototype</code>.</p>
+Le prototype de `Number` fournit certaines méthodes pour exprimer les valeurs représentées par les objets `Number` dans différents formats. Le tableau suivant liste certaines de ces méthodes de `Number.prototype`.
 
-<table class="standard-table">
- <caption>Méthodes of <code>Number.prototype</code></caption>
- <thead>
-  <tr>
-   <th scope="col">Méthode</th>
-   <th scope="col">Description</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td>{{jsxref("Number.toExponential", "toExponential()")}}</td>
-   <td>Renvoie une chaîne de caractères représentant le nombre en notation exponentielle.</td>
-  </tr>
-  <tr>
-   <td>{{jsxref("Number.toFixed", "toFixed()")}}</td>
-   <td>Renvoie une chaîne de caractères représentant le nombre en notation à point fixe.</td>
-  </tr>
-  <tr>
-   <td>{{jsxref("Number.toPrecision", "toPrecision()")}}</td>
-   <td>Renvoie une chaîne de caractères représentant le nombre en notation à point fixe avec une précision donnée.</td>
-  </tr>
- </tbody>
-</table>
+| Méthode                                                                  | Description                                                                                                 |
+| ------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------- |
+| {{jsxref("Number.toExponential", "toExponential()")}} | Renvoie une chaîne de caractères représentant le nombre en notation exponentielle.                          |
+| {{jsxref("Number.toFixed", "toFixed()")}}                 | Renvoie une chaîne de caractères représentant le nombre en notation à point fixe.                           |
+| {{jsxref("Number.toPrecision", "toPrecision()")}}         | Renvoie une chaîne de caractères représentant le nombre en notation à point fixe avec une précision donnée. |
 
-<h2 id="Lobjet_Math">L'objet <code>Math</code></h2>
+## L'objet `Math`
 
-<p>L'objet natif {{jsxref("Math")}} possède des propriétés et des méthodes statiques pour représenter des constantes et des fonctions mathématiques. Ainsi, la propriété <code>PI</code> de l'objet <code>Math</code> représente la valeur de la constante <math><semantics><mi>π</mi><annotation encoding="TeX">\pi</annotation></semantics></math> (3.141...), on peut l'utiliser dans les applications avec :</p>
+L'objet natif {{jsxref("Math")}} possède des propriétés et des méthodes statiques pour représenter des constantes et des fonctions mathématiques. Ainsi, la propriété `PI` de l'objet `Math` représente la valeur de la constante <math><semantics><mi>π</mi><annotation encoding="TeX">\pi</annotation></semantics></math> (3.141...), on peut l'utiliser dans les applications avec :
 
-<pre class="brush: js">Math.PI
-</pre>
+```js
+Math.PI
+```
 
-<p>De la même façon, les fonctions mathématiques usuelles sont des méthodes de <code>Math</code>. On retrouve par exemple les fonctions trigonométriques, logarithmiques et exponentielles ainsi que d'autres fonctions. Si on souhaite utiliser la fonction sinus, on pourra écrire :</p>
+De la même façon, les fonctions mathématiques usuelles sont des méthodes de `Math`. On retrouve par exemple les fonctions trigonométriques, logarithmiques et exponentielles ainsi que d'autres fonctions. Si on souhaite utiliser la fonction sinus, on pourra écrire :
 
-<pre class="brush: js">Math.sin(1.56)
-</pre>
+```js
+Math.sin(1.56)
+```
 
-<div class="note">
-<p><strong>Note :</strong> Les méthodes trigonométriques de <code>Math</code> prennent des arguments exprimés en radians.</p>
-</div>
+> **Note :** Les méthodes trigonométriques de `Math` prennent des arguments exprimés en radians.
 
-<p>Le tableau suivant liste les méthodes de l'objet <code>Math</code>.</p>
+Le tableau suivant liste les méthodes de l'objet `Math`.
 
-<table class="standard-table">
- <caption>Méthodes de <code>Math</code></caption>
- <tbody>
-  <tr>
-   <th scope="col">Méthode</th>
-   <th scope="col">Description</th>
-  </tr>
-  <tr>
-   <td>{{jsxref("Math.abs", "abs()")}}</td>
-   <td>Valeur absolue</td>
-  </tr>
-  <tr>
-   <td>{{jsxref("Math.sin", "sin()")}}, {{jsxref("Math.cos", "cos()")}}, {{jsxref("Math.tan", "tan()")}}</td>
-   <td>Fonctions trigonométriques standards (les arguments sont exprimés en radians)</td>
-  </tr>
-  <tr>
-   <td>{{jsxref("Math.asin", "asin()")}}, {{jsxref("Math.acos", "acos()")}}, {{jsxref("Math.atan", "atan()")}}, {{jsxref("Math.atan2", "atan2()")}}</td>
-   <td>Fonctions trigonométriques inverses (les valeurs renvoyées sont exprimées en radians)</td>
-  </tr>
-  <tr>
-   <td>{{jsxref("Math.sinh", "sinh()")}}, {{jsxref("Math.cosh", "cosh()")}}, {{jsxref("Math.tanh", "tanh()")}}</td>
-   <td>Fonctions trigonométriques hyperboliques (les arguments sont exprimés en radians)</td>
-  </tr>
-  <tr>
-   <td>{{jsxref("Math.asinh", "asinh()")}}, {{jsxref("Math.acosh", "acosh()")}}, {{jsxref("Math.atanh", "atanh()")}}</td>
-   <td>Fonctions trigonométriques hyperboliques inverses (les valeurs renvoyées sont exprimées en radians).</td>
-  </tr>
-  <tr>
-   <td>{{jsxref("Math.pow", "pow()")}}, {{jsxref("Math.exp", "exp()")}}, {{jsxref("Math.expm1", "expm1()")}}, {{jsxref("Math.log10", "log10()")}}, {{jsxref("Math.log1p", "log1p()")}}, {{jsxref("Math.log2", "log2()")}}</td>
-   <td>Fonctions exponentielles et logarithmiques</td>
-  </tr>
-  <tr>
-   <td>{{jsxref("Math.floor", "floor()")}}, {{jsxref("Math.ceil", "ceil()")}}</td>
-   <td>Renvoie le plus petit/grand entier inférieur/supérieur ou égal à l'argument donné</td>
-  </tr>
-  <tr>
-   <td>{{jsxref("Math.min", "min()")}}, {{jsxref("Math.max", "max()")}}</td>
-   <td>Renvoie le plus petit (resp. grand) nombre d'une liste de nombres séparés par des virgules</td>
-  </tr>
-  <tr>
-   <td>{{jsxref("Math.random", "random()")}}</td>
-   <td>Renvoie un nombre aléatoire compris entre 0 et 1</td>
-  </tr>
-  <tr>
-   <td>{{jsxref("Math.round", "round()")}}, {{jsxref("Math.fround", "fround()")}}, {{jsxref("Math.trunc", "trunc()")}},</td>
-   <td>Fonctions d'arrondis et de troncature</td>
-  </tr>
-  <tr>
-   <td>{{jsxref("Math.sqrt", "sqrt()")}}, {{jsxref("Math.cbrt", "cbrt()")}}, {{jsxref("Math.hypot", "hypot()")}}</td>
-   <td>Racine carrée, cubique et racine carrée de la somme des carrés des arguments</td>
-  </tr>
-  <tr>
-   <td>{{jsxref("Math.sign", "sign()")}}</td>
-   <td>Renvoie le signe d'un nombre et indique si la valeur est négative, positive ou nulle</td>
-  </tr>
-  <tr>
-   <td>{{jsxref("Math.clz32", "clz32()")}},<br>
-    {{jsxref("Math.imul", "imul()")}}</td>
-   <td>Le nombre de zéros qui commencent un nombre sur 32 bits en représentation binaire.<br>
-    La résultat de la multiplication de deux arguments sur 32 bits effectuée comme en C.</td>
-  </tr>
- </tbody>
-</table>
+| Méthode                                                                                                                                                                                                                                                                                | Description                                                                                                                                                             |
+| -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| {{jsxref("Math.abs", "abs()")}}                                                                                                                                                                                                                                               | Valeur absolue                                                                                                                                                          |
+| {{jsxref("Math.sin", "sin()")}}, {{jsxref("Math.cos", "cos()")}}, {{jsxref("Math.tan", "tan()")}}                                                                                                                                                           | Fonctions trigonométriques standards (les arguments sont exprimés en radians)                                                                                           |
+| {{jsxref("Math.asin", "asin()")}}, {{jsxref("Math.acos", "acos()")}}, {{jsxref("Math.atan", "atan()")}}, {{jsxref("Math.atan2", "atan2()")}}                                                                                             | Fonctions trigonométriques inverses (les valeurs renvoyées sont exprimées en radians)                                                                                   |
+| {{jsxref("Math.sinh", "sinh()")}}, {{jsxref("Math.cosh", "cosh()")}}, {{jsxref("Math.tanh", "tanh()")}}                                                                                                                                               | Fonctions trigonométriques hyperboliques (les arguments sont exprimés en radians)                                                                                       |
+| {{jsxref("Math.asinh", "asinh()")}}, {{jsxref("Math.acosh", "acosh()")}}, {{jsxref("Math.atanh", "atanh()")}}                                                                                                                                   | Fonctions trigonométriques hyperboliques inverses (les valeurs renvoyées sont exprimées en radians).                                                                    |
+| {{jsxref("Math.pow", "pow()")}}, {{jsxref("Math.exp", "exp()")}}, {{jsxref("Math.expm1", "expm1()")}}, {{jsxref("Math.log10", "log10()")}}, {{jsxref("Math.log1p", "log1p()")}}, {{jsxref("Math.log2", "log2()")}} | Fonctions exponentielles et logarithmiques                                                                                                                              |
+| {{jsxref("Math.floor", "floor()")}}, {{jsxref("Math.ceil", "ceil()")}}                                                                                                                                                                                         | Renvoie le plus petit/grand entier inférieur/supérieur ou égal à l'argument donné                                                                                       |
+| {{jsxref("Math.min", "min()")}}, {{jsxref("Math.max", "max()")}}                                                                                                                                                                                                     | Renvoie le plus petit (resp. grand) nombre d'une liste de nombres séparés par des virgules                                                                              |
+| {{jsxref("Math.random", "random()")}}                                                                                                                                                                                                                                       | Renvoie un nombre aléatoire compris entre 0 et 1                                                                                                                        |
+| {{jsxref("Math.round", "round()")}}, {{jsxref("Math.fround", "fround()")}}, {{jsxref("Math.trunc", "trunc()")}},                                                                                                                                  | Fonctions d'arrondis et de troncature                                                                                                                                   |
+| {{jsxref("Math.sqrt", "sqrt()")}}, {{jsxref("Math.cbrt", "cbrt()")}}, {{jsxref("Math.hypot", "hypot()")}}                                                                                                                                           | Racine carrée, cubique et racine carrée de la somme des carrés des arguments                                                                                            |
+| {{jsxref("Math.sign", "sign()")}}                                                                                                                                                                                                                                           | Renvoie le signe d'un nombre et indique si la valeur est négative, positive ou nulle                                                                                    |
+| {{jsxref("Math.clz32", "clz32()")}}, {{jsxref("Math.imul", "imul()")}}                                                                                                                                                                                         | Le nombre de zéros qui commencent un nombre sur 32 bits en représentation binaire. La résultat de la multiplication de deux arguments sur 32 bits effectuée comme en C. |
 
-<p>À la différence des autres objets, on ne crée pas d'objet de type <code>Math</code>. Ses propriétés sont statiques, on les appelle donc toujours depuis l'objet <code>Math</code>.</p>
+À la différence des autres objets, on ne crée pas d'objet de type `Math`. Ses propriétés sont statiques, on les appelle donc toujours depuis l'objet `Math`.
 
-<h2 id="Lobjet_Date">L'objet <code>Date</code></h2>
+## L'objet `Date`
 
-<p>JavaScript ne possède pas de type primitif pour représenter des dates. Cependant l'objet {{jsxref("Date")}} et ses méthodes permettent de manipuler des dates et des heures au sein d'une application. L'objet <code>Date</code> possède de nombreuses méthodes pour définir, modifier, obtenir des dates. Il ne possède pas de propriétés.</p>
+JavaScript ne possède pas de type primitif pour représenter des dates. Cependant l'objet {{jsxref("Date")}} et ses méthodes permettent de manipuler des dates et des heures au sein d'une application. L'objet `Date` possède de nombreuses méthodes pour définir, modifier, obtenir des dates. Il ne possède pas de propriétés.
 
-<p>JavaScript gère les dates de façon similaire à Java. Les deux langages possèdent de nombreuses méthodes en commun et les deux langages stockent les dates selon les nombres de millisecondes écoulées depuis le premier janvier 1970 à 00h00:00.</p>
+JavaScript gère les dates de façon similaire à Java. Les deux langages possèdent de nombreuses méthodes en commun et les deux langages stockent les dates selon les nombres de millisecondes écoulées depuis le premier janvier 1970 à 00h00:00.
 
-<p>L'objet <code>Date</code> permet de représenter des dates allant de -100 000 000 jours jusqu'à +100 000 000 jours par rapport au premier janvier 1970 UTC.</p>
+L'objet `Date` permet de représenter des dates allant de -100 000 000 jours jusqu'à +100 000 000 jours par rapport au premier janvier 1970 UTC.
 
-<p>Pour créer un objet <code>Date</code>, on utilisera la syntaxe suivante :</p>
+Pour créer un objet `Date`, on utilisera la syntaxe suivante :
 
-<pre class="brush: js">var monObjetDate = new Date([paramètres]);
-</pre>
+```js
+var monObjetDate = new Date([paramètres]);
+```
 
-<p>avec <code>monObjetDate</code> étant le nom de l'objet à créer, cela peut être un nouvel objet ou une propriété d'un objet existant.</p>
+avec `monObjetDate` étant le nom de l'objet à créer, cela peut être un nouvel objet ou une propriété d'un objet existant.
 
-<p>Lorsqu'on appelle <code>Date</code> sans le mot-clé <code>new</code>, cela renvoie la date fournie sous la forme d'une chaîne de caractères.</p>
+Lorsqu'on appelle `Date` sans le mot-clé `new`, cela renvoie la date fournie sous la forme d'une chaîne de caractères.
 
-<p>Les <code>paramètres</code> qui peuvent être utilisés sont :</p>
+Les `paramètres` qui peuvent être utilisés sont :
 
-<ul>
- <li>Aucun paramètre : l'objet créé représentera la date et l'heure courante.</li>
- <li>Une chaîne de caractères représentant une date au format suivant : "jour, année heures:minutes:secondes". Par exemple <code>var noël95 = new Date("December 25, 1995 13:30:00")</code>. Si les valeurs pour les heures, minutes ou secondes sont absentes, elles vaudront 0 par défaut.</li>
- <li>Un ensemble de valeurs entières pour l'année, le mois et le jour : <code>var noël95 = new Date(1995, 11, 25)</code>.</li>
- <li>Un ensemble de valeurs entières pour l'année, le mois, le jour, l'heure, les minutes et les secondes : <code>var noël95 = new Date(1995, 11, 25, 9, 30, 0);</code>.</li>
-</ul>
+- Aucun paramètre : l'objet créé représentera la date et l'heure courante.
+- Une chaîne de caractères représentant une date au format suivant : "jour, année heures:minutes:secondes". Par exemple `var noël95 = new Date("December 25, 1995 13:30:00")`. Si les valeurs pour les heures, minutes ou secondes sont absentes, elles vaudront 0 par défaut.
+- Un ensemble de valeurs entières pour l'année, le mois et le jour : `var noël95 = new Date(1995, 11, 25)`.
+- Un ensemble de valeurs entières pour l'année, le mois, le jour, l'heure, les minutes et les secondes : `var noël95 = new Date(1995, 11, 25, 9, 30, 0);`.
 
-<h3 id="Méthodes_de_lobjet_Date">Méthodes de l'objet <code>Date</code></h3>
+### Méthodes de l'objet `Date`
 
-<p>Les méthodes de l'objet <code>Date</code> se répartissent en différentes catégories :</p>
+Les méthodes de l'objet `Date` se répartissent en différentes catégories :
 
-<ul>
- <li>celles utilisées pour définir et modifier les valeurs des objets <code>Date</code> (mutateurs).</li>
- <li>celles utilisées pour obtenir des informations à partir des objets <code>Date</code> (accesseurs).</li>
- <li>celles utilisées pour convertir les objets <code>Date</code> sous différents formats (souvent en chaînes de caractères).</li>
- <li>celles utilisées pour analyser et convertir des chaînes de caractères représentant des dates.</li>
-</ul>
+- celles utilisées pour définir et modifier les valeurs des objets `Date` (mutateurs).
+- celles utilisées pour obtenir des informations à partir des objets `Date` (accesseurs).
+- celles utilisées pour convertir les objets `Date` sous différents formats (souvent en chaînes de caractères).
+- celles utilisées pour analyser et convertir des chaînes de caractères représentant des dates.
 
-<p>Avec les accesseurs et les mutateurs, il est possible d'obtenir ou de modifier séparément les secondes, les minutes, les heures, le jour du mois ou de la semaine, le mois et l'année. Il existe une méthode <code>getDay</code> qui renvoie le jour de la semaine mais il n'existe pas de méthode réciproque <code>setDay</code> car le jour de la semaine est automatiquement déterminé. Ces méthodes utilisent des entiers pour représenter les valeurs utilisées :</p>
+Avec les accesseurs et les mutateurs, il est possible d'obtenir ou de modifier séparément les secondes, les minutes, les heures, le jour du mois ou de la semaine, le mois et l'année. Il existe une méthode `getDay` qui renvoie le jour de la semaine mais il n'existe pas de méthode réciproque `setDay` car le jour de la semaine est automatiquement déterminé. Ces méthodes utilisent des entiers pour représenter les valeurs utilisées :
 
-<ul>
- <li>Pour les secondes et les minutes : 0 à 59</li>
- <li>Pour les heures : 0 à 23</li>
- <li>Pour les jours : 0 (dimanche) à 6 (samedi)</li>
- <li>Pour les dates : 1 à 31 (jour du mois)</li>
- <li>Pour les mois : 0 (janvier) à 11 (décembre)</li>
- <li>Pour les années : les années à partir de 1900</li>
-</ul>
+- Pour les secondes et les minutes : 0 à 59
+- Pour les heures : 0 à 23
+- Pour les jours : 0 (dimanche) à 6 (samedi)
+- Pour les dates : 1 à 31 (jour du mois)
+- Pour les mois : 0 (janvier) à 11 (décembre)
+- Pour les années : les années à partir de 1900
 
-<p>Ainsi, si on définit la date suivante :</p>
+Ainsi, si on définit la date suivante :
 
-<pre class="brush: js">var noël95 = new Date("December 25, 1995");
-</pre>
+```js
+var noël95 = new Date("December 25, 1995");
+```
 
-<p><code>noël95.getMonth()</code> renverra 11, et <code>noël95.getFullYear()</code> renverra 1995.</p>
+`noël95.getMonth()` renverra 11, et `noël95.getFullYear()` renverra 1995.
 
-<p>Les méthodes <code>getTime</code> et <code>setTime</code> peuvent être utiles pour comparer des dates entre elles. La méthode <code>getTime</code> renvoie le nombre de millisecondes écoulées depuis le premier janvier 1970 à 00:00:00 pour l'objet <code>Date</code>.</p>
+Les méthodes `getTime` et `setTime` peuvent être utiles pour comparer des dates entre elles. La méthode `getTime` renvoie le nombre de millisecondes écoulées depuis le premier janvier 1970 à 00:00:00 pour l'objet `Date`.
 
-<p>Par exemple, les instructions suivantes affichent le nombre de jours qui restent pour l'année courante :</p>
+Par exemple, les instructions suivantes affichent le nombre de jours qui restent pour l'année courante :
 
-<pre class="brush: js">var aujourdhui = new Date();
+```js
+var aujourdhui = new Date();
 
 // On définit le jour et le mois
 var finAnnée = new Date(1995, 11, 31, 23, 59, 59, 999);
@@ -352,41 +285,44 @@ var msParJour = 24 * 60 * 60 * 1000;
 // On renvoie le nombre de jours restants dans l'année
 var joursRestants = (finAnnée.getTime() - aujourdhui.getTime()) / msParJour;
 
-joursRestants = Math.round(joursRestants);</pre>
+joursRestants = Math.round(joursRestants);
+```
 
-<p>Cet exemple crée un objet <code>Date</code> nommé <code>aujourdhui</code> qui contient la date du jour. On crée ensuite un objet <code>Date</code> nommé <code>finAnnée</code> pour lequel on définit ensuite l'année avec l'année courante. Après, on calcule le nombre de millisecondes qui s'écoulent dans une journée. Enfin, on calcule le nombre de jours entre <code>aujourdhui</code> et <code>finAnnée</code> en utilisant <code>getTime</code> puis on arrondit le tout pour avoir un nombre de jours.</p>
+Cet exemple crée un objet `Date` nommé `aujourdhui` qui contient la date du jour. On crée ensuite un objet `Date` nommé `finAnnée` pour lequel on définit ensuite l'année avec l'année courante. Après, on calcule le nombre de millisecondes qui s'écoulent dans une journée. Enfin, on calcule le nombre de jours entre `aujourdhui` et `finAnnée` en utilisant `getTime` puis on arrondit le tout pour avoir un nombre de jours.
 
-<p>La méthode <code>parse</code> est utile lorsqu'on souhaite affecter des valeurs temporelles à partir de chaînes de caractères. Par exemple, dans le code qui suit, on utilise les méthodes <code>parse</code> et <code>setTime</code> pour affecter la valeur d'une date à un objet <code>IPOdate</code> :</p>
+La méthode `parse` est utile lorsqu'on souhaite affecter des valeurs temporelles à partir de chaînes de caractères. Par exemple, dans le code qui suit, on utilise les méthodes `parse` et `setTime` pour affecter la valeur d'une date à un objet `IPOdate` :
 
-<pre class="brush: js">var IPOdate = new Date();
+```js
+var IPOdate = new Date();
 IPOdate.setTime(Date.parse("Aug 9, 1995"));
-</pre>
+```
 
-<h3 id="Exemple_dutilisation_de_lobjet_Date">Exemple d'utilisation de l'objet <code>Date</code></h3>
+### Exemple d'utilisation de l'objet `Date`
 
-<p>Dans l'exemple qui suit, la fonction <code>JSClock()</code> renvoie le temps au format d'une horloge numérique représentant les heures sur 12 heures :</p>
+Dans l'exemple qui suit, la fonction `JSClock()` renvoie le temps au format d'une horloge numérique représentant les heures sur 12 heures :
 
-<pre class="brush: js">function JSClock() {
+```js
+function JSClock() {
   var temps = new Date();
   var heures = temps.getHours();
   var minutes = temps.getMinutes();
   var secondes = temps.getSeconds();
-  var calc = "" + (heures &gt; 12) ? heures - 12 : heures);
+  var calc = "" + (heures > 12) ? heures - 12 : heures);
   if (heures == 0)
     calc = "12";
-  calc += ((minutes &lt; 10) ? ":0" : ":") + minutes;
-  calc += ((secondes &lt; 10) ? ":0" : ":") + secondes;
-  calc += (heures &gt;= 12) ? " P.M." : " A.M.";
+  calc += ((minutes < 10) ? ":0" : ":") + minutes;
+  calc += ((secondes < 10) ? ":0" : ":") + secondes;
+  calc += (heures >= 12) ? " P.M." : " A.M.";
   return calc;
 }
-</pre>
+```
 
-<p>Pour commencer, la fonction <code>JSClock</code> crée un objet <code>Date</code> appelé <code>temps</code> qui représente la date et l'heure à l'instant où la fonction est exécutée. Ensuite, les méthodes <code>getHours</code>, <code>getMinutes</code>, et <code>getSeconds</code> sont appelées afin d'affecter les valeurs correspondantes à <code>heures</code>, <code>minute</code>s, et <code>secondes</code>.</p>
+Pour commencer, la fonction `JSClock` crée un objet `Date` appelé `temps` qui représente la date et l'heure à l'instant où la fonction est exécutée. Ensuite, les méthodes `getHours`, `getMinutes`, et `getSeconds` sont appelées afin d'affecter les valeurs correspondantes à `heures`, `minute`s, et `secondes`.
 
-<p>Les quatre instructions suivantes permettent de construire une chaîne de caractères à partir de la valeur temporelle. La première instruction crée une variable <code>calc</code> et lui affecte une valeur avec une expression conditionnelle : si <code>heures</code> est supérieure à 12, on affichera (<code>heures - 12</code>), sinon on affichera l'heure sauf si c'est 0 auquel cas on affichera 12.</p>
+Les quatre instructions suivantes permettent de construire une chaîne de caractères à partir de la valeur temporelle. La première instruction crée une variable `calc` et lui affecte une valeur avec une expression conditionnelle : si `heures` est supérieure à 12, on affichera (`heures - 12`), sinon on affichera l'heure sauf si c'est 0 auquel cas on affichera 12.
 
-<p>L'instruction qui suit concatène la valeur de <code>minutes</code> à <code>calc</code>. Si la valeur de <code>minutes</code> est inférieure à 10, l'expression conditionnelle ajoutera une chaîne avec un zéro pour que la valeur soit affichée avec deux chiffres. De la même façon, l'instruction qui suit concatène la valeur de <code>calc</code> avec les secondes.</p>
+L'instruction qui suit concatène la valeur de `minutes` à `calc`. Si la valeur de `minutes` est inférieure à 10, l'expression conditionnelle ajoutera une chaîne avec un zéro pour que la valeur soit affichée avec deux chiffres. De la même façon, l'instruction qui suit concatène la valeur de `calc` avec les secondes.
 
-<p>Enfin, une expression conditionnelle est utilisée pour ajouter "P.M." à <code>calc</code> si <code>heures</code> vaut 12 ou plus, sinon ce sera la chaîne "A.M." qui sera ajoutée à la fin de <code>calc</code>.</p>
+Enfin, une expression conditionnelle est utilisée pour ajouter "P.M." à `calc` si `heures` vaut 12 ou plus, sinon ce sera la chaîne "A.M." qui sera ajoutée à la fin de `calc`.
 
-<p>{{PreviousNext("Web/JavaScript/Guide/Expressions_et_Op%C3%A9rateurs", "Web/JavaScript/Guide/Formatage_du_texte")}}</p>
+{{PreviousNext("Web/JavaScript/Guide/Expressions_et_Op%C3%A9rateurs", "Web/JavaScript/Guide/Formatage_du_texte")}}
diff --git a/files/fr/web/javascript/guide/regular_expressions/assertions/index.md b/files/fr/web/javascript/guide/regular_expressions/assertions/index.md
index a16c6b48ce..1e1dbb1a9d 100644
--- a/files/fr/web/javascript/guide/regular_expressions/assertions/index.md
+++ b/files/fr/web/javascript/guide/regular_expressions/assertions/index.md
@@ -9,99 +9,130 @@ tags:
 translation_of: Web/JavaScript/Guide/Regular_Expressions/Assertions
 original_slug: Web/JavaScript/Guide/Expressions_régulières/Assertions
 ---
-<p>{{jsSidebar("JavaScript Guide")}}{{draft}}</p>
+{{jsSidebar("JavaScript Guide")}}{{draft}}
 
-<p>Les assertions indiquent les conditions selon lesquelles il est possible d'avoir une correspondance (contenu situé avant la correspondance, situé après ou expressions conditionnelles).</p>
+Les assertions indiquent les conditions selon lesquelles il est possible d'avoir une correspondance (contenu situé avant la correspondance, situé après ou expressions conditionnelles).
 
-<h2 id="Types">Types</h2>
+## Types
 
-<div class="blockIndicator note">
-<p><strong>Note :</strong> Le caractère <code>?</code> peut également être utilisé comme quantificateur.</p>
-</div>
+> **Note :** Le caractère `?` peut également être utilisé comme quantificateur.
 
 <table class="standard-table">
- <thead>
-  <tr>
-   <th scope="col">Caractères</th>
-   <th scope="col">Signification</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td><code>x(?=y)</code></td>
-   <td>
-    <p>Correspond à 'x' seulement s'il est suivi de 'y'. On appelle cela un test de succession (<em>lookahead</em>).</p>
-
-    <p>Ainsi, <code>/Jack(?=Sparrow)/</code> correspond à 'Jack' seulement s'il est suivi de 'Sparrow'. <code>/Jack(?=Sparrow|Bauer)/</code> correspond à 'Jack' seulement s'il est suivi de 'Sparrow' ou de 'Bauer'. Cependant, ni 'Sparrow' ni 'Bauer' ne feront partie de la correspondance.</p>
-   </td>
-  </tr>
-  <tr>
-   <td><code>x(?!y)</code></td>
-   <td>
-    <p>Correspond à 'x' seulement si 'x' n'est pas suivi de 'y'.</p>
-
-    <p>Ainsi, <code>/\d+(?!\.)/</code> correspond à un nombre qui n'est pas suivi par un point, cette expression utilisée avec <code>la chaîne 3.141</code> correspondra pour '141' mais pas pour '3.141'.</p>
-   </td>
-  </tr>
-  <tr>
-   <td><code>(?&lt;=y)x</code></td>
-   <td>
-    <p>Correspond à <code><em>x</em></code> seulement si <code><em>x</em></code> est précédé par <code><em>y</em></code>. C'est ce qu'on appelle une recherche arrière (<em>lookbehind</em>).</p>
-
-    <p>Ainsi /<code>(?&lt;=Jack)Sprat/</code> correspond à "Sprat" seulement s'il est précédé de "Jack".<br>
-     <code>/(?&lt;=Jack|Tom)Sprat/</code> correspond à "Sprat" seulement s'il est précédé de "Jack" ou "Tom".<br>
-     Toutefois, "Jack" et "Tom" ne feront pas partie de la correspondance.</p>
-   </td>
-  </tr>
-  <tr>
-   <td><code>(?&lt;!y)x</code></td>
-   <td>
-    <p>Correspond à <code><em>x</em></code> uniquement si <code><em>x</em></code> n'est pas précédé par <code><em>y</em></code> (parfois appelée en anglais <em>negated lookbehind</em>)<em>.</em></p>
-
-    <p>Ainsi, <code>/(?&lt;!-)\d+/</code> correspondra à un nombre seulement si celui-ci n'est pas précédé d'un signe moins.<br>
-     <code>/(?&lt;!-)\d+/.exec('3')</code> cible "3".<br>
-      <code>/(?&lt;!-)\d+/.exec('-3')</code>  ne trouve aucune correspondance car le nombre est précédé d'un signe</p>
-   </td>
-  </tr>
- </tbody>
+  <thead>
+    <tr>
+      <th scope="col">Caractères</th>
+      <th scope="col">Signification</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td><code>x(?=y)</code></td>
+      <td>
+        <p>
+          Correspond à 'x' seulement s'il est suivi de 'y'. On appelle cela un
+          test de succession (<em>lookahead</em>).
+        </p>
+        <p>
+          Ainsi, <code>/Jack(?=Sparrow)/</code> correspond à 'Jack' seulement
+          s'il est suivi de 'Sparrow'.
+          <code>/Jack(?=Sparrow|Bauer)/</code> correspond à 'Jack' seulement
+          s'il est suivi de 'Sparrow' ou de 'Bauer'. Cependant, ni 'Sparrow' ni
+          'Bauer' ne feront partie de la correspondance.
+        </p>
+      </td>
+    </tr>
+    <tr>
+      <td><code>x(?!y)</code></td>
+      <td>
+        <p>Correspond à 'x' seulement si 'x' n'est pas suivi de 'y'.</p>
+        <p>
+          Ainsi, <code>/\d+(?!\.)/</code> correspond à un nombre qui n'est pas
+          suivi par un point, cette expression utilisée avec
+          <code>la chaîne 3.141</code> correspondra pour '141' mais pas pour
+          '3.141'.
+        </p>
+      </td>
+    </tr>
+    <tr>
+      <td><code>(?&#x3C;=y)x</code></td>
+      <td>
+        <p>
+          Correspond à <code><em>x</em></code> seulement si
+          <code><em>x</em></code> est précédé par <code><em>y</em></code
+          >. C'est ce qu'on appelle une recherche arrière (<em>lookbehind</em>).
+        </p>
+        <p>
+          Ainsi /<code>(?&#x3C;=Jack)Sprat/</code> correspond à "Sprat"
+          seulement s'il est précédé de "Jack".<br /><code
+            >/(?&#x3C;=Jack|Tom)Sprat/</code
+          >
+          correspond à "Sprat" seulement s'il est précédé de "Jack" ou "Tom".<br />Toutefois,
+          "Jack" et "Tom" ne feront pas partie de la correspondance.
+        </p>
+      </td>
+    </tr>
+    <tr>
+      <td><code>(?&#x3C;!y)x</code></td>
+      <td>
+        <p>
+          Correspond à <code><em>x</em></code> uniquement si
+          <code><em>x</em></code> n'est pas précédé par
+          <code><em>y</em></code> (parfois appelée en anglais
+          <em>negated lookbehind</em>)<em>.</em>
+        </p>
+        <p>
+          Ainsi, <code>/(?&#x3C;!-)\d+/</code> correspondra à un nombre
+          seulement si celui-ci n'est pas précédé d'un signe moins.<br /><code
+            >/(?&#x3C;!-)\d+/.exec('3')</code
+          >
+          cible "3".<br /> <code>/(?&#x3C;!-)\d+/.exec('-3')</code>  ne trouve
+          aucune correspondance car le nombre est précédé d'un signe
+        </p>
+      </td>
+    </tr>
+  </tbody>
 </table>
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Assertion_avant_(lookahead)">Assertion avant (<em>lookahead</em>)</h3>
+### Assertion avant (_lookahead_)
 
-<pre class="brush: js">let regex = /Premier(?= test)/g;
+```js
+let regex = /Premier(?= test)/g;
 
 console.log('Premier test'.match(regex)); // [ 'Premier' ]
 console.log('Premier truc'.match(regex)); // null
 console.log("Voici le Premier test de l'année.".match(regex)); // [ 'Premier' ]
 console.log('Voici le Premier truc du mois.'.match(regex)); // null
-</pre>
+```
 
-<h3 id="Assertion_avant_négative">Assertion avant négative</h3>
+### Assertion avant négative
 
-<p>L'expression rationnelle <code>/\d+(?!\.)/</code> permettra de rechercher plusieurs chiffres si ceux-ci ne sont pas suivis d'un point décimal. Ainsi, <code>/\d+(?!\.)/.exec('3.141')</code> trouvera la sous-chaîne "141" mais pas "3."</p>
+L'expression rationnelle `/\d+(?!\.)/` permettra de rechercher plusieurs chiffres si ceux-ci ne sont pas suivis d'un point décimal. Ainsi, `/\d+(?!\.)/.exec('3.141')` trouvera la sous-chaîne "141" mais pas "3."
 
-<pre class="brush: js">console.log(/\d+(?!\.)/g.exec('3.141')); // [ '141', index: 2, input: '3.141' ]
-</pre>
+```js
+console.log(/\d+(?!\.)/g.exec('3.141')); // [ '141', index: 2, input: '3.141' ]
+```
 
-<h3 id="Signification_différente_de_'!'_entre_les_assertions_et_les_intervalles">Signification différente de <code>'?!'</code> entre les assertions et les intervalles</h3>
+### Signification différente de `'?!'` entre les assertions et les intervalles
 
-<p>La combinaison de caractères <code>?!</code> a un sens différent entre les <a href="/fr/docs/Web/JavaScript/Guide/Expressions_régulières/Assertions">assertions</a> <code>/x(?!y)/</code> et les <a href="/fr/docs/Web/JavaScript/Guide/Expressions_régulières/Groupes_et_intervalles">intervalles</a> <code>[^?!]</code>.</p>
+La combinaison de caractères `?!` a un sens différent entre les [assertions](/fr/docs/Web/JavaScript/Guide/Expressions_régulières/Assertions) `/x(?!y)/` et les [intervalles](/fr/docs/Web/JavaScript/Guide/Expressions_régulières/Groupes_et_intervalles) `[^?!]`.
 
-<pre class="brush: js">let orangePasCitron = "Voulez-vous avoir une orange? Oui, je ne veux pas avoir de citron!";
+```js
+let orangePasCitron = "Voulez-vous avoir une orange? Oui, je ne veux pas avoir de citron!";
 
 let choixPasCitron = /[^?!]+avoir(?! un citron)[^?!]+[?!]/gi
 console.log(orangePasCitron.match(choixPasCitron)); // [ 'Voulez-vous avoir une orange?' ]
 
 let choixPasOrange = /[^?!]+avoir(?! une orange)[^?!]+[?!]/gi
 console.log(orangePasCitron.match(choixPasOrange)); // [ 'Oui, je ne veux pas avoir de citron!' ]
-</pre>
+```
 
-<h3 id="Assertion_arrière_(lookbehind)">Assertion arrière (<em>lookbehind</em>)</h3>
+### Assertion arrière (_lookbehind_)
 
-<pre class="brush: js">let oranges = ['espèce orange A ', 'sorte orange B', 'espèce orange C',];
+```js
+let oranges = ['espèce orange A ', 'sorte orange B', 'espèce orange C',];
 
-let especesOranges = oranges.filter( fruit =&gt; fruit.match(/(?&lt;=espèce )orange/));
+let especesOranges = oranges.filter( fruit => fruit.match(/(?<=espèce )orange/));
 console.log(especesOranges); // [ 'espèce orange A ', 'espèce orange C' ]
-</pre>
+```
diff --git a/files/fr/web/javascript/guide/regular_expressions/character_classes/index.md b/files/fr/web/javascript/guide/regular_expressions/character_classes/index.md
index ba3e075bce..1d37d5b70d 100644
--- a/files/fr/web/javascript/guide/regular_expressions/character_classes/index.md
+++ b/files/fr/web/javascript/guide/regular_expressions/character_classes/index.md
@@ -9,173 +9,255 @@ tags:
 translation_of: Web/JavaScript/Guide/Regular_Expressions/Character_Classes
 original_slug: Web/JavaScript/Guide/Expressions_régulières/Classes_de_caractères
 ---
-<p>{{jsSidebar("JavaScript Guide")}}{{draft}}</p>
+{{jsSidebar("JavaScript Guide")}}{{draft}}
 
-<p>Les classes de caractères permettent de distinguer différents ensembles de caractères dans les expressions rationnelles (par exemple les chiffres d'une part et les lettres d'autre part).</p>
+Les classes de caractères permettent de distinguer différents ensembles de caractères dans les expressions rationnelles (par exemple les chiffres d'une part et les lettres d'autre part).
 
-<h2 id="Types">Types</h2>
+## Types
 
 <table class="standard-table">
- <thead>
-  <tr>
-   <th scope="col">Caractères</th>
-   <th scope="col">Signification</th>
-  </tr>
- </thead>
- <tbody>
- </tbody>
- <tbody>
-  <tr>
-   <td><code>.</code></td>
-   <td>
-    <p>Par défaut, (Le point) correspond à n'importe quel caractère excepté un caractère de saut de ligne.</p>
-
-    <p>Ainsi, <code>/.n/</code> correspond à  'un' et 'en' dans "Un baobab nain en cours de  croissance" mais pas à 'nain'.</p>
-
-    <p>Si le marqueur <code>s</code> (<em>dotAll</em>) est utilisé, le point correspondra également aux caractères de saut de ligne.</p>
-
-    <p>Le marqueur <code>m</code> ne modifie pas le comportement du point.</p>
-
-    <p>Attention, si on utilise le point dans <a href="/fr/docs/Web/JavaScript/Guide/Expressions_régulières/Groupes_et_intervalles">un intervalle de caractères</a>, il n'aura plus cette signification spéciale.</p>
-   </td>
-  </tr>
-  <tr>
-   <td><code>\d</code></td>
-   <td>
-    <p>Correspond à un chiffre et est équivalent à <code>[0-9]</code>.</p>
-
-    <p>Ainsi, <code>/\d/</code> ou <code>/[0-9]/</code> correspond à '2' dans "H2O est la molécule de l'eau".</p>
-   </td>
-  </tr>
-  <tr>
-   <td><code>\D</code></td>
-   <td>
-    <p>Correspond à tout caractère qui n'est pas un chiffre et est équivalent à<code> [^0-9]</code>.</p>
-
-    <p>Ainsi, <code>/\D/</code> ou <code>/[^0-9]/</code> correspond à 'H' dans "H2O est la molécule de l'eau".</p>
-   </td>
-  </tr>
-  <tr>
-   <td><code>\w</code></td>
-   <td>
-    <p>Correspond à n'importe quel caractère alphanumérique de l'alphabet latin, y compris le tiret bas. C'est équivalent à <code>[A-Za-z0-9_]</code>.</p>
-
-    <p>Ainsi, <code>/\w/</code> correspond à 'l' dans "licorne", à '5' dans "5,28€", et à '3' dans "3D."</p>
-   </td>
-  </tr>
-  <tr>
-   <td><code>\W</code></td>
-   <td>
-    <p>Correspond à n'importe quel caractère n'étant pas un caractère de l'alphabet latin ou le tiret bas. Cela est équivalent à <code>[^A-Za-z0-9_]</code>.</p>
-
-    <p>Ainsi, <code>/\W/</code> ou <code>/[^A-Za-z0-9_]/</code> correspond à '%' dans "50%."</p>
-   </td>
-  </tr>
-  <tr>
-   <td><code>\s</code></td>
-   <td>
-    <p>Correspond à un blanc (cela comprend les espace, tabulation, saut de ligne ou saut de page). C'est équivalent à <code>[ \f\n\r\t\v\u00a0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff]</code>.</p>
-
-    <p>Ainsi, <code>/\s\w*/</code> correspond à ' toto' dans "truc toto".</p>
-   </td>
-  </tr>
-  <tr>
-   <td><code>\S</code></td>
-   <td>
-    <p>Correspond à un caractère qui n'est pas un blanc. C'est équivalent à <code>[^ \f\n\r\t\v\u00a0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff]</code>.</p>
-
-    <p>Ainsi, <code>/\S\w*/</code> correspond à 'truc' dans "truc toto".</p>
-   </td>
-  </tr>
-  <tr>
-   <td><code>\t</code></td>
-   <td>Correspond à une tabulation (U+0009).</td>
-  </tr>
-  <tr>
-   <td><code>\r</code></td>
-   <td>Correspond à un retour chariot (U+000D).</td>
-  </tr>
-  <tr>
-   <td><code>\n</code></td>
-   <td>Correspond à un saut de ligne (U+000A).</td>
-  </tr>
-  <tr>
-   <td><code>\v</code></td>
-   <td>Correspond à une tabulation verticale (U+000B).</td>
-  </tr>
-  <tr>
-   <td><code>\f</code></td>
-   <td>Correspond à un saut de page (U+000C).</td>
-  </tr>
-  <tr>
-   <td><code>[\b]</code></td>
-   <td>Correspond pour un retour arrière (U+0008). (À ne pas confondre avec <code>\b</code>, voir <a href="/fr/docs/Web/JavaScript/Guide/Expressions_régulières/Limites">les limites</a>).</td>
-  </tr>
-  <tr>
-   <td><code>\0</code></td>
-   <td>Correspond au caractère NULL (U+0000). Il ne doit pas être suivi d'un autre chiffre car <code>\0&lt;chiffres&gt;</code> est une <a href="/fr/docs/Web/JavaScript/Guide/Types_et_grammaire#Les_caractères_d'échappement">séquence d'échappement</a> pour les nombres en notation octale (si besoin d'utiliser un chiffre ensuite, on pourra utiliser la forme <code>\x00</code>, cf. ci-après).</td>
-  </tr>
-  <tr>
-   <td><code>\cX</code></td>
-   <td>
-    <p>Correspond au caractère de contrôle où <code><em>X</em></code> est une lettre entre A et Z. Correspond au caractèlres de contrôle correspondant entre <code>U+0001</code>-<code>U+001F</code>. Ainsi, <code>/\cM/</code> correspondra au caractère controle-M au sein d'une chaîne de caractères soit <code>"\r"</code> pour <code>"\r\n"</code>.</p>
-   </td>
-  </tr>
-  <tr>
-   <td><code>\xhh</code></td>
-   <td>Correspond au caractère dont le code hexadécimal est hh (deux chiffres hexadécimaux).</td>
-  </tr>
-  <tr>
-   <td><code>\uhhhh</code></td>
-   <td>Correspond au caractère dont le code est hhhh (quatre chiffres hexadécimaux).</td>
-  </tr>
-  <tr>
-   <td><code>\u{hhhh}</code> ou <code>\u{hhhhh}</code></td>
-   <td>(Uniquement actif quand le marqueur <code>u</code> est activé) Correspond au caractère dont la valeur Unicode est <code>hhhh</code> (en chiffre hexadécimaux).</td>
-  </tr>
-  <tr>
-   <td><code>\</code></td>
-   <td>
-    <p>La barre oblique inversée indique que le prochain caractère doit être traité spécifiquement ou échappé. Elle se comporte d'une de ces façons :</p>
-
-    <ul>
-     <li>Pour les caractères normalement traités littéralement, cela indique que le prochain caractère est spécial et qu'il ne doit pas être interprété littéralement. Ainsi, <code>/b/</code> correspondra à la lettre "b" mais en utilisant la barre oblique inversée devant <code>/\b/</code>, on cherchera une limite de mot.</li>
-     <li>Pour les caractères spéciaux, la barre indique que le caractère doit être interprété littéralement. Ainsi, "*" est un caractère spécial (un quantificateur qui signifie que le caractère précédent doit être présent 0 ou plusieurs fois) : <code>/a*/</code> cherchera une correspondance avec 0 ou plusieurs "a". Si on souhaite trouver le caractère <code>*</code> dans une chaîne, on placera la barre oblique inversée devant : on a ainsi <code>/a\*/</code> qui permet de trouver "a*" dans une chaîne.</li>
-    </ul>
-
-    <div class="blockIndicator note">
-    <p><strong>Note :</strong> L'échappement vaut également avec la barre oblique inversée. Autrement dit, si on cherche la présence de <code>\</code> dans une chaîne, on pourra utiliser l'expression <code>/\\/</code> (où la première barre oblique échape la seconde).</p>
-    </div>
-   </td>
-  </tr>
- </tbody>
+  <thead>
+    <tr>
+      <th scope="col">Caractères</th>
+      <th scope="col">Signification</th>
+    </tr>
+  </thead>
+  <tbody></tbody>
+  <tbody>
+    <tr>
+      <td><code>.</code></td>
+      <td>
+        <p>
+          Par défaut, (Le point) correspond à n'importe quel caractère excepté
+          un caractère de saut de ligne.
+        </p>
+        <p>
+          Ainsi, <code>/.n/</code> correspond à  'un' et 'en' dans "Un baobab
+          nain en cours de  croissance" mais pas à 'nain'.
+        </p>
+        <p>
+          Si le marqueur <code>s</code> (<em>dotAll</em>) est utilisé, le point
+          correspondra également aux caractères de saut de ligne.
+        </p>
+        <p>
+          Le marqueur <code>m</code> ne modifie pas le comportement du point.
+        </p>
+        <p>
+          Attention, si on utilise le point dans
+          <a
+            href="/fr/docs/Web/JavaScript/Guide/Expressions_régulières/Groupes_et_intervalles"
+            >un intervalle de caractères</a
+          >, il n'aura plus cette signification spéciale.
+        </p>
+      </td>
+    </tr>
+    <tr>
+      <td><code>\d</code></td>
+      <td>
+        <p>Correspond à un chiffre et est équivalent à <code>[0-9]</code>.</p>
+        <p>
+          Ainsi, <code>/\d/</code> ou <code>/[0-9]/</code> correspond à '2' dans
+          "H2O est la molécule de l'eau".
+        </p>
+      </td>
+    </tr>
+    <tr>
+      <td><code>\D</code></td>
+      <td>
+        <p>
+          Correspond à tout caractère qui n'est pas un chiffre et est équivalent
+          à<code> [^0-9]</code>.
+        </p>
+        <p>
+          Ainsi, <code>/\D/</code> ou <code>/[^0-9]/</code> correspond à 'H'
+          dans "H2O est la molécule de l'eau".
+        </p>
+      </td>
+    </tr>
+    <tr>
+      <td><code>\w</code></td>
+      <td>
+        <p>
+          Correspond à n'importe quel caractère alphanumérique de l'alphabet
+          latin, y compris le tiret bas. C'est équivalent à
+          <code>[A-Za-z0-9_]</code>.
+        </p>
+        <p>
+          Ainsi, <code>/\w/</code> correspond à 'l' dans "licorne", à '5' dans
+          "5,28€", et à '3' dans "3D."
+        </p>
+      </td>
+    </tr>
+    <tr>
+      <td><code>\W</code></td>
+      <td>
+        <p>
+          Correspond à n'importe quel caractère n'étant pas un caractère de
+          l'alphabet latin ou le tiret bas. Cela est équivalent à
+          <code>[^A-Za-z0-9_]</code>.
+        </p>
+        <p>
+          Ainsi, <code>/\W/</code> ou <code>/[^A-Za-z0-9_]/</code> correspond à
+          '%' dans "50%."
+        </p>
+      </td>
+    </tr>
+    <tr>
+      <td><code>\s</code></td>
+      <td>
+        <p>
+          Correspond à un blanc (cela comprend les espace, tabulation, saut de
+          ligne ou saut de page). C'est équivalent à
+          <code
+            >[
+            \f\n\r\t\v\u00a0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff]</code
+          >.
+        </p>
+        <p>
+          Ainsi, <code>/\s\w*/</code> correspond à ' toto' dans "truc toto".
+        </p>
+      </td>
+    </tr>
+    <tr>
+      <td><code>\S</code></td>
+      <td>
+        <p>
+          Correspond à un caractère qui n'est pas un blanc. C'est équivalent à
+          <code
+            >[^
+            \f\n\r\t\v\u00a0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff]</code
+          >.
+        </p>
+        <p>Ainsi, <code>/\S\w*/</code> correspond à 'truc' dans "truc toto".</p>
+      </td>
+    </tr>
+    <tr>
+      <td><code>\t</code></td>
+      <td>Correspond à une tabulation (U+0009).</td>
+    </tr>
+    <tr>
+      <td><code>\r</code></td>
+      <td>Correspond à un retour chariot (U+000D).</td>
+    </tr>
+    <tr>
+      <td><code>\n</code></td>
+      <td>Correspond à un saut de ligne (U+000A).</td>
+    </tr>
+    <tr>
+      <td><code>\v</code></td>
+      <td>Correspond à une tabulation verticale (U+000B).</td>
+    </tr>
+    <tr>
+      <td><code>\f</code></td>
+      <td>Correspond à un saut de page (U+000C).</td>
+    </tr>
+    <tr>
+      <td><code>[\b]</code></td>
+      <td>
+        Correspond pour un retour arrière (U+0008). (À ne pas confondre avec
+        <code>\b</code>, voir
+        <a href="/fr/docs/Web/JavaScript/Guide/Expressions_régulières/Limites"
+          >les limites</a
+        >).
+      </td>
+    </tr>
+    <tr>
+      <td><code>\0</code></td>
+      <td>
+        Correspond au caractère NULL (U+0000). Il ne doit pas être suivi d'un
+        autre chiffre car <code>\0&#x3C;chiffres></code> est une
+        <a
+          href="/fr/docs/Web/JavaScript/Guide/Types_et_grammaire#Les_caractères_d&#x27;échappement"
+          >séquence d'échappement</a
+        >
+        pour les nombres en notation octale (si besoin d'utiliser un chiffre
+        ensuite, on pourra utiliser la forme <code>\x00</code>, cf. ci-après).
+      </td>
+    </tr>
+    <tr>
+      <td><code>\cX</code></td>
+      <td>
+        <p>
+          Correspond au caractère de contrôle où <code><em>X</em></code> est une
+          lettre entre A et Z. Correspond au caractèlres de contrôle
+          correspondant entre <code>U+0001</code>-<code>U+001F</code>. Ainsi,
+          <code>/\cM/</code> correspondra au caractère controle-M au sein d'une
+          chaîne de caractères soit <code>"\r"</code> pour <code>"\r\n"</code>.
+        </p>
+      </td>
+    </tr>
+    <tr>
+      <td><code>\xhh</code></td>
+      <td>
+        Correspond au caractère dont le code hexadécimal est hh (deux chiffres
+        hexadécimaux).
+      </td>
+    </tr>
+    <tr>
+      <td><code>\uhhhh</code></td>
+      <td>
+        Correspond au caractère dont le code est hhhh (quatre chiffres
+        hexadécimaux).
+      </td>
+    </tr>
+    <tr>
+      <td><code>\u{hhhh}</code> ou <code>\u{hhhhh}</code></td>
+      <td>
+        (Uniquement actif quand le marqueur <code>u</code> est activé)
+        Correspond au caractère dont la valeur Unicode est <code>hhhh</code> (en
+        chiffre hexadécimaux).
+      </td>
+    </tr>
+    <tr>
+      <td><code>\</code></td>
+      <td>
+        <p>
+          La barre oblique inversée indique que le prochain caractère doit être
+          traité spécifiquement ou échappé. Elle se comporte d'une de ces façons
+          :
+        </p>
+        <ul>
+          <li>
+            Pour les caractères normalement traités littéralement, cela indique
+            que le prochain caractère est spécial et qu'il ne doit pas être
+            interprété littéralement. Ainsi, <code>/b/</code> correspondra à la
+            lettre "b" mais en utilisant la barre oblique inversée devant
+            <code>/\b/</code>, on cherchera une limite de mot.
+          </li>
+          <li>
+            Pour les caractères spéciaux, la barre indique que le caractère doit
+            être interprété littéralement. Ainsi, "*" est un caractère spécial
+            (un quantificateur qui signifie que le caractère précédent doit être
+            présent 0 ou plusieurs fois) : <code>/a*/</code> cherchera une
+            correspondance avec 0 ou plusieurs "a". Si on souhaite trouver le
+            caractère <code>*</code> dans une chaîne, on placera la barre
+            oblique inversée devant : on a ainsi <code>/a\*/</code> qui permet
+            de trouver "a*" dans une chaîne.
+          </li>
+        </ul>
+        <div class="blockIndicator note">
+          <p>
+            <strong>Note :</strong> L'échappement vaut également avec la barre
+            oblique inversée. Autrement dit, si on cherche la présence de
+            <code>\</code> dans une chaîne, on pourra utiliser l'expression
+            <code>/\\/</code> (où la première barre oblique échape la seconde).
+          </p>
+        </div>
+      </td>
+    </tr>
+  </tbody>
 </table>
 
-<h2 id="Spécifications">Spécifications</h2>
+## Spécifications
 
-<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('ES3')}}</td>
-   <td>{{Spec2('ES3')}}</td>
-   <td>Définition initiale. Implémentée avec JavaScript 1.1.</td>
-  </tr>
- </tbody>
-</table>
+| Spécification            | État                 | Commentaires                                          |
+| ------------------------ | -------------------- | ----------------------------------------------------- |
+| {{SpecName('ES3')}} | {{Spec2('ES3')}} | Définition initiale. Implémentée avec JavaScript 1.1. |
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.RegExp.property_escapes")}}</p>
+{{Compat("javascript.builtins.RegExp.property_escapes")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{JSxRef("RegExp")}}</li>
-</ul>
+- {{JSxRef("RegExp")}}
diff --git a/files/fr/web/javascript/guide/regular_expressions/groups_and_ranges/index.md b/files/fr/web/javascript/guide/regular_expressions/groups_and_ranges/index.md
index 498e9e7ce8..1233a65060 100644
--- a/files/fr/web/javascript/guide/regular_expressions/groups_and_ranges/index.md
+++ b/files/fr/web/javascript/guide/regular_expressions/groups_and_ranges/index.md
@@ -10,83 +10,163 @@ tags:
 translation_of: Web/JavaScript/Guide/Regular_Expressions/Groups_and_Ranges
 original_slug: Web/JavaScript/Guide/Expressions_régulières/Groupes_et_intervalles
 ---
-<p>{{jsSidebar("JavaScript Guide")}}{{draft}}</p>
+{{jsSidebar("JavaScript Guide")}}{{draft}}
 
-<p>Les groupes et intervalles permettent de représenter des groupes ou des intervalles de caractères dans des expressions rationnelles.</p>
+Les groupes et intervalles permettent de représenter des groupes ou des intervalles de caractères dans des expressions rationnelles.
 
-<h2 id="Types">Types</h2>
+## Types
 
 <table class="standard-table">
- <thead>
-  <tr>
-   <th scope="col">Caractères</th>
-   <th scope="col">Signification</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td><code>x|y</code></td>
-   <td>
-    <p>Correspond à 'x' ou 'y'.</p>
-
-    <p>Ainsi, <code>/vert|rouge/</code> correspond à 'vert' dans "feu vert" et à 'rouge' dans "feu rouge".</p>
-   </td>
-  </tr>
-  <tr>
-   <td><code>[xyz]</code> ou <code>[a-c]</code></td>
-   <td>Un ensemble de caractère. Ce type de motif correspond pour n'importe quel caractètre présent entre les crochets, y compris les <a href="/fr/docs/Web/JavaScript/Guide/Types_et_grammaire#Les_caractères_d'échappement">séquences d'échappement</a>. Les caractères spéciaux comme le point (.) et l'astérisque ne sont pas considérés comme spéciaux au sein d'un ensemble et n'ont donc pas besoin d'être échappés. Il est possible de donner un ensemble sur un intervalle de caractères en utilisant un tiret (-), comme le montre l'exemple qui suit.<br>
-    <br>
-    Le motif <code>[a-d]</code>,  aura les mêmes correspondances que <code>[abcd]</code>, correspondant au 'b' de "bulle" et au 'c' de "ciel". Les motifis <code>/[a-z.]+/ </code>et <code>/[\w.]+/</code> correspondront pour la chaîne entirère : "Adre.ss.e".</td>
-  </tr>
-  <tr>
-   <td>
-    <p><code>[^xyz]</code> ou <code>[^a-c]</code></p>
-   </td>
-   <td>
-
-
-    <p>Exclusion d'un ensemble de caractères. Cela correspond à tout ce qui n'est pas compris entre crochets. Il est possible de fournir un intervalle de caractères en utilisant un tiret (-). Les autres règles qui s'appliquent pour l'ensemble de caractères (ci-avant) s'appliquent également ici.</p>
-
-    <p>Par exemple, <code>[^abc]</code> est équivalent à <code>[^a-c]</code>. Ils correspondent à 'u' dans "bulle" et à 'i' dans "ciel".</p>
-
-    <div class="note">
-    <p><strong>Note :</strong> Le caractère <code>^</code> peut également être utilisé afin d'indiquer le <a href="/fr/docs/Web/JavaScript/Guide/Expressions_régulières/Limites">début d'un champ</a>.</p>
-    </div>
-   </td>
-  </tr>
-  <tr>
-   <td><code>(x)</code></td>
-   <td>
-    <p>Correspond à 'x' et garde la correspondance en mémoire. Les parenthèses permettent de <em>capturer </em>l'expression dans un « groupe ».<br>
-     <br>
-     Les '<code>(toto)</code>' et '<code>(truc)</code>', dans le motif <code>/(toto) (truc) \1 \2/</code> correspondent et gardent en mémoire les deux premiers mots de la chaîne de caractère "toto truc toto truc". Les <code>\1</code> et <code>\2</code> du motif correspondent respectivement à la première et à la deuxième correspondances pour les sous-chaînes entre parenthèses. Lorsqu'on souhaite effectuer un remplacement, on utilisera <code>$1</code> et <code>$2</code> pour faire référence au premier et second groupe et <code>$</code><code>n </code>pour faire référence au n-ième groupe capturé (ex. <code>('toto truc'.replace(/(...) (...)/, '$2 $1').</code> <code>$&amp;</code> fera référence à la chaîne entière).</p>
-
-    <p>Capturing groups have a performance penalty. If you don't need the matched substring to be recalled, prefer non-capturing parentheses (see below).</p>
-
-    <p><code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/match">String.match()</a></code> won't return groups if the <code>/.../g</code> flag is set. However, you can still use <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/matchAll">String.matchAll()</a></code> to get all matches.</p>
-   </td>
-  </tr>
-  <tr>
-   <td><code>\n</code></td>
-   <td>
-    <p>Avec <code><em>n</em></code> un entier positif. Cela permet de faire référence à la dernière sous-chaîne qui correspond au n-ième groupe entre parenthèses de l'expression rationnelle (en comptant les parenthèses gauche). Ainsi, <code>/apple(,)\sorange\1/</code> correspondra à "apple, orange," dans "apple, orange, cherry, peach".</p>
-   </td>
-  </tr>
-  <tr>
-   <td><code>(?&lt;Nom&gt;x)</code></td>
-   <td>
-    <p>Correspond à <code>x</code> et nomme la correspondance. Les correspondances associées pourront être retrouvées via le nom indiqué. Les chevrons (<code>'&lt;'</code> et <code>'&gt;'</code>) sont obligatoires pour encadrer le nom.</p>
-
-    <p>Ainsi, si on veut extraire la composante de zone d'un numéro de téléphone aux États-Unis, on pourra écrire <code>/\((?&lt;area&gt;\d\d\d)\)/</code> et récupérer le nombre voulu avec <code>matches.groups.area</code>.</p>
-   </td>
-  </tr>
-  <tr>
-   <td><code>(?:<em>x</em>)</code></td>
-   <td>Correspond à 'x' mais ne garde pas la correspondance en mémoire. Les parenthèses ne <em>capturent</em> pas l'expression et permettent d'utiliser des sous-expressions d'une expression régulière pour travailler plus finement. L'expression <code>/(?:zoo){1,2}/</code> sans parenthèes non-capturantes <code>les caractères {1,2}</code> ne s'appliqueraient qu'au dernier 'o' de 'zoo'. Avec les parenthèses capturantes, <code>{1,2}</code> s'applique au mot entier 'zoo'.</td>
-  </tr>
- </tbody>
+  <thead>
+    <tr>
+      <th scope="col">Caractères</th>
+      <th scope="col">Signification</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td><code>x|y</code></td>
+      <td>
+        <p>Correspond à 'x' ou 'y'.</p>
+        <p>
+          Ainsi, <code>/vert|rouge/</code> correspond à 'vert' dans "feu vert"
+          et à 'rouge' dans "feu rouge".
+        </p>
+      </td>
+    </tr>
+    <tr>
+      <td><code>[xyz]</code> ou <code>[a-c]</code></td>
+      <td>
+        Un ensemble de caractère. Ce type de motif correspond pour n'importe
+        quel caractètre présent entre les crochets, y compris les
+        <a
+          href="/fr/docs/Web/JavaScript/Guide/Types_et_grammaire#Les_caractères_d&#x27;échappement"
+          >séquences d'échappement</a
+        >. Les caractères spéciaux comme le point (.) et l'astérisque ne sont
+        pas considérés comme spéciaux au sein d'un ensemble et n'ont donc pas
+        besoin d'être échappés. Il est possible de donner un ensemble sur un
+        intervalle de caractères en utilisant un tiret (-), comme le montre
+        l'exemple qui suit.<br /><br />Le motif <code>[a-d]</code>,  aura les
+        mêmes correspondances que <code>[abcd]</code>, correspondant au 'b' de
+        "bulle" et au 'c' de "ciel". Les motifis <code>/[a-z.]+/ </code>et
+        <code>/[\w.]+/</code> correspondront pour la chaîne entirère :
+        "Adre.ss.e".
+      </td>
+    </tr>
+    <tr>
+      <td>
+        <p><code>[^xyz]</code> ou <code>[^a-c]</code></p>
+      </td>
+      <td>
+        <p>
+          Exclusion d'un ensemble de caractères. Cela correspond à tout ce qui
+          n'est pas compris entre crochets. Il est possible de fournir un
+          intervalle de caractères en utilisant un tiret (-). Les autres règles
+          qui s'appliquent pour l'ensemble de caractères (ci-avant) s'appliquent
+          également ici.
+        </p>
+        <p>
+          Par exemple, <code>[^abc]</code> est équivalent à <code>[^a-c]</code>.
+          Ils correspondent à 'u' dans "bulle" et à 'i' dans "ciel".
+        </p>
+        <div class="note">
+          <p>
+            <strong>Note :</strong> Le caractère <code>^</code> peut également
+            être utilisé afin d'indiquer le
+            <a
+              href="/fr/docs/Web/JavaScript/Guide/Expressions_régulières/Limites"
+              >début d'un champ</a
+            >.
+          </p>
+        </div>
+      </td>
+    </tr>
+    <tr>
+      <td><code>(x)</code></td>
+      <td>
+        <p>
+          Correspond à 'x' et garde la correspondance en mémoire. Les
+          parenthèses permettent de <em>capturer </em>l'expression dans un «
+          groupe ».<br /><br />Les '<code>(toto)</code>' et
+          '<code>(truc)</code>', dans le motif
+          <code>/(toto) (truc) \1 \2/</code> correspondent et gardent en mémoire
+          les deux premiers mots de la chaîne de caractère "toto truc toto
+          truc". Les <code>\1</code> et <code>\2</code> du motif correspondent
+          respectivement à la première et à la deuxième correspondances pour les
+          sous-chaînes entre parenthèses. Lorsqu'on souhaite effectuer un
+          remplacement, on utilisera <code>$1</code> et <code>$2</code> pour
+          faire référence au premier et second groupe et <code>$</code
+          ><code>n </code>pour faire référence au n-ième groupe capturé (ex.
+          <code>('toto truc'.replace(/(...) (...)/, '$2 $1').</code>
+          <code>$&#x26;</code> fera référence à la chaîne entière).
+        </p>
+        <p>
+          Capturing groups have a performance penalty. If you don't need the
+          matched substring to be recalled, prefer non-capturing parentheses
+          (see below).
+        </p>
+        <p>
+          <code
+            ><a
+              href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/match"
+              >String.match()</a
+            ></code
+          >
+          won't return groups if the <code>/.../g</code> flag is set. However,
+          you can still use
+          <code
+            ><a
+              href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/matchAll"
+              >String.matchAll()</a
+            ></code
+          >
+          to get all matches.
+        </p>
+      </td>
+    </tr>
+    <tr>
+      <td><code>\n</code></td>
+      <td>
+        <p>
+          Avec <code><em>n</em></code> un entier positif. Cela permet de faire
+          référence à la dernière sous-chaîne qui correspond au n-ième groupe
+          entre parenthèses de l'expression rationnelle (en comptant les
+          parenthèses gauche). Ainsi,
+          <code>/apple(,)\sorange\1/</code> correspondra à "apple, orange," dans
+          "apple, orange, cherry, peach".
+        </p>
+      </td>
+    </tr>
+    <tr>
+      <td><code>(?&#x3C;Nom>x)</code></td>
+      <td>
+        <p>
+          Correspond à <code>x</code> et nomme la correspondance. Les
+          correspondances associées pourront être retrouvées via le nom indiqué.
+          Les chevrons (<code>'&#x3C;'</code> et <code>'>'</code>) sont
+          obligatoires pour encadrer le nom.
+        </p>
+        <p>
+          Ainsi, si on veut extraire la composante de zone d'un numéro de
+          téléphone aux États-Unis, on pourra écrire
+          <code>/\((?&#x3C;area>\d\d\d)\)/</code> et récupérer le nombre voulu
+          avec <code>matches.groups.area</code>.
+        </p>
+      </td>
+    </tr>
+    <tr>
+      <td><code>(?:<em>x</em>)</code></td>
+      <td>
+        Correspond à 'x' mais ne garde pas la correspondance en mémoire. Les
+        parenthèses ne <em>capturent</em> pas l'expression et permettent
+        d'utiliser des sous-expressions d'une expression régulière pour
+        travailler plus finement. L'expression <code>/(?:zoo){1,2}/</code> sans
+        parenthèes non-capturantes <code>les caractères {1,2}</code> ne
+        s'appliqueraient qu'au dernier 'o' de 'zoo'. Avec les parenthèses
+        capturantes, <code>{1,2}</code> s'applique au mot entier 'zoo'.
+      </td>
+    </tr>
+  </tbody>
 </table>
 
-<div class="note">
-<p><strong>Note :</strong> Firefox ne prend pas en charge les groupes nommés. Pour plus d'informations, voir <a href="https://bugzilla.mozilla.org/show_bug.cgi?id=1362154">le bug correspondant</a>.</p>
-</div>
+> **Note :** Firefox ne prend pas en charge les groupes nommés. Pour plus d'informations, voir [le bug correspondant](https://bugzilla.mozilla.org/show_bug.cgi?id=1362154).
diff --git a/files/fr/web/javascript/guide/regular_expressions/index.md b/files/fr/web/javascript/guide/regular_expressions/index.md
index dda529fffd..a5314a2a4c 100644
--- a/files/fr/web/javascript/guide/regular_expressions/index.md
+++ b/files/fr/web/javascript/guide/regular_expressions/index.md
@@ -9,630 +9,852 @@ tags:
 translation_of: Web/JavaScript/Guide/Regular_Expressions
 original_slug: Web/JavaScript/Guide/Expressions_régulières
 ---
-<p>{{jsSidebar("JavaScript Guide")}}{{PreviousNext("Web/JavaScript/Guide/Formatage_du_texte", "Web/JavaScript/Guide/Collections_indexées")}}</p>
+{{jsSidebar("JavaScript Guide")}}{{PreviousNext("Web/JavaScript/Guide/Formatage_du_texte", "Web/JavaScript/Guide/Collections_indexées")}}
 
-<p>Les expressions rationnelles sont des motifs utilisés pour correspondre à certaines combinaisons de caractères au sein de chaînes de caractères. En JavaScript, les expressions rationnelles sont également des objets. Ces motifs sont utilisés avec les méthodes {{jsxref("RegExp.exec", "exec")}} et {{jsxref("RegExp.test", "test")}} de {{jsxref("RegExp")}}, et avec les méthodes {{jsxref("String.match", "match")}}, {{jsxref("String.matchAll", "matchAll")}}, {{jsxref("String.replace", "replace")}}, {{jsxref("String.search", "search")}} et {{jsxref("String.split", "split")}} de {{jsxref("String")}}. Ce chapitre explique comment utiliser les expressions rationnelles en JavaScript (aussi appelées expressions régulières ou « <em>RegExp</em> »).</p>
+Les expressions rationnelles sont des motifs utilisés pour correspondre à certaines combinaisons de caractères au sein de chaînes de caractères. En JavaScript, les expressions rationnelles sont également des objets. Ces motifs sont utilisés avec les méthodes {{jsxref("RegExp.exec", "exec")}} et {{jsxref("RegExp.test", "test")}} de {{jsxref("RegExp")}}, et avec les méthodes {{jsxref("String.match", "match")}}, {{jsxref("String.matchAll", "matchAll")}}, {{jsxref("String.replace", "replace")}}, {{jsxref("String.search", "search")}} et {{jsxref("String.split", "split")}} de {{jsxref("String")}}. Ce chapitre explique comment utiliser les expressions rationnelles en JavaScript (aussi appelées expressions régulières ou « _RegExp_ »).
 
-<h2 id="Créer_une_expression_rationnelle">Créer une expression rationnelle</h2>
+## Créer une expression rationnelle
 
-<p>Il est possible de construire une expression rationnelle de deux façons :</p>
+Il est possible de construire une expression rationnelle de deux façons :
 
-<ul>
- <li>Utiliser un littéral d'expression régulière, qui correspond à un motif contenu entre deux barres obliques, par exemple :
-  <pre class="brush: js notranslate">var re = /ab+c/;
-</pre>
+- Utiliser un littéral d'expression régulière, qui correspond à un motif contenu entre deux barres obliques, par exemple :
 
-  <p>Lorsque les littéraux d'expression régulière sont utilisés, l'expression est compilée lors du chargement du script. Il est préférable d'utiliser cette méthode lorsque l'expression régulière reste constante, afin d'avoir de meilleurs performances.</p>
- </li>
- <li>Appeler le constructeur de l'objet {{jsxref("RegExp")}}, par exemple :
-  <pre class="brush: js notranslate">var re = new RegExp("ab+c");
-</pre>
+  ```js
+    var re = /ab+c/;
+    ```
 
-  <p>Avec cette méthode, l'expression rationnelle est compilée lors de l'exécution. On utilisera cette méthode lorsque le motif utilisé est variable ou provient d'une autre source (par exemple une interaction utilisateur).</p>
- </li>
-</ul>
+  Lorsque les littéraux d'expression régulière sont utilisés, l'expression est compilée lors du chargement du script. Il est préférable d'utiliser cette méthode lorsque l'expression régulière reste constante, afin d'avoir de meilleurs performances.
 
-<h2 id="Écrire_une_expression_rationnelle">Écrire une expression rationnelle</h2>
+- Appeler le constructeur de l'objet {{jsxref("RegExp")}}, par exemple :
 
-<p>Le motif d'une expression rationnelle est composé de caractères simples (comme <code>/abc/</code>), ou de caractères simples et spéciaux, comme <code>/ab*c/</code> ou <code>/Chapitre (\d+)\.\d*/ </code>. Le dernier exemple utilise des parenthèses qui permettent d'avoir une « mémoire ». La correspondance avec le motif contenu entre parenthèses pourra être utilisée par la suite. Ceci est décrit avec <a href="#parentheses">ce paragraphe</a>.</p>
+  ```js
+    var re = new RegExp("ab+c");
+    ```
 
-<h3 id="Utiliser_des_motifs_simples">Utiliser des motifs simples</h3>
+  Avec cette méthode, l'expression rationnelle est compilée lors de l'exécution. On utilisera cette méthode lorsque le motif utilisé est variable ou provient d'une autre source (par exemple une interaction utilisateur).
 
-<p>Les motifs simples sont construits à partir de caractères pour lesquels on souhaite avoir une correspondance directe. Le motif <code>/des/</code> correspond lorsqu'on observe exactement les caractères 'des' ensemble et dans cet ordre précis. On pourrait utiliser ce motif et détecter une correspondance dans les chaînes suivantes : "J'ai vu des licornes ?" et "Sa description de licorne était superbe" car la chaîne de caractères 'des' y est présente (dans le mot description pour le second exemple). Il n'y aura pas de correspondance avec la chaîne de caractères "Toc toc" car 'des' n'est pas présente.</p>
+## Écrire une expression rationnelle
 
-<h3 id="Utiliser_des_caractères_spéciaux">Utiliser des caractères spéciaux</h3>
+Le motif d'une expression rationnelle est composé de caractères simples (comme `/abc/`), ou de caractères simples et spéciaux, comme `/ab*c/` ou `/Chapitre (\d+)\.\d*/ `. Le dernier exemple utilise des parenthèses qui permettent d'avoir une « mémoire ». La correspondance avec le motif contenu entre parenthèses pourra être utilisée par la suite. Ceci est décrit avec [ce paragraphe](#parentheses).
 
-<p>Lorsque le motif à trouver est plus complexe qu'une simple égalité (trouver tous les B, les blancs...), le motif devra contenir des caractères spéciaux. Ainsi, le motif <code>/ab*c/</code> correspond à toutes les combinaisons de caractères qui possèdent un seul 'a' suivi de zéro ou plusieurs 'b' (l'astérisque utilisée ici signifie que l'élément qui la précède doit être présent zéro ou plusieurs fois) qui sont immédiatement suivis d'un 'c'. Par exemple, la chaîne de caractère "cbbabbbbcdebc" correspond au motif avec la chaîne de caractères 'abbbbc'.</p>
+### Utiliser des motifs simples
 
-<p>Les pages suivantes décrivent en détail les caractères spéciaux qui peuvent être utilisés afin de composer une expression rationnelle.</p>
+Les motifs simples sont construits à partir de caractères pour lesquels on souhaite avoir une correspondance directe. Le motif `/des/` correspond lorsqu'on observe exactement les caractères 'des' ensemble et dans cet ordre précis. On pourrait utiliser ce motif et détecter une correspondance dans les chaînes suivantes : "J'ai vu des licornes ?" et "Sa description de licorne était superbe" car la chaîne de caractères 'des' y est présente (dans le mot description pour le second exemple). Il n'y aura pas de correspondance avec la chaîne de caractères "Toc toc" car 'des' n'est pas présente.
 
-<dl>
- <dt><a href="/fr/docs/Web/JavaScript/Guide/Expressions_régulières/Assertions">Assertions</a></dt>
- <dd>Une assertion caractérisant la façon dont la correspondance peut se produire (en recherchant un motif avant, après ou avec une expression conditionnelle).</dd>
- <dt><a href="/fr/docs/Web/JavaScript/Guide/Expressions_régulières/Limites">Limites</a></dt>
- <dd>Permet d'indiquer le début ou la fin d'une ligne ou d'un mot.</dd>
- <dt><a href="/fr/docs/Web/JavaScript/Guide/Expressions_régulières/Classes_de_caractères">Classes de caractère</a></dt>
- <dd>Les classes permettent de distinguer différents caractères selon différents groupes (par exemple les lettres et les chiffres).</dd>
- <dt><a href="/fr/docs/Web/JavaScript/Guide/Expressions_régulières/Groupes_et_intervalles">Groupes et intervalles</a></dt>
- <dd>Permet d'indiquer un groupe ou un intervalle de caractères.</dd>
- <dt><a href="/fr/docs/Web/JavaScript/Guide/Expressions_régulières/Quantificateurs">Quantificateurs</a></dt>
- <dd>Permet d'indiquer un nombre de caractères ou d'expressions qui doivent correspondre.</dd>
- <dt><a href="/fr/docs/Web/JavaScript/Guide/Expressions_régulières/Unicode_Properties">Propriétés Unicode</a></dt>
- <dd>Permet de distinguer les caractères en fonction de leurs caractéristiques Unicode (majuscule/minuscule, symbole mathématique, ponctuation).</dd>
-</dl>
+### Utiliser des caractères spéciaux
 
-<h3 id="Échapper_des_caractères">Échapper des caractères</h3>
+Lorsque le motif à trouver est plus complexe qu'une simple égalité (trouver tous les B, les blancs...), le motif devra contenir des caractères spéciaux. Ainsi, le motif `/ab*c/` correspond à toutes les combinaisons de caractères qui possèdent un seul 'a' suivi de zéro ou plusieurs 'b' (l'astérisque utilisée ici signifie que l'élément qui la précède doit être présent zéro ou plusieurs fois) qui sont immédiatement suivis d'un 'c'. Par exemple, la chaîne de caractère "cbbabbbbcdebc" correspond au motif avec la chaîne de caractères 'abbbbc'.
 
-<p>SI on souhaite rechercher certains caractères dans une chaîne de caractères et que ceux-ci ont une signification spéciale lorsqu'ils font partie d'une expression rationnelle (ex. "*"), il faudra échapper ces caractères spéciaux en plaçant une barre oblique inversée (<em>backslash</em> "\") devant. Ainsi, si on souhaite trouver un "a" suivi d'un astérisque ("*") suivi d'un "b", on pourra composer l'expression rationnelle : <code>/a\*b/</code> où la barre oblique inversée échappe l'astérisque afin de lui enlever sa signification particulière.</p>
+Les pages suivantes décrivent en détail les caractères spéciaux qui peuvent être utilisés afin de composer une expression rationnelle.
 
-<p>De même si on écrit un littéral d'expression rationnelle et qu'on souhaite rechercher une barre oblique ("/") dans la chaîne cible, on pourra échapper ce caractère (sinon, il aura sa signification particulière aux expressions rationnelles et indiquera la fin du motif). Si on cherche la présence de "/exemple/" dans une chaîne de caractères, on pourra utiliser le littéral <code>/\/exemple\//</code>.</p>
+- [Assertions](/fr/docs/Web/JavaScript/Guide/Expressions_régulières/Assertions)
+  - : Une assertion caractérisant la façon dont la correspondance peut se produire (en recherchant un motif avant, après ou avec une expression conditionnelle).
+- [Limites](/fr/docs/Web/JavaScript/Guide/Expressions_régulières/Limites)
+  - : Permet d'indiquer le début ou la fin d'une ligne ou d'un mot.
+- [Classes de caractère](/fr/docs/Web/JavaScript/Guide/Expressions_régulières/Classes_de_caractères)
+  - : Les classes permettent de distinguer différents caractères selon différents groupes (par exemple les lettres et les chiffres).
+- [Groupes et intervalles](/fr/docs/Web/JavaScript/Guide/Expressions_régulières/Groupes_et_intervalles)
+  - : Permet d'indiquer un groupe ou un intervalle de caractères.
+- [Quantificateurs](/fr/docs/Web/JavaScript/Guide/Expressions_régulières/Quantificateurs)
+  - : Permet d'indiquer un nombre de caractères ou d'expressions qui doivent correspondre.
+- [Propriétés Unicode](/fr/docs/Web/JavaScript/Guide/Expressions_régulières/Unicode_Properties)
+  - : Permet de distinguer les caractères en fonction de leurs caractéristiques Unicode (majuscule/minuscule, symbole mathématique, ponctuation).
 
-<p>Il en va de même avec la barre oblique inversée (dont la signification spécifique est justement l'échappement) : si on veut rechercher la chaîne "C:\", on pourra utiliser le motif <code>/C:\\/</code> (la première barre oblique inversée sert à échapper la seconde).</p>
+### Échapper des caractères
 
-<p>Lorsqu'on utilise le constructeur {{jsxref("RegExp")}} avec une chaîne de caractères en paramètre (plutôt qu'un littéral), il faudra échapper la barre oblique inversée qui a un sens particulier dans les chaînes de caractères. Ainsi, le littéral <code>/a\*b/</code> et <code>new RegExp("a\\*b")</code> créeront la même expression (qui permet de chercher la lettre "a", suivie d'un astérisque, suivi de la lettre "b").</p>
+SI on souhaite rechercher certains caractères dans une chaîne de caractères et que ceux-ci ont une signification spéciale lorsqu'ils font partie d'une expression rationnelle (ex. "\*"), il faudra échapper ces caractères spéciaux en plaçant une barre oblique inversée (_backslash_ "\\") devant. Ainsi, si on souhaite trouver un "a" suivi d'un astérisque ("\*") suivi d'un "b", on pourra composer l'expression rationnelle : `/a\*b/` où la barre oblique inversée échappe l'astérisque afin de lui enlever sa signification particulière.
 
-<p>La tableau qui suit fournit une liste complète des caractères spéciaux pouvant être utilisés dans les expressions régulières ainsi que leur signification.</p>
+De même si on écrit un littéral d'expression rationnelle et qu'on souhaite rechercher une barre oblique ("/") dans la chaîne cible, on pourra échapper ce caractère (sinon, il aura sa signification particulière aux expressions rationnelles et indiquera la fin du motif). Si on cherche la présence de "/exemple/" dans une chaîne de caractères, on pourra utiliser le littéral `/\/exemple\//`.
+
+Il en va de même avec la barre oblique inversée (dont la signification spécifique est justement l'échappement) : si on veut rechercher la chaîne "C:\\", on pourra utiliser le motif `/C:\\/` (la première barre oblique inversée sert à échapper la seconde).
+
+Lorsqu'on utilise le constructeur {{jsxref("RegExp")}} avec une chaîne de caractères en paramètre (plutôt qu'un littéral), il faudra échapper la barre oblique inversée qui a un sens particulier dans les chaînes de caractères. Ainsi, le littéral `/a\*b/` et `new RegExp("a\\*b")` créeront la même expression (qui permet de chercher la lettre "a", suivie d'un astérisque, suivi de la lettre "b").
+
+La tableau qui suit fournit une liste complète des caractères spéciaux pouvant être utilisés dans les expressions régulières ainsi que leur signification.
 
 <table class="standard-table">
- <caption>Caractères spéciaux utilisables pour les expressions rationnelles.</caption>
- <thead>
-  <tr>
-   <th scope="col">Caractère</th>
-   <th scope="col">Signification</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td><code>\</code></td>
-   <td>
-    <p>Correspond selon les règles suivantes :<br>
-     <br>
-     Une barre oblique inversée (<em>backslash</em>) précédant un caractère non spécial indique que le caractère qui suit est spécial et qu'il ne doit pas être interprété directement. Ainsi, un '<code>b</code>', sans <code>\</code> avant, correspondra pour les 'b' minuscules quel que soit leur position. En revanche '<code>\b</code>' ne correspondra à aucun caractère mais indique <a href="#special-word-boundary">un caractère de fin de mot</a>.<br>
-     <br>
-     Un <em>backslash</em> précédant un caractère spécial indique que le caractère qui suit doit être interprété littéralement (et non pas comme un caractère spécial). Ainsi, le motif <code>/a*/</code> utilise le caractère spécial '<code>*</code>' pour correspondre à 0 ou plusieurs 'a'. Le motif <code>/a\*/</code>, au contraire, rend '<code>*</code>' non-spécial pour correspondre aux chaînes de caractères qui comportent la lettre a et une astérisque, comme 'a*'.<br>
-     <br>
-     Il ne faut pas oublier d'échapper le caractère <code>\</code> car lui-même est un caractère d'échappement dans les chaînes de caractères. Cela est utile lorsqu'on utilise la notation RegExp("motif").</p>
-   </td>
-  </tr>
-  <tr>
-   <td><code>^</code></td>
-   <td>Correspond au début la séquence. Si le marqueur (<em>flag</em>) de lignes multiples vaut <code>true</code>, il correspondra également immédiatement après un caractère de saut de ligne.<br>
-    <br>
-    Ainsi, <code>/^A/</code> ne correspond pas au 'A' de "un A", mais correspond au 'A' de "Arceau".<br>
-    <br>
-    Le caractère '<code>^</code>' possède un sens différent lorsqu'il est utilisé dans un motif d'ensemble de caractères. Voir les <a href="#special-negated-character-set">compléments sur les ensembles de caractères </a>pour plus de détails et d'exemples.</td>
-  </tr>
-  <tr>
-   <td><code>$</code></td>
-   <td>
-    <p>Correspond à la fin de la séquence. Si le marqueur (<em>flag</em>) de lignes multiples vaut true, il correspondra également immédiatement avant un caractère de saut de ligne.</p>
-
-    <p>Ainsi, <code>/t$/</code> ne correspond pas au 't' de "printemps", mais correspond au 't' de "aliment".</p>
-   </td>
-  </tr>
-  <tr>
-   <td><code>*</code></td>
-   <td>
-    <p>Correspond à l'expression précédente qui est répétée 0 ou plusieurs fois. Équivalent à <code>{0,}</code></p>
-
-    <p>Ainsi, <code>/bo*/</code> correspond à 'boo' dans "Un booléen" et à 'b' dans "Un bateau bleu", mais ne correspond à rien dans "Ce matin".</p>
-   </td>
-  </tr>
-  <tr>
-   <td><code>+</code></td>
-   <td>
-    <p>Correspond à l'expression précédente qui est répétée une ou plusieurs fois. C'est équivalent à <code>{1,}</code>.</p>
-
-    <p>Ainsi, <code>/a+/</code> correspond au 'a' dans "maison" et à tous les 'a' dans "maaaaaaison" mais ne correspond à rien dans "mission".</p>
-   </td>
-  </tr>
-  <tr>
-   <td><code>?</code></td>
-   <td>Correspond à l'expression précédente qui est présente une fois ou pas du tout. C'est équivalent à <code>{0,1}</code>.<br>
-    <br>
-    Ainsi, <code>/e?le?/</code> correspond au 'el' dans "gel" et au 'le' dans "angle" mais aussi au 'l' dans "Oslo".<br>
-    <br>
-    S'il est utilisé immédiatement après l'un des quantificateurs : *, +, ?, ou {}, il rend le quantificateur moins « gourmand » auquel cas le moins de caractères correspond (le comportement par défaut, « gourmand », permettant de faire correspondre le plus de caractères possible). Par exemple <code>/\d+/</code> utilisée avec "123abc" fait correspondre "123". Utiliser <code>/\d+?/</code> à la même chaîne de caractères fait correspondre "1".<br>
-    <br>
-    Ce symbole est également utilisé dans les tests de présence autour de l'expression, décrits par les lignes <code>x(?=y)</code> et <code>x(?!y)</code> de ce tableau.</td>
-  </tr>
-  <tr>
-   <td><code>.</code></td>
-   <td>
-    <p>Par défaut, (Le point) correspond à n'importe quel caractère excepté un caractère de saut de ligne.</p>
-
-    <p>Ainsi, <code>/.n/</code> correspond à 'un' et 'en' dans "Un baobab nain en cours de croissance" mais pas à 'nain'.</p>
-
-    <p>Si le marqueur <code>s</code> (<em>dotAll</em>) est utilisé, le point correspondra également aux caractères de saut de ligne.</p>
-   </td>
-  </tr>
-  <tr>
-   <td><code>(x)</code></td>
-   <td>
-    <p>Correspond à 'x' et garde la correspondance en mémoire. Les parenthèses permettent de <em>capturer </em>l'expression dans un « groupe ».<br>
-     <br>
-     Les '<code>(toto)</code>' et '<code>(truc)</code>', dans le motif <code>/(toto) (truc) \1 \2/</code> correspondent et gardent en mémoire les deux premiers mots de la chaîne de caractère "toto truc toto truc". Les <code>\1</code> et <code>\2</code> du motif correspondent respectivement à la première et à la deuxième correspondances pour les sous-chaînes entre parenthèses. Lorsqu'on souhaite effectuer un remplacement, on utilisera <code>$1</code> et <code>$2</code> pour faire référence au premier et second groupe et <code>$</code><code>n </code>pour faire référence au n-ième groupe capturé (ex. <code>('toto truc'.replace(/(...) (...)/, '$2 $1').</code> <code>$&amp;</code> fera référence à la chaîne entière).</p>
-   </td>
-  </tr>
-  <tr>
-   <td><code>(?:x)</code></td>
-   <td>Correspond à 'x' mais ne garde pas la correspondance en mémoire. Les parenthèses ne <em>capturent</em> pas l'expression et permettent d'utiliser des sous-expressions d'une expression régulière pour travailler plus finement. L'expression <code>/(?:zoo){1,2}/</code> sans parenthèses non-capturantes <code>les caractères {1,2}</code> ne s'appliqueraient qu'au dernier 'o' de 'zoo'. Avec les parenthèses capturantes, <code>{1,2}</code> s'applique au mot entier 'zoo'. Pour plus d'informations, voir <a href="#parentheses">Utiliser les parenthèses</a> ci-après.</td>
-  </tr>
-  <tr>
-   <td><code>x(?=y)</code></td>
-   <td>
-    <p>Correspond à 'x' seulement s'il est suivi de 'y'. On appelle cela un test de succession (<em>lookahead</em>).</p>
-
-    <p>Ainsi, <code>/Jack(?=Sparrow)/</code> correspond à 'Jack' seulement s'il est suivi de 'Sparrow'. <code>/Jack(?=Sparrow|Bauer)/</code> correspond à 'Jack' seulement s'il est suivi de 'Sparrow' ou de 'Bauer'. Cependant, ni 'Sparrow' ni 'Bauer' ne feront partie de la correspondance.</p>
-   </td>
-  </tr>
-  <tr>
-   <td><code>x(?!y)</code></td>
-   <td>
-    <p>Correspond à 'x' seulement si 'x' n'est pas suivi de 'y'.</p>
-
-    <p>Ainsi, <code>/\d+(?!\.)/</code> correspond à un nombre qui n'est pas suivi par un point, cette expression utilisée avec <code>la chaîne 3.141</code> correspondra pour '141' mais pas pour '3.141'.</p>
-   </td>
-  </tr>
-  <tr>
-   <td><code>(?&lt;=<em>y</em>)<em>x</em></code></td>
-   <td>
-    <p>Correspond à <code><em>x</em></code> seulement si <code><em>x</em></code> est précédé par <code><em>y</em></code>. C'est ce qu'on appelle une recherche arrière (<em>lookbehind</em>).</p>
-
-    <p>Ainsi /<code>(?&lt;=Jack)Sprat/</code> correspond à "Sprat" seulement s'il est précédé de "Jack".<br>
-     <code>/(?&lt;=Jack|Tom)Sprat/</code> correspond à "Sprat" seulement s'il est précédé de "Jack" ou "Tom".<br>
-     Toutefois, "Jack" et "Tom" ne feront pas partie de la correspondance.</p>
-   </td>
-  </tr>
-  <tr>
-   <td><code>(?&lt;!<em>y</em>)<em>x</em></code></td>
-   <td>
-    <p>Correspond à <code><em>x</em></code> uniquement si <code><em>x</em></code> n'est pas précédé par <code><em>y</em></code> (parfois appelée en anglais <em>negated lookbehind</em>)<em>.</em></p>
-
-    <p>Ainsi, <code>/(?&lt;!-)\d+/</code> correspondra à un nombre seulement si celui-ci n'est pas précédé d'un signe moins.<br>
-     <code>/(?&lt;!-)\d+/.exec('3')</code> cible "3".<br>
-     <code>/(?&lt;!-)\d+/.exec('-3')</code> ne trouve aucune correspondance car le nombre est précédé d'un signe.</p>
-   </td>
-  </tr>
-  <tr>
-   <td><code>x|y</code></td>
-   <td>
-    <p>Correspond à 'x' ou 'y'.</p>
-
-    <p>Ainsi, <code>/vert|rouge/</code> correspond à 'vert' dans "feu vert" et à 'rouge' dans "feu rouge".</p>
-   </td>
-  </tr>
-  <tr>
-   <td><code>{n}</code></td>
-   <td>Correspond pour exactement n occurences de l'expression précédente. N doit être un entier positif.<br>
-    <br>
-    Ainsi, <code>/a{2}/</code> ne correspond pas au 'a' de "Mozilla" mais correspond à tous les 'a' de "Mozilaa" et aux deux premiers 'a' de "Mozillaaa".</td>
-  </tr>
-  <tr>
-   <td><code>{n,}</code></td>
-   <td>
-    <p>Correspond lorsqu'il y a au moins <code>n</code> occurences de l'expression précédente. <code>n</code> doit être un entier positif.</p>
-
-    <p>Par exemple <code>/a{2,}/</code> correspondra à <code>"aa"</code> ou à <code>"aaa"</code> ou encore à <code>"aaaa"</code> mais pas à <code>"a"</code>.</p>
-   </td>
-  </tr>
-  <tr>
-   <td><code>{n,m}</code></td>
-   <td>
-    <p>Lorsque <code>n</code> et <code>m</code> sont des entiers positifs, cela correspond à au moins <code>n</code> occurences de l'expression précédente et à au plus <code>m</code> occurrences. Lorsque <code>m</code> n'est pas utilisé, la valeur par défaut correspondante sera l'infini.</p>
-
-    <p>Ainsi, <code>/a{1,3}/</code> ne correspond à rien dans "Mozill", au 'a' de "Mozilla", au deux premiers 'a' de "Mozillaa" et au trois premiers 'a' de "Mozillaaaaa". Pour ce dernier exemple, on doit noter que le correspondance ne se fait que sur "aaa" bien qu'il y ait plus de 'a' dans la chaîne de caractères.</p>
-   </td>
-  </tr>
-  <tr>
-   <td><code>[xyz]</code></td>
-   <td>Un ensemble de caractère. Ce type de motif correspond pour n'importe quel caractètre présent entre les crochets, y compris les <a href="/fr/docs/Web/JavaScript/Guide/Types_et_grammaire#Les_caractères_d'échappement">séquences d'échappement</a>. Les caractères spéciaux comme le point (.) et l'astérisque ne sont pas considérés comme spéciaux au sein d'un ensemble et n'ont donc pas besoin d'être échappés. Il est possible de donner un ensemble sur un intervalle de caractères en utilisant un tiret (-), comme le montre l'exemple qui suit.<br>
-    <br>
-    Le motif <code>[a-d]</code>, aura les mêmes correspondances que <code>[abcd]</code>, correspondant au 'b' de "bulle" et au 'c' de "ciel". Les motifis <code>/[a-z.]+/ </code>et <code>/[\w.]+/</code> correspondront pour la chaîne entirère : "Adre.ss.e".</td>
-  </tr>
-  <tr>
-   <td><code>[^xyz]</code></td>
-   <td>
-    <p>Exclusion d'un ensemble de caractères. Cela correspond à tout ce qui n'est pas compris entre crochets. Il est possible de fournir un intervalle de caractères en utilisant un tiret (-). Les autres règles qui s'appliquent pour l'ensemble de caractères (ci-avant) s'appliquent également ici.</p>
-
-    <p>Par exemple, <code>[^abc]</code> est équivalent à <code>[^a-c]</code>. Ils correspondent à 'u' dans "bulle" et à 'i' dans "ciel".</p>
-   </td>
-  </tr>
-  <tr>
-   <td><code>[\b]</code></td>
-   <td>Correspond pour un retour arrière (U+0008). (À ne pas confondre avec <code>\b</code>.)</td>
-  </tr>
-  <tr>
-   <td><code>\b</code></td>
-   <td>
-    <p>Correspond à la position d'uneAfter the <em>limite de mot</em>. Une limite de mot correspond à la position où un caractère d'un mot n'est pas suivi ou précédé d'un autre caractère de mot. Il faut savoir que la limite correspondante n'est pas incluse dans le résultat. Autrement dit, la longueur d'une telle correspondance est nulle. (À ne pas confondre avec <code>[\b]</code>.)</p>
-
-    <p>Exemples :<br>
-     <code>/\bm/</code> correspond au 'm' dans "mignon" ;<br>
-     <code>/no\b/</code> ne correspond pas au 'no' de "mignon" car 'no' est suivi de 'n' qui n'est pas un caractère de limite de mot;<br>
-     <code>/non\b/</code> correspond au 'non' de "mignon" car 'non' représente la fin de la chaîne de caractère et n'est donc pas suivi par un caractère de mot.<br>
-     <code>/\w\b\w/</code> ne correspondra jamais à quoi que ce soit car un caractère de mot ne peut pas être suivi à la fois par un caractère de mot et un caractère n'étant pas un caractère de mot.</p>
-
-    <div class="note">
-    <p><strong>Note :</strong> Le moteur d'expressions rationnelles JavaScript définit <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-15.10.2.6">un ensemble de caractères spécifiques</a> qui doivent être considérés comme des caractères de mot. Tout caractère qui n'est pas dans cet ensemble est considéré comme une limite de mot. Cet ensemble de caractères est relativement limité car constitué uniquement des caractères de l'alphabet romain en minuscules et en majuscules, des chiffres décimaux et du tiret-bas (<em>underscore</em>). Les autres caractères, comme les caractères accentués (é ou ü par exemple), sont donc considérés comme des limites de mots.</p>
-    </div>
-   </td>
-  </tr>
-  <tr>
-   <td><code>\B</code></td>
-   <td>
-    <p>Correspond à une "non-<em>limite de mot</em>". Cela correspond pour les cas suivants :</p>
-
-    <ul>
-     <li>Avant le premier caractère d'une chaîne de caractères</li>
-     <li>Après le dernier caractère d'une chaîne de caractères</li>
-     <li>Entre deux caractères de mot</li>
-     <li>Entre deux caractères qui ne sont pas des caractères de mot</li>
-     <li>Avec la chaîne vide.</li>
-    </ul>
-
-    <p>Ainsi, <code>/\B../</code> correspond au 'oo' de "football" (et <code>/e\B./</code> correspond au 'er' dans "une mer "</p>
-   </td>
-  </tr>
-  <tr>
-   <td><code>\c<em>X</em></code></td>
-   <td>
-    <p>Étant donné un caractère <em>X</em> compris entre A et Z, cela correspond au caractère de contrôle dans une chaîne de caractères.</p>
-
-    <p>Ainsi, <code>/\cM/</code> correspond au caractère de contrôle M (U+000D) d'une chaîne de caractère.</p>
-   </td>
-  </tr>
-  <tr>
-   <td><code>\d</code></td>
-   <td>
-    <p>Correspond à un chiffre et est équivalent à <code>[0-9]</code>.</p>
-
-    <p>Ainsi, <code>/\d/</code> ou <code>/[0-9]/</code> correspond à '2' dans "H2O est la molécule de l'eau".</p>
-   </td>
-  </tr>
-  <tr>
-   <td><code>\D</code></td>
-   <td>
-    <p>Correspond à tout caractère qui n'est pas un chiffre et est équivalent à<code> [^0-9]</code>.</p>
-
-    <p>Ainsi, <code>/\D/</code> ou <code>/[^0-9]/</code> correspond à 'H' dans "H2O est la molécule de l'eau".</p>
-   </td>
-  </tr>
-  <tr>
-   <td><code>\f</code></td>
-   <td>Correspond à un saut de page (U+000C).</td>
-  </tr>
-  <tr>
-   <td><code>\n</code></td>
-   <td>Correspond à un saut de ligne (U+000A).</td>
-  </tr>
-  <tr>
-   <td><code>\r</code></td>
-   <td>Correspond à un retour chariot (U+000D).</td>
-  </tr>
-  <tr>
-   <td><code>\s</code></td>
-   <td>
-    <p>Correspond à un blanc (cela comprend les espace, tabulation, saut de ligne ou saut de page). C'est équivalent à <code>[ \f\n\r\t\v\u00a0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff]</code>.</p>
-
-    <p>Ainsi, <code>/\s\w*/</code> correspond à ' toto' dans "truc toto".</p>
-   </td>
-  </tr>
-  <tr>
-   <td><code>\S</code></td>
-   <td>
-    <p>Correspond à un caractère qui n'est pas un blanc. C'est équivalent à <code>[^ \f\n\r\t\v\u00a0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff]</code>.</p>
-
-    <p>Ainsi, <code>/\S\w*/</code> correspond à 'truc' dans "truc toto".</p>
-   </td>
-  </tr>
-  <tr>
-   <td><code>\t</code></td>
-   <td>Correspond à une tabulation (U+0009).</td>
-  </tr>
-  <tr>
-   <td><code>\v</code></td>
-   <td>Correspond à une tabulation verticale (U+000B).</td>
-  </tr>
-  <tr>
-   <td><code>\w</code></td>
-   <td>
-    <p>Correspond à n'importe quel caractère alphanumérique, y compris le tiret bas. C'est équivalent à <code>[A-Za-z0-9_]</code>.</p>
-
-    <p>Ainsi, <code>/\w/</code> correspond à 'l' dans "licorne", à '5' dans "5,28€", et à '3' dans "3D."</p>
-   </td>
-  </tr>
-  <tr>
-   <td><code>\W</code></td>
-   <td>
-    <p>Correspond à n'importe quel caractère n'étant pas un caractère de mot. Cela est équivalent à <code>[^A-Za-z0-9_]</code>.</p>
-
-    <p>Ainsi, <code>/\W/</code> ou <code>/[^A-Za-z0-9_]/</code> correspond à '%' dans "50%."</p>
-   </td>
-  </tr>
-  <tr>
-   <td><code>\n</code></td>
-   <td>
-    <p>Soit <em>n</em> un entier strictement positif, cela fait référence au groupe de la n-ième expression entre parenthèses (en comptant les parenthèses ouvrantes).</p>
-
-    <p>Ainsi, <code>/pomme(,)\spoire\1/</code> correspond à 'pomme, poire,' dans "pomme, poire, cerise, pêche".</p>
-   </td>
-  </tr>
-  <tr>
-   <td><code>\0</code></td>
-   <td>Correspond au caractère NULL (U+0000). Il ne doit pas être suivi d'un autre chiffre car <code>\0&lt;chiffres&gt;</code> est une <a href="/fr/docs/Web/JavaScript/Guide/Types_et_grammaire#Les_caractères_d'échappement">séquence d'échappement</a> pour les nombres en notation octale (si besoin d'utiliser un chiffre ensuite, on pourra utiliser la forme <code>\x00</code>, cf. ci-après).</td>
-  </tr>
-  <tr>
-   <td><code>\xhh</code></td>
-   <td>Correspond au caractère dont le code hexadécimal est hh (deux chiffres hexadécimaux).</td>
-  </tr>
-  <tr>
-   <td><code>\uhhhh</code></td>
-   <td>Correspond au caractère dont le code est hhhh (quatre chiffres hexadécimaux).</td>
-  </tr>
-  <tr>
-   <td><code>\u{hhhh}</code></td>
-   <td>(Uniquement actif quand le marqueur <code>u</code> est activé) Correspond au caractère dont la valeur Unicode est <code>hhhh</code> (en chiffre hexadécimaux).</td>
-  </tr>
- </tbody>
+  <caption>
+    Caractères spéciaux utilisables pour les expressions rationnelles.
+  </caption>
+  <thead>
+    <tr>
+      <th scope="col">Caractère</th>
+      <th scope="col">Signification</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td><code>\</code></td>
+      <td>
+        <p>
+          Correspond selon les règles suivantes :<br /><br />Une barre oblique
+          inversée (<em>backslash</em>) précédant un caractère non spécial
+          indique que le caractère qui suit est spécial et qu'il ne doit pas
+          être interprété directement. Ainsi, un '<code>b</code>', sans
+          <code>\</code> avant, correspondra pour les 'b' minuscules quel que
+          soit leur position. En revanche '<code>\b</code>' ne correspondra à
+          aucun caractère mais indique
+          <a href="#special-word-boundary">un caractère de fin de mot</a
+          >.<br /><br />Un <em>backslash</em> précédant un caractère spécial
+          indique que le caractère qui suit doit être interprété littéralement
+          (et non pas comme un caractère spécial). Ainsi, le motif
+          <code>/a*/</code> utilise le caractère spécial '<code>*</code>' pour
+          correspondre à 0 ou plusieurs 'a'. Le motif <code>/a\*/</code>, au
+          contraire, rend '<code>*</code>' non-spécial pour correspondre aux
+          chaînes de caractères qui comportent la lettre a et une astérisque,
+          comme 'a*'.<br /><br />Il ne faut pas oublier d'échapper le caractère
+          <code>\</code> car lui-même est un caractère d'échappement dans les
+          chaînes de caractères. Cela est utile lorsqu'on utilise la notation
+          RegExp("motif").
+        </p>
+      </td>
+    </tr>
+    <tr>
+      <td><code>^</code></td>
+      <td>
+        Correspond au début la séquence. Si le marqueur (<em>flag</em>) de
+        lignes multiples vaut <code>true</code>, il correspondra également
+        immédiatement après un caractère de saut de ligne.<br /><br />Ainsi,
+        <code>/^A/</code> ne correspond pas au 'A' de "un A", mais correspond au
+        'A' de "Arceau".<br /><br />Le caractère '<code>^</code>' possède un
+        sens différent lorsqu'il est utilisé dans un motif d'ensemble de
+        caractères. Voir les
+        <a href="#special-negated-character-set"
+          >compléments sur les ensembles de caractères </a
+        >pour plus de détails et d'exemples.
+      </td>
+    </tr>
+    <tr>
+      <td><code>$</code></td>
+      <td>
+        <p>
+          Correspond à la fin de la séquence. Si le marqueur (<em>flag</em>) de
+          lignes multiples vaut true, il correspondra également immédiatement
+          avant un caractère de saut de ligne.
+        </p>
+        <p>
+          Ainsi, <code>/t$/</code> ne correspond pas au 't' de "printemps", mais
+          correspond au 't' de "aliment".
+        </p>
+      </td>
+    </tr>
+    <tr>
+      <td><code>*</code></td>
+      <td>
+        <p>
+          Correspond à l'expression précédente qui est répétée 0 ou plusieurs
+          fois. Équivalent à <code>{0,}</code>
+        </p>
+        <p>
+          Ainsi, <code>/bo*/</code> correspond à 'boo' dans "Un booléen" et à
+          'b' dans "Un bateau bleu", mais ne correspond à rien dans "Ce matin".
+        </p>
+      </td>
+    </tr>
+    <tr>
+      <td><code>+</code></td>
+      <td>
+        <p>
+          Correspond à l'expression précédente qui est répétée une ou plusieurs
+          fois. C'est équivalent à <code>{1,}</code>.
+        </p>
+        <p>
+          Ainsi, <code>/a+/</code> correspond au 'a' dans "maison" et à tous les
+          'a' dans "maaaaaaison" mais ne correspond à rien dans "mission".
+        </p>
+      </td>
+    </tr>
+    <tr>
+      <td><code>?</code></td>
+      <td>
+        Correspond à l'expression précédente qui est présente une fois ou pas du
+        tout. C'est équivalent à <code>{0,1}</code>.<br /><br />Ainsi,
+        <code>/e?le?/</code> correspond au 'el' dans "gel" et au 'le' dans
+        "angle" mais aussi au 'l' dans "Oslo".<br /><br />S'il est utilisé
+        immédiatement après l'un des quantificateurs : *, +, ?, ou {}, il rend
+        le quantificateur moins « gourmand » auquel cas le moins de caractères
+        correspond (le comportement par défaut, « gourmand », permettant de
+        faire correspondre le plus de caractères possible). Par exemple
+        <code>/\d+/</code> utilisée avec "123abc" fait correspondre "123".
+        Utiliser <code>/\d+?/</code> à la même chaîne de caractères fait
+        correspondre "1".<br /><br />Ce symbole est également utilisé dans les
+        tests de présence autour de l'expression, décrits par les lignes
+        <code>x(?=y)</code> et <code>x(?!y)</code> de ce tableau.
+      </td>
+    </tr>
+    <tr>
+      <td><code>.</code></td>
+      <td>
+        <p>
+          Par défaut, (Le point) correspond à n'importe quel caractère excepté
+          un caractère de saut de ligne.
+        </p>
+        <p>
+          Ainsi, <code>/.n/</code> correspond à 'un' et 'en' dans "Un baobab
+          nain en cours de croissance" mais pas à 'nain'.
+        </p>
+        <p>
+          Si le marqueur <code>s</code> (<em>dotAll</em>) est utilisé, le point
+          correspondra également aux caractères de saut de ligne.
+        </p>
+      </td>
+    </tr>
+    <tr>
+      <td><code>(x)</code></td>
+      <td>
+        <p>
+          Correspond à 'x' et garde la correspondance en mémoire. Les
+          parenthèses permettent de <em>capturer </em>l'expression dans un «
+          groupe ».<br /><br />Les '<code>(toto)</code>' et
+          '<code>(truc)</code>', dans le motif
+          <code>/(toto) (truc) \1 \2/</code> correspondent et gardent en mémoire
+          les deux premiers mots de la chaîne de caractère "toto truc toto
+          truc". Les <code>\1</code> et <code>\2</code> du motif correspondent
+          respectivement à la première et à la deuxième correspondances pour les
+          sous-chaînes entre parenthèses. Lorsqu'on souhaite effectuer un
+          remplacement, on utilisera <code>$1</code> et <code>$2</code> pour
+          faire référence au premier et second groupe et <code>$</code
+          ><code>n </code>pour faire référence au n-ième groupe capturé (ex.
+          <code>('toto truc'.replace(/(...) (...)/, '$2 $1').</code>
+          <code>$&#x26;</code> fera référence à la chaîne entière).
+        </p>
+      </td>
+    </tr>
+    <tr>
+      <td><code>(?:x)</code></td>
+      <td>
+        Correspond à 'x' mais ne garde pas la correspondance en mémoire. Les
+        parenthèses ne <em>capturent</em> pas l'expression et permettent
+        d'utiliser des sous-expressions d'une expression régulière pour
+        travailler plus finement. L'expression <code>/(?:zoo){1,2}/</code> sans
+        parenthèses non-capturantes <code>les caractères {1,2}</code> ne
+        s'appliqueraient qu'au dernier 'o' de 'zoo'. Avec les parenthèses
+        capturantes, <code>{1,2}</code> s'applique au mot entier 'zoo'. Pour
+        plus d'informations, voir
+        <a href="#parentheses">Utiliser les parenthèses</a> ci-après.
+      </td>
+    </tr>
+    <tr>
+      <td><code>x(?=y)</code></td>
+      <td>
+        <p>
+          Correspond à 'x' seulement s'il est suivi de 'y'. On appelle cela un
+          test de succession (<em>lookahead</em>).
+        </p>
+        <p>
+          Ainsi, <code>/Jack(?=Sparrow)/</code> correspond à 'Jack' seulement
+          s'il est suivi de 'Sparrow'.
+          <code>/Jack(?=Sparrow|Bauer)/</code> correspond à 'Jack' seulement
+          s'il est suivi de 'Sparrow' ou de 'Bauer'. Cependant, ni 'Sparrow' ni
+          'Bauer' ne feront partie de la correspondance.
+        </p>
+      </td>
+    </tr>
+    <tr>
+      <td><code>x(?!y)</code></td>
+      <td>
+        <p>Correspond à 'x' seulement si 'x' n'est pas suivi de 'y'.</p>
+        <p>
+          Ainsi, <code>/\d+(?!\.)/</code> correspond à un nombre qui n'est pas
+          suivi par un point, cette expression utilisée avec
+          <code>la chaîne 3.141</code> correspondra pour '141' mais pas pour
+          '3.141'.
+        </p>
+      </td>
+    </tr>
+    <tr>
+      <td>
+        <code>(?&#x3C;=<em>y</em>)<em>x</em></code>
+      </td>
+      <td>
+        <p>
+          Correspond à <code><em>x</em></code> seulement si
+          <code><em>x</em></code> est précédé par <code><em>y</em></code
+          >. C'est ce qu'on appelle une recherche arrière (<em>lookbehind</em>).
+        </p>
+        <p>
+          Ainsi /<code>(?&#x3C;=Jack)Sprat/</code> correspond à "Sprat"
+          seulement s'il est précédé de "Jack".<br /><code
+            >/(?&#x3C;=Jack|Tom)Sprat/</code
+          >
+          correspond à "Sprat" seulement s'il est précédé de "Jack" ou "Tom".<br />Toutefois,
+          "Jack" et "Tom" ne feront pas partie de la correspondance.
+        </p>
+      </td>
+    </tr>
+    <tr>
+      <td>
+        <code>(?&#x3C;!<em>y</em>)<em>x</em></code>
+      </td>
+      <td>
+        <p>
+          Correspond à <code><em>x</em></code> uniquement si
+          <code><em>x</em></code> n'est pas précédé par
+          <code><em>y</em></code> (parfois appelée en anglais
+          <em>negated lookbehind</em>)<em>.</em>
+        </p>
+        <p>
+          Ainsi, <code>/(?&#x3C;!-)\d+/</code> correspondra à un nombre
+          seulement si celui-ci n'est pas précédé d'un signe moins.<br /><code
+            >/(?&#x3C;!-)\d+/.exec('3')</code
+          >
+          cible "3".<br /><code>/(?&#x3C;!-)\d+/.exec('-3')</code> ne trouve
+          aucune correspondance car le nombre est précédé d'un signe.
+        </p>
+      </td>
+    </tr>
+    <tr>
+      <td><code>x|y</code></td>
+      <td>
+        <p>Correspond à 'x' ou 'y'.</p>
+        <p>
+          Ainsi, <code>/vert|rouge/</code> correspond à 'vert' dans "feu vert"
+          et à 'rouge' dans "feu rouge".
+        </p>
+      </td>
+    </tr>
+    <tr>
+      <td><code>{n}</code></td>
+      <td>
+        Correspond pour exactement n occurences de l'expression précédente. N
+        doit être un entier positif.<br /><br />Ainsi, <code>/a{2}/</code> ne
+        correspond pas au 'a' de "Mozilla" mais correspond à tous les 'a' de
+        "Mozilaa" et aux deux premiers 'a' de "Mozillaaa".
+      </td>
+    </tr>
+    <tr>
+      <td><code>{n,}</code></td>
+      <td>
+        <p>
+          Correspond lorsqu'il y a au moins <code>n</code> occurences de
+          l'expression précédente. <code>n</code> doit être un entier positif.
+        </p>
+        <p>
+          Par exemple <code>/a{2,}/</code> correspondra à <code>"aa"</code> ou à
+          <code>"aaa"</code> ou encore à <code>"aaaa"</code> mais pas à
+          <code>"a"</code>.
+        </p>
+      </td>
+    </tr>
+    <tr>
+      <td><code>{n,m}</code></td>
+      <td>
+        <p>
+          Lorsque <code>n</code> et <code>m</code> sont des entiers positifs,
+          cela correspond à au moins <code>n</code> occurences de l'expression
+          précédente et à au plus <code>m</code> occurrences. Lorsque
+          <code>m</code> n'est pas utilisé, la valeur par défaut correspondante
+          sera l'infini.
+        </p>
+        <p>
+          Ainsi, <code>/a{1,3}/</code> ne correspond à rien dans "Mozill", au
+          'a' de "Mozilla", au deux premiers 'a' de "Mozillaa" et au trois
+          premiers 'a' de "Mozillaaaaa". Pour ce dernier exemple, on doit noter
+          que le correspondance ne se fait que sur "aaa" bien qu'il y ait plus
+          de 'a' dans la chaîne de caractères.
+        </p>
+      </td>
+    </tr>
+    <tr>
+      <td><code>[xyz]</code></td>
+      <td>
+        Un ensemble de caractère. Ce type de motif correspond pour n'importe
+        quel caractètre présent entre les crochets, y compris les
+        <a
+          href="/fr/docs/Web/JavaScript/Guide/Types_et_grammaire#Les_caractères_d&#x27;échappement"
+          >séquences d'échappement</a
+        >. Les caractères spéciaux comme le point (.) et l'astérisque ne sont
+        pas considérés comme spéciaux au sein d'un ensemble et n'ont donc pas
+        besoin d'être échappés. Il est possible de donner un ensemble sur un
+        intervalle de caractères en utilisant un tiret (-), comme le montre
+        l'exemple qui suit.<br /><br />Le motif <code>[a-d]</code>, aura les
+        mêmes correspondances que <code>[abcd]</code>, correspondant au 'b' de
+        "bulle" et au 'c' de "ciel". Les motifis <code>/[a-z.]+/ </code>et
+        <code>/[\w.]+/</code> correspondront pour la chaîne entirère :
+        "Adre.ss.e".
+      </td>
+    </tr>
+    <tr>
+      <td><code>[^xyz]</code></td>
+      <td>
+        <p>
+          Exclusion d'un ensemble de caractères. Cela correspond à tout ce qui
+          n'est pas compris entre crochets. Il est possible de fournir un
+          intervalle de caractères en utilisant un tiret (-). Les autres règles
+          qui s'appliquent pour l'ensemble de caractères (ci-avant) s'appliquent
+          également ici.
+        </p>
+        <p>
+          Par exemple, <code>[^abc]</code> est équivalent à <code>[^a-c]</code>.
+          Ils correspondent à 'u' dans "bulle" et à 'i' dans "ciel".
+        </p>
+      </td>
+    </tr>
+    <tr>
+      <td><code>[\b]</code></td>
+      <td>
+        Correspond pour un retour arrière (U+0008). (À ne pas confondre avec
+        <code>\b</code>.)
+      </td>
+    </tr>
+    <tr>
+      <td><code>\b</code></td>
+      <td>
+        <p>
+          Correspond à la position d'uneAfter the <em>limite de mot</em>. Une
+          limite de mot correspond à la position où un caractère d'un mot n'est
+          pas suivi ou précédé d'un autre caractère de mot. Il faut savoir que
+          la limite correspondante n'est pas incluse dans le résultat. Autrement
+          dit, la longueur d'une telle correspondance est nulle. (À ne pas
+          confondre avec <code>[\b]</code>.)
+        </p>
+        <p>
+          Exemples :<br /><code>/\bm/</code> correspond au 'm' dans "mignon"
+          ;<br /><code>/no\b/</code> ne correspond pas au 'no' de "mignon" car
+          'no' est suivi de 'n' qui n'est pas un caractère de limite de mot;<br /><code
+            >/non\b/</code
+          >
+          correspond au 'non' de "mignon" car 'non' représente la fin de la
+          chaîne de caractère et n'est donc pas suivi par un caractère de
+          mot.<br /><code>/\w\b\w/</code> ne correspondra jamais à quoi que ce
+          soit car un caractère de mot ne peut pas être suivi à la fois par un
+          caractère de mot et un caractère n'étant pas un caractère de mot.
+        </p>
+        <div class="note">
+          <p>
+            <strong>Note :</strong> Le moteur d'expressions rationnelles
+            JavaScript définit
+            <a
+              href="http://www.ecma-international.org/ecma-262/5.1/#sec-15.10.2.6"
+              >un ensemble de caractères spécifiques</a
+            >
+            qui doivent être considérés comme des caractères de mot. Tout
+            caractère qui n'est pas dans cet ensemble est considéré comme une
+            limite de mot. Cet ensemble de caractères est relativement limité
+            car constitué uniquement des caractères de l'alphabet romain en
+            minuscules et en majuscules, des chiffres décimaux et du tiret-bas
+            (<em>underscore</em>). Les autres caractères, comme les caractères
+            accentués (é ou ü par exemple), sont donc considérés comme des
+            limites de mots.
+          </p>
+        </div>
+      </td>
+    </tr>
+    <tr>
+      <td><code>\B</code></td>
+      <td>
+        <p>
+          Correspond à une "non-<em>limite de mot</em>". Cela correspond pour
+          les cas suivants :
+        </p>
+        <ul>
+          <li>Avant le premier caractère d'une chaîne de caractères</li>
+          <li>Après le dernier caractère d'une chaîne de caractères</li>
+          <li>Entre deux caractères de mot</li>
+          <li>Entre deux caractères qui ne sont pas des caractères de mot</li>
+          <li>Avec la chaîne vide.</li>
+        </ul>
+        <p>
+          Ainsi, <code>/\B../</code> correspond au 'oo' de "football" (et
+          <code>/e\B./</code> correspond au 'er' dans "une mer "
+        </p>
+      </td>
+    </tr>
+    <tr>
+      <td>
+        <code>\c<em>X</em></code>
+      </td>
+      <td>
+        <p>
+          Étant donné un caractère <em>X</em> compris entre A et Z, cela
+          correspond au caractère de contrôle dans une chaîne de caractères.
+        </p>
+        <p>
+          Ainsi, <code>/\cM/</code> correspond au caractère de contrôle M
+          (U+000D) d'une chaîne de caractère.
+        </p>
+      </td>
+    </tr>
+    <tr>
+      <td><code>\d</code></td>
+      <td>
+        <p>Correspond à un chiffre et est équivalent à <code>[0-9]</code>.</p>
+        <p>
+          Ainsi, <code>/\d/</code> ou <code>/[0-9]/</code> correspond à '2' dans
+          "H2O est la molécule de l'eau".
+        </p>
+      </td>
+    </tr>
+    <tr>
+      <td><code>\D</code></td>
+      <td>
+        <p>
+          Correspond à tout caractère qui n'est pas un chiffre et est équivalent
+          à<code> [^0-9]</code>.
+        </p>
+        <p>
+          Ainsi, <code>/\D/</code> ou <code>/[^0-9]/</code> correspond à 'H'
+          dans "H2O est la molécule de l'eau".
+        </p>
+      </td>
+    </tr>
+    <tr>
+      <td><code>\f</code></td>
+      <td>Correspond à un saut de page (U+000C).</td>
+    </tr>
+    <tr>
+      <td><code>\n</code></td>
+      <td>Correspond à un saut de ligne (U+000A).</td>
+    </tr>
+    <tr>
+      <td><code>\r</code></td>
+      <td>Correspond à un retour chariot (U+000D).</td>
+    </tr>
+    <tr>
+      <td><code>\s</code></td>
+      <td>
+        <p>
+          Correspond à un blanc (cela comprend les espace, tabulation, saut de
+          ligne ou saut de page). C'est équivalent à
+          <code
+            >[
+            \f\n\r\t\v\u00a0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff]</code
+          >.
+        </p>
+        <p>
+          Ainsi, <code>/\s\w*/</code> correspond à ' toto' dans "truc toto".
+        </p>
+      </td>
+    </tr>
+    <tr>
+      <td><code>\S</code></td>
+      <td>
+        <p>
+          Correspond à un caractère qui n'est pas un blanc. C'est équivalent à
+          <code
+            >[^
+            \f\n\r\t\v\u00a0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff]</code
+          >.
+        </p>
+        <p>Ainsi, <code>/\S\w*/</code> correspond à 'truc' dans "truc toto".</p>
+      </td>
+    </tr>
+    <tr>
+      <td><code>\t</code></td>
+      <td>Correspond à une tabulation (U+0009).</td>
+    </tr>
+    <tr>
+      <td><code>\v</code></td>
+      <td>Correspond à une tabulation verticale (U+000B).</td>
+    </tr>
+    <tr>
+      <td><code>\w</code></td>
+      <td>
+        <p>
+          Correspond à n'importe quel caractère alphanumérique, y compris le
+          tiret bas. C'est équivalent à <code>[A-Za-z0-9_]</code>.
+        </p>
+        <p>
+          Ainsi, <code>/\w/</code> correspond à 'l' dans "licorne", à '5' dans
+          "5,28€", et à '3' dans "3D."
+        </p>
+      </td>
+    </tr>
+    <tr>
+      <td><code>\W</code></td>
+      <td>
+        <p>
+          Correspond à n'importe quel caractère n'étant pas un caractère de mot.
+          Cela est équivalent à <code>[^A-Za-z0-9_]</code>.
+        </p>
+        <p>
+          Ainsi, <code>/\W/</code> ou <code>/[^A-Za-z0-9_]/</code> correspond à
+          '%' dans "50%."
+        </p>
+      </td>
+    </tr>
+    <tr>
+      <td><code>\n</code></td>
+      <td>
+        <p>
+          Soit <em>n</em> un entier strictement positif, cela fait référence au
+          groupe de la n-ième expression entre parenthèses (en comptant les
+          parenthèses ouvrantes).
+        </p>
+        <p>
+          Ainsi, <code>/pomme(,)\spoire\1/</code> correspond à 'pomme, poire,'
+          dans "pomme, poire, cerise, pêche".
+        </p>
+      </td>
+    </tr>
+    <tr>
+      <td><code>\0</code></td>
+      <td>
+        Correspond au caractère NULL (U+0000). Il ne doit pas être suivi d'un
+        autre chiffre car <code>\0&#x3C;chiffres></code> est une
+        <a
+          href="/fr/docs/Web/JavaScript/Guide/Types_et_grammaire#Les_caractères_d&#x27;échappement"
+          >séquence d'échappement</a
+        >
+        pour les nombres en notation octale (si besoin d'utiliser un chiffre
+        ensuite, on pourra utiliser la forme <code>\x00</code>, cf. ci-après).
+      </td>
+    </tr>
+    <tr>
+      <td><code>\xhh</code></td>
+      <td>
+        Correspond au caractère dont le code hexadécimal est hh (deux chiffres
+        hexadécimaux).
+      </td>
+    </tr>
+    <tr>
+      <td><code>\uhhhh</code></td>
+      <td>
+        Correspond au caractère dont le code est hhhh (quatre chiffres
+        hexadécimaux).
+      </td>
+    </tr>
+    <tr>
+      <td><code>\u{hhhh}</code></td>
+      <td>
+        (Uniquement actif quand le marqueur <code>u</code> est activé)
+        Correspond au caractère dont la valeur Unicode est <code>hhhh</code> (en
+        chiffre hexadécimaux).
+      </td>
+    </tr>
+  </tbody>
 </table>
 
-<p>Afin d'échapper les informations saisies par l'utilisateur et de traîter les chaînes de caractères pour les utiliser au sein d'un expression régulière correspondante, il est possible d'utiliser le remplacement suivant :</p>
+Afin d'échapper les informations saisies par l'utilisateur et de traîter les chaînes de caractères pour les utiliser au sein d'un expression régulière correspondante, il est possible d'utiliser le remplacement suivant :
 
-<pre class="brush: js notranslate">function escapeRegExp(string){
-  // $&amp; correspond à la chaîne correspondante
+```js
+function escapeRegExp(string){
+  // $& correspond à la chaîne correspondante
   // dans son intégralité
-  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&amp;");
-}</pre>
+  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+```
 
-<p>Le marqueur <code>g</code> situé en fin d'expression permet d'effectuer une recherche globale, qui parcoure toute la chaîne et renvoie l'ensemble des correspondances trouvées (voir <a href="#recherches_flag">Utiliser les marqueurs</a> ci-après).</p>
+Le marqueur `g` situé en fin d'expression permet d'effectuer une recherche globale, qui parcoure toute la chaîne et renvoie l'ensemble des correspondances trouvées (voir [Utiliser les marqueurs](#recherches_flag) ci-après).
 
-<div class="note">
-<p><strong>Note :</strong> Voir la page sur la méthode <code><a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/String/replace">String.replace</a></code> pour plus d'informations.</p>
-</div>
+> **Note :** Voir la page sur la méthode [`String.replace`](/fr/docs/Web/JavaScript/Reference/Objets_globaux/String/replace) pour plus d'informations.
 
-<h3 id="Utiliser_les_parenthèses">Utiliser les parenthèses</h3>
+### Utiliser les parenthèses
 
-<p>Les parenthèses encadrant une partie du motif de l'expression régulière peuvent être utilisées pour garder en mémoire les correspondances. Cela pourra être utile pour réutiliser la correspondance trouvée.</p>
+Les parenthèses encadrant une partie du motif de l'expression régulière peuvent être utilisées pour garder en mémoire les correspondances. Cela pourra être utile pour réutiliser la correspondance trouvée.
 
-<p>Ainsi, le motif <code>/Chapitre (\d+)\.\d*/</code> utilise des caractères échappés et spéciaux et indique une partie du motif à garder en mémoire. Ce motif correspond aux caractères 'Chapitre ' suivi par un ou plusieurs caractères numériques (<code>\d</code> correspond à un chiffre et <code>+</code> indiquant que une série de 1 ou plusieurs chiffres), suivis par un point (qu'il est nécessaire d'échapper car c'est un caractère spécial, on utilise donc '\' pour indiquer qu'on souhaite reconnaître le caractère '.'), suivi par 0 ou plusieurs chiffres (<code>\d</code> correspondant à un chiffre et l'astérisque indiquant que le caractère est présent 0 ou plusieurs fois). Les parenthèses sont utilisées pour garder en mémoire les premiers chiffres correspondant.</p>
+Ainsi, le motif `/Chapitre (\d+)\.\d*/` utilise des caractères échappés et spéciaux et indique une partie du motif à garder en mémoire. Ce motif correspond aux caractères 'Chapitre ' suivi par un ou plusieurs caractères numériques (`\d` correspond à un chiffre et `+` indiquant que une série de 1 ou plusieurs chiffres), suivis par un point (qu'il est nécessaire d'échapper car c'est un caractère spécial, on utilise donc '\\' pour indiquer qu'on souhaite reconnaître le caractère '.'), suivi par 0 ou plusieurs chiffres (`\d` correspondant à un chiffre et l'astérisque indiquant que le caractère est présent 0 ou plusieurs fois). Les parenthèses sont utilisées pour garder en mémoire les premiers chiffres correspondant.
 
-<p>Ce motif est trouvé dans "Ouvrir le Chapitre 4.3 au paragraphe 6" et le chiffre '4' est gardé en mémoire. Le motif n'est pas trouvé dans  "Chapitre 3 et 4", car la chaîne de caractères ne comporte pas de point après le '3'.</p>
+Ce motif est trouvé dans "Ouvrir le Chapitre 4.3 au paragraphe 6" et le chiffre '4' est gardé en mémoire. Le motif n'est pas trouvé dans  "Chapitre 3 et 4", car la chaîne de caractères ne comporte pas de point après le '3'.
 
-<p>Pour qu'une partie de la chaîne de caractère corresponde mais que la correspondance ne soit pas gardée en mémoire, on pourra utiliser <code>?:</code>. Ainsi, <code>(?:\d+)</code> correspondra pour une séquence de chiffres (1 ou plusieurs chiffres) mais on ne gardera pas en mémoire les caractères correspondants.</p>
+Pour qu'une partie de la chaîne de caractère corresponde mais que la correspondance ne soit pas gardée en mémoire, on pourra utiliser `?:`. Ainsi, `(?:\d+)` correspondra pour une séquence de chiffres (1 ou plusieurs chiffres) mais on ne gardera pas en mémoire les caractères correspondants.
 
-<h2 id="Utiliser_les_expressions_rationnelles">Utiliser les expressions rationnelles</h2>
+## Utiliser les expressions rationnelles
 
-<p>Les expresssions régulières sont utilisées avec les méthodes <code>test</code><code> </code>et<code> exec</code> de l'objet<code> RegExp</code> et avec les méthodes <code>match</code>, <code>replace</code>, <code>search</code>, et <code>split</code> de l'objet <code>String</code>. Ces méthodes sont expliquées en détail dans la <a href="/fr/docs/Web/JavaScript/Reference">Référence JavaScript</a>.</p>
+Les expresssions régulières sont utilisées avec les méthodes ` test``  `et` exec` de l'objet` RegExp` et avec les méthodes `match`, `replace`, `search`, et `split` de l'objet `String`. Ces méthodes sont expliquées en détail dans la [Référence JavaScript](/fr/docs/Web/JavaScript/Reference).
 
-<table class="standard-table">
- <caption>Méthodes utilisant les expressions régulières</caption>
- <thead>
-  <tr>
-   <th scope="col">Méthode</th>
-   <th scope="col">Description</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td>{{jsxref("RegExp.exec", "exec")}}</td>
-   <td>Une méthode de l'objet <code>RegExp</code> qui exécute une recherche de correspondance dans une chaîne de caractères. Elle renvoie un tableau d'informations ou <code>null</code> lorsqu'il n'y a pas de correspondance.</td>
-  </tr>
-  <tr>
-   <td>{{jsxref("RegExp.test", "test")}}</td>
-   <td>Une méthode de l'objet <code>RegExp</code> testant la présence d'une correspondance dans une chaîne de caractères. Elle renvoie true ou false.</td>
-  </tr>
-  <tr>
-   <td>{{jsxref("String.match", "match")}}</td>
-   <td>Une méthode de l'objet <code>String</code> qui exécute une recherche de correspondance dans une chaîne de caractères. Elle renvoie un tableau d'informations ou <code>null</code> lorsqu'il n'y a pas de correspondance.</td>
-  </tr>
-  <tr>
-   <td>{{jsxref("String.matchAll", "matchAll")}}</td>
-   <td>Une méthode de l'objet <code>String</code> qui renvoie un itérateur contenant l'ensemble des correspondances, y compris les groupes capturants.</td>
-  </tr>
-  <tr>
-   <td>{{jsxref("String.search", "search")}}</td>
-   <td>Une méthode de l'objet <code>String</code> qui teste la présence d'une correspondance dans une chaîne de correspondance. Elle renvoie la position de la correspondance ou -1 s'il n'y en a pas.</td>
-  </tr>
-  <tr>
-   <td>{{jsxref("String.replace", "replace")}}</td>
-   <td>Une méthode de l'objet <code>String</code> qui recherche une correspondance dans une chaîne de caractères et qui remplace la correspondance par une chaîne de substitution.</td>
-  </tr>
-  <tr>
-   <td>{{jsxref("String.split", "split")}}</td>
-   <td>Une méthode de l'objet <code>String</code> qui utilise une expression régulière ou une chaîne de caractères pour découper une chaîne de caractères en un tableau comprenant les fragments résultants.</td>
-  </tr>
- </tbody>
-</table>
+| Méthode                                                  | Description                                                                                                                                                                                        |
+| -------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| {{jsxref("RegExp.exec", "exec")}}             | Une méthode de l'objet `RegExp` qui exécute une recherche de correspondance dans une chaîne de caractères. Elle renvoie un tableau d'informations ou `null` lorsqu'il n'y a pas de correspondance. |
+| {{jsxref("RegExp.test", "test")}}             | Une méthode de l'objet `RegExp` testant la présence d'une correspondance dans une chaîne de caractères. Elle renvoie true ou false.                                                                |
+| {{jsxref("String.match", "match")}}         | Une méthode de l'objet `String` qui exécute une recherche de correspondance dans une chaîne de caractères. Elle renvoie un tableau d'informations ou `null` lorsqu'il n'y a pas de correspondance. |
+| {{jsxref("String.matchAll", "matchAll")}} | Une méthode de l'objet `String` qui renvoie un itérateur contenant l'ensemble des correspondances, y compris les groupes capturants.                                                               |
+| {{jsxref("String.search", "search")}}         | Une méthode de l'objet `String` qui teste la présence d'une correspondance dans une chaîne de correspondance. Elle renvoie la position de la correspondance ou -1 s'il n'y en a pas.               |
+| {{jsxref("String.replace", "replace")}}     | Une méthode de l'objet `String` qui recherche une correspondance dans une chaîne de caractères et qui remplace la correspondance par une chaîne de substitution.                                   |
+| {{jsxref("String.split", "split")}}         | Une méthode de l'objet `String` qui utilise une expression régulière ou une chaîne de caractères pour découper une chaîne de caractères en un tableau comprenant les fragments résultants.         |
 
-<p>Pour savoir si un motif est présent au sein d'une chaîne de caractères, utiliser les méthodes<code> test</code> ou <code>search</code>. Pour obtenir plus d'informations (moins rapidement) on utilisera les méthodes <code>exec</code> ou <code>match</code>. Si on utilise <code>exec</code> ou <code>match</code> et qu'une correspondance est trouvée, ces méthodes renverront un tableau et mettront à jour des propriétés de l'objet global <code>RegExp</code> et aussi de l'instance de <code>RegExp</code> associée à l'expression rationnelle. Si aucune correspondance n'est trouvée, la méthode <code>exec</code> renverra <code>null</code> (qui est automatiquement converti à <code>false</code> lors d'un test conditionnel).</p>
+Pour savoir si un motif est présent au sein d'une chaîne de caractères, utiliser les méthodes` test` ou `search`. Pour obtenir plus d'informations (moins rapidement) on utilisera les méthodes `exec` ou `match`. Si on utilise `exec` ou `match` et qu'une correspondance est trouvée, ces méthodes renverront un tableau et mettront à jour des propriétés de l'objet global `RegExp` et aussi de l'instance de `RegExp` associée à l'expression rationnelle. Si aucune correspondance n'est trouvée, la méthode `exec` renverra `null` (qui est automatiquement converti à `false` lors d'un test conditionnel).
 
-<p>Dans l'exemple qui suit, le script utilise la méthode <code>exec</code> pour trouver une correspondance dans une chaîne de caractères.</p>
+Dans l'exemple qui suit, le script utilise la méthode `exec` pour trouver une correspondance dans une chaîne de caractères.
 
-<pre class="brush: js notranslate">var monExpressionReguliere = /d(b+)d/g;
+```js
+var monExpressionReguliere = /d(b+)d/g;
 var monTableau = monExpressionReguliere.exec("cdbbdbsbz");
-</pre>
+```
 
-<p>S'il n'est pas nécessaire d'accéder aux propriétés de l'expression régulière, une autre façon de récupérer <code>monTableau</code> peut être :</p>
+S'il n'est pas nécessaire d'accéder aux propriétés de l'expression régulière, une autre façon de récupérer `monTableau` peut être :
 
-<pre class="brush: js notranslate">var monTableau = /d(b+)d/g.exec("cdbbdbsbz");
+```js
+var monTableau = /d(b+)d/g.exec("cdbbdbsbz");
 // équivalent à "cdbbdbsbz".match(/d(b+)d/g);
-</pre>
+```
 
-<p>Si on souhaite construire une expression régulière à partir d'une chaîne de caractères, on peut utiliser le script suivant :</p>
+Si on souhaite construire une expression régulière à partir d'une chaîne de caractères, on peut utiliser le script suivant :
 
-<pre class="brush: js notranslate">var monExpressionReguliere = new RegExp("d(b+)d", "g");
+```js
+var monExpressionReguliere = new RegExp("d(b+)d", "g");
 var monTableau = monExpressionReguliere.exec("cdbbdbsbz");
-</pre>
+```
 
-<p>Avec ces scripts, on obtient bien une correspondance, la méthode renvoie un tableau et met à jour les propriétés listées dans le tableau qui suit.</p>
+Avec ces scripts, on obtient bien une correspondance, la méthode renvoie un tableau et met à jour les propriétés listées dans le tableau qui suit.
 
 <table class="standard-table">
- <caption>Résultats dûs à l'exécution d'une expression rationnelle.</caption>
- <thead>
-  <tr>
-   <th scope="col">Objet</th>
-   <th scope="col">Propriété ou indice</th>
-   <th scope="col">Description</th>
-   <th scope="col">Pour cet exemple</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td rowspan="4"><code>monTableau</code></td>
-   <td></td>
-   <td>La chaîne de caractères correspondante et les fragments de chaînes gardés en mémoire.</td>
-   <td><code>["dbbd", "bb"]</code></td>
-  </tr>
-  <tr>
-   <td><code>index</code></td>
-   <td>L'indice (débute à partir de 0) de la correspondance, compté dans la chaîne de caractère initiale.</td>
-   <td><code>1</code></td>
-  </tr>
-  <tr>
-   <td><code>input</code></td>
-   <td>La chaîne de caractères initiale.</td>
-   <td><code>"cdbbdbsbz"</code></td>
-  </tr>
-  <tr>
-   <td><code>[0]</code></td>
-   <td>Les derniers caractères qui correspondent.</td>
-   <td><code>"dbbd"</code></td>
-  </tr>
-  <tr>
-   <td rowspan="2"><code>monExpressionRégulière</code></td>
-   <td><code>lastIndex</code></td>
-   <td>L'indice auquel débuter la prochaine correspondance. (Cette propriété n'est utilisée que si l'expression régulière utilise l'option g, décrite dans « <a href="#recherches_flag">Effectuer des recherches avancées avec les marqueurs</a> ».</td>
-   <td><code>5</code></td>
-  </tr>
-  <tr>
-   <td><code>source</code></td>
-   <td>Le texte du motif, mis à jour à la création de l'expression régulière mais pas lors de son exécution.</td>
-   <td><code>"d(b+)d"</code></td>
-  </tr>
- </tbody>
+  <caption>
+    Résultats dûs à l'exécution d'une expression rationnelle.
+  </caption>
+  <thead>
+    <tr>
+      <th scope="col">Objet</th>
+      <th scope="col">Propriété ou indice</th>
+      <th scope="col">Description</th>
+      <th scope="col">Pour cet exemple</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td rowspan="4"><code>monTableau</code></td>
+      <td></td>
+      <td>
+        La chaîne de caractères correspondante et les fragments de chaînes
+        gardés en mémoire.
+      </td>
+      <td><code>["dbbd", "bb"]</code></td>
+    </tr>
+    <tr>
+      <td><code>index</code></td>
+      <td>
+        L'indice (débute à partir de 0) de la correspondance, compté dans la
+        chaîne de caractère initiale.
+      </td>
+      <td><code>1</code></td>
+    </tr>
+    <tr>
+      <td><code>input</code></td>
+      <td>La chaîne de caractères initiale.</td>
+      <td><code>"cdbbdbsbz"</code></td>
+    </tr>
+    <tr>
+      <td><code>[0]</code></td>
+      <td>Les derniers caractères qui correspondent.</td>
+      <td><code>"dbbd"</code></td>
+    </tr>
+    <tr>
+      <td rowspan="2"><code>monExpressionRégulière</code></td>
+      <td><code>lastIndex</code></td>
+      <td>
+        L'indice auquel débuter la prochaine correspondance. (Cette propriété
+        n'est utilisée que si l'expression régulière utilise l'option g, décrite
+        dans «
+        <a href="#recherches_flag"
+          >Effectuer des recherches avancées avec les marqueurs</a
+        >
+        ».
+      </td>
+      <td><code>5</code></td>
+    </tr>
+    <tr>
+      <td><code>source</code></td>
+      <td>
+        Le texte du motif, mis à jour à la création de l'expression régulière
+        mais pas lors de son exécution.
+      </td>
+      <td><code>"d(b+)d"</code></td>
+    </tr>
+  </tbody>
 </table>
 
-<p>Comme le montre la seconde formulation de cet exemple, il est possible d'utiliser une expression rationnelle, créée avec un objet initialisé sans l'affecter à une variable. Cela implique qu'à chaque utilisation, on aura une nouvelle expression régulière distincte et qu'on ne pourra pas, pour cette raison, accéder aux propriétés de l'expression régulière. Avec le script suivant :</p>
+Comme le montre la seconde formulation de cet exemple, il est possible d'utiliser une expression rationnelle, créée avec un objet initialisé sans l'affecter à une variable. Cela implique qu'à chaque utilisation, on aura une nouvelle expression régulière distincte et qu'on ne pourra pas, pour cette raison, accéder aux propriétés de l'expression régulière. Avec le script suivant :
 
-<pre class="brush: js notranslate">var monExpressionReguliere = /d(b+)d/g;
+```js
+var monExpressionReguliere = /d(b+)d/g;
 var monTableau = monExpressionReguliere.exec("cdbbdbsbz");
 console.log("La valeur de lastIndex est " + monExpressionReguliere.lastIndex);
 
 // "La valeur de lastIndex est 5"
-</pre>
+```
 
-<p>Si le script utilisé est :</p>
+Si le script utilisé est :
 
-<pre class="brush: js notranslate">var monTableau = /d(b+)d/g.exec("cdbbdbsbz");
+```js
+var monTableau = /d(b+)d/g.exec("cdbbdbsbz");
 console.log("La valeur de lastIndex est " + /d(b+)d/g.lastIndex);
 
 // "La valeur de lastIndex est 0"
-</pre>
+```
 
-<p>Les occurences de <code>/d(b+)d/g</code> dans les deux instructions sont des objets différents. Leurs propriétés <code>lastIndex</code> respectives ont donc des valeurs différentes. Quand il est nécessaire d'accéder aux propriétés d'un objet décrivant une expression rationnelle, il faudra d'abord l'affecter à une variable.</p>
+Les occurences de `/d(b+)d/g` dans les deux instructions sont des objets différents. Leurs propriétés `lastIndex` respectives ont donc des valeurs différentes. Quand il est nécessaire d'accéder aux propriétés d'un objet décrivant une expression rationnelle, il faudra d'abord l'affecter à une variable.
 
-<h3 id="Utiliser_les_correspondances_de_groupes_avec_les_parenthèses">Utiliser les correspondances de groupes avec les parenthèses</h3>
+### Utiliser les correspondances de groupes avec les parenthèses
 
-<p>Les parenthèses, utilisées dans un motif d'expression régulière, permettent de garder en mémoire un groupe (ou fragment) d'une correspondance. Ainsi, <code>/a(b)c/</code> correspond aux caractères 'abc' et garde 'b' en mémoire. Pour récupérer ces fragments mémorisés, on peut utiliser les éléments du tableau <code>array</code> <code>[1]</code>, ..., <code>[n]</code>.</p>
+Les parenthèses, utilisées dans un motif d'expression régulière, permettent de garder en mémoire un groupe (ou fragment) d'une correspondance. Ainsi, `/a(b)c/` correspond aux caractères 'abc' et garde 'b' en mémoire. Pour récupérer ces fragments mémorisés, on peut utiliser les éléments du tableau `array` `[1]`, ..., `[n]`.
 
-<p>Le nombre de fragments qu'il est possible de garder entre parenthèses n'est pas limité. Le tableau renvoyé contiendra tout ce qui aura été trouvé. Les exemples qui suivent montrent comment utiliser cette syntaxe.</p>
+Le nombre de fragments qu'il est possible de garder entre parenthèses n'est pas limité. Le tableau renvoyé contiendra tout ce qui aura été trouvé. Les exemples qui suivent montrent comment utiliser cette syntaxe.
 
-<p>Le script qui suit utilise la méthode {{jsxref("String.replace", "replace()")}} pour échanger les mots d'une chaîne de caractères. Pour remplacer le texte, le script utilise <code>$1</code> et <code>$2</code> qui correspondent au premier et deuxième groupe correspondant.</p>
+Le script qui suit utilise la méthode {{jsxref("String.replace", "replace()")}} pour échanger les mots d'une chaîne de caractères. Pour remplacer le texte, le script utilise `$1` et `$2` qui correspondent au premier et deuxième groupe correspondant.
 
-<pre class="brush: js notranslate">var re = /(\w+)\s(\w+)/;
+```js
+var re = /(\w+)\s(\w+)/;
 var str = "Titi toto";
 var newstr = str.replace(re, "$2, $1");
 console.log(newstr);
-</pre>
+```
 
-<p>Cela affichera "toto, Titi".</p>
+Cela affichera "toto, Titi".
 
-<h3 id="Effectuer_des_recherches_avancées_en_utilisant_les_marqueurs_flags">Effectuer des recherches avancées en utilisant les marqueurs (<em>flags</em>)</h3>
+### Effectuer des recherches avancées en utilisant les marqueurs (_flags_)
 
-<p>Les expressions rationnelles peuvent être utilisées avec des marqueurs optionnels permettant des recherches globales et/ou ne respectant pas la casse. Ces marqueurs peuvent être utilisés séparement ou ensemble, quel que soit l'ordre. Ils font partie de l'expression régulière.</p>
+Les expressions rationnelles peuvent être utilisées avec des marqueurs optionnels permettant des recherches globales et/ou ne respectant pas la casse. Ces marqueurs peuvent être utilisés séparement ou ensemble, quel que soit l'ordre. Ils font partie de l'expression régulière.
 
-<table class="standard-table">
- <caption>Drapeaux utilisés avec les expressions régulières.</caption>
- <thead>
-  <tr>
-   <th scope="col">Drapeau (<em>Flag</em>)</th>
-   <th scope="col">Description</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td><code>g</code></td>
-   <td>Recherche globale</td>
-  </tr>
-  <tr>
-   <td><code>i</code></td>
-   <td>Recherche ne respectant pas la casse</td>
-  </tr>
-  <tr>
-   <td><code>m</code></td>
-   <td>Recherche sur plusieurs lignes</td>
-  </tr>
-  <tr>
-   <td><code>s</code></td>
-   <td>Le point peut correspondre aux caractères de saut de ligne.</td>
-  </tr>
-  <tr>
-   <td><code>u</code></td>
-   <td>Unicode. Le motif de recherche est interprété comme une séquence de codets Unicode.</td>
-  </tr>
-  <tr>
-   <td><code>y</code></td>
-   <td>Effectue une recherche qui « adhère », en partant de la position courante de la chaîne de caractères sur laquelle la recherche est effectuée. Voir la page sur {{jsxref("RegExp.sticky","sticky")}}.</td>
-  </tr>
- </tbody>
-</table>
+| Drapeau (_Flag_) | Description                                                                                                                                                                                                      |
+| ---------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `g`              | Recherche globale                                                                                                                                                                                                |
+| `i`              | Recherche ne respectant pas la casse                                                                                                                                                                             |
+| `m`              | Recherche sur plusieurs lignes                                                                                                                                                                                   |
+| `s`              | Le point peut correspondre aux caractères de saut de ligne.                                                                                                                                                      |
+| `u`              | Unicode. Le motif de recherche est interprété comme une séquence de codets Unicode.                                                                                                                              |
+| `y`              | Effectue une recherche qui « adhère », en partant de la position courante de la chaîne de caractères sur laquelle la recherche est effectuée. Voir la page sur {{jsxref("RegExp.sticky","sticky")}}. |
 
-<p>Pour utiliser un marqueur avec une expression régulière, on utilisera la syntaxe suivante :</p>
+Pour utiliser un marqueur avec une expression régulière, on utilisera la syntaxe suivante :
 
-<pre class="brush: js notranslate">var re = /motif/marqueurs;
-</pre>
+```js
+var re = /motif/marqueurs;
+```
 
-<p>ou</p>
+ou
 
-<pre class="brush: js notranslate">var re = new RegExp("motif", "marqueurs");
-</pre>
+```js
+var re = new RegExp("motif", "marqueurs");
+```
 
-<p>Les marqueurs font partie intégrante d'une expression régulière, ils ne peuvent pas être ajoutés ou supprimés ensuite.</p>
+Les marqueurs font partie intégrante d'une expression régulière, ils ne peuvent pas être ajoutés ou supprimés ensuite.
 
-<p>Ainsi, <code>re = /\w+\s/g</code> permet de créer une expression régulière pour trouver un ou plusieurs caractères suivis d'un espace, la recherche est effectuée globalement, sur toute la chaîne de caractères.</p>
+Ainsi, `re = /\w+\s/g` permet de créer une expression régulière pour trouver un ou plusieurs caractères suivis d'un espace, la recherche est effectuée globalement, sur toute la chaîne de caractères.
 
-<pre class="brush: js notranslate">var re = /\w+\s/g;
+```js
+var re = /\w+\s/g;
 var str = "un deux trois quatre";
 var monTableau = str.match(re);
 console.log(monTableau);
-</pre>
+```
 
-<p>Cela affichera ["un ", "deux ", "trois "]. On pourrait remplacer la ligne :</p>
+Cela affichera \["un ", "deux ", "trois "]. On pourrait remplacer la ligne :
 
-<pre class="brush: js notranslate">var re = /\w+\s/g;
-</pre>
+```js
+var re = /\w+\s/g;
+```
 
-<p>avec la ligne :</p>
+avec la ligne :
 
-<pre class="brush: js notranslate">var re = new RegExp("\\w+\\s", "g");
-</pre>
+```js
+var re = new RegExp("\\w+\\s", "g");
+```
 
-<p>pour obtenir le même résultat.</p>
+pour obtenir le même résultat.
 
-<p>Le comportement du marqueur <code>'g'</code> est différent selon qu'il est utilisé avec <code><a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/RegExp/exec">exec()</a></code> ou avec <code><a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/String/match">match()</a></code>. Pour <code>match()</code>, c'est la chaîne de caractères qui invoque la méthode et l'expression rationnelle est alors un argument. Pour <code>exec()</code>, c'est l'expression rationnelle qui invoque la méthode et c'est la chaîne de caractères qui est passée en argument. Dans l'appel à <code>exec()</code>, le marqueur <code>'g'</code> permet d'avoir une progression itérative.</p>
+Le comportement du marqueur `'g'` est différent selon qu'il est utilisé avec [`exec()`](/fr/docs/Web/JavaScript/Reference/Objets_globaux/RegExp/exec) ou avec [`match()`](/fr/docs/Web/JavaScript/Reference/Objets_globaux/String/match). Pour `match()`, c'est la chaîne de caractères qui invoque la méthode et l'expression rationnelle est alors un argument. Pour `exec()`, c'est l'expression rationnelle qui invoque la méthode et c'est la chaîne de caractères qui est passée en argument. Dans l'appel à `exec()`, le marqueur `'g'` permet d'avoir une progression itérative.
 
-<p>Le marqueur <code>m</code> pourra être utilisé pour traiter une chaîne de caractères de plusieurs lignes comme plusieurs lignes distinctes. Si ce marqueur est utilisé, les caractères spéciaux <code>^</code> et <code>$</code> correspondront au début ou à la fin de n'importe quelle ligne appartenant à la chaîne de caractères au lieu de correspondre simplement au début ou à la fin de la chaîne.</p>
+Le marqueur `m` pourra être utilisé pour traiter une chaîne de caractères de plusieurs lignes comme plusieurs lignes distinctes. Si ce marqueur est utilisé, les caractères spéciaux `^` et `$` correspondront au début ou à la fin de n'importe quelle ligne appartenant à la chaîne de caractères au lieu de correspondre simplement au début ou à la fin de la chaîne.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<p>Les exemples qui suivent utilisent les expressions régulières dans différents cas.</p>
+Les exemples qui suivent utilisent les expressions régulières dans différents cas.
 
-<h3 id="Changer_lordre_dune_saisie">Changer l'ordre d'une saisie</h3>
+### Changer l'ordre d'une saisie
 
-<p>L'exemple qui suit utilise les expressions régulières et <code>string.split()</code> et <code>string.replace()</code>. Le script nettoie la chaîne de caractères saisie qui contient des noms (prénom puis nom) séparés par des blancs, tabulations et points-virgules. Enfin il inverse les noms et prénoms puis trie la liste.</p>
+L'exemple qui suit utilise les expressions régulières et `string.split()` et `string.replace()`. Le script nettoie la chaîne de caractères saisie qui contient des noms (prénom puis nom) séparés par des blancs, tabulations et points-virgules. Enfin il inverse les noms et prénoms puis trie la liste.
 
-<pre class="brush: js notranslate">// La chaîne des noms contient plusieurs blancs et tabulations,
+```js
+// La chaîne des noms contient plusieurs blancs et tabulations,
 // il peut y avoir plusieurs espaces entre le nom et le prénom.
 var noms = "Harry Trump ;Fred Barney; Helen Rigby ; Bill Abel ; Chris Hand ";
 
@@ -670,59 +892,66 @@ var listeParNomFamille = [];
 output.push("---------- Après découpage avec l'expression régulière");
 
 var i, len;
-for (i = 0, len = listeNoms.length; i &lt; len; i++){
+for (i = 0, len = listeNoms.length; i < len; i++){
   output.push(listeNoms[i]);
   listeParNomFamille[i] = listeNoms[i].replace(motif, "$2, $1");
 }
 
 // Afficher le nouveau tableau
 output.push("---------- Noms et prénoms inversés");
-for (i = 0, len = listeParNomFamille.length; i &lt; len; i++){
+for (i = 0, len = listeParNomFamille.length; i < len; i++){
   output.push(listeParNomFamille[i]);
 }
 
 // Trier par le nom de famille puis afficher le tableau trié
 listeParNomFamille.sort();
 output.push("---------- Triée");
-for (i = 0, len = listeParNomFamille.length; i &lt; len; i++){
+for (i = 0, len = listeParNomFamille.length; i < len; i++){
   output.push(listeParNomFamille[i]);
 }
 
 output.push("---------- Fin");
 
 console.log(output.join("\n"));
-</pre>
+```
 
-<h3 id="Utiliser_les_caractères_spéciaux_pour_vérifier_la_saisie">Utiliser les caractères spéciaux pour vérifier la saisie</h3>
+### Utiliser les caractères spéciaux pour vérifier la saisie
 
-<p>Dans l'exemple suivant, on s'attend à ce que l'utilisateur saisissent un numéro de téléphone. Quand l'utilisateur appuie sur le bouton "Vérifier", le script vérifie la validité du numéro. Si le numéro est valide (il correspond à la séquence de caractères fournie par l'expression régulière), le script affiche un message remerciant l'utilisateur et confirmant le numéro. S'il est invalide, le script informe l'utilisateur et lui signifie que les informations saisies ne sont pas valides.</p>
+Dans l'exemple suivant, on s'attend à ce que l'utilisateur saisissent un numéro de téléphone. Quand l'utilisateur appuie sur le bouton "Vérifier", le script vérifie la validité du numéro. Si le numéro est valide (il correspond à la séquence de caractères fournie par l'expression régulière), le script affiche un message remerciant l'utilisateur et confirmant le numéro. S'il est invalide, le script informe l'utilisateur et lui signifie que les informations saisies ne sont pas valides.
 
-<p>Dans les parenthèses sans mémoire <code>(?:</code> , l'expression régulière cherche les deux premiers chiffres ou l'indicatif du pays suivi d'un blanc et du premier chiffre, ce qui correspond à</p>
+Dans les parenthèses sans mémoire `(?:` , l'expression régulière cherche les deux premiers chiffres ou l'indicatif du pays suivi d'un blanc et du premier chiffre, ce qui correspond à
 
-<pre class="brush: html notranslate">\d{2}|\+\d{2}[ ]\d</pre>
+```html
+\d{2}|\+\d{2}[ ]\d
+```
 
-<p>Cette partie signifie : deux chiffres OU un signe '+' suivi de deux chiffres, un blanc et un autre chiffre.</p>
+Cette partie signifie : deux chiffres OU un signe '+' suivi de deux chiffres, un blanc et un autre chiffre.
 
-<p>Ensuite, on a un groupe qui est mémorisé (entre parenthèses) :</p>
+Ensuite, on a un groupe qui est mémorisé (entre parenthèses) :
 
-<pre class="brush: html notranslate">([- ])</pre>
+```html
+([- ])
+```
 
-<p>Ce groupe correspond à ce qui va être utilisé pour séparer les différentes composantes du numéro de téléphone.</p>
+Ce groupe correspond à ce qui va être utilisé pour séparer les différentes composantes du numéro de téléphone.
 
-<p>Ensuite,</p>
+Ensuite,
 
-<pre class="brush: html notranslate">\d{2}\1</pre>
+```html
+\d{2}\1
+```
 
-<p>signifie qu'on a deux chiffres suivi du premier groupe qui est celui qui définit le séparateur. Le reste est composé de la même façon. Ainsi les numéros de téléphone +33 1 23 45 67 89 et 01 23 45 67 89 seront tous les deux valides.</p>
+signifie qu'on a deux chiffres suivi du premier groupe qui est celui qui définit le séparateur. Le reste est composé de la même façon. Ainsi les numéros de téléphone +33 1 23 45 67 89 et 01 23 45 67 89 seront tous les deux valides.
 
-<p>L'événement <code>Change</code>, provoqué quand l'utilisateur appuie sur Entrée, renseigne la valeur <code>RegExp.input</code>.</p>
+L'événement `Change`, provoqué quand l'utilisateur appuie sur Entrée, renseigne la valeur `RegExp.input`.
 
-<pre class="brush: html notranslate">&lt;!DOCTYPE html&gt;
-&lt;html&gt;
-  &lt;head&gt;
-    &lt;meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"&gt;
-    &lt;meta http-equiv="Content-Script-Type" content="text/javascript"&gt;
-    &lt;script type="text/javascript"&gt;
+```html
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+    <meta http-equiv="Content-Script-Type" content="text/javascript">
+    <script type="text/javascript">
       var re = /(?:\d{2}|\+\d{2}[ ]\d)([- ])\d{2}\1\d{2}\1\d{2}\1\d{2}/;
       function testInfo(phoneInput){
         var OK = re.exec(phoneInput.value);
@@ -731,16 +960,16 @@ console.log(output.join("\n"));
         else
           window.alert("Merci, votre numéro est : " + OK[0]);
       }
-    &lt;/script&gt;
-  &lt;/head&gt;
-  &lt;body&gt;
-    &lt;p&gt;Saisissez votre numéro de téléphone (avec indicatif) puis cliquez sur "Vérifier".
-        &lt;br&gt;Le format attendu est ## ## ## ## ## ou +## # ## ## ## ##.&lt;/p&gt;
-    &lt;form action="#"&gt;
-      &lt;input id="phone"&gt;&lt;button onclick="testInfo(document.getElementById('phone'));"&gt;Vérifier&lt;/button&gt;
-    &lt;/form&gt;
-  &lt;/body&gt;
-&lt;/html&gt;
-</pre>
-
-<p>{{PreviousNext("Web/JavaScript/Guide/Formatage_du_texte", "Web/JavaScript/Guide/Collections_indexées")}}</p>
+    </script>
+  </head>
+  <body>
+    <p>Saisissez votre numéro de téléphone (avec indicatif) puis cliquez sur "Vérifier".
+        <br>Le format attendu est ## ## ## ## ## ou +## # ## ## ## ##.</p>
+    <form action="#">
+      <input id="phone"><button onclick="testInfo(document.getElementById('phone'));">Vérifier</button>
+    </form>
+  </body>
+</html>
+```
+
+{{PreviousNext("Web/JavaScript/Guide/Formatage_du_texte", "Web/JavaScript/Guide/Collections_indexées")}}
diff --git a/files/fr/web/javascript/guide/regular_expressions/quantifiers/index.md b/files/fr/web/javascript/guide/regular_expressions/quantifiers/index.md
index f27dfa250b..f94599fde7 100644
--- a/files/fr/web/javascript/guide/regular_expressions/quantifiers/index.md
+++ b/files/fr/web/javascript/guide/regular_expressions/quantifiers/index.md
@@ -9,90 +9,136 @@ tags:
 translation_of: Web/JavaScript/Guide/Regular_Expressions/Quantifiers
 original_slug: Web/JavaScript/Guide/Expressions_régulières/Quantificateurs
 ---
-<p>{{jsSidebar("JavaScript Guide")}}{{draft}}</p>
+{{jsSidebar("JavaScript Guide")}}{{draft}}
 
-<p>Les quantificateurs indiquent le nombre de caractères ou d'expressions qu'il faut pour une correspondance.</p>
+Les quantificateurs indiquent le nombre de caractères ou d'expressions qu'il faut pour une correspondance.
 
-<h2 id="Types">Types</h2>
+## Types
 
 <table class="standard-table">
- <thead>
-  <tr>
-   <th scope="col">Caractères</th>
-   <th scope="col">Signification</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td><code>x*</code></td>
-   <td>
-    <p>Correspond à l'expression précédente qui est répétée 0 ou plusieurs fois. Équivalent à <code>{0,}</code></p>
-
-    <p>Ainsi, <code>/bo*/</code> correspond à 'boo' dans "Un booléen" et à 'b' dans "Un bateau bleu", mais ne correspond à rien dans "Ce matin".</p>
-   </td>
-  </tr>
-  <tr>
-   <td><code>x+</code></td>
-   <td>
-    <p>Correspond à l'expression précédente qui est répétée une ou plusieurs fois. C'est équivalent à <code>{1,}</code>.</p>
-
-    <p>Ainsi, <code>/a+/</code> correspond au 'a' dans "maison" et à tous les 'a' dans "maaaaaaison" mais ne correspond à rien dans "mission".</p>
-   </td>
-  </tr>
-  <tr>
-   <td><code>x?</code></td>
-   <td>
-    <p>Correspond à l'expression précédente qui est présente une fois ou pas du tout. C'est équivalent à <code>{0,1}</code>.<br>
-     <br>
-     Ainsi, <code>/e?le?/</code> correspond au 'el' dans "gel" et au 'le' dans "angle" mais aussi au 'l' dans "Oslo".<br>
-     <br>
-     S'il est utilisé immédiatement après l'un des quantificateurs : *, +, ?, ou {}, il rend le quantificateur moins « gourmand » auquel cas le moins de caractères correspond (le comportement par défaut, « gourmand », permettant de faire correspondre le plus de caractères possible). Par exemple <code>/\d+/</code> utilisée avec "123abc" fait correspondre "123". Utiliser <code>/\d+?/</code> à la même chaîne de caractères fait correspondre "1".<br>
-     <br>
-     Ce symbole est également utilisé dans les tests de présence autour de l'expression, décrits par les lignes <code>x(?=y)</code> et <code>x(?!y)</code> de ce tableau.</p>
-   </td>
-  </tr>
-  <tr>
-   <td><code>x{n}</code></td>
-   <td>
-    <p>Correspond pour exactement n occurences de l'expression précédente. N doit être un entier positif.<br>
-     <br>
-     Ainsi, <code>/a{2}/</code> ne correspond pas au 'a' de "Mozilla" mais correspond à tous les 'a' de "Mozilaa" et aux deux premiers 'a' de "Mozillaaa".</p>
-   </td>
-  </tr>
-  <tr>
-   <td><code>x{n,}</code></td>
-   <td>
-    <p>Correspond lorsqu'il y a au moins <code>n</code> occurences de l'expression précédente. <code>n</code> doit être un entier positif.</p>
-
-    <p>Par exemple <code>/a{2,}/</code> correspondra à <code>"aa"</code> ou à <code>"aaa"</code> ou encore à <code>"aaaa"</code> mais pas à <code>"a"</code>.</p>
-   </td>
-  </tr>
-  <tr>
-   <td><code>x{n,m}</code></td>
-   <td>
-    <p>Lorsque <code>n</code> et <code>m</code> sont des entiers positifs, cela correspond à au moins <code>n</code> occurences de l'expression précédente et à au plus <code>m</code> occurrences. Lorsque <code>m</code> n'est pas utilisé, la valeur par défaut correspondante sera l'infini.</p>
-
-    <p>Ainsi, <code>/a{1,3}/</code> ne correspond à rien dans "Mozill", au 'a' de "Mozilla", au deux premiers 'a' de "Mozillaa" et au trois premiers 'a' de "Mozillaaaaa". Pour ce dernier exemple, on doit noter que le correspondance ne se fait que sur "aaa" bien qu'il y ait plus de 'a' dans la chaîne de caractères.</p>
-   </td>
-  </tr>
-  <tr>
-   <td>
-    <p><code>x*?</code><br>
-     <code>x+?</code><br>
-     <code>x??</code><br>
-     <code>x{n}?</code><br>
-     <code>x{n,}?</code><br>
-     <code>x{n,m}?</code></p>
-   </td>
-   <td>
-    <p>Correspond à l'expression précédente qui est présente une fois ou pas du tout. C'est équivalent à <code>{0,1}</code>.<br>
-     <br>
-     Ainsi, <code>/e?le?/</code> correspond au 'el' dans "gel" et au 'le' dans "angle" mais aussi au 'l' dans "Oslo".<br>
-     <br>
-     S'il est utilisé immédiatement après l'un des quantificateurs : *, +, ?, ou {}, il rend le quantificateur moins « gourmand » auquel cas le moins de caractères correspond (le comportement par défaut, « gourmand », permettant de faire correspondre le plus de caractères possible). Par exemple <code>/\d+/</code> utilisée avec "123abc" fait correspondre "123". Utiliser <code>/\d+?/</code> à la même chaîne de caractères fait correspondre "1".<br>
-     <br>
-     Ce symbole est également utilisé dans les tests de présence autour de l'expression, décrits par les lignes <code>x(?=y)</code> et <code>x(?!y)</code> de ce tableau.</p>
-   </td>
-  </tr>
- </tbody>
+  <thead>
+    <tr>
+      <th scope="col">Caractères</th>
+      <th scope="col">Signification</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td><code>x*</code></td>
+      <td>
+        <p>
+          Correspond à l'expression précédente qui est répétée 0 ou plusieurs
+          fois. Équivalent à <code>{0,}</code>
+        </p>
+        <p>
+          Ainsi, <code>/bo*/</code> correspond à 'boo' dans "Un booléen" et à
+          'b' dans "Un bateau bleu", mais ne correspond à rien dans "Ce matin".
+        </p>
+      </td>
+    </tr>
+    <tr>
+      <td><code>x+</code></td>
+      <td>
+        <p>
+          Correspond à l'expression précédente qui est répétée une ou plusieurs
+          fois. C'est équivalent à <code>{1,}</code>.
+        </p>
+        <p>
+          Ainsi, <code>/a+/</code> correspond au 'a' dans "maison" et à tous les
+          'a' dans "maaaaaaison" mais ne correspond à rien dans "mission".
+        </p>
+      </td>
+    </tr>
+    <tr>
+      <td><code>x?</code></td>
+      <td>
+        <p>
+          Correspond à l'expression précédente qui est présente une fois ou pas
+          du tout. C'est équivalent à <code>{0,1}</code>.<br /><br />Ainsi,
+          <code>/e?le?/</code> correspond au 'el' dans "gel" et au 'le' dans
+          "angle" mais aussi au 'l' dans "Oslo".<br /><br />S'il est utilisé
+          immédiatement après l'un des quantificateurs : *, +, ?, ou {}, il rend
+          le quantificateur moins « gourmand » auquel cas le moins de caractères
+          correspond (le comportement par défaut, « gourmand », permettant de
+          faire correspondre le plus de caractères possible). Par exemple
+          <code>/\d+/</code> utilisée avec "123abc" fait correspondre "123".
+          Utiliser <code>/\d+?/</code> à la même chaîne de caractères fait
+          correspondre "1".<br /><br />Ce symbole est également utilisé dans les
+          tests de présence autour de l'expression, décrits par les lignes
+          <code>x(?=y)</code> et <code>x(?!y)</code> de ce tableau.
+        </p>
+      </td>
+    </tr>
+    <tr>
+      <td><code>x{n}</code></td>
+      <td>
+        <p>
+          Correspond pour exactement n occurences de l'expression précédente. N
+          doit être un entier positif.<br /><br />Ainsi, <code>/a{2}/</code> ne
+          correspond pas au 'a' de "Mozilla" mais correspond à tous les 'a' de
+          "Mozilaa" et aux deux premiers 'a' de "Mozillaaa".
+        </p>
+      </td>
+    </tr>
+    <tr>
+      <td><code>x{n,}</code></td>
+      <td>
+        <p>
+          Correspond lorsqu'il y a au moins <code>n</code> occurences de
+          l'expression précédente. <code>n</code> doit être un entier positif.
+        </p>
+        <p>
+          Par exemple <code>/a{2,}/</code> correspondra à <code>"aa"</code> ou à
+          <code>"aaa"</code> ou encore à <code>"aaaa"</code> mais pas à
+          <code>"a"</code>.
+        </p>
+      </td>
+    </tr>
+    <tr>
+      <td><code>x{n,m}</code></td>
+      <td>
+        <p>
+          Lorsque <code>n</code> et <code>m</code> sont des entiers positifs,
+          cela correspond à au moins <code>n</code> occurences de l'expression
+          précédente et à au plus <code>m</code> occurrences. Lorsque
+          <code>m</code> n'est pas utilisé, la valeur par défaut correspondante
+          sera l'infini.
+        </p>
+        <p>
+          Ainsi, <code>/a{1,3}/</code> ne correspond à rien dans "Mozill", au
+          'a' de "Mozilla", au deux premiers 'a' de "Mozillaa" et au trois
+          premiers 'a' de "Mozillaaaaa". Pour ce dernier exemple, on doit noter
+          que le correspondance ne se fait que sur "aaa" bien qu'il y ait plus
+          de 'a' dans la chaîne de caractères.
+        </p>
+      </td>
+    </tr>
+    <tr>
+      <td>
+        <p>
+          <code>x*?</code><br /><code>x+?</code><br /><code>x??</code
+          ><br /><code>x{n}?</code><br /><code>x{n,}?</code><br /><code
+            >x{n,m}?</code
+          >
+        </p>
+      </td>
+      <td>
+        <p>
+          Correspond à l'expression précédente qui est présente une fois ou pas
+          du tout. C'est équivalent à <code>{0,1}</code>.<br /><br />Ainsi,
+          <code>/e?le?/</code> correspond au 'el' dans "gel" et au 'le' dans
+          "angle" mais aussi au 'l' dans "Oslo".<br /><br />S'il est utilisé
+          immédiatement après l'un des quantificateurs : *, +, ?, ou {}, il rend
+          le quantificateur moins « gourmand » auquel cas le moins de caractères
+          correspond (le comportement par défaut, « gourmand », permettant de
+          faire correspondre le plus de caractères possible). Par exemple
+          <code>/\d+/</code> utilisée avec "123abc" fait correspondre "123".
+          Utiliser <code>/\d+?/</code> à la même chaîne de caractères fait
+          correspondre "1".<br /><br />Ce symbole est également utilisé dans les
+          tests de présence autour de l'expression, décrits par les lignes
+          <code>x(?=y)</code> et <code>x(?!y)</code> de ce tableau.
+        </p>
+      </td>
+    </tr>
+  </tbody>
 </table>
diff --git a/files/fr/web/javascript/guide/regular_expressions/unicode_property_escapes/index.md b/files/fr/web/javascript/guide/regular_expressions/unicode_property_escapes/index.md
index 04b21810ae..f7b7b5c99c 100644
--- a/files/fr/web/javascript/guide/regular_expressions/unicode_property_escapes/index.md
+++ b/files/fr/web/javascript/guide/regular_expressions/unicode_property_escapes/index.md
@@ -10,422 +10,116 @@ tags:
 translation_of: Web/JavaScript/Guide/Regular_Expressions/Unicode_Property_Escapes
 original_slug: Web/JavaScript/Guide/Expressions_régulières/Échappement_propriétés_Unicode
 ---
-<p>{{jsSidebar("JavaScript Guide")}}{{draft}}</p>
+{{jsSidebar("JavaScript Guide")}}{{draft}}
 
-<p>Les séquences d'échappement pour les propriétés Unicode permettent de distinguer les caractères Unicodes en fonction de leurs propriétés : majuscules, minuscules, symboles mathématiques, ponctuation, etc.</p>
+Les séquences d'échappement pour les propriétés Unicode permettent de distinguer les caractères Unicodes en fonction de leurs propriétés : majuscules, minuscules, symboles mathématiques, ponctuation, etc.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="brush: js">// Valeurs non-binaires
-\p{UnicodePropertyName=<em>ValeurPropriétéUnicode</em>}
+```js
+// Valeurs non-binaires
+\p{UnicodePropertyName=ValeurPropriétéUnicode}
 \p{UnicodePropertyName}
 
 // Valeurs binaires et non-binaires
 \p{UnicodePropertyName}
-</pre>
+```
 
-<dl>
- <dt><code>ValeurPropriétéUnicode</code></dt>
- <dd>Une des valeurs listées ci-après. Pour certaines valeurs, le mot-clé <code>NomPropriétéUnicode</code> et le signe égal peuvent être omis.</dd>
-</dl>
+- `ValeurPropriétéUnicode`
+  - : Une des valeurs listées ci-après. Pour certaines valeurs, le mot-clé `NomPropriétéUnicode` et le signe égal peuvent être omis.
 
-<h2 id="Valeurs">Valeurs</h2>
+## Valeurs
 
-<h3 id="Non-binaires">Non-binaires</h3>
+### Non-binaires
 
-<table class="standard-table">
- <thead>
-  <tr>
-   <th scope="col">Échappements</th>
-   <th scope="col">Signification</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td><code>\p{LC}<br>
-    \p{Cased_Letter}<br>
-    \p{UnicodePropertyName=Cased_Letter}</code></td>
-   <td>N'importe quelle lettre avec la version minuscule et la version majuscule. Équivalent à <code>\p{Lu}|\p{Ll}|p{Lt}</code>.</td>
-  </tr>
-  <tr>
-   <td><code>\p{Close_Punctuation}<br>
-    \p{UnicodePropertyName=Close_Punctuation}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Connector_Punctuation}<br>
-    \p{UnicodePropertyName=Connector_Punctuation}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Control}<br>
-    \p{UnicodePropertyName=Control}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Currency_Symbol}<br>
-    \p{UnicodePropertyName=Currency_Symbol}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Dash_Punctuation}<br>
-    \p{UnicodePropertyName=Dash_Punctuation}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Decimal_Number}<br>
-    \p{UnicodePropertyName=Decimal_Number}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Enclosing_Mark}<br>
-    \p{UnicodePropertyName=Enclosing_Mark}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Final_Punctuation}<br>
-    ​​​​​​​\p{UnicodePropertyName=Final_Punctuation}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Format}<br>
-    ​​​​​​​\p{UnicodePropertyName=Format}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Initial_Punctuation}<br>
-    ​​​​​​​\p{UnicodePropertyName=Initial_Punctuation}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Letter}<br>
-    ​​​​​​​\p{UnicodePropertyName=Letter}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Letter_Number}<br>
-    ​​​​​​​\p{UnicodePropertyName=Line_Separator}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Lowercase_Letter}<br>
-    ​​​​​​​\p{UnicodePropertyName=Lowercase_Letter}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Mark}<br>
-    ​​​​​​​\p{UnicodePropertyName=Mark}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Math_Symbol;}<br>
-    ​​​​​​​\p{UnicodePropertyName=Math_Symbol}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Modifier_Letter}<br>
-    ​​​​​​​\p{UnicodePropertyName=Modifier_Letter}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Modifier_Symbol}<br>
-    ​​​​​​​\p{UnicodePropertyName=Modifier_Symbol}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Nonspacing_Mark}<br>
-    ​​​​​​​\p{UnicodePropertyName=Nonspacing_Mark}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Number}<br>
-    ​​​​​​​\p{UnicodePropertyName=Number}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Open_Punctuation}<br>
-    ​​​​​​​\p{UnicodePropertyName=Open_Punctuation}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Other}<br>
-    ​​​​​​​\p{UnicodePropertyName=Other_Letter}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Other_Letter}<br>
-    ​​​​​​​\p{UnicodePropertyName=Other_Letter}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Other_Number}<br>
-    ​​​​​​​\p{UnicodePropertyName=Other_Number}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Other_Punctuation}<br>
-    ​​​​​​​\p{UnicodePropertyName=Other_Punctuation}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Paragraph_Separator}<br>
-    ​​​​​​​\p{UnicodePropertyName=Paragraph_Separator}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Private_Use}</code>Meaning<br>
-    <code>​​​​​​​\p{UnicodePropertyName=Private_Use}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Punctuation}<br>
-    ​​​​​​​\p{UnicodePropertyName=Punctuation}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Separator}<br>
-    ​​​​​​​\p{UnicodePropertyName=Separator}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Space_Separator}<br>
-    ​​​​​​​\p{UnicodePropertyName=Space_Separator}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Spaceing_Mark}<br>
-    ​​​​​​​\p{UnicodePropertyName=Spacing_Mark}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Surrogate}<br>
-    ​​​​​​​\p{UnicodePropertyName=Surrogate}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Symbol}<br>
-    ​​​​​​​\p{UnicodePropertyName=Symbol}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Titlecase_Letter}<br>
-    ​​​​​​​\p{UnicodePropertyName=Titlecase_Letter}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Unassigned}<br>
-    ​​​​​​​\p{UnicodePropertyName=Unassigned}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Uppercase_Letter}<br>
-    ​​​​​​​\p{UnicodePropertyName=UppercaseLetter}</code></td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
+| Échappements                                                                 | Signification                                                                                                    |
+| ---------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------- |
+| `\p{LC} \p{Cased_Letter} \p{UnicodePropertyName=Cased_Letter}`               | N'importe quelle lettre avec la version minuscule et la version majuscule. Équivalent à `\p{Lu}\|\p{Ll}\|p{Lt}`. |
+| `\p{Close_Punctuation} \p{UnicodePropertyName=Close_Punctuation}`            |                                                                                                                  |
+| `\p{Connector_Punctuation} \p{UnicodePropertyName=Connector_Punctuation}`    |                                                                                                                  |
+| `\p{Control} \p{UnicodePropertyName=Control}`                                |                                                                                                                  |
+| `\p{Currency_Symbol} \p{UnicodePropertyName=Currency_Symbol}`                |                                                                                                                  |
+| `\p{Dash_Punctuation} \p{UnicodePropertyName=Dash_Punctuation}`              |                                                                                                                  |
+| `\p{Decimal_Number} \p{UnicodePropertyName=Decimal_Number}`                  |                                                                                                                  |
+| `\p{Enclosing_Mark} \p{UnicodePropertyName=Enclosing_Mark}`                  |                                                                                                                  |
+| `\p{Final_Punctuation} ​​​​​​​\p{UnicodePropertyName=Final_Punctuation}`     |                                                                                                                  |
+| `\p{Format} ​​​​​​​\p{UnicodePropertyName=Format}`                           |                                                                                                                  |
+| `\p{Initial_Punctuation} ​​​​​​​\p{UnicodePropertyName=Initial_Punctuation}` |                                                                                                                  |
+| `\p{Letter} ​​​​​​​\p{UnicodePropertyName=Letter}`                           |                                                                                                                  |
+| `\p{Letter_Number} ​​​​​​​\p{UnicodePropertyName=Line_Separator}`            |                                                                                                                  |
+| `\p{Lowercase_Letter} ​​​​​​​\p{UnicodePropertyName=Lowercase_Letter}`       |                                                                                                                  |
+| `\p{Mark} ​​​​​​​\p{UnicodePropertyName=Mark}`                               |                                                                                                                  |
+| `\p{Math_Symbol;} ​​​​​​​\p{UnicodePropertyName=Math_Symbol}`                |                                                                                                                  |
+| `\p{Modifier_Letter} ​​​​​​​\p{UnicodePropertyName=Modifier_Letter}`         |                                                                                                                  |
+| `\p{Modifier_Symbol} ​​​​​​​\p{UnicodePropertyName=Modifier_Symbol}`         |                                                                                                                  |
+| `\p{Nonspacing_Mark} ​​​​​​​\p{UnicodePropertyName=Nonspacing_Mark}`         |                                                                                                                  |
+| `\p{Number} ​​​​​​​\p{UnicodePropertyName=Number}`                           |                                                                                                                  |
+| `\p{Open_Punctuation} ​​​​​​​\p{UnicodePropertyName=Open_Punctuation}`       |                                                                                                                  |
+| `\p{Other} ​​​​​​​\p{UnicodePropertyName=Other_Letter}`                      |                                                                                                                  |
+| `\p{Other_Letter} ​​​​​​​\p{UnicodePropertyName=Other_Letter}`               |                                                                                                                  |
+| `\p{Other_Number} ​​​​​​​\p{UnicodePropertyName=Other_Number}`               |                                                                                                                  |
+| `\p{Other_Punctuation} ​​​​​​​\p{UnicodePropertyName=Other_Punctuation}`     |                                                                                                                  |
+| `\p{Paragraph_Separator} ​​​​​​​\p{UnicodePropertyName=Paragraph_Separator}` |                                                                                                                  |
+| `\p{Private_Use}`Meaning `​​​​​​​\p{UnicodePropertyName=Private_Use}`        |                                                                                                                  |
+| `\p{Punctuation} ​​​​​​​\p{UnicodePropertyName=Punctuation}`                 |                                                                                                                  |
+| `\p{Separator} ​​​​​​​\p{UnicodePropertyName=Separator}`                     |                                                                                                                  |
+| `\p{Space_Separator} ​​​​​​​\p{UnicodePropertyName=Space_Separator}`         |                                                                                                                  |
+| `\p{Spaceing_Mark} ​​​​​​​\p{UnicodePropertyName=Spacing_Mark}`              |                                                                                                                  |
+| `\p{Surrogate} ​​​​​​​\p{UnicodePropertyName=Surrogate}`                     |                                                                                                                  |
+| `\p{Symbol} ​​​​​​​\p{UnicodePropertyName=Symbol}`                           |                                                                                                                  |
+| `\p{Titlecase_Letter} ​​​​​​​\p{UnicodePropertyName=Titlecase_Letter}`       |                                                                                                                  |
+| `\p{Unassigned} ​​​​​​​\p{UnicodePropertyName=Unassigned}`                   |                                                                                                                  |
+| `\p{Uppercase_Letter} ​​​​​​​\p{UnicodePropertyName=UppercaseLetter}`        |                                                                                                                  |
 
-<h3 id="Binaires">Binaires</h3>
+### Binaires
 
-<table class="standard-table">
- <thead>
-  <tr>
-   <th scope="col">Échappement</th>
-   <th scope="col">Signification</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td><code>\p{Alphabetic}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Bidi_Control}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Bidi_Mirrored}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Case_Ignorable}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Cased}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Changes_When_Casefolded}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Changes_When_Casemapped}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Changes_When_Lowercased}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Changes_When_NFKC_Casefolded}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Changes_When_Titlecased}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Changes_When_Uppercased}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Dash}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Default_Ignorable_Code_Point}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Deprecated}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Diacritic}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Emoji}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Emoji_Component}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Emoji_Modifier}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Emoji_Modifier_Base}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Emoji_Presentation}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Extender}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Grapheme_Base}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Grapheme_Extend}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Hex_Digit}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{ID_Continue}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{ID_Start}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Ideographic}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{IDS_Binary_Operator}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{IDS_Trinary_Operator}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Join_Control}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Logical_Order_Exception}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Lowercase}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Math}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Noncharacter_Code_Point}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Pattern_Syntax}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Pattern_White_Space}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Quotation_Mark}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Radical}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{RegionalIndicator}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Sentence_Terminal}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Soft_Dotted}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Terminal_Punctuation}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Unified_Ideograph}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Uppercase}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{Variation_Selector}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{White_Space}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{XID_Continue}</code></td>
-   <td></td>
-  </tr>
-  <tr>
-   <td><code>\p{XID_Start}</code></td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
+| Échappement                        | Signification |
+| ---------------------------------- | ------------- |
+| `\p{Alphabetic}`                   |               |
+| `\p{Bidi_Control}`                 |               |
+| `\p{Bidi_Mirrored}`                |               |
+| `\p{Case_Ignorable}`               |               |
+| `\p{Cased}`                        |               |
+| `\p{Changes_When_Casefolded}`      |               |
+| `\p{Changes_When_Casemapped}`      |               |
+| `\p{Changes_When_Lowercased}`      |               |
+| `\p{Changes_When_NFKC_Casefolded}` |               |
+| `\p{Changes_When_Titlecased}`      |               |
+| `\p{Changes_When_Uppercased}`      |               |
+| `\p{Dash}`                         |               |
+| `\p{Default_Ignorable_Code_Point}` |               |
+| `\p{Deprecated}`                   |               |
+| `\p{Diacritic}`                    |               |
+| `\p{Emoji}`                        |               |
+| `\p{Emoji_Component}`              |               |
+| `\p{Emoji_Modifier}`               |               |
+| `\p{Emoji_Modifier_Base}`          |               |
+| `\p{Emoji_Presentation}`           |               |
+| `\p{Extender}`                     |               |
+| `\p{Grapheme_Base}`                |               |
+| `\p{Grapheme_Extend}`              |               |
+| `\p{Hex_Digit}`                    |               |
+| `\p{ID_Continue}`                  |               |
+| `\p{ID_Start}`                     |               |
+| `\p{Ideographic}`                  |               |
+| `\p{IDS_Binary_Operator}`          |               |
+| `\p{IDS_Trinary_Operator}`         |               |
+| `\p{Join_Control}`                 |               |
+| `\p{Logical_Order_Exception}`      |               |
+| `\p{Lowercase}`                    |               |
+| `\p{Math}`                         |               |
+| `\p{Noncharacter_Code_Point}`      |               |
+| `\p{Pattern_Syntax}`               |               |
+| `\p{Pattern_White_Space}`          |               |
+| `\p{Quotation_Mark}`               |               |
+| `\p{Radical}`                      |               |
+| `\p{RegionalIndicator}`            |               |
+| `\p{Sentence_Terminal}`            |               |
+| `\p{Soft_Dotted}`                  |               |
+| `\p{Terminal_Punctuation}`         |               |
+| `\p{Unified_Ideograph}`            |               |
+| `\p{Uppercase}`                    |               |
+| `\p{Variation_Selector}`           |               |
+| `\p{White_Space}`                  |               |
+| `\p{XID_Continue}`                 |               |
+| `\p{XID_Start}`                    |               |
diff --git a/files/fr/web/javascript/guide/text_formatting/index.md b/files/fr/web/javascript/guide/text_formatting/index.md
index 0049f8f7ac..b67205a859 100644
--- a/files/fr/web/javascript/guide/text_formatting/index.md
+++ b/files/fr/web/javascript/guide/text_formatting/index.md
@@ -8,196 +8,275 @@ tags:
 translation_of: Web/JavaScript/Guide/Text_formatting
 original_slug: Web/JavaScript/Guide/Formatage_du_texte
 ---
-<div>{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/Numbers_and_dates", "Web/JavaScript/Guide/Regular_Expressions")}}</div>
+{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/Numbers_and_dates", "Web/JavaScript/Guide/Regular_Expressions")}}
 
-<p>Ce chapitre présente comment travailler avec les chaînes de caractères et le texte en JavaScript.</p>
+Ce chapitre présente comment travailler avec les chaînes de caractères et le texte en JavaScript.
 
-<h2 id="Les_chaînes_de_caractères">Les chaînes de caractères</h2>
+## Les chaînes de caractères
 
-<p>Le type {{Glossary("String")}} de JavaScript est utilisé pour représenter des données textuelles. C'est un ensemble d'"éléments" de valeurs non signées sur 16 bits (unités de codage UTF-16). Chaque élément dans la chaîne de caractères occupe une position dans la chaîne de caractères. Le premier élément se trouve à l'indice 0, le suivant à l'indice 1 et ainsi de suite. La longueur d'une chaîne de caractères est le nombre d'éléments qu'elle contient. Vous pouvez créer des chaînes de caractères en utilisant des littéraux de chaîne de caractères ou des objets chaîne de caractères.</p>
+Le type {{Glossary("String")}} de JavaScript est utilisé pour représenter des données textuelles. C'est un ensemble d'"éléments" de valeurs non signées sur 16 bits (unités de codage UTF-16). Chaque élément dans la chaîne de caractères occupe une position dans la chaîne de caractères. Le premier élément se trouve à l'indice 0, le suivant à l'indice 1 et ainsi de suite. La longueur d'une chaîne de caractères est le nombre d'éléments qu'elle contient. Vous pouvez créer des chaînes de caractères en utilisant des littéraux de chaîne de caractères ou des objets chaîne de caractères.
 
-<h3 id="Les_littéraux_de_chaînes_de_caractères">Les littéraux de chaînes de caractères</h3>
+### Les littéraux de chaînes de caractères
 
-<p>Vous pouvez créer des chaînes de caractères simple en utilisant des apostrophes simples ou doubles :</p>
+Vous pouvez créer des chaînes de caractères simple en utilisant des apostrophes simples ou doubles :
 
-<pre class="brush: js">'machin'
-"truc"</pre>
+```js
+'machin'
+"truc"
+```
 
-<p>Des chaînes plus avancées peuvent être créées en utilisant des séquences d'échappement.</p>
+Des chaînes plus avancées peuvent être créées en utilisant des séquences d'échappement.
 
-<h4 id="Les_séquences_déchappement_hexadécimales">Les séquences d'échappement hexadécimales</h4>
+#### Les séquences d'échappement hexadécimales
 
-<p>Le nombre situé après \x est interprété comme un nombre <a href="https://fr.wikipedia.org/wiki/Syst%C3%A8me_hexad%C3%A9cimal">hexadécimal</a> :</p>
+Le nombre situé après \x est interprété comme un nombre [hexadécimal](https://fr.wikipedia.org/wiki/Syst%C3%A8me_hexad%C3%A9cimal) :
 
-<pre class="brush: js">'\xA9' // "©"</pre>
+```js
+'\xA9' // "©"
+```
 
-<h4 id="Les_séquences_déchappement_Unicode">Les séquences d'échappement Unicode</h4>
+#### Les séquences d'échappement Unicode
 
-<p>Les séquences d'échappement Unicode requièrent au moins quatres caractères hexadécimaux après \u.</p>
+Les séquences d'échappement Unicode requièrent au moins quatres caractères hexadécimaux après \u.
 
-<pre class="brush: js">'\u00A9' // "©"</pre>
+```js
+'\u00A9' // "©"
+```
 
-<h4 id="Léchappement_dunités_de_codage_Unicode">L'échappement d'unités de codage Unicode</h4>
+#### L'échappement d'unités de codage Unicode
 
-<p>Nouveau dans ECMAScript 2015. Avec les échappements d'unités de codage Unicode, tout caractère peut être échappé en utilisant des nombres hexadécimaux, de sorte qu'il est possible de d'utiliser des unités de codage Unicode jusqu'à <code>0x10FFFF</code>. Avec les échappements Unicode simples, il est souvent nécessaire d'écrire les moitiés de remplacement séparément pour obtenir le même résultat.</p>
+Nouveau dans ECMAScript 2015. Avec les échappements d'unités de codage Unicode, tout caractère peut être échappé en utilisant des nombres hexadécimaux, de sorte qu'il est possible de d'utiliser des unités de codage Unicode jusqu'à `0x10FFFF`. Avec les échappements Unicode simples, il est souvent nécessaire d'écrire les moitiés de remplacement séparément pour obtenir le même résultat.
 
-<p>Voir aussi {{jsxref("String.fromCodePoint()")}} ou {{jsxref("String.prototype.codePointAt()")}}.</p>
+Voir aussi {{jsxref("String.fromCodePoint()")}} ou {{jsxref("String.prototype.codePointAt()")}}.
 
-<pre class="brush: js">'\u{2F804}'
+```js
+'\u{2F804}'
 
 // Le même avec des échappements Unicode simples
 '\uD87E\uDC04'
-</pre>
+```
 
-<h3 id="Les_objets_String">Les objets String</h3>
+### Les objets String
 
-<p>L'objet {{jsxref("String")}} est un conteneur autour du type de donnée primitif chaîne de caractères.</p>
+L'objet {{jsxref("String")}} est un conteneur autour du type de donnée primitif chaîne de caractères.
 
-<pre><code>var s = new String('foo'); // crée un objet String
-console.log(s); // affiche : {'0': 'f', '1': 'o', '2': 'o'}
-typeof s; // retourne 'object'</code></pre>
+    var s = new String('foo'); // crée un objet String
+    console.log(s); // affiche : {'0': 'f', '1': 'o', '2': 'o'}
+    typeof s; // retourne 'object'
 
-<p>Vous pouvez appeler chacune des méthodes de l'objet <code>String</code> avec une valeur littérale de chaîne de caractères : JavaScript convertira automatiquement le littéral en un objet <code>String</code> temporaire, appellera la méthode, puis supprimera l'objet <code>String</code> temporaire. Vous pouvez aussi utiliser la propriété <code>String.length</code> sur un littéral de chaîne de caractères.</p>
+Vous pouvez appeler chacune des méthodes de l'objet `String` avec une valeur littérale de chaîne de caractères : JavaScript convertira automatiquement le littéral en un objet `String` temporaire, appellera la méthode, puis supprimera l'objet `String` temporaire. Vous pouvez aussi utiliser la propriété `String.length` sur un littéral de chaîne de caractères.
 
-<p>Vous devriez utiliser des littéraux de chaîne de caractères, à moins que vous n'ayez spécifiquement besoin d'un objet <code>String</code>, parce que les objets <code>String</code> peuvent avoir un comportement contre-intuitif :</p>
+Vous devriez utiliser des littéraux de chaîne de caractères, à moins que vous n'ayez spécifiquement besoin d'un objet `String`, parce que les objets `String` peuvent avoir un comportement contre-intuitif :
 
-<pre class="brush: js">var s1 = '2 + 2'; // crée une valeur de chaîne de caractères
+```js
+var s1 = '2 + 2'; // crée une valeur de chaîne de caractères
 var s2 = new String('2 + 2'); // crée un objet String
 eval(s1); // renvoie le nombre 4
-eval(s2); // renvoie la chaîne "2 + 2"</pre>
+eval(s2); // renvoie la chaîne "2 + 2"
+```
 
-<p>Un objet <code>String</code> possède une propriété, <code>length</code>, qui indique le nombre d'unités de codage UTF-16 dans la chaîne de caractères. Par exemple, le code suivant affecte à <code>x</code> la valeur 16, parce que la chaîne "Bonjour, Monde !" contient 16 caractères, chacun représenté par une unité de codage UTF-16. Vous pouvez accéder à chaque unité de codage en utilisant une syntaxe de tableau entre crochets. Vous ne pouvez pas changer les caractères, du fait que les chaînes sont des objets immuables (semblables à des tableaux) :</p>
+Un objet `String` possède une propriété, `length`, qui indique le nombre d'unités de codage UTF-16 dans la chaîne de caractères. Par exemple, le code suivant affecte à `x` la valeur 16, parce que la chaîne "Bonjour, Monde !" contient 16 caractères, chacun représenté par une unité de codage UTF-16. Vous pouvez accéder à chaque unité de codage en utilisant une syntaxe de tableau entre crochets. Vous ne pouvez pas changer les caractères, du fait que les chaînes sont des objets immuables (semblables à des tableaux) :
 
-<pre class="brush: js">var machaine = 'Bonjour, Monde !';
+```js
+var machaine = 'Bonjour, Monde !';
 var x = machaine.length;
 machaine[0] = 'L'; // cela n'a aucun effet car les chaînes sont immuables
 machaine[0]; // cela renvoie "B"
-</pre>
+```
 
-<p>Les caractères dont les valeurs scalaires sont supérieures à U+FFFF (comme certains rares caractères chinois/japonais/coréens/vietnamiens et certains emojis) sont stockés en UTF-16 via deux unités de codage de remplacement. Par exemple, une chaîne de caractères contenant le seul caractère U+1F600 ("Emoji grinning face") aura une longueur de 2. Le fait d'accéder aux unités de codage individuelles dans une telle chaîne de caractères en utilisant des crochets peut avoir des conséquences indésirables telles que la génération d'unité de codage de remplacement non conformes, en violation du standard Unicode. (Des exemples devraient être ajoutés à cette page après que le bug MDN 857438 sera corrigé. Voir aussi {{jsxref("String.fromCodePoint()")}} ou {{jsxref("String.prototype.codePointAt()")}}.</p>
+Les caractères dont les valeurs scalaires sont supérieures à U+FFFF (comme certains rares caractères chinois/japonais/coréens/vietnamiens et certains emojis) sont stockés en UTF-16 via deux unités de codage de remplacement. Par exemple, une chaîne de caractères contenant le seul caractère U+1F600 ("Emoji grinning face") aura une longueur de 2. Le fait d'accéder aux unités de codage individuelles dans une telle chaîne de caractères en utilisant des crochets peut avoir des conséquences indésirables telles que la génération d'unité de codage de remplacement non conformes, en violation du standard Unicode. (Des exemples devraient être ajoutés à cette page après que le bug MDN 857438 sera corrigé. Voir aussi {{jsxref("String.fromCodePoint()")}} ou {{jsxref("String.prototype.codePointAt()")}}.
 
-<p>Un objet String a une grande variété de méthodes : par exemple, celles qui retournent une variation de la chaîne de caractères elle-même, telles que <code>substring</code> et <code>toUpperCase</code>.</p>
+Un objet String a une grande variété de méthodes : par exemple, celles qui retournent une variation de la chaîne de caractères elle-même, telles que `substring` et `toUpperCase`.
 
-<p>Le tableau suivant résume les méthodes des objets {{jsxref("String")}}.</p>
+Le tableau suivant résume les méthodes des objets {{jsxref("String")}}.
 
-<h4 id="Méthodes_de_String">Méthodes de <code>String</code></h4>
+#### Méthodes de `String`
 
 <table class="standard-table">
- <thead>
-  <tr>
-   <th scope="col">Méthode</th>
-   <th scope="col">Description</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td>{{jsxref("String.charAt", "charAt")}}, {{jsxref("String.charCodeAt", "charCodeAt")}}, {{jsxref("String.codePointAt", "codePointAt")}}</td>
-   <td>Retourne le caractère ou le code de caractère à la position spécifiée de la chaîne de caractères.</td>
-  </tr>
-  <tr>
-   <td>{{jsxref("String.indexOf", "indexOf")}}, {{jsxref("String.lastIndexOf", "lastIndexOf")}}</td>
-   <td>Retourne la position de la sous-chaîne spécifiée dans la chaîne de caractères, ou la dernière position de la sous-chaîne spécifiée, respectivement.</td>
-  </tr>
-  <tr>
-   <td>{{jsxref("String.startsWith", "startsWith")}}, {{jsxref("String.endsWith", "endsWith")}}, {{jsxref("String.includes", "includes")}}</td>
-   <td>Retourne le fait de savoir si la chaîne de caractères courante commence ou non par, finit ou non par, ou contient ou non, la chaîne spécifiée.</td>
-  </tr>
-  <tr>
-   <td>{{jsxref("String.concat", "concat")}}</td>
-   <td>Combine le texte de deux chaînes de caractères et retourne une nouvelle chaîne de caractères.</td>
-  </tr>
-  <tr>
-   <td>{{jsxref("String.fromCharCode", "fromCharCode")}}, {{jsxref("String.fromCodePoint", "fromCodePoint")}},</td>
-   <td>Construit une chaîne de caractères à partir de la séquence de valeurs Unicode fournie. Cette méthode est une méthode de la classe String et non une instance de String.</td>
-  </tr>
-  <tr>
-   <td>{{jsxref("String.split", "split")}}</td>
-   <td>Découpe un objet <code>String</code> en un tableau de chaînes de caractères en découpant la chaîne de caractères en sous-chaînes.</td>
-  </tr>
-  <tr>
-   <td>{{jsxref("String.slice", "slice")}}</td>
-   <td>Extrait une partie de la chaîne de caractères et retourne une nouvelle chaîne de caractères.</td>
-  </tr>
-  <tr>
-   <td>{{jsxref("String.substring", "substring")}}, {{jsxref("String.substr", "substr")}}</td>
-   <td>Retourne le sous-ensemble spécifié de la chaîne de caractères, en spécifiant soit des indices de début et de fin, soit l'indice de début et une longueur.</td>
-  </tr>
-  <tr>
-   <td>{{jsxref("String.match", "match")}}, {{jsxref("String.matchAll", "matchAll")}}, {{jsxref("String.replace", "replace")}}, {{jsxref("String.search", "search")}}</td>
-   <td>Ces fonctions utilisent des expressions rationnelles.</td>
-  </tr>
-  <tr>
-   <td>{{jsxref("String.toLowerCase", "toLowerCase")}}, {{jsxref("String.toUpperCase", "toUpperCase")}}</td>
-   <td>
-    <p>Retourne la chaîne tout en minuscules ou tout en majuscules, respectivement.</p>
-   </td>
-  </tr>
-  <tr>
-   <td>{{jsxref("String.normalize", "normalize")}}</td>
-   <td>Retourne la Forme Normalisée Unicode de la chaîne de caractères appelante.</td>
-  </tr>
-  <tr>
-   <td>{{jsxref("String.repeat", "repeat")}}</td>
-   <td>Retourne une chaîne constituée des éléments de l'objet répétés le nombre de fois donné.</td>
-  </tr>
-  <tr>
-   <td>{{jsxref("String.trim", "trim")}}</td>
-   <td>Retire les blancs en début et en fin de chaîne.</td>
-  </tr>
- </tbody>
+  <thead>
+    <tr>
+      <th scope="col">Méthode</th>
+      <th scope="col">Description</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td>
+        {{jsxref("String.charAt", "charAt")}},
+        {{jsxref("String.charCodeAt", "charCodeAt")}},
+        {{jsxref("String.codePointAt", "codePointAt")}}
+      </td>
+      <td>
+        Retourne le caractère ou le code de caractère à la position spécifiée de
+        la chaîne de caractères.
+      </td>
+    </tr>
+    <tr>
+      <td>
+        {{jsxref("String.indexOf", "indexOf")}},
+        {{jsxref("String.lastIndexOf", "lastIndexOf")}}
+      </td>
+      <td>
+        Retourne la position de la sous-chaîne spécifiée dans la chaîne de
+        caractères, ou la dernière position de la sous-chaîne spécifiée,
+        respectivement.
+      </td>
+    </tr>
+    <tr>
+      <td>
+        {{jsxref("String.startsWith", "startsWith")}},
+        {{jsxref("String.endsWith", "endsWith")}},
+        {{jsxref("String.includes", "includes")}}
+      </td>
+      <td>
+        Retourne le fait de savoir si la chaîne de caractères courante commence
+        ou non par, finit ou non par, ou contient ou non, la chaîne spécifiée.
+      </td>
+    </tr>
+    <tr>
+      <td>{{jsxref("String.concat", "concat")}}</td>
+      <td>
+        Combine le texte de deux chaînes de caractères et retourne une nouvelle
+        chaîne de caractères.
+      </td>
+    </tr>
+    <tr>
+      <td>
+        {{jsxref("String.fromCharCode", "fromCharCode")}},
+        {{jsxref("String.fromCodePoint", "fromCodePoint")}},
+      </td>
+      <td>
+        Construit une chaîne de caractères à partir de la séquence de valeurs
+        Unicode fournie. Cette méthode est une méthode de la classe String et
+        non une instance de String.
+      </td>
+    </tr>
+    <tr>
+      <td>{{jsxref("String.split", "split")}}</td>
+      <td>
+        Découpe un objet <code>String</code> en un tableau de chaînes de
+        caractères en découpant la chaîne de caractères en sous-chaînes.
+      </td>
+    </tr>
+    <tr>
+      <td>{{jsxref("String.slice", "slice")}}</td>
+      <td>
+        Extrait une partie de la chaîne de caractères et retourne une nouvelle
+        chaîne de caractères.
+      </td>
+    </tr>
+    <tr>
+      <td>
+        {{jsxref("String.substring", "substring")}},
+        {{jsxref("String.substr", "substr")}}
+      </td>
+      <td>
+        Retourne le sous-ensemble spécifié de la chaîne de caractères, en
+        spécifiant soit des indices de début et de fin, soit l'indice de début
+        et une longueur.
+      </td>
+    </tr>
+    <tr>
+      <td>
+        {{jsxref("String.match", "match")}}, {{jsxref("String.matchAll", "matchAll")}},
+        {{jsxref("String.replace", "replace")}},
+        {{jsxref("String.search", "search")}}
+      </td>
+      <td>Ces fonctions utilisent des expressions rationnelles.</td>
+    </tr>
+    <tr>
+      <td>
+        {{jsxref("String.toLowerCase", "toLowerCase")}},
+        {{jsxref("String.toUpperCase", "toUpperCase")}}
+      </td>
+      <td>
+        <p>
+          Retourne la chaîne tout en minuscules ou tout en majuscules,
+          respectivement.
+        </p>
+      </td>
+    </tr>
+    <tr>
+      <td>{{jsxref("String.normalize", "normalize")}}</td>
+      <td>
+        Retourne la Forme Normalisée Unicode de la chaîne de caractères
+        appelante.
+      </td>
+    </tr>
+    <tr>
+      <td>{{jsxref("String.repeat", "repeat")}}</td>
+      <td>
+        Retourne une chaîne constituée des éléments de l'objet répétés le nombre
+        de fois donné.
+      </td>
+    </tr>
+    <tr>
+      <td>{{jsxref("String.trim", "trim")}}</td>
+      <td>Retire les blancs en début et en fin de chaîne.</td>
+    </tr>
+  </tbody>
 </table>
 
-<h3 id="Les_littéraux_de_modèle_multi-lignes">Les littéraux de modèle multi-lignes</h3>
+### Les littéraux de modèle multi-lignes
 
-<p>Le <a href="/fr/docs/Web/JavaScript/Reference/Litt%C3%A9raux_gabarits">littéraux de modèle</a> sont des littéraux de chaîne de caractères permettant des expressions intégrées. Avec eux, vous pouvez utiliser des chaînes de caractères multi-lignes et des fonctionnalités d'interpolation de chaînes.</p>
+Le [littéraux de modèle](/fr/docs/Web/JavaScript/Reference/Litt%C3%A9raux_gabarits) sont des littéraux de chaîne de caractères permettant des expressions intégrées. Avec eux, vous pouvez utiliser des chaînes de caractères multi-lignes et des fonctionnalités d'interpolation de chaînes.
 
-<p>Les littéraux de gabarits sont délimités par des <a href="https://fr.wikipedia.org/wiki/Accent_grave">accents graves</a> (ou <em>backticks` `</em> en anglais), au lieu des apostrophes simples ou doubles. Les littéraux de modèle peuvent contenir des marque-places. Ceux-ci sont indiqués par le signe dollar et des accolades (<code>${expression}</code>).</p>
+Les littéraux de gabarits sont délimités par des [accents graves](https://fr.wikipedia.org/wiki/Accent_grave) (ou _backticks\` \`_ en anglais), au lieu des apostrophes simples ou doubles. Les littéraux de modèle peuvent contenir des marque-places. Ceux-ci sont indiqués par le signe dollar et des accolades (`${expression}`).
 
-<h4 id="Multi-lignes">Multi-lignes</h4>
+#### Multi-lignes
 
-<p>Tout caractère de passage à la ligne inséré dans le source fait partie du littéral de modèle. En utilisant les chaînes de caractères normales, vous auriez eu à utiliser la syntaxe suivante afin d'avoir des chaînes de caractères multi-lignes :</p>
+Tout caractère de passage à la ligne inséré dans le source fait partie du littéral de modèle. En utilisant les chaînes de caractères normales, vous auriez eu à utiliser la syntaxe suivante afin d'avoir des chaînes de caractères multi-lignes :
 
-<pre class="brush: js">console.log('chaîne ligne de texte 1\n\
+```js
+console.log('chaîne ligne de texte 1\n\
 chaîne ligne de texte 2');
 // "chaîne ligne de texte 1
-// chaîne ligne de texte 2"</pre>
+// chaîne ligne de texte 2"
+```
 
-<p>Pour obtenir le même effet avec des chaînes de caractères multi-lignes, vous pouvez maintenant écrire :</p>
+Pour obtenir le même effet avec des chaînes de caractères multi-lignes, vous pouvez maintenant écrire :
 
-<pre class="brush: js">console.log(`chaîne ligne de texte 1
+```js
+console.log(`chaîne ligne de texte 1
 chaîne ligne de texte 2`);
 // "chaîne ligne de texte 1
-// chaîne ligne de texte 2"</pre>
+// chaîne ligne de texte 2"
+```
 
-<h4 id="Expressions_intégrées">Expressions intégrées</h4>
+#### Expressions intégrées
 
-<p>Pour intégrer des expressions dans des chaînes normales, vous devriez utiliser la syntaxe suivante :</p>
+Pour intégrer des expressions dans des chaînes normales, vous devriez utiliser la syntaxe suivante :
 
-<pre class="brush: js">var a = 5;
+```js
+var a = 5;
 var b = 10;
 console.log('Quinze vaut ' + (a + b) + ' et\npas ' + (2 * a + b) + '.');
 // "Quinze vaut 15 et
-// pas 20."</pre>
+// pas 20."
+```
 
-<p>Maintenant, avec les modèles, vous pouvez utiliser du sucre syntaxique rendant plus lisibles les substitutions comme celle-ci :</p>
+Maintenant, avec les modèles, vous pouvez utiliser du sucre syntaxique rendant plus lisibles les substitutions comme celle-ci :
 
-<pre class="brush: js">var a = 5;
+```js
+var a = 5;
 var b = 10;
 console.log(`Quinze vaut ${a + b} et\npas ${2 * a + b}.`);
 // "Quinze vaut 15 et
-// pas 20."</pre>
+// pas 20."
+```
 
-<p>Pour plus d'informations, voir les <a href="/fr/docs/Web/JavaScript/Reference/Littéraux_gabarits">Littéraux de modèles</a> dans la <a href="/fr/docs/Web/JavaScript/Reference">Référence JavaScript</a>.</p>
+Pour plus d'informations, voir les [Littéraux de modèles](/fr/docs/Web/JavaScript/Reference/Littéraux_gabarits) dans la [Référence JavaScript](/fr/docs/Web/JavaScript/Reference).
 
-<h2 id="Internationalisation">Internationalisation</h2>
+## Internationalisation
 
-<p>L'objet {{jsxref("Intl")}} est l'espace de noms pour l'API d'Internationalisation de l'ECMAScript, qui fournit des fonctionnalités de comparaison de chaînes de caractères, de formatage de nombres, et de formatage des dates et heures prenant en compte la langue. Les constructeurs pour les objets {{jsxref("Collator")}}, {{jsxref("NumberFormat")}} et {{jsxref("DateTimeFormat")}} sont des propriétés de l'objet <code>Intl</code>.</p>
+L'objet {{jsxref("Intl")}} est l'espace de noms pour l'API d'Internationalisation de l'ECMAScript, qui fournit des fonctionnalités de comparaison de chaînes de caractères, de formatage de nombres, et de formatage des dates et heures prenant en compte la langue. Les constructeurs pour les objets {{jsxref("Collator")}}, {{jsxref("NumberFormat")}} et {{jsxref("DateTimeFormat")}} sont des propriétés de l'objet `Intl`.
 
-<h3 id="Formatage_date_et_heure">Formatage date et heure</h3>
+### Formatage date et heure
 
-<p>L'objet {{jsxref("DateTimeFormat")}} est utile pour formater la date et l'heure. Ce qui suit formate une date en anglais telle qu'utilisée aux États-Unis (le résultat sera différent dans une autre zone horaire).</p>
+L'objet {{jsxref("DateTimeFormat")}} est utile pour formater la date et l'heure. Ce qui suit formate une date en anglais telle qu'utilisée aux États-Unis (le résultat sera différent dans une autre zone horaire).
 
-<pre class="brush: js">var msParJour = 24 * 60 * 60 * 1000;
+```js
+var msParJour = 24 * 60 * 60 * 1000;
 
 // 17 juillet 2014 00:00:00 UTC.
 var _17juillet2014 = new Date(msParJour * (44 * 365 + 11 + 197));
@@ -207,13 +286,14 @@ var options = { year: "2-digit", month: "2-digit", day: "2-digit",
 var dateHeureAmericaine = new Intl.DateTimeFormat("en-US", options).format;
 
 console.log(dateHeureAmericaine(_17juillet2014)); // 07/16/14, 5:00 PM PDT
-</pre>
+```
 
-<h3 id="Formatage_des_nombres">Formatage des nombres</h3>
+### Formatage des nombres
 
-<p>L'objet {{jsxref("NumberFormat")}} est utile pour formater les nombres, par exemple, les devises :</p>
+L'objet {{jsxref("NumberFormat")}} est utile pour formater les nombres, par exemple, les devises :
 
-<pre class="brush: js">var prixDeLEssence = new Intl.NumberFormat("en-US",
+```js
+var prixDeLEssence = new Intl.NumberFormat("en-US",
                         { style: "currency", currency: "USD",
                           minimumFractionDigits: 3 });
 
@@ -223,32 +303,34 @@ var decimalesHanRMBEnChine = new Intl.NumberFormat("zh-CN-u-nu-hanidec",
                         { style: "currency", currency: "CNY" });
 
 console.log(decimalesHanRMBEnChine.format(1314.25)); // ￥ 一,三一四.二五
-</pre>
+```
 
-<h3 id="Ordonnancement">Ordonnancement</h3>
+### Ordonnancement
 
-<p>L'objet {{jsxref("Collator")}} est utile pour comparer et trier des chaînes de caractères.</p>
+L'objet {{jsxref("Collator")}} est utile pour comparer et trier des chaînes de caractères.
 
-<p>Par exemple, il y a en fait deux ordres de tri en allemand, <em>annuaire</em> et <em>dictionnaire</em>. Annuaire met l'accent sur le son, et c'est comme si "ä", "ö", etc. étaient étendus en "ae", "oe", etc. avant le tri :</p>
+Par exemple, il y a en fait deux ordres de tri en allemand, _annuaire_ et _dictionnaire_. Annuaire met l'accent sur le son, et c'est comme si "ä", "ö", etc. étaient étendus en "ae", "oe", etc. avant le tri :
 
-<pre class="brush: js">var noms = ['Hochberg', 'Hönigswald', 'Holzman'];
+```js
+var noms = ['Hochberg', 'Hönigswald', 'Holzman'];
 
 var annuaireAllemand = new Intl.Collator('de-DE-u-co-phonebk');
 
 // Comme si tri de ['Hochberg', 'Hoenigswald', 'Holzman']:
 console.log(noms.sort(annuaireAllemand.compare).join(', '));
 // Affiche "Hochberg, Hönigswald, Holzman"
-</pre>
+```
 
-<p>Certains mots allemands se conjuguent avec des umlauts supplémentaires, de sorte que dans les dictionnaires, le fait d'ignorer les umlauts pour le tri  est perceptible (sauf lors du tri de mots ne différant <em>que</em> par des umlauts, comme <em>schon</em> avant <em>schön</em>).</p>
+Certains mots allemands se conjuguent avec des umlauts supplémentaires, de sorte que dans les dictionnaires, le fait d'ignorer les umlauts pour le tri  est perceptible (sauf lors du tri de mots ne différant _que_ par des umlauts, comme *schon* avant _schön_).
 
-<pre class="brush: js">var dictionnaireAllemand = new Intl.Collator('de-DE-u-co-dict');
+```js
+var dictionnaireAllemand = new Intl.Collator('de-DE-u-co-dict');
 
 // Comme si tri de ["Hochberg", "Honigswald", "Holzman"]:
 console.log(nom.sort(dictionnaireAllemand.compare).join(', '));
 // Affiche "Hochberg, Holzman, Hönigswald"
-</pre>
+```
 
-<p>Pour plus d'informations sur l'API {{jsxref("Intl")}}, voir aussi <a href="https://hacks.mozilla.org/2014/12/introducing-the-javascript-internationalization-api/">Introducing the JavaScript Internationalization API</a>.</p>
+Pour plus d'informations sur l'API {{jsxref("Intl")}}, voir aussi [Introducing the JavaScript Internationalization API](https://hacks.mozilla.org/2014/12/introducing-the-javascript-internationalization-api/).
 
-<p>{{PreviousNext("Web/JavaScript/Guide/Numbers_and_dates", "Web/JavaScript/Guide/Regular_Expressions")}}</p>
+{{PreviousNext("Web/JavaScript/Guide/Numbers_and_dates", "Web/JavaScript/Guide/Regular_Expressions")}}
diff --git a/files/fr/web/javascript/guide/using_promises/index.md b/files/fr/web/javascript/guide/using_promises/index.md
index 5f30035f51..95b35d1884 100644
--- a/files/fr/web/javascript/guide/using_promises/index.md
+++ b/files/fr/web/javascript/guide/using_promises/index.md
@@ -10,16 +10,17 @@ tags:
 translation_of: Web/JavaScript/Guide/Using_promises
 original_slug: Web/JavaScript/Guide/Utiliser_les_promesses
 ---
-<div>{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/Le_modèle_objet_JavaScript_en_détails", "Web/JavaScript/Guide/iterateurs_et_generateurs")}}</div>
+{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/Le_modèle_objet_JavaScript_en_détails", "Web/JavaScript/Guide/iterateurs_et_generateurs")}}
 
-<p>Une promesse est un objet ({{jsxref("Promise")}}) qui représente la complétion ou l'échec d'une opération asynchrone. La plupart du temps, on « consomme » des promesses et c'est donc ce que nous verrons dans la première partie de ce guide pour ensuite expliquer comment les créer.</p>
+Une promesse est un objet ({{jsxref("Promise")}}) qui représente la complétion ou l'échec d'une opération asynchrone. La plupart du temps, on « consomme » des promesses et c'est donc ce que nous verrons dans la première partie de ce guide pour ensuite expliquer comment les créer.
 
-<p>En résumé, une promesse est un objet qui est renvoyé et auquel on attache des <em>callbacks</em> plutôt que de passer des <em>callbacks</em> à une fonction. Ainsi, au lieu d'avoir une fonction qui prend deux <em>callbacks</em> en arguments :</p>
+En résumé, une promesse est un objet qui est renvoyé et auquel on attache des _callbacks_ plutôt que de passer des _callbacks_ à une fonction. Ainsi, au lieu d'avoir une fonction qui prend deux _callbacks_ en arguments :
 
-<pre class="brush: js">function faireQqcALAncienne(successCallback, failureCallback){
+```js
+function faireQqcALAncienne(successCallback, failureCallback){
   console.log("C'est fait");
   // réussir une fois sur deux
-  if (Math.random() &gt; .5) {
+  if (Math.random() > .5) {
     successCallback("Réussite");
   } else {
     failureCallback("Échec");
@@ -36,16 +37,16 @@ function failureCallback(erreur) {
 }
 
 faireQqcALAncienne(successCallback, failureCallback);
+```
 
-</pre>
+On aura une fonction qui renvoie une promesse et on attachera les callbacks sur cette promesse :
 
-<p>On aura une fonction qui renvoie une promesse et on attachera les callbacks sur cette promesse :</p>
-
-<pre class="brush: js">function faireQqc() {
-  return new Promise((successCallback, failureCallback) =&gt; {
+```js
+function faireQqc() {
+  return new Promise((successCallback, failureCallback) => {
     console.log("C'est fait");
     // réussir une fois sur deux
-    if (Math.random() &gt; .5) {
+    if (Math.random() > .5) {
       successCallback("Réussite");
     } else {
       failureCallback("Échec");
@@ -55,58 +56,61 @@ faireQqcALAncienne(successCallback, failureCallback);
 
 const promise = faireQqc();
 promise.then(successCallback, failureCallback);
-</pre>
+```
 
-<p>ou encore :</p>
+ou encore :
 
-<pre class="brush: js">faireQqc().then(successCallback, failureCallback);
-</pre>
+```js
+faireQqc().then(successCallback, failureCallback);
+```
 
-<p>Cette dernière forme est ce qu'on appelle <em>un appel de fonction asynchrone</em>. Cette convention possède différents avantages dont le premier est <em>le chaînage</em>.</p>
+Cette dernière forme est ce qu'on appelle _un appel de fonction asynchrone_. Cette convention possède différents avantages dont le premier est _le chaînage_.
 
-<h2 id="Garanties">Garanties</h2>
+## Garanties
 
-<p>À la différence des imbrications de <em>callbacks</em>, une promesse apporte certaines garanties :</p>
+À la différence des imbrications de _callbacks_, une promesse apporte certaines garanties :
 
-<ul>
- <li>Les <em>callbacks</em> ne seront jamais appelés avant la fin du parcours de la boucle d'évènements JavaScript courante</li>
- <li>Les <em>callbacks</em> ajoutés grâce à <code>then</code> seront appelés, y compris après le succès ou l'échec de l'opération asynchrone</li>
- <li>Plusieurs <em>callbacks</em> peuvent être ajoutés en appelant <code>then</code> plusieurs fois, ils seront alors exécutés l'un après l'autre selon l'ordre dans lequel ils ont été insérés.</li>
-</ul>
+- Les _callbacks_ ne seront jamais appelés avant la fin du parcours de la boucle d'évènements JavaScript courante
+- Les _callbacks_ ajoutés grâce à `then` seront appelés, y compris après le succès ou l'échec de l'opération asynchrone
+- Plusieurs _callbacks_ peuvent être ajoutés en appelant `then` plusieurs fois, ils seront alors exécutés l'un après l'autre selon l'ordre dans lequel ils ont été insérés.
 
-<h2 id="Chaînage_des_promesses">Chaînage des promesses</h2>
+## Chaînage des promesses
 
-<p>Un besoin fréquent est d'exécuter deux ou plus d'opérations asynchrones les unes à la suite des autres, avec chaque opération qui démarre lorsque la précédente a réussi et en utilisant le résultat de l'étape précédente. Ceci peut être réalisé en créant une chaîne de promesses.</p>
+Un besoin fréquent est d'exécuter deux ou plus d'opérations asynchrones les unes à la suite des autres, avec chaque opération qui démarre lorsque la précédente a réussi et en utilisant le résultat de l'étape précédente. Ceci peut être réalisé en créant une chaîne de promesses.
 
-<p>La méthode <code>then()</code> renvoie une <em>nouvelle</em> promesse, différente de la première :</p>
+La méthode `then()` renvoie une _nouvelle_ promesse, différente de la première :
 
-<pre class="brush: js">const promise = faireQqc();
+```js
+const promise = faireQqc();
 const promise2 = promise.then(successCallback, failureCallback);
-</pre>
+```
 
-<p>ou encore :</p>
+ou encore :
 
-<pre class="brush: js">const promise2 = faireQqc().then(successCallback, failureCallback);
-</pre>
+```js
+const promise2 = faireQqc().then(successCallback, failureCallback);
+```
 
-<p>La deuxième promesse (<code>promise2</code>) indique l'état de complétion, pas uniquement pour <code>faireQqc()</code> mais aussi pour le callback qui lui a été passé (<code>successCallback</code> ou <code>failureCallback</code>) qui peut aussi être une fonction asynchrone qui renvoie une promesse. Lorsque c'est le cas, tous les <em>callbacks</em> ajoutés à <code>promise2</code> forment une file derrière la promesse renvoyée par <code>successCallback</code> ou <code>failureCallback</code>.</p>
+La deuxième promesse (`promise2`) indique l'état de complétion, pas uniquement pour `faireQqc()` mais aussi pour le callback qui lui a été passé (`successCallback` ou `failureCallback`) qui peut aussi être une fonction asynchrone qui renvoie une promesse. Lorsque c'est le cas, tous les _callbacks_ ajoutés à `promise2` forment une file derrière la promesse renvoyée par `successCallback` ou `failureCallback`.
 
-<p>Autrement dit, chaque promesse représente l'état de complétion d'une étape asynchrone au sein de cette succession d'étapes.</p>
+Autrement dit, chaque promesse représente l'état de complétion d'une étape asynchrone au sein de cette succession d'étapes.
 
-<p>Auparavant, l'enchaînement de plusieurs opérations asynchrones déclenchait une pyramide dantesque de <em>callbacks</em> :</p>
+Auparavant, l'enchaînement de plusieurs opérations asynchrones déclenchait une pyramide dantesque de _callbacks_ :
 
-<pre class="brush: js">faireQqc(function(result) {
+```js
+faireQqc(function(result) {
   faireAutreChose(result, function(newResult) {
     faireUnTroisiemeTruc(newResult, function(finalResult) {
       console.log('Résultat final :' + finalResult);
     }, failureCallback);
   }, failureCallback);
 }, failureCallback);
-</pre>
+```
 
-<p>Grâce à des fonctions plus modernes et aux promesses, on attache les <em>callbacks</em> aux promesses qui sont renvoyées. On peut ainsi construire une <em>chaîne de promesses</em> :</p>
+Grâce à des fonctions plus modernes et aux promesses, on attache les _callbacks_ aux promesses qui sont renvoyées. On peut ainsi construire une _chaîne de promesses_ :
 
-<pre class="brush: js">faireQqc().then(function(result) {
+```js
+faireQqc().then(function(result) {
   return faireAutreChose(result);
 })
 .then(function(newResult) {
@@ -116,68 +120,69 @@ const promise2 = promise.then(successCallback, failureCallback);
   console.log('Résultat final : ' + finalResult);
 })
 .catch(failureCallback);
-</pre>
+```
 
-<p>Les arguments passés à <code>then</code> sont optionnels. La forme <code>catch(failureCallback)</code> est un alias plus court pour <code>then(null, failureCallback)</code>. Ces chaînes de promesses sont parfois construites avec <a href="/fr/docs/Web/JavaScript/Reference/Fonctions/Fonctions_fléchées">des fonctions fléchées</a> :</p>
+Les arguments passés à `then` sont optionnels. La forme `catch(failureCallback)` est un alias plus court pour `then(null, failureCallback)`. Ces chaînes de promesses sont parfois construites avec [des fonctions fléchées](/fr/docs/Web/JavaScript/Reference/Fonctions/Fonctions_fléchées) :
 
-<pre class="brush: js">faireQqc()
-.then(result =&gt; faireAutreChose(result))
-.then(newResult =&gt; faireUnTroisiemeTruc(newResult))
-.then(finalResult =&gt; {
+```js
+faireQqc()
+.then(result => faireAutreChose(result))
+.then(newResult => faireUnTroisiemeTruc(newResult))
+.then(finalResult => {
   console.log('Résultat final : ' + finalResult);
 })
 .catch(failureCallback);
-</pre>
+```
 
-<div class="warning">
-<p><strong>Attention :</strong> cela implique que les fonctions asynchrones renvoient toutes des promesses, sinon les <em>callbacks</em> ne pourront être chaînés et les erreurs ne seront pas interceptées (les fonctions fléchées ont une valeur de retour implicite si les accolades ne sont pas utilisées : <code>() =&gt; x</code> est synonyme de <code>() =&gt; { return x; }</code>).</p>
-</div>
+> **Attention :** cela implique que les fonctions asynchrones renvoient toutes des promesses, sinon les _callbacks_ ne pourront être chaînés et les erreurs ne seront pas interceptées (les fonctions fléchées ont une valeur de retour implicite si les accolades ne sont pas utilisées : `() => x` est synonyme de `() => { return x; }`).
 
-<h3 id="Chaînage_après_un_catch">Chaînage après un catch</h3>
+### Chaînage après un catch
 
-<p>Il est possible de chaîner de nouvelles actions <em>après</em> un rejet, c'est-à-dire un <code>catch</code>. C'est utile pour accomplir de nouvelles actions après qu'une action ait échoué dans la chaine. Par exemple :</p>
+Il est possible de chaîner de nouvelles actions _après_ un rejet, c'est-à-dire un `catch`. C'est utile pour accomplir de nouvelles actions après qu'une action ait échoué dans la chaine. Par exemple :
 
-<pre class="brush: js">new Promise((resolve, reject) =&gt; {
+```js
+new Promise((resolve, reject) => {
     console.log('Initial');
 
     resolve();
 })
-.then(() =&gt; {
+.then(() => {
     throw new Error('Something failed');
 
     console.log('Do this');
 })
-.catch(() =&gt; {
+.catch(() => {
     console.error('Do that');
 })
-.then(() =&gt; {
+.then(() => {
     console.log('Do this whatever happened before');
 });
-</pre>
+```
 
-<p>Cela va produire la sortie suivante :</p>
+Cela va produire la sortie suivante :
 
-<pre>Initial
-Do that
-Do this whatever happened before
-</pre>
+    Initial
+    Do that
+    Do this whatever happened before
 
-<p>Notez que le texte <q>Do this</q> n'est pas affiché car l'erreur <q>Something failed</q> a produit un rejet.</p>
+Notez que le texte "Do this" n'est pas affiché car l'erreur "Something failed" a produit un rejet.
 
-<h2 id="Propagation_des_erreurs">Propagation des erreurs</h2>
+## Propagation des erreurs
 
-<p>Dans les exemples précédents, <code>failureCallback</code> était présent trois fois dans la pyramide de <em>callbacks</em> et une seule fois, à la fin, dans la chaîne des promesses :</p>
+Dans les exemples précédents, `failureCallback` était présent trois fois dans la pyramide de _callbacks_ et une seule fois, à la fin, dans la chaîne des promesses :
 
-<pre class="brush: js">faireQqc()
-.then(result =&gt; faireAutreChose(result))
-.then(newResult =&gt; faireUnTroisiemeTruc(newResult))
-.then(finalResult =&gt; console.log('Résultat final : ' + finalResult))
+```js
+faireQqc()
+.then(result => faireAutreChose(result))
+.then(newResult => faireUnTroisiemeTruc(newResult))
+.then(finalResult => console.log('Résultat final : ' + finalResult))
 .catch(failureCallback);
-</pre>
+```
 
-<p>En fait, dès qu'une exception est levée, la chaîne de promesses utilisera le premier <code>catch()</code> ou <code>onRejected</code> disponible. Ce fonctionnement est assez proche de ce qu'on peut trouver pour du code synchrone :</p>
+En fait, dès qu'une exception est levée, la chaîne de promesses utilisera le premier `catch()` ou `onRejected` disponible. Ce fonctionnement est assez proche de ce qu'on peut trouver pour du code synchrone :
 
-<pre class="brush: js">try {
+```js
+try {
   const result = syncFaireQqc();
   const newResult = syncFaireQqcAutre(result);
   const finalResult = syncFaireUnTroisiemeTruc(newResult);
@@ -185,11 +190,12 @@ Do this whatever happened before
 } catch(error) {
   failureCallback(error);
 }
-</pre>
+```
 
-<p>Cette symétrie entre le code asynchrone et le code synchrone atteint son paroxysme avec le couple d'opérateurs <a href="/fr/docs/Web/JavaScript/Reference/Instructions/async_function"><code>async</code>/<code>await</code></a> d'ECMAScript 2017:</p>
+Cette symétrie entre le code asynchrone et le code synchrone atteint son paroxysme avec le couple d'opérateurs [`async`/`await`](/fr/docs/Web/JavaScript/Reference/Instructions/async_function) d'ECMAScript 2017:
 
-<pre class="brush: js">async function toto() {
+```js
+async function toto() {
   try {
     const result = await faireQqc();
     const newResult = await faireQqcAutre(result);
@@ -199,117 +205,126 @@ Do this whatever happened before
     failureCallback(error);
   }
 }
-</pre>
+```
 
-<p>Ce fonctionnement est construit sur les promesses et <code>faireQqc()</code> est la même fonction que celle utilisée dans les exemples précédents.</p>
+Ce fonctionnement est construit sur les promesses et `faireQqc()` est la même fonction que celle utilisée dans les exemples précédents.
 
-<p>Les promesses permettent de résoudre les problèmes de cascades infernales de <em>callbacks</em> notamment en interceptant les différentes erreurs (exceptions et erreurs de programmation). Ceci est essentiel pour obtenir une composition fonctionnelle des opérations asynchrones.</p>
+Les promesses permettent de résoudre les problèmes de cascades infernales de _callbacks_ notamment en interceptant les différentes erreurs (exceptions et erreurs de programmation). Ceci est essentiel pour obtenir une composition fonctionnelle des opérations asynchrones.
 
-<h2 id="Évènements_liés_à_la_rupture_dune_promesse">Évènements liés à la rupture d'une promesse</h2>
+## Évènements liés à la rupture d'une promesse
 
-<p>Lorsqu'une promesse est rompue/rejetée, un des deux évènements suivants est envoyé au niveau de la portée globale ({{domxref("window")}} ou {{domxref("Worker")}} si le script est utilisé dans un <em>worker</em>) :</p>
+Lorsqu'une promesse est rompue/rejetée, un des deux évènements suivants est envoyé au niveau de la portée globale ({{domxref("window")}} ou {{domxref("Worker")}} si le script est utilisé dans un _worker_) :
 
-<dl>
- <dt>{{domxref("Window.rejectionhandled_event","rejectionhandled")}}</dt>
- <dd>Cet évènement est envoyé lorsqu'une promesse est rompue et après que le rejet ai été traité par la fonction <code>reject</code> associée à la promesse.</dd>
- <dt>{{domxref("Window.unhandledrejection_event","unhandledrejection")}}</dt>
- <dd>Cet évènement est envoyé lorsque la promesse est rompue et qu'aucune fonction n'a été définie pour gérer le rejet de la promesse.</dd>
-</dl>
+- {{domxref("Window.rejectionhandled_event","rejectionhandled")}}
+  - : Cet évènement est envoyé lorsqu'une promesse est rompue et après que le rejet ai été traité par la fonction `reject` associée à la promesse.
+- {{domxref("Window.unhandledrejection_event","unhandledrejection")}}
+  - : Cet évènement est envoyé lorsque la promesse est rompue et qu'aucune fonction n'a été définie pour gérer le rejet de la promesse.
 
-<p>Dans les deux cas, l'évènement (dont le type est {{domxref("PromiseRejectionEvent")}}) aura deux propriétés :</p>
+Dans les deux cas, l'évènement (dont le type est {{domxref("PromiseRejectionEvent")}}) aura deux propriétés :
 
-<dl>
- <dt>{{domxref("PromiseRejectionEvent.promise","promise")}}</dt>
- <dd>La promesse qui a été rompue.</dd>
- <dt>{{domxref("PromiseRejectionEvent.reason","reason")}}</dt>
- <dd>La raison pour laquelle la promesse a été rompue.</dd>
-</dl>
+- {{domxref("PromiseRejectionEvent.promise","promise")}}
+  - : La promesse qui a été rompue.
+- {{domxref("PromiseRejectionEvent.reason","reason")}}
+  - : La raison pour laquelle la promesse a été rompue.
 
-<p>Gérer ces évènements permet d'avoir une ultime méthode pour gérer le rejet des promesses. Cela peut notamment s'avérer utile pour le débogage. Ces évènements sont déclenchés au niveau global et permettent ainsi d'intercepter les erreurs pour chaque contexte (fenêtre ou <em>worker</em>)</p>
+Gérer ces évènements permet d'avoir une ultime méthode pour gérer le rejet des promesses. Cela peut notamment s'avérer utile pour le débogage. Ces évènements sont déclenchés au niveau global et permettent ainsi d'intercepter les erreurs pour chaque contexte (fenêtre ou _worker_)
 
-<pre class="brush: js">window.addEventListener("unhandledrejection", event =&gt; {
+```js
+window.addEventListener("unhandledrejection", event => {
   // Examiner la ou les promesse(s) qui posent problème en debug
   // Nettoyer ce qui doit l'être quand ça se produit en réel
 
-}, false);</pre>
+}, false);
+```
 
-<h2 id="Envelopper_les_callbacks_des_API">Envelopper les <em>callbacks</em> des API</h2>
+## Envelopper les _callbacks_ des API
 
-<p>Il est possible de créer un objet  {{jsxref("Promise")}} grâce à son constructeur. Et même si, idéalement, cela ne devrait pas être nécessaire, certaines API fonctionnent toujours avec des <em>callbacks</em> passés en arguments. C'est notamment le cas de la méthode  {{domxref("WindowTimers.setTimeout", "setTimeout()")}} :</p>
+Il est possible de créer un objet  {{jsxref("Promise")}} grâce à son constructeur. Et même si, idéalement, cela ne devrait pas être nécessaire, certaines API fonctionnent toujours avec des _callbacks_ passés en arguments. C'est notamment le cas de la méthode  {{domxref("WindowTimers.setTimeout", "setTimeout()")}} :
 
-<pre class="brush: js">setTimeout(() =&gt; saySomething("10 seconds passed"), 10 * 1000);
-</pre>
+```js
+setTimeout(() => saySomething("10 seconds passed"), 10 * 1000);
+```
 
-<p>Si on mélange des <em>callbacks</em> et des promesses, cela sera problématique. Si  <code>saySomething</code> échoue ou contient des erreurs, rien n'interceptera l'erreur.</p>
+Si on mélange des _callbacks_ et des promesses, cela sera problématique. Si  `saySomething` échoue ou contient des erreurs, rien n'interceptera l'erreur.
 
-<p>Pour ces fonctions, la meilleure pratique consiste à les <em>envelopper</em> dans des promesses au plus bas niveau possible et de ne plus les appeler directement :</p>
+Pour ces fonctions, la meilleure pratique consiste à les _envelopper_ dans des promesses au plus bas niveau possible et de ne plus les appeler directement :
 
-<pre class="brush: js">const wait = ms =&gt; new Promise(resolve =&gt; setTimeout(resolve, ms));
+```js
+const wait = ms => new Promise(resolve => setTimeout(resolve, ms));
 
-wait(10 * 1000).then(() =&gt; saySomething("10 seconds")).catch(failureCallback);
-</pre>
+wait(10 * 1000).then(() => saySomething("10 seconds")).catch(failureCallback);
+```
 
-<p>Le constructeur <code>Promise</code> prend en argument une fonction et nous permet de la convertir manuellement en une promesse. Ici, vu que <code>setTimeout</code> n'échoue pas vraiment, on laisse de côté la gestion de l'échec.</p>
+Le constructeur `Promise` prend en argument une fonction et nous permet de la convertir manuellement en une promesse. Ici, vu que `setTimeout` n'échoue pas vraiment, on laisse de côté la gestion de l'échec.
 
-<h2 id="Composition">Composition</h2>
+## Composition
 
-<p>{{jsxref("Promise.resolve()")}} et {{jsxref("Promise.reject()")}} sont des méthodes qui permettent de créer des promesses déjà tenues ou rompues.</p>
+{{jsxref("Promise.resolve()")}} et {{jsxref("Promise.reject()")}} sont des méthodes qui permettent de créer des promesses déjà tenues ou rompues.
 
-<p>{{jsxref("Promise.all()")}} et {{jsxref("Promise.race()")}} sont deux outils de composition qui permettent de mener des opérations asynchrones en parallèle.</p>
+{{jsxref("Promise.all()")}} et {{jsxref("Promise.race()")}} sont deux outils de composition qui permettent de mener des opérations asynchrones en parallèle.
 
-<p>On peut lancer des opérations en parallèles et attendre qu'elles soient toutes finies de cette façon :</p>
+On peut lancer des opérations en parallèles et attendre qu'elles soient toutes finies de cette façon :
 
-<pre class="brush: js">Promise.all([func1(), func2(), func3()])
-.then(([resultat1, resultat2, resultat3]) =&gt; { /* où on utilise resultat1/2/3 */ });</pre>
+```js
+Promise.all([func1(), func2(), func3()])
+.then(([resultat1, resultat2, resultat3]) => { /* où on utilise resultat1/2/3 */ });
+```
 
-<p>Il est possible de construire une composition séquentielle de la façon suivante :</p>
+Il est possible de construire une composition séquentielle de la façon suivante :
 
-<pre class="brush: js">[func1, func2].reduce((p, f) =&gt; p.then(f), Promise.resolve());
-</pre>
+```js
+[func1, func2].reduce((p, f) => p.then(f), Promise.resolve());
+```
 
-<p>Dans ce fragment de code, on réduit un tableau de fonctions asynchrones en une chaîne de promesse équivalente à : <code>Promise.resolve().then(func1).then(func2);</code></p>
+Dans ce fragment de code, on réduit un tableau de fonctions asynchrones en une chaîne de promesse équivalente à : `Promise.resolve().then(func1).then(func2);`
 
-<p>On peut également accomplir cela avec une fonction de composition réutilisable  :</p>
+On peut également accomplir cela avec une fonction de composition réutilisable  :
 
-<pre class="brush: js">const applyAsync = (acc, val) =&gt; acc.then(val);
-const composeAsync = (...funcs) =&gt; x =&gt; funcs.reduce(applyAsync, Promise.resolve(x));</pre>
+```js
+const applyAsync = (acc, val) => acc.then(val);
+const composeAsync = (...funcs) => x => funcs.reduce(applyAsync, Promise.resolve(x));
+```
 
-<p>La fonction <code>composeAsync</code> accepte autant de fonctions que nécessaire comme arguments et renvoie une nouvelle fonction qui prend une valeur initiale pour la passer à travers ces étapes de compositions. Cette façon de faire garantit que les fonctions, qu'elles soient synchrones ou asynchrones, sont exécutées dans le bon ordre :</p>
+La fonction `composeAsync` accepte autant de fonctions que nécessaire comme arguments et renvoie une nouvelle fonction qui prend une valeur initiale pour la passer à travers ces étapes de compositions. Cette façon de faire garantit que les fonctions, qu'elles soient synchrones ou asynchrones, sont exécutées dans le bon ordre :
 
-<pre class="brush: js">const transformData = composeAsync(func1, asyncFunc1, asyncFunc2, func2);
-transformData(data);</pre>
+```js
+const transformData = composeAsync(func1, asyncFunc1, asyncFunc2, func2);
+transformData(data);
+```
 
-<p>Avec ECMAScript 2017, on peut obtenir une composition séquentielle plus simplement avec les opérateurs <code>await</code>/<code>async</code> :</p>
+Avec ECMAScript 2017, on peut obtenir une composition séquentielle plus simplement avec les opérateurs `await`/`async` :
 
-<pre class="brush: js">let result;
+```js
+let result;
 for(const f of [func1, func2, func3]) {
   result = await f(result);
-} </pre>
+} 
+```
 
-<h2 id="Gestion_du_temps">Gestion du temps</h2>
+## Gestion du temps
 
-<p>Pour éviter de mauvaises surprises, les fonctions passées à <code>then()</code> ne seront jamais appelées de façon synchrone, y compris lorsqu'il s'agit d'une promesse déjà résolue :</p>
+Pour éviter de mauvaises surprises, les fonctions passées à `then()` ne seront jamais appelées de façon synchrone, y compris lorsqu'il s'agit d'une promesse déjà résolue :
 
-<pre class="brush: js">Promise.resolve().then(() =&gt; console.log(2));
+```js
+Promise.resolve().then(() => console.log(2));
 console.log(1); // 1, 2
-</pre>
+```
 
-<p>En fait, la fonction passée à <code>then</code><code>()</code> est placée dans une file de micro-tâches qui sont exécutées lorsque cette file est vidée à la fin de la boucle d'évènements JavaScript :</p>
+En fait, la fonction passée à ` then``() ` est placée dans une file de micro-tâches qui sont exécutées lorsque cette file est vidée à la fin de la boucle d'évènements JavaScript :
 
-<pre class="brush: js">var wait = ms =&gt; new Promise(resolve =&gt; setTimeout(resolve, ms));
+```js
+var wait = ms => new Promise(resolve => setTimeout(resolve, ms));
 
-wait().then(() =&gt; console.log(4));
-Promise.resolve().then(() =&gt; console.log(2)).then(() =&gt; console.log(3));
+wait().then(() => console.log(4));
+Promise.resolve().then(() => console.log(2)).then(() => console.log(3));
 console.log(1); // 1, 2, 3, 4
-</pre>
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("Promise.then()")}}</li>
- <li><a href="/fr/docs/Web/JavaScript/Reference/Instructions/async_function"><code>async</code>/<code>await</code></a></li>
- <li><a href="http://promisesaplus.com/">La spécification Promises/A+</a></li>
- <li><a href="http://pouchdb.com/2015/05/18/we-have-a-problem-with-promises.html">Nolan Lawson : We have a problem with promises — Common mistakes with promises (article en anglais)</a></li>
-</ul>
+- {{jsxref("Promise.then()")}}
+- [`async`/`await`](/fr/docs/Web/JavaScript/Reference/Instructions/async_function)
+- [La spécification Promises/A+](http://promisesaplus.com/)
+- [Nolan Lawson : We have a problem with promises — Common mistakes with promises (article en anglais)](http://pouchdb.com/2015/05/18/we-have-a-problem-with-promises.html)
 
-<p>{{PreviousNext("Web/JavaScript/Guide/Le_modèle_objet_JavaScript_en_détails", "Web/JavaScript/Guide/iterateurs_et_generateurs")}}</p>
+{{PreviousNext("Web/JavaScript/Guide/Le_modèle_objet_JavaScript_en_détails", "Web/JavaScript/Guide/iterateurs_et_generateurs")}}
diff --git a/files/fr/web/javascript/guide/working_with_objects/index.md b/files/fr/web/javascript/guide/working_with_objects/index.md
index f02ca6ff02..214902c6dd 100644
--- a/files/fr/web/javascript/guide/working_with_objects/index.md
+++ b/files/fr/web/javascript/guide/working_with_objects/index.md
@@ -12,56 +12,60 @@ tags:
 translation_of: Web/JavaScript/Guide/Working_with_Objects
 original_slug: Web/JavaScript/Guide/Utiliser_les_objets
 ---
-<div>{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/Keyed_collections", "Web/JavaScript/Guide/Details_of_the_Object_Model")}}</div>
+{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/Keyed_collections", "Web/JavaScript/Guide/Details_of_the_Object_Model")}}
 
-<p>JavaScript est conçu autour d'un paradigme simple, basé sur les objets. Un objet est un ensemble de propriétés et une propriété est une association entre un nom (aussi appelé <em>clé</em>) et une valeur. La valeur d'une propriété peut être une fonction, auquel cas la propriété peut être appelée « méthode ». En plus des objets natifs fournis par l'environnement, il est possible de construire ses propres objets. Ce chapitre aborde la manipulation d'objets, l'utilisation des propriétés, fonctions et méthodes, il explique également comment créer ses objets.</p>
+JavaScript est conçu autour d'un paradigme simple, basé sur les objets. Un objet est un ensemble de propriétés et une propriété est une association entre un nom (aussi appelé _clé_) et une valeur. La valeur d'une propriété peut être une fonction, auquel cas la propriété peut être appelée « méthode ». En plus des objets natifs fournis par l'environnement, il est possible de construire ses propres objets. Ce chapitre aborde la manipulation d'objets, l'utilisation des propriétés, fonctions et méthodes, il explique également comment créer ses objets.
 
-<h2 id="objects_overview">Un aperçu des objets</h2>
+## Un aperçu des objets
 
-<p>À l'instar de nombreux autres langages de programmation, on peut comparer les objets JavaScript aux objets du monde réel.</p>
+À l'instar de nombreux autres langages de programmation, on peut comparer les objets JavaScript aux objets du monde réel.
 
-<p>En JavaScript, un objet est une entité à part entière qui possède des propriétés et un type. Si on effectue cette comparaison avec une tasse par exemple, on pourra dire qu'une tasse est un objet avec des propriétés. Ces propriétés pourront être la couleur, la forme, le poids, le matériau qui la constitue, etc. De la même façon, un objet JavaScript possède des propriétés, chacune définissant une caractéristique.</p>
+En JavaScript, un objet est une entité à part entière qui possède des propriétés et un type. Si on effectue cette comparaison avec une tasse par exemple, on pourra dire qu'une tasse est un objet avec des propriétés. Ces propriétés pourront être la couleur, la forme, le poids, le matériau qui la constitue, etc. De la même façon, un objet JavaScript possède des propriétés, chacune définissant une caractéristique.
 
-<h2 id="objects_and_properties">Les objets et les propriétés</h2>
+## Les objets et les propriétés
 
-<p>Un objet JavaScript possède donc plusieurs propriétés qui lui sont associées. Une propriété peut être vue comme une variable attachée à l'objet. Les propriétés d'un objet sont des variables tout ce qu'il y a de plus classiques, exception faite qu'elles sont attachées à des objets. Les propriétés d'un objet représentent ses caractéristiques et on peut y accéder avec une notation utilisant le point « . », de la façon suivante :</p>
+Un objet JavaScript possède donc plusieurs propriétés qui lui sont associées. Une propriété peut être vue comme une variable attachée à l'objet. Les propriétés d'un objet sont des variables tout ce qu'il y a de plus classiques, exception faite qu'elles sont attachées à des objets. Les propriétés d'un objet représentent ses caractéristiques et on peut y accéder avec une notation utilisant le point « . », de la façon suivante :
 
-<pre class="brush: js">nomObjet.nomPropriete</pre>
+```js
+nomObjet.nomPropriete
+```
 
-<p>Comme pour les variables JavaScript en général, le nom de l'objet (qui peut être une variable) et le nom des propriétés sont sensibles à la casse (une lettre minuscule ne sera pas équivalente à une lettre majuscule). On peut définir une propriété en lui affectant une valeur. Ainsi, si on crée un objet <code>maVoiture</code> et qu'on lui donne les propriétés <code>fabricant</code>, <code>modèle</code>, et <code>année</code> :</p>
+Comme pour les variables JavaScript en général, le nom de l'objet (qui peut être une variable) et le nom des propriétés sont sensibles à la casse (une lettre minuscule ne sera pas équivalente à une lettre majuscule). On peut définir une propriété en lui affectant une valeur. Ainsi, si on crée un objet `maVoiture` et qu'on lui donne les propriétés `fabricant`, `modèle`, et `année` :
 
-<pre class="brush: js">
+```js
 let maVoiture = new Object();
 maVoiture.fabricant = "Ford";
 maVoiture.modele = "Mustang";
 maVoiture.annee = 1969;
-</pre>
+```
 
-<p>L'exemple précédent peut également s'écrire avec <strong><a href="#object_initializers">la syntaxe littérale pour initialiser les objets</a></strong> : on fournit une liste, délimitée par des virgules, qui contient des paires de noms et de valeurs décrivant les propriétés et où le tout est encadré d'accolades (<code>{}</code>) :</p>
+L'exemple précédent peut également s'écrire avec **[la syntaxe littérale pour initialiser les objets](#object_initializers)** : on fournit une liste, délimitée par des virgules, qui contient des paires de noms et de valeurs décrivant les propriétés et où le tout est encadré d'accolades (`{}`) :
 
-<pre class="brush: js">
+```js
 let maVoiture = {
   make: 'Ford',
   model: 'Mustang',
   year: 1969
 };
-</pre>
+```
 
-<p>Les propriétés d'un objet qui n'ont pas été affectées auront la valeur <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/undefined"><code>undefined</code></a> (et non <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/null"><code>null</code></a>).</p>
+Les propriétés d'un objet qui n'ont pas été affectées auront la valeur [`undefined`](/fr/docs/Web/JavaScript/Reference/Global_Objects/undefined) (et non [`null`](/fr/docs/Web/JavaScript/Reference/Global_Objects/null)).
 
-<pre class="brush: js">maVoiture.color; // undefined</pre>
+```js
+maVoiture.color; // undefined
+```
 
-<p>On peut aussi définir ou accéder à des propriétés JavaScript en utilisant une notation avec les crochets (voir la page sur <a href="/fr/docs/Web/JavaScript/Reference/Operators/Property_Accessors">les accesseurs de propriétés</a> pour plus de détails). Les objets sont parfois appelés «&nbsp;tableaux associatifs&nbsp;». Cela peut se comprendre, car chaque propriété est associée avec une chaîne de caractères qui permet d'y accéder. Ainsi, par exemple, on peut accéder aux propriétés de l'objet <code>maVoiture</code> de la façon suivante :</p>
+On peut aussi définir ou accéder à des propriétés JavaScript en utilisant une notation avec les crochets (voir la page sur [les accesseurs de propriétés](/fr/docs/Web/JavaScript/Reference/Operators/Property_Accessors) pour plus de détails). Les objets sont parfois appelés « tableaux associatifs ». Cela peut se comprendre, car chaque propriété est associée avec une chaîne de caractères qui permet d'y accéder. Ainsi, par exemple, on peut accéder aux propriétés de l'objet `maVoiture` de la façon suivante :
 
-<pre class="brush: js">
+```js
 maVoiture["fabricant"] = "Ford";
 maVoiture["modèle"] = "Mustang";
 maVoiture["année"] = 1969;
-</pre>
+```
 
-<p>Le nom d'une propriété d'un objet peut être n'importe quelle chaîne JavaScript valide (ou n'importe quelle valeur qui puisse être convertie en une chaîne de caractères), y compris la chaîne vide. Cependant, n'importe quel nom de propriété qui n'est pas un identifiant valide (par exemple si le nom d'une propriété contient un tiret, un espace ou débute par un chiffre) devra être utilisé avec la notation à crochets. Cette notation s'avère également utile quand les noms des propriétés sont déterminés de façon dynamique (c'est-à-dire qu'on ne sait pas le nom de la propriété avant l'exécution). Par exemple :</p>
+Le nom d'une propriété d'un objet peut être n'importe quelle chaîne JavaScript valide (ou n'importe quelle valeur qui puisse être convertie en une chaîne de caractères), y compris la chaîne vide. Cependant, n'importe quel nom de propriété qui n'est pas un identifiant valide (par exemple si le nom d'une propriété contient un tiret, un espace ou débute par un chiffre) devra être utilisé avec la notation à crochets. Cette notation s'avère également utile quand les noms des propriétés sont déterminés de façon dynamique (c'est-à-dire qu'on ne sait pas le nom de la propriété avant l'exécution). Par exemple :
 
-<pre class="brush: js">
+```js
 // on crée quatre variables avec une même instruction
 let monObj = new Object();
 let str = "maChaîne";
@@ -76,23 +80,23 @@ monObj[obj]              = "Objet";
 monObj[""]               = "Une chaîne vide";
 
 console.log(monObj);
-</pre>
+```
 
-<p>On notera que les valeurs utilisées entre les crochets sont automatiquement converties en chaînes de caractères grâce à la méthode <code><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Object/toString">toString()</a></code> sauf si ces valeurs sont des symboles (cf. <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Symbol"><code>Symbol</code></a>). En effet, les noms des propriétés pour les objets JavaScript peuvent être des chaînes de caractères ou des symboles. Ainsi, dans l'exemple précédent, lorsqu'on ajoute la clé <code>obj</code> sur <code>monObj</code>, le moteur JavaScript appelle la méthode <code>obj.toString()</code> et utilise la chaîne de caractères renvoyée par cette méthode comme nom pour la propriété.</p>
+On notera que les valeurs utilisées entre les crochets sont automatiquement converties en chaînes de caractères grâce à la méthode [`toString()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Object/toString) sauf si ces valeurs sont des symboles (cf. [`Symbol`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Symbol)). En effet, les noms des propriétés pour les objets JavaScript peuvent être des chaînes de caractères ou des symboles. Ainsi, dans l'exemple précédent, lorsqu'on ajoute la clé `obj` sur `monObj`, le moteur JavaScript appelle la méthode `obj.toString()` et utilise la chaîne de caractères renvoyée par cette méthode comme nom pour la propriété.
 
-<p>On peut également accéder aux propriétés d'un objet en utilisant une valeur qui est une chaîne de caractères enregistrée dans une variable :</p>
+On peut également accéder aux propriétés d'un objet en utilisant une valeur qui est une chaîne de caractères enregistrée dans une variable :
 
-<pre class="brush: js">
+```js
 let nomPropriété = "fabricant";
 maVoiture[nomPropriété] = "Ford";
 
 nomPropriété = "modèle";
 maVoiture[nomPropriété] = "Mustang";
-</pre>
+```
 
-<p>La notation avec les crochets peut être utilisée dans une boucle <code><a href="/fr/docs/Web/JavaScript/Reference/Statements/for...in">for...in</a></code> afin de parcourir les propriétés énumérables d'un objet. Pour illustrer comment cela fonctionne, on définit la fonction suivante qui affiche les propriétés d'un objet qu'on lui a passé en argument avec le nom associé :</p>
+La notation avec les crochets peut être utilisée dans une boucle [`for...in`](/fr/docs/Web/JavaScript/Reference/Statements/for...in) afin de parcourir les propriétés énumérables d'un objet. Pour illustrer comment cela fonctionne, on définit la fonction suivante qui affiche les propriétés d'un objet qu'on lui a passé en argument avec le nom associé :
 
-<pre class="brush: js">
+```js
 function afficherProps(obj, nomObjet) {
   let resultat = "";
   for (let i in obj) {
@@ -102,29 +106,27 @@ function afficherProps(obj, nomObjet) {
   }
   return resultat;
 }
-</pre>
+```
 
-<p>Si on appelle la fonction avec <code>afficherProps(maVoiture, "maVoiture")</code>, cela affichera le contenu suivant dans la console :</p>
+Si on appelle la fonction avec `afficherProps(maVoiture, "maVoiture")`, cela affichera le contenu suivant dans la console :
 
-<pre class="brush: js">
+```js
 maVoiture.fabricant = Ford
 maVoiture.modele = Mustang
 maVoiture.annee = 1969
-</pre>
+```
 
-<h2 id="enumerate_the_properties_of_an_object">Lister les propriétés d'un objet</h2>
+## Lister les propriétés d'un objet
 
-<p>À partir d'ECMAScript 5, il existe trois méthodes natives pour lister/parcourir les propriétés d'un objet :</p>
+À partir d'ECMAScript 5, il existe trois méthodes natives pour lister/parcourir les propriétés d'un objet :
 
-<ul>
- <li>Les boucles <code><a href="/fr/docs/Web/JavaScript/Reference/Statements/for...in">for...in</a></code> qui permettent de parcourir l'ensemble des propriétés énumérables d'un objet et de sa chaîne de prototypes.</li>
- <li><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Object/keys"><code>Object.keys(o)</code></a> qui permet de renvoyer un tableau contenant les noms (clés ou <em>keys</em>) des propriétés propres (celles qui ne sont pas héritées via la chaîne de prototypes) d'un objet <code>o</code> pour les propriétés énumérables.</li>
- <li><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyNames"><code>Object.getOwnPropertyNames(o)</code></a> qui permet de renvoyer un tableau contenant les noms des propriétés propres (énumérables ou non) d'un objet <code>o</code>.</li>
-</ul>
+- Les boucles [`for...in`](/fr/docs/Web/JavaScript/Reference/Statements/for...in) qui permettent de parcourir l'ensemble des propriétés énumérables d'un objet et de sa chaîne de prototypes.
+- [`Object.keys(o)`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Object/keys) qui permet de renvoyer un tableau contenant les noms (clés ou _keys_) des propriétés propres (celles qui ne sont pas héritées via la chaîne de prototypes) d'un objet `o` pour les propriétés énumérables.
+- [`Object.getOwnPropertyNames(o)`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyNames) qui permet de renvoyer un tableau contenant les noms des propriétés propres (énumérables ou non) d'un objet `o`.
 
-<p>Avant ECMAScript 5, il n'existait aucune méthode native pour lister l'ensemble des propriétés d'un objet. Cependant, on pouvait utiliser le code suivant pour y parvenir :</p>
+Avant ECMAScript 5, il n'existait aucune méthode native pour lister l'ensemble des propriétés d'un objet. Cependant, on pouvait utiliser le code suivant pour y parvenir :
 
-<pre class="brush: js">
+```js
 function listerToutesLesProprietes(o){
   let objectToInspect;
   let resultat = [];
@@ -136,41 +138,42 @@ function listerToutesLesProprietes(o){
   }
   return resultat;
 }
-</pre>
+```
 
-<p>Cela peut être utile pour révéler les propriétés « cachées » où leur nom est réutilisé dans la chaîne de prototypes. Pour lister les propriétés accessibles, il suffit de retirer les duplicatas du tableau.</p>
+Cela peut être utile pour révéler les propriétés « cachées » où leur nom est réutilisé dans la chaîne de prototypes. Pour lister les propriétés accessibles, il suffit de retirer les duplicatas du tableau.
 
-<h2 id="creating_new_objects">Créer de nouveaux objets</h2>
+## Créer de nouveaux objets
 
-<p>Un environnement JavaScript possède certains objets natifs prédéfinis. En plus de ces objets, il est possible de créer ses propres objets. Pour cela, on peut utiliser un <a href="/fr/docs/Web/JavaScript/Reference/Operators/Object_initializer">initialisateur d'objet</a>. On peut aussi créer un constructeur puis instancier un objet avec cette fonction en utilisant l'opérateur <code>new</code>.</p>
+Un environnement JavaScript possède certains objets natifs prédéfinis. En plus de ces objets, il est possible de créer ses propres objets. Pour cela, on peut utiliser un [initialisateur d'objet](/fr/docs/Web/JavaScript/Reference/Operators/Object_initializer). On peut aussi créer un constructeur puis instancier un objet avec cette fonction en utilisant l'opérateur `new`.
 
-<h3 id="using_object_initializers">Utiliser les initialisateurs d'objets</h3>
+### Utiliser les initialisateurs d'objets
 
-<p>On peut créer des objets avec une fonction qui est un constructeur, mais on peut aussi créer des objets avec des <a href="/fr/docs/Web/JavaScript/Reference/Operators/Object_initializer">initialisateurs d'objets</a>. On appelle parfois cette syntaxe la notation <em>littérale</em>.</p>
+On peut créer des objets avec une fonction qui est un constructeur, mais on peut aussi créer des objets avec des [initialisateurs d'objets](/fr/docs/Web/JavaScript/Reference/Operators/Object_initializer). On appelle parfois cette syntaxe la notation _littérale_.
 
-<p>La syntaxe utilisée avec les initialisateurs d'objets est la suivante :</p>
+La syntaxe utilisée avec les initialisateurs d'objets est la suivante :
 
-<pre class="brush: js">
+```js
 let obj = { 
   propriete_1:   valeur_1,   // propriete_# peut être un identifiant
             2:   valeur_2,   // ou un nombre
             // ...,
   "propriete n": valeur_n
   }; // ou une chaîne
-</pre>
+```
 
-<p>où on a <code>obj</code> le nom de l'objet qu'on souhaite créer et chaque <code>propriete_<em>i</em></code> un identifiant (que ce soit un nom, un nombre ou une chaîne de caractères) et chaque <code>valeur_<em>i</em></code> une expression dont la valeur sera affectée à la propriété <code>propriete_<em>i</em></code>. S'il n'est pas nécessaire d'utiliser l'objet <code>obj</code> par la suite, il n'est pas nécessaire de réaliser l'affectation à une variable (attention alors à l'encadrer dans des parenthèses pour que le littéral objet soit bien interprété comme une instruction et non pas comme un bloc.)</p>
+où on a `obj` le nom de l'objet qu'on souhaite créer et chaque `propriete_i` un identifiant (que ce soit un nom, un nombre ou une chaîne de caractères) et chaque `valeur_i` une expression dont la valeur sera affectée à la propriété `propriete_i`. S'il n'est pas nécessaire d'utiliser l'objet `obj` par la suite, il n'est pas nécessaire de réaliser l'affectation à une variable (attention alors à l'encadrer dans des parenthèses pour que le littéral objet soit bien interprété comme une instruction et non pas comme un bloc.)
 
-<p>Les initialisateurs d'objets sont des expressions et chaque initialisateur entraîne la création d'un nouvel objet dans l'instruction pour laquelle il est exécuté. Des initialisateurs d'objets identiques créeront des objets distincts qui ne seront pas équivalents. Les objets sont créés de la même façon qu'avec <code>new Object()</code>, les objets créés à partir d'une expression littérale seront des instances d'<code>Object</code>.</p>
+Les initialisateurs d'objets sont des expressions et chaque initialisateur entraîne la création d'un nouvel objet dans l'instruction pour laquelle il est exécuté. Des initialisateurs d'objets identiques créeront des objets distincts qui ne seront pas équivalents. Les objets sont créés de la même façon qu'avec `new Object()`, les objets créés à partir d'une expression littérale seront des instances d'`Object`.
 
-<p>L'instruction suivante crée un objet et l'affecte à une variable <code>x</code> si et seulement si l'expression <code>cond</code> est vraie :</p>
+L'instruction suivante crée un objet et l'affecte à une variable `x` si et seulement si l'expression `cond` est vraie :
 
-<pre class="brush: js">if (cond) let x = {emplacement: "le monde"};
-</pre>
+```js
+if (cond) let x = {emplacement: "le monde"};
+```
 
-<p>Dans l'exemple suivant, on crée un objet <code>maHonda</code> avec trois propriétés. La propriété <code>moteur</code> est également un objet avec ses propres propriétés.</p>
+Dans l'exemple suivant, on crée un objet `maHonda` avec trois propriétés. La propriété `moteur` est également un objet avec ses propres propriétés.
 
-<pre class="brush: js">
+```js
 let maHonda = {
   couleur: "rouge",
   roue: 4,
@@ -179,99 +182,98 @@ let maHonda = {
     taille: 2.2
   }
 };
-</pre>
+```
 
-<p>De la même façon, on pourra utiliser des initialisateurs pour créer des tableaux. Pour plus d'informations à ce sujet, voir <a href="/fr/docs/Web/JavaScript/Guide/Grammar_and_types#les_litt.c3.a9raux_de_tableaux">les littéraux de tableaux</a>.</p>
+De la même façon, on pourra utiliser des initialisateurs pour créer des tableaux. Pour plus d'informations à ce sujet, voir [les littéraux de tableaux](/fr/docs/Web/JavaScript/Guide/Grammar_and_types#les_litt.c3.a9raux_de_tableaux).
 
-<h3 id="using_a_constructor_function">Utiliser les constructeurs</h3>
+### Utiliser les constructeurs
 
-<p>On peut aussi créer des objets d'une autre façon, en suivant deux étapes :</p>
+On peut aussi créer des objets d'une autre façon, en suivant deux étapes :
 
-<ol>
- <li>On définit une fonction qui sera un constructeur définissant le type de l'objet. La convention, pour nommer les constructeurs, est d'utiliser une majuscule comme première lettre pour l'identifiant de la fonction.</li>
- <li>On crée une instance de l'objet avec <code>new</code>.</li>
-</ol>
+1.  On définit une fonction qui sera un constructeur définissant le type de l'objet. La convention, pour nommer les constructeurs, est d'utiliser une majuscule comme première lettre pour l'identifiant de la fonction.
+2.  On crée une instance de l'objet avec `new`.
 
-<p>Pour définir le type d'un objet, on crée une fonction qui définit le nom de ce type et les propriétés et méthodes des instances. Ainsi, si on souhaite créer un type d'objet pour représenter des voitures, on pourra nommer ce type <code>voiture</code>, et il pourra avoir des propriétés pour le fabricant, le modèle et l'année. Pour ce faire, on pourra écrire la fonction suivante :</p>
+Pour définir le type d'un objet, on crée une fonction qui définit le nom de ce type et les propriétés et méthodes des instances. Ainsi, si on souhaite créer un type d'objet pour représenter des voitures, on pourra nommer ce type `voiture`, et il pourra avoir des propriétés pour le fabricant, le modèle et l'année. Pour ce faire, on pourra écrire la fonction suivante :
 
-<pre class="brush: js">
+```js
 function Voiture(fabricant, modele, annee) {
   this.fabricant = fabricant;
   this.modele = modele;
   this.annee = annee;
 }
-</pre>
+```
 
-<p>On voit ici qu'on utilise le mot-clé <code>this</code> pour affecter des valeurs aux propriétés d'un objet en fonction des valeurs passées en arguments de la fonction.</p>
+On voit ici qu'on utilise le mot-clé `this` pour affecter des valeurs aux propriétés d'un objet en fonction des valeurs passées en arguments de la fonction.
 
-<p>On peut désormais créer un objet <code>maVoiture</code> de la façon suivante :</p>
+On peut désormais créer un objet `maVoiture` de la façon suivante :
 
-<pre class="brush: js">
+```js
 let maVoiture = new Voiture("Eagle", "Talon TSi", 1993);
-</pre>
+```
 
-<p>Cette instruction crée un objet <code>maVoiture</code> et lui affecte les valeurs fournies pour ses propriétés. On obtient donc <code>maVoiture.fabricant</code> qui sera la chaîne de caractères "Eagle", <code>maVoiture.annee</code> qui sera l'entier 1993, et ainsi de suite.</p>
+Cette instruction crée un objet `maVoiture` et lui affecte les valeurs fournies pour ses propriétés. On obtient donc `maVoiture.fabricant` qui sera la chaîne de caractères "Eagle", `maVoiture.annee` qui sera l'entier 1993, et ainsi de suite.
 
-<p>Grâce à ce constructeur, on peut ensuite créer autant d'objets <code>Voiture</code> que nécessaire. Par exemple :</p>
+Grâce à ce constructeur, on peut ensuite créer autant d'objets `Voiture` que nécessaire. Par exemple :
 
-<pre class="brush: js">
+```js
 let voitureMorgan = new Voiture("Audi", "A3", 2005);
 let voitureMax = new Voiture("Mazda", "Miata", 1990);
-</pre>
+```
 
-<p>Un objet peut avoir une propriété qui est elle-même un objet. Ainsi, si on définit un type d'objet <code>personne</code> de cette façon :</p>
+Un objet peut avoir une propriété qui est elle-même un objet. Ainsi, si on définit un type d'objet `personne` de cette façon :
 
-<pre class="brush: js">
+```js
 function Personne(nom, age, sexe) {
   this.nom = nom;
   this.age = age;
   this.sexe = sexe;
 }
-</pre>
+```
 
-<p>et qu'on instancie deux nouveaux objets <code>personne</code> avec</p>
+et qu'on instancie deux nouveaux objets `personne` avec
 
-<pre class="brush: js">
+```js
 let max = new Personne("Max Gun", 33, "M");
 let morgan = new Personne("Morgan Sousbrouille", 39, "M");
-</pre>
+```
 
-<p>On pourra réécrire la fonction de définition pour le type <code>Voiture</code> pour inclure une propriété <code>proprietaire</code> qui est représentée par un objet <code>personne</code> :</p>
+On pourra réécrire la fonction de définition pour le type `Voiture` pour inclure une propriété `proprietaire` qui est représentée par un objet `personne` :
 
-<pre class="brush: js">
+```js
 function Voiture(fabricant, modele, annee, proprietaire) {
   this.fabricant = fabricant;
   this.modele = modele;
   this.annee = annee;
   this.proprietaire = proprietaire;
 }
-</pre>
+```
 
-<p>Pour instancier des nouveaux objets, on pourra donc utiliser :</p>
+Pour instancier des nouveaux objets, on pourra donc utiliser :
 
-<pre class="brush: js">
+```js
 let voiture1 = new Voiture("Mazda", "Miata", 1993, max);
 let voiture2 = new Voiture("Audi", "A3", 2005, morgan);
-</pre>
+```
 
-<p>On notera que le dernier argument n'est pas une chaîne de caractères ou une valeur numérique mais bien un objet. Les objets <code>max</code> et <code>morgan</code> sont passés en arguments pour représenter les propriétaires. Ainsi, si on veut obtenir le nom du propriétaire pour <code>voiture2</code>, on peut accéder à la propriété de la façon suivante :</p>
+On notera que le dernier argument n'est pas une chaîne de caractères ou une valeur numérique mais bien un objet. Les objets `max` et `morgan` sont passés en arguments pour représenter les propriétaires. Ainsi, si on veut obtenir le nom du propriétaire pour `voiture2`, on peut accéder à la propriété de la façon suivante :
 
-<pre class="brush: js">
+```js
 voiture2.proprietaire.nom
-</pre>
+```
 
-<p>Il est toujours possible d'ajouter une propriété à un objet défini précédemment. Par exemple, on peut ajouter une propriété à l'objet <code>voiture1</code> avec l'instruction :</p>
+Il est toujours possible d'ajouter une propriété à un objet défini précédemment. Par exemple, on peut ajouter une propriété à l'objet `voiture1` avec l'instruction :
 
-<pre class="brush: js">voiture1.couleur = "noir";
-</pre>
+```js
+voiture1.couleur = "noir";
+```
 
-<p>Ici, on ajoute une propriété <code>couleur</code> à <code>voiture1</code>, et on lui affecte une valeur "noir". Cependant, cela n'affecte pas les autres objets <code>voiture</code>. Pour ajouter une nouvelle propriété à tous les objets, il faudra ajouter la propriété au constructeur <code>voiture</code>.</p>
+Ici, on ajoute une propriété `couleur` à `voiture1`, et on lui affecte une valeur "noir". Cependant, cela n'affecte pas les autres objets `voiture`. Pour ajouter une nouvelle propriété à tous les objets, il faudra ajouter la propriété au constructeur `voiture`.
 
-<h3 id="using_the_object.create_method">Utiliser la méthode <code>Object.create()</code></h3>
+### Utiliser la méthode `Object.create()`
 
-<p>Les objets peuvent également être créés en utilisant la méthode <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Object/create"><code>Object.create()</code></a>. Cette méthode peut s'avérer très utile, car elle permet de choisir le prototype pour l'objet qu'on souhaite créer, sans avoir à définir un constructeur.</p>
+Les objets peuvent également être créés en utilisant la méthode [`Object.create()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Object/create). Cette méthode peut s'avérer très utile, car elle permet de choisir le prototype pour l'objet qu'on souhaite créer, sans avoir à définir un constructeur.
 
-<pre class="brush: js">
+```js
 // Propriétés pour animal et encapsulation des méthodes
 let Animal = {
   type: "Invertébrés",        // Valeur par défaut  value of properties
@@ -288,36 +290,36 @@ animal1.afficherType(); // affichera Invertébrés
 let poisson = Object.create(Animal);
 poisson.type = "Poisson";
 poisson.afficherType(); // affichera Poisson
-</pre>
+```
 
-<h2 id="inheritance">L'héritage</h2>
+## L'héritage
 
-<p>Tous les objets JavaScript héritent d'un autre objet. L'objet dont on hérite est appelé <em>prototype</em> et les propriétés héritées peuvent être accédées via l'objet <code>prototype</code> du constructeur. Pour plus d'informations sur le fonctionnement de l'héritage, voir la page sur <a href="/fr/docs/Web/JavaScript/Inheritance_and_the_prototype_chain">l'héritage et la chaîne de prototypes</a>.</p>
+Tous les objets JavaScript héritent d'un autre objet. L'objet dont on hérite est appelé _prototype_ et les propriétés héritées peuvent être accédées via l'objet `prototype` du constructeur. Pour plus d'informations sur le fonctionnement de l'héritage, voir la page sur [l'héritage et la chaîne de prototypes](/fr/docs/Web/JavaScript/Inheritance_and_the_prototype_chain).
 
-<h2 id="indexing_object_properties">Indexer les propriétés d'un objet</h2>
+## Indexer les propriétés d'un objet
 
-<p>Il est possible d'accéder à une propriété via son nom et via son indice (ordinal). Si on définit une propriété grâce à un nom, on accédera toujours à la valeur via le nom. De même, si on définit une propriété grâce à un indice, on y accèdera toujours via son indice.</p>
+Il est possible d'accéder à une propriété via son nom et via son indice (ordinal). Si on définit une propriété grâce à un nom, on accédera toujours à la valeur via le nom. De même, si on définit une propriété grâce à un indice, on y accèdera toujours via son indice.
 
-<p>Cette restriction s'applique lorsqu'on crée un objet et ses propriétés via un constructeur et lorsqu'on déclare les propriétés explicitement (par exemple avec <code>maVoiture.couleur = "rouge"</code>). Si on définit une propriété d'un objet avec <code>maVoiture[5] = "25 kmh"</code>, on pourra faire référence à cette propriété grâce à <code>maVoiture[5]</code>.</p>
+Cette restriction s'applique lorsqu'on crée un objet et ses propriétés via un constructeur et lorsqu'on déclare les propriétés explicitement (par exemple avec `maVoiture.couleur = "rouge"`). Si on définit une propriété d'un objet avec `maVoiture[5] = "25 kmh"`, on pourra faire référence à cette propriété grâce à `maVoiture[5]`.
 
-<p>Il existe une exception à cette règle lorsqu'on manipule des objets "semblables à des tableaux" provenant d'API Web telles que l'objet <code>forms</code>. Pour ces objets semblables à des tableaux, on peut accéder à une propriété de l'objet grâce à son nom (si l'attribut <a href="/fr/docs/Web/HTML/Global_attributes#name"><code>name</code></a> est utilisé sur l'élément HTML) ou grâce à son index selon l'ordre dans le document. Ainsi, si on souhaite cibler un élément <code>&lt;form&gt;</code> du document possédant un attribut <code>name</code> qui vaut <code>monForm</code> et que cet élément est le deuxième élément du document, on pourra y accéder avec <code>document.forms[1]</code>, <code>document.forms["monForm"]</code> ou encore avec <code>document.forms.monForm</code>.</p>
+Il existe une exception à cette règle lorsqu'on manipule des objets "semblables à des tableaux" provenant d'API Web telles que l'objet `forms`. Pour ces objets semblables à des tableaux, on peut accéder à une propriété de l'objet grâce à son nom (si l'attribut [`name`](/fr/docs/Web/HTML/Global_attributes#name) est utilisé sur l'élément HTML) ou grâce à son index selon l'ordre dans le document. Ainsi, si on souhaite cibler un élément `<form>` du document possédant un attribut `name` qui vaut `monForm` et que cet élément est le deuxième élément du document, on pourra y accéder avec `document.forms[1]`, `document.forms["monForm"]` ou encore avec `document.forms.monForm`.
 
-<h2 id="defining_properties_for_an_object_type">Définir des propriétés pour un type d'objet</h2>
+## Définir des propriétés pour un type d'objet
 
-<p>On peut ajouter une propriété à un type précédemment défini en utilisant la propriété <code>prototype</code>. Cela permettra de définir une propriété qui sera partagée par tous les objets d'un même type plutôt qu'elle ne soit définie que pour un seul objet. Le code suivant permet d'ajouter une propriété <code>couleur</code> à tous les objets de type <code>voiture</code>. On affecte ensuite une valeur à cette propriété pour l'objet <code>voiture1</code>.</p>
+On peut ajouter une propriété à un type précédemment défini en utilisant la propriété `prototype`. Cela permettra de définir une propriété qui sera partagée par tous les objets d'un même type plutôt qu'elle ne soit définie que pour un seul objet. Le code suivant permet d'ajouter une propriété `couleur` à tous les objets de type `voiture`. On affecte ensuite une valeur à cette propriété pour l'objet `voiture1`.
 
-<pre class="brush: js">
+```js
 Voiture.prototype.couleur = null;
 voiture1.couleur = "noir";
-</pre>
+```
 
-<p>Pour plus d'informations, voir l'article sur <a href="/fr/docs/conflicting/Web/JavaScript/Reference/Global_Objects/Function">la propriété <code>prototype</code></a> de l'objet <code>Function</code> de la <a href="/fr/docs/Web/JavaScript/Reference">référence JavaScript</a>.</p>
+Pour plus d'informations, voir l'article sur [la propriété `prototype`](/fr/docs/conflicting/Web/JavaScript/Reference/Global_Objects/Function) de l'objet `Function` de la [référence JavaScript](/fr/docs/Web/JavaScript/Reference).
 
-<h2 id="defining_methods">Définir des méthodes</h2>
+## Définir des méthodes
 
-<p>Une <em>méthode</em> est une fonction associée à un objet. Autrement dit, une méthode est une propriété d'un objet qui est une fonction. Les méthodes sont définies comme des fonctions normales et sont affectées à des propriétés d'un objet. Voir la page sur <a href="/fr/docs/Web/JavaScript/Reference/Functions/Method_definitions">les définitions de méthodes</a> pour plus d'informations. Par exemple :</p>
+Une _méthode_ est une fonction associée à un objet. Autrement dit, une méthode est une propriété d'un objet qui est une fonction. Les méthodes sont définies comme des fonctions normales et sont affectées à des propriétés d'un objet. Voir la page sur [les définitions de méthodes](/fr/docs/Web/JavaScript/Reference/Functions/Method_definitions) pour plus d'informations. Par exemple :
 
-<pre class="brush: js">
+```js
 nomObjet.nomMethode = nomFonction;
 
 let monObj = {
@@ -331,34 +333,34 @@ let monObj = {
     // …faire autre chose
   }
 };
-</pre>
+```
 
-<p>avec <code>nomObjet</code> qui est un objet existant, <code>nomMethode</code> est le nom de la propriété à laquelle on souhaite affecter la méthode et <code>nomFonction</code> le nom de la fonction.</p>
+avec `nomObjet` qui est un objet existant, `nomMethode` est le nom de la propriété à laquelle on souhaite affecter la méthode et `nomFonction` le nom de la fonction.
 
-<p>On peut ensuite appeler la méthode sur l'objet :</p>
+On peut ensuite appeler la méthode sur l'objet :
 
-<pre class="brush: js">
+```js
 object.nomMethode(parametres);
-</pre>
+```
 
-<p>On peut définir des méthodes pour un type d'objet en incluant la définition de la méthode dans le constructeur. Par exemple, on peut définir une fonction qui mettrait en forme et qui afficherait les propriétés d'un objet <code>voiture</code>. Par exemple :</p>
+On peut définir des méthodes pour un type d'objet en incluant la définition de la méthode dans le constructeur. Par exemple, on peut définir une fonction qui mettrait en forme et qui afficherait les propriétés d'un objet `voiture`. Par exemple :
 
-<pre class="brush: js">
+```js
 function afficheVoiture() {
   let resultat = `Une belle ${this.modele}, fabriquée en ${this.annee} par ${this.fabricant}`;
   console.log(résultat);
 }
-</pre>
+```
 
-<p>On peut ensuite ajouter cette fonction comme méthode dans le constructeur avec cette instruction :</p>
+On peut ensuite ajouter cette fonction comme méthode dans le constructeur avec cette instruction :
 
-<pre class="brush: js">
+```js
 this.afficheVoiture = afficheVoiture;
-</pre>
+```
 
-<p>La définition complète de <code>Voiture</code> serait donc :</p>
+La définition complète de `Voiture` serait donc :
 
-<pre class="brush: js">
+```js
 function Voiture(fabricant, modele, annee, proprietaire) {
   this.fabricant = fabricant;
   this.modele = modele;
@@ -366,21 +368,22 @@ function Voiture(fabricant, modele, annee, proprietaire) {
   this.proprietaire = proprietaire;
   this.afficheVoiture = afficheVoiture;
 }
-</pre>
+```
 
-<p>On pourra donc ensuite appeler la méthode <code>afficheVoiture</code> pour chaque objet de ce type :</p>
+On pourra donc ensuite appeler la méthode `afficheVoiture` pour chaque objet de ce type :
 
-<pre class="brush: js">voiture1.afficheVoiture();
+```js
+voiture1.afficheVoiture();
 voiture2.afficheVoiture();
-</pre>
+```
 
-<h2 id="using_this_for_object_references">Utiliser <code>this</code> pour les références aux objets</h2>
+## Utiliser `this` pour les références aux objets
 
-<p>JavaScript possède un mot-clé spécial <code><a href="/fr/docs/Web/JavaScript/Reference/Operators/this">this</a></code>, qui peut être utilisé à l'intérieur d'une méthode pour faire référence à l'objet courant.</p>
+JavaScript possède un mot-clé spécial [`this`](/fr/docs/Web/JavaScript/Reference/Operators/this), qui peut être utilisé à l'intérieur d'une méthode pour faire référence à l'objet courant.
 
-<p>Par exemple, supposons qu'on ait deux objets, <code>responsable</code> et <code>stagiaire</code>. Chaque objet possède son propre <code>nom</code>, <code>age</code> et <code>poste</code>. Dans la fonction <code>direBonjour()</code>, on remarque qu'on utilise <code>this.nom</code>. Lorsqu'on ajoute cette méthode aux deux objets, on peut alors appeler cette fonction depuis les deux objets et celle-ci affichera <code>'Bonjour, mon nom est '</code> suivi de la valeur de la propriété <code>nom</code> rattaché à l'objet indiqué.</p>
+Par exemple, supposons qu'on ait deux objets, `responsable` et `stagiaire`. Chaque objet possède son propre `nom`, `age` et `poste`. Dans la fonction `direBonjour()`, on remarque qu'on utilise `this.nom`. Lorsqu'on ajoute cette méthode aux deux objets, on peut alors appeler cette fonction depuis les deux objets et celle-ci affichera `'Bonjour, mon nom est '` suivi de la valeur de la propriété `nom` rattaché à l'objet indiqué.
 
-<pre class="brush: js">
+```js
 const responsable = {
  nom: "Jean",
  age: 27,
@@ -403,33 +406,31 @@ stagiaire.direBonjour = direBonjour;
 
 responsable.direBonjour(); // Bonjour, mon nom est John'
 stagiaire.direBonjour();   // Bonjour, mon nom est Ben'
-</pre>
+```
 
-<p>Ici, <code>this</code> fait référence à l'objet courant. On peut également créer une fonction <code>direMonAge()</code> qui affiche une phrase indiquant l'age.</p>
+Ici, `this` fait référence à l'objet courant. On peut également créer une fonction `direMonAge()` qui affiche une phrase indiquant l'age.
 
-<pre class="brush: js">
+```js
 function direMonAge(){
   console.log("J'ai " + this.age + " ans.");
 };
 
 responsable.direMonAge = direMonAge;
 responsable.direMonAge(); // J'ai 27 ans.
-</pre>
+```
 
-<h2 id="defining_getters_and_setters">Définir des accesseurs et des mutateurs (<em>getters</em> et <em>setters</em>)</h2>
+## Définir des accesseurs et des mutateurs (_getters_ et _setters_)
 
-<p>Un <a href="/fr/docs/Web/JavaScript/Reference/Functions/get">accesseur</a> (<em>getter</em>) est une méthode qui permet de récupérer la valeur d'une propriété donnée. Un <a href="/fr/docs/Web/JavaScript/Reference/Functions/set">mutateur</a> (<em>setter</em>) est une méthode qui permet de définir la valeur d'une propriété donnée. Il est possible de définir des accesseurs et des mutateurs sur chaque objet (qu'il soit natif ou défini par l'utilisateur) qui supporte l'ajout de nouvelles propriétés.</p>
+Un [accesseur](/fr/docs/Web/JavaScript/Reference/Functions/get) (_getter_) est une méthode qui permet de récupérer la valeur d'une propriété donnée. Un [mutateur](/fr/docs/Web/JavaScript/Reference/Functions/set) (_setter_) est une méthode qui permet de définir la valeur d'une propriété donnée. Il est possible de définir des accesseurs et des mutateurs sur chaque objet (qu'il soit natif ou défini par l'utilisateur) qui supporte l'ajout de nouvelles propriétés.
 
-<p>Les accesseurs et mutateurs peuvent être :</p>
+Les accesseurs et mutateurs peuvent être :
 
-<ul>
- <li>définis avec <a href="#object_initializers">les initialisateurs d'objet</a>, ou</li>
- <li>ajoutés après la construction en utilisant une méthode pour ajouter un accesseur ou un mutateur.</li>
-</ul>
+- définis avec [les initialisateurs d'objet](#object_initializers), ou
+- ajoutés après la construction en utilisant une méthode pour ajouter un accesseur ou un mutateur.
 
-<p>Lorsqu'on définit des accesseurs et des mutateurs <a href="#object_initializers">en utilisant la syntaxe littérale des initialisateurs d'objet</a>, il suffit d'ajouter un préfixe <code>get</code> devant une fonction pour un accesseur et un préfixe <code>set</code> devant une fonction pour un mutateur. La méthode pour l'accesseur ne doit pas utiliser de paramètre tandis que la méthode pour le mutateur doit utiliser un seul paramètre (la nouvelle valeur à définir). Ainsi :</p>
+Lorsqu'on définit des accesseurs et des mutateurs [en utilisant la syntaxe littérale des initialisateurs d'objet](#object_initializers), il suffit d'ajouter un préfixe `get` devant une fonction pour un accesseur et un préfixe `set` devant une fonction pour un mutateur. La méthode pour l'accesseur ne doit pas utiliser de paramètre tandis que la méthode pour le mutateur doit utiliser un seul paramètre (la nouvelle valeur à définir). Ainsi :
 
-<pre class="brush: js">
+```js
 let o = {
   a: 7,
   get b() {
@@ -441,24 +442,22 @@ let o = {
 };
 
 console.log(o.a); // 7
-console.log(o.b); // 8 &lt;-- À ce moment, la méthode get b() est invoquée
-o.c = 50;         //   &lt;-- À ce moment, la méthode set c(x) est invoquée
+console.log(o.b); // 8 <-- À ce moment, la méthode get b() est invoquée
+o.c = 50;         //   <-- À ce moment, la méthode set c(x) est invoquée
 console.log(o.a); // 25
-</pre>
+```
 
-<p>Les propriétés de l'objet <code>o</code> sont :</p>
+Les propriétés de l'objet `o` sont :
 
-<ul>
- <li><code>o.a</code> — un nombre</li>
- <li><code>o.b</code> — un accesseur qui renvoie la valeur de <code>o.a</code> plus 1</li>
- <li><code>o.c</code> — un mutateur qui définit la valeur de <code>o.a</code> avec la moitié de la valeur passée pour <code>o.c</code></li>
-</ul>
+- `o.a` — un nombre
+- `o.b` — un accesseur qui renvoie la valeur de `o.a` plus 1
+- `o.c` — un mutateur qui définit la valeur de `o.a` avec la moitié de la valeur passée pour `o.c`
 
-<p>On notera que les noms des fonctions pour les accesseurs et les mutateurs définis dans un initialisateur d'objet avec la forme <code>[gs]et <em>propriete</em>()</code> ne sont pas les noms des accesseurs/mutateurs eux-mêmes malgré ce que pourrait laisser croire la syntaxe.</p>
+On notera que les noms des fonctions pour les accesseurs et les mutateurs définis dans un initialisateur d'objet avec la forme `[gs]et propriete()` ne sont pas les noms des accesseurs/mutateurs eux-mêmes malgré ce que pourrait laisser croire la syntaxe.
 
-<p>Les accesseurs et mutateurs peuvent également être ajoutés à un objet après sa création via la méthode <code>Object.defineProperties()</code> (ou <code>Object.defineProperty()</code>). Le premier paramètre de cette méthode est l'objet sur lequel on souhaite ajouter les fonctions. Le deuxième paramètre est un objet dont les noms des propriétés sont les noms des accesseurs et/ou des mutateurs et les valeurs de ces propriétés sont les objets qui définissent les fonctions correspondantes. Voici un exemple qui définit un accesseur et un mutateur pour obtenir un résultat équivalent à l'exemple précédent :</p>
+Les accesseurs et mutateurs peuvent également être ajoutés à un objet après sa création via la méthode `Object.defineProperties()` (ou `Object.defineProperty()`). Le premier paramètre de cette méthode est l'objet sur lequel on souhaite ajouter les fonctions. Le deuxième paramètre est un objet dont les noms des propriétés sont les noms des accesseurs et/ou des mutateurs et les valeurs de ces propriétés sont les objets qui définissent les fonctions correspondantes. Voici un exemple qui définit un accesseur et un mutateur pour obtenir un résultat équivalent à l'exemple précédent :
 
-<pre class="brush: js">
+```js
 let o = { a: 0 };
 
 Object.defineProperties(o, {
@@ -468,15 +467,15 @@ Object.defineProperties(o, {
 
 o.c = 10; // Exécute le mutateur qui affecte 10 / 2 (5) à la propriété 'a'
 console.log(o.b); // Exécute l'accesseur qui renvoie a + 1, soit 6
-</pre>
+```
 
-<p>Le choix de l'une ou l'autre de ces formes dépend de votre style et du type de tâche à réaliser. Si vous utilisez déjà un initialisateur d'objet lors de la définition d'un prototype, vous choisirez probablement la première forme, plus concise et plus naturelle. Toutefois, si vous avez besoin d'ajouter des accesseurs/mutateurs plus tard, parce que vous n'avez pas écrit le prototype ou la définition de l'objet, seule la seconde forme sera possible. Cette dernière représente mieux la nature dynamique de JavaScript mais peut rendre la lecture et la compréhension du code plus difficiles.</p>
+Le choix de l'une ou l'autre de ces formes dépend de votre style et du type de tâche à réaliser. Si vous utilisez déjà un initialisateur d'objet lors de la définition d'un prototype, vous choisirez probablement la première forme, plus concise et plus naturelle. Toutefois, si vous avez besoin d'ajouter des accesseurs/mutateurs plus tard, parce que vous n'avez pas écrit le prototype ou la définition de l'objet, seule la seconde forme sera possible. Cette dernière représente mieux la nature dynamique de JavaScript mais peut rendre la lecture et la compréhension du code plus difficiles.
 
-<h2 id="deleting_properties">Supprimer des propriétés</h2>
+## Supprimer des propriétés
 
-<p>Il est possible de retirer des propriétés propres (celles qui ne sont pas héritées) grâce à l'opérateur <code><a href="/fr/docs/Web/JavaScript/Reference/Operators/delete">delete</a></code>. Le code suivant montre comment retirer une propriété :</p>
+Il est possible de retirer des propriétés propres (celles qui ne sont pas héritées) grâce à l'opérateur [`delete`](/fr/docs/Web/JavaScript/Reference/Operators/delete). Le code suivant montre comment retirer une propriété :
 
-<pre class="brush: js">
+```js
 // On crée un nouvel objet, monObj, avec deux propriétés a et b.
 let monObj = new Object;
 monObj.a = 5;
@@ -485,29 +484,30 @@ monObj.b = 12;
 // On retire la propriété a, monObj a donc uniquement la propriété b
 delete monObj.a;
 console.log("a" in monObj) // produit "false"
-</pre>
+```
 
-<p>Il est aussi possible de supprimer une propriété de l'objet global avec <code>delete</code> si aucun mot-clé comme <code>var</code>, <code>let</code> ou <code>const</code> n'avait été utilisé :</p>
+Il est aussi possible de supprimer une propriété de l'objet global avec `delete` si aucun mot-clé comme `var`, `let` ou `const` n'avait été utilisé :
 
-<pre class="brush: js">
+```js
 g = 17;
 delete g;
-</pre>
+```
 
-<h2 id="comparing_objects">Comparer des objets</h2>
+## Comparer des objets
 
-<p>En JavaScript, les objets fonctionnent par référence. Deux objets distincts ne sont jamais égaux, même s'ils ont les mêmes valeurs pour les mêmes propriétés. On aura une équivalence uniquement si on compare deux références vers un seul et même objet donné.</p>
+En JavaScript, les objets fonctionnent par référence. Deux objets distincts ne sont jamais égaux, même s'ils ont les mêmes valeurs pour les mêmes propriétés. On aura une équivalence uniquement si on compare deux références vers un seul et même objet donné.
 
-<pre class="brush: js">
+```js
 // Deux variables avec deux objets distincts
 // qui ont les mêmes propriétés
 let fruit = {nom: "pomme"};
 let fruit2 = {nom: "pomme"};
 
 fruit == fruit2  // renvoie false
-fruit === fruit2 // renvoie false</pre>
+fruit === fruit2 // renvoie false
+```
 
-<pre class="brush: js">
+```js
 // Deux variables référençant un même objet
 let fruit = {nom: "pomme"};
 let fruit2 = fruit;  // On affecte la même référence
@@ -518,15 +518,13 @@ fruit === fruit2 // renvoie true
 
 fruit.nom = "raisin";
 console.log(fruit2); // affiche {nom: "raisin"} et non {nom: "pomme"}
-</pre>
+```
 
-<p>Pour plus d'informations sur les opérateurs de comparaisons, voir <a href="/fr/docs/Web/JavaScript/Reference/Operators">cet article</a>.</p>
+Pour plus d'informations sur les opérateurs de comparaisons, voir [cet article](/fr/docs/Web/JavaScript/Reference/Operators).
 
-<h2 id="see_also">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>Pour aller plus loin, voir <a href="/fr/docs/Web/JavaScript/Guide/Details_of_the_Object_Model">les détails du modèle objet javaScript</a></li>
- <li>Pour en savoir plus sur les classes ECMAScript 2015 (une nouvelle façon de créer des objets), lire le chapitre sur les <a href="/fr/docs/Web/JavaScript/Reference/Classes">classes JavaScript</a>.</li>
-</ul>
+- Pour aller plus loin, voir [les détails du modèle objet javaScript](/fr/docs/Web/JavaScript/Guide/Details_of_the_Object_Model)
+- Pour en savoir plus sur les classes ECMAScript 2015 (une nouvelle façon de créer des objets), lire le chapitre sur les [classes JavaScript](/fr/docs/Web/JavaScript/Reference/Classes).
 
-<p>{{PreviousNext("Web/JavaScript/Guide/Keyed_collections", "Web/JavaScript/Guide/Details_of_the_Object_Model")}}</p>
+{{PreviousNext("Web/JavaScript/Guide/Keyed_collections", "Web/JavaScript/Guide/Details_of_the_Object_Model")}}
diff --git a/files/fr/web/javascript/index.md b/files/fr/web/javascript/index.md
index bb77718a93..b8888103f5 100644
--- a/files/fr/web/javascript/index.md
+++ b/files/fr/web/javascript/index.md
@@ -8,122 +8,108 @@ tags:
   - Learn
 translation_of: Web/JavaScript
 ---
-<div>{{JsSidebar}}</div>
-
-<p><strong>JavaScript</strong> (souvent abrégé en « JS ») est un langage de script léger, orienté objet, principalement connu comme le langage de script des pages web. Mais il est aussi <a href="https://fr.wikipedia.org/wiki/JavaScript#Autres_utilisations">utilisé dans de nombreux environnements extérieurs aux navigateurs web</a> tels que <a href="https://nodejs.org/">Node.js</a>, <a href="https://couchdb.apache.org/">Apache CouchDB</a> voire <a href="https://www.adobe.com/devnet/acrobat/javascript.html">Adobe Acrobat</a>. Le code JavaScript est interprété ou compilé à la volée (<a href="https://fr.wikipedia.org/wiki/Compilation_%C3%A0_la_vol%C3%A9e">JIT</a>). C'est un langage à objets utilisant le concept de <a href="https://fr.wikipedia.org/wiki/Programmation_orient%C3%A9e_prototype">prototype</a>, disposant d'un typage faible et dynamique qui permet de programmer suivant plusieurs paradigmes de programmation : fonctionnelle, impérative et orientée objet. <a href="/fr/docs/Web/JavaScript/About_JavaScript">Apprenez-en plus sur JavaScript</a>.</p>
-
-<p>Cette section de MDN est dédiée au langage JavaScript. Pour des informations sur l'utilisation de JavaScript avec les <a href="/fr/docs/Glossary/API">API</a> spécifiques des navigateurs web pour les pages web, veuillez consulter les sections sur les <a href="/fr/docs/Web/API">API Web</a> (<em>Web API</em> en anglais) et le <a href="/fr/docs/Web/API/Document_Object_Model">DOM</a>.</p>
-
-<p>Le standard qui spécifie JavaScript est <a href="/fr/docs/Web/JavaScript/Language_Resources">ECMAScript</a>. En 2012, tous les navigateurs modernes supportent complètement ECMAScript 5.1. Les anciens navigateurs supportent au minimum ECMAScript 3. Une sixième version majeure du standard a été finalisée et publiée le 17 juin 2015. Cette version s'intitule officiellement ECMAScript 2015 mais est encore fréquemment appelée ECMAScript 6 ou ES6. Étant donné que les standards ECMAScript sont désormais édités sur un rythme annuel, cette documentation fait référence à la dernière version en cours de rédaction, actuellement c'est <a href="https://tc39.github.io/ecma262/">ECMAScript 2020</a>.</p>
-
-<p>JavaScript ne doit pas être confondu avec le <a href="https://fr.wikipedia.org/wiki/Java_%28langage%29">langage de programmation Java</a>. Java et JavaScript sont deux marques déposées par Oracle dans de nombreux pays mais ces deux langages de programmation ont chacun une syntaxe, une sémantique et des usages différents.</p>
-
-<div class="callout">
-  <h4 id="Looking_to_become_a_front-end_web_developer">Vous cherchez à devenir un développeur web front-end ?</h4>
-  <p>Nous avons élaboré un cours qui comprend toutes les informations essentielles dont vous avez besoin pour atteindre votre objectif.</p>
-  <p><a href="/fr/docs/Learn/Front-end_web_developer">Commencer</a></p>
-</div>
-
-<h2 id="Tutorials">Tutoriels</h2>
-
-<p>Apprenez comment programmer en JavaScript.</p>
-
-<h3 id="For_complete_beginners">Ressources pour commencer</h3>
-
-<p>Si vous souhaitez apprendre JavaScript et que vous débutez en programmation ou en JavaScript, <a href="/fr/docs/Learn/JavaScript">la section JavaScript de la zone d'apprentissage de MDN (<em>learning area</em>)</a> est le meilleur endroit où commencer. Cette section contient les modules suivants :</p>
-
-<dl>
-  <dt><a href="/fr/docs/Learn/JavaScript/First_steps">Les premiers pas en JavaScript</a></dt>
-  <dd>Cet ensemble de chapitres répond à des questions telles que « qu'est-ce que JavaScript ? », « à quoi ressemble-t-il ? », « que puis-je faire avec ? » et présente des éléments clés du langage tels que les variables, les chaînes de caractères, les nombres et les tableaux.</dd>
-  <dt><a href="/fr/docs/Learn/JavaScript/Building_blocks">Les principaux blocs de JavaScript</a></dt>
-  <dd>On poursuit ici la présentation des fonctionnalités importantes de JavaScript, notamment celle des blocs de codes fréquemment utilisés comme les instructions conditionnelles, les boucles, les fonctions et les évènements.</dd>
-  <dt><a href="/fr/docs/Learn/JavaScript/Objects">Une introduction aux objets JavaScript</a></dt>
-  <dd>JavaScript est un langage de programmation « orienté objet » et ce concept est primordial pour utiliser JavaScript au mieux, écrire du code plus efficace et comprendre son fonctionnement. Ce module présente les bases de ces concepts.</dd>
-  <dt><a href="/fr/docs/Learn/JavaScript/Asynchronous">La programmation asynchrone en JavaScript</a></dt>
-  <dd>Dans cet article, on aborde les fonctionnalités asynchrones de JavaScript, en quoi elles sont importantes et la façon dont elles peuvent être utilisées lors d'opérations bloquantes comme la récupération de ressources provenant d'un serveur.</dd>
-  <dt><a href="/fr/docs/Learn/JavaScript/Client-side_web_APIs">Les API Web utilisées côté client</a></dt>
-  <dd>Lorsqu'on écrit du JavaScript pour un site web ou une application, il est rapidement nécessaire de manipuler les API : des interfaces qui permettent de manipuler différents aspects du navigateur, des données provenant d'autres sites ou services, etc. Dans ce module, nous verrons ce que sont les API, et comment utiliser les API les plus fréquemment utilisées.</dd>
-</dl>
-
-<h3 id="JavaScript_guide">Guide JavaScript</h3>
-
-<dl>
-  <dt><a href="/fr/docs/Web/JavaScript/Guide">Guide JavaScript</a></dt>
-  <dd>Un guide détaillé de JavaScript, destiné aux personnes qui ont déjà développé en JavaScript ou avec un autre langage.</dd>
-</dl>
-
-<h3 id="Intermediate">Niveau intermédiaire</h3>
-
-<dl>
-  <dt><a href="/fr/docs/Learn/Tools_and_testing/Client-side_JavaScript_frameworks">Comprendre les <i>frameworks</i> JavaScript côté client</a></dt>
-  <dd>Les <i>frameworks</i> JavaScript font partie de l'écosystème du développement web côté client. Les outils qu'ils fournissent permettent de construire des applications dynamiques sur des bases robustes. Dans ce module, on présente les notions principales de leur fonctionnement et comment ces outils peuvent rejoindre votre panoplie. Des tutoriels sur les frameworks les plus répandus suivront cet article.</dd>
-  <dt><a href="/fr/docs/Web/JavaScript/A_re-introduction_to_JavaScript">Une réintroduction à JavaScript</a></dt>
-  <dd>Un aperçu pour ceux qui <em>pensent</em> s'y connaître en JavaScript.</dd>
-  <dt><a href="/fr/docs/Web/JavaScript/Data_structures">Structures de données JavaScript</a></dt>
-  <dd>Aperçu des structures de données disponibles en JavaScript.</dd>
-  <dt><a href="/fr/docs/Web/JavaScript/Equality_comparisons_and_sameness">Égalité, comparaison et similarité</a></dt>
-  <dd>JavaScript propose trois opérations de comparaison de valeurs différentes : l'égalité stricte à l'aide de <code>===</code>, l'égalité souple à l'aide de <code>==</code> et la méthode <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Object/is"><code>Object.is()</code></a>.</dd>
-  <dt><a href="/fr/docs/Web/JavaScript/Closures">Closures</a></dt>
-  <dd>
-  <p>Une <i>closure</i> est la combinaison d'une fonction et de l'environnement lexical dans lequel cette fonction a été déclarée.</p>
-  </dd>
-</dl>
-
-<h3 id="Advanced">Niveau avancé</h3>
-
-<dl>
-  <dt><a href="/fr/docs/Web/JavaScript/Inheritance_and_the_prototype_chain">Héritage et chaîne de prototypes</a></dt>
-  <dd>Cette page explique l'héritage à base de prototype, un concept souvent incompris et sous-estimé.</dd>
-  <dt><a href="/fr/docs/Web/JavaScript/Reference/Strict_mode">Le mode strict</a></dt>
-  <dd>Une variante plus restreinte de JavaScript (par exemple, on ne peut pas utiliser de variable avant de l'avoir définie). Elle permet d'obtenir de meilleures performances et de faciliter le débogage.</dd>
-  <dt><a href="/fr/docs/Web/JavaScript/Typed_arrays">Les tableaux typés en JavaScript</a></dt>
-  <dd>Les tableaux typés permettent d'accéder à des données binaires brutes, de façon organisée.</dd>
-  <dt><a href="/fr/docs/Web/JavaScript/Memory_Management">La gestion de la mémoire en JavaScript</a></dt>
-  <dd>Cet article décrit le cycle de vie des objets et de la mémoire en JavaScript, ainsi que le mécanisme du ramasse-miettes.</dd>
-  <dt><a href="/fr/docs/Web/JavaScript/EventLoop">Gestion de la concurrence et boucle des événements</a></dt>
-  <dd>Le modèle de concurrence utilisé par JavaScript est basé sur une « boucle d'événements »</dd>
-</dl>
-
-<h2 id="Reference">Référence</h2>
-
-<p>Parcourez la documentation complète de la <a href="/fr/docs/Web/JavaScript/Reference">référence JavaScript</a>.</p>
-
-<dl>
-  <dt><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects">Les objets standard</a></dt>
-  <dd>Apprenez à connaître les objets natifs standard tels que <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Array"><code>Array</code></a>, <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Boolean"><code>Boolean</code></a>, <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Date"><code>Date</code></a>, <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Error"><code>Error</code></a>, <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Function"><code>Function</code></a>, <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/JSON"><code>JSON</code></a>, <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Math"><code>Math</code></a>, <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Number"><code>Number</code></a>, <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Object"><code>Object</code></a>, <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/RegExp"><code>RegExp</code></a>, <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/String"><code>String</code></a>, <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Map"><code>Map</code></a>, <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Set"><code>Set</code></a>, <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/WeakMap"><code>WeakMap</code></a>, <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/WeakSet"><code>WeakSet</code></a>, et d'autres.</dd>
-  <dt><a href="/fr/docs/Web/JavaScript/Reference/Operators">Les expressions et les opérateurs</a></dt>
-  <dd>Apprenez à connaître comment fonctionnent les opérateurs JavaScript comme <a href="/fr/docs/Web/JavaScript/Reference/Operators/instanceof"><code>instanceof</code></a>, <a href="/fr/docs/Web/JavaScript/Reference/Operators/typeof"><code>typeof</code></a>, <a href="/fr/docs/Web/JavaScript/Reference/Operators/new"><code>new</code></a>, <a href="/fr/docs/Web/JavaScript/Reference/Operators/this"><code>this</code></a> et bien d'autres notions comme <a href="/fr/docs/Web/JavaScript/Reference/Operators/Operator_Precedence">la précédence des opérateurs</a>.</dd>
-  <dt><a href="/fr/docs/Web/JavaScript/Reference/Statements">Les instructions et les déclarations</a></dt>
-  <dd>Apprenez à connaître comment utiliser <a href="/fr/docs/Web/JavaScript/Reference/Statements/do...while"><code>do...while</code></a>, <a href="/fr/docs/Web/JavaScript/Reference/Statements/for...in"><code>for...in</code></a>, <a href="/fr/docs/Web/JavaScript/Reference/Statements/for...of"><code>for...of</code></a>, <a href="/fr/docs/Web/JavaScript/Reference/Statements/try...catch"><code>try...catch</code></a>, <a href="/fr/docs/Web/JavaScript/Reference/Statements/let"><code>let</code></a>, <a href="/fr/docs/Web/JavaScript/Reference/Statements/var"><code>var</code></a>, <a href="/fr/docs/Web/JavaScript/Reference/Statements/const"><code>const</code></a>, <a href="/fr/docs/Web/JavaScript/Reference/Statements/if...else"><code>if...else</code></a>, <a href="/fr/docs/Web/JavaScript/Reference/Statements/switch"><code>switch</code></a> et les autres mots-clés et instructions JavaScript.</dd>
-  <dt><a href="/fr/docs/Web/JavaScript/Reference/Functions">Les fonctions</a></dt>
-  <dd>Apprenez à utiliser les fonctions en JavaScript pour développer vos applications.</dd>
-</dl>
-
-<h2 id="Tools_resources">Outils &amp; ressources</h2>
-
-<p>Voici une liste d'outils utiles pour écrire et déboguer du code <strong>JavaScript</strong>.</p>
-
-<dl>
-  <dt><a href="/fr/docs/Tools">Outils de développement de Firefox</a></dt>
-  <dd><a href="/fr/docs/Tools/Web_Console">Console web</a>, <a href="/fr/docs/Tools/Performance">profileur JavaScript</a>, <a href="/fr/docs/Tools/Debugger">débogueur</a>, et plus.</dd>
-  <dt><a href="/fr/docs/Web/JavaScript/Shells">Invites de commande JavaScript</a></dt>
-  <dd>Un interpréteur de commandes JavaScript vous permet de tester rapidement des extraits de code JavaScript.</dd>
-  <dt><a href="https://learnjavascript.online/">Apprendre le JavaScript (en anglais)</a></dt>
-  <dd>Une excellente ressource pour les développeurs web en herbe - Apprenez JavaScript dans un environnement interactif, avec des leçons courtes et des tests interactifs, guidés par une évaluation automatique. Les 40 premières leçons sont gratuites, et le cours complet est disponible moyennant un petit paiement unique.</dd>
-  <dt><a href="https://togetherjs.com/">TogetherJS</a></dt>
-  <dd>La collaboration rendue facile. En ajoutant TogetherJS à votre site, vos utilisateurs peuvent s'entraider sur un site web en temps réel !</dd>
-  <dt><a href="https://stackoverflow.com/questions/tagged/javascript">Stack Overflow</a></dt>
-  <dd>Questions Stack Overflow portant le tag « JavaScript ».</dd>
-  <dt><a href="https://jsfiddle.net/">JSFiddle</a></dt>
-  <dd>Modifiez votre code JavaScript, CSS, HTML et obtenez des résultats en direct. Utilisez des ressources externes et collaborez avec votre équipe en ligne.</dd>
-  <dt><a href="https://plnkr.co/">Plunker</a></dt>
-  <dd>Plunker est une communauté en ligne pour créer, collaborer et partager vos idées de développement web. Modifiez vos fichiers JavaScript, CSS, HTML et obtenez des résultats en direct et la structure des fichiers.</dd>
-  <dt><a href="https://jsbin.com/">JSBin</a></dt>
-  <dd>JS Bin est un outil de débogage collaboratif open-source pour le développement web.</dd>
-  <dt><a href="https://codepen.io/">Codepen</a></dt>
-  <dd>Codepen est un autre outil de développement web collaboratif utilisé comme un terrain de jeu pour des résultats en direct.</dd>
-  <dt><a href="https://stackblitz.com/">StackBlitz</a></dt>
-  <dd>StackBlitz est un autre terrain de jeu/outil de débogage en ligne, qui peut héberger et déployer des applications full-stack utilisant React, Angular, etc.</dd>
-  <dt><a href="https://runjs.app/">RunJS</a></dt>
-  <dd>RunJS est un outil de bureau de type bac-à-sable/ardoise, qui fournit des résultats en direct et un accès aux API Node.JS et à celles du navigateur.</dd>
-</dl>
+{{JsSidebar}}
+
+**JavaScript** (souvent abrégé en « JS ») est un langage de script léger, orienté objet, principalement connu comme le langage de script des pages web. Mais il est aussi [utilisé dans de nombreux environnements extérieurs aux navigateurs web](https://fr.wikipedia.org/wiki/JavaScript#Autres_utilisations) tels que [Node.js](https://nodejs.org/), [Apache CouchDB](https://couchdb.apache.org/) voire [Adobe Acrobat](https://www.adobe.com/devnet/acrobat/javascript.html). Le code JavaScript est interprété ou compilé à la volée ([JIT](https://fr.wikipedia.org/wiki/Compilation_%C3%A0_la_vol%C3%A9e)). C'est un langage à objets utilisant le concept de [prototype](https://fr.wikipedia.org/wiki/Programmation_orient%C3%A9e_prototype), disposant d'un typage faible et dynamique qui permet de programmer suivant plusieurs paradigmes de programmation : fonctionnelle, impérative et orientée objet. [Apprenez-en plus sur JavaScript](/fr/docs/Web/JavaScript/About_JavaScript).
+
+Cette section de MDN est dédiée au langage JavaScript. Pour des informations sur l'utilisation de JavaScript avec les [API](/fr/docs/Glossary/API) spécifiques des navigateurs web pour les pages web, veuillez consulter les sections sur les [API Web](/fr/docs/Web/API) (_Web API_ en anglais) et le [DOM](/fr/docs/Web/API/Document_Object_Model).
+
+Le standard qui spécifie JavaScript est [ECMAScript](/fr/docs/Web/JavaScript/Language_Resources). En 2012, tous les navigateurs modernes supportent complètement ECMAScript 5.1. Les anciens navigateurs supportent au minimum ECMAScript 3. Une sixième version majeure du standard a été finalisée et publiée le 17 juin 2015. Cette version s'intitule officiellement ECMAScript 2015 mais est encore fréquemment appelée ECMAScript 6 ou ES6. Étant donné que les standards ECMAScript sont désormais édités sur un rythme annuel, cette documentation fait référence à la dernière version en cours de rédaction, actuellement c'est [ECMAScript 2020](https://tc39.github.io/ecma262/).
+
+JavaScript ne doit pas être confondu avec le [langage de programmation Java](https://fr.wikipedia.org/wiki/Java_%28langage%29). Java et JavaScript sont deux marques déposées par Oracle dans de nombreux pays mais ces deux langages de programmation ont chacun une syntaxe, une sémantique et des usages différents.
+
+> **Remarque :** **Vous cherchez à devenir un développeur web front-end ?**
+>
+> Nous avons élaboré un cours qui comprend toutes les informations essentielles dont vous avez besoin pour atteindre votre objectif.
+>
+> [Commencer](/fr/docs/Learn/Front-end_web_developer)
+
+## Tutoriels
+
+Apprenez comment programmer en JavaScript.
+
+### Ressources pour commencer
+
+Si vous souhaitez apprendre JavaScript et que vous débutez en programmation ou en JavaScript, [la section JavaScript de la zone d'apprentissage de MDN (_learning area_)](/fr/docs/Learn/JavaScript) est le meilleur endroit où commencer. Cette section contient les modules suivants :
+
+- [Les premiers pas en JavaScript](/fr/docs/Learn/JavaScript/First_steps)
+  - : Cet ensemble de chapitres répond à des questions telles que « qu'est-ce que JavaScript ? », « à quoi ressemble-t-il ? », « que puis-je faire avec ? » et présente des éléments clés du langage tels que les variables, les chaînes de caractères, les nombres et les tableaux.
+- [Les principaux blocs de JavaScript](/fr/docs/Learn/JavaScript/Building_blocks)
+  - : On poursuit ici la présentation des fonctionnalités importantes de JavaScript, notamment celle des blocs de codes fréquemment utilisés comme les instructions conditionnelles, les boucles, les fonctions et les évènements.
+- [Une introduction aux objets JavaScript](/fr/docs/Learn/JavaScript/Objects)
+  - : JavaScript est un langage de programmation « orienté objet » et ce concept est primordial pour utiliser JavaScript au mieux, écrire du code plus efficace et comprendre son fonctionnement. Ce module présente les bases de ces concepts.
+- [La programmation asynchrone en JavaScript](/fr/docs/Learn/JavaScript/Asynchronous)
+  - : Dans cet article, on aborde les fonctionnalités asynchrones de JavaScript, en quoi elles sont importantes et la façon dont elles peuvent être utilisées lors d'opérations bloquantes comme la récupération de ressources provenant d'un serveur.
+- [Les API Web utilisées côté client](/fr/docs/Learn/JavaScript/Client-side_web_APIs)
+  - : Lorsqu'on écrit du JavaScript pour un site web ou une application, il est rapidement nécessaire de manipuler les API : des interfaces qui permettent de manipuler différents aspects du navigateur, des données provenant d'autres sites ou services, etc. Dans ce module, nous verrons ce que sont les API, et comment utiliser les API les plus fréquemment utilisées.
+
+### Guide JavaScript
+
+- [Guide JavaScript](/fr/docs/Web/JavaScript/Guide)
+  - : Un guide détaillé de JavaScript, destiné aux personnes qui ont déjà développé en JavaScript ou avec un autre langage.
+
+### Niveau intermédiaire
+
+- [Comprendre les _frameworks_ JavaScript côté client](/fr/docs/Learn/Tools_and_testing/Client-side_JavaScript_frameworks)
+  - : Les _frameworks_ JavaScript font partie de l'écosystème du développement web côté client. Les outils qu'ils fournissent permettent de construire des applications dynamiques sur des bases robustes. Dans ce module, on présente les notions principales de leur fonctionnement et comment ces outils peuvent rejoindre votre panoplie. Des tutoriels sur les frameworks les plus répandus suivront cet article.
+- [Une réintroduction à JavaScript](/fr/docs/Web/JavaScript/A_re-introduction_to_JavaScript)
+  - : Un aperçu pour ceux qui _pensent_ s'y connaître en JavaScript.
+- [Structures de données JavaScript](/fr/docs/Web/JavaScript/Data_structures)
+  - : Aperçu des structures de données disponibles en JavaScript.
+- [Égalité, comparaison et similarité](/fr/docs/Web/JavaScript/Equality_comparisons_and_sameness)
+  - : JavaScript propose trois opérations de comparaison de valeurs différentes : l'égalité stricte à l'aide de `===`, l'égalité souple à l'aide de `==` et la méthode [`Object.is()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Object/is).
+- [Closures](/fr/docs/Web/JavaScript/Closures)
+  - : Une _closure_ est la combinaison d'une fonction et de l'environnement lexical dans lequel cette fonction a été déclarée.
+
+### Niveau avancé
+
+- [Héritage et chaîne de prototypes](/fr/docs/Web/JavaScript/Inheritance_and_the_prototype_chain)
+  - : Cette page explique l'héritage à base de prototype, un concept souvent incompris et sous-estimé.
+- [Le mode strict](/fr/docs/Web/JavaScript/Reference/Strict_mode)
+  - : Une variante plus restreinte de JavaScript (par exemple, on ne peut pas utiliser de variable avant de l'avoir définie). Elle permet d'obtenir de meilleures performances et de faciliter le débogage.
+- [Les tableaux typés en JavaScript](/fr/docs/Web/JavaScript/Typed_arrays)
+  - : Les tableaux typés permettent d'accéder à des données binaires brutes, de façon organisée.
+- [La gestion de la mémoire en JavaScript](/fr/docs/Web/JavaScript/Memory_Management)
+  - : Cet article décrit le cycle de vie des objets et de la mémoire en JavaScript, ainsi que le mécanisme du ramasse-miettes.
+- [Gestion de la concurrence et boucle des événements](/fr/docs/Web/JavaScript/EventLoop)
+  - : Le modèle de concurrence utilisé par JavaScript est basé sur une « boucle d'événements »
+
+## Référence
+
+Parcourez la documentation complète de la [référence JavaScript](/fr/docs/Web/JavaScript/Reference).
+
+- [Les objets standard](/fr/docs/Web/JavaScript/Reference/Global_Objects)
+  - : Apprenez à connaître les objets natifs standard tels que [`Array`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Array), [`Boolean`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Boolean), [`Date`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Date), [`Error`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Error), [`Function`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Function), [`JSON`](/fr/docs/Web/JavaScript/Reference/Global_Objects/JSON), [`Math`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Math), [`Number`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Number), [`Object`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Object), [`RegExp`](/fr/docs/Web/JavaScript/Reference/Global_Objects/RegExp), [`String`](/fr/docs/Web/JavaScript/Reference/Global_Objects/String), [`Map`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Map), [`Set`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Set), [`WeakMap`](/fr/docs/Web/JavaScript/Reference/Global_Objects/WeakMap), [`WeakSet`](/fr/docs/Web/JavaScript/Reference/Global_Objects/WeakSet), et d'autres.
+- [Les expressions et les opérateurs](/fr/docs/Web/JavaScript/Reference/Operators)
+  - : Apprenez à connaître comment fonctionnent les opérateurs JavaScript comme [`instanceof`](/fr/docs/Web/JavaScript/Reference/Operators/instanceof), [`typeof`](/fr/docs/Web/JavaScript/Reference/Operators/typeof), [`new`](/fr/docs/Web/JavaScript/Reference/Operators/new), [`this`](/fr/docs/Web/JavaScript/Reference/Operators/this) et bien d'autres notions comme [la précédence des opérateurs](/fr/docs/Web/JavaScript/Reference/Operators/Operator_Precedence).
+- [Les instructions et les déclarations](/fr/docs/Web/JavaScript/Reference/Statements)
+  - : Apprenez à connaître comment utiliser [`do...while`](/fr/docs/Web/JavaScript/Reference/Statements/do...while), [`for...in`](/fr/docs/Web/JavaScript/Reference/Statements/for...in), [`for...of`](/fr/docs/Web/JavaScript/Reference/Statements/for...of), [`try...catch`](/fr/docs/Web/JavaScript/Reference/Statements/try...catch), [`let`](/fr/docs/Web/JavaScript/Reference/Statements/let), [`var`](/fr/docs/Web/JavaScript/Reference/Statements/var), [`const`](/fr/docs/Web/JavaScript/Reference/Statements/const), [`if...else`](/fr/docs/Web/JavaScript/Reference/Statements/if...else), [`switch`](/fr/docs/Web/JavaScript/Reference/Statements/switch) et les autres mots-clés et instructions JavaScript.
+- [Les fonctions](/fr/docs/Web/JavaScript/Reference/Functions)
+  - : Apprenez à utiliser les fonctions en JavaScript pour développer vos applications.
+
+## Outils & ressources
+
+Voici une liste d'outils utiles pour écrire et déboguer du code **JavaScript**.
+
+- [Outils de développement de Firefox](/fr/docs/Tools)
+  - : [Console web](/fr/docs/Tools/Web_Console), [profileur JavaScript](/fr/docs/Tools/Performance), [débogueur](/fr/docs/Tools/Debugger), et plus.
+- [Invites de commande JavaScript](/fr/docs/Web/JavaScript/Shells)
+  - : Un interpréteur de commandes JavaScript vous permet de tester rapidement des extraits de code JavaScript.
+- [Apprendre le JavaScript (en anglais)](https://learnjavascript.online/)
+  - : Une excellente ressource pour les développeurs web en herbe - Apprenez JavaScript dans un environnement interactif, avec des leçons courtes et des tests interactifs, guidés par une évaluation automatique. Les 40 premières leçons sont gratuites, et le cours complet est disponible moyennant un petit paiement unique.
+- [TogetherJS](https://togetherjs.com/)
+  - : La collaboration rendue facile. En ajoutant TogetherJS à votre site, vos utilisateurs peuvent s'entraider sur un site web en temps réel !
+- [Stack Overflow](https://stackoverflow.com/questions/tagged/javascript)
+  - : Questions Stack Overflow portant le tag « JavaScript ».
+- [JSFiddle](https://jsfiddle.net/)
+  - : Modifiez votre code JavaScript, CSS, HTML et obtenez des résultats en direct. Utilisez des ressources externes et collaborez avec votre équipe en ligne.
+- [Plunker](https://plnkr.co/)
+  - : Plunker est une communauté en ligne pour créer, collaborer et partager vos idées de développement web. Modifiez vos fichiers JavaScript, CSS, HTML et obtenez des résultats en direct et la structure des fichiers.
+- [JSBin](https://jsbin.com/)
+  - : JS Bin est un outil de débogage collaboratif open-source pour le développement web.
+- [Codepen](https://codepen.io/)
+  - : Codepen est un autre outil de développement web collaboratif utilisé comme un terrain de jeu pour des résultats en direct.
+- [StackBlitz](https://stackblitz.com/)
+  - : StackBlitz est un autre terrain de jeu/outil de débogage en ligne, qui peut héberger et déployer des applications full-stack utilisant React, Angular, etc.
+- [RunJS](https://runjs.app/)
+  - : RunJS est un outil de bureau de type bac-à-sable/ardoise, qui fournit des résultats en direct et un accès aux API Node.JS et à celles du navigateur.
diff --git a/files/fr/web/javascript/inheritance_and_the_prototype_chain/index.md b/files/fr/web/javascript/inheritance_and_the_prototype_chain/index.md
index 1b21ea0232..160e5aa03e 100644
--- a/files/fr/web/javascript/inheritance_and_the_prototype_chain/index.md
+++ b/files/fr/web/javascript/inheritance_and_the_prototype_chain/index.md
@@ -10,31 +10,30 @@ tags:
 translation_of: Web/JavaScript/Inheritance_and_the_prototype_chain
 original_slug: Web/JavaScript/Héritage_et_chaîne_de_prototypes
 ---
-<div>{{jsSidebar("Advanced")}}</div>
+{{jsSidebar("Advanced")}}
 
-<p>JavaScript peut prêter à confusion losqu'on est habitué à manipuler des langages de programmation manipulant les classes (tels que Java ou C++). En effet, JavaScript est un langage dynamique et ne possède pas de concept de classe à part entière (le mot-clé <code>class</code> a certes été ajouté avec ES2015 mais il s'agit uniquement de sucre syntaxique, JavaScript continue de reposer sur l'héritage prototypique).</p>
+JavaScript peut prêter à confusion losqu'on est habitué à manipuler des langages de programmation manipulant les classes (tels que Java ou C++). En effet, JavaScript est un langage dynamique et ne possède pas de concept de classe à part entière (le mot-clé `class` a certes été ajouté avec ES2015 mais il s'agit uniquement de sucre syntaxique, JavaScript continue de reposer sur l'héritage prototypique).
 
-<p>En ce qui concerne l'héritage, JavaScript n'utilise qu'une seule structure : les objets. Chaque objet possède une propriété privée qui contient un lien vers un autre objet appelé le <strong>prototype</strong>. Ce prototype possède également son prototype et ainsi de suite, jusqu'à ce qu'un objet ait {{jsxref("null")}} comme prototype. Par définition, <code>null</code> ne possède pas de prototype et est ainsi le dernier maillon de la <strong>chaîne de prototype</strong>.</p>
+En ce qui concerne l'héritage, JavaScript n'utilise qu'une seule structure : les objets. Chaque objet possède une propriété privée qui contient un lien vers un autre objet appelé le **prototype**. Ce prototype possède également son prototype et ainsi de suite, jusqu'à ce qu'un objet ait {{jsxref("null")}} comme prototype. Par définition, `null` ne possède pas de prototype et est ainsi le dernier maillon de la **chaîne de prototype**.
 
-<p>La majorité des objets JavaScript sont des instances de {{jsxref("Object")}} qui est l'avant dernier maillon de la chaîne de prototype.</p>
+La majorité des objets JavaScript sont des instances de {{jsxref("Object")}} qui est l'avant dernier maillon de la chaîne de prototype.
 
-<p>Bien que cette confusion (entre classe et prototype) soit souvent avancée comme l'une des faiblesses de JavaScript, le modèle prototypique est plus puissant que le modèle classique et il est notamment possible de construire un modèle classique à partir d'un modèle prototypique.</p>
+Bien que cette confusion (entre classe et prototype) soit souvent avancée comme l'une des faiblesses de JavaScript, le modèle prototypique est plus puissant que le modèle classique et il est notamment possible de construire un modèle classique à partir d'un modèle prototypique.
 
-<h2 id="Héritage_et_chaîne_de_prototype">Héritage et chaîne de prototype</h2>
+## Héritage et chaîne de prototype
 
-<h3 id="Propriété_héritées">Propriété héritées</h3>
+### Propriété héritées
 
-<p>Les objets JavaScript sont des ensembles dynamiques de propriétés (les propriétés directement rattachées à un objet sont appelées <strong>propriétés en propre (<em>own properties</em>)</strong>). Les objets JavaScript possèdent également un lien vers un objet qui est leur prototype. Lorsqu'on tente d'accéder aux propriétés d'un objet, la propriété sera recherchée d'abord sur l'objet même, puis sur son prototype, puis sur le prototype du prototype et ainsi de suite jusqu'à ce qu'elle soit trouvée ou que la fin de la chaîne de prototype ait été atteinte.</p>
+Les objets JavaScript sont des ensembles dynamiques de propriétés (les propriétés directement rattachées à un objet sont appelées **propriétés en propre (_own properties_)**). Les objets JavaScript possèdent également un lien vers un objet qui est leur prototype. Lorsqu'on tente d'accéder aux propriétés d'un objet, la propriété sera recherchée d'abord sur l'objet même, puis sur son prototype, puis sur le prototype du prototype et ainsi de suite jusqu'à ce qu'elle soit trouvée ou que la fin de la chaîne de prototype ait été atteinte.
 
-<div class="note">
-<p><strong>Note :</strong> Dans la spécification ECMAScript, on utilise la notation <code>unObjet.[[Prototype]]</code> pour faire référence au prototype de <code>unObjet</code>. Depuis ECMAScript 2015, on peut accéder à <code>[[Prototype]]</code> grâce aux accesseurs {{jsxref("Object.getPrototypeOf()")}} et {{jsxref("Object.setPrototypeOf()")}}. Cela est équivalent à la propriété JavaScript <code>__proto__</code> qui était non-standard avant ES2015 mais qui était de fait implémentée par la majorité des navigateurs.</p>
+> **Note :** Dans la spécification ECMAScript, on utilise la notation `unObjet.[[Prototype]]` pour faire référence au prototype de `unObjet`. Depuis ECMAScript 2015, on peut accéder à `[[Prototype]]` grâce aux accesseurs {{jsxref("Object.getPrototypeOf()")}} et {{jsxref("Object.setPrototypeOf()")}}. Cela est équivalent à la propriété JavaScript `__proto__` qui était non-standard avant ES2015 mais qui était de fait implémentée par la majorité des navigateurs.
+>
+> Cette propriété ne devrait pas être confondue avec la propriété `func.prototype` des fonctions qui définissent le `[[Prototype]]` à affecter aux instances des objets créés par cette fonction lorsqu'elle est utilisée comme constructeur. La propriété **`Object.prototype`** représente le prototype de {{jsxref("Object")}}.
 
-<p>Cette propriété ne devrait pas être confondue avec la propriété <code><em>func</em>.prototype</code> des fonctions qui définissent le <code>[[Prototype]]</code> à affecter aux instances des objets créés par cette fonction lorsqu'elle est utilisée comme constructeur. La propriété <code><strong>Object.prototype</strong></code> représente le prototype de {{jsxref("Object")}}.</p>
-</div>
+Voici ce qui se produit lorsqu'on tente d'accéder à une propriété :
 
-<p>Voici ce qui se produit lorsqu'on tente d'accéder à une propriété :</p>
-
-<pre class="brush: js">// On commence par créer un objet o pour lequel la fonction f sera
+```js
+// On commence par créer un objet o pour lequel la fonction f sera
 // son constructeur et lui créera deux propriétés en propre
 // a et b :
 let f = function () {
@@ -57,7 +56,7 @@ f.prototype.c = 4;
 // On a alors atteint la fin de la chaîne de prototype car,
 // par définition, null n'a pas de [[Prototype]].
 // Ainsi, la chaîne complète est ici :
-// {a: 1, b: 2} ---&gt; {b: 3, c: 4} ---&gt; Object.prototype ---&gt; null
+// {a: 1, b: 2} ---> {b: 3, c: 4} ---> Object.prototype ---> null
 
 console.log(o.a); // 1
 // Existe-t-il une propriété 'a' en propre sur o ? Oui, elle vaut 1.
@@ -83,17 +82,18 @@ console.log(o.d); // undefined
 // de propriété 'd' par défaut. On vérifie son prototype.
 // o.[[Prototype]].[[Prototype]].[[Prototype]] est null, on arrête la recherche
 // aucune propriété n'est trouvée, le moteur renvoie undefined.
-</pre>
+```
 
-<p>Lorsquon définit une propriété sur un objet, cela définit une propriété en propre. La seule exception se produit lorsqu'on définit <a href="/fr/docs/Web/JavaScript/Guide/Utiliser_les_objets#Définir_des_accesseurs_et_des_mutateurs_(getters_et_setters)">un accesseur et/ou un mutateur</a> sur une propriété héritée.</p>
+Lorsquon définit une propriété sur un objet, cela définit une propriété en propre. La seule exception se produit lorsqu'on définit [un accesseur et/ou un mutateur](</fr/docs/Web/JavaScript/Guide/Utiliser_les_objets#Définir_des_accesseurs_et_des_mutateurs_(getters_et_setters)>) sur une propriété héritée.
 
-<h3 id="Méthodes_héritées">Méthodes héritées</h3>
+### Méthodes héritées
 
-<p>JavaScript ne possède pas de méthodes au sens des langages de classe. En effet, en JavaScript, toute fonction associée à un objet est également une propriété. Une fonction héritée se comportera comme n'importe quelle autre propriété (y compris pour l'ombrage mentionné ci-avant où on pourra parler de surcharge).</p>
+JavaScript ne possède pas de méthodes au sens des langages de classe. En effet, en JavaScript, toute fonction associée à un objet est également une propriété. Une fonction héritée se comportera comme n'importe quelle autre propriété (y compris pour l'ombrage mentionné ci-avant où on pourra parler de surcharge).
 
-<p>Lorsqu'une fonction héritée est exécutée, la valeur de <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_this"><code>this</code></a> pointe vers l'objet hérité et non vers l'objet prototype qui possède la fonction comme propriété en propre.</p>
+Lorsqu'une fonction héritée est exécutée, la valeur de [`this`](/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_this) pointe vers l'objet hérité et non vers l'objet prototype qui possède la fonction comme propriété en propre.
 
-<pre class="brush: js">var o = {
+```js
+var o = {
   a: 2,
   m: function() {
     return this.a + 1;
@@ -111,32 +111,30 @@ console.log(p.m()); // 5
 // lorsque p.m est appelée, 'this' fait référence à p.
 // Ainsi quand p hérite de m via o,
 // 'this.a' signifie p.a, soit la propriété 'a' de p
+```
 
+## Utiliser les prototypes avec JavaScript
 
-</pre>
-
-<h2 id="Utiliser_les_prototypes_avec_JavaScript">Utiliser les prototypes avec JavaScript</h2>
+Regardons un peu plus en détail ce qui se déroule en arrière-plan.
 
-<p>Regardons un peu plus en détail ce qui se déroule en arrière-plan.</p>
+> **Note :** Pour tous les exempls suivants, nous vous invitons à ouvrir la "console" de votre navigateur pour y copier/coller/éditer les fragments de code. Pour savoir comment lancer cette console, vous pouvez lire la documentation des navigateurs : [Firefox](/fr/docs/Tools), [Chrome](https://developers.google.com/web/tools/chrome-devtools/), [Edge](https://docs.microsoft.com/en-us/microsoft-edge/devtools-guide).
 
-<div class="blockIndicator note">
-<p><strong>Note :</strong> Pour tous les exempls suivants, nous vous invitons à ouvrir la "console" de votre navigateur pour y copier/coller/éditer les fragments de code. Pour savoir comment lancer cette console, vous pouvez lire la documentation des navigateurs : <a href="/fr/docs/Tools">Firefox</a>, <a href="https://developers.google.com/web/tools/chrome-devtools/">Chrome</a>, <a href="https://docs.microsoft.com/en-us/microsoft-edge/devtools-guide">Edge</a>.</p>
-</div>
+En JavaScript, comme mentionné ci-dessus, les fonctions peuvent avoir des propriétés. Toutes les fonctions ont une propriété spéciale intitulée `prototype`.
 
-<p>En JavaScript, comme mentionné ci-dessus, les fonctions peuvent avoir des propriétés. Toutes les fonctions ont une propriété spéciale intitulée <code>prototype</code>.</p>
-
-<pre class="brush: js">function faireUnTruc(){}
+```js
+function faireUnTruc(){}
 console.log( faireUnTruc.prototype ); // Object {...}
 // Peu importe comment vous déclarez la fonction.
 // une fonction en JavaScript aura toujours une propriété
 // prototype par défaut.
 var faireUnTruc= function(){};
 console.log(faireUnTruc.prototype); // Object {...}
-</pre>
+```
 
-<p>Comme mentionné avant, <code>faireUnTruc()</code> possède une propriété par défaut <code>prototype</code>. Après avoir exécuté ce code dans une console, la console devrait afficher un objet semblable à :</p>
+Comme mentionné avant, `faireUnTruc()` possède une propriété par défaut `prototype`. Après avoir exécuté ce code dans une console, la console devrait afficher un objet semblable à :
 
-<pre class="brush: js">{
+```js
+{
     constructor: ƒ faireUnTruc(),
     __proto__: {
         constructor: ƒ Object(),
@@ -147,17 +145,21 @@ console.log(faireUnTruc.prototype); // Object {...}
         toString: ƒ toString(),
         valueOf: ƒ valueOf()
     }
-}</pre>
+}
+```
 
-<p>On peut ajouter des propriétés au prototype de <code>faireUnTruc()</code> comme suit :</p>
+On peut ajouter des propriétés au prototype de `faireUnTruc()` comme suit :
 
-<pre class="brush: js">function faireUnTruc(){}
+```js
+function faireUnTruc(){}
 faireUnTruc.prototype.toto = "truc";
-console.log( faireUnTruc.prototype );</pre>
+console.log( faireUnTruc.prototype );
+```
 
-<p>Produira le résultat suivant :</p>
+Produira le résultat suivant :
 
-<pre class="brush: js">{
+```js
+{
     toto: "truc",
     constructor: ƒ faireUnTruc(),
     __proto__: {
@@ -170,21 +172,24 @@ console.log( faireUnTruc.prototype );</pre>
         valueOf: ƒ valueOf()
     }
 }
-</pre>
+```
 
-<p>On peut utiliser l'opérateur <code>new</code> afin de créer une instance de <code>faireUnTruc()</code> basée sur ce prototype. Pour utiliser l'opérateur <code>new</code>, il suffira d'appeler la fonction et de précéder cet appel avec le mot-clé <code>new</code>. Lorsqu'on appelle une fonction avec un opérateur <code>new</code>, celle-ci renvoie un objet qui est une instance de la fonction. On peut ensuite ajouter des propriétés sur cet objet.</p>
+On peut utiliser l'opérateur `new` afin de créer une instance de `faireUnTruc()` basée sur ce prototype. Pour utiliser l'opérateur `new`, il suffira d'appeler la fonction et de précéder cet appel avec le mot-clé `new`. Lorsqu'on appelle une fonction avec un opérateur `new`, celle-ci renvoie un objet qui est une instance de la fonction. On peut ensuite ajouter des propriétés sur cet objet.
 
-<p>Voyons le code qui suit :</p>
+Voyons le code qui suit :
 
-<pre class="brush: js">function faireUnTruc(){}
+```js
+function faireUnTruc(){}
 faireUnTruc.prototype.toto = "truc"; // on ajoute une propriété au prototype
 var uneInstance = new faireUnTruc();
 uneInstance.prop = "une valeur"; // on ajoute une propriété sur l'objet
-console.log(uneInstance);</pre>
+console.log(uneInstance);
+```
 
-<p>Exécuté, ce code produira le résultat suivant dans la console :</p>
+Exécuté, ce code produira le résultat suivant dans la console :
 
-<pre class="brush: js">{
+```js
+{
     prop: "une valeur",
     __proto__: {
         toto: "truc",
@@ -199,19 +204,21 @@ console.log(uneInstance);</pre>
             valueOf: ƒ valueOf()
         }
     }
-}</pre>
+}
+```
 
-<p>Comme nous l'avons vu avant, la valeur de <code>__proto__</code> pour <code>uneInstance</code> est <code>faireUnTruc.prototype</code>. Mais quel est l'intérêt ? Lorsqu'on accède à une propriété de <code>uneInstance</code>, le moteur contrôle d'abord si <code>uneInstance</code> possède cette propriété.</p>
+Comme nous l'avons vu avant, la valeur de `__proto__` pour `uneInstance` est `faireUnTruc.prototype`. Mais quel est l'intérêt ? Lorsqu'on accède à une propriété de `uneInstance`, le moteur contrôle d'abord si `uneInstance` possède cette propriété.
 
-<p>Si <code>uneInstance</code> ne possède pas cette propriété, le moteur contrôlera la propriété sur la propriété <code>__proto__</code> de <code>uneInstance</code> (c'est-à-dire <code>faireUnTruc.prototype</code>). Si la propriété <code>__proto__</code> de <code>uneInstance</code> possède la propriété qu'on recherche, ce sera celle-ci qui sera utilisée.</p>
+Si `uneInstance` ne possède pas cette propriété, le moteur contrôlera la propriété sur la propriété `__proto__` de `uneInstance` (c'est-à-dire `faireUnTruc.prototype`). Si la propriété `__proto__` de `uneInstance` possède la propriété qu'on recherche, ce sera celle-ci qui sera utilisée.
 
-<p>Si <code>__proto__</code> de <code>unTruc</code> ne possède pas la propriété recherchée, le moteur contrôle la propriété <code>__proto__</code> de la propriété <code>__proto__</code> de <code>uneInstance</code>. Par défaut, la propriété <code>__proto__</code> de n'importe quel propriété <code>prototype</code>d'une fonction est  <code>window.Object.prototype</code>. Ainsi, la propriété <code>__proto__</code> de la propriété <code>__proto__</code> de  <code>uneInstance</code> (c'est-à-dire <code>__proto__</code> de <code>faireUnTruc.prototype</code> (c'est-à-dire. <code>Object.prototype</code>)) est contrôlée pour vérifier si la propriété y est présente.</p>
+Si `__proto__` de `unTruc` ne possède pas la propriété recherchée, le moteur contrôle la propriété `__proto__` de la propriété `__proto__` de `uneInstance`. Par défaut, la propriété `__proto__` de n'importe quel propriété `prototype`d'une fonction est  `window.Object.prototype`. Ainsi, la propriété `__proto__` de la propriété `__proto__` de  `uneInstance` (c'est-à-dire `__proto__` de `faireUnTruc.prototype` (c'est-à-dire. `Object.prototype`)) est contrôlée pour vérifier si la propriété y est présente.
 
-<p>Si la propriété n'est pas trouvée sur la propriété <code>__proto__</code> de la propriété <code>__proto__</code> de <code>uneInstance</code>, c'est la proriété <code>__proto__</code> de la propriété <code>__proto__</code> de la propriété <code>__proto__</code> de <code>uneInstance</code> qui est contrôlée. Cependant il y a un problème car la propriété <code>__proto__</code> de la propriété <code>__proto__</code> de la propriété <code>__proto__</code> de <code>unTruc</code> n'existe pas. Autrement dit, toute la chaîne de prototype a été parcouru et on ne peut pas remonter d'un cran sur un autre <code>__proto__</code> et le moteur peut conclure que la propriété n'existe pas pour cet objet et renvoyer <code>undefined</code>.</p>
+Si la propriété n'est pas trouvée sur la propriété `__proto__` de la propriété `__proto__` de `uneInstance`, c'est la proriété `__proto__` de la propriété `__proto__` de la propriété `__proto__` de `uneInstance` qui est contrôlée. Cependant il y a un problème car la propriété `__proto__` de la propriété `__proto__` de la propriété `__proto__` de `unTruc` n'existe pas. Autrement dit, toute la chaîne de prototype a été parcouru et on ne peut pas remonter d'un cran sur un autre `__proto__` et le moteur peut conclure que la propriété n'existe pas pour cet objet et renvoyer `undefined`.
 
-<p>Regardons ce qui se produit dans la console avec un peu de code :</p>
+Regardons ce qui se produit dans la console avec un peu de code :
 
-<pre class="brush: js">function faireUnTruc(){}
+```js
+function faireUnTruc(){}
 faireUnTruc.prototype.toto = "truc";
 var uneInstance = new faireUnTruc();
 uneInstance.prop = "une valeur";
@@ -220,36 +227,40 @@ console.log("uneInstance.toto: " + uneInstance.toto);
 console.log("faireUnTruc.prop: " + faireUnTruc.prop);
 console.log("faireUnTruc.toto: " + faireUnTruc.toto);
 console.log("faireUnTruc.prototype.prop: " + faireUnTruc.prototype.prop);
-console.log("faireUnTruc.prototype.toto:  " + faireUnTruc.prototype.toto);</pre>
+console.log("faireUnTruc.prototype.toto:  " + faireUnTruc.prototype.toto);
+```
 
-<p>Le résultat est le suivant :</p>
+Le résultat est le suivant :
 
-<pre class="brush: js">uneInstance.prop: une valeur
+```js
+uneInstance.prop: une valeur
 uneInstance.toto: truc
 faireUnTruc.prop: undefined
 faireUnTruc.toto: undefined
 faireUnTruc.prototype.prop: undefined
-faireUnTruc.prototype.toto: truc</pre>
+faireUnTruc.prototype.toto: truc
+```
 
-<h2 id="Les_différentes_façons_de_créer_des_objets_et_les_impacts_sur_la_chaîne_de_prototype">Les différentes façons de créer des objets et les impacts sur la chaîne de prototype</h2>
+## Les différentes façons de créer des objets et les impacts sur la chaîne de prototype
 
-<h3 id="Objets_créés_avec_les_raccourcis_syntaxiques_littéraux">Objets créés avec les raccourcis syntaxiques (littéraux)</h3>
+### Objets créés avec les raccourcis syntaxiques (littéraux)
 
-<pre class="brush: js">var o = {a: 1};
+```js
+var o = {a: 1};
 
 // Le nouvel objet possède Object.prototype comme [[Prototype]]
 // o ne possède pas de propriété 'hasOwnProperty' en propre
 // hasOwnProperty est une propriété en propre de Object.prototype.
 // o hérite de hasOwnProperty via Object.prototype
 // Object.prototype possède null comme prototype.
-// o ---&gt; Object.prototype ---&gt; null
+// o ---> Object.prototype ---> null
 
 var b = ['coucou', 'ça va', '?'];
 
 // Les tableaux (Array) héritent de Array.prototype
 // (qui possède les méthodes indexOf, forEach, etc.)
 // La chaîne de prototype est donc :
-// b ---&gt; Array.prototype ---&gt; Object.prototype ---&gt; null
+// b ---> Array.prototype ---> Object.prototype ---> null
 
 function f() {
   return 2;
@@ -258,14 +269,15 @@ function f() {
 // Les fonctions héritent de Function.prototype
 // (qui possède les méthodes call, bind, etc.)
 // La chaîne de prototype est donc
-// f ---&gt; Function.prototype ---&gt; Object.prototype ---&gt; null
-</pre>
+// f ---> Function.prototype ---> Object.prototype ---> null
+```
 
-<h3 id="Objets_créés_avec_un_constructeur">Objets créés avec un constructeur</h3>
+### Objets créés avec un constructeur
 
-<p>En JavaScript, un constructeur est <em>juste</em> une fonction que l'on invoque avec l'opérateur <code><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_new">new</a></code>.</p>
+En JavaScript, un constructeur est _juste_ une fonction que l'on invoque avec l'opérateur [`new`](/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_new).
 
-<pre class="brush: js">function Graphe() {
+```js
+function Graphe() {
   this.sommets = [];
   this.arêtes = [];
 }
@@ -279,33 +291,35 @@ Graphe.prototype = {
 var g = new Graphe();
 // g est un objet qui possède les propriétés 'sommets' and 'arêtes' en propre.
 // g.[[Prototype]] est la valeur de Graphe.prototype lorsque "new Graphe()" est exécuté.
-</pre>
+```
 
-<h3 id="Objets_créés_avec_Object.create">Objets créés avec <code>Object.create()</code></h3>
+### Objets créés avec `Object.create()`
 
-<p>ECMAScript 5 a introduit une nouvelle méthode : {{jsxref("Object.create()")}}. Appeler cette méthode crée un nouvel objet et le prototype de cet objet est le premier argument de cette fonction :</p>
+ECMAScript 5 a introduit une nouvelle méthode : {{jsxref("Object.create()")}}. Appeler cette méthode crée un nouvel objet et le prototype de cet objet est le premier argument de cette fonction :
 
-<pre class="brush: js">var a = {a: 1};
-// a ---&gt; Object.prototype ---&gt; null
+```js
+var a = {a: 1};
+// a ---> Object.prototype ---> null
 
 var b = Object.create(a);
-// b ---&gt; a ---&gt; Object.prototype ---&gt; null
+// b ---> a ---> Object.prototype ---> null
 console.log(b.a); // 1 (héritée)
 
 var c = Object.create(b);
-// c ---&gt; b ---&gt; a ---&gt; Object.prototype ---&gt; null
+// c ---> b ---> a ---> Object.prototype ---> null
 
 var d = Object.create(null);
-// d ---&gt; null
+// d ---> null
 console.log(d.hasOwnProperty);
 // undefined, car d n'hérite pas de Object.prototype
-</pre>
+```
 
-<h4 id="Suppression_des_propriétés_avec_delete">Suppression des propriétés avec <code>delete</code></h4>
+#### Suppression des propriétés avec `delete`
 
-<p>L'opérateur <code><a href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/L_op%C3%A9rateur_delete">delete</a></code> permet de supprimer une propriété directement rattachée à un objet. En revanche, il n'empêchera pas l'exploration de la chaîne de prototype :</p>
+L'opérateur [`delete`](/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/L_op%C3%A9rateur_delete) permet de supprimer une propriété directement rattachée à un objet. En revanche, il n'empêchera pas l'exploration de la chaîne de prototype :
 
-<pre class="brush: js">let a = {toto: 1};
+```js
+let a = {toto: 1};
 let b = Object.create(a);
 
 console.log(b.toto); // Affiche 1 car c'est une propriété disponible via le prototype
@@ -314,13 +328,15 @@ console.log(b.toto); // Affiche 5, désormais cette propriété existe sur l'obj
 
 delete b.toto;
 console.log(b.toto); // Affiche 1 : la propriété n'est plus disponible sur l'objet mais
-                     // on peut toujours la récupérer via le prototype</pre>
+                     // on peut toujours la récupérer via le prototype
+```
 
-<h3 id="Objets_créés_avec_le_mot-clé_class">Objets créés avec le mot-clé <code>class</code></h3>
+### Objets créés avec le mot-clé `class`
 
-<p>ECMAScript 2015 introduit plusieurs mots-clés destinés à créer du sucre syntaxique pour manipuler des <a href="/fr/docs/Web/JavaScript/Reference/Classes">classes</a>. Ces mots-clés sont {{jsxref("Instructions/class", "class")}}, {{jsxref("Classes/constructor", "constructor")}}, {{jsxref("Classes/static", "static")}}, {{jsxref("Classes/extends", "extends")}} et {{jsxref("Opérateurs/super", "super")}}.</p>
+ECMAScript 2015 introduit plusieurs mots-clés destinés à créer du sucre syntaxique pour manipuler des [classes](/fr/docs/Web/JavaScript/Reference/Classes). Ces mots-clés sont {{jsxref("Instructions/class", "class")}}, {{jsxref("Classes/constructor", "constructor")}}, {{jsxref("Classes/static", "static")}}, {{jsxref("Classes/extends", "extends")}} et {{jsxref("Opérateurs/super", "super")}}.
 
-<pre class="brush: js">'use strict';
+```js
+'use strict';
 
 class Polygone {
   constructor(hauteur, largeur) {
@@ -343,15 +359,16 @@ class Carré extends Polygone {
 }
 
 var carré = new Carré(2);
-</pre>
+```
 
-<h3 id="Performance">Performance</h3>
+### Performance
 
-<p>Le temps de recherche des propriétés sera plus élevé si ces propriétés sont situées plus loin dans la chaîne de prototype. Tenter d'accéder à ces propriétés éloignées pourra avoir un impact négatif sur les performances. De plus, tenter d'accéder à des propriétés inexistantes entraîntera toujours le parcours de l'ensemble de la chaîne de prototype.</p>
+Le temps de recherche des propriétés sera plus élevé si ces propriétés sont situées plus loin dans la chaîne de prototype. Tenter d'accéder à ces propriétés éloignées pourra avoir un impact négatif sur les performances. De plus, tenter d'accéder à des propriétés inexistantes entraîntera toujours le parcours de l'ensemble de la chaîne de prototype.
 
-<p>Lorsqu'on parcourt les propriétés d'un objet, <strong>toutes</strong> les propriétés énumérables situées sur la chaîne de prototype seront parcourues. Pour vérifier si un objet possède une propriété en propre plus que via sa chaîne de prototype, on devra utiliser la méthode <a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object/hasOwnProperty"><code>hasOwnProperty()</code></a> qui est héritée grâce à <code>Object.prototype</code>. Prenons un exemple concret avec le cas du graphe traité dans un exemple précédent :</p>
+Lorsqu'on parcourt les propriétés d'un objet, **toutes** les propriétés énumérables situées sur la chaîne de prototype seront parcourues. Pour vérifier si un objet possède une propriété en propre plus que via sa chaîne de prototype, on devra utiliser la méthode [`hasOwnProperty()`](/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object/hasOwnProperty) qui est héritée grâce à `Object.prototype`. Prenons un exemple concret avec le cas du graphe traité dans un exemple précédent :
 
-<pre class="brush: js">console.log(g.hasOwnProperty('arêtes'));
+```js
+console.log(g.hasOwnProperty('arêtes'));
 // true
 
 console.log(g.hasOwnProperty('nononon'));
@@ -362,36 +379,34 @@ console.log(g.hasOwnProperty('ajoutSommet'));
 
 console.log(g.__proto__.hasOwnProperty('ajoutSommet'));
 // true
-</pre>
+```
 
-<div class="blockIndicator note">
-<p><strong>Note :</strong> Tester si une propriété vaut {{jsxref("undefined")}} ne suffit pas à vérifier la présence de la propriété sur un objet : une propriété peut très bien exister sur un objet mais valoir <code>undefined</code>.</p>
-</div>
+> **Note :** Tester si une propriété vaut {{jsxref("undefined")}} ne suffit pas à vérifier la présence de la propriété sur un objet : une propriété peut très bien exister sur un objet mais valoir `undefined`.
 
-<h3 id="Mauvaise_pratique_étendre_les_prototypes_natifs">Mauvaise pratique : étendre les prototypes natifs</h3>
+### Mauvaise pratique : étendre les prototypes natifs
 
-<p>On peut parfois voir du code qui étend <code>Object.prototype</code> ou l'un des prototypes natifs.</p>
+On peut parfois voir du code qui étend `Object.prototype` ou l'un des prototypes natifs.
 
-<p>Cette technique est intitulée <em>monkey patching </em>et brise l'encapsulation. Bien qu'elle soit utilisée par certains <em>frameworks</em>, il n'existe pas de raison suffisante pour étendre les objets natifs avec des fonctionnalités non-standard.</p>
+Cette technique est intitulée _monkey patching_ et brise l'encapsulation. Bien qu'elle soit utilisée par certains _frameworks_, il n'existe pas de raison suffisante pour étendre les objets natifs avec des fonctionnalités non-standard.
 
-<p>La<strong> seule</strong> raison qui peut prévaloir pour l'extension de prototypes natifs est l'ajout de fonctionnalités JavaScript apparues avec les nouvelles versions des spécifications et moteurs afin d'en disposer dans de plus anciens environnements.</p>
+La **seule** raison qui peut prévaloir pour l'extension de prototypes natifs est l'ajout de fonctionnalités JavaScript apparues avec les nouvelles versions des spécifications et moteurs afin d'en disposer dans de plus anciens environnements.
 
-<h3 id="Résumé_des_méthodes_pour_étendre_la_chaîne_de_prototype">Résumé des méthodes pour étendre la chaîne de prototype</h3>
+### Résumé des méthodes pour étendre la chaîne de prototype
 
-<p>Voici un tableau avec les quatre outils qui permettent d'étendre une chaîne de prototypes avec chacun leurs avantages et leurs inconvénients. Tous les exemples mentionnés permettent de créer le même objet <code>inst</code> (et affichant donc le même résultat dans la console) mais de façon différente.</p>
+Voici un tableau avec les quatre outils qui permettent d'étendre une chaîne de prototypes avec chacun leurs avantages et leurs inconvénients. Tous les exemples mentionnés permettent de créer le même objet `inst` (et affichant donc le même résultat dans la console) mais de façon différente.
 
 <table class="standard-table">
- <tbody>
-  <tr>
-   <td style="width: 1%;">Nom</td>
-   <td>Exemples</td>
-   <td>Avantages</td>
-   <td style="vertical-align: top; width: 60%;">Inconvénients</td>
-  </tr>
-  <tr>
-   <td>Initialisation</td>
-   <td>
-    <pre class="brush: js">
+  <tbody>
+    <tr>
+      <td style="width: 1%">Nom</td>
+      <td>Exemples</td>
+      <td>Avantages</td>
+      <td style="vertical-align: top; width: 60%">Inconvénients</td>
+    </tr>
+    <tr>
+      <td>Initialisation</td>
+      <td>
+        <pre class="brush: js">
 function toto(){}
 toto.prototype = {
   toto_prop: "toto val"
@@ -403,23 +418,35 @@ truc.prototype = proto;
 var inst = new truc();
 console.log(inst.toto_prop);
 console.log(inst.truc_prop);
-</pre>
-   </td>
-   <td style="vertical-align: top;">Prise en charge par l'ensemble des navigateurs. Cette méthode est très rapide, standard et facilement optimisable.</td>
-   <td>
-    <p>Afin d'utiliser cette méthode, il faut que la fonction ait été initialisée. Pendant cette initialisation, le constructeur peut enregistrer des informations uniques qui doivent être générées pour chaque objet.</p>
-
-    <p>Toutefois, il est possible que ces informations uniques ne soient générées qu'une seule fois.</p>
-
-    <p>De plus, l'initialisation du constructeur peut ajouter des méthodes non souhaitées sur l'objet.</p>
-
-    <p>Cela dit, ces problèmes ne se révèlent que rarement.</p>
-   </td>
-  </tr>
-  <tr>
-   <td><code>Object.create()</code></td>
-   <td style="vertical-align: top;">
-    <pre class="brush: js">
+</pre
+        >
+      </td>
+      <td style="vertical-align: top">
+        Prise en charge par l'ensemble des navigateurs. Cette méthode est très
+        rapide, standard et facilement optimisable.
+      </td>
+      <td>
+        <p>
+          Afin d'utiliser cette méthode, il faut que la fonction ait été
+          initialisée. Pendant cette initialisation, le constructeur peut
+          enregistrer des informations uniques qui doivent être générées pour
+          chaque objet.
+        </p>
+        <p>
+          Toutefois, il est possible que ces informations uniques ne soient
+          générées qu'une seule fois.
+        </p>
+        <p>
+          De plus, l'initialisation du constructeur peut ajouter des méthodes
+          non souhaitées sur l'objet.
+        </p>
+        <p>Cela dit, ces problèmes ne se révèlent que rarement.</p>
+      </td>
+    </tr>
+    <tr>
+      <td><code>Object.create()</code></td>
+      <td style="vertical-align: top">
+        <pre class="brush: js">
 function toto(){}
 toto.prototype = {
   toto_prop: "toto val"
@@ -433,9 +460,9 @@ truc.prototype = proto;
 var inst = new truc();
 console.log(inst.toto_prop);
 console.log(inst.truc_prop);
-</pre>
-
-    <pre class="brush: js">
+</pre
+        >
+        <pre class="brush: js">
 function toto(){}
 toto.prototype = {
   toto_prop: "toto val"
@@ -452,21 +479,37 @@ var proto = Object.create(
 truc.prototype = proto;
 var inst = new truc();
 console.log(inst.toto_prop);
-console.log(inst.truc_prop)</pre>
-   </td>
-   <td>Prise en charge par la majorité des navigateurs actuels. Elle permet de définir directement <code>__proto__</code> en une seule fois et le navigateur peut mieux optimiser l'objet. Elle permet aussi de créer des objets sans prototype avec <code>Object.create(null)</code>.</td>
-   <td style="vertical-align: top;">
-    <p>Cette méthode n'est pas prise en charge par IE8 et les versions antérieures. Toutefois, Microsoft ayant mis un terme au support des systèmes qui utilisent ces navigateurs, ce ne devrait pas être un problème pour la plupart des navigation.</p>
-
-    <p>De plus, la lenteur de l'initialisation de l'objet peut être causer des soucis de performances lorsqu'on utilise un deuxième argument car descripteur de propriété possède un objet rattaché. Lorsqu'on gère des centaines de milliers de descripteurs, cela peut entraîner un certain <em>lag</em>.</p>
-   </td>
-  </tr>
-  <tr>
-   <td>
-    <p><code>Object.setPrototypeOf()</code></p>
-   </td>
-   <td>
-    <pre class="brush: js">
+console.log(inst.truc_prop)</pre
+        >
+      </td>
+      <td>
+        Prise en charge par la majorité des navigateurs actuels. Elle permet de
+        définir directement <code>__proto__</code> en une seule fois et le
+        navigateur peut mieux optimiser l'objet. Elle permet aussi de créer des
+        objets sans prototype avec <code>Object.create(null)</code>.
+      </td>
+      <td style="vertical-align: top">
+        <p>
+          Cette méthode n'est pas prise en charge par IE8 et les versions
+          antérieures. Toutefois, Microsoft ayant mis un terme au support des
+          systèmes qui utilisent ces navigateurs, ce ne devrait pas être un
+          problème pour la plupart des navigation.
+        </p>
+        <p>
+          De plus, la lenteur de l'initialisation de l'objet peut être causer
+          des soucis de performances lorsqu'on utilise un deuxième argument car
+          descripteur de propriété possède un objet rattaché. Lorsqu'on gère des
+          centaines de milliers de descripteurs, cela peut entraîner un certain
+          <em>lag</em>.
+        </p>
+      </td>
+    </tr>
+    <tr>
+      <td>
+        <p><code>Object.setPrototypeOf()</code></p>
+      </td>
+      <td>
+        <pre class="brush: js">
 function toto(){}
 toto.prototype = {
   toto_prop: "toto val"
@@ -482,9 +525,9 @@ truc.prototype = proto;
 var inst = new truc();
 console.log(inst.toto_prop);
 console.log(inst.truc_prop);
-</pre>
-
-    <pre class="brush: js">
+</pre
+        >
+        <pre class="brush: js">
 function toto(){}
 toto.prototype = {
   toto_prop: "toto val"
@@ -498,15 +541,27 @@ proto=Object.setPrototypeOf(
 truc.prototype = proto;
 var inst = new truc();
 console.log(inst.toto_prop);
-console.log(inst.truc_prop)</pre>
-   </td>
-   <td style="vertical-align: top;">Prise en charge par l'ensemble des navigateurs actuels. Elle permet de manipuler dynamiquement le prototype d'un objet et également de rattacher un prototype à un objet qui n'aurait pas de prototype.</td>
-   <td>Cette méthode devrait être dépréciée et possède des performances faibles. En effet, les moteurs tenteront d'optimiser la connaissance de la structure du prototype et cette méthode viendra à l'enconte de ces hypothèses et certains navigateurs pourront même recompiler le code pour le faire fonctionner selon les spécifications. Cette méthode n'est pas prise en charge par IE8 et les versions antérieures.</td>
-  </tr>
-  <tr>
-   <td><code>__proto__</code></td>
-   <td style="vertical-align: top;">
-    <pre class="brush: js">
+console.log(inst.truc_prop)</pre
+        >
+      </td>
+      <td style="vertical-align: top">
+        Prise en charge par l'ensemble des navigateurs actuels. Elle permet de
+        manipuler dynamiquement le prototype d'un objet et également de
+        rattacher un prototype à un objet qui n'aurait pas de prototype.
+      </td>
+      <td>
+        Cette méthode devrait être dépréciée et possède des performances
+        faibles. En effet, les moteurs tenteront d'optimiser la connaissance de
+        la structure du prototype et cette méthode viendra à l'enconte de ces
+        hypothèses et certains navigateurs pourront même recompiler le code pour
+        le faire fonctionner selon les spécifications. Cette méthode n'est pas
+        prise en charge par IE8 et les versions antérieures.
+      </td>
+    </tr>
+    <tr>
+      <td><code>__proto__</code></td>
+      <td style="vertical-align: top">
+        <pre class="brush: js">
 function toto(){}
 toto.prototype = {
   toto_prop: "toto val"
@@ -520,9 +575,9 @@ truc.prototype = proto;
 var inst = new truc();
 console.log(inst.toto_prop);
 console.log(inst.truc_prop);
-</pre>
-
-    <pre class="brush: js">
+</pre
+        >
+        <pre class="brush: js">
 var inst = {
   __proto__: {
     truc_prop: "truc val",
@@ -533,42 +588,59 @@ var inst = {
   }
 };
 console.log(inst.toto_prop);
-console.log(inst.truc_prop)</pre>
-   </td>
-   <td>Prise en charge par l'ensemble des navigateurs actuels (y compris IE11 et ultérieurs). Défiinir __proto__ sur quelque chose qui n'est pas un objet échouera silencieusement.</td>
-   <td>Cette méthode est dépréciée et n'est pas performante car les moteurs tentent d'optimiser les prototypes. Aussi, le modifier ainsi dynamiquement bloque ces optimisations et peut causer la recompilation du code pour qu'il fonctionne selon les spécifications. Cette méthode n'est pas prise en charge par IE10 et les versions antérieures.</td>
-  </tr>
- </tbody>
+console.log(inst.truc_prop)</pre
+        >
+      </td>
+      <td>
+        Prise en charge par l'ensemble des navigateurs actuels (y compris IE11
+        et ultérieurs). Défiinir __proto__ sur quelque chose qui n'est pas un
+        objet échouera silencieusement.
+      </td>
+      <td>
+        Cette méthode est dépréciée et n'est pas performante car les moteurs
+        tentent d'optimiser les prototypes. Aussi, le modifier ainsi
+        dynamiquement bloque ces optimisations et peut causer la recompilation
+        du code pour qu'il fonctionne selon les spécifications. Cette méthode
+        n'est pas prise en charge par IE10 et les versions antérieures.
+      </td>
+    </tr>
+  </tbody>
 </table>
 
-<h2 id="prototype_et_Object.getPrototypeOf"><code>prototype</code> et <code>Object.getPrototypeOf()</code></h2>
+## `prototype` et `Object.getPrototypeOf()`
 
-<p>JavaScript peut prêter à confusion pour les développeurs utilisant Java ou C++. JavaScript est un langage dynamique et les structures peuvent évoluer lors de l'exécution.</p>
+JavaScript peut prêter à confusion pour les développeurs utilisant Java ou C++. JavaScript est un langage dynamique et les structures peuvent évoluer lors de l'exécution.
 
-<p>Vous avez peut-être remarqué que la fonction <code>A</code> possède une propriété spéciale intitulée <code>prototype</code>. Cette propriété spéciale fonctionne avec l'opérateur <code>new</code> Elle permet de copier la référence  l'objet prototype sur la propriété interne <code>[[Prototype]]</code> de la nouvelle instance créée. Ainsi, avec <code>var a1 = new A()</code>, Le moteur JavaScript définira <code>a1.[[Prototype]] = A.prototype</code>. Quand on tente d'accéder à une des propriétés de l'instance, JavaScript vérifie la présence sur l'instance puis analyse son prototype <code>[[Prototype]]</code>. Cela signifie que tout ce qui est défini sur <code>prototype</code> est effectivement partagé par l'ensemble des instances et on peut même modifier <code>prototype</code> en cours de route afin de modifier indirectement l'ensemble des instances.</p>
+Vous avez peut-être remarqué que la fonction `A` possède une propriété spéciale intitulée `prototype`. Cette propriété spéciale fonctionne avec l'opérateur `new` Elle permet de copier la référence  l'objet prototype sur la propriété interne `[[Prototype]]` de la nouvelle instance créée. Ainsi, avec `var a1 = new A()`, Le moteur JavaScript définira `a1.[[Prototype]] = A.prototype`. Quand on tente d'accéder à une des propriétés de l'instance, JavaScript vérifie la présence sur l'instance puis analyse son prototype `[[Prototype]]`. Cela signifie que tout ce qui est défini sur `prototype` est effectivement partagé par l'ensemble des instances et on peut même modifier `prototype` en cours de route afin de modifier indirectement l'ensemble des instances.
 
-<p>Dans l'exemple précédent, si on avait eu <code>var a1 = new A(); var a2 = new A();</code> alors <code>a1.faireUnTruc</code> aurait fait référence à <code>Object.getPrototypeOf(a1).faireUntruc</code> qui est identique à <code>A.prototype.faireUnTruc</code>. Autrement dit <code>Object.getPrototypeOf(a1).faireUnTruc == Object.getPrototypeOf(a2).faireUnTruc == A.prototype.faireUnTruc</code>.</p>
+Dans l'exemple précédent, si on avait eu `var a1 = new A(); var a2 = new A();` alors `a1.faireUnTruc` aurait fait référence à `Object.getPrototypeOf(a1).faireUntruc` qui est identique à `A.prototype.faireUnTruc`. Autrement dit `Object.getPrototypeOf(a1).faireUnTruc == Object.getPrototypeOf(a2).faireUnTruc == A.prototype.faireUnTruc`.
 
-<p>Autrement dit <code>prototype</code> peut être utilisé pour les types et <code>Object.getPrototypeOf()</code> pour les instances.</p>
+Autrement dit `prototype` peut être utilisé pour les types et `Object.getPrototypeOf()` pour les instances.
 
-<p><code>[[Prototype]]</code> est analysé de façon récursive. Ainsi, <code>a1.faireUnTruc</code> correspondra à chercher <code>Object.getPrototypeOf(a1).faireUnTruc</code> puis <code>Object.getPrototypeOf(Object.getPrototypeOf(a1)).faireUnTruc</code> etc., jusqu'à ce qu'elle soit trouvée ou que <code>Object.getPrototypeOf</code>renvoie <code>null</code>.</p>
+`[[Prototype]]` est analysé de façon récursive. Ainsi, `a1.faireUnTruc` correspondra à chercher `Object.getPrototypeOf(a1).faireUnTruc` puis `Object.getPrototypeOf(Object.getPrototypeOf(a1)).faireUnTruc` etc., jusqu'à ce qu'elle soit trouvée ou que `Object.getPrototypeOf`renvoie `null`.
 
-<p>Ainsi, quand on appelle :</p>
+Ainsi, quand on appelle :
 
-<pre class="brush: js">var o = new Toto();</pre>
+```js
+var o = new Toto();
+```
 
-<p>Le moteur JavaScript effectue les étapes suivantes :</p>
+Le moteur JavaScript effectue les étapes suivantes :
 
-<pre class="brush: js">var o = new Object();
+```js
+var o = new Object();
 o.[[Prototype]] = Toto.prototype;
-Toto.call(o);</pre>
+Toto.call(o);
+```
 
-<p>(ou quelque chose qui y ressemble) et si on écrit ensuite :</p>
+(ou quelque chose qui y ressemble) et si on écrit ensuite :
 
-<pre class="brush: js">o.unePropriété;</pre>
+```js
+o.unePropriété;
+```
 
-<p>Le moteur vérifie si <code>o</code> possède une propriété <code>unePropriété</code> en propre. Si ce n'est pas le cas, il vérifie <code>Object.getPrototypeOf(o).unePropriété</code> et ainsi de suite.</p>
+Le moteur vérifie si `o` possède une propriété `unePropriété` en propre. Si ce n'est pas le cas, il vérifie `Object.getPrototypeOf(o).unePropriété` et ainsi de suite.
 
-<h2 id="Conclusion">Conclusion</h2>
+## Conclusion
 
-<p>Il est essentiel de comprendre le modèle d'héritage prototypique avant d'écrire du code complexe qui repose sur ces notions. Il est également préférable d'avoir une idée de la longueur de la chaîne de prototype utilisée pour les différents objets et de fragmenter cette chaîne si besoin afin d'éviter des écueils de performances. Enfin, on veillera à ne pas étendre les prototypes natifs sauf afin d'émuler des nouvelles fonctionnalités qui ne seraient pas disponibles dans l'environnement utilisé.</p>
+Il est essentiel de comprendre le modèle d'héritage prototypique avant d'écrire du code complexe qui repose sur ces notions. Il est également préférable d'avoir une idée de la longueur de la chaîne de prototype utilisée pour les différents objets et de fragmenter cette chaîne si besoin afin d'éviter des écueils de performances. Enfin, on veillera à ne pas étendre les prototypes natifs sauf afin d'émuler des nouvelles fonctionnalités qui ne seraient pas disponibles dans l'environnement utilisé.
diff --git a/files/fr/web/javascript/javascript_technologies_overview/index.md b/files/fr/web/javascript/javascript_technologies_overview/index.md
index 7e9491ec06..95e2f5bcd5 100644
--- a/files/fr/web/javascript/javascript_technologies_overview/index.md
+++ b/files/fr/web/javascript/javascript_technologies_overview/index.md
@@ -7,79 +7,73 @@ tags:
   - JavaScript
 translation_of: Web/JavaScript/JavaScript_technologies_overview
 ---
-<div>{{JsSidebar("Introductory")}}</div>
+{{JsSidebar("Introductory")}}
 
-<h2 id="Introduction">Introduction</h2>
+## Introduction
 
-<p><a href="/fr/docs/Web/HTML">HTML</a> est utilisé pour définir la structure et le contenu d'une page web, <a href="/fr/docs/Web/CSS">CSS</a> permet de définir la mise en forme, le style graphique avec lequel afficher le contenu. <a href="/fr/docs/Web/JavaScript">JavaScript</a> permet quant à lui d'ajouter des fonctionnalités d'interaction pour créer des applications web riches en contenu.</p>
+[HTML](/fr/docs/Web/HTML) est utilisé pour définir la structure et le contenu d'une page web, [CSS](/fr/docs/Web/CSS) permet de définir la mise en forme, le style graphique avec lequel afficher le contenu. [JavaScript](/fr/docs/Web/JavaScript) permet quant à lui d'ajouter des fonctionnalités d'interaction pour créer des applications web riches en contenu.
 
-<p>Cependant, le terme « JavaScript » au sens large regroupe divers éléments très différents : le langage cœur (ECMAScript) d'une part et les <a href="/fr/docs/Web/Reference/API">API Web</a> d'autre part et notamment le DOM (Document Object Model, ou Modèle d'Objet du Document).</p>
+Cependant, le terme « JavaScript » au sens large regroupe divers éléments très différents : le langage cœur (ECMAScript) d'une part et les [API Web](/fr/docs/Web/Reference/API) d'autre part et notamment le DOM (Document Object Model, ou Modèle d'Objet du Document).
 
-<h2 id="JavaScript_le_langage_(ECMAScript)">JavaScript, le langage (ECMAScript)</h2>
+## JavaScript, le langage (ECMAScript)
 
-<p>Le langage JavaScript (au sens strict) est standardisé par le comité ECMA TC39 sous la forme d'un langage intitulé <a href="/fr/docs/Web/JavaScript/Language_Resources">ECMAScript</a>.</p>
+Le langage JavaScript (au sens strict) est standardisé par le comité ECMA TC39 sous la forme d'un langage intitulé [ECMAScript](/fr/docs/Web/JavaScript/Language_Resources).
 
-<p>Ce langage est aussi utilisé dans des environnements différents des navigateurs web, comme par exemple dans <a href="https://nodejs.org/">node.js</a>.</p>
+Ce langage est aussi utilisé dans des environnements différents des navigateurs web, comme par exemple dans [node.js](https://nodejs.org/).
 
-<h3 id="Quelles_sont_les_caractéristiques_d'ECMAScript">Quelles sont les caractéristiques d'ECMAScript?</h3>
+### Quelles sont les caractéristiques d'ECMAScript?
 
-<p>Entre autres choses, ECMAScript définit :</p>
+Entre autres choses, ECMAScript définit :
 
-<ul>
- <li><a href="/fr/docs/Web/JavaScript/Reference/Grammaire_lexicale">La syntaxe du langage</a> (règles d'interprétation (parsing), mots-clés, flux d'instructions, initialisation littérale d'objets...)</li>
- <li>Le mécanisme de traitement d'erreurs ({{jsxref("Instructions/throw","throw")}}, {{jsxref("Instructions/try...catch","try...catch")}} capacité qu'a l'utilisateur de créer des types d'erreurs personnalisés)</li>
- <li>Les types de variables (booléen, nombre, chaîne de caractères, fonction, objet...)</li>
- <li>L'objet global. Dans l'environnement d'un navigateur, cet objet global est l'objet {{domxref("Window","window")}}. ECMAScript ne définit ici que les API accessibles depuis l'objet global (peu importe l'environnement qui peut être différent d'un navigateur) (par exemple {{jsxref("parseInt","parseInt()")}}, {{jsxref("parseFloat","parseFloat()")}}, {{jsxref("decodeURI","decodeURI()")}}, {{jsxref("encodeURI","encodeURI()")}}...)</li>
- <li><a href="/fr/docs/Web/JavaScript/Guide/Inheritance_and_the_prototype_chain">Le mécanisme d'héritage</a> basé sur le concept de prototype</li>
- <li>Les objets et fonctions natifs ({{jsxref("JSON")}}, {{jsxref("Math")}}, méthodes de<code> </code> {{jsxref("Array.prototype")}}, méthodes d'introspection d'<code>Object</code>...)</li>
- <li><a href="/fr/docs/Web/JavaScript/Reference/Strict_mode">Le mode strict</a>.</li>
-</ul>
+- [La syntaxe du langage](/fr/docs/Web/JavaScript/Reference/Grammaire_lexicale) (règles d'interprétation (parsing), mots-clés, flux d'instructions, initialisation littérale d'objets...)
+- Le mécanisme de traitement d'erreurs ({{jsxref("Instructions/throw","throw")}}, {{jsxref("Instructions/try...catch","try...catch")}} capacité qu'a l'utilisateur de créer des types d'erreurs personnalisés)
+- Les types de variables (booléen, nombre, chaîne de caractères, fonction, objet...)
+- L'objet global. Dans l'environnement d'un navigateur, cet objet global est l'objet {{domxref("Window","window")}}. ECMAScript ne définit ici que les API accessibles depuis l'objet global (peu importe l'environnement qui peut être différent d'un navigateur) (par exemple {{jsxref("parseInt","parseInt()")}}, {{jsxref("parseFloat","parseFloat()")}}, {{jsxref("decodeURI","decodeURI()")}}, {{jsxref("encodeURI","encodeURI()")}}...)
+- [Le mécanisme d'héritage](/fr/docs/Web/JavaScript/Guide/Inheritance_and_the_prototype_chain) basé sur le concept de prototype
+- Les objets et fonctions natifs ({{jsxref("JSON")}}, {{jsxref("Math")}}, méthodes de` `{{jsxref("Array.prototype")}}, méthodes d'introspection d'`Object`...)
+- [Le mode strict](/fr/docs/Web/JavaScript/Reference/Strict_mode).
 
-<h3 id="Support_des_navigateurs">Support des navigateurs</h3>
+### Support des navigateurs
 
-<p>En octobre 2016, les versions actuelles des principaux navigateurs web supportent <a href="/fr/docs/Web/JavaScript/New_in_JavaScript/ECMAScript_5_support_in_Mozilla">ECMAScript 5.1</a> et <a href="/fr/docs/Web/JavaScript/Nouveaut%C3%A9s_et_historique_de_JavaScript/Support_ECMAScript_6_par_Mozilla">ECMAScript 2015 (aussi appelé ES6)</a> mais certaines anciennes versions n'implémentent que ECMAScript 5.</p>
+En octobre 2016, les versions actuelles des principaux navigateurs web supportent [ECMAScript 5.1](/fr/docs/Web/JavaScript/New_in_JavaScript/ECMAScript_5_support_in_Mozilla) et [ECMAScript 2015 (aussi appelé ES6)](/fr/docs/Web/JavaScript/Nouveaut%C3%A9s_et_historique_de_JavaScript/Support_ECMAScript_6_par_Mozilla) mais certaines anciennes versions n'implémentent que ECMAScript 5.
 
-<h3 id="Futur">Futur</h3>
+### Futur
 
-<p>La sixième édition majeure d'ECMAScript a été officiellement approuvée et publiée en tant que standard le 17 juin 2015 par l'assemblée générale ECMA. Depuis cette édition, les éditions ECMAScript sont publiées à un rythme annuel.</p>
+La sixième édition majeure d'ECMAScript a été officiellement approuvée et publiée en tant que standard le 17 juin 2015 par l'assemblée générale ECMA. Depuis cette édition, les éditions ECMAScript sont publiées à un rythme annuel.
 
-<h3 id="API_d'internationalisation">API d'internationalisation</h3>
+### API d'internationalisation
 
-<p>La <a href="http://ecma-international.org/ecma-402/1.0/">spécification ECMAScript pour l'API d'internationalisation</a> est un ajout à la spécification du langage ECMAScript, également standardisée par ECMA TC39. L'API d'internationalisation ajoute la collation (c'est-à-dire la comparaison entre chaînes de caractères), le formatage de nombres, dates et heures dans les applications JavaScript en prenant en compte la locale de l'utilisateur pour fournir le meilleur format. Le standard initial a été aprouvé en décembre 2012 ; le statut de son implémentation dans les différents navigateurs est disponible sur la page de l'objet {{jsxref("Intl")}}. La spécification d'internationalisation est également ratifiée annuellement et les navigateurs améliorent leur implémentation au fur et à mesure.</p>
+La [spécification ECMAScript pour l'API d'internationalisation](http://ecma-international.org/ecma-402/1.0/) est un ajout à la spécification du langage ECMAScript, également standardisée par ECMA TC39. L'API d'internationalisation ajoute la collation (c'est-à-dire la comparaison entre chaînes de caractères), le formatage de nombres, dates et heures dans les applications JavaScript en prenant en compte la locale de l'utilisateur pour fournir le meilleur format. Le standard initial a été aprouvé en décembre 2012 ; le statut de son implémentation dans les différents navigateurs est disponible sur la page de l'objet {{jsxref("Intl")}}. La spécification d'internationalisation est également ratifiée annuellement et les navigateurs améliorent leur implémentation au fur et à mesure.
 
-<h2 id="Les_API_du_DOM_(Document_Object_Model)">Les API du DOM (<em>Document Object Model</em>)</h2>
+## Les API du DOM (_Document Object Model_)
 
-<h3 id="WebIDL">WebIDL</h3>
+### WebIDL
 
-<p>La <a href="http://www.w3.org/TR/WebIDL/">spécification WebIDL</a> fournit le lien entre les technologies DOM et ECMAScript.</p>
+La [spécification WebIDL](http://www.w3.org/TR/WebIDL/) fournit le lien entre les technologies DOM et ECMAScript.
 
-<h3 id="Le_cœur_du_DOM">Le cœur du DOM</h3>
+### Le cœur du DOM
 
-<p>Le Modèle d'Objet du Document (<em>Document Object Model</em> ou DOM en anglais) est une convention multi-plateforme, indépendante du langage utilisée pour représenter et interagir avec les objets dans les documents HTML, XHTML et XML. Les objets de <strong>l'arbre du DOM</strong> peuvent être accédés et manipulés en utilisant des méthodes sur les objets. Les fonctionnalités principales du DOM sont standardisées par le {{Glossary("W3C")}}. Il définit les interfaces offertes par les documents HTML et XML sans cibler un langage de manipulation précis. Parmi les éléments définis par le DOM, on peut trouver:</p>
+Le Modèle d'Objet du Document (_Document Object Model_ ou DOM en anglais) est une convention multi-plateforme, indépendante du langage utilisée pour représenter et interagir avec les objets dans les documents HTML, XHTML et XML. Les objets de **l'arbre du DOM** peuvent être accédés et manipulés en utilisant des méthodes sur les objets. Les fonctionnalités principales du DOM sont standardisées par le {{Glossary("W3C")}}. Il définit les interfaces offertes par les documents HTML et XML sans cibler un langage de manipulation précis. Parmi les éléments définis par le DOM, on peut trouver:
 
-<ul>
- <li>La structure du document, un modèle d'arbre et l'architecture d'événements DOM dans le <a href="http://dvcs.w3.org/hg/domcore/raw-file/tip/Overview.html">noyau DOM</a> : {{domxref("Node")}}, {{domxref("Element")}}, {{domxref("DocumentFragment")}}, {{domxref("Document")}}, {{domxref("DOMImplementation")}}, {{domxref("Event")}}, {{domxref("EventTarget")}}, …</li>
- <li>Une définition moins rigoureuse de l'architecture d'événements DOM, ainsi que des événements spécifiques avec <a href="http://dev.w3.org/2006/webapi/DOM-Level-3-Events/html/DOM3-Events.html">les événements DOM</a>.</li>
- <li>D'autres éléments tels que le <a href="http://www.w3.org/TR/DOM-Level-2-Traversal-Range/traversal.html">DOM Traversal</a> et le <a href="http://html5.org/specs/dom-range.html">DOM Range</a>.</li>
-</ul>
+- La structure du document, un modèle d'arbre et l'architecture d'événements DOM dans le [noyau DOM](http://dvcs.w3.org/hg/domcore/raw-file/tip/Overview.html) : {{domxref("Node")}}, {{domxref("Element")}}, {{domxref("DocumentFragment")}}, {{domxref("Document")}}, {{domxref("DOMImplementation")}}, {{domxref("Event")}}, {{domxref("EventTarget")}}, …
+- Une définition moins rigoureuse de l'architecture d'événements DOM, ainsi que des événements spécifiques avec [les événements DOM](http://dev.w3.org/2006/webapi/DOM-Level-3-Events/html/DOM3-Events.html).
+- D'autres éléments tels que le [DOM Traversal](http://www.w3.org/TR/DOM-Level-2-Traversal-Range/traversal.html) et le [DOM Range](http://html5.org/specs/dom-range.html).
 
-<p>Du point de vue d'ECMAScript, les objets définis dans la spécification DOM sont appelés des « objets hôtes ».</p>
+Du point de vue d'ECMAScript, les objets définis dans la spécification DOM sont appelés des « objets hôtes ».
 
-<h3 id="Le_DOM_HTML">Le DOM HTML</h3>
+### Le DOM HTML
 
-<p><a href="/fr/docs/Web/HTML">HTML</a>, le langage de balisage du Web, est spécifié en termes de DOM. Comme une couche au-dessus des concepts abstraits définis dans DOM Core, HTML définit également la <em>signification </em>des éléments. Le DOM HTML inclut des choses telles que la propriété <code>className</code> sur des éléments HTML, or des API telles que {{domxref("document.body")}}.<br>
- <br>
- La spécification HTML définit aussi les restrictions sur les documents ; par exemple, elle requiert que tous les enfants d'un élément {{HTMLRef("ul")}} (une liste non-ordonnée) soient des éléments {{HTMLRef("li")}}, puisqu'ils représentent les éléments d'une liste. En général, cela interdit aussi l'utilisation d'éléments et d'attributs qui ne sont pas définis dans un certain standard.<br>
- <br>
- Si vous cherchez la documentation sur l'objet {{domxref("Document")}}, l'objet {{domxref("Window")}} ou sur les autres éléments du DOM, vous pouvez lire <a href="/fr/docs/Web/API/Référence_du_DOM_Gecko">la documentation relative au DOM</a>.</p>
+[HTML](/fr/docs/Web/HTML), le langage de balisage du Web, est spécifié en termes de DOM. Comme une couche au-dessus des concepts abstraits définis dans DOM Core, HTML définit également la _signification_ des éléments. Le DOM HTML inclut des choses telles que la propriété `className` sur des éléments HTML, or des API telles que {{domxref("document.body")}}.
 
-<h2 id="D'autres_API_fréquemment_utilisées">D'autres API fréquemment utilisées</h2>
+La spécification HTML définit aussi les restrictions sur les documents ; par exemple, elle requiert que tous les enfants d'un élément {{HTMLRef("ul")}} (une liste non-ordonnée) soient des éléments {{HTMLRef("li")}}, puisqu'ils représentent les éléments d'une liste. En général, cela interdit aussi l'utilisation d'éléments et d'attributs qui ne sont pas définis dans un certain standard.
 
-<ul>
- <li>Les fonctions {{domxref("WindowTimers.setTimeout", "setTimeout")}} et {{domxref("WindowTimers.setInterval", "setInterval")}} ont d'abord été spécifiées dans l'interface {{domxref("Window")}} du standard HTML.</li>
- <li><a href="https://dvcs.w3.org/hg/xhr/raw-file/tip/Overview.html" title="http://dev.w3.org/2006/webapi/XMLHttpRequest-2/">XMLHttpRequest</a> : une API qui permet d'envoyer des requêtes HTTP asynchrones (voir aussi : <a href="/fr/docs/Web/API/XMLHttpRequest">la page MDN sur XMLHttpRequest</a>)</li>
- <li><a href="http://dev.w3.org/csswg/cssom/">CSS Object Model</a> : le CSSOM est utilisé pour abstraire les règles CSS sous forme d'objets. (voir aussi : <a href="/fr/docs/Web/API/CSS_Object_Model">la page MDN sur CSSOM</a>)</li>
- <li><a href="https://html.spec.whatwg.org/multipage/workers.html">WebWorkers</a> : une API qui permet d'effectuer des calculs parallèles (voir aussi : <a href="/fr/docs/Web/API/Web_Workers_API">la page MDN sur cette API</a>)</li>
- <li><a href="https://html.spec.whatwg.org/multipage//#network">WebSockets</a> : une API qui permet d'effectuer des communications bi-directionnelles de bas-niveau (voir aussi : <a href="/fr/docs/WebSockets">la page MDN sur cette API</a>)</li>
- <li><code><a href="https://html.spec.whatwg.org/multipage/scripting.html#2dcontext">Canvas2DContext</a></code> : Une API de dessin pour l'élément {{htmlelement("canvas")}}.</li>
-</ul>
+Si vous cherchez la documentation sur l'objet {{domxref("Document")}}, l'objet {{domxref("Window")}} ou sur les autres éléments du DOM, vous pouvez lire [la documentation relative au DOM](/fr/docs/Web/API/Référence_du_DOM_Gecko).
+
+## D'autres API fréquemment utilisées
+
+- Les fonctions {{domxref("WindowTimers.setTimeout", "setTimeout")}} et {{domxref("WindowTimers.setInterval", "setInterval")}} ont d'abord été spécifiées dans l'interface {{domxref("Window")}} du standard HTML.
+- [XMLHttpRequest](https://dvcs.w3.org/hg/xhr/raw-file/tip/Overview.html "http://dev.w3.org/2006/webapi/XMLHttpRequest-2/") : une API qui permet d'envoyer des requêtes HTTP asynchrones (voir aussi : [la page MDN sur XMLHttpRequest](/fr/docs/Web/API/XMLHttpRequest))
+- [CSS Object Model](http://dev.w3.org/csswg/cssom/) : le CSSOM est utilisé pour abstraire les règles CSS sous forme d'objets. (voir aussi : [la page MDN sur CSSOM](/fr/docs/Web/API/CSS_Object_Model))
+- [WebWorkers](https://html.spec.whatwg.org/multipage/workers.html) : une API qui permet d'effectuer des calculs parallèles (voir aussi : [la page MDN sur cette API](/fr/docs/Web/API/Web_Workers_API))
+- [WebSockets](https://html.spec.whatwg.org/multipage//#network) : une API qui permet d'effectuer des communications bi-directionnelles de bas-niveau (voir aussi : [la page MDN sur cette API](/fr/docs/WebSockets))
+- [`Canvas2DContext`](https://html.spec.whatwg.org/multipage/scripting.html#2dcontext) : Une API de dessin pour l'élément {{htmlelement("canvas")}}.
diff --git a/files/fr/web/javascript/language_resources/index.md b/files/fr/web/javascript/language_resources/index.md
index 7e47a0d08b..f992cd5ffe 100644
--- a/files/fr/web/javascript/language_resources/index.md
+++ b/files/fr/web/javascript/language_resources/index.md
@@ -6,146 +6,248 @@ tags:
   - JavaScript
 translation_of: Web/JavaScript/Language_Resources
 ---
-<div>{{JsSidebar}}</div>
+{{JsSidebar}}
 
-<p><strong>ECMAScript</strong> est un langage de script qui forme la base de <a href="/fr/docs/Web/JavaScript">JavaScript</a>. ECMAScript est standardisé par l'organisation <a href="https://www.ecma-international.org/">ECMA International</a> grâce aux spécifications <strong>ECMA-262 et ECMA-402</strong>. Les standards ECMAScript suivants ont été approuvés ou sont en cours de rédaction:</p>
+**ECMAScript** est un langage de script qui forme la base de [JavaScript](/fr/docs/Web/JavaScript). ECMAScript est standardisé par l'organisation [ECMA International](https://www.ecma-international.org/) grâce aux spécifications **ECMA-262 et ECMA-402**. Les standards ECMAScript suivants ont été approuvés ou sont en cours de rédaction:
 
 <table class="standard-table">
- <tbody>
-  <tr>
-   <th>Nom</th>
-   <th>Lien</th>
-   <th>Date de publication</th>
-   <th>Description</th>
-  </tr>
-  <tr>
-   <th colspan="4">Éditions actuelles</th>
-  </tr>
-  <tr>
-   <td>ECMA-262 10e édition</td>
-   <td><a href="https://tc39.github.io/ecma262/">Brouillon de travail</a></td>
-   <td>2019</td>
-   <td>Spécification du langage ECMAScript 2019</td>
-  </tr>
-  <tr>
-   <td>ECMA-262, 9e édition</td>
-   <td><a href="http://ecma-international.org/publications/files/ECMA-ST/Ecma-262.pdf">PDF</a>, <a href="http://ecma-international.org/ecma-262/9.0/index.html#Title">HTML</a>, <br>
-    <a href="https://tc39.github.io/ecma262/">Brouillon de travail</a>, <a href="https://github.com/tc39/ecma262">dépôt</a></td>
-   <td>2018</td>
-   <td>Spécification du langage ECMAScript 2018</td>
-  </tr>
-  <tr>
-   <td>ECMA-402 5e édition</td>
-   <td><a href="https://tc39.github.io/ecma402/">Brouillon de la spécification</a>, <a href="https://github.com/tc39/ecma402">dépôt</a></td>
-   <td>2018</td>
-   <td>Spécification pour l'API d'internationalisation ECMAScript 2018</td>
-  </tr>
-  <tr>
-   <th colspan="4">Éditions historiques/obsolètes</th>
-  </tr>
-  <tr>
-   <td>ECMA-262</td>
-   <td><a href="https://www.ecma-international.org/publications/files/ECMA-ST-ARCH/ECMA-262,%201st%20edition,%20June%201997.pdf">PDF</a></td>
-   <td>Juin 1997</td>
-   <td>ECMAScript : un langage de programmation générique, multi-plateforme. C'est la première version du standard ECMAScript.</td>
-  </tr>
-  <tr>
-   <td>ECMA-262, 2e édition</td>
-   <td><a href="https://www.ecma-international.org/publications/files/ECMA-ST-ARCH/ECMA-262,%202nd%20edition,%20August%201998.pdf">PDF</a></td>
-   <td>Août 1998</td>
-   <td>Spécification du langage ECMAScript. C'est la deuxième révision du standard. Elle correspond aussi au standard ISO 16262.</td>
-  </tr>
-  <tr>
-   <td>ECMA-262 3e édition</td>
-   <td><a href="https://www.ecma-international.org/publications/files/ECMA-ST-ARCH/ECMA-262,%203rd%20edition,%20December%201999.pdf">PDF</a></td>
-   <td>Décembre 1999</td>
-   <td>Spécification du langage ECMAScript. C'est la troisième révision du standard. Elle correspond à JavaScript 1.5.<br>
-    Voir aussi <a href="https://www.mozilla.org/js/language/E262-3-errata.html">l'errata</a> à ce propos.</td>
-  </tr>
-  <tr>
-   <td>ECMA-262 5e édition</td>
-   <td><a href="https://www.ecma-international.org/publications/files/ECMA-ST-ARCH/ECMA-262%205th%20edition%20December%202009.pdf">PDF</a></td>
-   <td>Décembre 2009</td>
-   <td>Spécification du langage ECMAScript. C'est la cinquième révision du standard.<br>
-    Voir aussi <a href="https://wiki.ecmascript.org/doku.php?id=es3.1:es3.1_proposal_working_draft">l'errata pour ES5</a> et <a href="/fr/DOcs/JavaScript/ECMAScript_5_support_in_Mozilla">la prise en charge d'ECMAScript 5 par Mozilla</a></td>
-  </tr>
-  <tr>
-   <td>ECMA-357</td>
-   <td><a href="https://www.ecma-international.org/publications/files/ECMA-ST-WITHDRAWN/ECMA-357,%201st%20edition,%20June%202004.pdf">PDF</a></td>
-   <td>Juin 2004</td>
-   <td><a href="/fr/DOcs/E4X">ECMAScript pour XML (E4X)</a>.<br>
-    Voir aussi<a class="link-https" href="https://bugzilla.mozilla.org/attachment.cgi?id=169406"> l'errata pour E4X</a>.</td>
-  </tr>
-  <tr>
-   <td>ECMA-262, édition 5.1</td>
-   <td><a href="https://www.ecma-international.org/ecma-262/5.1/Ecma-262.pdf">PDF</a>, <a href="https://www.ecma-international.org/ecma-262/5.1/">HTML</a></td>
-   <td>Juin 2011</td>
-   <td>Cette version correspond complètement à la troisième édition du standard international <a href="https://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm?csnumber=55755">ISO/IEC 16262:2011</a>.<br>
-    Elle inclut les correctifs lié à l'errata pour ES5, elle ne contient pas de nouvelles fonctionnalités.</td>
-  </tr>
-  <tr>
-   <td>ECMA-402 1ère édition</td>
-   <td><a href="https://ecma-international.org/ecma-402/1.0/ECMA-402.pdf">PDF</a>, <a href="https://ecma-international.org/ecma-402/1.0/index.html">HTML</a></td>
-   <td>Décembre 2012</td>
-   <td>Spécification pour l'API d'internationalisation ECMAScript</td>
-  </tr>
-  <tr>
-   <td>ECMA-262 6e édition</td>
-   <td><a href="https://www.ecma-international.org/publications/files/ECMA-ST/Ecma-262.pdf">PDF</a>, <a href="https://www.ecma-international.org/ecma-262/6.0/index.html">HTML</a></td>
-   <td>Juin 2015</td>
-   <td>Spécification 2015 pour le langage ECMAScript (sixième édition)</td>
-  </tr>
-  <tr>
-   <td>ECMA-402 2e édition</td>
-   <td><a href="https://www.ecma-international.org/ecma-402/2.0/ECMA-402.pdf">PDF</a></td>
-   <td>Juin 2015</td>
-   <td>Spécification pour l'API d'internationalisation ECMAScript 2015</td>
-  </tr>
-  <tr>
-   <td>ECMA-262 7e édition</td>
-   <td><a href="https://www.ecma-international.org/ecma-262/7.0/">HTML</a></td>
-   <td>Juin 2016</td>
-   <td>Spécification 2016 pour le langage ECMAScript (septième édition)</td>
-  </tr>
-  <tr>
-   <td>ECMA-402 3e édition</td>
-   <td><a href="https://www.ecma-international.org/ecma-402/3.0/">HTML</a></td>
-   <td>Juin 2016</td>
-   <td>Spécification pour l'API d'internationalisation ECMAScript 2016</td>
-  </tr>
-  <tr>
-   <td>ECMA-262 8e édition</td>
-   <td><a href="https://www.ecma-international.org/ecma-262/8.0/">HTML</a></td>
-   <td>Juin 2017</td>
-   <td>Spécification 2017 pour le langage ECMAScript (huitième édition)</td>
-  </tr>
-  <tr>
-   <td>ECMA-402 4e édition</td>
-   <td><a href="https://www.ecma-international.org/ecma-402/4.0/">HTML</a></td>
-   <td>Juin 2017</td>
-   <td>Spécification pour l'API d'internationalisation ECMAScript 2017</td>
-  </tr>
- </tbody>
+  <tbody>
+    <tr>
+      <th>Nom</th>
+      <th>Lien</th>
+      <th>Date de publication</th>
+      <th>Description</th>
+    </tr>
+    <tr>
+      <th colspan="4">Éditions actuelles</th>
+    </tr>
+    <tr>
+      <td>ECMA-262 10e édition</td>
+      <td>
+        <a href="https://tc39.github.io/ecma262/">Brouillon de travail</a>
+      </td>
+      <td>2019</td>
+      <td>Spécification du langage ECMAScript 2019</td>
+    </tr>
+    <tr>
+      <td>ECMA-262, 9e édition</td>
+      <td>
+        <a
+          href="http://ecma-international.org/publications/files/ECMA-ST/Ecma-262.pdf"
+          >PDF</a
+        >,
+        <a href="http://ecma-international.org/ecma-262/9.0/index.html#Title"
+          >HTML</a
+        >, <br /><a href="https://tc39.github.io/ecma262/"
+          >Brouillon de travail</a
+        >, <a href="https://github.com/tc39/ecma262">dépôt</a>
+      </td>
+      <td>2018</td>
+      <td>Spécification du langage ECMAScript 2018</td>
+    </tr>
+    <tr>
+      <td>ECMA-402 5e édition</td>
+      <td>
+        <a href="https://tc39.github.io/ecma402/"
+          >Brouillon de la spécification</a
+        >, <a href="https://github.com/tc39/ecma402">dépôt</a>
+      </td>
+      <td>2018</td>
+      <td>Spécification pour l'API d'internationalisation ECMAScript 2018</td>
+    </tr>
+    <tr>
+      <th colspan="4">Éditions historiques/obsolètes</th>
+    </tr>
+    <tr>
+      <td>ECMA-262</td>
+      <td>
+        <a
+          href="https://www.ecma-international.org/publications/files/ECMA-ST-ARCH/ECMA-262,%201st%20edition,%20June%201997.pdf"
+          >PDF</a
+        >
+      </td>
+      <td>Juin 1997</td>
+      <td>
+        ECMAScript : un langage de programmation générique, multi-plateforme.
+        C'est la première version du standard ECMAScript.
+      </td>
+    </tr>
+    <tr>
+      <td>ECMA-262, 2e édition</td>
+      <td>
+        <a
+          href="https://www.ecma-international.org/publications/files/ECMA-ST-ARCH/ECMA-262,%202nd%20edition,%20August%201998.pdf"
+          >PDF</a
+        >
+      </td>
+      <td>Août 1998</td>
+      <td>
+        Spécification du langage ECMAScript. C'est la deuxième révision du
+        standard. Elle correspond aussi au standard ISO 16262.
+      </td>
+    </tr>
+    <tr>
+      <td>ECMA-262 3e édition</td>
+      <td>
+        <a
+          href="https://www.ecma-international.org/publications/files/ECMA-ST-ARCH/ECMA-262,%203rd%20edition,%20December%201999.pdf"
+          >PDF</a
+        >
+      </td>
+      <td>Décembre 1999</td>
+      <td>
+        Spécification du langage ECMAScript. C'est la troisième révision du
+        standard. Elle correspond à JavaScript 1.5.<br />Voir aussi
+        <a href="https://www.mozilla.org/js/language/E262-3-errata.html"
+          >l'errata</a
+        >
+        à ce propos.
+      </td>
+    </tr>
+    <tr>
+      <td>ECMA-262 5e édition</td>
+      <td>
+        <a
+          href="https://www.ecma-international.org/publications/files/ECMA-ST-ARCH/ECMA-262%205th%20edition%20December%202009.pdf"
+          >PDF</a
+        >
+      </td>
+      <td>Décembre 2009</td>
+      <td>
+        Spécification du langage ECMAScript. C'est la cinquième révision du
+        standard.<br />Voir aussi
+        <a
+          href="https://wiki.ecmascript.org/doku.php?id=es3.1:es3.1_proposal_working_draft"
+          >l'errata pour ES5</a
+        >
+        et
+        <a href="/fr/DOcs/JavaScript/ECMAScript_5_support_in_Mozilla"
+          >la prise en charge d'ECMAScript 5 par Mozilla</a
+        >
+      </td>
+    </tr>
+    <tr>
+      <td>ECMA-357</td>
+      <td>
+        <a
+          href="https://www.ecma-international.org/publications/files/ECMA-ST-WITHDRAWN/ECMA-357,%201st%20edition,%20June%202004.pdf"
+          >PDF</a
+        >
+      </td>
+      <td>Juin 2004</td>
+      <td>
+        <a href="/fr/DOcs/E4X">ECMAScript pour XML (E4X)</a>.<br />Voir aussi<a
+          class="link-https"
+          href="https://bugzilla.mozilla.org/attachment.cgi?id=169406"
+        >
+          l'errata pour E4X</a
+        >.
+      </td>
+    </tr>
+    <tr>
+      <td>ECMA-262, édition 5.1</td>
+      <td>
+        <a href="https://www.ecma-international.org/ecma-262/5.1/Ecma-262.pdf"
+          >PDF</a
+        >, <a href="https://www.ecma-international.org/ecma-262/5.1/">HTML</a>
+      </td>
+      <td>Juin 2011</td>
+      <td>
+        Cette version correspond complètement à la troisième édition du standard
+        international
+        <a
+          href="https://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm?csnumber=55755"
+          >ISO/IEC 16262:2011</a
+        >.<br />Elle inclut les correctifs lié à l'errata pour ES5, elle ne
+        contient pas de nouvelles fonctionnalités.
+      </td>
+    </tr>
+    <tr>
+      <td>ECMA-402 1ère édition</td>
+      <td>
+        <a href="https://ecma-international.org/ecma-402/1.0/ECMA-402.pdf"
+          >PDF</a
+        >,
+        <a href="https://ecma-international.org/ecma-402/1.0/index.html"
+          >HTML</a
+        >
+      </td>
+      <td>Décembre 2012</td>
+      <td>Spécification pour l'API d'internationalisation ECMAScript</td>
+    </tr>
+    <tr>
+      <td>ECMA-262 6e édition</td>
+      <td>
+        <a
+          href="https://www.ecma-international.org/publications/files/ECMA-ST/Ecma-262.pdf"
+          >PDF</a
+        >,
+        <a href="https://www.ecma-international.org/ecma-262/6.0/index.html"
+          >HTML</a
+        >
+      </td>
+      <td>Juin 2015</td>
+      <td>Spécification 2015 pour le langage ECMAScript (sixième édition)</td>
+    </tr>
+    <tr>
+      <td>ECMA-402 2e édition</td>
+      <td>
+        <a href="https://www.ecma-international.org/ecma-402/2.0/ECMA-402.pdf"
+          >PDF</a
+        >
+      </td>
+      <td>Juin 2015</td>
+      <td>Spécification pour l'API d'internationalisation ECMAScript 2015</td>
+    </tr>
+    <tr>
+      <td>ECMA-262 7e édition</td>
+      <td>
+        <a href="https://www.ecma-international.org/ecma-262/7.0/">HTML</a>
+      </td>
+      <td>Juin 2016</td>
+      <td>Spécification 2016 pour le langage ECMAScript (septième édition)</td>
+    </tr>
+    <tr>
+      <td>ECMA-402 3e édition</td>
+      <td>
+        <a href="https://www.ecma-international.org/ecma-402/3.0/">HTML</a>
+      </td>
+      <td>Juin 2016</td>
+      <td>Spécification pour l'API d'internationalisation ECMAScript 2016</td>
+    </tr>
+    <tr>
+      <td>ECMA-262 8e édition</td>
+      <td>
+        <a href="https://www.ecma-international.org/ecma-262/8.0/">HTML</a>
+      </td>
+      <td>Juin 2017</td>
+      <td>Spécification 2017 pour le langage ECMAScript (huitième édition)</td>
+    </tr>
+    <tr>
+      <td>ECMA-402 4e édition</td>
+      <td>
+        <a href="https://www.ecma-international.org/ecma-402/4.0/">HTML</a>
+      </td>
+      <td>Juin 2017</td>
+      <td>Spécification pour l'API d'internationalisation ECMAScript 2017</td>
+    </tr>
+  </tbody>
 </table>
 
-<p>ES.Next est un nom dynamique qui fait toujours référence à la prochaine version d'ECMAScript, en cours de rédaction. Les fonctionnalités d'ES.Next sont plutôt considérées comme des propositions car la spécification n'a pas encore été finalisée.</p>
+ES.Next est un nom dynamique qui fait toujours référence à la prochaine version d'ECMAScript, en cours de rédaction. Les fonctionnalités d'ES.Next sont plutôt considérées comme des propositions car la spécification n'a pas encore été finalisée.
 
-<p>Pour plus d'informations sur l'histoire d'ECMAScript, voir <a href="https://fr.wikipedia.org/wiki/ECMAScript">la page Wikipédia sur ECMAScript</a>.</p>
+Pour plus d'informations sur l'histoire d'ECMAScript, voir [la page Wikipédia sur ECMAScript](https://fr.wikipedia.org/wiki/ECMAScript).
 
-<p>Il est possible de participer ou de suivre les travaux concernant la prochaine révision de la spécification sur le langage ECMAScript, appelée « Harmony », ainsi que pour la spécification de l'API d'internationalisation grâce au wiki public et à la liste de diffusion<a class="link-https" href="https://mail.mozilla.org/listinfo/es-discuss"> es-discuss</a> accessibles depuis <a href="https://www.ecmascript.org/community.php">ecmascript.org</a>.</p>
+Il est possible de participer ou de suivre les travaux concernant la prochaine révision de la spécification sur le langage ECMAScript, appelée « Harmony », ainsi que pour la spécification de l'API d'internationalisation grâce au wiki public et à la liste de diffusion[ es-discuss](https://mail.mozilla.org/listinfo/es-discuss) accessibles depuis [ecmascript.org](https://www.ecmascript.org/community.php).
 
-<h2 id="Implémentations">Implémentations</h2>
+## Implémentations
 
-<ul>
- <li><a href="/fr/docs/SpiderMonkey">SpiderMonkey</a> : le moteur JavaScript utilisé dans Firefox et les autres produits Mozilla</li>
- <li><a href="/fr/docs/Rhino">Rhino</a> : un moteur JavaScript écrit en Java</li>
- <li><a href="/fr/docs/Tamarin">Tamarin</a> : la machine virtuelle ActionScript (utilisée par Adobe® Flash® Player)</li>
- <li><a href="https://en.wikipedia.org/wiki/List_of_ECMAScript_engines">Autres implémentations</a> (Wikipédia).</li>
-</ul>
+- [SpiderMonkey](/fr/docs/SpiderMonkey) : le moteur JavaScript utilisé dans Firefox et les autres produits Mozilla
+- [Rhino](/fr/docs/Rhino) : un moteur JavaScript écrit en Java
+- [Tamarin](/fr/docs/Tamarin) : la machine virtuelle ActionScript (utilisée par Adobe® Flash® Player)
+- [Autres implémentations](https://en.wikipedia.org/wiki/List_of_ECMAScript_engines) (Wikipédia).
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li><a href="https://brendaneich.com/">Le blog de Brendan Eich</a> (en anglais). Brendan Eich est le créateur de JavaScript et du moteur SpiderMonkey. Il continue de travailler avec le groupe de travail ECMA pour faire évoluer le langage.</li>
- <li><a href="https://dmitrysoshnikov.com/">L'analyse de Dmitry Soshnikov sur les troisième et cinquième édition d'ECMA-262</a></li>
-</ul>
+- [Le blog de Brendan Eich](https://brendaneich.com/) (en anglais). Brendan Eich est le créateur de JavaScript et du moteur SpiderMonkey. Il continue de travailler avec le groupe de travail ECMA pour faire évoluer le langage.
+- [L'analyse de Dmitry Soshnikov sur les troisième et cinquième édition d'ECMA-262](https://dmitrysoshnikov.com/)
diff --git a/files/fr/web/javascript/memory_management/index.md b/files/fr/web/javascript/memory_management/index.md
index 1e42785cde..2f02a5edec 100644
--- a/files/fr/web/javascript/memory_management/index.md
+++ b/files/fr/web/javascript/memory_management/index.md
@@ -8,29 +8,28 @@ tags:
 translation_of: Web/JavaScript/Memory_Management
 original_slug: Web/JavaScript/Gestion_de_la_mémoire
 ---
-<div>{{JsSidebar("Advanced")}}</div>
+{{JsSidebar("Advanced")}}
 
-<p>Les langages de bas niveau, tels que C, possèdent des primitives permettant de gérer la mémoire : <code><a href="https://pubs.opengroup.org/onlinepubs/009695399/functions/malloc.html">malloc()</a></code> et <code><a href="https://en.wikipedia.org/wiki/C_dynamic_memory_allocation#Overview_of_functions">free()</a></code> par exemple. En revanche, lorsqu'on utilise JavaScript, la mémoire est allouée lors de la création des objets puis libérée « automatiquement » lorsque ceux-ci ne sont plus utilisés. Cette libération automatique est appelée <em>garbage collection </em>en anglais ou ramasse-miettes. Le fait que ce processus soit automatique est souvent source de confusion et donne parfois l'impression que JavaScript (ou d'autres langages de haut niveau) ne permet pas de gérer la mémoire : nous allons voir que ce n'est pas le cas.</p>
+Les langages de bas niveau, tels que C, possèdent des primitives permettant de gérer la mémoire : [`malloc()`](https://pubs.opengroup.org/onlinepubs/009695399/functions/malloc.html) et [`free()`](https://en.wikipedia.org/wiki/C_dynamic_memory_allocation#Overview_of_functions) par exemple. En revanche, lorsqu'on utilise JavaScript, la mémoire est allouée lors de la création des objets puis libérée « automatiquement » lorsque ceux-ci ne sont plus utilisés. Cette libération automatique est appelée _garbage collection_ en anglais ou ramasse-miettes. Le fait que ce processus soit automatique est souvent source de confusion et donne parfois l'impression que JavaScript (ou d'autres langages de haut niveau) ne permet pas de gérer la mémoire : nous allons voir que ce n'est pas le cas.
 
-<h2 id="Le_cycle_de_vie_de_la_mémoire">Le cycle de vie de la mémoire</h2>
+## Le cycle de vie de la mémoire
 
-<p>Quel que soit le langage de programmation, le cycle de vie de la mémoire ressemblera à :</p>
+Quel que soit le langage de programmation, le cycle de vie de la mémoire ressemblera à :
 
-<ol>
- <li>Allouer la mémoire dont on a besoin</li>
- <li>Utiliser cette mémoire allouée (lecture, écriture)</li>
- <li>Libérer la mémoire allouée lorsqu'on n'en a plus besoin</li>
-</ol>
+1.  Allouer la mémoire dont on a besoin
+2.  Utiliser cette mémoire allouée (lecture, écriture)
+3.  Libérer la mémoire allouée lorsqu'on n'en a plus besoin
 
-<p>Le deuxième point est explicite, au niveau du code, pour tous les langages de programmation. Le premier et le troisième points sont explicites pour les langages de bas niveau mais souvent implicites pour les langages de haut niveau tels que JavaScript.</p>
+Le deuxième point est explicite, au niveau du code, pour tous les langages de programmation. Le premier et le troisième points sont explicites pour les langages de bas niveau mais souvent implicites pour les langages de haut niveau tels que JavaScript.
 
-<h3 id="Allocation_de_la_mémoire_en_JavaScript">Allocation de la mémoire en JavaScript</h3>
+### Allocation de la mémoire en JavaScript
 
-<h4 id="Initialisation_des_valeurs">Initialisation des valeurs</h4>
+#### Initialisation des valeurs
 
-<p>Afin de simplifier l'écriture de code, JavaScript alloue la mémoire lors de la déclaration des variables :</p>
+Afin de simplifier l'écriture de code, JavaScript alloue la mémoire lors de la déclaration des variables :
 
-<pre class="brush: js">// alloue de la mémoire pour un nombre
+```js
+// alloue de la mémoire pour un nombre
 var n = 123;
 // alloue de la mémoire pour une chaîne de caractères
 var s = "azerty";
@@ -54,22 +53,24 @@ function f(a) {
 unElement.addEventListener('click', function(){
   unElement.style.backgroundColor = 'blue';
 }, false);
-</pre>
+```
 
-<h4 id="Allocation_par_appels_de_fonctions">Allocation par appels de fonctions</h4>
+#### Allocation par appels de fonctions
 
-<p>Certains appels de fonctions entraînent l'allocation mémoire d'un objet.</p>
+Certains appels de fonctions entraînent l'allocation mémoire d'un objet.
 
-<pre class="brush: js">// Alloue la mémoire pour un objet date
+```js
+// Alloue la mémoire pour un objet date
 var d = new Date();
 
 // Alloue de la mémoire pour un objet représentant un élément du DOM
 var e = document.createElement('div');
-</pre>
+```
 
-<p>Certaines méthodes allouent de la mémoire pour des nouveaux objets ou de nouvelles valeurs.</p>
+Certaines méthodes allouent de la mémoire pour des nouveaux objets ou de nouvelles valeurs.
 
-<pre class="brush: js">var s = "azerty";
+```js
+var s = "azerty";
 var s2 = s.substr(0, 3); // s2 est une nouvelle chaîne de caractères
 // Les chaînes étant immuables, JavaScript peut choisir
 // de ne pas allouer de mémoire mais seulement
@@ -80,35 +81,36 @@ var a2 = ["génération", "nan nan"];
 var a3 = a.concat(a2);
 // nouveau tableau de 4 éléments
 // (résultat de la concaténation de a et a2)
-</pre>
+```
 
-<h3 id="Utilisation_des_variables">Utilisation des variables</h3>
+### Utilisation des variables
 
-<p>Utiliser des variables revient à lire et écrire la mémoire allouée. Cela peut être effectué lorsqu'on lit ou modifie la valeur d'une variable ou d'une propriété d'un objet ou encore lorsqu'on passe un argument à une fonction.</p>
+Utiliser des variables revient à lire et écrire la mémoire allouée. Cela peut être effectué lorsqu'on lit ou modifie la valeur d'une variable ou d'une propriété d'un objet ou encore lorsqu'on passe un argument à une fonction.
 
-<h3 id="Libérer_la_mémoire_qui_n'est_plus_nécessaire">Libérer la mémoire qui n'est plus nécessaire</h3>
+### Libérer la mémoire qui n'est plus nécessaire
 
-<p>La plupart des problèmes concernant la gestion de la mémoire surviennent à cet endroit. Le plus difficile est de savoir « quand » la mémoire allouée n'est plus utilisée. Pour les langages « bas niveau », il faut donc que le développeur détermine quelle partie de la mémoire n'est plus utilisée à tel endroit du code et la libère.</p>
+La plupart des problèmes concernant la gestion de la mémoire surviennent à cet endroit. Le plus difficile est de savoir « quand » la mémoire allouée n'est plus utilisée. Pour les langages « bas niveau », il faut donc que le développeur détermine quelle partie de la mémoire n'est plus utilisée à tel endroit du code et la libère.
 
-<p>Les interpréteurs des langages de haut niveau intègrent un composant logiciel, appelé « ramasse-miettes » qui a pour but de surveiller l'utilisation de la mémoire afin de déterminer quand une partie de la mémoire allouée n'est plus utilisée afin de la libérer automatiquement. Ce procédé ne peut être qu'une approximation car savoir si tel ou tel fragment de mémoire est nécessaire est un problème <a href="https://fr.wikipedia.org/wiki/D%C3%A9cidabilit%C3%A9">indécidable</a> (autrement dit, ce problème ne peut être résolu par un algorithme).</p>
+Les interpréteurs des langages de haut niveau intègrent un composant logiciel, appelé « ramasse-miettes » qui a pour but de surveiller l'utilisation de la mémoire afin de déterminer quand une partie de la mémoire allouée n'est plus utilisée afin de la libérer automatiquement. Ce procédé ne peut être qu'une approximation car savoir si tel ou tel fragment de mémoire est nécessaire est un problème [indécidable](https://fr.wikipedia.org/wiki/D%C3%A9cidabilit%C3%A9) (autrement dit, ce problème ne peut être résolu par un algorithme).
 
-<h2 id="Le_ramasse-miettes_ou_garbage_collection">Le ramasse-miettes ou <em>garbage collection</em></h2>
+## Le ramasse-miettes ou _garbage collection_
 
-<p>Comme on vient de le voir, savoir si de la mémoire peut être libérée demeure un problème indécidable. Les ramasses-miettes ne sont donc que des solutions restreintes pour ce problème. La section qui suit détaille les notions importantes pour comprendre ce mécanisme, ainsi que ses limitations.</p>
+Comme on vient de le voir, savoir si de la mémoire peut être libérée demeure un problème indécidable. Les ramasses-miettes ne sont donc que des solutions restreintes pour ce problème. La section qui suit détaille les notions importantes pour comprendre ce mécanisme, ainsi que ses limitations.
 
-<h3 id="Références">Références</h3>
+### Références
 
-<p>Le concept principal utilisé par les algorithmes de ramasse-miettes est celui de <em>référence</em>. Dans ce contexte, un objet en référence un autre lorsqu'il a accès à lui (implicitement ou explicitement). Ainsi, un objet JavaScript référencera son <a href="/fr/docs/Web/JavaScript/Guide/Inheritance_and_the_prototype_chain">prototype</a> (référence implicite) et ses propriétés (référence explicite).</p>
+Le concept principal utilisé par les algorithmes de ramasse-miettes est celui de _référence_. Dans ce contexte, un objet en référence un autre lorsqu'il a accès à lui (implicitement ou explicitement). Ainsi, un objet JavaScript référencera son [prototype](/fr/docs/Web/JavaScript/Guide/Inheritance_and_the_prototype_chain) (référence implicite) et ses propriétés (référence explicite).
 
-<p>Dans ce contexte, la notion d'objet s'étend et dépasse celle utilisée pour décrire les objets JavaScript, elle contiendra notamment les portées de fonctions (ou la portée globale).</p>
+Dans ce contexte, la notion d'objet s'étend et dépasse celle utilisée pour décrire les objets JavaScript, elle contiendra notamment les portées de fonctions (ou la portée globale).
 
-<h3 id="Compter_les_références">Compter les références</h3>
+### Compter les références
 
-<p>L'algorithme le plus simple consiste à faire l'équivalence entre « un objet n'est plus nécessaire » et « un objet n'a pas d'objet le référençant ». Ainsi un objet peut être « ramassé » par le ramasse-miettes quand il n'y a plus de références pointant vers lui.</p>
+L'algorithme le plus simple consiste à faire l'équivalence entre « un objet n'est plus nécessaire » et « un objet n'a pas d'objet le référençant ». Ainsi un objet peut être « ramassé » par le ramasse-miettes quand il n'y a plus de références pointant vers lui.
 
-<h4 id="Exemple">Exemple</h4>
+#### Exemple
 
-<pre class="brush: js">var o = {
+```js
+var o = {
   a: {
     b: 2
   }
@@ -135,13 +137,14 @@ o2 = "yo"; // L'objet 'o' ne possède plus de références vers lui
 oa = null; // la propriété 'a' ne possède plus de références
            // vers elle. L'objet peut être ramassé et la mémoire
            // libérée.
-</pre>
+```
 
-<h4 id="Une_limitation_les_cycles">Une limitation : les cycles</h4>
+#### Une limitation : les cycles
 
-<p>Cet algorithme est limité car il ne peut pas gérer les cycles (exemple : A référence B et B référence A, ce qui forme un cycle). Avec les cycles, des objets pourraient très bien ne plus être nécessaires et cependant il serait impossible de les ramasser pour libérer la mémoire en utilisant l'algorithme précédent car chaque objet serait référencé au moins une fois et aucun ne pourrait être « ramassé ». Les références circulaires peuvent parfois entraîner des fuites mémoire.</p>
+Cet algorithme est limité car il ne peut pas gérer les cycles (exemple : A référence B et B référence A, ce qui forme un cycle). Avec les cycles, des objets pourraient très bien ne plus être nécessaires et cependant il serait impossible de les ramasser pour libérer la mémoire en utilisant l'algorithme précédent car chaque objet serait référencé au moins une fois et aucun ne pourrait être « ramassé ». Les références circulaires peuvent parfois entraîner des fuites mémoire.
 
-<pre class="brush: js">function f() {
+```js
+function f() {
   var o = {};
   var o2 = {};
   o.a = o2; // o référence o2
@@ -151,58 +154,61 @@ oa = null; // la propriété 'a' ne possède plus de références
 }
 
 f();
-</pre>
+```
 
-<h4 id="Exemple_réel">Exemple réel</h4>
+#### Exemple réel
 
-<p>Les navigateurs Internet Explorer 6 et 7 utilisent cet algorithme pour gérer les objets du DOM. Certains codes peuvent donc entraîner des fuites de mémoires, en voici un exemple :</p>
+Les navigateurs Internet Explorer 6 et 7 utilisent cet algorithme pour gérer les objets du DOM. Certains codes peuvent donc entraîner des fuites de mémoires, en voici un exemple :
 
-<pre class="brush: js">var div;
+```js
+var div;
 window.onload = function() {
   div = document.getElementById("monElementDiv");
   div.referenceCirculaire = div;
   div.desDonnees = new Array(10000).join("*");
 };
-</pre>
+```
 
-<p>Dans cet exemple, l'élément du DOM <code>monElementDiv</code> possède une référence circulaire vers lui-même via la propriété <code>referenceCirculaire</code>. Si la propriété n'est pas retirée ou modifiée de façon explicite, un ramasse-miettes qui compte les références aura toujours au moins une référence comptée, ce qui gardera l'élément DOM en mémoire et ce même s'il a été retiré de l'arbre du DOM. Si l'élément du DOM contient beaucoup de données (ce qui est illustré ici avec la propriétés <code>desDonnées</code>), la mémoire consommée par ces données ne sera jamais libérée.</p>
+Dans cet exemple, l'élément du DOM `monElementDiv` possède une référence circulaire vers lui-même via la propriété `referenceCirculaire`. Si la propriété n'est pas retirée ou modifiée de façon explicite, un ramasse-miettes qui compte les références aura toujours au moins une référence comptée, ce qui gardera l'élément DOM en mémoire et ce même s'il a été retiré de l'arbre du DOM. Si l'élément du DOM contient beaucoup de données (ce qui est illustré ici avec la propriétés `desDonnées`), la mémoire consommée par ces données ne sera jamais libérée.
 
-<h3 id="Algorithme_«_marquer_et_balayer_»_(mark-and-sweep)">Algorithme « marquer et balayer » (<em>mark-and-sweep</em>)</h3>
+### Algorithme « marquer et balayer » (_mark-and-sweep_)
 
-<p>Cet algorithme réduit la définition « un objet n'est plus nécessaire » à « un objet ne peut être atteint ».</p>
+Cet algorithme réduit la définition « un objet n'est plus nécessaire » à « un objet ne peut être atteint ».
 
-<p>L'utilisation de cet algorithme implique de savoir quels sont les objets racines (en JavaScript, la racine est l'objet global). De façon périodique, le ramasse-miettes commencera par ces racines, listera tous les objets référencés par ces racines, puis les objets référencés par eux etc. Le ramasse-miettes pourra ainsi construire une liste de tous les objets accessibles et collecter ceux qui ne sont plus accessibles.</p>
+L'utilisation de cet algorithme implique de savoir quels sont les objets racines (en JavaScript, la racine est l'objet global). De façon périodique, le ramasse-miettes commencera par ces racines, listera tous les objets référencés par ces racines, puis les objets référencés par eux etc. Le ramasse-miettes pourra ainsi construire une liste de tous les objets accessibles et collecter ceux qui ne sont plus accessibles.
 
-<p>Cet algorithme est meilleur que le précédent car la proposition « un objet possède 0 référence » implique « un objet ne peut être atteint ». En revanche, la réciproque n'est pas vraie comme nous avons pu le voir avec les cycles.</p>
+Cet algorithme est meilleur que le précédent car la proposition « un objet possède 0 référence » implique « un objet ne peut être atteint ». En revanche, la réciproque n'est pas vraie comme nous avons pu le voir avec les cycles.
 
-<p>En 2012, l'ensemble des navigateurs web modernes disposent d'un ramasse-miettes implémentant cet algorithme <em>mark-and-sweep</em>. L'ensemble des améliorations apportées dans ce domaine de JavaScript représentent des améliorations basées sur cet algorithme, ce ne sont pas de nouveaux algorithmes ou une nouvelle définition pour les objets à supprimer.</p>
+En 2012, l'ensemble des navigateurs web modernes disposent d'un ramasse-miettes implémentant cet algorithme _mark-and-sweep_. L'ensemble des améliorations apportées dans ce domaine de JavaScript représentent des améliorations basées sur cet algorithme, ce ne sont pas de nouveaux algorithmes ou une nouvelle définition pour les objets à supprimer.
 
-<h4 id="Les_cycles_ne_posent_plus_problème">Les cycles ne posent plus problème</h4>
+#### Les cycles ne posent plus problème
 
-<p>Dans l'exemple ci-dessus, après le retour de la fonction, les deux objets ne sont plus référencés par quelque chose d'accessible depuis l'objet global. L'algorithme les marquera donc comme « non-accessibles ».</p>
+Dans l'exemple ci-dessus, après le retour de la fonction, les deux objets ne sont plus référencés par quelque chose d'accessible depuis l'objet global. L'algorithme les marquera donc comme « non-accessibles ».
 
-<h4 id="Limitation_libérer_la_mémoire_manuellement">Limitation : libérer la mémoire manuellement</h4>
+#### Limitation : libérer la mémoire manuellement
 
-<p>On pourrait parfois avoir envie de décider quand libérer la mémoire. En 2019, il n'est pas possible de déclencher le ramasse miettes en JavaScript.</p>
+On pourrait parfois avoir envie de décider quand libérer la mémoire. En 2019, il n'est pas possible de déclencher le ramasse miettes en JavaScript.
 
-<h2 id="Node.js">Node.js</h2>
+## Node.js
 
-<p>Node.js propose certaines options et outils pour configurer et déboguer des problèmes mémoires. Ces fonctionnalités peuvent ne pas être disponibles dans les environnements navigateur.</p>
+Node.js propose certaines options et outils pour configurer et déboguer des problèmes mémoires. Ces fonctionnalités peuvent ne pas être disponibles dans les environnements navigateur.
 
-<h3 id="Options_d'exécution">Options d'exécution</h3>
+### Options d'exécution
 
-<p>La quantité de mémoire pour la mémoire du tas (<em>heap</em>) peut être augmentée avec une option :</p>
+La quantité de mémoire pour la mémoire du tas (_heap_) peut être augmentée avec une option :
 
-<pre class="brush: bash">node --max-old-space-size=6000 index.js</pre>
+```bash
+node --max-old-space-size=6000 index.js
+```
 
-<p>On peut également exposer le ramasse-miettes afin de déboguer des problèmes mémoires. Cela s'active via une option et s'utilise avec le débogueur Chrome :</p>
+On peut également exposer le ramasse-miettes afin de déboguer des problèmes mémoires. Cela s'active via une option et s'utilise avec le débogueur Chrome :
 
-<pre class="brush: bash">node --expose-gc --inspect index.js</pre>
+```bash
+node --expose-gc --inspect index.js
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li><a class="external" href="https://www.ibm.com/developerworks/web/library/wa-memleak/">Article d'IBM sur les pratiques menant aux fuites mémoires en JavaScript (2007)</a> (en anglais)</li>
- <li><a class="external" href="https://msdn.microsoft.com/en-us/magazine/ff728624.aspx">Billet de Kangax sur les méthodes à utiliser pour enregistrer les gestionnaires d'événements et éviter les fuites mémoires (2010)</a> (en anglais)</li>
- <li><a href="/fr/docs/Performance">La performance pour les logiciels Mozilla et les modules complémentaires</a></li>
-</ul>
+- [Article d'IBM sur les pratiques menant aux fuites mémoires en JavaScript (2007)](https://www.ibm.com/developerworks/web/library/wa-memleak/) (en anglais)
+- [Billet de Kangax sur les méthodes à utiliser pour enregistrer les gestionnaires d'événements et éviter les fuites mémoires (2010)](https://msdn.microsoft.com/en-us/magazine/ff728624.aspx) (en anglais)
+- [La performance pour les logiciels Mozilla et les modules complémentaires](/fr/docs/Performance)
diff --git a/files/fr/web/javascript/reference/about/index.md b/files/fr/web/javascript/reference/about/index.md
index 4f2bfd5e74..d51cc9129f 100644
--- a/files/fr/web/javascript/reference/about/index.md
+++ b/files/fr/web/javascript/reference/about/index.md
@@ -7,48 +7,42 @@ tags:
 translation_of: Web/JavaScript/Reference/About
 original_slug: Web/JavaScript/Reference/A_propos
 ---
-<div>{{JsSidebar}}</div>
+{{JsSidebar}}
 
-<p>La référence JavaScript regroupe les différentes notions autour du langage JavaScript. L'ensemble du langage y est détaillé. Si vous développez une application JavaScript, vous pourrez utiliser ces différentes pages (d'où le titre de « référence »). Si vous apprenez JavaScript ou que vous souhaitez comprendre comment fonctionnent certains de ses composants, vous pouvez lire le <a href="/fr/docs/Web/JavaScript/Guide">Guide JavaScript</a>.</p>
+La référence JavaScript regroupe les différentes notions autour du langage JavaScript. L'ensemble du langage y est détaillé. Si vous développez une application JavaScript, vous pourrez utiliser ces différentes pages (d'où le titre de « référence »). Si vous apprenez JavaScript ou que vous souhaitez comprendre comment fonctionnent certains de ses composants, vous pouvez lire le [Guide JavaScript](/fr/docs/Web/JavaScript/Guide).
 
-<p>Le langage JavaScript a été conçu pour être utilisé dans un environnement dans lequel il s'intègre : un navigateur, des scripts côté serveur, etc. De façon générale, cette référence ne cible pas un environnement en particulier et tente de rester le plus « agnostique » possible.</p>
+Le langage JavaScript a été conçu pour être utilisé dans un environnement dans lequel il s'intègre : un navigateur, des scripts côté serveur, etc. De façon générale, cette référence ne cible pas un environnement en particulier et tente de rester le plus « agnostique » possible.
 
-<h2 id="Où_trouver_des_informations_sur_JavaScript">Où trouver des informations sur JavaScript</h2>
+## Où trouver des informations sur JavaScript
 
-<p>La documentation JavaScript sur les fonctionnalités essentielles du langage (qui correspondent à <a href="/fr/docs/Web/JavaScript/Language_Resources">ECMAScript</a> pour la plupart) se trouve dans les sections suivantes :</p>
+La documentation JavaScript sur les fonctionnalités essentielles du langage (qui correspondent à [ECMAScript](/fr/docs/Web/JavaScript/Language_Resources) pour la plupart) se trouve dans les sections suivantes :
 
-<ul>
- <li>Le <a href="/fr/docs/Web/JavaScript/Guide">Guide JavaScript</a></li>
- <li>La <a href="/fr/docs/Web/JavaScript/Reference">Référence JavaScript</a></li>
-</ul>
+- Le [Guide JavaScript](/fr/docs/Web/JavaScript/Guide)
+- La [Référence JavaScript](/fr/docs/Web/JavaScript/Reference)
 
-<p>Si vous découvrez JavaScript, vous pouvez débuter votre lecture avec le <a href="/fr/docs/Web/JavaScript/Guide">guide</a>. Une fois les fondamentaux acquis, vous pourrez utiliser la <a href="/fr/docs/Web/JavaScript/Reference">référence</a> pour obtenir plus d'informations sur les différents objets et éléments du langage.</p>
+Si vous découvrez JavaScript, vous pouvez débuter votre lecture avec le [guide](/fr/docs/Web/JavaScript/Guide). Une fois les fondamentaux acquis, vous pourrez utiliser la [référence](/fr/docs/Web/JavaScript/Reference) pour obtenir plus d'informations sur les différents objets et éléments du langage.
 
-<h2 id="Structure_de_cette_référence">Structure de cette référence</h2>
+## Structure de cette référence
 
-<p>La référence JavaScript s'organise autour de différents chapitres :</p>
+La référence JavaScript s'organise autour de différents chapitres :
 
-<dl>
- <dt><a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux">Les objets natifs standards</a></dt>
- <dd>Ce chapitre aborde l'ensemble des objets natifs standards JavaScript, ainsi que leurs méthodes et propriétés.</dd>
- <dt><a href="/fr/docs/Web/JavaScript/Reference/Instructions">Les instructions et déclarations</a></dt>
- <dd>Les applications JavaScript sont composées d'instructions organisées grâce à une syntaxe. Une instruction peut s'étaler sur plusieurs lignes et plusieurs instructions peuvent être présentes sur une ligne si elles sont séparées par des points-virugles.</dd>
- <dt><a href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs">Les expressions et opérateurs</a></dt>
- <dd>Ce chapitre traite des opérateurs présents en JavaScript ainsi que des expressions et des mots-clés du langage.</dd>
- <dt><a href="/fr/docs/Web/JavaScript/Reference/Fonctions">Les fonctions</a></dt>
- <dd>Ce chapitre aborde les concepts sur les fonctions en JavaScript.</dd>
- <dt><a href="/fr/docs/Web/JavaScript/Reference/Classes">Les classes</a></dt>
- <dd>Ce chapitre présente les classes, un sucre syntaxique pour les objets ajouté avec ECMAScript 2015.</dd>
- <dt><a href="/fr/docs/Web/JavaScript/Reference/Erreurs">Les erreurs</a></dt>
- <dd>Un chapitre sur les erreurs, les exceptions et les avertissements utilisées en JavaScript.</dd>
- <dt><a href="/fr/docs/Web/JavaScript/New_in_JavaScript">Les nouveautés en JavaScript</a></dt>
- <dd>Ce chapitre aborde les différentes versions de JavaScript et les changements qui ont eu lieu.</dd>
-</dl>
+- [Les objets natifs standards](/fr/docs/Web/JavaScript/Reference/Objets_globaux)
+  - : Ce chapitre aborde l'ensemble des objets natifs standards JavaScript, ainsi que leurs méthodes et propriétés.
+- [Les instructions et déclarations](/fr/docs/Web/JavaScript/Reference/Instructions)
+  - : Les applications JavaScript sont composées d'instructions organisées grâce à une syntaxe. Une instruction peut s'étaler sur plusieurs lignes et plusieurs instructions peuvent être présentes sur une ligne si elles sont séparées par des points-virugles.
+- [Les expressions et opérateurs](/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs)
+  - : Ce chapitre traite des opérateurs présents en JavaScript ainsi que des expressions et des mots-clés du langage.
+- [Les fonctions](/fr/docs/Web/JavaScript/Reference/Fonctions)
+  - : Ce chapitre aborde les concepts sur les fonctions en JavaScript.
+- [Les classes](/fr/docs/Web/JavaScript/Reference/Classes)
+  - : Ce chapitre présente les classes, un sucre syntaxique pour les objets ajouté avec ECMAScript 2015.
+- [Les erreurs](/fr/docs/Web/JavaScript/Reference/Erreurs)
+  - : Un chapitre sur les erreurs, les exceptions et les avertissements utilisées en JavaScript.
+- [Les nouveautés en JavaScript](/fr/docs/Web/JavaScript/New_in_JavaScript)
+  - : Ce chapitre aborde les différentes versions de JavaScript et les changements qui ont eu lieu.
 
-<h3 id="D'autres_pages_de_la_référence">D'autres pages de la référence</h3>
+### D'autres pages de la référence
 
-<ul>
- <li><a href="/fr/docs/JavaScript/R%C3%A9f%C3%A9rence_JavaScript/Annexes/Fonctionnalit%C3%A9s_d%C3%A9pr%C3%A9ci%C3%A9es">Les fonctionnalités dépréciées et obsolètes</a></li>
- <li><a href="/fr/docs/Web/JavaScript/Reference/Grammaire_lexicale">La grammaire lexicale de JavaScript</a></li>
- <li><a href="/fr/docs/Web/JavaScript/Structures_de_donn%C3%A9es">Les types de données et les structures de données</a></li>
-</ul>
+- [Les fonctionnalités dépréciées et obsolètes](/fr/docs/JavaScript/R%C3%A9f%C3%A9rence_JavaScript/Annexes/Fonctionnalit%C3%A9s_d%C3%A9pr%C3%A9ci%C3%A9es)
+- [La grammaire lexicale de JavaScript](/fr/docs/Web/JavaScript/Reference/Grammaire_lexicale)
+- [Les types de données et les structures de données](/fr/docs/Web/JavaScript/Structures_de_donn%C3%A9es)
diff --git a/files/fr/web/javascript/reference/classes/constructor/index.md b/files/fr/web/javascript/reference/classes/constructor/index.md
index f488f06dc5..ea9682c80d 100644
--- a/files/fr/web/javascript/reference/classes/constructor/index.md
+++ b/files/fr/web/javascript/reference/classes/constructor/index.md
@@ -9,24 +9,27 @@ tags:
 translation_of: Web/JavaScript/Reference/Classes/constructor
 browser-compat: javascript.classes.constructor
 ---
-<div>{{jsSidebar("Classes")}}</div>
+{{jsSidebar("Classes")}}
 
-<p>La méthode <strong><code>constructor</code></strong> est une méthode qui est utilisée pour créer et initialiser un objet lorsqu'on utilise le mot clé <a href="/fr/docs/Web/JavaScript/Reference/Statements/class"><code>class</code></a>.</p>
+La méthode **`constructor`** est une méthode qui est utilisée pour créer et initialiser un objet lorsqu'on utilise le mot clé [`class`](/fr/docs/Web/JavaScript/Reference/Statements/class).
 
-<div>{{EmbedInteractiveExample("pages/js/classes-constructor.html")}}</div>
+{{EmbedInteractiveExample("pages/js/classes-constructor.html")}}
 
-<h2 id="syntax">Syntaxe</h2>
+## Syntaxe
 
-<pre class="brush: js">constructor() { ... }
+```js
+constructor() { ... }
 constructor(argument0) { ... }
 constructor(argument0, argument1) { ... }
-constructor(argument0, argument1, ... , argumentN) { ... }</pre>
+constructor(argument0, argument1, ... , argumentN) { ... }
+```
 
-<h2 id="description">Description</h2>
+## Description
 
-<p>Un constructeur vous permet de fournir toute initialisation personnalisée qui doit être effectuée avant que toute autre méthode puisse être appelée sur un objet instancié.</p>
+Un constructeur vous permet de fournir toute initialisation personnalisée qui doit être effectuée avant que toute autre méthode puisse être appelée sur un objet instancié.
 
-<pre class="brush: js">class Person {
+```js
+class Person {
   constructor(name) {
     this.name = name;
   }
@@ -38,21 +41,27 @@ constructor(argument0, argument1, ... , argumentN) { ... }</pre>
 
 const otto = new Person('Otto');
 
-otto.introduce();</pre>
+otto.introduce();
+```
 
-<p>Si vous ne fournissez pas votre propre constructeur, alors un constructeur par défaut sera fourni pour vous. Si votre classe est une classe de base, le constructeur par défaut est vide :</p>
+Si vous ne fournissez pas votre propre constructeur, alors un constructeur par défaut sera fourni pour vous. Si votre classe est une classe de base, le constructeur par défaut est vide :
 
-<pre class="brush: js">constructor() {}</pre>
+```js
+constructor() {}
+```
 
-<p>Si votre classe est une classe dérivée, le constructeur par défaut appelle le constructeur parent, en transmettant tous les arguments qui ont été fournis :</p>
+Si votre classe est une classe dérivée, le constructeur par défaut appelle le constructeur parent, en transmettant tous les arguments qui ont été fournis :
 
-<pre class="brush: js">constructor(...args) {
+```js
+constructor(...args) {
   super(...args);
-}</pre>
+}
+```
 
-<p>Cela permet à un code comme celui-ci de fonctionner :</p>
+Cela permet à un code comme celui-ci de fonctionner :
 
-<pre class="brush: js">class ValidationError extends Error {
+```js
+class ValidationError extends Error {
   printCustomerMessage() {
     return `La validation a échoué :-( (détails : ${this.message})`;
   }
@@ -68,13 +77,15 @@ try {
     console.log('Erreur inconnue', error);
     throw error;
   }
-}</pre>
+}
+```
 
-<p>La classe <code>ValidationError</code> n'a pas besoin d'un constructeur explicite, car elle n'a pas besoin de faire d'initialisation personnalisée. Le constructeur par défaut se charge alors d'initialiser le parent <code>Error</code> à partir de l'argument qui lui est fourni.</p>
+La classe `ValidationError` n'a pas besoin d'un constructeur explicite, car elle n'a pas besoin de faire d'initialisation personnalisée. Le constructeur par défaut se charge alors d'initialiser le parent `Error` à partir de l'argument qui lui est fourni.
 
-<p>Cependant, si vous fournissez votre propre constructeur, et que votre classe dérive d'une certaine classe parente, alors vous devez appeler explicitement le constructeur de la classe parente en utilisant <code>super</code>. Par exemple :</p>
+Cependant, si vous fournissez votre propre constructeur, et que votre classe dérive d'une certaine classe parente, alors vous devez appeler explicitement le constructeur de la classe parente en utilisant `super`. Par exemple :
 
-<pre class="brush: js">class ValidationError extends Error {
+```js
+class ValidationError extends Error {
   constructor(message) {
     super(message);  // appelle le constructeur de la classe parent
     this.name = 'ValidationError';
@@ -96,17 +107,19 @@ try {
     console.log('Unknown error', error);
     throw error;
   }
-}</pre>
+}
+```
 
-<p>Il ne peut y avoir qu'une seule méthode spéciale portant le nom « <code>constructor</code> » dans une classe. Avoir plus d'une occurrence d'une méthode <code>constructor</code> dans une classe lancera une erreur <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/SyntaxError"><code>SyntaxError</code></a>.</p>
+Il ne peut y avoir qu'une seule méthode spéciale portant le nom « `constructor` » dans une classe. Avoir plus d'une occurrence d'une méthode `constructor` dans une classe lancera une erreur [`SyntaxError`](/fr/docs/Web/JavaScript/Reference/Global_Objects/SyntaxError).
 
-<h2 id="examples">Exemples</h2>
+## Exemples
 
-<h3 id="using_the_constructor_method">Utilisation de la méthode du <code>constructor</code></h3>
+### Utilisation de la méthode du `constructor`
 
-<p>Cet extrait de code est tiré de l'<a href="https://github.com/GoogleChrome/samples/blob/gh-pages/classes-es6/index.html">échantillon de classes</a> (<a href="https://googlechrome.github.io/samples/classes-es6/index.html">démo en direct</a>).</p>
+Cet extrait de code est tiré de l'[échantillon de classes](https://github.com/GoogleChrome/samples/blob/gh-pages/classes-es6/index.html) ([démo en direct](https://googlechrome.github.io/samples/classes-es6/index.html)).
 
-<pre class="brush: js">class Square extends Polygon {
+```js
+class Square extends Polygon {
   constructor(length) {
     // Ici, on appelle le constructeur de la classe parente avec des longueurs
     // fournies pour la largeur et la hauteur du polygone.
@@ -124,13 +137,15 @@ try {
     this.height = value**0.5;
     this.width = value**0.5;
   }
-}</pre>
+}
+```
 
-<h3 id="another_example">Un autre exemple</h3>
+### Un autre exemple
 
-<p>Ici, le prototype de la classe <code>Square</code> est modifié — mais le constructeur de sa classe de base <code>Polygon</code> est toujours appelé lorsqu'une nouvelle instance d'un carré est créée.</p>
+Ici, le prototype de la classe `Square` est modifié — mais le constructeur de sa classe de base `Polygon` est toujours appelé lorsqu'une nouvelle instance d'un carré est créée.
 
-<pre class="brush: js">class Polygon {
+```js
+class Polygon {
     constructor() {
         this.name = "Polygone";
     }
@@ -150,23 +165,21 @@ console.log(Object.getPrototypeOf(Square.prototype) === Polygon.prototype); //fa
 console.log(Object.getPrototypeOf(Square.prototype) === Rectangle.prototype); //true
 
 let newInstance = new Square();
-console.log(newInstance.name); // Polygone</pre>
+console.log(newInstance.name); // Polygone
+```
 
-<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="see_also">Voir aussi</h2>
+## Voir aussi
 
-<ul>
-  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/super"><code>super()</code></a></li>
-  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/class">Expression <code>class</code></a></li>
-  <li><a href="/fr/docs/Web/JavaScript/Reference/Statements/class">Déclaration <code>class</code></a></li>
-  <li><a href="/fr/docs/Web/JavaScript/Reference/Classes"><code>Classes</code></a></li>
-  <li><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Object/constructor">Object.prototype.constructor</a>
-  </li>
-</ul>
+- [`super()`](/fr/docs/Web/JavaScript/Reference/Operators/super)
+- [Expression `class`](/fr/docs/Web/JavaScript/Reference/Operators/class)
+- [Déclaration `class`](/fr/docs/Web/JavaScript/Reference/Statements/class)
+- [`Classes`](/fr/docs/Web/JavaScript/Reference/Classes)
+- [Object.prototype.constructor](/fr/docs/Web/JavaScript/Reference/Global_Objects/Object/constructor)
diff --git a/files/fr/web/javascript/reference/classes/extends/index.md b/files/fr/web/javascript/reference/classes/extends/index.md
index 8e3af50594..2dee751c38 100644
--- a/files/fr/web/javascript/reference/classes/extends/index.md
+++ b/files/fr/web/javascript/reference/classes/extends/index.md
@@ -7,32 +7,30 @@ tags:
   - Reference
 translation_of: Web/JavaScript/Reference/Classes/extends
 ---
-<div>{{jsSidebar("Classes")}}</div>
+{{jsSidebar("Classes")}}
 
-<p>Le mot-clé <strong><code>extends</code></strong> est utilisé dans les <a href="/fr/docs/Web/JavaScript/Reference/Instructions/class">déclarations</a> et <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/class">expressions de classes</a> afin de signifier qu'un type représenté par une classe hérite d'un autre type.</p>
+Le mot-clé **`extends`** est utilisé dans les [déclarations](/fr/docs/Web/JavaScript/Reference/Instructions/class) et [expressions de classes](/fr/docs/Web/JavaScript/Reference/Opérateurs/class) afin de signifier qu'un type représenté par une classe hérite d'un autre type.
 
+{{EmbedInteractiveExample("pages/js/classes-extends.html", "taller")}}
 
+## Syntaxe
 
-<div>{{EmbedInteractiveExample("pages/js/classes-extends.html", "taller")}}</div>
+    class ClasseFille extends ClasseParente { ... }
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Description
 
-<pre class="syntaxbox">class ClasseFille extends ClasseParente { ... }
-</pre>
+Le mot-clé `extends` peut être utilisé pour créer des sous-classes de classes existantes (natives ou non).
 
-<h2 id="Description">Description</h2>
+La propriété `.prototype` d'une classe fille (aussi appelée une _extension_) doit être un {{jsxref("Object")}} ou {{jsxref("null")}}.
 
-<p>Le mot-clé <code>extends</code> peut être utilisé pour créer des sous-classes de classes existantes (natives ou non).</p>
+## Exemples
 
-<p>La propriété <code>.prototype</code> d'une classe fille (aussi appelée une <em>extension</em>) doit être un {{jsxref("Object")}} ou {{jsxref("null")}}.</p>
+### Utiliser `extends`
 
-<h2 id="Exemples">Exemples</h2>
+Ce fragment de code est tiré de [cet exemple](https://github.com/GoogleChrome/samples/blob/gh-pages/classes-es6/index.html) et crée une classe `Carré` qui hérite de `Polygone` :
 
-<h3 id="Utiliser_extends">Utiliser <code>extends</code></h3>
-
-<p>Ce fragment de code est tiré de <a href="https://github.com/GoogleChrome/samples/blob/gh-pages/classes-es6/index.html">cet exemple</a> et crée une classe <code>Carré</code> qui hérite de <code>Polygone</code> :</p>
-
-<pre class="brush: js">class Carré extends Polygone {
+```js
+class Carré extends Polygone {
   constructor(longueur) {
     // On utilise le constructeur de la classe parente
     // avec le mot-clé super
@@ -47,13 +45,15 @@ translation_of: Web/JavaScript/Reference/Classes/extends
     return this.hauteur * this.largeur;
   }
 
-}</pre>
+}
+```
 
-<h3 id="Utiliser_extends_avec_des_objets_natifs">Utiliser <code>extends</code> avec des objets natifs</h3>
+### Utiliser `extends` avec des objets natifs
 
-<p>Dans l'exemple suivant, on crée l'équivalent d'une sous-classe pour {{jsxref("Date")}} :</p>
+Dans l'exemple suivant, on crée l'équivalent d'une sous-classe pour {{jsxref("Date")}} :
 
-<pre class="brush: js">class maDate extends Date {
+```js
+class maDate extends Date {
   constructor() {
     super();
   }
@@ -62,15 +62,17 @@ translation_of: Web/JavaScript/Reference/Classes/extends
     var mois = ['Jan','Fév','Mar','Avr','Mai','Juin','Juil','Août','Sep','Oct','Nov','Déc'];
     return this.getDate() + "-" + mois[this.getMonth()] + "-" + this.getFullYear();
   }
-}</pre>
+}
+```
 
-<p>Ces exemples sont extraits de ces deux pages : <a href="https://googlechrome.github.io/samples/classes-es6/index.html">démonstration</a>, <a href="https://github.com/GoogleChrome/samples/blob/gh-pages/classes-es6/index.html">source</a>.</p>
+Ces exemples sont extraits de ces deux pages : [démonstration](https://googlechrome.github.io/samples/classes-es6/index.html), [source](https://github.com/GoogleChrome/samples/blob/gh-pages/classes-es6/index.html).
 
-<h3 id="Étendre_null">Étendre <code>null</code></h3>
+### Étendre `null`
 
-<p>Étendre {{jsxref("null")}} se fait comme avec une classe normale sauf que l'objet prototype n'hérite pas de {{jsxref("Object.prototype")}}.</p>
+Étendre {{jsxref("null")}} se fait comme avec une classe normale sauf que l'objet prototype n'hérite pas de {{jsxref("Object.prototype")}}.
 
-<pre class="brush: js">class extensionNull extends null {
+```js
+class extensionNull extends null {
   constructor() {}
 }
 
@@ -78,37 +80,20 @@ Object.getPrototypeOf(extensionNull); // Function.prototype
 Object.getPrototypeOf(extensionNull.prototype); // null
 
 new extensionNull(); // ReferenceError
-</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-class-definitions', 'extends')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-class-definitions', 'extends')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.classes.extends")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li><a href="/fr/docs/Web/JavaScript/Reference/Classes">Les classes</a></li>
- <li><code><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/super">super</a></code></li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                    | État                         | Commentaires         |
+| -------------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ES2015', '#sec-class-definitions', 'extends')}} | {{Spec2('ES2015')}}     | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-class-definitions', 'extends')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.classes.extends")}}
+
+## Voir aussi
+
+- [Les classes](/fr/docs/Web/JavaScript/Reference/Classes)
+- [`super`](/fr/docs/Web/JavaScript/Reference/Opérateurs/super)
diff --git a/files/fr/web/javascript/reference/classes/index.md b/files/fr/web/javascript/reference/classes/index.md
index 33721a3faa..2808bc1d39 100644
--- a/files/fr/web/javascript/reference/classes/index.md
+++ b/files/fr/web/javascript/reference/classes/index.md
@@ -9,39 +9,43 @@ tags:
   - Reference
 translation_of: Web/JavaScript/Reference/Classes
 ---
-<div>{{JsSidebar("Classes")}}</div>
+{{JsSidebar("Classes")}}
 
-<p>Les classes JavaScript ont été introduites avec ECMAScript 2015. Elles sont un « sucre syntaxique » par rapport à l'héritage prototypal. En effet, cette syntaxe n'introduit pas un nouveau modèle d'héritage dans JavaScript ! Elle fournit uniquement une syntaxe plus simple pour créer des objets et manipuler l'héritage.</p>
+Les classes JavaScript ont été introduites avec ECMAScript 2015. Elles sont un « sucre syntaxique » par rapport à l'héritage prototypal. En effet, cette syntaxe n'introduit pas un nouveau modèle d'héritage dans JavaScript ! Elle fournit uniquement une syntaxe plus simple pour créer des objets et manipuler l'héritage.
 
-<h2 id="Définir_des_classes">Définir des classes</h2>
+## Définir des classes
 
-<p>En réalité, les classes sont juste des <a href="/fr/docs/Web/JavaScript/Reference/Fonctions">fonctions</a> spéciales. Ainsi, les classes sont définies de la même façon que les fonctions : par déclaration, ou par expression.</p>
+En réalité, les classes sont juste des [fonctions](/fr/docs/Web/JavaScript/Reference/Fonctions) spéciales. Ainsi, les classes sont définies de la même façon que les fonctions : par déclaration, ou par expression.
 
-<h3 id="Les_déclarations_de_classes">Les déclarations de classes</h3>
+### Les déclarations de classes
 
-<p>Pour utiliser une déclaration de classe simple, on utilisera le mot-clé <code>class</code>, suivi par le nom de la classe que l'on déclare (ici « Rectangle »).</p>
+Pour utiliser une déclaration de classe simple, on utilisera le mot-clé `class`, suivi par le nom de la classe que l'on déclare (ici « Rectangle »).
 
-<pre class="brush: js">class Rectangle {
+```js
+class Rectangle {
   constructor(hauteur, largeur) {
     this.hauteur = hauteur;
     this.largeur = largeur;
   }
-}</pre>
+}
+```
 
-<h4 id="Remontée_des_déclarations_(hoisting)">Remontée des déclarations (<em>hoisting</em>)</h4>
+#### Remontée des déclarations (_hoisting_)
 
-<p><a href="/fr/docs/Web/JavaScript/Reference/Instructions/function">Les déclarations de fonctions</a> sont remontées dans le code. En revanche, ce n'est pas le cas pour les déclarations de classes. Ainsi, il est nécessaire de déclarer la classe avant de l'instancier. Dans le cas contraire, on obtient une {{jsxref("ReferenceError")}} :</p>
+[Les déclarations de fonctions](/fr/docs/Web/JavaScript/Reference/Instructions/function) sont remontées dans le code. En revanche, ce n'est pas le cas pour les déclarations de classes. Ainsi, il est nécessaire de déclarer la classe avant de l'instancier. Dans le cas contraire, on obtient une {{jsxref("ReferenceError")}} :
 
-<pre class="brush: js example-bad">const p = new Rectangle(); // ReferenceError
+```js example-bad
+const p = new Rectangle(); // ReferenceError
 
 class Rectangle {}
-</pre>
+```
 
-<h3 id="Les_expressions_de_classes">Les expressions de classes</h3>
+### Les expressions de classes
 
-<p>Il est possible d'utiliser des expressions de classes, nommées ou anonymes. Si on utilise un nom dans l'expression, ce nom ne sera accessible que depuis le corps de la classe via la propriété {{jsxref("Function.name", "name")}} (cette valeur ne sera pas directement accessible pour les instances).</p>
+Il est possible d'utiliser des expressions de classes, nommées ou anonymes. Si on utilise un nom dans l'expression, ce nom ne sera accessible que depuis le corps de la classe via la propriété {{jsxref("Function.name", "name")}} (cette valeur ne sera pas directement accessible pour les instances).
 
-<pre class="brush: js">// anonyme
+```js
+// anonyme
 let Rectangle = class {
   constructor(hauteur, largeur) {
     this.hauteur = hauteur;
@@ -56,31 +60,30 @@ let Rectangle = class Rectangle {
     this.largeur = largeur;
   }
 };
-</pre>
+```
 
-<div class="note">
-<p><strong>Note :</strong> Les mêmes règles s'appliquent aux expressions de classes en ce qui concerne la remontée (<em>hoisting</em>) des classes (cf. le paragraphe précédent sur les remontées des déclarations de classe).</p>
-</div>
+> **Note :** Les mêmes règles s'appliquent aux expressions de classes en ce qui concerne la remontée (_hoisting_) des classes (cf. le paragraphe précédent sur les remontées des déclarations de classe).
 
-<h2 id="Corps_d'une_classe_et_définition_des_méthodes">Corps d'une classe et définition des méthodes</h2>
+## Corps d'une classe et définition des méthodes
 
-<p>Le corps d'une classe est la partie contenue entre les accolades. C'est dans cette partie que l'on définit les propriétés d'une classe comme ses méthodes et son constructeur.</p>
+Le corps d'une classe est la partie contenue entre les accolades. C'est dans cette partie que l'on définit les propriétés d'une classe comme ses méthodes et son constructeur.
 
-<h3 id="Mode_strict">Mode strict</h3>
+### Mode strict
 
-<p>Le corps des classes, pour les expressions et pour les déclarations de classes, est exécuté en <a href="/fr/docs/Web/JavaScript/Reference/Strict_mode">mode strict</a> (autrement dit, le constructeur, les méthodes statiques, le prototype, les accesseurs (<em>getters</em>) et mutateurs (<em>setters</em>) sont exécutés en mode strict).</p>
+Le corps des classes, pour les expressions et pour les déclarations de classes, est exécuté en [mode strict](/fr/docs/Web/JavaScript/Reference/Strict_mode) (autrement dit, le constructeur, les méthodes statiques, le prototype, les accesseurs (_getters_) et mutateurs (_setters_) sont exécutés en mode strict).
 
-<h3 id="Constructeur">Constructeur</h3>
+### Constructeur
 
-<p>La méthode <code><a href="/fr/docs/Web/JavaScript/Reference/Classes/constructor">constructor</a></code> est une méthode spéciale qui permet de créer et d'initialiser les objet créés avec une classe. Il ne peut y avoir qu'une seule méthode avec le nom "constructor" pour une classe donnée. Si la classe contient plusieurs occurences d'une méthode <code>constructor</code>, cela provoquera une exception {{jsxref("SyntaxError")}}.</p>
+La méthode [`constructor`](/fr/docs/Web/JavaScript/Reference/Classes/constructor) est une méthode spéciale qui permet de créer et d'initialiser les objet créés avec une classe. Il ne peut y avoir qu'une seule méthode avec le nom "constructor" pour une classe donnée. Si la classe contient plusieurs occurences d'une méthode `constructor`, cela provoquera une exception {{jsxref("SyntaxError")}}.
 
-<p>Le constructeur ainsi déclaré peut utiliser le mot-clé <code>super</code> afin d'appeler le constructeur de la classe parente.</p>
+Le constructeur ainsi déclaré peut utiliser le mot-clé `super` afin d'appeler le constructeur de la classe parente.
 
-<h3 id="Méthodes_de_prototype">Méthodes de prototype</h3>
+### Méthodes de prototype
 
-<p>Voir aussi les définitions de méthode.</p>
+Voir aussi les définitions de méthode.
 
-<pre class="brush: js">class Rectangle {
+```js
+class Rectangle {
   constructor(hauteur, largeur) {
     this.hauteur = hauteur;
     this.largeur = largeur;
@@ -97,13 +100,15 @@ let Rectangle = class Rectangle {
 
 const carré = new Rectangle(10, 10);
 
-console.log(carré.area);</pre>
+console.log(carré.area);
+```
 
-<h3 id="Méthodes_statiques">Méthodes statiques</h3>
+### Méthodes statiques
 
-<p>Le mot-clé <code><a href="/fr/docs/Web/JavaScript/Reference/Classes/static">static</a></code> permet de définir une méthode statique pour une classe. Les méthodes statiques sont appelées par rapport à la classe entière et non par rapport à une <a href="/fr/docs/Web/JavaScript/Introduction_à_JavaScript_orienté_objet#L'instance">instance</a> donnée (ces méthodes ne peuvent pas être appelées « depuis » une instance). Ces méthodes sont généralement utilisées sous formes d'utilitaires au sein d'applications.</p>
+Le mot-clé [`static`](/fr/docs/Web/JavaScript/Reference/Classes/static) permet de définir une méthode statique pour une classe. Les méthodes statiques sont appelées par rapport à la classe entière et non par rapport à une [instance](/fr/docs/Web/JavaScript/Introduction_à_JavaScript_orienté_objet#L'instance) donnée (ces méthodes ne peuvent pas être appelées « depuis » une instance). Ces méthodes sont généralement utilisées sous formes d'utilitaires au sein d'applications.
 
-<pre class="brush: js">class Point {
+```js
+class Point {
   constructor(x, y) {
     this.x = x;
     this.y = y;
@@ -119,13 +124,15 @@ console.log(carré.area);</pre>
 const p1 = new Point(5, 5);
 const p2 = new Point(10, 10);
 
-console.log(Point.distance(p1, p2));</pre>
+console.log(Point.distance(p1, p2));
+```
 
-<h3 id="Gestion_de_this_pour_le_prototype_et_les_méthodes_statiques">Gestion de <code>this</code> pour le prototype et les méthodes statiques</h3>
+### Gestion de `this` pour le prototype et les méthodes statiques
 
-<p>Lorsqu'une méthode statique ou une méthode liée au prototype est appelée sans valeur <code>this</code>, celle-ci vaudra <code>undefined</code> au sein de la fonction. Il n'y aura pas d'autodétermination de <code>this</code> (<em>autoboxing</em> en anglais). On aura le même résultat si on invoque ces fonctions dans du code non-strict car les fonctions liées aux classes sont exécutées en mode strict.</p>
+Lorsqu'une méthode statique ou une méthode liée au prototype est appelée sans valeur `this`, celle-ci vaudra `undefined` au sein de la fonction. Il n'y aura pas d'autodétermination de `this` (_autoboxing_ en anglais). On aura le même résultat si on invoque ces fonctions dans du code non-strict car les fonctions liées aux classes sont exécutées en mode strict.
 
-<pre class="brush: js">class Animal {
+```js
+class Animal {
   crie() {
     return this;
   }
@@ -141,13 +148,15 @@ crie(); // undefined
 
 Animal.mange(); // class Animal
 let mange = Animal.mange;
-mange(); // undefined</pre>
+mange(); // undefined
+```
 
-<p>Si on écrit le code avec des fonctions traditionnelles plutôt qu'avec des classes et qu'on utilise le mode non-strict, l'autodétermination de <code>this</code> sera faite en fonction du contexte dans lequel la fonction a été appelée. Si la valeur initiale est <code>undefined</code>, <code>this</code> correspondra à l'objet global.</p>
+Si on écrit le code avec des fonctions traditionnelles plutôt qu'avec des classes et qu'on utilise le mode non-strict, l'autodétermination de `this` sera faite en fonction du contexte dans lequel la fonction a été appelée. Si la valeur initiale est `undefined`, `this` correspondra à l'objet global.
 
-<p>L'autodétermination de <code>this</code> n'a pas lieu en mode strict, la valeur <code>this</code> est passée telle quelle.</p>
+L'autodétermination de `this` n'a pas lieu en mode strict, la valeur `this` est passée telle quelle.
 
-<pre class="brush: js">function Animal() { }
+```js
+function Animal() { }
 
 Animal.prototype.crie = function() {
   return this;
@@ -163,75 +172,80 @@ crie(); // l'objet global
 
 let mange = Animal.mange;
 mange(); // l'objet global
-</pre>
+```
 
-<h3 id="Propriétés_des_instances">Propriétés des instances</h3>
+### Propriétés des instances
 
-<p>Les propriétés des instances doivent être définies dans les méthodes de la classe :</p>
+Les propriétés des instances doivent être définies dans les méthodes de la classe :
 
-<pre class="brush: js">class Rectangle {
+```js
+class Rectangle {
   constructor(hauteur, largeur) {
     this.hauteur = hauteur;
     this.largeur = largeur;
   }
-}</pre>
+}
+```
 
-<p>Les propriétés statiques ou les données relatives au prototype doivent être définies en dehors de la déclaration comportant le corps de la classe :</p>
+Les propriétés statiques ou les données relatives au prototype doivent être définies en dehors de la déclaration comportant le corps de la classe :
 
-<pre class="brush: js">Rectangle.largeurStatique = 20;
-Rectangle.prototype.largeurProto = 25;</pre>
+```js
+Rectangle.largeurStatique = 20;
+Rectangle.prototype.largeurProto = 25;
+```
 
-<h3 id="Déclarations_de_champs">Déclarations de champs</h3>
+### Déclarations de champs
 
-<p>{{SeeCompatTable}}</p>
+{{SeeCompatTable}}
 
-<div class="warning">
-<p><strong>Attention :</strong> Les déclarations de champs publics et privés sont une <a href="https://github.com/tc39/proposal-class-fields">fonctionnalité expérimentale actuellement proposée pour être intégrée dans le standard ECMAScript</a>. Elle n'est pas implémentée par la majorité des navigateurs mais on peut émuler cette fonctionnalité en utilisant un système de compilation tel que <a href="https://babeljs.io/">Babel</a>.</p>
-</div>
+> **Attention :** Les déclarations de champs publics et privés sont une [fonctionnalité expérimentale actuellement proposée pour être intégrée dans le standard ECMAScript](https://github.com/tc39/proposal-class-fields). Elle n'est pas implémentée par la majorité des navigateurs mais on peut émuler cette fonctionnalité en utilisant un système de compilation tel que [Babel](https://babeljs.io/).
 
-<h4 id="Déclarations_de_champs_publics">Déclarations de champs publics</h4>
+#### Déclarations de champs publics
 
-<p>En utilisant la syntaxe pour la déclaration des champs, on peut réécrire l'exemple précédent de la façon suivante :</p>
+En utilisant la syntaxe pour la déclaration des champs, on peut réécrire l'exemple précédent de la façon suivante :
 
-<pre class="brush: js">class Rectangle {
+```js
+class Rectangle {
   hauteur = 0;
   largeur;
   constructor(hauteur, largeur) {
     this.hauteur = hauteur;
     this.largeur = largeur;
   }
-}</pre>
+}
+```
 
-<p>En déclarant les champs en préalable, il est plus facile de comprendre la classe dans son ensemble. De plus, on s'assure que les champs soient toujours présents.</p>
+En déclarant les champs en préalable, il est plus facile de comprendre la classe dans son ensemble. De plus, on s'assure que les champs soient toujours présents.
 
-<p>Comme on peut le voir dans cet exemple, les champs peuvent éventuellement être déclarés avec une valeur par défaut.</p>
+Comme on peut le voir dans cet exemple, les champs peuvent éventuellement être déclarés avec une valeur par défaut.
 
-<h4 id="Déclarations_de_champs_privés">Déclarations de champs privés</h4>
+#### Déclarations de champs privés
 
-<p>En utilisant des champs privés, on peut revoir la définition de la façon suivante :</p>
+En utilisant des champs privés, on peut revoir la définition de la façon suivante :
 
-<pre class="brush: js">class Rectangle {
+```js
+class Rectangle {
   #hauteur = 0;
   #largeur;
   constructor(hauteur, largeur){
     this.#hauteur = hauteur;
     this.#largeur = largeur;
   }
-}</pre>
+}
+```
 
-<p>Si on utilise les champs privés hors de la classe, cela génèrera une erreur. Ces champs ne peuvent être lus ou modifiés que depuis le corps de la classe. En évitant d'exposer des éléments à l'extérieur, on s'assure que les portions de code qui consomment cette classe n'utilise pas ses détails internes et on peut alors maintenir la classe dans son ensemble et modifier les détails internes si besoin.</p>
+Si on utilise les champs privés hors de la classe, cela génèrera une erreur. Ces champs ne peuvent être lus ou modifiés que depuis le corps de la classe. En évitant d'exposer des éléments à l'extérieur, on s'assure que les portions de code qui consomment cette classe n'utilise pas ses détails internes et on peut alors maintenir la classe dans son ensemble et modifier les détails internes si besoin.
 
-<div class="note">
-<p><strong>Note :</strong> Les champs privés doivent nécessairement être déclarés en premier dans les déclarations de champ.</p>
-</div>
+> **Note :** Les champs privés doivent nécessairement être déclarés en premier dans les déclarations de champ.
 
-<p>Il n'est pas possible de créer des champs privés <em>a posteriori</em> au moment où on leur affecterait une valeur. Autrement dit, il est possible de déclarer une variable normale au moment voulu lorsqu'on lui affecte une valeur tandis que pour les champs privés, ces derniers doivent être déclarés (éventuellement initialisés) en amont, au début du corps de la classe.</p>
+Il n'est pas possible de créer des champs privés _a posteriori_ au moment où on leur affecterait une valeur. Autrement dit, il est possible de déclarer une variable normale au moment voulu lorsqu'on lui affecte une valeur tandis que pour les champs privés, ces derniers doivent être déclarés (éventuellement initialisés) en amont, au début du corps de la classe.
 
-<h2 id="Créer_une_sous-classe_avec_extends">Créer une sous-classe avec <code>extends</code></h2>
+## Créer une sous-classe avec `extends`
 
-<p>Le mot-clé <code><a href="/fr/docs/Web/JavaScript/Reference/Classes/extends">extends</a></code>, utilisé dans les déclarations ou les expressions de classes, permet de créer une classe qui hérite d'une autre classe (on parle aussi de « sous-classe » ou de « classe-fille »).</p>
+Le mot-clé [`extends`](/fr/docs/Web/JavaScript/Reference/Classes/extends), utilisé dans les déclarations ou les expressions de classes, permet de créer une classe qui hérite d'une autre classe (on parle aussi de « sous-classe » ou de « classe-fille »).
 
-<pre class="brush: js">class Animal {
+```js
+class Animal {
   constructor(nom) {
     this.nom = nom;
   }
@@ -248,13 +262,15 @@ class Chien extends Animal {
   parle() {
     console.log(`${this.nom} aboie.`);
   }
-}</pre>
+}
+```
 
-<p>Si on déclare un constructeur dans une classe fille, on doit utiliser <code>super()</code> avant <code>this</code>.</p>
+Si on déclare un constructeur dans une classe fille, on doit utiliser `super()` avant `this`.
 
-<p>On peut également étendre des classes plus <em>traditionnelles</em> basées sur des constructeurs fonctionnels :</p>
+On peut également étendre des classes plus _traditionnelles_ basées sur des constructeurs fonctionnels :
 
-<pre class="brush: js">function Animal (nom) {
+```js
+function Animal (nom) {
   this.nom = nom;
 }
 Animal.prototype.crie = function () {
@@ -271,11 +287,13 @@ class Chien extends Animal {
 let c = new Chien('Ida');
 c.crie();
 // Ida fait du bruit.
-// Ida aboie.</pre>
+// Ida aboie.
+```
 
-<p>En revanche, les classes ne permettent pas d'étendre des objets classiques non-constructibles. Si on souhaite créer un lien d'héritage en un objet et une classe, on utilisera {{jsxref("Object.setPrototypeOf()")}} :</p>
+En revanche, les classes ne permettent pas d'étendre des objets classiques non-constructibles. Si on souhaite créer un lien d'héritage en un objet et une classe, on utilisera {{jsxref("Object.setPrototypeOf()")}} :
 
-<pre class="brush: js">const Animal = {
+```js
+const Animal = {
   crie() {
     console.log(`${this.nom} fait du bruit.`);
   }
@@ -295,30 +313,34 @@ Object.setPrototypeOf(Chien.prototype, Animal);
 let d = new Chien('Ida');
 d.crie();
 // Ida fait du bruit
-// Ida aboie.</pre>
+// Ida aboie.
+```
 
-<h2 id="Le_symbole_species">Le symbole <code>species</code></h2>
+## Le symbole `species`
 
-<p>Lorsqu'on souhaite renvoyer des objets {{jsxref("Array")}} avec une sous-classe <code>MonArray</code>, on peut utiliser symbole <code>species</code> pour surcharger le constructeur par défaut.</p>
+Lorsqu'on souhaite renvoyer des objets {{jsxref("Array")}} avec une sous-classe `MonArray`, on peut utiliser symbole `species` pour surcharger le constructeur par défaut.
 
-<p>Par exemple, si, lorsqu'on utilise des méthodes comme {{jsxref("Array.map","map()")}} qui renvoient le constructeur par défaut et qu'on veut qu'elles renvoient <code>Array</code> plutôt que <code>MonArray</code>, on utilisera {{jsxref("Symbol.species")}} :</p>
+Par exemple, si, lorsqu'on utilise des méthodes comme {{jsxref("Array.map","map()")}} qui renvoient le constructeur par défaut et qu'on veut qu'elles renvoient `Array` plutôt que `MonArray`, on utilisera {{jsxref("Symbol.species")}} :
 
-<pre class="brush: js">class MonArray extends Array {
+```js
+class MonArray extends Array {
   // On surcharge species
   // avec le constructeur Array du parent
   static get [Symbol.species]() { return Array; }
 }
 let a = new MonArray(1,2,3);
-let mapped = a.map(x =&gt; x * x);
+let mapped = a.map(x => x * x);
 
 console.log(mapped instanceof MonArray); // false
-console.log(mapped instanceof Array);    // true</pre>
+console.log(mapped instanceof Array);    // true
+```
 
-<h2 id="Utiliser_super_pour_la_classe_parente">Utiliser super pour la classe parente</h2>
+## Utiliser super pour la classe parente
 
-<p>Le mot-clé <code><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/super">super</a></code> est utilisé pour appeler les fonctions rattachées à un objet parent.</p>
+Le mot-clé [`super`](/fr/docs/Web/JavaScript/Reference/Opérateurs/super) est utilisé pour appeler les fonctions rattachées à un objet parent.
 
-<pre class="brush: js">class Chat {
+```js
+class Chat {
   constructor(nom) {
     this.nom = nom;
   }
@@ -334,78 +356,55 @@ class Lion extends Chat {
     console.log(`${this.nom} rugit.`);
   }
 }
-</pre>
+```
 
-<h2 id="Les_mix-ins">Les <em>mix-ins</em></h2>
+## Les _mix-ins_
 
-<p>Les sous-classes abstraites ou <em>mix-ins</em> sont des modèles (<em>templates</em>) pour des classes. Une classe ECMAScript ne peut avoir qu'une seule classe parente et il n'est donc pas possible, par exemple, d'hériter de plusieurs classes dont une classe abstraite. La fonctionnalité dont on souhaite disposer doit être fournie par la classe parente.</p>
+Les sous-classes abstraites ou _mix-ins_ sont des modèles (_templates_) pour des classes. Une classe ECMAScript ne peut avoir qu'une seule classe parente et il n'est donc pas possible, par exemple, d'hériter de plusieurs classes dont une classe abstraite. La fonctionnalité dont on souhaite disposer doit être fournie par la classe parente.
 
-<p>Une fonction peut prendre une classe parente en entrée et renvoyer une classe fille qui étend cette classe parente. Cela peut permettre d'émuler les <em>mix-ins</em> avec ECMAScript.</p>
+Une fonction peut prendre une classe parente en entrée et renvoyer une classe fille qui étend cette classe parente. Cela peut permettre d'émuler les _mix-ins_ avec ECMAScript.
 
-<pre class="brush: js">let calculetteMixin = Base =&gt; class extends Base {
+```js
+let calculetteMixin = Base => class extends Base {
   calc() { }
 };
 
-let aleatoireMixin = Base =&gt; class extends Base {
+let aleatoireMixin = Base => class extends Base {
   randomiseur() { }
 };
-</pre>
+```
 
-<p>Une classe utilisant ces <em>mix-ins</em> peut alors être écrite de cette façon :</p>
+Une classe utilisant ces _mix-ins_ peut alors être écrite de cette façon :
 
-<pre class="brush: js">class Toto { }
+```js
+class Toto { }
 class Truc extends calculetteMixin(aleatoireMixin(Toto)) { }
-</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-class-definitions', 'Class definitions')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES2016', '#sec-class-definitions', 'Class definitions')}}</td>
-   <td>{{Spec2('ES2016')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES2017', '#sec-class-definitions', 'Class definitions')}}</td>
-   <td>{{Spec2('ES2017')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-class-definitions', 'Class definitions')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.classes")}}</p>
-
-<h2 id="Utilisation_via_l'éditeur_multiligne_dans_Firefox">Utilisation via l'éditeur multiligne dans Firefox</h2>
-
-<p>Une classe ne peut pas être redéfinie. Si vous testez votre code via l'éditeur multiligne JavaScript de Firefox (Outils &gt; Développement web &gt; Editeur multiligne JavaScript) et que vous exécutez à plusieurs reprises votre code avec la définition d'une classe, vous obtiendrez une exception SyntaxError : <em>redeclaration of let &lt;class-name&gt;</em>.</p>
-
-<p>Pour relancer une définition, il faut utiliser le menu Exécuter &gt; Recharger et exécuter. À ce sujet, voir le bug {{bug("1428672")}}.</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li><a href="/fr/docs/Web/JavaScript/Reference/Fonctions">Les fonctions</a></li>
- <li>{{jsxref("Instructions/class", "Les déclarations de classes","",1)}}</li>
- <li>{{jsxref("Opérateurs/class", "Les expressions de classes","",1)}}</li>
- <li>{{jsxref("Opérateurs/super", "super")}}</li>
- <li><a href="https://tech.mozfr.org/post/2015/07/29/ES6-en-details-%3A-les-classes">Billet sur les classes (traduction en français)</a></li>
- <li><a href="https://github.com/tc39/proposal-class-fields">Champs publics et privés pour les classes (proposition de niveau 3)</a></li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                | État                         | Commentaires         |
+| -------------------------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ES2015', '#sec-class-definitions', 'Class definitions')}} | {{Spec2('ES2015')}}     | Définition initiale. |
+| {{SpecName('ES2016', '#sec-class-definitions', 'Class definitions')}} | {{Spec2('ES2016')}}     |                      |
+| {{SpecName('ES2017', '#sec-class-definitions', 'Class definitions')}} | {{Spec2('ES2017')}}     |                      |
+| {{SpecName('ESDraft', '#sec-class-definitions', 'Class definitions')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.classes")}}
+
+## Utilisation via l'éditeur multiligne dans Firefox
+
+Une classe ne peut pas être redéfinie. Si vous testez votre code via l'éditeur multiligne JavaScript de Firefox (Outils > Développement web > Editeur multiligne JavaScript) et que vous exécutez à plusieurs reprises votre code avec la définition d'une classe, vous obtiendrez une exception SyntaxError : _redeclaration of let \<class-name>_.
+
+Pour relancer une définition, il faut utiliser le menu Exécuter > Recharger et exécuter. À ce sujet, voir le bug {{bug("1428672")}}.
+
+## Voir aussi
+
+- [Les fonctions](/fr/docs/Web/JavaScript/Reference/Fonctions)
+- {{jsxref("Instructions/class", "Les déclarations de classes","",1)}}
+- {{jsxref("Opérateurs/class", "Les expressions de classes","",1)}}
+- {{jsxref("Opérateurs/super", "super")}}
+- [Billet sur les classes (traduction en français)](https://tech.mozfr.org/post/2015/07/29/ES6-en-details-%3A-les-classes)
+- [Champs publics et privés pour les classes (proposition de niveau 3)](https://github.com/tc39/proposal-class-fields)
diff --git a/files/fr/web/javascript/reference/classes/private_class_fields/index.md b/files/fr/web/javascript/reference/classes/private_class_fields/index.md
index 9d1187b01d..45ad084074 100644
--- a/files/fr/web/javascript/reference/classes/private_class_fields/index.md
+++ b/files/fr/web/javascript/reference/classes/private_class_fields/index.md
@@ -7,36 +7,34 @@ tags:
   - JavaScript
 translation_of: Web/JavaScript/Reference/Classes/Private_class_fields
 ---
-<div>{{JsSidebar("Classes")}}</div>
+{{JsSidebar("Classes")}}Les propriétés de classe sont publiques par défaut et peuvent être lues et modifiées à l'extérieur de la classe. Cependant, [une proposition expérimentale](https://github.com/tc39/proposal-class-fields), permettant de définir des variables privées dans une classe avec le préfixe `#`, est disponible.
 
-<div>Les propriétés de classe sont publiques par défaut et peuvent être lues et modifiées à l'extérieur de la classe. Cependant, <a href="https://github.com/tc39/proposal-class-fields">une proposition expérimentale</a>, permettant de définir des variables privées dans une classe avec le préfixe <code>#</code>, est disponible.</div>
+## Syntaxe
 
-<h2 id="Syntaxe">Syntaxe</h2>
+    class ClassWithPrivateField {
+      #privateField
+    }
 
-<pre class="syntaxbox notranslate">class ClassWithPrivateField {
-  #privateField
-}
+    class ClassWithPrivateMethod {
+      #privateMethod() {
+        return 'hello world'
+     }
+    }
 
-class ClassWithPrivateMethod {
-  #privateMethod() {
-    return 'hello world'
- }
-}
-
-class ClassWithPrivateStaticField {
-  static #PRIVATE_STATIC_FIELD
-}
-</pre>
+    class ClassWithPrivateStaticField {
+      static #PRIVATE_STATIC_FIELD
+    }
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Champs_privés_statiques">Champs privés statiques</h3>
+### Champs privés statiques
 
-<p>Les champs privés sont accessibles depuis le constructeur et depuis l'intérieur de la déclaration de la classe elle-même.</p>
+Les champs privés sont accessibles depuis le constructeur et depuis l'intérieur de la déclaration de la classe elle-même.
 
-<p>La limitation des variables statiques ne pouvant être appelées que par des méthodes statiques tient toujours.</p>
+La limitation des variables statiques ne pouvant être appelées que par des méthodes statiques tient toujours.
 
-<pre class="brush: js notranslate">class ClassWithPrivateStaticField {
+```js
+class ClassWithPrivateStaticField {
   static #PRIVATE_STATIC_FIELD
 
   static publicStaticMethod() {
@@ -45,15 +43,17 @@ class ClassWithPrivateStaticField {
   }
 }
 
-console.assert(ClassWithPrivateStaticField.publicStaticMethod() === 42)</pre>
+console.assert(ClassWithPrivateStaticField.publicStaticMethod() === 42)
+```
 
-<p>Les champs statiques privés sont ajoutés au constructeur de la classe au moment de l'évaluation de classe..</p>
+Les champs statiques privés sont ajoutés au constructeur de la classe au moment de l'évaluation de classe..
 
-<p>Il y a une restriction de provenance sur les champs statiques privés. Seule la classe qui a défini un champ statique privé peut y accéder.</p>
+Il y a une restriction de provenance sur les champs statiques privés. Seule la classe qui a défini un champ statique privé peut y accéder.
 
-<p>Ceci peut conduire à un comportement inattendu lors de l'utilisation de <strong><code>this</code></strong>.</p>
+Ceci peut conduire à un comportement inattendu lors de l'utilisation de **`this`**.
 
-<pre class="brush: js notranslate">class BaseClassWithPrivateStaticField {
+```js
+class BaseClassWithPrivateStaticField {
   static #PRIVATE_STATIC_FIELD
 
   static basePublicStaticMethod() {
@@ -71,15 +71,16 @@ try {
 } catch(e) { error = e}
 
 console.assert(error instanceof TypeError)
-</pre>
+```
 
-<h3 id="Champs_dinstance_privés">Champs d'instance privés</h3>
+### Champs d'instance privés
 
-<p>Les champs d'instance privés sont déclarés avec des <strong>noms</strong> à <strong># </strong>(prononcés "<em>noms à hash</em>", "<em>hash names</em>" en anglais), qui sont des identifieurs préfixés par <code>#</code>. Le <code>#</code> fait partie du nom lui-même. Il est utilisé tant pour la déclaration que pour l'accès.</p>
+Les champs d'instance privés sont déclarés avec des **noms** à **#** (prononcés "_noms à hash_", "_hash names_" en anglais), qui sont des identifieurs préfixés par `#`. Le `#` fait partie du nom lui-même. Il est utilisé tant pour la déclaration que pour l'accès.
 
-<p>L'encapsulation est forcée par le langage. C'est une erreur de syntaxe que de faire référence aux noms à <code>#</code> en dehors de leur portée.</p>
+L'encapsulation est forcée par le langage. C'est une erreur de syntaxe que de faire référence aux noms à `#` en dehors de leur portée.
 
-<pre class="brush: js notranslate">class ClassWithPrivateField {
+```js
+class ClassWithPrivateField {
   #privateField
 
   constructor() {
@@ -90,17 +91,18 @@ console.assert(error instanceof TypeError)
 
 const instance = new ClassWithPrivateField()
 instance.#privateField === 42 // Erreur de syntaxe
-</pre>
+```
 
-<h3 id="Méthodes_Privées">Méthodes Privées</h3>
+### Méthodes Privées
 
-<h4 id="Méthodes_statiques_privées">Méthodes statiques privées</h4>
+#### Méthodes statiques privées
 
-<p>Comme leur équivalents publics, les méthodes statiques privées sont appelées dans la classe elle-même, pas dans les instances de la classe. Comme les champs statiques privés, elles ne sont accessibles que depuis l'intérieur de la déclaration de la classe.</p>
+Comme leur équivalents publics, les méthodes statiques privées sont appelées dans la classe elle-même, pas dans les instances de la classe. Comme les champs statiques privés, elles ne sont accessibles que depuis l'intérieur de la déclaration de la classe.
 
-<p>Les méthodes statiques privées peuvent être des fonctions génératrices, asynchrones et génératrices asynchrones.</p>
+Les méthodes statiques privées peuvent être des fonctions génératrices, asynchrones et génératrices asynchrones.
 
-<pre class="brush: js notranslate">class ClassWithPrivateStaticMethod {
+```js
+class ClassWithPrivateStaticMethod {
     static #privateStaticMethod() {
         return 42
     }
@@ -116,11 +118,12 @@ instance.#privateField === 42 // Erreur de syntaxe
 
 console.assert(ClassWithPrivateStaticMethod.publicStaticMethod1() === 42);
 console.assert(ClassWithPrivateStaticMethod.publicStaticMethod2() === 42);
-</pre>
+```
 
-<p>Cela peut conduire à un comportement inattendu lors de l'utilisation de <strong><code>this</code></strong>. Dans l'exemple suivant, <code>this</code> fait référence à la classe <code>Derived</code> (pas à la classe <code>Base</code>) lorsqu'on essaie d'appeler <code>Derived.publicStaticMethod2()</code>, et fait ainsi apparaître la même "restriction de provenance" que mentionné ci-dessus :</p>
+Cela peut conduire à un comportement inattendu lors de l'utilisation de **`this`**. Dans l'exemple suivant, `this` fait référence à la classe `Derived` (pas à la classe `Base`) lorsqu'on essaie d'appeler `Derived.publicStaticMethod2()`, et fait ainsi apparaître la même "restriction de provenance" que mentionné ci-dessus :
 
-<pre class="brush: js notranslate">class Base {
+```js
+class Base {
     static #privateStaticMethod() {
         return 42;
     }
@@ -136,13 +139,14 @@ class Derived extends Base {}
 
 console.log(Derived.publicStaticMethod1()); // 42
 console.log(Derived.publicStaticMethod2()); // TypeError
-</pre>
+```
 
-<h4 id="Méthodes_dinstance_privées">Méthodes d'instance privées</h4>
+#### Méthodes d'instance privées
 
-<p>Les méthodes d'instance privées sont des méthodes disponibles dans les instances de classe privées, dont l'accès est restreint de la même manière que les champs d'instance privés.</p>
+Les méthodes d'instance privées sont des méthodes disponibles dans les instances de classe privées, dont l'accès est restreint de la même manière que les champs d'instance privés.
 
-<pre class="brush: js notranslate">class ClassWithPrivateMethod {
+```js
+class ClassWithPrivateMethod {
   #privateMethod() {
     return 'hello world'
   }
@@ -154,11 +158,13 @@ console.log(Derived.publicStaticMethod2()); // TypeError
 
 const instance = new ClassWithPrivateMethod()
 console.log(instance.getPrivateMessage())
-// expected output: "hello worl​d"</pre>
+// expected output: "hello worl​d"
+```
 
-<p>Les méthodes d'instance privées peuvent être des fonctions génératrices, asynchones ou génératrices asynchrones. Des accesseurs (getters) et des mutateurs (setters) privés sont aussi posibles :</p>
+Les méthodes d'instance privées peuvent être des fonctions génératrices, asynchones ou génératrices asynchrones. Des accesseurs (getters) et des mutateurs (setters) privés sont aussi posibles :
 
-<pre class="brush: js notranslate">class ClassWithPrivateAccessor {
+```js
+class ClassWithPrivateAccessor {
   #message
 
   get #decoratedMessage() {
@@ -176,32 +182,19 @@ console.log(instance.getPrivateMessage())
 
 new ClassWithPrivateAccessor();
 // expected output: "✨hello worl​d✨"
-</pre>
-
-<h2 id="Spécifications">Spécifications</h2>
-
-<table class="standard-table">
- <thead>
-  <tr>
-   <th scope="col">Spécification</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td>{{SpecName('Public and private instance fields', '#prod-FieldDefinition', 'FieldDefinition')}}</td>
-  </tr>
- </tbody>
-</table>
+```
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Spécifications
 
+| Spécification                                                                                                                |
+| ---------------------------------------------------------------------------------------------------------------------------- |
+| {{SpecName('Public and private instance fields', '#prod-FieldDefinition', 'FieldDefinition')}} |
 
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.classes.private_class_fields")}}</p>
+{{Compat("javascript.classes.private_class_fields")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li><a href="/fr/docs/Web/JavaScript/Reference/Classes/Class_fields">Champs de classe publiques</a></li>
- <li><a href="https://rfrn.org/~shu/2018/05/02/the-semantics-of-all-js-class-elements.html">The Semantics of All JS Class Elements</a></li>
-</ul>
+- [Champs de classe publiques](/fr/docs/Web/JavaScript/Reference/Classes/Class_fields)
+- [The Semantics of All JS Class Elements](https://rfrn.org/~shu/2018/05/02/the-semantics-of-all-js-class-elements.html)
diff --git a/files/fr/web/javascript/reference/classes/public_class_fields/index.md b/files/fr/web/javascript/reference/classes/public_class_fields/index.md
index 80b3096c8a..8630e5e473 100644
--- a/files/fr/web/javascript/reference/classes/public_class_fields/index.md
+++ b/files/fr/web/javascript/reference/classes/public_class_fields/index.md
@@ -8,64 +8,65 @@ tags:
 translation_of: Web/JavaScript/Reference/Classes/Public_class_fields
 original_slug: Web/JavaScript/Reference/Classes/Class_fields
 ---
-<div>{{JsSidebar("Classes")}}{{SeeCompatTable}}</div>
+{{JsSidebar("Classes")}}{{SeeCompatTable}}
 
-<div class="note">
-<p><strong>Note :</strong> Cette page décrit des fonctionnalités expérimentales.</p>
+> **Note :** Cette page décrit des fonctionnalités expérimentales.
+>
+> Les déclarations de champs, tant publics que privés, sont [une fonctionnalité expérimentale (étape 3)](https://github.com/tc39/proposal-class-fields) proposée au [TC39](https://tc39.github.io/beta/), le comité des standards JavaScript.
+>
+> La prise en charge dans les navigateurs est limitée, mais cette fonctionnalité peut être utilisée à travers une étape de contruction avec des systèmes tels que [Babel](https://babeljs.io/). Voir [l'information de compatibilité](/fr/docs/Web/JavaScript/Reference/Classes/Class_fields$edit#Browser_compatibility) ci-dessous.
 
-<p>Les déclarations de champs, tant publics que privés, sont <a href="https://github.com/tc39/proposal-class-fields">une fonctionnalité expérimentale (étape 3)</a> proposée au <a href="https://tc39.github.io/beta/">TC39</a>, le comité des standards JavaScript.</p>
+Les champs publics, tant statiques que d'instance, sont des propriétés qui peuvent être écrites, et qui sont énumérables et configurables. En tant que telles, à la différence de leurs contreparties privées, elles participent à l'héritage du prototype.
 
-<p>La prise en charge dans les navigateurs est limitée, mais cette fonctionnalité peut être utilisée à travers une étape de contruction avec des systèmes tels que <a href="https://babeljs.io/">Babel</a>. Voir <a href="/fr/docs/Web/JavaScript/Reference/Classes/Class_fields$edit#Browser_compatibility">l'information de compatibilité</a> ci-dessous.</p>
-</div>
+## Syntaxe
 
-<p>Les champs publics, tant statiques que d'instance, sont des propriétés qui peuvent être écrites, et qui sont énumérables et configurables. En tant que telles, à la différence de leurs contreparties privées, elles participent à l'héritage du prototype.</p>
+    class ClasseAvecChampDInstance {
+      champDInstance = 'champ d\'instance'
+    }
 
-<h2 id="Syntaxe">Syntaxe</h2>
+    class ClasseAvecChampStatique {
+      static champStatique = 'champ statique'
+    }
 
-<pre class="syntaxbox notranslate">class ClasseAvecChampDInstance {
-  champDInstance = 'champ d\'instance'
-}
-
-class ClasseAvecChampStatique {
-  static champStatique = 'champ statique'
-}
-
-class ClasseAvecMethodeDInstancePublique {
-  methodePublique() {
-    return 'hello world'
-  }
-}
-</pre>
+    class ClasseAvecMethodeDInstancePublique {
+      methodePublique() {
+        return 'hello world'
+      }
+    }
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Champs_statiques_publics">Champs statiques publics</h3>
+### Champs statiques publics
 
-<p>Les champs statiques publics sont utiles lorsque vous voulez qu'un champ n'existe qu'une seule fois par classe, pas dans chaque instance que vous créez. Cela est utile pour des caches, une configuration fixe, ou tout autres données dont vous n'avez pas besoin qu'elles soient répliquées à travers les instances.</p>
+Les champs statiques publics sont utiles lorsque vous voulez qu'un champ n'existe qu'une seule fois par classe, pas dans chaque instance que vous créez. Cela est utile pour des caches, une configuration fixe, ou tout autres données dont vous n'avez pas besoin qu'elles soient répliquées à travers les instances.
 
-<p>Les champs statiques publics sont déclarés en utilisant le mot-clé <code>static</code>. Ils sont ajoutés au constructeur de la classe au moment de l'évaluation de la classe en utilisant {{jsxref("Global_Objects/Object/defineProperty", "Object.defineProperty()")}}. On y accède à nouveau à partir du constructeur de la classe.</p>
+Les champs statiques publics sont déclarés en utilisant le mot-clé `static`. Ils sont ajoutés au constructeur de la classe au moment de l'évaluation de la classe en utilisant {{jsxref("Global_Objects/Object/defineProperty", "Object.defineProperty()")}}. On y accède à nouveau à partir du constructeur de la classe.
 
-<pre class="brush: js notranslate">class ClasseAvecChampStatique {
+```js
+class ClasseAvecChampStatique {
   static champStatique = 'champ statique'
 }
 
 console.log(ClasseAvecChampStatique.champStatique)
 // affichage attendu : "champ statique"​
-</pre>
+```
 
-<p>Les champs sans initialiseur sont initialisés à <code>undefined</code>.</p>
+Les champs sans initialiseur sont initialisés à `undefined`.
 
-<pre class="brush: js notranslate">class ClasseAvecChampStatique {
+```js
+class ClasseAvecChampStatique {
   static champStatique
 }
 
 console.assert(ClasseAvecChampStatique.hasOwnProperty('champStatique'))
 console.log(ClasseAvecChampStatique.champStatique)
-// affichage attendu : "undefined"</pre>
+// affichage attendu : "undefined"
+```
 
-<p>Les champs statiques publics ne sont pas réinitialisés dans les sous-classes, mais on peut y accéder via la chaîne de prototypes.</p>
+Les champs statiques publics ne sont pas réinitialisés dans les sous-classes, mais on peut y accéder via la chaîne de prototypes.
 
-<pre class="brush: js notranslate">class ClasseAvecChampStatique {
+```js
+class ClasseAvecChampStatique {
   static champStatiqueDeBase = 'champ de base'
 }
 
@@ -77,11 +78,13 @@ console.log(SousClasseAvecChampStatique.sousChampStatique)
 // affichage attendu : "champ de la sous-classe"
 
 console.log(SousClasseAvecChampStatique.champStatiqueDeBase)
-// affichage attendu : "champ de base"</pre>
+// affichage attendu : "champ de base"
+```
 
-<p>Lors de l'initialisation des champs, <code>this</code> fait référence au constructeur de la classe. Vous pouvez aussi le référencer par son nom, et utiliser <code>super</code> pour obtenir le constructeur de la superclasse (s'il en existe un) :</p>
+Lors de l'initialisation des champs, `this` fait référence au constructeur de la classe. Vous pouvez aussi le référencer par son nom, et utiliser `super` pour obtenir le constructeur de la superclasse (s'il en existe un) :
 
-<pre class="brush: js notranslate">class ClasseAvecChampStatique {
+```js
+class ClasseAvecChampStatique {
   static champStatiqueDeBase = 'champ statique de base'
   static autreChampStatiqueDeBase = this.champStatiqueDeBase
 
@@ -97,36 +100,41 @@ console.log(ClasseAvecChampStatique.autreChampStatiqueDeBase)
 
 console.log(SousClasseAvecChampStatique.sousChampStatique)
 // affichage attendu : "affichage de la méthode statique de base"
-</pre>
+```
 
-<h3 id="Champs_dinstance_publics">Champs d'instance publics</h3>
+### Champs d'instance publics
 
-<p>Les champs d'instance publics existent dans chaque instance créée d'une classe. En déclarant un champ public, vous pouvez vous assurer que le champ est toujours présent, et que la définition de la classe est davantage auto-documentée.</p>
+Les champs d'instance publics existent dans chaque instance créée d'une classe. En déclarant un champ public, vous pouvez vous assurer que le champ est toujours présent, et que la définition de la classe est davantage auto-documentée.
 
-<p>Les champs d'instance publics sont ajoutés grâce à {{jsxref("Global_Objects/Object/defineProperty", "Object.defineProperty()")}}, soit au moment de la construction dans la classe de base (avant que le corps du constructeur ne soit exécuté), soit juste après le retour de <code>super()</code> dans une sous-classe.</p>
+Les champs d'instance publics sont ajoutés grâce à {{jsxref("Global_Objects/Object/defineProperty", "Object.defineProperty()")}}, soit au moment de la construction dans la classe de base (avant que le corps du constructeur ne soit exécuté), soit juste après le retour de `super()` dans une sous-classe.
 
-<pre class="brush: js notranslate">class ClasseAvecChampDInstance {
+```js
+class ClasseAvecChampDInstance {
   champDInstance = 'champ d\'instance'
 }
 
 const instance = new ClasseAvecChampDInstance()
 console.log(instance.champDInstance)
-// affichage attendu : "champ d'instance"</pre>
+// affichage attendu : "champ d'instance"
+```
 
-<p>Les champs sans initialiseur sont initialisés à <code>undefined</code>.</p>
+Les champs sans initialiseur sont initialisés à `undefined`.
 
-<pre class="brush: js notranslate">class ClasseAvecChampDInstance {
+```js
+class ClasseAvecChampDInstance {
   champdDInstance
 }
 
 const instance = new ClasseAvecChampDInstance()
 console.assert(instance.hasOwnProperty('champDInstance'))
 console.log(instance.champDInstance);
-// affichage attendu : "undefined"</pre>
+// affichage attendu : "undefined"
+```
 
-<p>À l'instar des propriétés, les noms de champ peuvent être calculés :</p>
+À l'instar des propriétés, les noms de champ peuvent être calculés :
 
-<pre class="brush: js notranslate">const PREFIXE = 'prefixe';
+```js
+const PREFIXE = 'prefixe';
 
 class ClasseAvecNomDeChampCalcule {
     [`${PREFIXE}Champ`] = 'champ préfixé'
@@ -134,11 +142,13 @@ class ClasseAvecNomDeChampCalcule {
 
 const instance = new ClasseAvecNomDeChampCalcule()
 console.log(instance.prefixeChamp)
-// affichage attendu : "champ préfixé"</pre>
+// affichage attendu : "champ préfixé"
+```
 
-<p>Lors de l'initialisation des champs, <code>this</code> fait référence à l'instance en cours de construction. Tout comme dans les méthodes d'instance publiques, si vous êtes dans une sous-classe, vous pouvez accéder au prototype de la superclasse en utilisant <code>super</code>.</p>
+Lors de l'initialisation des champs, `this` fait référence à l'instance en cours de construction. Tout comme dans les méthodes d'instance publiques, si vous êtes dans une sous-classe, vous pouvez accéder au prototype de la superclasse en utilisant `super`.
 
-<pre class="brush: js notranslate">class ClasseAvecChampDInstance {
+```js
+class ClasseAvecChampDInstance {
   champDInstanceDeBase = 'champ de base'
   autreChampDInstanceDeBase = this.champDInstanceDeBase
   methodeDInstanceDeBase() { return 'affichage de la méthode de base' }
@@ -155,30 +165,34 @@ console.log(base.autreChampDInstanceDeBase)
 // affichage attendu : "champ de base"
 
 console.log(sous.sousChampDInstance)
-// affichage attendu : "affichage de la méthode de base"</pre>
+// affichage attendu : "affichage de la méthode de base"
+```
 
-<h3 id="Méthodes_publiques">Méthodes publiques</h3>
+### Méthodes publiques
 
-<h4 id="Méthodes_statiques_publiques">Méthodes statiques publiques</h4>
+#### Méthodes statiques publiques
 
-<p>Le mot-clé <code><strong>static</strong></code> définit une méthode statique pour une classe. Les méthodes statiques ne sont pas appelées dans les instances de la classe. A la place, elles le sont dans la classe elle-même. Ce sont souvent des méthodes utilitaires, comme des fonctions pour créer ou cloner des objets.</p>
+Le mot-clé **`static`** définit une méthode statique pour une classe. Les méthodes statiques ne sont pas appelées dans les instances de la classe. A la place, elles le sont dans la classe elle-même. Ce sont souvent des méthodes utilitaires, comme des fonctions pour créer ou cloner des objets.
 
-<pre class="brush: js notranslate">class ClasseAvecMethodeStatique {
+```js
+class ClasseAvecMethodeStatique {
   static methodeStatique() {
     return 'la méthode statique a été appelée.';
   }
 }
 
 console.log(ClasseAvecMethodeStatique.methodeStatique());
-// affichage attendu : "la méthode statique a été appelée."</pre>
+// affichage attendu : "la méthode statique a été appelée."
+```
 
-<p>Les méthodes statiques sont ajoutées au constructeur de la classe grâce à {{jsxref("Global_Objects/Object/defineProperty", "Object.defineProperty()")}} au moment de l'évaluation de la classe. Ces méthodes peuvent être écrites, ne sont pas énumérables et sont configurables.</p>
+Les méthodes statiques sont ajoutées au constructeur de la classe grâce à {{jsxref("Global_Objects/Object/defineProperty", "Object.defineProperty()")}} au moment de l'évaluation de la classe. Ces méthodes peuvent être écrites, ne sont pas énumérables et sont configurables.
 
-<h4 id="Méthodes_dinstance_publiques">Méthodes d'instance publiques</h4>
+#### Méthodes d'instance publiques
 
-<p>Comme leur nom l'implique, les méthodes d'instance publiques sont des fonctions disponibles dans les instances de la classe.</p>
+Comme leur nom l'implique, les méthodes d'instance publiques sont des fonctions disponibles dans les instances de la classe.
 
-<pre class="brush: js notranslate">class ClasseAvecMethodeDInstancePublique {
+```js
+class ClasseAvecMethodeDInstancePublique {
   methodePublique() {
     return 'hello world'
   }
@@ -186,21 +200,25 @@ console.log(ClasseAvecMethodeStatique.methodeStatique());
 
 const instance = new ClasseAvecMethodeDInstancePublique()
 console.log(instance.methodePublique())
-// affichage attendu : "hello worl​d"</pre>
+// affichage attendu : "hello worl​d"
+```
 
-<p>Les méthodes d'instance publiques sont ajoutées au prototype au moment de l'évaluation de la classe en utilisant {{jsxref("Global_Objects/Object/defineProperty", "Object.defineProperty()")}}. Elles peuvent être écrites, ne sont pas énumérables et sont configurables.</p>
+Les méthodes d'instance publiques sont ajoutées au prototype au moment de l'évaluation de la classe en utilisant {{jsxref("Global_Objects/Object/defineProperty", "Object.defineProperty()")}}. Elles peuvent être écrites, ne sont pas énumérables et sont configurables.
 
-<p>Vous pouvez utiliser des fonctions génératrices, asynchrones et génératrices asynchrones.</p>
+Vous pouvez utiliser des fonctions génératrices, asynchrones et génératrices asynchrones.
 
-<pre class="brush: js notranslate">class ClasseAvecMethodesFantaisie {
+```js
+class ClasseAvecMethodesFantaisie {
   *methodeGeneratrice() { }
   async methodeAsynchrone() { }
   async *methodeGeneratriceAsynchrone() { }
-}</pre>
+}
+```
 
-<p>A l'intérieur des méthodes d'instance, <code>this</code> fait référence à l'instance elle-même. Dans les sous-classes, <code>super</code> vous donne accès au prototype de la superclasse, ce qui vous permet d'appeler les méthodes de la superclasse.</p>
+A l'intérieur des méthodes d'instance, `this` fait référence à l'instance elle-même. Dans les sous-classes, `super` vous donne accès au prototype de la superclasse, ce qui vous permet d'appeler les méthodes de la superclasse.
 
-<pre class="brush: js notranslate">class ClasseDeBase {
+```js
+class ClasseDeBase {
   msg = 'hello world'
   methodePubliqueDeBase() {
     return this.msg
@@ -216,11 +234,12 @@ class SousClasse extends ClasseDeBase {
 const instance = new SousClasse()
 console.log(instance.sousMethodePublique())
 // affichage attendu : "hello worl​d"
-</pre>
+```
 
-<p>Les accesseurs et les mutateurs sont des méthodes spéciales qui sont liées à une propriété de classe, et sont appelées lorsqu'on accède à cette propriété ou qu'on la définit. Utilisez la syntaxe <a href="https://developer.mozilla.org/fr-FR/docs/Web/JavaScript/Reference/Functions/get">get</a> et <a href="https://developer.mozilla.org/fr-FR/docs/Web/JavaScript/Reference/Functions/set">set</a> pour déclarer un accesseur ou un mutateur publique d'une instance.</p>
+Les accesseurs et les mutateurs sont des méthodes spéciales qui sont liées à une propriété de classe, et sont appelées lorsqu'on accède à cette propriété ou qu'on la définit. Utilisez la syntaxe [get](https://developer.mozilla.org/fr-FR/docs/Web/JavaScript/Reference/Functions/get) et [set](https://developer.mozilla.org/fr-FR/docs/Web/JavaScript/Reference/Functions/set) pour déclarer un accesseur ou un mutateur publique d'une instance.
 
-<pre class="brush: js notranslate">class ClasseAvecGetSet {
+```js
+class ClasseAvecGetSet {
   #msg = 'hello world'
   get msg() {
     return this.#msg
@@ -237,29 +256,18 @@ console.log(instance.msg);
 instance.msg = 'gâteau';
 console.log(instance.msg);
 // affichage attendu : "hello gâteau"
-</pre>
+```
 
-<h2 id="Spécifications">Spécifications</h2>
+## Spécifications
 
-<table class="standard-table">
- <thead>
-  <tr>
-   <th scope="col">Spécification</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td>{{SpecName('Public and private instance fields', '#prod-FieldDefinition', 'FieldDefinition')}}</td>
-  </tr>
- </tbody>
-</table>
+| Spécification                                                                                                                |
+| ---------------------------------------------------------------------------------------------------------------------------- |
+| {{SpecName('Public and private instance fields', '#prod-FieldDefinition', 'FieldDefinition')}} |
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.classes.public_class_fields")}}</p>
+{{Compat("javascript.classes.public_class_fields")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li><a href="https://rfrn.org/~shu/2018/05/02/the-semantics-of-all-js-class-elements.html">The Semantics of All JS Class Elements</a></li>
-</ul>
+- [The Semantics of All JS Class Elements](https://rfrn.org/~shu/2018/05/02/the-semantics-of-all-js-class-elements.html)
diff --git a/files/fr/web/javascript/reference/classes/static/index.md b/files/fr/web/javascript/reference/classes/static/index.md
index f93abc7411..f08b2b5a94 100644
--- a/files/fr/web/javascript/reference/classes/static/index.md
+++ b/files/fr/web/javascript/reference/classes/static/index.md
@@ -8,33 +8,32 @@ tags:
   - Reference
 translation_of: Web/JavaScript/Reference/Classes/static
 ---
-<div>{{jsSidebar("Classes")}}</div>
+{{jsSidebar("Classes")}}
 
-<p>Le mot-clé <code><strong>static</strong></code> permet de définir une méthode statique d'une classe. Les méthodes statiques ne sont pas disponibles sur les instances d'une classe mais sont appelées sur la classe elle-même. Les méthodes statiques sont généralement des fonctions utilitaires (qui peuvent permettre de créer ou de cloner des objets par exemple).</p>
+Le mot-clé **`static`** permet de définir une méthode statique d'une classe. Les méthodes statiques ne sont pas disponibles sur les instances d'une classe mais sont appelées sur la classe elle-même. Les méthodes statiques sont généralement des fonctions utilitaires (qui peuvent permettre de créer ou de cloner des objets par exemple).
 
-<div>{{EmbedInteractiveExample("pages/js/classes-static.html")}}</div>
+{{EmbedInteractiveExample("pages/js/classes-static.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">static <em>nomMéthode()</em> { ... }</pre>
+    static nomMéthode() { ... }
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Les méthodes statiques sont utilisées lorsque la méthode ne s'applique qu'à la classe elle-même et pas à ses instances. Les méthodes statiques sont généralement utilisées pour créer des fonctions utilitaires.</p>
+Les méthodes statiques sont utilisées lorsque la méthode ne s'applique qu'à la classe elle-même et pas à ses instances. Les méthodes statiques sont généralement utilisées pour créer des fonctions utilitaires.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Exemple_classique">Exemple classique</h3>
+### Exemple classique
 
-<p>Dans l'exemple qui suit, on illustre :</p>
+Dans l'exemple qui suit, on illustre :
 
-<ul>
- <li>comment une classe implémente une méthode statique</li>
- <li>comment une classe avec une propriété statique peut être déclinée avec une sous-classe</li>
- <li>comment une méthode statique peut ou ne peut pas être appelé</li>
-</ul>
+- comment une classe implémente une méthode statique
+- comment une classe avec une propriété statique peut être déclinée avec une sous-classe
+- comment une méthode statique peut ou ne peut pas être appelé
 
-<pre class="brush: js">class Triple {
+```js
+class Triple {
   static triple(n) {
     if (n === undefined) {
       n = 1;
@@ -55,13 +54,14 @@ console.log(SuperTriple.triple(4)); // 144
 var tp = new Triple();
 console.log(SuperTriple.triple(4)); // 144 (pas d'impact de l'affectation du parent)
 console.log(tp.triple()); // tp.triple n'est pas une fonction
-</pre>
+```
 
-<h3 id="Utilisation_depuis_une_autre_méthode_statique">Utilisation depuis une autre méthode statique</h3>
+### Utilisation depuis une autre méthode statique
 
-<p>Afin d'appeler une autre méthode statique dans une méthode statique, on pourra utiliser {{jsxref("Opérateurs/L_opérateur_this","this")}}.</p>
+Afin d'appeler une autre méthode statique dans une méthode statique, on pourra utiliser {{jsxref("Opérateurs/L_opérateur_this","this")}}.
 
-<pre class="brush: js">class StaticMethodCall {
+```js
+class StaticMethodCall {
   static staticMethod() {
     return 'Méthode statique appelée';
   }
@@ -72,13 +72,15 @@ console.log(tp.triple()); // tp.triple n'est pas une fonction
 StaticMethodCall.staticMethod();
 // 'Méthode statique appelée'
 StaticMethodCall.anotherStaticMethod();
-// 'Méthode statique appelée depuis une autre statique'</pre>
+// 'Méthode statique appelée depuis une autre statique'
+```
 
-<h3 id="Depuis_les_constructeurs_de_classes_et_les_autres_méthodes">Depuis les constructeurs de classes et les autres méthodes</h3>
+### Depuis les constructeurs de classes et les autres méthodes
 
-<p>Les méthodes statiques ne sont pas directement accessibles via le mot-clé <code><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_this">this</a></code>. Il faut les appeler avec le nom de la classe qui préfixe le nom de la méthode statique <code>NomDeClasse.MéthodeStatique()</code> (comme pour les autres appels en dehors de la classe) ou avec la propriété <code>constructor</code>  : <code>this.constructor.MéthodeStatique()</code>.</p>
+Les méthodes statiques ne sont pas directement accessibles via le mot-clé [`this`](/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_this). Il faut les appeler avec le nom de la classe qui préfixe le nom de la méthode statique `NomDeClasse.MéthodeStatique()` (comme pour les autres appels en dehors de la classe) ou avec la propriété `constructor`  : `this.constructor.MéthodeStatique()`.
 
-<pre class="brush: js">class StaticMethodCall{
+```js
+class StaticMethodCall{
   constructor(){
     console.log(StaticMethodCall.staticMethod());
     // 'appel de la méthode statique'
@@ -90,38 +92,22 @@ StaticMethodCall.anotherStaticMethod();
   static  staticMethod(){
     return 'appel de la méthode statique.';
   }
-}</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-class-definitions', 'Class definitions')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-class-definitions', 'Class definitions')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.classes.static")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li><a href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/class">Expression <code>class</code></a></li>
- <li><a href="/fr/docs/Web/JavaScript/Reference/Instructions/class">Déclaration <code>class</code></a></li>
- <li><a href="/fr/docs/Web/JavaScript/Reference/Classes">Les classes</a></li>
-</ul>
+}
+```
+
+## Spécifications
+
+| Spécification                                                                                | État                         | Commentaires         |
+| -------------------------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ES2015', '#sec-class-definitions', 'Class definitions')}} | {{Spec2('ES2015')}}     | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-class-definitions', 'Class definitions')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.classes.static")}}
+
+## Voir aussi
+
+- [Expression `class`](/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/class)
+- [Déclaration `class`](/fr/docs/Web/JavaScript/Reference/Instructions/class)
+- [Les classes](/fr/docs/Web/JavaScript/Reference/Classes)
diff --git a/files/fr/web/javascript/reference/deprecated_and_obsolete_features/index.md b/files/fr/web/javascript/reference/deprecated_and_obsolete_features/index.md
index 54f3bd85dd..bed483b8a9 100644
--- a/files/fr/web/javascript/reference/deprecated_and_obsolete_features/index.md
+++ b/files/fr/web/javascript/reference/deprecated_and_obsolete_features/index.md
@@ -9,285 +9,201 @@ tags:
 translation_of: Web/JavaScript/Reference/Deprecated_and_obsolete_features
 original_slug: JavaScript/Reference/Annexes/Fonctionnalités_dépréciées
 ---
-<div>{{JsSidebar("More")}}</div>
+{{JsSidebar("More")}}
 
-<p>Cette page liste les fonctionnalités de JavaScript qui sont dépréciées (<em>deprecated</em>) (c'est-à-dire que ces fonctionnalités sont toujours disponibles mais qu'il est prévu de les retirer) et les fonctionnalités obsolètes (celles qui ne sont plus utilisables).</p>
+Cette page liste les fonctionnalités de JavaScript qui sont dépréciées (_deprecated_) (c'est-à-dire que ces fonctionnalités sont toujours disponibles mais qu'il est prévu de les retirer) et les fonctionnalités obsolètes (celles qui ne sont plus utilisables).
 
-<h2 id="Fonctionnalités_dépréciées">Fonctionnalités dépréciées</h2>
+## Fonctionnalités dépréciées
 
-<p>Ces fonctionnalités dépréciées peuvent toujours être utilisées mais avec une grande attention car elles pourront être supprimées complètements à l'avenir. En règle général, il faut les retirer du code qui les utilise.</p>
+Ces fonctionnalités dépréciées peuvent toujours être utilisées mais avec une grande attention car elles pourront être supprimées complètements à l'avenir. En règle général, il faut les retirer du code qui les utilise.
 
-<h3 id="RegExp_Properties">Propriétés de <code>RegExp</code></h3>
+### Propriétés de `RegExp`
 
-<p>Les propriétés suivantes sont dépréciées. Cela n'affecte pas le comportement de {{jsxref("Objets_globaux/String/replace", "replace", "Specifying_a_string_as_a_parameter")}} lorsqu'on utilise une chaîne de caractères en paramètre de remplacement :</p>
+Les propriétés suivantes sont dépréciées. Cela n'affecte pas le comportement de {{jsxref("Objets_globaux/String/replace", "replace", "Specifying_a_string_as_a_parameter")}} lorsqu'on utilise une chaîne de caractères en paramètre de remplacement :
 
 <table class="standard-table">
- <tbody>
-  <tr>
-   <th>Propriété</th>
-   <th>Description</th>
-  </tr>
-  <tr>
-   <td>{{jsxref("RegExp.n", "$1-$9")}}</td>
-   <td>
-    <p>Les sous-chaînes correspondantes s'il y en a.<br>
-     <strong>Attention : </strong>Utiliser ces propriétés peut causer certains problèmes car les extensions des navigateurs peuvent les modifier. À éviter !</p>
-   </td>
-  </tr>
-  <tr>
-   <td>{{jsxref("RegExp.input", "$_")}}</td>
-   <td>Voir <code>input</code>.</td>
-  </tr>
-  <tr>
-   <td>{{jsxref("RegExp.multiline", "$*")}}</td>
-   <td>Voir <code>multiline</code>.</td>
-  </tr>
-  <tr>
-   <td>{{jsxref("RegExp.lastMatch", "$&amp;")}}</td>
-   <td>Voir <code>lastMatch</code>.</td>
-  </tr>
-  <tr>
-   <td>{{jsxref("RegExp.lastMatch", "$&amp;")}}</td>
-   <td>Voir <code>lastParen</code>.</td>
-  </tr>
-  <tr>
-   <td>{{jsxref("RegExp.leftContext", "$`")}}</td>
-   <td>Voir <code>leftContext</code>.</td>
-  </tr>
-  <tr>
-   <td>{{jsxref("RegExp.rightContext", "$'")}}</td>
-   <td>Voir <code>rightContext</code>.</td>
-  </tr>
-  <tr>
-   <td>{{jsxref("RegExp.input", "input")}}</td>
-   <td>La chaîne par rapport à laquelle on recherche une correspondance grâce à l'expression rationnelle.</td>
-  </tr>
-  <tr>
-   <td>{{jsxref("RegExp.lastMatch", "lastMatch")}}</td>
-   <td>Les derniers caractères correspondants.</td>
-  </tr>
-  <tr>
-   <td>{{jsxref("RegExp.lastParen", "lastParen")}}</td>
-   <td>La dernière sous-chaîne (groupe entre parenthèses) correspondante si elle existe.</td>
-  </tr>
-  <tr>
-   <td>{{jsxref("RegExp.leftContext", "leftContext")}}</td>
-   <td>La sous-chaîne qui précède la correspondance la plus récente.</td>
-  </tr>
-  <tr>
-   <td>{{jsxref("RegExp.rightContext", "rightContext")}}</td>
-   <td>La sous-chaîne qui suit la correspondance la plus récente.</td>
-  </tr>
- </tbody>
+  <tbody>
+    <tr>
+      <th>Propriété</th>
+      <th>Description</th>
+    </tr>
+    <tr>
+      <td>{{jsxref("RegExp.n", "$1-$9")}}</td>
+      <td>
+        <p>
+          Les sous-chaînes correspondantes s'il y en a.<br /><strong
+            >Attention : </strong
+          >Utiliser ces propriétés peut causer certains problèmes car les
+          extensions des navigateurs peuvent les modifier. À éviter !
+        </p>
+      </td>
+    </tr>
+    <tr>
+      <td>{{jsxref("RegExp.input", "$_")}}</td>
+      <td>Voir <code>input</code>.</td>
+    </tr>
+    <tr>
+      <td>{{jsxref("RegExp.multiline", "$*")}}</td>
+      <td>Voir <code>multiline</code>.</td>
+    </tr>
+    <tr>
+      <td>{{jsxref("RegExp.lastMatch", "$&amp;")}}</td>
+      <td>Voir <code>lastMatch</code>.</td>
+    </tr>
+    <tr>
+      <td>{{jsxref("RegExp.lastMatch", "$&amp;")}}</td>
+      <td>Voir <code>lastParen</code>.</td>
+    </tr>
+    <tr>
+      <td>{{jsxref("RegExp.leftContext", "$`")}}</td>
+      <td>Voir <code>leftContext</code>.</td>
+    </tr>
+    <tr>
+      <td>{{jsxref("RegExp.rightContext", "$'")}}</td>
+      <td>Voir <code>rightContext</code>.</td>
+    </tr>
+    <tr>
+      <td>{{jsxref("RegExp.input", "input")}}</td>
+      <td>
+        La chaîne par rapport à laquelle on recherche une correspondance grâce à
+        l'expression rationnelle.
+      </td>
+    </tr>
+    <tr>
+      <td>{{jsxref("RegExp.lastMatch", "lastMatch")}}</td>
+      <td>Les derniers caractères correspondants.</td>
+    </tr>
+    <tr>
+      <td>{{jsxref("RegExp.lastParen", "lastParen")}}</td>
+      <td>
+        La dernière sous-chaîne (groupe entre parenthèses) correspondante si
+        elle existe.
+      </td>
+    </tr>
+    <tr>
+      <td>{{jsxref("RegExp.leftContext", "leftContext")}}</td>
+      <td>La sous-chaîne qui précède la correspondance la plus récente.</td>
+    </tr>
+    <tr>
+      <td>{{jsxref("RegExp.rightContext", "rightContext")}}</td>
+      <td>La sous-chaîne qui suit la correspondance la plus récente.</td>
+    </tr>
+  </tbody>
 </table>
 
-<p>Les propriétés qui suivent sont désormais des propriétés des instances de <code>RegExp</code> et ne sont plus des propriétés de l'objet <code>RegExp</code> :</p>
+Les propriétés qui suivent sont désormais des propriétés des instances de `RegExp` et ne sont plus des propriétés de l'objet `RegExp` :
 
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th>Propriété</th>
-   <th>Description</th>
-  </tr>
-  <tr>
-   <td>{{jsxref("RegExp.global", "global")}}</td>
-   <td>Permet d'utiliser une expression rationnelle pour relever l'ensemble des correspondances ou uniquement la première.</td>
-  </tr>
-  <tr>
-   <td>{{jsxref("RegExp.ignoreCase", "ignoreCase")}}</td>
-   <td>Définit si la casse doit être ignorée ou non lors de la recherche d'une correspondance.</td>
-  </tr>
-  <tr>
-   <td>{{jsxref("RegExp.lastIndex", "lastIndex")}}</td>
-   <td>L'index à partir duquel chercher la prochaine correspondance.</td>
-  </tr>
-  <tr>
-   <td>{{jsxref("RegExp.multiline", "multiline")}}</td>
-   <td>Définit si la recherche doit s'effectuer sur une seule ligne ou plusieurs.</td>
-  </tr>
-  <tr>
-   <td>{{jsxref("RegExp.source", "source")}}</td>
-   <td>Le texte du motif.</td>
-  </tr>
- </tbody>
-</table>
+| Propriété                                                    | Description                                                                                                         |
+| ------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------- |
+| {{jsxref("RegExp.global", "global")}}             | Permet d'utiliser une expression rationnelle pour relever l'ensemble des correspondances ou uniquement la première. |
+| {{jsxref("RegExp.ignoreCase", "ignoreCase")}} | Définit si la casse doit être ignorée ou non lors de la recherche d'une correspondance.                             |
+| {{jsxref("RegExp.lastIndex", "lastIndex")}}     | L'index à partir duquel chercher la prochaine correspondance.                                                       |
+| {{jsxref("RegExp.multiline", "multiline")}}     | Définit si la recherche doit s'effectuer sur une seule ligne ou plusieurs.                                          |
+| {{jsxref("RegExp.source", "source")}}             | Le texte du motif.                                                                                                  |
 
-<h3 id="RegExp_Methods">Méthodes de <code>RegExp</code></h3>
+### Méthodes de `RegExp`
 
-<ul>
- <li>La méthode <code>compile</code> est dépréciée.</li>
- <li>La méthode <code>valueOf</code> n'est plus spécifiquement liée à <code>RegExp</code>. Utilisez {{jsxref("Object.valueOf()")}}.</li>
-</ul>
+- La méthode `compile` est dépréciée.
+- La méthode `valueOf` n'est plus spécifiquement liée à `RegExp`. Utilisez {{jsxref("Object.valueOf()")}}.
 
-<h3 id="Propriétés_de_Function">Propriétés de <code>Function</code></h3>
+### Propriétés de `Function`
 
-<ul>
- <li>Les propriétés {{jsxref("Objets_globaux/Function/caller", "caller")}} et {{jsxref("Objets_globaux/Function/arguments", "arguments")}} sont dépréciées car elles permettaient de fuiter l'appelant de la fonction. En lieu et place de la propriété <code>arguments</code>, c'est l'objet {{jsxref("Fonctions/arguments", "arguments")}} qui doit être utilisée (notamment dans les fermetures).</li>
-</ul>
+- Les propriétés {{jsxref("Objets_globaux/Function/caller", "caller")}} et {{jsxref("Objets_globaux/Function/arguments", "arguments")}} sont dépréciées car elles permettaient de fuiter l'appelant de la fonction. En lieu et place de la propriété `arguments`, c'est l'objet {{jsxref("Fonctions/arguments", "arguments")}} qui doit être utilisée (notamment dans les fermetures).
 
-<h3 id="Générateur_historique">Générateur historique</h3>
+### Générateur historique
 
-<ul>
- <li>{{jsxref("Instructions/Legacy_generator_function", "L'instruction pour le générateur historique")}} et {{jsxref("Opérateurs/Legacy_generator_function", "l'expression de fonction du générateur historique")}} sont dépréciées. Il faut utiliser {{jsxref("Instructions/function*", "L'instruction function* ")}} et {{jsxref("Opérateurs/function*", "l'expression function*")}} à la place.</li>
- <li>{{jsxref("Opérateurs/Compréhensions_de_tableau", "Les compréhensions de tableaux JS1.7/JS1.8", "#Diff.C3.A9rences_avec_les_compr.C3.A9hensions_pr.C3.A9c.C3.A9dentes_JS1.7.2FJS1.8")}} et {{jsxref("Opérateurs/Compréhensions_de_générateur", "les compréhensions de générateurs JS1.7/JS1.8", "#Differences_to_the_older_JS1.7.2FJS1.8_comprehensions")}} sont dépréciées.</li>
-</ul>
+- {{jsxref("Instructions/Legacy_generator_function", "L'instruction pour le générateur historique")}} et {{jsxref("Opérateurs/Legacy_generator_function", "l'expression de fonction du générateur historique")}} sont dépréciées. Il faut utiliser {{jsxref("Instructions/function*", "L'instruction function* ")}} et {{jsxref("Opérateurs/function*", "l'expression function*")}} à la place.
+- {{jsxref("Opérateurs/Compréhensions_de_tableau", "Les compréhensions de tableaux JS1.7/JS1.8", "#Diff.C3.A9rences_avec_les_compr.C3.A9hensions_pr.C3.A9c.C3.A9dentes_JS1.7.2FJS1.8")}} et {{jsxref("Opérateurs/Compréhensions_de_générateur", "les compréhensions de générateurs JS1.7/JS1.8", "#Differences_to_the_older_JS1.7.2FJS1.8_comprehensions")}} sont dépréciées.
 
-<h3 id="Itérateur">Itérateur</h3>
+### Itérateur
 
-<ul>
- <li>{{jsxref("Objets_globaux/StopIteration", "StopIteration")}} est déprécié.</li>
- <li>{{jsxref("Objets_globaux/Iterator", "Iterator")}} est déprécié.</li>
-</ul>
+- {{jsxref("Objets_globaux/StopIteration", "StopIteration")}} est déprécié.
+- {{jsxref("Objets_globaux/Iterator", "Iterator")}} est déprécié.
 
-<h3 id="Méthode_d'Object">Méthode d'<code>Object</code></h3>
+### Méthode d'`Object`
 
-<ul>
- <li>{{jsxref("Object.watch", "watch")}} et {{jsxref("Object.unwatch", "unwatch")}} sont dépréciés. L'objet {{jsxref("Proxy")}} doit être utilisé à la place.</li>
- <li><code>__iterator__</code> est déprécié.</li>
- <li>{{jsxref("Object.noSuchMethod", "__noSuchMethod__")}} est déprécié. {{jsxref("Proxy")}} doit être utilisé à la place.</li>
-</ul>
+- {{jsxref("Object.watch", "watch")}} et {{jsxref("Object.unwatch", "unwatch")}} sont dépréciés. L'objet {{jsxref("Proxy")}} doit être utilisé à la place.
+- `__iterator__` est déprécié.
+- {{jsxref("Object.noSuchMethod", "__noSuchMethod__")}} est déprécié. {{jsxref("Proxy")}} doit être utilisé à la place.
 
-<h3 id="Méthodes_de_Date">Méthodes de <code>Date</code></h3>
+### Méthodes de `Date`
 
-<ul>
- <li>{{jsxref("Objets_globaux/Date/getYear", "getYear")}} et {{jsxref("Objets_globaux/Date/setYear", "setYear")}} sont impactés par le « bug de l'an 2000 » et ont été remplacés par {{jsxref("Objets_globaux/Date/getFullYear", "getFullYear")}} et {{jsxref("Objets_globaux/Date/setFullYear", "setFullYear")}}.</li>
- <li>{{jsxref("Objets_globaux/Date/toISOString", "toISOString")}} doit être utilisé à la place de la méthode {{jsxref("Global_Objects/Date/toGMTString", "toGMTString")}} qui est dépréciée.</li>
- <li>{{jsxref("Objets_globaux/Date/toLocaleFormat", "toLocaleFormat")}} est dépréciée.</li>
-</ul>
+- {{jsxref("Objets_globaux/Date/getYear", "getYear")}} et {{jsxref("Objets_globaux/Date/setYear", "setYear")}} sont impactés par le « bug de l'an 2000 » et ont été remplacés par {{jsxref("Objets_globaux/Date/getFullYear", "getFullYear")}} et {{jsxref("Objets_globaux/Date/setFullYear", "setFullYear")}}.
+- {{jsxref("Objets_globaux/Date/toISOString", "toISOString")}} doit être utilisé à la place de la méthode {{jsxref("Global_Objects/Date/toGMTString", "toGMTString")}} qui est dépréciée.
+- {{jsxref("Objets_globaux/Date/toLocaleFormat", "toLocaleFormat")}} est dépréciée.
 
-<h3 id="Fonctions">Fonctions</h3>
+### Fonctions
 
-<ul>
- <li>{{jsxref("Opérateurs/Expression_de_fermetures", "Les expressions de fermetures", "", 1)}} sont dépréciées. Il faut utiliser {{jsxref("Opérateurs/L_opérateur_function", "function")}} ou {{jsxref("Fonctions/Fonctions_fléchées", "les fonctions fléchées", "", 1)}} à la place.</li>
-</ul>
+- {{jsxref("Opérateurs/Expression_de_fermetures", "Les expressions de fermetures", "", 1)}} sont dépréciées. Il faut utiliser {{jsxref("Opérateurs/L_opérateur_function", "function")}} ou {{jsxref("Fonctions/Fonctions_fléchées", "les fonctions fléchées", "", 1)}} à la place.
 
-<h3 id="Proxy">Proxy</h3>
+### Proxy
 
-<ul>
- <li><a href="/en-US/docs/Archive/Web/Old_Proxy_API">Proxy.create</a> et <a href="/en-US/docs/Archive/Web/Old_Proxy_API">Proxy.createFunction</a> sont dépréciées. L'API {{jsxref("Objets_globaux/Proxy", "Proxy")}} doit être utilisée à la place.</li>
- <li>Les trappes de captures suivantes sont obsolètes :
-  <ul>
-   <li><code>hasOwn</code> ({{bug(980565)}}, Firefox 33).</li>
-   <li><code>getEnumerablePropertyKeys</code> ({{bug(783829)}}, Firefox 37)</li>
-   <li><code>getOwnPropertyNames</code> ({{bug(1007334)}}, Firefox 33)</li>
-   <li><code>keys</code> ({{bug(1007334)}}, Firefox 33)</li>
-  </ul>
- </li>
-</ul>
+- [Proxy.create](/en-US/docs/Archive/Web/Old_Proxy_API) et [Proxy.createFunction](/en-US/docs/Archive/Web/Old_Proxy_API) sont dépréciées. L'API {{jsxref("Objets_globaux/Proxy", "Proxy")}} doit être utilisée à la place.
+- Les trappes de captures suivantes sont obsolètes :
 
-<h3 id="Escape_Sequences">Séquences d'échappement</h3>
+  - `hasOwn` ({{bug(980565)}}, Firefox 33).
+  - `getEnumerablePropertyKeys` ({{bug(783829)}}, Firefox 37)
+  - `getOwnPropertyNames` ({{bug(1007334)}}, Firefox 33)
+  - `keys` ({{bug(1007334)}}, Firefox 33)
 
-<ul>
- <li>Les séquences d'échappement octales (\ suivi par un, deux ou trois chiffres octaux) sont dépréciées pour les chaînes de caractères et les littéraux d'expressions rationnelles.</li>
- <li>Les fonctions {{jsxref("Objets_globaux/escape", "escape")}} et {{jsxref("Objets_globaux/unescape", "unescape")}} sont dépréciées. Ce sont les méthodes et objets {{jsxref("Objets_globaux/encodeURI", "encodeURI")}}, {{jsxref("Objets_globaux/encodeURIComponent", "encodeURIComponent")}}, {{jsxref("Objets_globaux/decodeURI", "decodeURI")}} ou {{jsxref("Objets_globaux/decodeURIComponent", "decodeURIComponent")}} qui doivent être utilisées pour encoder/décoder les séquences d'échappement des caractères spéciaux.</li>
-</ul>
+### Séquences d'échappement
 
-<h3 id="Méthodes_de_String">Méthodes de <code>String</code></h3>
+- Les séquences d'échappement octales (\ suivi par un, deux ou trois chiffres octaux) sont dépréciées pour les chaînes de caractères et les littéraux d'expressions rationnelles.
+- Les fonctions {{jsxref("Objets_globaux/escape", "escape")}} et {{jsxref("Objets_globaux/unescape", "unescape")}} sont dépréciées. Ce sont les méthodes et objets {{jsxref("Objets_globaux/encodeURI", "encodeURI")}}, {{jsxref("Objets_globaux/encodeURIComponent", "encodeURIComponent")}}, {{jsxref("Objets_globaux/decodeURI", "decodeURI")}} ou {{jsxref("Objets_globaux/decodeURIComponent", "decodeURIComponent")}} qui doivent être utilisées pour encoder/décoder les séquences d'échappement des caractères spéciaux.
 
-<ul>
- <li><a href="/fr/docs/tag/HTML%20wrapper%20methods">Les méthodes d'enrobage HTML</a> telles que {{jsxref("String.prototype.fontsize")}} et {{jsxref("String.prototype.big")}} sont dépréciées.</li>
- <li>{{jsxref("String.prototype.quote")}} a été retiré de Firefox 37.</li>
- <li>Le paramètre non-standard <code>flags</code> de {{jsxref("String.prototype.search")}}, {{jsxref("String.prototype.match")}}, et {{jsxref("String.prototype.replace")}} sont dépréciés.</li>
- <li>{{jsxref("String.prototype.substr")}} ne sera sans doute pas retiré prochainement mais il est défini dans l'<a href="https://www.ecma-international.org/ecma-262/9.0/index.html#sec-string.prototype.substr">annexe B du standard ECMA-262</a> dont l'introduction précise clairement que « les développeurs ne devraient pass utiliser ou présupposer l'existence de ces fonctionnalités et de ces comportements lors de l'écriture de nouveau code ECMAScript ».</li>
-</ul>
+### Méthodes de `String`
 
-<h2 id="Fonctionnalités_obsolètes">Fonctionnalités obsolètes</h2>
+- [Les méthodes d'enrobage HTML](/fr/docs/tag/HTML%20wrapper%20methods) telles que {{jsxref("String.prototype.fontsize")}} et {{jsxref("String.prototype.big")}} sont dépréciées.
+- {{jsxref("String.prototype.quote")}} a été retiré de Firefox 37.
+- Le paramètre non-standard `flags` de {{jsxref("String.prototype.search")}}, {{jsxref("String.prototype.match")}}, et {{jsxref("String.prototype.replace")}} sont dépréciés.
+- {{jsxref("String.prototype.substr")}} ne sera sans doute pas retiré prochainement mais il est défini dans l'[annexe B du standard ECMA-262](https://www.ecma-international.org/ecma-262/9.0/index.html#sec-string.prototype.substr) dont l'introduction précise clairement que « les développeurs ne devraient pass utiliser ou présupposer l'existence de ces fonctionnalités et de ces comportements lors de l'écriture de nouveau code ECMAScript ».
 
-<p>Ces fonctionnalités sont obsolètes et ont intégralement été retirées de JavaScript. Elles ne peuvent plus être utilisées.</p>
+## Fonctionnalités obsolètes
 
-<h3 id="Object">Object</h3>
+Ces fonctionnalités sont obsolètes et ont intégralement été retirées de JavaScript. Elles ne peuvent plus être utilisées.
 
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th>Propriété</th>
-   <th>Description</th>
-  </tr>
-  <tr>
-   <td>{{jsxref("Objets_globaux/Object/count", "__count__")}}</td>
-   <td>Renvoie le nombre de propriétés énumérables d'un objet défini par l'utillisateur.</td>
-  </tr>
-  <tr>
-   <td>{{jsxref("Objets_globaux/Object/Parent", "__parent__")}}</td>
-   <td>Pointe vers le contexte d'un objet.</td>
-  </tr>
-  <tr>
-   <td>{{jsxref("Global_Objects/Object/eval", "Object.prototype.eval()")}}</td>
-   <td>Évalue une chaine de caractères étant du code JavaScript, dans le contexte de l'objet indiqué.</td>
-  </tr>
-  <tr>
-   <td>{{jsxref("Object.observe()")}}</td>
-   <td>Observe les modifications apportées à un objet de façon asynchrone.</td>
-  </tr>
-  <tr>
-   <td>{{jsxref("Object.unobserve()")}}</td>
-   <td>Retire les observateurs ajoutés à un objet.</td>
-  </tr>
-  <tr>
-   <td>{{jsxref("Object.getNotifier()")}}</td>
-   <td>Crée un objet qui permet de déclencher un changement de façon synthétique.</td>
-  </tr>
- </tbody>
-</table>
+### Object
 
-<h3 id="Function"><code>Function</code></h3>
+| Propriété                                                                                | Description                                                                                    |
+| ---------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------- |
+| {{jsxref("Objets_globaux/Object/count", "__count__")}}                 | Renvoie le nombre de propriétés énumérables d'un objet défini par l'utillisateur.              |
+| {{jsxref("Objets_globaux/Object/Parent", "__parent__")}}             | Pointe vers le contexte d'un objet.                                                            |
+| {{jsxref("Global_Objects/Object/eval", "Object.prototype.eval()")}} | Évalue une chaine de caractères étant du code JavaScript, dans le contexte de l'objet indiqué. |
+| {{jsxref("Object.observe()")}}                                                 | Observe les modifications apportées à un objet de façon asynchrone.                            |
+| {{jsxref("Object.unobserve()")}}                                             | Retire les observateurs ajoutés à un objet.                                                    |
+| {{jsxref("Object.getNotifier()")}}                                             | Crée un objet qui permet de déclencher un changement de façon synthétique.                     |
 
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th>Propriété</th>
-   <th>Description</th>
-  </tr>
-  <tr>
-   <td>{{jsxref("Objets_globaux/Function/arity", "arity")}}</td>
-   <td>Nombre d'arguments déclarés pour une fonction.</td>
-  </tr>
- </tbody>
-</table>
+### `Function`
 
-<h3 id="Array"><code>Array</code></h3>
+| Propriété                                                            | Description                                    |
+| -------------------------------------------------------------------- | ---------------------------------------------- |
+| {{jsxref("Objets_globaux/Function/arity", "arity")}} | Nombre d'arguments déclarés pour une fonction. |
 
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th>Propriété</th>
-   <th>Description</th>
-  </tr>
-  <tr>
-   <td>{{jsxref("Array.observe()")}}</td>
-   <td>Observe les modifications apportées à un tableau de façon asynchrone.</td>
-  </tr>
-  <tr>
-   <td>{{jsxref("Array.unobserve()")}}</td>
-   <td>Retire les observateurs ajoutés à un tableau.</td>
-  </tr>
- </tbody>
-</table>
+### `Array`
+
+| Propriété                                | Description                                                           |
+| ---------------------------------------- | --------------------------------------------------------------------- |
+| {{jsxref("Array.observe()")}} | Observe les modifications apportées à un tableau de façon asynchrone. |
+| {{jsxref("Array.unobserve()")}} | Retire les observateurs ajoutés à un tableau.                         |
 
-<h3 id="Number"><code>Number</code></h3>
+### `Number`
 
-<ul>
- <li>{{jsxref("Number.toInteger()")}}</li>
-</ul>
+- {{jsxref("Number.toInteger()")}}
 
-<h3 id="ParallelArray"><code>ParallelArray</code></h3>
+### `ParallelArray`
 
-<ul>
- <li>{{jsxref("ParallelArray")}}</li>
-</ul>
+- {{jsxref("ParallelArray")}}
 
-<h3 id="Instructions">Instructions</h3>
+### Instructions
 
-<ul>
- <li>{{jsxref("Instructions/for_each...in", "for each...in")}}, utiliser {{jsxref("Instructions/for...of", "for...of")}} à la place.</li>
- <li>La décomposition de variables dans {{jsxref("Instructions/for...in", "for...in")}}, utiliser {{jsxref("Instructions/for...of", "for...of")}} à la place.</li>
- <li>Les blocs et expressions <code>let</code> sont obsolètes.</li>
-</ul>
+- {{jsxref("Instructions/for_each...in", "for each...in")}}, utiliser {{jsxref("Instructions/for...of", "for...of")}} à la place.
+- La décomposition de variables dans {{jsxref("Instructions/for...in", "for...in")}}, utiliser {{jsxref("Instructions/for...of", "for...of")}} à la place.
+- Les blocs et expressions `let` sont obsolètes.
 
-<h3 id="E4X">E4X</h3>
+### E4X
 
-<p>Voir la page <a href="/fr/docs/E4X">E4X</a> pour plus d'informations.</p>
+Voir la page [E4X](/fr/docs/E4X) pour plus d'informations.
 
-<h3 id="Sharp_variables">Sharp variables</h3>
+### Sharp variables
 
-<p>Voir la page <a href="/en-US/docs/Archive/Web/Sharp_variables_in_JavaScript">sur les variables « Sharp » en JavaScript</a> pour plus d'informations.</p>
+Voir la page [sur les variables « Sharp » en JavaScript](/en-US/docs/Archive/Web/Sharp_variables_in_JavaScript) pour plus d'informations.
diff --git a/files/fr/web/javascript/reference/deprecated_and_obsolete_features/the_legacy_iterator_protocol/index.md b/files/fr/web/javascript/reference/deprecated_and_obsolete_features/the_legacy_iterator_protocol/index.md
index 22c6e16c0b..8a6de2d8e6 100644
--- a/files/fr/web/javascript/reference/deprecated_and_obsolete_features/the_legacy_iterator_protocol/index.md
+++ b/files/fr/web/javascript/reference/deprecated_and_obsolete_features/the_legacy_iterator_protocol/index.md
@@ -9,48 +9,45 @@ translation_of: >-
   Web/JavaScript/Reference/Deprecated_and_obsolete_features/The_legacy_Iterator_protocol
 original_slug: Web/JavaScript/Guide/Le_protocole_itérateur_historique
 ---
-<div>{{JSSideBar("More")}}</div>
+{{JSSideBar("More")}}
 
-<div class="warning"><p><strong>Attention :</strong> Ce protocole historique était une fonctionnalité spécifique à SpiderMonkey et est supprimé à partir de Firefox 58. Pour utiliser des itérations par la suite, veuillez utiliser des boucles <a href="/fr/docs/Web/JavaScript/Reference/Instructions/for...of">for..of</a> ainsi que le <a href="/fr/docs/Web/JavaScript/Guide/Le_protocole_iterator">protocole itérateur</a>.</p></div>
+> **Attention :** Ce protocole historique était une fonctionnalité spécifique à SpiderMonkey et est supprimé à partir de Firefox 58. Pour utiliser des itérations par la suite, veuillez utiliser des boucles [for..of](/fr/docs/Web/JavaScript/Reference/Instructions/for...of) ainsi que le [protocole itérateur](/fr/docs/Web/JavaScript/Guide/Le_protocole_iterator).
 
-<h2 id="Le_protocole_itérateur_obsolète_spécifique_à_Firefox">Le protocole itérateur obsolète, spécifique à Firefox</h2>
+## Le protocole itérateur obsolète, spécifique à Firefox
 
-<p>Avant la version 26, Firefox implémentait un autre protocole d'itération semblable à celui défini par <a href="/fr/docs/Web/JavaScript/Guide/Le_protocole_iterator">ES2015</a>.</p>
+Avant la version 26, Firefox implémentait un autre protocole d'itération semblable à celui défini par [ES2015](/fr/docs/Web/JavaScript/Guide/Le_protocole_iterator).
 
-<p>Un objet est un itérateur historique lorsqu'il implémente une méthode <code>next()</code> avec la sémantique suivante et lorsqu'il renvoie une exception {{jsxref("Objets_globaux/StopIteration", "StopIteration")}} à la fin de l'itération :</p>
+Un objet est un itérateur historique lorsqu'il implémente une méthode `next()` avec la sémantique suivante et lorsqu'il renvoie une exception {{jsxref("Objets_globaux/StopIteration", "StopIteration")}} à la fin de l'itération :
 
 <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 une valeur.</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 une valeur.</p></td>
+    </tr>
+  </tbody>
 </table>
 
-<h3 id="Les_différences_entre_le_protocole_historique_et_celui_d'ES2015">Les différences entre le protocole historique et celui d'ES2015</h3>
+### Les différences entre le protocole historique et celui d'ES2015
 
-<ul>
- <li>La valeur était directement renvoyée par la fonction <code>next</code> alors qu'avec le protocole ES2015, elle est contenue dans une propriété <code>value</code></li>
- <li>La fin de l'itération était signalée par un objet {{jsxref("Objets-globaux/StopIteration", "StopIteration")}}.</li>
-</ul>
+- La valeur était directement renvoyée par la fonction `next` alors qu'avec le protocole ES2015, elle est contenue dans une propriété `value`
+- La fin de l'itération était signalée par un objet {{jsxref("Objets-globaux/StopIteration", "StopIteration")}}.
 
-<h3 id="Un_exemple_simple_utilisant_l'ancien_protocole">Un exemple simple utilisant l'ancien protocole</h3>
+### Un exemple simple utilisant l'ancien protocole
 
-<h4 id="Exemple">Exemple</h4>
+#### Exemple
 
-<pre class="brush: js">function créerItérateur(tableau){
+```js
+function créerItérateur(tableau){
     var nextIndex = 0;
 
     return {
        next: function(){
-           if(nextIndex &lt; tableau.length){
+           if(nextIndex < tableau.length){
                return tableau[nextIndex++];
            else
                throw new StopIteration();
@@ -70,11 +67,9 @@ catch(e){
          // fin de l'itération
     }
 }
-</pre>
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li><a href="/fr/docs/Web/JavaScript/Guide/iterateurs_et_generateurs">Les itérateurs et générateurs</a></li>
- <li><a href="/fr/docs/JavaScript/Reference/Annexes/Fonctionnalités_dépréciées">D'autres fonctionnalités dépréciées et obsolètes</a></li>
-</ul>
+- [Les itérateurs et générateurs](/fr/docs/Web/JavaScript/Guide/iterateurs_et_generateurs)
+- [D'autres fonctionnalités dépréciées et obsolètes](/fr/docs/JavaScript/Reference/Annexes/Fonctionnalités_dépréciées)
diff --git a/files/fr/web/javascript/reference/errors/already_has_pragma/index.md b/files/fr/web/javascript/reference/errors/already_has_pragma/index.md
index 506c6bc246..a9aa355462 100644
--- a/files/fr/web/javascript/reference/errors/already_has_pragma/index.md
+++ b/files/fr/web/javascript/reference/errors/already_has_pragma/index.md
@@ -8,35 +8,37 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/Already_has_pragma
 original_slug: Web/JavaScript/Reference/Erreurs/Already_has_pragma
 ---
-<div>{{jsSidebar("Errors")}}</div>
+{{jsSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">Warning: -fichier- is being assigned a //# sourceMappingURL, but already has one.</pre>
+    Warning: -fichier- is being assigned a //# sourceMappingURL, but already has one.
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>Un avertissement. L'exécution du script JavaScript n'est pas interrompue.</p>
+Un avertissement. L'exécution du script JavaScript n'est pas interrompue.
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p>Un fichier <em>source map</em> a été défini plus d'une fois pour un fichier source JavaScript donné.</p>
+Un fichier _source map_ a été défini plus d'une fois pour un fichier source JavaScript donné.
 
-<p>La plupart du temps, les fichiers sources des scripts JavaScript sont fusionnés et minifiés afin que les transferts de fichiers du serveur vers le navigateur soient plus efficaces. Grâce <a href="http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/">aux fichiers de correspondance des sources (<em>source maps</em>)</a>, il est possible d'indiquer au débogueur le code original correspondant. Il existe deux méthodes pour déclarer une correspondance de sources : en utilisant un commentaire ou définissant un en-tête pour le fichier JavaScript.</p>
+La plupart du temps, les fichiers sources des scripts JavaScript sont fusionnés et minifiés afin que les transferts de fichiers du serveur vers le navigateur soient plus efficaces. Grâce [aux fichiers de correspondance des sources (_source maps_)](http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/), il est possible d'indiquer au débogueur le code original correspondant. Il existe deux méthodes pour déclarer une correspondance de sources : en utilisant un commentaire ou définissant un en-tête pour le fichier JavaScript.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<p>Voici une correspondance de source déclarée via un commentaire dans le fichier :</p>
+Voici une correspondance de source déclarée via un commentaire dans le fichier :
 
-<pre class="brush: js example-good">//# sourceMappingURL=http://exemple.com/chemin/vers/la/sourcemap.map</pre>
+```js example-good
+//# sourceMappingURL=http://exemple.com/chemin/vers/la/sourcemap.map
+```
 
-<p>Une autre méthode consiste à indiquer la source originale dans l'en-tête du fichier JavaScript :</p>
+Une autre méthode consiste à indiquer la source originale dans l'en-tête du fichier JavaScript :
 
-<pre class="brush: js example-good">X-SourceMap: /chemin/vers/le/fichier.js.map</pre>
+```js example-good
+X-SourceMap: /chemin/vers/le/fichier.js.map
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li><a href="/fr/docs/Outils/Débogueur/Comment/Utiliser_une_source_map">Comment utiliser une correspondance de source - Les outils de développement Firefox</a></li>
- <li><a href="http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/">Une introduction aux correspondances de sources – HTML5 Rocks (en anglais)</a></li>
-</ul>
+- [Comment utiliser une correspondance de source - Les outils de développement Firefox](/fr/docs/Outils/Débogueur/Comment/Utiliser_une_source_map)
+- [Une introduction aux correspondances de sources – HTML5 Rocks (en anglais)](http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/)
diff --git a/files/fr/web/javascript/reference/errors/array_sort_argument/index.md b/files/fr/web/javascript/reference/errors/array_sort_argument/index.md
index 6f7c3d07f2..b39add1b92 100644
--- a/files/fr/web/javascript/reference/errors/array_sort_argument/index.md
+++ b/files/fr/web/javascript/reference/errors/array_sort_argument/index.md
@@ -8,41 +8,41 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/Array_sort_argument
 original_slug: Web/JavaScript/Reference/Erreurs/Array_sort_argument
 ---
-<div>{{jsSidebar("Errors")}}</div>
+{{jsSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">TypeError: argument is not a function object (Edge)
-TypeError: invalid Array.prototype.sort argument (Firefox)
-</pre>
+    TypeError: argument is not a function object (Edge)
+    TypeError: invalid Array.prototype.sort argument (Firefox)
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>{{jsxref("TypeError")}}</p>
+{{jsxref("TypeError")}}
 
-<h2 id="Que_s'est-il_passé">Que s'est-il passé ?</h2>
+## Que s'est-il passé ?
 
-<p>L'argument passé à {{jsxref("Array.prototype.sort()")}} devrait être {{jsxref("undefined")}} ou être une fonction comparant ses opérandes.</p>
+L'argument passé à {{jsxref("Array.prototype.sort()")}} devrait être {{jsxref("undefined")}} ou être une fonction comparant ses opérandes.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Cas_invalides">Cas invalides</h3>
+### Cas invalides
 
-<pre class="brush: js example-bad">[1, 3, 2].sort(5);  // TypeError
+```js example-bad
+[1, 3, 2].sort(5);  // TypeError
 
-var cmp = { asc: (x, y) =&gt; x &gt;= y, dsc : (x, y) =&gt; x &lt;= y };
+var cmp = { asc: (x, y) => x >= y, dsc : (x, y) => x <= y };
 [1, 3, 2].sort(cmp[this.key] || 'asc');  // TypeError
-</pre>
+```
 
-<h3 id="Cas_valides">Cas valides</h3>
+### Cas valides
 
-<pre class="brush: js example-good">[1, 3, 2].sort();   // [1, 2, 3]
+```js example-good
+[1, 3, 2].sort();   // [1, 2, 3]
 
-var cmp = { asc: (x, y) =&gt; x &gt;= y, dsc : (x, y) =&gt; x &lt;= y };
-[1, 3, 2].sort(cmp[this.key || 'asc']); // [1, 2, 3]</pre>
+var cmp = { asc: (x, y) => x >= y, dsc : (x, y) => x <= y };
+[1, 3, 2].sort(cmp[this.key || 'asc']); // [1, 2, 3]
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("Array.prototype.sort()")}}</li>
-</ul>
+- {{jsxref("Array.prototype.sort()")}}
diff --git a/files/fr/web/javascript/reference/errors/bad_octal/index.md b/files/fr/web/javascript/reference/errors/bad_octal/index.md
index 4b14545161..eeea43f7ac 100644
--- a/files/fr/web/javascript/reference/errors/bad_octal/index.md
+++ b/files/fr/web/javascript/reference/errors/bad_octal/index.md
@@ -10,44 +10,44 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/Bad_octal
 original_slug: Web/JavaScript/Reference/Erreurs/Bad_octal
 ---
-<div>{{jsSidebar("Errors")}}</div>
+{{jsSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">Warning: SyntaxError: 08 is not a legal ECMA-262 octal constant.
-Warning: SyntaxError: 09 is not a legal ECMA-262 octal constant.
-</pre>
+    Warning: SyntaxError: 08 is not a legal ECMA-262 octal constant.
+    Warning: SyntaxError: 09 is not a legal ECMA-262 octal constant.
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>Un avertissement, l'exécution du script JavaScript ne sera pas interrompue.</p>
+Un avertissement, l'exécution du script JavaScript ne sera pas interrompue.
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p>Les littéraux de nombres décimaux peuvent démarrer par un zéro suivi d'un autre chiffre. Si tous les chiffres après le 0 de tête sont inférieurs à 8, le nombre est interprété comme un nombre en notation octale. Or, cela ne peut pas être le cas avec <code>08</code> et <code>09</code> et JavaScript produit un avertissement.</p>
+Les littéraux de nombres décimaux peuvent démarrer par un zéro suivi d'un autre chiffre. Si tous les chiffres après le 0 de tête sont inférieurs à 8, le nombre est interprété comme un nombre en notation octale. Or, cela ne peut pas être le cas avec `08` et `09` et JavaScript produit un avertissement.
 
-<p>Les littéraux en notation octale et les séquences d'échappement octales sont désormais dépréciées (il y a aura donc un avertissement complémentaire sur la dépréciation de ces notations). Avec ECMAScript 6 et les versions ultérieures, la syntaxe utilise un zéro initial, suivi de la lettre latine « o » en majuscule ou en minuscule ((<code>0o</code> ou <code>0O)</code>. Pour plus d'informations à ce sujet, voir la page sur <a href="/fr/docs/Web/JavaScript/Reference/Grammaire_lexicale#Octaux">la grammaire lexicale JavaScript</a>.</p>
+Les littéraux en notation octale et les séquences d'échappement octales sont désormais dépréciées (il y a aura donc un avertissement complémentaire sur la dépréciation de ces notations). Avec ECMAScript 6 et les versions ultérieures, la syntaxe utilise un zéro initial, suivi de la lettre latine « o » en majuscule ou en minuscule ((`0o` ou `0O)`. Pour plus d'informations à ce sujet, voir la page sur [la grammaire lexicale JavaScript](/fr/docs/Web/JavaScript/Reference/Grammaire_lexicale#Octaux).
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Nombres_invalides_en_notation_octale">Nombres invalides en notation octale</h3>
+### Nombres invalides en notation octale
 
-<pre class="brush: js example-bad">08;
+```js example-bad
+08;
 09;
 // SyntaxError: 08 is not a legal ECMA-262 octal constant
-// SyntaxError: "0"-prefixed octal literals and octal escape sequences are deprecated</pre>
+// SyntaxError: "0"-prefixed octal literals and octal escape sequences are deprecated
+```
 
-<h3 id="Nombres_valides_en_notation_octale">Nombres valides en notation octale</h3>
+### Nombres valides en notation octale
 
-<p>On utilisera un zéro suivi de la lettre « o » pour indiquer un nombre exprimé en notation octale :</p>
+On utilisera un zéro suivi de la lettre « o » pour indiquer un nombre exprimé en notation octale :
 
-<pre class="brush: js example-good">0O755;
+```js example-good
+0O755;
 0o644;
-</pre>
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li><a href="/fr/docs/Web/JavaScript/Reference/Grammaire_lexicale#Octaux">La grammaire lexicale de JavaScript</a></li>
- <li><a href="/fr/docs/Web/JavaScript/Reference/Errors/Deprecated_octal">SyntaxError: "0"-prefixed octal literals and octal escape seq. are deprecated</a></li>
-</ul>
+- [La grammaire lexicale de JavaScript](/fr/docs/Web/JavaScript/Reference/Grammaire_lexicale#Octaux)
+- [SyntaxError: "0"-prefixed octal literals and octal escape seq. are deprecated](/fr/docs/Web/JavaScript/Reference/Errors/Deprecated_octal)
diff --git a/files/fr/web/javascript/reference/errors/bad_radix/index.md b/files/fr/web/javascript/reference/errors/bad_radix/index.md
index c620439cae..ecc2b20a37 100644
--- a/files/fr/web/javascript/reference/errors/bad_radix/index.md
+++ b/files/fr/web/javascript/reference/errors/bad_radix/index.md
@@ -8,57 +8,54 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/Bad_radix
 original_slug: Web/JavaScript/Reference/Erreurs/Bad_radix
 ---
-<div>{{jsSidebar("Errors")}}</div>
+{{jsSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">RangeError: invalid argument (Edge)
-RangeError: radix must be an integer at least 2 and no greater than 36 (Firefox)
-RangeError: toString() radix argument must be between 2 and 36 (Chrome)
-</pre>
+    RangeError: invalid argument (Edge)
+    RangeError: radix must be an integer at least 2 and no greater than 36 (Firefox)
+    RangeError: toString() radix argument must be between 2 and 36 (Chrome)
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>{{jsxref("RangeError")}}</p>
+{{jsxref("RangeError")}}
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p>C'est le paramètre utilisé avec la méthode {{jsxref("Number.prototype.toString()")}} ou avec la méthode {{jsxref("BigInt.prototype.toString()")}} pour indiquer la base de conversion qui est en cause. Ce paramètre, optionnel, doit être un nombre entier, compris entre 2 et 36 qui inique la base du système numérique dans lequel on veut représenter les valeurs numériques.</p>
+C'est le paramètre utilisé avec la méthode {{jsxref("Number.prototype.toString()")}} ou avec la méthode {{jsxref("BigInt.prototype.toString()")}} pour indiquer la base de conversion qui est en cause. Ce paramètre, optionnel, doit être un nombre entier, compris entre 2 et 36 qui inique la base du système numérique dans lequel on veut représenter les valeurs numériques.
 
-<p>Pourquoi limiter la base à 36 ? Lorsqu'une base est supérieure à 10, on utilise les caractères de l'alphabet pour représenter les chiffres. Or, l'alphabet latin ne possède que 26 caractères. En utilisant donc les 10 chiffres arabes et ces caractères, on possède 36 caractères pour représenter les chiffres d'un nombre.</p>
+Pourquoi limiter la base à 36 ? Lorsqu'une base est supérieure à 10, on utilise les caractères de l'alphabet pour représenter les chiffres. Or, l'alphabet latin ne possède que 26 caractères. En utilisant donc les 10 chiffres arabes et ces caractères, on possède 36 caractères pour représenter les chiffres d'un nombre.
 
-<p>Généralement, on emploie cette méthode avec des bases fréquemment utilisées :</p>
+Généralement, on emploie cette méthode avec des bases fréquemment utilisées :
 
-<ul>
- <li>2 pour <a href="https://fr.wikipedia.org/wiki/Syst%C3%A8me_binaire">les nombres binaires</a>,</li>
- <li>8 pour <a href="https://fr.wikipedia.org/wiki/Syst%C3%A8me_octal">les nombres octaux</a>,</li>
- <li>10 pour <a href="https://fr.wikipedia.org/wiki/Syst%C3%A8me_d%C3%A9cimal">les nombres décimaux</a>,</li>
- <li>16 pour <a href="https://fr.wikipedia.org/wiki/Syst%C3%A8me_hexad%C3%A9cimal">les nombres hexadécimaux</a>.</li>
-</ul>
+- 2 pour [les nombres binaires](https://fr.wikipedia.org/wiki/Syst%C3%A8me_binaire),
+- 8 pour [les nombres octaux](https://fr.wikipedia.org/wiki/Syst%C3%A8me_octal),
+- 10 pour [les nombres décimaux](https://fr.wikipedia.org/wiki/Syst%C3%A8me_d%C3%A9cimal),
+- 16 pour [les nombres hexadécimaux](https://fr.wikipedia.org/wiki/Syst%C3%A8me_hexad%C3%A9cimal).
 
-<h2 id="Examples">Examples</h2>
+## Examples
 
-<h3 id="Exemples_invalides">Exemples invalides</h3>
+### Exemples invalides
 
-<pre class="brush: js example-bad">(42).toString(0);
+```js example-bad
+(42).toString(0);
 (42).toString(1);
 (42).toString(37);
 (42).toString(150);
 // On ne peut pas utiliser une telle
 // chaîne pour du formatage :
 (12071989).toString("MM-dd-yyyy");
-</pre>
+```
 
-<h3 id="Exemples_valides">Exemples valides</h3>
+### Exemples valides
 
-<pre class="brush: js example-good">(42).toString(2);     // "101010" (binary)
+```js example-good
+(42).toString(2);     // "101010" (binary)
 (13).toString(8);     // "15"     (octal)
 (0x42).toString(10);  // "66"     (decimal)
 (100000).toString(16) // "186a0"  (hexadecimal)
-</pre>
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("Number.prototype.toString()")}}</li>
-</ul>
+- {{jsxref("Number.prototype.toString()")}}
diff --git a/files/fr/web/javascript/reference/errors/bad_regexp_flag/index.md b/files/fr/web/javascript/reference/errors/bad_regexp_flag/index.md
index 9f1632d1a0..17657e237b 100644
--- a/files/fr/web/javascript/reference/errors/bad_regexp_flag/index.md
+++ b/files/fr/web/javascript/reference/errors/bad_regexp_flag/index.md
@@ -8,100 +8,81 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/Bad_regexp_flag
 original_slug: Web/JavaScript/Reference/Erreurs/Bad_regexp_flag
 ---
-<div>{{jsSidebar("Errors")}}</div>
-
-<h2 id="Message">Message</h2>
-
-<pre class="syntaxbox">SyntaxError: Syntax error in regular expression (Edge)
-SyntaxError: invalid regular expression flag "x" (Firefox)
-SyntaxError: Invalid regular expression flags (Chrome)
-</pre>
-
-<h2 id="Type_d'erreur">Type d'erreur</h2>
-
-<p>{{jsxref("SyntaxError")}}</p>
-
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
-
-<p>Un marqueur (<em>flag</em>) invalide est utilisé dans une expression rationnelle. Un littéral d'expression rationnelle se compose d'un motif entouré de deux barres obliques, les marqueurs sont ajoutés après la seconde barre oblique. On peut également les indiquer dans le deuxième paramètre du constructeur {{jsxref("RegExp")}}. Les marqueurs d'une expression rationnelle peuvent être utilisés séparément ou combinés, dans n'importe quel ordre. Il existe uniquement cinq marqueurs autorisés en ECMAScript.</p>
-
-<p>Pour ajouter un marqueur sur une expression rationnelle, on utilisera cette syntaxe :</p>
-
-<pre class="brush: js">var re = /motif/marqueurs;
-</pre>
-
-<p>ou encore :</p>
-
-<pre class="brush: js">var re = new RegExp('motif', 'marqueurs');</pre>
-
-<table class="standard-table">
- <caption>Marqueurs autorisés pour les expressions rationnelles</caption>
- <thead>
-  <tr>
-   <th scope="col">Marqueur</th>
-   <th scope="col">Description</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td><code>g</code></td>
-   <td>Recherche globale.</td>
-  </tr>
-  <tr>
-   <td>i</td>
-   <td>Recherche non-sensible à la casse.</td>
-  </tr>
-  <tr>
-   <td>m</td>
-   <td>Recherche sur plusieurs lignes.</td>
-  </tr>
-  <tr>
-   <td>u</td>
-   <td>Unicode : le motif est interprété comme une suite de codets Unicode.</td>
-  </tr>
-  <tr>
-   <td>y</td>
-   <td>La recherche effectuée est « adhérente » et recherche une correspondance à la position indiquée dans la chaîne cible (cf. {{jsxref("RegExp.sticky", "sticky")}}).</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Exemples">Exemples</h2>
-
-<p>Seuls cinq marqueurs d'expression rationnelle sont valides :</p>
-
-<pre class="brush: js example-bad">/toto/truc;
+{{jsSidebar("Errors")}}
+
+## Message
+
+    SyntaxError: Syntax error in regular expression (Edge)
+    SyntaxError: invalid regular expression flag "x" (Firefox)
+    SyntaxError: Invalid regular expression flags (Chrome)
+
+## Type d'erreur
+
+{{jsxref("SyntaxError")}}
+
+## Quel est le problème ?
+
+Un marqueur (_flag_) invalide est utilisé dans une expression rationnelle. Un littéral d'expression rationnelle se compose d'un motif entouré de deux barres obliques, les marqueurs sont ajoutés après la seconde barre oblique. On peut également les indiquer dans le deuxième paramètre du constructeur {{jsxref("RegExp")}}. Les marqueurs d'une expression rationnelle peuvent être utilisés séparément ou combinés, dans n'importe quel ordre. Il existe uniquement cinq marqueurs autorisés en ECMAScript.
+
+Pour ajouter un marqueur sur une expression rationnelle, on utilisera cette syntaxe :
+
+```js
+var re = /motif/marqueurs;
+```
+
+ou encore :
+
+```js
+var re = new RegExp('motif', 'marqueurs');
+```
+
+| Marqueur | Description                                                                                                                                                                  |
+| -------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `g`      | Recherche globale.                                                                                                                                                           |
+| i        | Recherche non-sensible à la casse.                                                                                                                                           |
+| m        | Recherche sur plusieurs lignes.                                                                                                                                              |
+| u        | Unicode : le motif est interprété comme une suite de codets Unicode.                                                                                                         |
+| y        | La recherche effectuée est « adhérente » et recherche une correspondance à la position indiquée dans la chaîne cible (cf. {{jsxref("RegExp.sticky", "sticky")}}). |
+
+## Exemples
+
+Seuls cinq marqueurs d'expression rationnelle sont valides :
+
+```js example-bad
+/toto/truc;
 
 // SyntaxError: invalid regular expression flag "t"
-</pre>
+```
 
-<p>Peut-être souhaitiez-vous créer une expression rationnelle ? Une expression qui contient deux barres obliques est interprétée comme un littéral d'expression rationnelle :</p>
+Peut-être souhaitiez-vous créer une expression rationnelle ? Une expression qui contient deux barres obliques est interprétée comme un littéral d'expression rationnelle :
 
-<pre class="brush: js example-bad">let obj = {
+```js example-bad
+let obj = {
   url: /docs/Web
 };
 
 // SyntaxError: invalid regular expression flag "W"
-</pre>
+```
 
-<p>Peut-être souhaitiez-vous créer une chaîne de caractères ? Dans ce cas, il faut ajouter des quotes (simples ou doubles) afin de former un littéral de chaîne de caractères :</p>
+Peut-être souhaitiez-vous créer une chaîne de caractères ? Dans ce cas, il faut ajouter des quotes (simples ou doubles) afin de former un littéral de chaîne de caractères :
 
-<pre class="brush: js example-good">let obj = {
+```js example-good
+let obj = {
   url: '/docs/Web'
-};</pre>
+};
+```
 
-<h3 id="Marqueurs_valides">Marqueurs valides</h3>
+### Marqueurs valides
 
-<p>Voir le tableau ci-avant pour la liste des marqueurs autorisés pour manipuler les expressions rationnelles en JavaScript.</p>
+Voir le tableau ci-avant pour la liste des marqueurs autorisés pour manipuler les expressions rationnelles en JavaScript.
 
-<pre class="brush: js example-good">/toto/g;
+```js example-good
+/toto/g;
 /toto/gim;
 /toto/uy;
-</pre>
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li><a href="/fr/docs/Web/JavaScript/Guide/Expressions_régulières">Les expressions rationnelles</a></li>
- <li><a href="http://xregexp.com/flags/">XRegEx</a> – une bibliothèque relative aux expressions rationnelles qui fournit quatre nouveaux marqueurs (<em>flags</em>) (<code>n</code>, <code>s</code>, <code>x</code>, <code>A</code>)</li>
-</ul>
+- [Les expressions rationnelles](/fr/docs/Web/JavaScript/Guide/Expressions_régulières)
+- [XRegEx](http://xregexp.com/flags/) – une bibliothèque relative aux expressions rationnelles qui fournit quatre nouveaux marqueurs (_flags_) (`n`, `s`, `x`, `A`)
diff --git a/files/fr/web/javascript/reference/errors/bad_return_or_yield/index.md b/files/fr/web/javascript/reference/errors/bad_return_or_yield/index.md
index 787f099067..f50090e6ec 100644
--- a/files/fr/web/javascript/reference/errors/bad_return_or_yield/index.md
+++ b/files/fr/web/javascript/reference/errors/bad_return_or_yield/index.md
@@ -9,50 +9,51 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/Bad_return_or_yield
 original_slug: Web/JavaScript/Reference/Erreurs/Bad_return_or_yield
 ---
-<div>{{jsSidebar("Errors")}}</div>
+{{jsSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">SyntaxError: 'return' statement outside of function (Edge)
-SyntaxError: return not in function (Firefox)
-SyntaxError: yield not in function (Firefox)
-</pre>
+    SyntaxError: 'return' statement outside of function (Edge)
+    SyntaxError: return not in function (Firefox)
+    SyntaxError: yield not in function (Firefox)
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>{{jsxref("SyntaxError")}}.</p>
+{{jsxref("SyntaxError")}}.
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p>Une instruction <code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/return">return</a></code> ou <code><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/yield">yield</a></code> est utilisée en dehors d'une <a href="/fr/docs/Web/JavaScript/Guide/Fonctions">fonction</a>. Il est possible que des accolades soient manquantes. Les mots-clés <code>return</code> et <code>yield</code> doivent être utilisés dans une fonction car ils permettent de terminer ou d'arrêter/reprendre l'exécution d'une fonction et de définir une valeur qui doit être renvoyée à l'appelant de la fonction.</p>
+Une instruction [`return`](/fr/docs/Web/JavaScript/Reference/Instructions/return) ou [`yield`](/fr/docs/Web/JavaScript/Reference/Opérateurs/yield) est utilisée en dehors d'une [fonction](/fr/docs/Web/JavaScript/Guide/Fonctions). Il est possible que des accolades soient manquantes. Les mots-clés `return` et `yield` doivent être utilisés dans une fonction car ils permettent de terminer ou d'arrêter/reprendre l'exécution d'une fonction et de définir une valeur qui doit être renvoyée à l'appelant de la fonction.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<pre class="brush: js example-bad">var encouragement = function(score) {
+```js example-bad
+var encouragement = function(score) {
   if (score === 147)
     return "Super !";
   };
-  if (score &gt; 100) {
+  if (score > 100) {
     return "Un record!";
   }
 }
 
-// SyntaxError: return not in function</pre>
+// SyntaxError: return not in function
+```
 
-<p>À première vue, les accolades semblent correctes mais en regardant de plus près, on voit qu'il manque une accolade ouvrante ("{") après la première instruction <code>if</code>. La version correcte serait :</p>
+À première vue, les accolades semblent correctes mais en regardant de plus près, on voit qu'il manque une accolade ouvrante ("{") après la première instruction `if`. La version correcte serait :
 
-<pre class="brush: js example-good">var encouragement = function(score) {
+```js example-good
+var encouragement = function(score) {
   if (score === 147) {
     return "Maximum!";
   }
-  if (score &gt; 100) {
+  if (score > 100) {
     return "Century!";
   }
-};</pre>
+};
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li><code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/return">return</a></code></li>
- <li><code><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/yield">yield</a></code></li>
-</ul>
+- [`return`](/fr/docs/Web/JavaScript/Reference/Instructions/return)
+- [`yield`](/fr/docs/Web/JavaScript/Reference/Opérateurs/yield)
diff --git a/files/fr/web/javascript/reference/errors/called_on_incompatible_type/index.md b/files/fr/web/javascript/reference/errors/called_on_incompatible_type/index.md
index 35fcf07a52..a560955088 100644
--- a/files/fr/web/javascript/reference/errors/called_on_incompatible_type/index.md
+++ b/files/fr/web/javascript/reference/errors/called_on_incompatible_type/index.md
@@ -8,34 +8,34 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/Called_on_incompatible_type
 original_slug: Web/JavaScript/Reference/Erreurs/Called_on_incompatible_type
 ---
-<div>{{jsSidebar("Errors")}}</div>
+{{jsSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">TypeError: 'this' is not a Set object (Edge)
-TypeError: Function.prototype.toString called on incompatible object (Firefox)
-TypeError: Function.prototype.bind called on incompatible target (Firefox)
-TypeError: Method Set.prototype.add called on incompatible receiver undefined (Chrome)
-TypeError: Bind must be called on a function (Chrome)
-</pre>
+    TypeError: 'this' is not a Set object (Edge)
+    TypeError: Function.prototype.toString called on incompatible object (Firefox)
+    TypeError: Function.prototype.bind called on incompatible target (Firefox)
+    TypeError: Method Set.prototype.add called on incompatible receiver undefined (Chrome)
+    TypeError: Bind must be called on a function (Chrome)
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>{{jsxref("TypeError")}}</p>
+{{jsxref("TypeError")}}
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p>Lorsque cette erreur est levée, cela signifie qu'une fonction (d'un objet donné) est appelé avec une valeur <code>this</code> qui ne correspond pas au type attendu par la fonction.</p>
+Lorsque cette erreur est levée, cela signifie qu'une fonction (d'un objet donné) est appelé avec une valeur `this` qui ne correspond pas au type attendu par la fonction.
 
-<p>Cela peut se produire lorsqu'on utilise les méthodes {{jsxref("Function.prototype.call()")}} ou {{jsxref("Function.prototype.apply()")}} et qu'on fournit un argument <code>this</code> dont le type n'est pas celui attendu.</p>
+Cela peut se produire lorsqu'on utilise les méthodes {{jsxref("Function.prototype.call()")}} ou {{jsxref("Function.prototype.apply()")}} et qu'on fournit un argument `this` dont le type n'est pas celui attendu.
 
-<p>Cela peut également se produire quand on fournit une fonction (sous la forme d'un objet) comme argument d'une autre fonction. Dans ce cas, l'objet ne sera pas capturé comme valeur <code>this</code> pour la fonction. Pour contourner ce problème, on peut fournir une fonction lambda qui effectue l'appel ou utiliser la fonction {{jsxref("Function.prototype.bind()")}} afin que <code>this</code> soit l'objet attendu.</p>
+Cela peut également se produire quand on fournit une fonction (sous la forme d'un objet) comme argument d'une autre fonction. Dans ce cas, l'objet ne sera pas capturé comme valeur `this` pour la fonction. Pour contourner ce problème, on peut fournir une fonction lambda qui effectue l'appel ou utiliser la fonction {{jsxref("Function.prototype.bind()")}} afin que `this` soit l'objet attendu.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Exemples_invalides">Exemples invalides</h3>
+### Exemples invalides
 
-<pre class="brush: js example-bad">var monSet = new Set;
+```js example-bad
+var monSet = new Set;
 ['truc', 'bidule'].forEach(monSet.add);
 // monSet.add est une fonction mais
 // "monSet" n'est pas capturé en tant que this.
@@ -47,30 +47,27 @@ var maFonction = function () {
 // maFonction.bind est une fonction
 // mais "maFonction" n'est pas capturé en tant
 // que this.
+```
 
-</pre>
+### Exemples valides
 
-<h3 id="Exemples_valides">Exemples valides</h3>
-
-<pre class="brush: js example-good">var monSet = new Set;
+```js example-good
+var monSet = new Set;
 ['truc', 'bidule'].forEach(monSet.add.bind(monSet));
 // Cela fonctionne car on lie "monSet" avec this.
 
 var maFonction = function () {
   console.log(this)
 };
-['truc', 'bidule'].forEach(x =&gt; maFonction.bind(x));
+['truc', 'bidule'].forEach(x => maFonction.bind(x));
 // Cela fonctionne car on utilise
 // la fonction "bind" ce qui permet de
 // créer une fonction lambda qui propage
 // l'argument.
+```
 
-</pre>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("Function.prototype.call()")}}</li>
- <li>{{jsxref("Function.prototype.apply()")}}</li>
- <li>{{jsxref("Function.prototype.bind()")}}</li>
-</ul>
+- {{jsxref("Function.prototype.call()")}}
+- {{jsxref("Function.prototype.apply()")}}
+- {{jsxref("Function.prototype.bind()")}}
diff --git a/files/fr/web/javascript/reference/errors/cant_access_lexical_declaration_before_init/index.md b/files/fr/web/javascript/reference/errors/cant_access_lexical_declaration_before_init/index.md
index 1ac434163b..351754cba4 100644
--- a/files/fr/web/javascript/reference/errors/cant_access_lexical_declaration_before_init/index.md
+++ b/files/fr/web/javascript/reference/errors/cant_access_lexical_declaration_before_init/index.md
@@ -9,30 +9,30 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/Cant_access_lexical_declaration_before_init
 original_slug: Web/JavaScript/Reference/Erreurs/Cant_access_lexical_declaration_before_init
 ---
-<div>{{jsSidebar("Errors")}}</div>
+{{jsSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">ReferenceError: Use before delaration (Edge)
-ReferenceError: can't access lexical declaration `X' before initialization (Firefox)
-ReferenceError: 'x' is not defined (Chrome)
-</pre>
+    ReferenceError: Use before delaration (Edge)
+    ReferenceError: can't access lexical declaration `X' before initialization (Firefox)
+    ReferenceError: 'x' is not defined (Chrome)
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>{{jsxref("ReferenceError")}}</p>
+{{jsxref("ReferenceError")}}
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p>Il y a eu un accès à une variable déclarée avec <code>let</code> ou <code>const</code> avant que celle-ci ait été initialisée. Cela peut se produire dans n'importe quelle instruction de bloc avec une variable déclarée avec <code>let</code> ou <code>const</code> et qui est utilisée avant son initialisation.</p>
+Il y a eu un accès à une variable déclarée avec `let` ou `const` avant que celle-ci ait été initialisée. Cela peut se produire dans n'importe quelle instruction de bloc avec une variable déclarée avec `let` ou `const` et qui est utilisée avant son initialisation.
 
-<h2 id="Exemple">Exemple</h2>
+## Exemple
 
-<h3 id="Exemples_invalides">Exemples invalides</h3>
+### Exemples invalides
 
-<p>Dans l'exemple qui suit, la variable <code>toto</code> est redéclarée dans le bloc avec un second <code>let</code> et elle n'est donc pas initialisée.</p>
+Dans l'exemple qui suit, la variable `toto` est redéclarée dans le bloc avec un second `let` et elle n'est donc pas initialisée.
 
-<pre class="brush: js example-bad">function test(){
+```js example-bad
+function test(){
    let toto = 33;
    if (true) {
       let toto = (toto + 55);
@@ -41,23 +41,22 @@ ReferenceError: 'x' is not defined (Chrome)
    }
 }
 test();
-</pre>
+```
 
-<h3 id="Exemples_valides">Exemples valides</h3>
+### Exemples valides
 
-<p>Afin que <code>toto</code> puisse être modifiée au sein de l'instruction <code>if</code>, on enlèvera la redéclaration dans ce bloc :</p>
+Afin que `toto` puisse être modifiée au sein de l'instruction `if`, on enlèvera la redéclaration dans ce bloc :
 
-<pre class="brush: js example-good">function test(){
+```js example-good
+function test(){
    let toto = 33;
    if (true) {
       toto = (toto + 55);
    }
 }
 test();
-</pre>
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li><a href="/fr/docs/Web/JavaScript/Reference/Instructions/let#Zone_morte_temporaire_(Temporal_Dead_Zone_TDZ)_et_les_erreurs_liées_à_let">La « zone morte temporelle » (ou TDZ pour « <em>Temporal Dead Zone</em> ») et les erreurs avec <code>let</code></a></li>
-</ul>
+- [La « zone morte temporelle » (ou TDZ pour « _Temporal Dead Zone_ ») et les erreurs avec `let`](</fr/docs/Web/JavaScript/Reference/Instructions/let#Zone_morte_temporaire_(Temporal_Dead_Zone_TDZ)_et_les_erreurs_liées_à_let>)
diff --git a/files/fr/web/javascript/reference/errors/cant_access_property/index.md b/files/fr/web/javascript/reference/errors/cant_access_property/index.md
index e9ea7c5e0c..20c4ffd4a6 100644
--- a/files/fr/web/javascript/reference/errors/cant_access_property/index.md
+++ b/files/fr/web/javascript/reference/errors/cant_access_property/index.md
@@ -8,53 +8,53 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/Cant_access_property
 original_slug: Web/JavaScript/Reference/Erreurs/Cant_access_property
 ---
-<div>{{jsSidebar("Errors")}}</div>
+{{jsSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">TypeError: Unable to get property {x} of undefined or null reference (Edge)
-TypeError: can't access property {x} of {y} (Firefox)
-TypeError: {y} is undefined, can't access property {x} of it (Firefox)
-TypeError: {y} is null, can't access property {x} of it (Firefox)
+    TypeError: Unable to get property {x} of undefined or null reference (Edge)
+    TypeError: can't access property {x} of {y} (Firefox)
+    TypeError: {y} is undefined, can't access property {x} of it (Firefox)
+    TypeError: {y} is null, can't access property {x} of it (Firefox)
 
-Exemples
-TypeError: x is undefined, can't access property "prop" of it
-TypeError: x is null, can't access property "prop" of it
-TypeError: can't access property "prop" of undefined
-TypeError: can't access property "prop" of null
-</pre>
+    Exemples
+    TypeError: x is undefined, can't access property "prop" of it
+    TypeError: x is null, can't access property "prop" of it
+    TypeError: can't access property "prop" of undefined
+    TypeError: can't access property "prop" of null
 
-<h2 id="Types_d'erreur">Types d'erreur</h2>
+## Types d'erreur
 
-<p>{{jsxref("TypeError")}}.</p>
+{{jsxref("TypeError")}}.
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p>On a tenté d'accéder à une propriété sur la valeur {{jsxref("undefined")}} ou {{jsxref("null")}}.</p>
+On a tenté d'accéder à une propriété sur la valeur {{jsxref("undefined")}} ou {{jsxref("null")}}.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Cas_invalides">Cas invalides</h3>
+### Cas invalides
 
-<pre class="brush: js example-bad">// undefined et null ne possèdent aucune propriété et aucune méthode substring
+```js example-bad
+// undefined et null ne possèdent aucune propriété et aucune méthode substring
 var toto = undefined;
 toto.substring(1); // TypeError: x is undefined, can't access property "substring" of it
 
 var toto = null;
 toto.substring(1); // TypeError: x is null, can't access property "substring" of it
-</pre>
+```
 
-<h3 id="Corriger_le_problème">Corriger le problème</h3>
+### Corriger le problème
 
-<p>Pour détecter le cas où la valeur utilisée est <code>undefined</code> ou <code>null</code>, on peut utiliser l'opérateur <code><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_typeof">typeof</a></code>. Par exemple :</p>
+Pour détecter le cas où la valeur utilisée est `undefined` ou `null`, on peut utiliser l'opérateur [`typeof`](/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_typeof). Par exemple :
 
-<pre class="brush: js">if (typeof toto !== 'undefined') {
+```js
+if (typeof toto !== 'undefined') {
   // On sait alors que toto est bien défini et on peut utiliser ses propriétés s'il en a.
-}</pre>
+}
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("undefined")}}</li>
- <li>{{jsxref("null")}}</li>
-</ul>
+- {{jsxref("undefined")}}
+- {{jsxref("null")}}
diff --git a/files/fr/web/javascript/reference/errors/cant_assign_to_property/index.md b/files/fr/web/javascript/reference/errors/cant_assign_to_property/index.md
index 29b72aaa47..771d329791 100644
--- a/files/fr/web/javascript/reference/errors/cant_assign_to_property/index.md
+++ b/files/fr/web/javascript/reference/errors/cant_assign_to_property/index.md
@@ -9,48 +9,47 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/Cant_assign_to_property
 original_slug: Web/JavaScript/Reference/Erreurs/Cant_assign_to_property
 ---
-<div>{{jsSidebar("Errors")}}</div>
+{{jsSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">TypeError: can't assign to property "x" on {y}: not an object (Firefox)
-TypeError: Cannot create property 'x' on {y} (Chrome)
-</pre>
+    TypeError: can't assign to property "x" on {y}: not an object (Firefox)
+    TypeError: Cannot create property 'x' on {y} (Chrome)
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>{{jsxref("TypeError")}}.</p>
+{{jsxref("TypeError")}}.
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p>En <a href="/fr/docs/Web/JavaScript/Reference/Strict_mode">mode strict</a>, une exception {{jsxref("TypeError")}} est déclenchée lorsqu'on tente de créer une propriété sur <a href="/fr/docs/Web/JavaScript/Structures_de_données#Les_valeurs_primitives">une valeur primitive</a> telle qu'un symbole, une chaîne de caractères, un nombre ou un booleén.</p>
+En [mode strict](/fr/docs/Web/JavaScript/Reference/Strict_mode), une exception {{jsxref("TypeError")}} est déclenchée lorsqu'on tente de créer une propriété sur [une valeur primitive](/fr/docs/Web/JavaScript/Structures_de_données#Les_valeurs_primitives) telle qu'un symbole, une chaîne de caractères, un nombre ou un booleén.
 
-<p>Le problème peut être lié à une valeur qui se trouve à un endroit inattendu ou qu'un équivalent objet d'une valeur primitive est attendu (ex. {{jsxref("String")}} pour la chaîne de caractères ou {{jsxref("Number")}} pour un nombre).</p>
+Le problème peut être lié à une valeur qui se trouve à un endroit inattendu ou qu'un équivalent objet d'une valeur primitive est attendu (ex. {{jsxref("String")}} pour la chaîne de caractères ou {{jsxref("Number")}} pour un nombre).
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Exemple_invalide">Exemple invalide</h3>
+### Exemple invalide
 
-<pre class="brush: js example-bad">'use strict';
+```js example-bad
+'use strict';
 
 var foo = "my string";
 // The following line does nothing if not in strict mode.
 foo.bar = {}; // TypeError: can't assign to property "bar" on "my string": not an object
-</pre>
+```
 
-<h3 id="Exemple_valide">Exemple valide</h3>
+### Exemple valide
 
-<p>On pourra corriger le problème en convertissant la valeur primitive en sont équivalent objet avec un constructeur (ici {{jsxref("String")}} pour .</p>
+On pourra corriger le problème en convertissant la valeur primitive en sont équivalent objet avec un constructeur (ici {{jsxref("String")}} pour .
 
-<pre class="brush: js example-good">'use strict';
+```js example-good
+'use strict';
 
 var foo = new String("my string");
 foo.bar = {};
-</pre>
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("Strict_mode")}}</li>
- <li>{{Glossary("primitive")}}</li>
-</ul>
+- {{jsxref("Strict_mode")}}
+- {{Glossary("primitive")}}
diff --git a/files/fr/web/javascript/reference/errors/cant_define_property_object_not_extensible/index.md b/files/fr/web/javascript/reference/errors/cant_define_property_object_not_extensible/index.md
index 674ffd0138..8849cda16d 100644
--- a/files/fr/web/javascript/reference/errors/cant_define_property_object_not_extensible/index.md
+++ b/files/fr/web/javascript/reference/errors/cant_define_property_object_not_extensible/index.md
@@ -8,59 +8,60 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/Cant_define_property_object_not_extensible
 original_slug: Web/JavaScript/Reference/Erreurs/Cant_define_property_object_not_extensible
 ---
-<div>{{jsSidebar("Errors")}}</div>
+{{jsSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">TypeError: Cannot create property for a non-extensible object (Edge)
-TypeError: can't define property "x": "obj" is not extensible (Firefox)
-TypeError: Cannot define property: "x", object is not extensible. (Chrome)
-</pre>
+    TypeError: Cannot create property for a non-extensible object (Edge)
+    TypeError: can't define property "x": "obj" is not extensible (Firefox)
+    TypeError: Cannot define property: "x", object is not extensible. (Chrome)
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>{{jsxref("TypeError")}}</p>
+{{jsxref("TypeError")}}
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p>La plupart du temps, un objet est extensible, ce qui signifie qu'on peut lui ajouter de nouvelles propriétés. Cependant, dans ce cas, on a utilisé la méthode {{jsxref("Object.preventExtensions()")}} afin de marquer l'objet comme non-extensible. Celui-ci ne pourra donc pas recevoir de nouvelles propriétés en plus de celles dont il dispose déjà.</p>
+La plupart du temps, un objet est extensible, ce qui signifie qu'on peut lui ajouter de nouvelles propriétés. Cependant, dans ce cas, on a utilisé la méthode {{jsxref("Object.preventExtensions()")}} afin de marquer l'objet comme non-extensible. Celui-ci ne pourra donc pas recevoir de nouvelles propriétés en plus de celles dont il dispose déjà.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<p>En <a href="/fr/docs/Web/JavaScript/Reference/Strict_mode">mode strict</a>, si on essaie d'ajouter une nouvelle propriété sur un objet non-extensible, on obtient une exception <code>TypeError</code>. En mode non-strict, l'ajout de la nouvelle propriété est ignoré silencieusement.</p>
+En [mode strict](/fr/docs/Web/JavaScript/Reference/Strict_mode), si on essaie d'ajouter une nouvelle propriété sur un objet non-extensible, on obtient une exception `TypeError`. En mode non-strict, l'ajout de la nouvelle propriété est ignoré silencieusement.
 
-<pre class="brush: js example-bad">'use strict';
+```js example-bad
+'use strict';
 
 var obj = {};
 Object.preventExtensions(obj);
 
 obj.x = 'toto';
 // TypeError: can't define property "x": "obj" is not extensible
-</pre>
+```
 
-<p>Pour le mode strict ete le mode non-strict, un appel à {{jsxref("Object.defineProperty()")}} déclenchera une exception lorsqu'on utilisera cette méthode pour ajouter une nouvelle propriété à un objet non-extenssible.</p>
+Pour le mode strict ete le mode non-strict, un appel à {{jsxref("Object.defineProperty()")}} déclenchera une exception lorsqu'on utilisera cette méthode pour ajouter une nouvelle propriété à un objet non-extenssible.
 
-<pre class="brush: js example-bad">var obj = { };
+```js example-bad
+var obj = { };
 Object.preventExtensions(obj);
 
 Object.defineProperty(obj,
   'x', { value: "toto" }
 );
 // TypeError: can't define property "x": "obj" is not extensible
-</pre>
+```
 
-<p>Pour corriger cet erreur, il faut retirer l'appel à {{jsxref("Object.preventExtensions()")}} pour que l'objet soit extensible, soit ajouter la propriété avant que l'objet devienne non-extensible, soit retirer l'ajout de cette propriété si elle n'est pas nécessaire.</p>
+Pour corriger cet erreur, il faut retirer l'appel à {{jsxref("Object.preventExtensions()")}} pour que l'objet soit extensible, soit ajouter la propriété avant que l'objet devienne non-extensible, soit retirer l'ajout de cette propriété si elle n'est pas nécessaire.
 
-<pre class="brush: js example-good">'use strict';
+```js example-good
+'use strict';
 
 var obj = {};
 obj.x = 'toto'; // On ajoute la propriété avant de
                // bloquer l'ajout d'autres propriétés
 
-Object.preventExtensions(obj);</pre>
+Object.preventExtensions(obj);
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("Object.preventExtensions()")}}</li>
-</ul>
+- {{jsxref("Object.preventExtensions()")}}
diff --git a/files/fr/web/javascript/reference/errors/cant_delete/index.md b/files/fr/web/javascript/reference/errors/cant_delete/index.md
index 7ec2b3bac8..c2e807eecf 100644
--- a/files/fr/web/javascript/reference/errors/cant_delete/index.md
+++ b/files/fr/web/javascript/reference/errors/cant_delete/index.md
@@ -9,30 +9,30 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/Cant_delete
 original_slug: Web/JavaScript/Reference/Erreurs/Cant_delete
 ---
-<div>{{jsSidebar("Errors")}}</div>
+{{jsSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">TypeError: Calling delete on 'x' is not allowed in strict mode (Edge)
-TypeError: property "x" is non-configurable and can't be deleted. (Firefox)
-TypeError: Cannot delete property 'x' of #&lt;Object&gt; (Chrome)
-</pre>
+    TypeError: Calling delete on 'x' is not allowed in strict mode (Edge)
+    TypeError: property "x" is non-configurable and can't be deleted. (Firefox)
+    TypeError: Cannot delete property 'x' of #<Object> (Chrome)
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>{{jsxref("TypeError")}} in strict mode only.</p>
+{{jsxref("TypeError")}} in strict mode only.
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p>Une instruction demande la suppression d'une propriété <a href="/fr/docs/Web/JavaScript/Structures_de_données#Propriétés">non-configurable</a>. L'attribut <code>configurable</code> permet de contrôler si la propriété peut être supprimée de l'objet auquel elle est rattachée et si ces attributs (en dehors de <code>writable</code>) peuvent être modifiés.</p>
+Une instruction demande la suppression d'une propriété [non-configurable](/fr/docs/Web/JavaScript/Structures_de_données#Propriétés). L'attribut `configurable` permet de contrôler si la propriété peut être supprimée de l'objet auquel elle est rattachée et si ces attributs (en dehors de `writable`) peuvent être modifiés.
 
-<p>Cette erreur ne se produit qu'en <a href="/fr/docs/Web/JavaScript/Reference/Strict_mode">mode strict</a>. En mode non-strict, l'opération de suppression renverra <code>false</code>.</p>
+Cette erreur ne se produit qu'en [mode strict](/fr/docs/Web/JavaScript/Reference/Strict_mode). En mode non-strict, l'opération de suppression renverra `false`.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<p>Les propriétés non-configurables ne sont pas très fréquentes mais il est possible d'en créer grâce à {{jsxref("Object.defineProperty()")}} ou à  {{jsxref("Object.freeze()")}}.</p>
+Les propriétés non-configurables ne sont pas très fréquentes mais il est possible d'en créer grâce à {{jsxref("Object.defineProperty()")}} ou à  {{jsxref("Object.freeze()")}}.
 
-<pre class="brush: js example-bad">"use strict";
+```js example-bad
+"use strict";
 var obj = Object.freeze({name: "Elsa", score: 157});
 delete obj.score;  // TypeError
 
@@ -44,17 +44,17 @@ delete obj.toto;  // TypeError
 "use strict";
 var frozenArray = Object.freeze([0, 1, 2]);
 frozenArray.pop();  // TypeError
-</pre>
+```
 
-<p>Certaines propriétés natives de JavaScript sont non-configurables. Peut-être que le code tente de supprimer une constante mathématique :</p>
+Certaines propriétés natives de JavaScript sont non-configurables. Peut-être que le code tente de supprimer une constante mathématique :
 
-<pre class="brush: js example-bad">"use strict";
-delete Math.PI;  // TypeError</pre>
+```js example-bad
+"use strict";
+delete Math.PI;  // TypeError
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_delete">L'opérateur <code>delete</code></a></li>
- <li>{{jsxref("Object.defineProperty()")}}</li>
- <li>{{jsxref("Object.freeze()")}}</li>
-</ul>
+- [L'opérateur `delete`](/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_delete)
+- {{jsxref("Object.defineProperty()")}}
+- {{jsxref("Object.freeze()")}}
diff --git a/files/fr/web/javascript/reference/errors/cant_redefine_property/index.md b/files/fr/web/javascript/reference/errors/cant_redefine_property/index.md
index 5311f957a5..0c445fd4a6 100644
--- a/files/fr/web/javascript/reference/errors/cant_redefine_property/index.md
+++ b/files/fr/web/javascript/reference/errors/cant_redefine_property/index.md
@@ -8,45 +8,45 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/Cant_redefine_property
 original_slug: Web/JavaScript/Reference/Erreurs/Cant_redefine_property
 ---
-<div>{{jsSidebar("Errors")}}</div>
+{{jsSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">TypeError: Cannot modify non-writable property {x} (Edge)
-TypeError: can't redefine non-configurable property "x" (Firefox)
-TypeError: Cannot redefine property: "x" (Chrome)
-</pre>
+    TypeError: Cannot modify non-writable property {x} (Edge)
+    TypeError: can't redefine non-configurable property "x" (Firefox)
+    TypeError: Cannot redefine property: "x" (Chrome)
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>{{jsxref("TypeError")}}</p>
+{{jsxref("TypeError")}}
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p>On essaie de redéfinir une propriété alors que celle-ci est <a href="/fr/docs/Web/JavaScript/Structures_de_données#Propriétés">non-configurable</a>. L'attribut <code>configurable</code> permet d'indiquer si la propriété peut être supprimée d'un objet et si ses attributs (en dehors de <code>writable</code>) peuvent être modifiés. Généralement, les propriétés d'un objet créées avec un <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Initialisateur_objet">initialisateur d'objet</a> sont configurables. Cependant, lorsqu'on utilise la méthode {{jsxref("Object.defineProperty()")}}, la propriété n'est pas configurable par défaut.</p>
+On essaie de redéfinir une propriété alors que celle-ci est [non-configurable](/fr/docs/Web/JavaScript/Structures_de_données#Propriétés). L'attribut `configurable` permet d'indiquer si la propriété peut être supprimée d'un objet et si ses attributs (en dehors de `writable`) peuvent être modifiés. Généralement, les propriétés d'un objet créées avec un [initialisateur d'objet](/fr/docs/Web/JavaScript/Reference/Opérateurs/Initialisateur_objet) sont configurables. Cependant, lorsqu'on utilise la méthode {{jsxref("Object.defineProperty()")}}, la propriété n'est pas configurable par défaut.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Propriétés_non-configurables_créées_avec_Object.defineProperty()">Propriétés non-configurables créées avec <code>Object.defineProperty()</code></h3>
+### Propriétés non-configurables créées avec `Object.defineProperty()`
 
-<p>La méthode {{jsxref("Object.defineProperty()")}} crée des propriétés non-configurables si on n'indique pas le contraire :</p>
+La méthode {{jsxref("Object.defineProperty()")}} crée des propriétés non-configurables si on n'indique pas le contraire :
 
-<pre class="brush: js example-bad">var obj = Object.create({});
+```js example-bad
+var obj = Object.create({});
 Object.defineProperty(obj, "toto", {value: "machin"});
 
 Object.defineProperty(obj, "toto", {value: "bidule"});
 // TypeError: can't redefine non-configurable property "toto"
-</pre>
+```
 
-<p>Si on veut pouvoir redéfinir la propriété "toto" dans la suite du code, il faudra la créer comme étant configurable.</p>
+Si on veut pouvoir redéfinir la propriété "toto" dans la suite du code, il faudra la créer comme étant configurable.
 
-<pre class="brush: js example-good">var obj = Object.create({});
+```js example-good
+var obj = Object.create({});
 Object.defineProperty(obj, "toto", {value: "machin", configurable: true});
-Object.defineProperty(obj, "toto", {value: "bidule", configurable: true});</pre>
+Object.defineProperty(obj, "toto", {value: "bidule", configurable: true});
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li><a href="/fr/docs/Web/JavaScript/Structures_de_données#Propriétés">[[Configurable]]</a></li>
- <li>{{jsxref("Object.defineProperty()")}}</li>
-</ul>
+- [\[\[Configurable\]\]](/fr/docs/Web/JavaScript/Structures_de_données#Propriétés)
+- {{jsxref("Object.defineProperty()")}}
diff --git a/files/fr/web/javascript/reference/errors/cyclic_object_value/index.md b/files/fr/web/javascript/reference/errors/cyclic_object_value/index.md
index aa50f933f9..58de02ab6d 100644
--- a/files/fr/web/javascript/reference/errors/cyclic_object_value/index.md
+++ b/files/fr/web/javascript/reference/errors/cyclic_object_value/index.md
@@ -8,45 +8,47 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/Cyclic_object_value
 original_slug: Web/JavaScript/Reference/Erreurs/Cyclic_object_value
 ---
-<div>{{jsSidebar("Errors")}}</div>
+{{jsSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">TypeError: cyclic object value (Firefox)
-TypeError: Converting circular structure to JSON (Chrome and Opera)
-TypeError: Circular reference in value argument not supported (Edge)
-</pre>
+    TypeError: cyclic object value (Firefox)
+    TypeError: Converting circular structure to JSON (Chrome and Opera)
+    TypeError: Circular reference in value argument not supported (Edge)
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>{{jsxref("TypeError")}}</p>
+{{jsxref("TypeError")}}
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p>Lorsqu'on appelle la méthode {{jsxref("JSON.stringify()")}}, les structures de références cycliques ne peuvent pas être converties en chaîne de caractères car <a href="https://www.json.org/">le format JSON</a> ne prend pas en charge les références (bien qu'<a href="http://tools.ietf.org/html/draft-pbryan-zyp-json-ref-03">un brouillon IETF existe</a>).</p>
+Lorsqu'on appelle la méthode {{jsxref("JSON.stringify()")}}, les structures de références cycliques ne peuvent pas être converties en chaîne de caractères car [le format JSON](https://www.json.org/) ne prend pas en charge les références (bien qu'[un brouillon IETF existe](http://tools.ietf.org/html/draft-pbryan-zyp-json-ref-03)).
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<p>Avec une structure circulaire comme la suivante :</p>
+Avec une structure circulaire comme la suivante :
 
-<pre class="brush: js">var a = {};
+```js
+var a = {};
 var b = {};
 a.child = b;
 b.child = a;
-</pre>
+```
 
-<p>{{jsxref("JSON.stringify()")}} échouera :</p>
+{{jsxref("JSON.stringify()")}} échouera :
 
-<pre class="brush: js example-bad">JSON.stringify(a);
+```js example-bad
+JSON.stringify(a);
 // TypeError: cyclic object value
-</pre>
+```
 
-<p>Il est nécessaire de contrôler l'existence de cycles avant la conversion en chaîne de caractères. On peut par exemple fournir une fonction de remplacement comme deuxième argument de la fonction {{jsxref("JSON.stringify()")}}.</p>
+Il est nécessaire de contrôler l'existence de cycles avant la conversion en chaîne de caractères. On peut par exemple fournir une fonction de remplacement comme deuxième argument de la fonction {{jsxref("JSON.stringify()")}}.
 
-<pre class="brush: js">const getCircularReplacer = () =&gt; {
+```js
+const getCircularReplacer = () => {
   const seen = new WeakSet();
-  return (key, value) =&gt; {
-    if (typeof value === "object" &amp;&amp; value !== null) {
+  return (key, value) => {
+    if (typeof value === "object" && value !== null) {
       if (seen.has(value)) {
         return;
       }
@@ -57,13 +59,12 @@ b.child = a;
 };
 
 JSON.stringify(circularReference, getCircularReplacer());
-// {"otherData":123}</pre>
+// {"otherData":123}
+```
 
-<p>On peut également utiliser une bibliothèque ou une fonction utilitaire pour ce scénario. comme <a href="https://github.com/douglascrockford/JSON-js/blob/master/cycle.js">cycle.js</a>.</p>
+On peut également utiliser une bibliothèque ou une fonction utilitaire pour ce scénario. comme [cycle.js](https://github.com/douglascrockford/JSON-js/blob/master/cycle.js).
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("JSON.stringify")}}</li>
- <li><a href="https://github.com/douglascrockford/JSON-js/blob/master/cycle.js">cycle.js</a> qui introduit deux fonctions : <code>JSON.decycle</code> <code>et JSON.retrocycle</code> qui permettent d'encoder et de décoder des structures cycliques en JSON.</li>
-</ul>
+- {{jsxref("JSON.stringify")}}
+- [cycle.js](https://github.com/douglascrockford/JSON-js/blob/master/cycle.js) qui introduit deux fonctions : `JSON.decycle` `et JSON.retrocycle` qui permettent d'encoder et de décoder des structures cycliques en JSON.
diff --git a/files/fr/web/javascript/reference/errors/dead_object/index.md b/files/fr/web/javascript/reference/errors/dead_object/index.md
index ba4498fd26..0f65953ae7 100644
--- a/files/fr/web/javascript/reference/errors/dead_object/index.md
+++ b/files/fr/web/javascript/reference/errors/dead_object/index.md
@@ -8,43 +8,44 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/Dead_object
 original_slug: Web/JavaScript/Reference/Erreurs/Dead_object
 ---
-<div>{{JSSidebar("Errors")}}</div>
+{{JSSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">TypeError: can't access dead object
-</pre>
+    TypeError: can't access dead object
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>{{jsxref("TypeError")}}</p>
+{{jsxref("TypeError")}}
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p>Afin d'améliorer l'utilisation de la mémoire et de prévenir les fuites mémoire, Firefox empêche les modules complémentaires de conserver des références fortes vers les objets du DOM après que leur document parent a été détruit. Un objet mort (<em>dead</em>) est un objet qui contient une référence forte vers un éléments du DOM, même après que celui-ci a été détruit dans le DOM. Pour éviter ces problèmes, les références aux objets du DOM d'un document étranger devraient être enregistrées dans un objet spécifique à ce document et être nettoyées lors de la suppression du document. On peut également utiliser les objets qui permettent d'enregistrer <a href="/fr/docs/Mozilla/Tech/XPCOM/Language_Bindings/Components.utils.getWeakReference">des références faibles</a>.</p>
+Afin d'améliorer l'utilisation de la mémoire et de prévenir les fuites mémoire, Firefox empêche les modules complémentaires de conserver des références fortes vers les objets du DOM après que leur document parent a été détruit. Un objet mort (_dead_) est un objet qui contient une référence forte vers un éléments du DOM, même après que celui-ci a été détruit dans le DOM. Pour éviter ces problèmes, les références aux objets du DOM d'un document étranger devraient être enregistrées dans un objet spécifique à ce document et être nettoyées lors de la suppression du document. On peut également utiliser les objets qui permettent d'enregistrer [des références faibles](/fr/docs/Mozilla/Tech/XPCOM/Language_Bindings/Components.utils.getWeakReference).
 
-<h2 id="Vérifier_si_un_objet_est_mort">Vérifier si un objet est mort</h2>
+## Vérifier si un objet est mort
 
-<p><code><a href="/fr/docs/Components.utils">Components.utils</a></code> fournit une méthode <code>isDeadWrapper()</code> qui peut être utilisée par du code privilégié :</p>
+[`Components.utils`](/fr/docs/Components.utils) fournit une méthode `isDeadWrapper()` qui peut être utilisée par du code privilégié :
 
-<pre class="brush: js">if (Components.utils.isDeadWrapper(window)) {
+```js
+if (Components.utils.isDeadWrapper(window)) {
   // dead
-}</pre>
+}
+```
 
-<p>Du code sans privilège ne pourra pas accéder à <code>Component.utils</code> et pourra simplement intercepter l'exception :</p>
+Du code sans privilège ne pourra pas accéder à `Component.utils` et pourra simplement intercepter l'exception :
 
-<pre class="brush: js">try {
+```js
+try {
   String(window);
 }
 catch (e) {
   console.log("window est problablement mort ");
-}</pre>
+}
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li><a href="https://blog.mozilla.org/addons/2012/09/12/what-does-cant-access-dead-object-mean/">Que signifie “can’t access dead object” ? (en anglais)</a></li>
- <li><a href="/fr/docs/Extensions/Common_causes_of_memory_leaks_in_extensions">Les causes principales des fuites mémoire dans les extensions</a></li>
- <li><code><a href="/fr/docs/Components.utils">Components.utils</a></code></li>
- <li><a href="/en-US/docs/Mozilla/Zombie_compartments#Zombie_compartments">Compartiments zombies</a></li>
-</ul>
+- [Que signifie “can’t access dead object” ? (en anglais)](https://blog.mozilla.org/addons/2012/09/12/what-does-cant-access-dead-object-mean/)
+- [Les causes principales des fuites mémoire dans les extensions](/fr/docs/Extensions/Common_causes_of_memory_leaks_in_extensions)
+- [`Components.utils`](/fr/docs/Components.utils)
+- [Compartiments zombies](/en-US/docs/Mozilla/Zombie_compartments#Zombie_compartments)
diff --git a/files/fr/web/javascript/reference/errors/delete_in_strict_mode/index.md b/files/fr/web/javascript/reference/errors/delete_in_strict_mode/index.md
index 4451a729be..19d3f9b747 100644
--- a/files/fr/web/javascript/reference/errors/delete_in_strict_mode/index.md
+++ b/files/fr/web/javascript/reference/errors/delete_in_strict_mode/index.md
@@ -10,34 +10,34 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/Delete_in_strict_mode
 original_slug: Web/JavaScript/Reference/Erreurs/Delete_in_strict_mode
 ---
-<div>{{jsSidebar("Errors")}}</div>
+{{jsSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">SyntaxError: Calling delete on expression not allowed in strict mode (Edge)
-SyntaxError: applying the 'delete' operator to an unqualified name is deprecated (Firefox)
-SyntaxError: Delete of an unqualified identifier in strict mode. (Chrome)
-</pre>
+    SyntaxError: Calling delete on expression not allowed in strict mode (Edge)
+    SyntaxError: applying the 'delete' operator to an unqualified name is deprecated (Firefox)
+    SyntaxError: Delete of an unqualified identifier in strict mode. (Chrome)
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>{{jsxref("SyntaxError")}}, uniquement en <a href="/fr/docs/Web/JavaScript/Reference/Strict_mode">mode strict</a>.</p>
+{{jsxref("SyntaxError")}}, uniquement en [mode strict](/fr/docs/Web/JavaScript/Reference/Strict_mode).
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p>Les variables JavaScript ne peuvent pas être supprimées grâce à l'opérateur <code><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_delete">delete</a></code>. En mode strict, toute tentative de suppression d'une variable lèvera une exception.</p>
+Les variables JavaScript ne peuvent pas être supprimées grâce à l'opérateur [`delete`](/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_delete). En mode strict, toute tentative de suppression d'une variable lèvera une exception.
 
-<p>L'opérateur <code>delete</code> sert uniquement à supprimer des propriétés sur un objet. Les propriétés d'un objet sont « qualifiées » si elles sont configurables.</p>
+L'opérateur `delete` sert uniquement à supprimer des propriétés sur un objet. Les propriétés d'un objet sont « qualifiées » si elles sont configurables.
 
-<p>Contrairement à ce qu'on pourrait penser, l'opérateur <code>delete</code> n'a rien à voir avec la libération de la mémoire. La gestion de la mémoire se fait indirectement en cassant les références utilisées. Pour plus d'informations, consulter les pages sur <code><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_delete">delete</a></code> et <a href="/fr/docs/Web/JavaScript/Gestion_de_la_mémoire">la gestion de la mémoire en JavaScript</a>.</p>
+Contrairement à ce qu'on pourrait penser, l'opérateur `delete` n'a rien à voir avec la libération de la mémoire. La gestion de la mémoire se fait indirectement en cassant les références utilisées. Pour plus d'informations, consulter les pages sur [`delete`](/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_delete) et [la gestion de la mémoire en JavaScript](/fr/docs/Web/JavaScript/Gestion_de_la_mémoire).
 
-<p>Cette erreur ne se produit qu'en <a href="/fr/docs/Web/JavaScript/Reference/Strict_mode">mode strict</a>. En mode non-strict, l'opération renvoie simplement <code>false</code>.</p>
+Cette erreur ne se produit qu'en [mode strict](/fr/docs/Web/JavaScript/Reference/Strict_mode). En mode non-strict, l'opération renvoie simplement `false`.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<p>Essayer de supprimer une variable normale avec <code>delete</code> ne fonctionne pas, voire lève une exception en mode strict :</p>
+Essayer de supprimer une variable normale avec `delete` ne fonctionne pas, voire lève une exception en mode strict :
 
-<pre class="brush: js example-bad">'use strict';
+```js example-bad
+'use strict';
 
 var x;
 
@@ -47,23 +47,22 @@ delete x;
 
 // SyntaxError: applying the 'delete' operator to
 // an unqualified name is deprecated
-</pre>
+```
 
-<p>Pour libérer le contenu d'une variable, on peut la passer à {{jsxref("null")}} :</p>
+Pour libérer le contenu d'une variable, on peut la passer à {{jsxref("null")}} :
 
-<pre class="brush: js example-good">'use strict';
+```js example-good
+'use strict';
 
 var x;
 // ...
 x = null;
 
 // x peut être ramassée par le ramasse-miettes
-</pre>
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li><code><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_delete">delete</a></code></li>
- <li><a href="/fr/docs/Web/JavaScript/Gestion_de_la_mémoire">La gestion de la mémoire en JavaScript</a></li>
- <li><a href="/en-US/docs/Web/JavaScript/Reference/Errors/Cant_delete">TypeError: property "x" is non-configurable and can't be deleted</a></li>
-</ul>
+- [`delete`](/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_delete)
+- [La gestion de la mémoire en JavaScript](/fr/docs/Web/JavaScript/Gestion_de_la_mémoire)
+- [TypeError: property "x" is non-configurable and can't be deleted](/en-US/docs/Web/JavaScript/Reference/Errors/Cant_delete)
diff --git a/files/fr/web/javascript/reference/errors/deprecated_caller_or_arguments_usage/index.md b/files/fr/web/javascript/reference/errors/deprecated_caller_or_arguments_usage/index.md
index 669f4903a9..d9aba3fe1e 100644
--- a/files/fr/web/javascript/reference/errors/deprecated_caller_or_arguments_usage/index.md
+++ b/files/fr/web/javascript/reference/errors/deprecated_caller_or_arguments_usage/index.md
@@ -8,31 +8,31 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/Deprecated_caller_or_arguments_usage
 original_slug: Web/JavaScript/Reference/Erreurs/Deprecated_caller_or_arguments_usage
 ---
-<div>{{jsSidebar("Errors")}}</div>
+{{jsSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">TypeError: 'arguments', 'callee' and 'caller' are restricted function properties and cannot be accessed in this context (Edge)
-Warning: ReferenceError: deprecated caller usage (Firefox)
-Warning: ReferenceError: deprecated arguments usage (Firefox)
-TypeError: 'callee' and 'caller' cannot be accessed in strict mode. (Safari)
-</pre>
+    TypeError: 'arguments', 'callee' and 'caller' are restricted function properties and cannot be accessed in this context (Edge)
+    Warning: ReferenceError: deprecated caller usage (Firefox)
+    Warning: ReferenceError: deprecated arguments usage (Firefox)
+    TypeError: 'callee' and 'caller' cannot be accessed in strict mode. (Safari)
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>Un avertissement uniquement affiché en mode strict qui prend la forme d'une {{jsxref("ReferenceError")}}. L'exécution du script JavaScript n'est pas interrompue.</p>
+Un avertissement uniquement affiché en mode strict qui prend la forme d'une {{jsxref("ReferenceError")}}. L'exécution du script JavaScript n'est pas interrompue.
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p><a href="/fr/docs/Web/JavaScript/Reference/Strict_mode">En mode strict</a>, les propriétés {{jsxref("Function.caller")}} et/ou {{jsxref("Function.arguments")}} sont utilisées alors qu'elles ne devraient pas l'être. Ces propriétés sont dépréciées car elles font fuiter des informations sur l'appelant de la fonction et ne sont pas standards. De plus, ces propriétés rendent certaines optimisations plus complexe et peuvent nuire aux performances.</p>
+[En mode strict](/fr/docs/Web/JavaScript/Reference/Strict_mode), les propriétés {{jsxref("Function.caller")}} et/ou {{jsxref("Function.arguments")}} sont utilisées alors qu'elles ne devraient pas l'être. Ces propriétés sont dépréciées car elles font fuiter des informations sur l'appelant de la fonction et ne sont pas standards. De plus, ces propriétés rendent certaines optimisations plus complexe et peuvent nuire aux performances.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utilisation_de_function.caller_ou_de_arguments.callee.caller">Utilisation de <code>function.caller</code> ou de <code>arguments.callee.caller</code></h3>
+### Utilisation de `function.caller` ou de `arguments.callee.caller`
 
-<p>{{jsxref("Function.caller")}} et <code><a href="/fr/docs/Web/JavaScript/Reference/Fonctions/arguments/callee">arguments.callee.caller</a></code> sont dépréciées (se référer aux articles de la référence pour plus d'informations).</p>
+{{jsxref("Function.caller")}} et [`arguments.callee.caller`](/fr/docs/Web/JavaScript/Reference/Fonctions/arguments/callee) sont dépréciées (se référer aux articles de la référence pour plus d'informations).
 
-<pre class="brush: js example-bad">"use strict";
+```js example-bad
+"use strict";
 
 function myFunc() {
   if (myFunc.caller == null) {
@@ -44,19 +44,21 @@ function myFunc() {
 
 myFunc();
 // Warning: ReferenceError: deprecated caller usage
-// "La fonction a été appelée depuis la portée globale !"</pre>
+// "La fonction a été appelée depuis la portée globale !"
+```
 
-<h3 id="Function.arguments"><code>Function.arguments</code></h3>
+### `Function.arguments`
 
-<p>{{jsxref("Function.arguments")}} est dépréciée (se référer à l'article sur cette propriété pour plus d'informations).</p>
+{{jsxref("Function.arguments")}} est dépréciée (se référer à l'article sur cette propriété pour plus d'informations).
 
-<pre class="brush: js example-bad">"use strict";
+```js example-bad
+"use strict";
 
 function f(n) { g(n - 1); }
 
 function g(n) {
   console.log('before: ' + g.arguments[0]);
-  if (n &gt; 0) { f(n); }
+  if (n > 0) { f(n); }
   console.log('after: ' + g.arguments[0]);
 }
 
@@ -64,13 +66,11 @@ f(2);
 
 console.log('returned: ' + g.arguments);
 // Warning: ReferenceError: deprecated arguments usage
-</pre>
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li><a href="/fr/docs/JavaScript/Reference/Annexes/Fonctionnalités_dépréciées">Les fonctionnalités obsolètes et dépréciées</a></li>
- <li><a href="/fr/docs/Web/JavaScript/Reference/Strict_mode">Le mode strict</a></li>
- <li>{{jsxref("Function.arguments")}}</li>
- <li>{{jsxref("Function.caller")}} and <code><a href="/fr/docs/Web/JavaScript/Reference/Functions/arguments/callee">arguments.callee.caller</a></code></li>
-</ul>
+- [Les fonctionnalités obsolètes et dépréciées](/fr/docs/JavaScript/Reference/Annexes/Fonctionnalités_dépréciées)
+- [Le mode strict](/fr/docs/Web/JavaScript/Reference/Strict_mode)
+- {{jsxref("Function.arguments")}}
+- {{jsxref("Function.caller")}} and [`arguments.callee.caller`](/fr/docs/Web/JavaScript/Reference/Functions/arguments/callee)
diff --git a/files/fr/web/javascript/reference/errors/deprecated_expression_closures/index.md b/files/fr/web/javascript/reference/errors/deprecated_expression_closures/index.md
index 5cd6889b74..8f709e61a9 100644
--- a/files/fr/web/javascript/reference/errors/deprecated_expression_closures/index.md
+++ b/files/fr/web/javascript/reference/errors/deprecated_expression_closures/index.md
@@ -8,73 +8,76 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/Deprecated_expression_closures
 original_slug: Web/JavaScript/Reference/Erreurs/Deprecated_expression_closures
 ---
-<div>{{jsSidebar("Errors")}}</div>
+{{jsSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">Warning: expression closures are deprecated
-</pre>
+    Warning: expression closures are deprecated
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>Un avertissement, l'exécution du code JavaScript ne sera pas interrompue.</p>
+Un avertissement, l'exécution du code JavaScript ne sera pas interrompue.
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p>La syntaxe non-standard avec <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Expression_closures">une expression de fermeture</a> est dépréciée et ne devrait plus être utilisée. Cette syntaxe sera complètement retirée avec le bug {{bug(1083458)}} et les scripts qui l'utilisent déclencheront alors une exception {{jsxref("SyntaxError")}}.</p>
+La syntaxe non-standard avec [une expression de fermeture](/fr/docs/Web/JavaScript/Reference/Opérateurs/Expression_closures) est dépréciée et ne devrait plus être utilisée. Cette syntaxe sera complètement retirée avec le bug {{bug(1083458)}} et les scripts qui l'utilisent déclencheront alors une exception {{jsxref("SyntaxError")}}.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Syntaxe_dépréciée">Syntaxe dépréciée</h3>
+### Syntaxe dépréciée
 
-<p>Les expression de fermeture permettent de ne pas utiliser les accolades ou les instructions <code>return</code> au sein d'une déclaration de fonction ou pour une définition de méthode dans un objet.</p>
+Les expression de fermeture permettent de ne pas utiliser les accolades ou les instructions `return` au sein d'une déclaration de fonction ou pour une définition de méthode dans un objet.
 
-<pre class="brush: js example-bad">var x = function() 1;
+```js example-bad
+var x = function() 1;
 
 var obj = {
   count: function() 1
 };
-</pre>
+```
 
-<h3 id="Syntaxe_standard">Syntaxe standard</h3>
+### Syntaxe standard
 
-<p>Pour convertir cette syntaxe non-standard en une syntaxe standard, il suffit d'ajouter des accolades et l'instruction return.</p>
+Pour convertir cette syntaxe non-standard en une syntaxe standard, il suffit d'ajouter des accolades et l'instruction return.
 
-<pre class="brush: js example-good">var x = function() { return 1; }
+```js example-good
+var x = function() { return 1; }
 
 var obj = {
   count: function() { return 1; }
 };
-</pre>
+```
 
-<h3 id="Syntaxe_standard_avec_les_fonctions_fléchées">Syntaxe standard avec les fonctions fléchées</h3>
+### Syntaxe standard avec les fonctions fléchées
 
-<p>On peut aussi utiliser <a href="/fr/docs/Web/JavaScript/Reference/Fonctions/Fonctions_fléchées">les fonctions fléchées</a> :</p>
+On peut aussi utiliser [les fonctions fléchées](/fr/docs/Web/JavaScript/Reference/Fonctions/Fonctions_fléchées) :
 
-<pre class="brush: js example-good">var x = () =&gt; 1;</pre>
+```js example-good
+var x = () => 1;
+```
 
-<h3 id="Syntaxe_standard_avec_la_notation_raccourcie_pour_les_méthodes">Syntaxe standard avec la notation raccourcie pour les méthodes</h3>
+### Syntaxe standard avec la notation raccourcie pour les méthodes
 
-<p>On retrouve parfois les expressions de fermeture dans les accesseurs et les mutateurs, par exemple :</p>
+On retrouve parfois les expressions de fermeture dans les accesseurs et les mutateurs, par exemple :
 
-<pre class="brush: js example-bad">var obj = {
+```js example-bad
+var obj = {
   get x() 1,
   set x(v) this.v = v
 };
-</pre>
+```
 
-<p>Grâce aux <a href="/fr/docs/Web/JavaScript/Reference/Fonctions/Définition_de_méthode">définitions de méthodes</a> ES2015, on peut convertir le fragment de code précédent en :</p>
+Grâce aux [définitions de méthodes](/fr/docs/Web/JavaScript/Reference/Fonctions/Définition_de_méthode) ES2015, on peut convertir le fragment de code précédent en :
 
-<pre class="brush: js example-good">var obj = {
+```js example-good
+var obj = {
   get x() { return 1 },
   set x(v) { this.v = v }
 };
-</pre>
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Expression_closures">Les expressions de fermeture</a></li>
- <li><a href="/fr/docs/Web/JavaScript/Reference/Fonctions/Fonctions_fléchées">Les fonctions fléchées</a></li>
- <li><a href="/fr/docs/Web/JavaScript/Reference/Fonctions/Définition_de_méthode">Les définitions de méthode</a></li>
-</ul>
+- [Les expressions de fermeture](/fr/docs/Web/JavaScript/Reference/Opérateurs/Expression_closures)
+- [Les fonctions fléchées](/fr/docs/Web/JavaScript/Reference/Fonctions/Fonctions_fléchées)
+- [Les définitions de méthode](/fr/docs/Web/JavaScript/Reference/Fonctions/Définition_de_méthode)
diff --git a/files/fr/web/javascript/reference/errors/deprecated_octal/index.md b/files/fr/web/javascript/reference/errors/deprecated_octal/index.md
index 067c0a363a..9b9b9c92f6 100644
--- a/files/fr/web/javascript/reference/errors/deprecated_octal/index.md
+++ b/files/fr/web/javascript/reference/errors/deprecated_octal/index.md
@@ -9,61 +9,62 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/Deprecated_octal
 original_slug: Web/JavaScript/Reference/Erreurs/Deprecated_octal
 ---
-<div>{{jsSidebar("Errors")}}</div>
+{{jsSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">SyntaxError: Octal numeric literals and escape characters not allowed in strict mode (Edge)
-SyntaxError:
-"0"-prefixed octal literals and octal escape sequences are deprecated;
-for octal literals use the "0o" prefix instead
-</pre>
+    SyntaxError: Octal numeric literals and escape characters not allowed in strict mode (Edge)
+    SyntaxError:
+    "0"-prefixed octal literals and octal escape sequences are deprecated;
+    for octal literals use the "0o" prefix instead
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>{{jsxref("SyntaxError")}}, uniquement en <a href="/fr/docs/Web/JavaScript/Reference/Strict_mode">mode strict</a>.</p>
+{{jsxref("SyntaxError")}}, uniquement en [mode strict](/fr/docs/Web/JavaScript/Reference/Strict_mode).
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p>Les littéraux en base octale et les séquences d'échappement octales sont dépréciées et lèvent une exception {{jsxref("SyntaxError")}} en mode strict. À partir d'ECMAScript 2015, la syntaxe standard utilise un zéro suivi de la lettre « o » (en minuscule ou en majuscule) (<code>0o</code> or <code>0O)</code>.</p>
+Les littéraux en base octale et les séquences d'échappement octales sont dépréciées et lèvent une exception {{jsxref("SyntaxError")}} en mode strict. À partir d'ECMAScript 2015, la syntaxe standard utilise un zéro suivi de la lettre « o » (en minuscule ou en majuscule) (`0o` or `0O)`.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Littéraux_en_base_octale_préfixés_par_0">Littéraux en base octale préfixés par 0</h3>
+### Littéraux en base octale préfixés par 0
 
-<pre class="brush: js example-bad">"use strict";
+```js example-bad
+"use strict";
 
 03;
 
 // SyntaxError: "0"-prefixed octal literals and octal escape sequences
-// are deprecated</pre>
+// are deprecated
+```
 
-<h3 id="Séquences_d'échappement_en_base_octale">Séquences d'échappement en base octale</h3>
+### Séquences d'échappement en base octale
 
-<pre class="brush: js example-bad">"use strict";
+```js example-bad
+"use strict";
 
 "\251";
 
 // SyntaxError: "0"-prefixed octal literals and octal escape sequences
 // are deprecated
-</pre>
+```
 
-<h3 id="Littéraux_valides">Littéraux valides</h3>
+### Littéraux valides
 
-<p>Pour former un littéral en base octal, on pourra utiliser un zéro suivi de la lettre « o » :</p>
+Pour former un littéral en base octal, on pourra utiliser un zéro suivi de la lettre « o » :
 
-<pre class="brush: js example-good">0o3;
-</pre>
+```js example-good
+0o3;
+```
 
-<p>Pour former une séquence d'échappement en base octale, on écrira une séquence d'échappement en base hexadécimale :</p>
+Pour former une séquence d'échappement en base octale, on écrira une séquence d'échappement en base hexadécimale :
 
-<pre class="brush: js example-good">'\xA9';</pre>
+```js example-good
+'\xA9';
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li><a href="/fr/docs/Web/JavaScript/Reference/Grammaire_lexicale#Octaux">La grammaire lexicale JavaScript</a></li>
- <li>
-  <p><a href="/fr/docs/Web/JavaScript/Reference/Erreurs/Bad_octal">Warning: 08/09 is not a legal ECMA-262 octal constant</a></p>
- </li>
-</ul>
+- [La grammaire lexicale JavaScript](/fr/docs/Web/JavaScript/Reference/Grammaire_lexicale#Octaux)
+- [Warning: 08/09 is not a legal ECMA-262 octal constant](/fr/docs/Web/JavaScript/Reference/Erreurs/Bad_octal)
diff --git a/files/fr/web/javascript/reference/errors/deprecated_source_map_pragma/index.md b/files/fr/web/javascript/reference/errors/deprecated_source_map_pragma/index.md
index 8d36de23af..f08481d96a 100644
--- a/files/fr/web/javascript/reference/errors/deprecated_source_map_pragma/index.md
+++ b/files/fr/web/javascript/reference/errors/deprecated_source_map_pragma/index.md
@@ -10,50 +10,52 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/Deprecated_source_map_pragma
 original_slug: Web/JavaScript/Reference/Erreurs/Deprecated_source_map_pragma
 ---
-<div>{{jsSidebar("Errors")}}</div>
+{{jsSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">Warning: SyntaxError: Using //@ to indicate sourceURL pragmas is deprecated. Use //# instead
+    Warning: SyntaxError: Using //@ to indicate sourceURL pragmas is deprecated. Use //# instead
 
-Warning: SyntaxError: Using //@ to indicate sourceMappingURL pragmas is deprecated. Use //# instead
-</pre>
+    Warning: SyntaxError: Using //@ to indicate sourceMappingURL pragmas is deprecated. Use //# instead
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>Un avertissement prenant la forme d'une exception {{jsxref("SyntaxError")}}. L'exécution du code JavaScript n'est pas interrompue.</p>
+Un avertissement prenant la forme d'une exception {{jsxref("SyntaxError")}}. L'exécution du code JavaScript n'est pas interrompue.
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p>Une syntaxe dépréciée a été utilisée pour indiquer une correspondance de source (<em>source map</em>) dans le code JavaScript.</p>
+Une syntaxe dépréciée a été utilisée pour indiquer une correspondance de source (_source map_) dans le code JavaScript.
 
-<p>Il arrive souvent que les fichiers sources JavaScript soient combinés et minifiés afin que le transfert depuis le serveur vers le client soit plus efficace. Grâce <a href="http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/">aux correspondances de source (ou <em>source maps</em>)</a>, le débogueur peut utiliser les sources des fichiers correspondants aux fichiers minifiés.</p>
+Il arrive souvent que les fichiers sources JavaScript soient combinés et minifiés afin que le transfert depuis le serveur vers le client soit plus efficace. Grâce [aux correspondances de source (ou _source maps_)](http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/), le débogueur peut utiliser les sources des fichiers correspondants aux fichiers minifiés.
 
-<p>La spécification sur cet outil a évolué car il existait un conflit de syntaxe avec IE (après <code>//@cc_on</code>, la correspondance était interprétée comme un test conditionnel de compilation du moteur JScript).<a href="https://msdn.microsoft.com/en-us/library/8ka90k2e%28v=vs.94%29.aspx"> Ce commentaire de compilation conditionnelle</a> pour IE est peu connu mais son existence entraînait des erreurs avec <a href="https://bugs.jquery.com/ticket/13274">jQuery</a> et d'autres bibliothèques.</p>
+La spécification sur cet outil a évolué car il existait un conflit de syntaxe avec IE (après `//@cc_on`, la correspondance était interprétée comme un test conditionnel de compilation du moteur JScript).[ Ce commentaire de compilation conditionnelle](https://msdn.microsoft.com/en-us/library/8ka90k2e%28v=vs.94%29.aspx) pour IE est peu connu mais son existence entraînait des erreurs avec [jQuery](https://bugs.jquery.com/ticket/13274) et d'autres bibliothèques.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Syntaxe_dépréciée">Syntaxe dépréciée</h3>
+### Syntaxe dépréciée
 
-<p>La syntaxe utilisant l'arobase (@) est dépréciée :</p>
+La syntaxe utilisant l'arobase (@) est dépréciée :
 
-<pre class="brush: js example-bad">//@ sourceMappingURL=http://exemple.com/chemin/vers/la/sourcemap.map
-</pre>
+```js example-bad
+//@ sourceMappingURL=http://exemple.com/chemin/vers/la/sourcemap.map
+```
 
-<h3 id="Syntaxe_standard">Syntaxe standard</h3>
+### Syntaxe standard
 
-<p>Il faut utiliser le dièse (#) :</p>
+Il faut utiliser le dièse (#) :
 
-<pre class="brush: js example-good">//# sourceMappingURL=http://exemple.com/chemin/vers/la/sourcemap.map</pre>
+```js example-good
+//# sourceMappingURL=http://exemple.com/chemin/vers/la/sourcemap.map
+```
 
-<p>Autrement, on peut indiquer la correspondance dans un en-tête {{HTTPHeader("SourceMap")}} pour servir le fichier JavaScript afin d'éviter tout commentaire :</p>
+Autrement, on peut indiquer la correspondance dans un en-tête {{HTTPHeader("SourceMap")}} pour servir le fichier JavaScript afin d'éviter tout commentaire :
 
-<pre class="brush: js example-good">X-SourceMap: /path/to/file.js.map</pre>
+```js example-good
+X-SourceMap: /path/to/file.js.map
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li><a href="/fr/docs/Outils/Débogueur/Comment/Utiliser_une_source_map">Comment utiliser les <em>source map</em> – Documentation des outils Firefox</a></li>
- <li><a href="http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/">Introduction to source maps – HTML5 rocks</a></li>
- <li>{{HTTPHeader("SourceMap")}}</li>
-</ul>
+- [Comment utiliser les _source map_ – Documentation des outils Firefox](/fr/docs/Outils/Débogueur/Comment/Utiliser_une_source_map)
+- [Introduction to source maps – HTML5 rocks](http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/)
+- {{HTTPHeader("SourceMap")}}
diff --git a/files/fr/web/javascript/reference/errors/deprecated_string_generics/index.md b/files/fr/web/javascript/reference/errors/deprecated_string_generics/index.md
index f348c0b4d8..fa9305c553 100644
--- a/files/fr/web/javascript/reference/errors/deprecated_string_generics/index.md
+++ b/files/fr/web/javascript/reference/errors/deprecated_string_generics/index.md
@@ -8,65 +8,66 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/Deprecated_String_generics
 original_slug: Web/JavaScript/Reference/Erreurs/Deprecated_String_generics
 ---
-<div>{{jsSidebar("Errors")}}</div>
-
-<div>Les méthodes génériques pour les chaînes de caractères ont été retirées à partir de Firefox 68.</div>
-
-<h2 id="Message">Message</h2>
-
-<pre class="syntaxbox">Warning: String.charAt            is deprecated; use String.prototype.charAt            instead
-Warning: String.charCodeAt        is deprecated; use String.prototype.charCodeAt        instead
-Warning: String.concat            is deprecated; use String.prototype.concat            instead
-Warning: String.contains          is deprecated; use String.prototype.contains          instead
-Warning: String.endsWith          is deprecated; use String.prototype.endsWith          instead
-Warning: String.includes          is deprecated; use String.prototype.includes          instead
-Warning: String.indexOf           is deprecated; use String.prototype.indexOf           instead
-Warning: String.lastIndexOf       is deprecated; use String.prototype.lastIndexOf       instead
-Warning: String.localeCompare     is deprecated; use String.prototype.localeCompare     instead
-Warning: String.match             is deprecated; use String.prototype.match             instead
-Warning: String.normalize         is deprecated; use String.prototype.normalize         instead
-Warning: String.replace           is deprecated; use String.prototype.replace           instead
-Warning: String.search            is deprecated; use String.prototype.search            instead
-Warning: String.slice             is deprecated; use String.prototype.slice             instead
-Warning: String.split             is deprecated; use String.prototype.split             instead
-Warning: String.startsWith        is deprecated; use String.prototype.startsWith        instead
-Warning: String.substr            is deprecated; use String.prototype.substr            instead
-Warning: String.substring         is deprecated; use String.prototype.substring         instead
-Warning: String.toLocaleLowerCase is deprecated; use String.prototype.toLocaleLowerCase instead
-Warning: String.toLocaleUpperCase is deprecated; use String.prototype.toLocaleUpperCase instead
-Warning: String.toLowerCase       is deprecated; use String.prototype.toLowerCase       instead
-Warning: String.toUpperCase       is deprecated; use String.prototype.toUpperCase       instead
-Warning: String.trim              is deprecated; use String.prototype.trim              instead
-Warning: String.trimLeft          is deprecated; use String.prototype.trimLeft          instead
-Warning: String.trimRight         is deprecated; use String.prototype.trimRight         instead
-</pre>
-
-<h2 id="Type_d'erreur">Type d'erreur</h2>
-
-<p>Un avertissement, l'exécution du script n'est pas interrompue.</p>
-
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
-
-<p>Les méthodes génériques non-standards de {{jsxref("String")}} sont dépréciées et ont été retirées à partir de Firefox 68 (il n'y a pas de prise en charge des navigateurs en dehors de Firefox). Les méthodes génériques sont des méthodes utilisées pour manipuler les instances de ce type d'objet et qui sont disponibles sur l'objet <code>String</code>, ce qui permet de les appliquer à n'importe quel objet.</p>
-
-<h2 id="Exemples">Exemples</h2>
-
-<h3 id="Syntaxe_dépréciée">Syntaxe dépréciée</h3>
-
-<pre class="brush: js example-bad">var num = 15;
-String.replace(num, /5/, '2');</pre>
-
-<h3 id="Syntaxe_standard">Syntaxe standard</h3>
-
-<pre class="brush: js example-good">var num = 15;
+{{jsSidebar("Errors")}}Les méthodes génériques pour les chaînes de caractères ont été retirées à partir de Firefox 68.
+
+## Message
+
+    Warning: String.charAt            is deprecated; use String.prototype.charAt            instead
+    Warning: String.charCodeAt        is deprecated; use String.prototype.charCodeAt        instead
+    Warning: String.concat            is deprecated; use String.prototype.concat            instead
+    Warning: String.contains          is deprecated; use String.prototype.contains          instead
+    Warning: String.endsWith          is deprecated; use String.prototype.endsWith          instead
+    Warning: String.includes          is deprecated; use String.prototype.includes          instead
+    Warning: String.indexOf           is deprecated; use String.prototype.indexOf           instead
+    Warning: String.lastIndexOf       is deprecated; use String.prototype.lastIndexOf       instead
+    Warning: String.localeCompare     is deprecated; use String.prototype.localeCompare     instead
+    Warning: String.match             is deprecated; use String.prototype.match             instead
+    Warning: String.normalize         is deprecated; use String.prototype.normalize         instead
+    Warning: String.replace           is deprecated; use String.prototype.replace           instead
+    Warning: String.search            is deprecated; use String.prototype.search            instead
+    Warning: String.slice             is deprecated; use String.prototype.slice             instead
+    Warning: String.split             is deprecated; use String.prototype.split             instead
+    Warning: String.startsWith        is deprecated; use String.prototype.startsWith        instead
+    Warning: String.substr            is deprecated; use String.prototype.substr            instead
+    Warning: String.substring         is deprecated; use String.prototype.substring         instead
+    Warning: String.toLocaleLowerCase is deprecated; use String.prototype.toLocaleLowerCase instead
+    Warning: String.toLocaleUpperCase is deprecated; use String.prototype.toLocaleUpperCase instead
+    Warning: String.toLowerCase       is deprecated; use String.prototype.toLowerCase       instead
+    Warning: String.toUpperCase       is deprecated; use String.prototype.toUpperCase       instead
+    Warning: String.trim              is deprecated; use String.prototype.trim              instead
+    Warning: String.trimLeft          is deprecated; use String.prototype.trimLeft          instead
+    Warning: String.trimRight         is deprecated; use String.prototype.trimRight         instead
+
+## Type d'erreur
+
+Un avertissement, l'exécution du script n'est pas interrompue.
+
+## Quel est le problème ?
+
+Les méthodes génériques non-standards de {{jsxref("String")}} sont dépréciées et ont été retirées à partir de Firefox 68 (il n'y a pas de prise en charge des navigateurs en dehors de Firefox). Les méthodes génériques sont des méthodes utilisées pour manipuler les instances de ce type d'objet et qui sont disponibles sur l'objet `String`, ce qui permet de les appliquer à n'importe quel objet.
+
+## Exemples
+
+### Syntaxe dépréciée
+
+```js example-bad
+var num = 15;
+String.replace(num, /5/, '2');
+```
+
+### Syntaxe standard
+
+```js example-good
+var num = 15;
 String(num).replace(/5/, '2');
-</pre>
+```
 
-<h2 id="Shim">Shim</h2>
+## Shim
 
-<p>Voici une méthode qui permet d'avoir les méthodes génériques au sein des navigateurs qui ne les prennent pas en charge :</p>
+Voici une méthode qui permet d'avoir les méthodes génériques au sein des navigateurs qui ne les prennent pas en charge :
 
-<pre class="brush: js">/*globals define*/
+```js
+/*globals define*/
 // Assumes all supplied String instance methods already present
 // (one may use shims for these if not available)
 (function() {
@@ -93,14 +94,13 @@ String(num).replace(/5/, '2');
       };
     };
 
-  for (i = 0; i &lt; methodCount; i++) {
+  for (i = 0; i < methodCount; i++) {
     assignStringGeneric(methods[i]);
   }
-}());</pre>
+}());
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("String")}}</li>
- <li><a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Array#Les_méthodes_génériques_de_manipulation_de_tableaux">Les méthodes génériques pour les tableaux</a> (également dépréciées).</li>
-</ul>
+- {{jsxref("String")}}
+- [Les méthodes génériques pour les tableaux](/fr/docs/Web/JavaScript/Reference/Objets_globaux/Array#Les_méthodes_génériques_de_manipulation_de_tableaux) (également dépréciées).
diff --git a/files/fr/web/javascript/reference/errors/deprecated_tolocaleformat/index.md b/files/fr/web/javascript/reference/errors/deprecated_tolocaleformat/index.md
index 444295566c..362fb57677 100644
--- a/files/fr/web/javascript/reference/errors/deprecated_tolocaleformat/index.md
+++ b/files/fr/web/javascript/reference/errors/deprecated_tolocaleformat/index.md
@@ -8,85 +8,89 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/Deprecated_toLocaleFormat
 original_slug: Web/JavaScript/Reference/Erreurs/Deprecated_toLocaleFormat
 ---
-<div>{{jsSidebar("Errors")}}</div>
+{{jsSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">Warning: Date.prototype.toLocaleFormat is deprecated; consider using Intl.DateTimeFormat instead
-</pre>
+    Warning: Date.prototype.toLocaleFormat is deprecated; consider using Intl.DateTimeFormat instead
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>Un avertissement, l'exécution du script JavaScript n'est pas interrompue.</p>
+Un avertissement, l'exécution du script JavaScript n'est pas interrompue.
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p>La méthode non-standard {{jsxref("Date.prototype.toLocaleFormat")}} est dépréciée et ne devrait plus être utilisée. Elle utilise une chaîne de caractères qui indique le format avec la même syntaxe que la fonction <code>strftime()</code> en C. Cette fonction n'est plus disponible à partir de Firefox 58.</p>
+La méthode non-standard {{jsxref("Date.prototype.toLocaleFormat")}} est dépréciée et ne devrait plus être utilisée. Elle utilise une chaîne de caractères qui indique le format avec la même syntaxe que la fonction `strftime()` en C. Cette fonction n'est plus disponible à partir de Firefox 58.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Syntaxe_dépréciée">Syntaxe dépréciée</h3>
+### Syntaxe dépréciée
 
-<p>La méthode {{jsxref("Date.prototype.toLocaleFormat")}} est dépréciée et sera retirée (aucune prise en charge par les autres navigateurs en dehors de Firefox).</p>
+La méthode {{jsxref("Date.prototype.toLocaleFormat")}} est dépréciée et sera retirée (aucune prise en charge par les autres navigateurs en dehors de Firefox).
 
-<pre class="brush: js example-bad">var today = new Date();
+```js example-bad
+var today = new Date();
 var date = today.toLocaleFormat('%A %e %B %Y');
 
 console.log(date);
 // En français
-// "Vendredi 10 mars 2017"</pre>
+// "Vendredi 10 mars 2017"
+```
 
-<h3 id="Utiliser_une_syntaxe_standard_grâce_à_l'API_ECMAScript_Intl">Utiliser une syntaxe standard grâce à l'API ECMAScript Intl</h3>
+### Utiliser une syntaxe standard grâce à l'API ECMAScript Intl
 
-<p>Le standard ECMA-402 (l'API ECMAScript Intl) définit des objets et méthodes standards qui permettent de mettre en forme des dates et heures (disponible à partir de Chrome 24, de Firefox 29, d'IE11 et de  Safari10).</p>
+Le standard ECMA-402 (l'API ECMAScript Intl) définit des objets et méthodes standards qui permettent de mettre en forme des dates et heures (disponible à partir de Chrome 24, de Firefox 29, d'IE11 et de  Safari10).
 
-<p>Si on souhaite uniquement formater une date, on pourra utiliser la méthode {{jsxref("Date.prototype.toLocaleDateString")}}.</p>
+Si on souhaite uniquement formater une date, on pourra utiliser la méthode {{jsxref("Date.prototype.toLocaleDateString")}}.
 
-<pre class="brush: js example-good">var today = new Date();
+```js example-good
+var today = new Date();
 var options = { weekday: 'long', year: 'numeric',
                 month: 'long', day: 'numeric' };
 var date = today.toLocaleDateString('fr-FR', options);
 
 console.log(date);
 // "Vendredi 10 mars 2017"
-</pre>
+```
 
-<p>Si on manipule plus de dates, on peut utiliser l'objet {{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}} qui permet de mettre en cache certains des calculs afin d'avoir une mise en forme rapide (ce qui s'avère utile lorsqu'on a une boucle par exemple) :</p>
+Si on manipule plus de dates, on peut utiliser l'objet {{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}} qui permet de mettre en cache certains des calculs afin d'avoir une mise en forme rapide (ce qui s'avère utile lorsqu'on a une boucle par exemple) :
 
-<pre class="brush: js example-good">var options = { weekday: 'long', year: 'numeric',
+```js example-good
+var options = { weekday: 'long', year: 'numeric',
                 month: 'long', day: 'numeric' };
 var dateFormatter = new Intl.DateTimeFormat('de-DE', options)
 
 var dates = [Date.UTC(2012, 11, 20, 3, 0, 0),
              Date.UTC(2014, 04, 12, 8, 0, 0)];
 
-dates.forEach(date =&gt; console.log(dateFormatter.format(date)));
+dates.forEach(date => console.log(dateFormatter.format(date)));
 
 // "Donnerstag, 20. Dezember 2012"
 // "Montag, 12. Mai 2014"
-</pre>
+```
 
-<h3 id="Utiliser_les_méthodes_de_l'objet_Date">Utiliser les méthodes de l'objet <code>Date</code></h3>
+### Utiliser les méthodes de l'objet `Date`
 
-<p>L'objet {{jsxref("Date")}} dispose de plusieurs méthodes qui permettent de construire une chaîne de caractères pour une date donnée. Ainsi</p>
+L'objet {{jsxref("Date")}} dispose de plusieurs méthodes qui permettent de construire une chaîne de caractères pour une date donnée. Ainsi
 
-<pre class="brush: js example-bad">(new Date()).toLocaleFormat("%Y%m%d");
+```js example-bad
+(new Date()).toLocaleFormat("%Y%m%d");
 // "20170310"
-</pre>
+```
 
-<p>Pourra être converti en :</p>
+Pourra être converti en :
 
-<pre class="brush: js example-good">let now = new Date();
+```js example-good
+let now = new Date();
 let date = now.getFullYear() * 10000 +
           (now.getMonth() + 1) * 100 + now.getDate();
 
 console.log(date);
-// "20170310"</pre>
+// "20170310"
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("Date.prototype.toLocaleFormat")}}</li>
- <li>{{jsxref("Date.prototype.toLocaleDateString")}}</li>
- <li>{{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}}</li>
-</ul>
+- {{jsxref("Date.prototype.toLocaleFormat")}}
+- {{jsxref("Date.prototype.toLocaleDateString")}}
+- {{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}}
diff --git a/files/fr/web/javascript/reference/errors/equal_as_assign/index.md b/files/fr/web/javascript/reference/errors/equal_as_assign/index.md
index 2e420be691..400fb4a797 100644
--- a/files/fr/web/javascript/reference/errors/equal_as_assign/index.md
+++ b/files/fr/web/javascript/reference/errors/equal_as_assign/index.md
@@ -8,47 +8,49 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/Equal_as_assign
 original_slug: Web/JavaScript/Reference/Erreurs/Equal_as_assign
 ---
-<div>{{jsSidebar("Errors")}}</div>
+{{jsSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">Warning: SyntaxError: test for equality (==) mistyped as assignment (=)?
-</pre>
+    Warning: SyntaxError: test for equality (==) mistyped as assignment (=)?
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>Uniquement pour Firefox. Un avertissement sous la forme d'une exception {{jsxref("SyntaxError")}}, généré uniquement si la préférence <code>javascript.options.strict</code> vaut <code>true</code>.</p>
+Uniquement pour Firefox. Un avertissement sous la forme d'une exception {{jsxref("SyntaxError")}}, généré uniquement si la préférence `javascript.options.strict` vaut `true`.
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p>Le code utilise une affectation (<code>=</code>) là où on attendrait un test d'égalité (<code>==</code>). Afin d'aider au débogage, le moteur JavaScript déclenche des avertissements lorsqu'il détecte ce motif.</p>
+Le code utilise une affectation (`=`) là où on attendrait un test d'égalité (`==`). Afin d'aider au débogage, le moteur JavaScript déclenche des avertissements lorsqu'il détecte ce motif.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Des_affectations_utilisées_au_sein_d'expressions_conditionnelles">Des affectations utilisées au sein d'expressions conditionnelles</h3>
+### Des affectations utilisées au sein d'expressions conditionnelles
 
-<p>Il est conseillé de ne pas utiliser d'affectations simples dans des expressions conditionnelles (comme le test effectué avec <code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/if...else">if...else</a></code>) car on peut confondre les deux à la lecture du code. Ainsi, on n'utilisera pas la forme suivante :</p>
+Il est conseillé de ne pas utiliser d'affectations simples dans des expressions conditionnelles (comme le test effectué avec [`if...else`](/fr/docs/Web/JavaScript/Reference/Instructions/if...else)) car on peut confondre les deux à la lecture du code. Ainsi, on n'utilisera pas la forme suivante :
 
-<pre class="brush: js example-bad">if (x = y) {
+```js example-bad
+if (x = y) {
   // do the right thing
 }
-</pre>
+```
 
-<p>Si on doit effectivement affecter une variable dans une expression conditionnelle, on entourera l'affectation d'une paire de parenthèses supplémentaires afin de montrer qu'on veut bien effectuer une affectation, comme ceci :</p>
+Si on doit effectivement affecter une variable dans une expression conditionnelle, on entourera l'affectation d'une paire de parenthèses supplémentaires afin de montrer qu'on veut bien effectuer une affectation, comme ceci :
 
-<pre class="brush: js">if ((x = y)) {
+```js
+if ((x = y)) {
   // exécuter le code
-}</pre>
+}
+```
 
-<p>Autrement (généralement), on veut plutôt utiliser un opérateur de comparaison (<code>==</code> ou <code>===</code> par exemple) :</p>
+Autrement (généralement), on veut plutôt utiliser un opérateur de comparaison (`==` ou `===` par exemple) :
 
-<pre class="brush: js">if (x == y) {
+```js
+if (x == y) {
   // exécuter le code
-}</pre>
+}
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li><code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/if...else">if...else</a></code></li>
- <li><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_comparaison">Les opérateurs de comparaison</a></li>
-</ul>
+- [`if...else`](/fr/docs/Web/JavaScript/Reference/Instructions/if...else)
+- [Les opérateurs de comparaison](/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_comparaison)
diff --git a/files/fr/web/javascript/reference/errors/for-each-in_loops_are_deprecated/index.md b/files/fr/web/javascript/reference/errors/for-each-in_loops_are_deprecated/index.md
index 26954d8e79..7d1e4dc118 100644
--- a/files/fr/web/javascript/reference/errors/for-each-in_loops_are_deprecated/index.md
+++ b/files/fr/web/javascript/reference/errors/for-each-in_loops_are_deprecated/index.md
@@ -7,95 +7,100 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/For-each-in_loops_are_deprecated
 original_slug: Web/JavaScript/Reference/Erreurs/For-each-in_loops_are_deprecated
 ---
-<div>{{jsSidebar("Errors")}}</div>
+{{jsSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">Warning: JavaScript 1.6's for-each-in loops are deprecated; consider using ES6 for-of instead
-</pre>
+    Warning: JavaScript 1.6's for-each-in loops are deprecated; consider using ES6 for-of instead
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>Avertissement.</p>
+Avertissement.
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p>L'instruction {{jsxref("Instructions/for_each...in", "for each (variable in obj)")}} présente à partir de JavaScript 1.6 est une instruction dépréciée et est amenée à disparaître dans un avenir proche.</p>
+L'instruction {{jsxref("Instructions/for_each...in", "for each (variable in obj)")}} présente à partir de JavaScript 1.6 est une instruction dépréciée et est amenée à disparaître dans un avenir proche.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Itérer_sur_un_objet">Itérer sur un objet</h3>
+### Itérer sur un objet
 
-<p>{{jsxref("Instructions/for_each...in", "for each...in")}} pouvait être utilisé pour parcourir les valeurs contenues dans un objet.</p>
+{{jsxref("Instructions/for_each...in", "for each...in")}} pouvait être utilisé pour parcourir les valeurs contenues dans un objet.
 
-<h4 id="Syntaxe_dépréciée">Syntaxe dépréciée</h4>
+#### Syntaxe dépréciée
 
-<pre class="brush: js example-bad">var objet = { a: 10, b: 20 };
+```js example-bad
+var objet = { a: 10, b: 20 };
 
 for each (var x in objet) {
   console.log(x);        // 10
                          // 20
 }
-</pre>
+```
 
-<h4 id="Syntaxe_alternative_standard">Syntaxe alternative, standard</h4>
+#### Syntaxe alternative, standard
 
-<p>On peut désormais utilisé l'instruction de boucle standard {{jsxref("Instructions/for...in", "for...in")}} afin d'itérer sur les clés d'un objet et de récupérer les valeurs des propriétés :</p>
+On peut désormais utilisé l'instruction de boucle standard {{jsxref("Instructions/for...in", "for...in")}} afin d'itérer sur les clés d'un objet et de récupérer les valeurs des propriétés :
 
-<pre class="brush: js example-good">var objet = { a: 10, b: 20 };
+```js example-good
+var objet = { a: 10, b: 20 };
 
 for (var key in objet) {
   var x = objet[key];
   console.log(x);        // 10
                          // 20
 }
-</pre>
+```
 
-<p>Ou alors, on peut utiliser {{jsxref("Instructions/for...of", "for...of")}} (ES2015) et {{jsxref("Object.values")}} (ES2017) afin d'obtenir un tableau des valeurs associées à un objet pour ensuite le parcourir :</p>
+Ou alors, on peut utiliser {{jsxref("Instructions/for...of", "for...of")}} (ES2015) et {{jsxref("Object.values")}} (ES2017) afin d'obtenir un tableau des valeurs associées à un objet pour ensuite le parcourir :
 
-<pre class="brush: js example-good">var objet = { a: 10, b: 20 };
+```js example-good
+var objet = { a: 10, b: 20 };
 
 for (var x of Object.values(objet)) {
   console.log(x);        // 10
                          // 20
 }
-</pre>
+```
 
-<h3 id="Itérer_sur_un_tableau">Itérer sur un tableau</h3>
+### Itérer sur un tableau
 
-<p>{{jsxref("Instructions/for_each...in", "for each...in")}} pouvait être utilisée afin de parcourir les éléments d'un tableau.</p>
+{{jsxref("Instructions/for_each...in", "for each...in")}} pouvait être utilisée afin de parcourir les éléments d'un tableau.
 
-<h4 id="Syntaxe_dépréciée_2">Syntaxe dépréciée</h4>
+#### Syntaxe dépréciée
 
-<pre class="brush: js example-bad">var array = [10, 20, 30];
+```js example-bad
+var array = [10, 20, 30];
 
 for each (var x in array) {
   console.log(x);        // 10
                          // 20
                          // 30
 }
-</pre>
+```
 
-<h4 id="Syntaxe_alternative_standard_2">Syntaxe alternative, standard</h4>
+#### Syntaxe alternative, standard
 
-<p>On peut obtenir le même effet avec les boucles {{jsxref("Instructions/for...of", "for...of")}} (ES2015).</p>
+On peut obtenir le même effet avec les boucles {{jsxref("Instructions/for...of", "for...of")}} (ES2015).
 
-<pre class="brush: js example-good">var array = [10, 20, 30];
+```js example-good
+var array = [10, 20, 30];
 
 for (var x of array) {
   console.log(x);        // 10
                          // 20
                          // 30
 }
-</pre>
+```
 
-<h3 id="Parcourir_un_tableau_qui_vaille_null_ou_undefined">Parcourir un tableau qui vaille <code>null</code> ou <code>undefined</code></h3>
+### Parcourir un tableau qui vaille `null` ou `undefined`
 
-<p>{{jsxref("Instructions/for_each...in", "for each...in")}} ne fera rien si la valeur fournie est <code>null</code> ou <code>undefined</code>. En revanche, {{jsxref("Instructions/for...of", "for...of")}} lèvera une exception dans ces cas.</p>
+{{jsxref("Instructions/for_each...in", "for each...in")}} ne fera rien si la valeur fournie est `null` ou `undefined`. En revanche, {{jsxref("Instructions/for...of", "for...of")}} lèvera une exception dans ces cas.
 
-<h4 id="Syntaxe_dépréciée_3">Syntaxe dépréciée</h4>
+#### Syntaxe dépréciée
 
-<pre class="brush: js example-bad">function func(array) {
+```js example-bad
+function func(array) {
   for each (var x in array) {
     console.log(x);
   }
@@ -104,13 +109,14 @@ func([10, 20]);        // 10
                        // 20
 func(null);            // rien ne s'affiche
 func(undefined);       // rien ne s'affiche
-</pre>
+```
 
-<h4 id="Syntaxe_alternative_standard_3">Syntaxe alternative, standard</h4>
+#### Syntaxe alternative, standard
 
-<p>Pour réécrire les instructions {{jsxref("Instructions/for_each...in", "for each...in")}} afin que les valeurs <code>null</code> ou <code>undefined</code> puissent être gérées avec {{jsxref("Instructions/for...of", "for...of")}}, il faudra rajouter une protection :</p>
+Pour réécrire les instructions {{jsxref("Instructions/for_each...in", "for each...in")}} afin que les valeurs `null` ou `undefined` puissent être gérées avec {{jsxref("Instructions/for...of", "for...of")}}, il faudra rajouter une protection :
 
-<pre class="brush: js example-good">function func(array) {
+```js example-good
+function func(array) {
   if (array) {
     for (var x of array) {
       console.log(x);
@@ -121,49 +127,50 @@ func([10, 20]);        // 10
                        // 20
 func(null);            // rien ne s'affiche
 func(undefined);       // rien ne s'affiche
-</pre>
+```
 
-<h3 id="Itérer_sur_les_tuples_clé-valeur_d'un_objet">Itérer sur les tuples clé-valeur d'un objet</h3>
+### Itérer sur les tuples clé-valeur d'un objet
 
-<h4 id="Syntaxe_dépréciée_4">Syntaxe dépréciée</h4>
+#### Syntaxe dépréciée
 
-<p>On pouvait utiliser une forme syntaxique particulière, désormais dépréciée, qui combine {{jsxref("Instructions/for_each...in", "for each...in")}} et l'objet déprécié {{jsxref("Iterator")}}.</p>
+On pouvait utiliser une forme syntaxique particulière, désormais dépréciée, qui combine {{jsxref("Instructions/for_each...in", "for each...in")}} et l'objet déprécié {{jsxref("Iterator")}}.
 
-<pre class="brush: js example-bad">var object = { a: 10, b: 20 };
+```js example-bad
+var object = { a: 10, b: 20 };
 
 for each (var [key, value] in Iterator(object)) {
   console.log(key, value);  // "a", 10
                             // "b", 20
 }
-</pre>
+```
 
-<h4 id="Syntaxe_alternative_standard_4">Syntaxe alternative, standard</h4>
+#### Syntaxe alternative, standard
 
-<p>On peut désormais utiliser la boucle {{jsxref("Instructions/for...in", "for...in")}} afin de parcourir les différentes clés d'un objet pour ensuite récupérer les valeurs associées :</p>
+On peut désormais utiliser la boucle {{jsxref("Instructions/for...in", "for...in")}} afin de parcourir les différentes clés d'un objet pour ensuite récupérer les valeurs associées :
 
-<pre class="brush: js example-good">var object = { a: 10, b: 20 };
+```js example-good
+var object = { a: 10, b: 20 };
 
 for (var key in object) {
   var value = object[key];
   console.log(key, value);  // "a", 10
                             // "b", 20
 }
-</pre>
+```
 
-<p>Ou encore, on peut utiliser {{jsxref("Instructions/for...of", "for...of")}} (ES2015) et {{jsxref("Object.entries")}} (ES2017) pour récupérer un tableau contenant les clés et les valeurs d'un objet qu'on pourra ensuite parcourir :</p>
+Ou encore, on peut utiliser {{jsxref("Instructions/for...of", "for...of")}} (ES2015) et {{jsxref("Object.entries")}} (ES2017) pour récupérer un tableau contenant les clés et les valeurs d'un objet qu'on pourra ensuite parcourir :
 
-<pre class="brush: js example-good">var object = { a: 10, b: 20 };
+```js example-good
+var object = { a: 10, b: 20 };
 
 for (var [key, value] of Object.entries(object)) {
   console.log(key, value);  // "a", 10
                             // "b", 20
 }
-</pre>
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("Instructions/for...of", "for...of")}}</li>
- <li>{{jsxref("Object.values")}}</li>
- <li>{{jsxref("Object.entries")}}</li>
-</ul>
+- {{jsxref("Instructions/for...of", "for...of")}}
+- {{jsxref("Object.values")}}
+- {{jsxref("Object.entries")}}
diff --git a/files/fr/web/javascript/reference/errors/getter_only/index.md b/files/fr/web/javascript/reference/errors/getter_only/index.md
index 01fd2c0e14..d308e5b583 100644
--- a/files/fr/web/javascript/reference/errors/getter_only/index.md
+++ b/files/fr/web/javascript/reference/errors/getter_only/index.md
@@ -9,28 +9,28 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/Getter_only
 original_slug: Web/JavaScript/Reference/Erreurs/Getter_only
 ---
-<div>{{jsSidebar("Errors")}}</div>
+{{jsSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">TypeError: Assignment to read-only properties is not allowed in strict mode (Edge)
-TypeError: setting getter-only property "x" (Firefox)
-TypeError: Cannot set property "prop" of #&lt;Object&gt; which has only a getter (Chrome)
-</pre>
+    TypeError: Assignment to read-only properties is not allowed in strict mode (Edge)
+    TypeError: setting getter-only property "x" (Firefox)
+    TypeError: Cannot set property "prop" of #<Object> which has only a getter (Chrome)
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>{{jsxref("TypeError")}}, uniquement en <a href="/en-US/docs/Web/JavaScript/Reference/Strict_mode">mode strict</a>.</p>
+{{jsxref("TypeError")}}, uniquement en [mode strict](/en-US/docs/Web/JavaScript/Reference/Strict_mode).
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p>On essaie de fournir une nouvelle valeur pour une propriété qui ne dispose que d'un <a href="/fr/docs/Web/JavaScript/Reference/Fonctions/get">accesseur</a>. Ceci échouera en mode non-strict mais lèvera une exception {{jsxref("TypeError")}} en <a href="/fr/docs/Web/JavaScript/Reference/Strict_mode">mode strict</a>.</p>
+On essaie de fournir une nouvelle valeur pour une propriété qui ne dispose que d'un [accesseur](/fr/docs/Web/JavaScript/Reference/Fonctions/get). Ceci échouera en mode non-strict mais lèvera une exception {{jsxref("TypeError")}} en [mode strict](/fr/docs/Web/JavaScript/Reference/Strict_mode).
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<p>Dans l'exemple qui suit, on voit comment créer un accesseur sur une propriété. En revanche, dans la définition de l'objet, on n'inclut aucun <a href="/fr/docs/Web/JavaScript/Reference/Fonctions/set">mutateur</a> et une exception <code>TypeError</code> sera déclenchée lorsqu'on voudra modifier la propriété <code>temperature</code> pour la passer à <code>30</code>. Pour plus de détails, on pourra consulter la page {{jsxref("Object.defineProperty()")}}.</p>
+Dans l'exemple qui suit, on voit comment créer un accesseur sur une propriété. En revanche, dans la définition de l'objet, on n'inclut aucun [mutateur](/fr/docs/Web/JavaScript/Reference/Fonctions/set) et une exception `TypeError` sera déclenchée lorsqu'on voudra modifier la propriété `temperature` pour la passer à `30`. Pour plus de détails, on pourra consulter la page {{jsxref("Object.defineProperty()")}}.
 
-<pre class="brush: js example-bad">"use strict";
+```js example-bad
+"use strict";
 
 function Archiver() {
   var temperature = null;
@@ -47,11 +47,12 @@ arc.temperature; // 'get!'
 
 arc.temperature = 30;
 // TypeError: setting a property that has only a getter
-</pre>
+```
 
-<p>Pour corriger cette erreur, soit on retire la ligne 16 (où on tente de modifier la propriété) soit on implémente un mutateur, comme ceci :</p>
+Pour corriger cette erreur, soit on retire la ligne 16 (où on tente de modifier la propriété) soit on implémente un mutateur, comme ceci :
 
-<pre class="brush: js example-good highlight[12]">"use strict";
+```js example-good
+"use strict";
 
 function Archiver() {
   var temperature = null;
@@ -75,11 +76,10 @@ var arc = new Archiver();
 arc.temperature; // 'get!'
 arc.temperature = 11;
 arc.temperature = 13;
-arc.getArchive(); // [{ val: 11 }, { val: 13 }]</pre>
+arc.getArchive(); // [{ val: 11 }, { val: 13 }]
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("Object.defineProperty()")}}</li>
- <li>{{jsxref("Object.defineProperties()")}}</li>
-</ul>
+- {{jsxref("Object.defineProperty()")}}
+- {{jsxref("Object.defineProperties()")}}
diff --git a/files/fr/web/javascript/reference/errors/identifier_after_number/index.md b/files/fr/web/javascript/reference/errors/identifier_after_number/index.md
index 1401b41432..b2ca711e5a 100644
--- a/files/fr/web/javascript/reference/errors/identifier_after_number/index.md
+++ b/files/fr/web/javascript/reference/errors/identifier_after_number/index.md
@@ -8,32 +8,32 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/Identifier_after_number
 original_slug: Web/JavaScript/Reference/Erreurs/Identifier_after_number
 ---
-<div>{{JSSidebar("Errors")}}</div>
+{{JSSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">SyntaxError: Unexpected identifier after numeric literal (Edge)
-SyntaxError: identifier starts immediately after numeric literal (Firefox)
-SyntaxError: Unexpected number (Chrome)
-</pre>
+    SyntaxError: Unexpected identifier after numeric literal (Edge)
+    SyntaxError: identifier starts immediately after numeric literal (Firefox)
+    SyntaxError: Unexpected number (Chrome)
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>{{jsxref("SyntaxError")}}</p>
+{{jsxref("SyntaxError")}}
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p>Les noms qu'on donne aux variables (aussi appelés « identifiants ») doivent respecter certaines règles…</p>
+Les noms qu'on donne aux variables (aussi appelés « identifiants ») doivent respecter certaines règles…
 
-<p>En JavaScript, un identifiant doit commencer par une lettre, un tiret bas (_) ou un dollar ($), il ne peut pas commencer par un chiffre. Seuls les caractères après le premier peuvent être des chiffres.</p>
+En JavaScript, un identifiant doit commencer par une lettre, un tiret bas (\_) ou un dollar ($), il ne peut pas commencer par un chiffre. Seuls les caractères après le premier peuvent être des chiffres.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Des_variables_dont_le_nom_commence_par_un_chiffre">Des variables dont le nom commence par un chiffre</h3>
+### Des variables dont le nom commence par un chiffre
 
-<p>En JavaScript, les noms des variables ne peuvent pas commencer par un chiffre. Aussi, le script suivant provoquera des erreurs :</p>
+En JavaScript, les noms des variables ne peuvent pas commencer par un chiffre. Aussi, le script suivant provoquera des erreurs :
 
-<pre class="brush: js example-bad">var 1vie = 'toto';
+```js example-bad
+var 1vie = 'toto';
 // SyntaxError: identifier starts immediately after numeric literal
 
 var toto = 1vie;
@@ -41,17 +41,16 @@ var toto = 1vie;
 
 alert(1.toto);
 // SyntaxError: identifier starts immediately after numeric literal
-</pre>
+```
 
-<p>Pour éviter ce problème, il faudra renommer les variables afin d'éviter d'utiliser un chiffre au début :</p>
+Pour éviter ce problème, il faudra renommer les variables afin d'éviter d'utiliser un chiffre au début :
 
-<pre class="brush: js example-good">var vie1 = 'toto';
+```js example-good
+var vie1 = 'toto';
 var toto = vie1;
-</pre>
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li><a href="/fr/docs/Web/JavaScript/Reference/Grammaire_lexicale">La grammaire lexicale de JavaScript</a></li>
- <li><a href="/fr/docs/Web/JavaScript/Guide/Types_et_grammaire#Variables">Les variables</a> dans le <a href="/fr/docs/Web/JavaScript/Guide">Guide JavaScript</a></li>
-</ul>
+- [La grammaire lexicale de JavaScript](/fr/docs/Web/JavaScript/Reference/Grammaire_lexicale)
+- [Les variables](/fr/docs/Web/JavaScript/Guide/Types_et_grammaire#Variables) dans le [Guide JavaScript](/fr/docs/Web/JavaScript/Guide)
diff --git a/files/fr/web/javascript/reference/errors/illegal_character/index.md b/files/fr/web/javascript/reference/errors/illegal_character/index.md
index 9c886718f5..d1da414713 100644
--- a/files/fr/web/javascript/reference/errors/illegal_character/index.md
+++ b/files/fr/web/javascript/reference/errors/illegal_character/index.md
@@ -8,30 +8,30 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/Illegal_character
 original_slug: Web/JavaScript/Reference/Erreurs/Illegal_character
 ---
-<div>{{jsSidebar("Errors")}}</div>
+{{jsSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">SyntaxError: Invalid character (Edge)
-SyntaxError: illegal character (Firefox)
-SyntaxError: Invalid or unexpected token (Chrome)
-</pre>
+    SyntaxError: Invalid character (Edge)
+    SyntaxError: illegal character (Firefox)
+    SyntaxError: Invalid or unexpected token (Chrome)
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>{{jsxref("SyntaxError")}}</p>
+{{jsxref("SyntaxError")}}
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p>Dans le code, il y a un élément de la syntaxe qui n'est pas à la bonne place. Pour détecter les erreurs de ce type, vous pouvez utiliser un éditeur de texte qui prend en charge la coloration syntaxique et qui met en évidence les caractères problématiques (par exemple si on a utilisé un tiret (<code> – </code>) au lieu d'un moins ( - ) ou des guillemets anglais (<code> “ </code>) à la place de doubles quotes ( " ).</p>
+Dans le code, il y a un élément de la syntaxe qui n'est pas à la bonne place. Pour détecter les erreurs de ce type, vous pouvez utiliser un éditeur de texte qui prend en charge la coloration syntaxique et qui met en évidence les caractères problématiques (par exemple si on a utilisé un tiret (` – `) au lieu d'un moins ( - ) ou des guillemets anglais (` “ `) à la place de doubles quotes ( " ).
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Caractères_ressemblants">Caractères ressemblants</h3>
+### Caractères ressemblants
 
-<p>Certains caractères ressemblent à des caractères spéciaux en JavaScript mais n'en sont pas. Dans ce cas, lorsque le moteur analysera le code, il échouera.</p>
+Certains caractères ressemblent à des caractères spéciaux en JavaScript mais n'en sont pas. Dans ce cas, lorsque le moteur analysera le code, il échouera.
 
-<pre class="brush: js example-bad">“Ceci ressemble à une chaîne de caractères.”;
+```js example-bad
+“Ceci ressemble à une chaîne de caractères.”;
 // “ n'est pas le caractère "
 // SyntaxError: illegal character
 
@@ -40,45 +40,50 @@ SyntaxError: Invalid or unexpected token (Chrome)
 // SyntaxError: illegal character
 
 var toto = "truc";
-// ; (&lt;37e&gt;) n'est pas le caractère ;
+// ; (<37e>) n'est pas le caractère ;
 // SyntaxError: illegal character
-</pre>
+```
 
-<p>On peut corriger ce point en utilisant les bons caractères :</p>
+On peut corriger ce point en utilisant les bons caractères :
 
-<pre class="brush: js example-good">"Ceci est vraiment une chaîne de caractères.";
+```js example-good
+"Ceci est vraiment une chaîne de caractères.";
 42 - 13;
 var toto = "truc";
-</pre>
+```
 
-<p>Certains éditeurs et environnements de développement intégrés indiqueront la présence de tels caractères avec une coloration syntaxique différente. Toutefois, tous les éditeurs n'ont pas une telle fonctionnalité et si vous n'arrivez pas à déterminer l'origine du problème, il vaudra sans doute mieux supprimer la ligne incriminée et la resaisir manuellement.</p>
+Certains éditeurs et environnements de développement intégrés indiqueront la présence de tels caractères avec une coloration syntaxique différente. Toutefois, tous les éditeurs n'ont pas une telle fonctionnalité et si vous n'arrivez pas à déterminer l'origine du problème, il vaudra sans doute mieux supprimer la ligne incriminée et la resaisir manuellement.
 
-<h3 id="Caractères_oubliés">Caractères oubliés</h3>
+### Caractères oubliés
 
-<p>On oublie parfois un caractère.</p>
+On oublie parfois un caractère.
 
-<pre class="brush: js example-bad">var couleurs = ['#000', #333', '#666'];
+```js example-bad
+var couleurs = ['#000', #333', '#666'];
 // SyntaxError: illegal character
-</pre>
+```
 
-<p>Dans ce cas, il suffit de rajouter la quote pour <code>'#333'</code>.</p>
+Dans ce cas, il suffit de rajouter la quote pour `'#333'`.
 
-<pre class="brush: js example-good">var couleurs = ['#000', '#333', '#666'];</pre>
+```js example-good
+var couleurs = ['#000', '#333', '#666'];
+```
 
-<h3 id="Caractères_cachés">Caractères cachés</h3>
+### Caractères cachés
 
-<p>Lorsque vous copiez/collez du code depuis des sources externes, celles-ci peuvent contenir des caractères invalides difficiles à discerner.</p>
+Lorsque vous copiez/collez du code depuis des sources externes, celles-ci peuvent contenir des caractères invalides difficiles à discerner.
 
-<pre class="brush: js example-bad">var toto = 'truc';​
+```js example-bad
+var toto = 'truc';​
 // SyntaxError: illegal character
-</pre>
+```
 
-<p>Lorsqu'on inspecte ce code grâce à un éditeur de texte (par exemple Vim), on peut voir qu'il y en fait un <a href="https://fr.wikipedia.org/wiki/Espace_sans_chasse">espace sans chasse (ZWSP) (U+200B)</a>.</p>
+Lorsqu'on inspecte ce code grâce à un éditeur de texte (par exemple Vim), on peut voir qu'il y en fait un [espace sans chasse (ZWSP) (U+200B)](https://fr.wikipedia.org/wiki/Espace_sans_chasse).
 
-<pre class="brush: js">var toto = 'truc';​&lt;200b&gt;</pre>
+```js
+var toto = 'truc';​<200b>
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li><a href="/fr/docs/Web/JavaScript/Reference/Grammaire_lexicale">La grammaire lexicale de JavaScript</a></li>
-</ul>
+- [La grammaire lexicale de JavaScript](/fr/docs/Web/JavaScript/Reference/Grammaire_lexicale)
diff --git a/files/fr/web/javascript/reference/errors/in_operator_no_object/index.md b/files/fr/web/javascript/reference/errors/in_operator_no_object/index.md
index 104971982d..4a07499692 100644
--- a/files/fr/web/javascript/reference/errors/in_operator_no_object/index.md
+++ b/files/fr/web/javascript/reference/errors/in_operator_no_object/index.md
@@ -8,67 +8,71 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/in_operator_no_object
 original_slug: Web/JavaScript/Reference/Erreurs/in_operator_no_object
 ---
-<div>{{jsSidebar("Errors")}}</div>
+{{jsSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">TypeError: Invalid operand to 'in' (Edge)
-TypeError: right-hand side of 'in' should be an object, got 'x' (Firefox)
-TypeError: cannot use 'in' operator to search for 'x' in 'y' (Firefox, Chrome)
-</pre>
+    TypeError: Invalid operand to 'in' (Edge)
+    TypeError: right-hand side of 'in' should be an object, got 'x' (Firefox)
+    TypeError: cannot use 'in' operator to search for 'x' in 'y' (Firefox, Chrome)
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>{{jsxref("TypeError")}}</p>
+{{jsxref("TypeError")}}
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p>L'<a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_in">opérateur <code>in</code></a> peut uniquement être utilisé pour vérifier qu'une propriété appartient à un objet. Il ne peut pas être utilisé pour rechercher des caractères dans des chaînes de caractères, des nombres ou dans d'autres types de données en dehors des objets.</p>
+L'[opérateur `in`](/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_in) peut uniquement être utilisé pour vérifier qu'une propriété appartient à un objet. Il ne peut pas être utilisé pour rechercher des caractères dans des chaînes de caractères, des nombres ou dans d'autres types de données en dehors des objets.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Rechercher_un_texte_dans_une_chaîne_de_caractères">Rechercher un texte dans une chaîne de caractères</h3>
+### Rechercher un texte dans une chaîne de caractères
 
-<p>À la différence de certains langages de programmation (Python par exemple), JavaScript ne permet pas de chercher des textes dans une chaîne de caractères grâce à l'opérateur <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_in"><code>in</code></a>.</p>
+À la différence de certains langages de programmation (Python par exemple), JavaScript ne permet pas de chercher des textes dans une chaîne de caractères grâce à l'opérateur [`in`](/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_in).
 
-<pre class="brush: js example-bad">"Coucou" in "Coucou monde";
+```js example-bad
+"Coucou" in "Coucou monde";
 // TypeError: cannot use 'in' operator to search for 'Coucou' in 'Coucou monde'
-</pre>
+```
 
-<p>On utilisera plutôt la méthode {{jsxref("String.prototype.indexOf()")}} :</p>
+On utilisera plutôt la méthode {{jsxref("String.prototype.indexOf()")}} :
 
-<pre class="brush: js example-good">"Coucou monde".indexOf("Coucou") !== -1;
-// true</pre>
+```js example-good
+"Coucou monde".indexOf("Coucou") !== -1;
+// true
+```
 
-<h3 id="null_ou_undefined_ne_fonctionnent_pas"><code>null</code> ou <code>undefined</code> ne fonctionnent pas</h3>
+### `null` ou `undefined` ne fonctionnent pas
 
-<p>Avant d'utiliser <code>in</code>, il faut s'assurer que la valeur qu'on inspecte n'est pas {{jsxref("null")}} ou {{jsxref("undefined")}}.</p>
+Avant d'utiliser `in`, il faut s'assurer que la valeur qu'on inspecte n'est pas {{jsxref("null")}} ou {{jsxref("undefined")}}.
 
-<pre class="brush: js example-bad">var toto = null;
+```js example-bad
+var toto = null;
 "truc" in toto;
 // TypeError: cannot use 'in' operator to search for 'truc' in 'toto" (Chrome)
 // TypeError: right-hand side of 'in' should be an object, got null (Firefox)
-</pre>
+```
 
-<p>L'opérateur <code>in</code> doit être utilisé avec un objet.</p>
+L'opérateur `in` doit être utilisé avec un objet.
 
-<pre class="brush: js example-good">var toto = { machin: "bidule" };
+```js example-good
+var toto = { machin: "bidule" };
 "truc" in toto; // false
 
 "PI" in Math; // true
 "pi" in Math; // false
-</pre>
+```
 
-<h3 id="Rechercher_dans_un_tableau">Rechercher dans un tableau</h3>
+### Rechercher dans un tableau
 
-<p>Attention lorsqu'on utilise l'opérateur <code>in</code> quand on recherche une valeur dans un objet {{jsxref("Array")}}. L'opérateur <code>in</code> vérifie la présence de l'index mais pas la valeur présente à cet index.</p>
+Attention lorsqu'on utilise l'opérateur `in` quand on recherche une valeur dans un objet {{jsxref("Array")}}. L'opérateur `in` vérifie la présence de l'index mais pas la valeur présente à cet index.
 
-<pre class="brush: js">var arbres = ['cèdre', 'bouleau', 'pin', 'sapin', 'érable'];
+```js
+var arbres = ['cèdre', 'bouleau', 'pin', 'sapin', 'érable'];
 3 in arbres; // true
-"pin" in arbres; // false</pre>
+"pin" in arbres; // false
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_in">L'opérateur <code>in</code></a></li>
-</ul>
+- [L'opérateur `in`](/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_in)
diff --git a/files/fr/web/javascript/reference/errors/index.md b/files/fr/web/javascript/reference/errors/index.md
index 7110b7682a..aeaeeb5519 100644
--- a/files/fr/web/javascript/reference/errors/index.md
+++ b/files/fr/web/javascript/reference/errors/index.md
@@ -6,19 +6,17 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors
 original_slug: Web/JavaScript/Reference/Erreurs
 ---
-<p>{{jsSidebar("Errors")}}</p>
+{{jsSidebar("Errors")}}
 
-<p><em>Errare ECMAScript est</em>…<br>
- Vous trouverez ci-après une liste d'erreurs causées par le moteur JavaScript. Ces erreurs peuvent aider à déboguer certains problèmes mais leur signification n'est pas toujours claire. Chacune de ces pages fournit donc des explications et informations supplémentaires à propos de ces erreurs.</p>
+_Errare ECMAScript est_…
+Vous trouverez ci-après une liste d'erreurs causées par le moteur JavaScript. Ces erreurs peuvent aider à déboguer certains problèmes mais leur signification n'est pas toujours claire. Chacune de ces pages fournit donc des explications et informations supplémentaires à propos de ces erreurs.
 
-<p>D'un point de vue technique, chaque erreur est un objet {{jsxref("Error")}} et possède une propriété <code>name</code> (son nom) et une propriété <code>message</code>.</p>
+D'un point de vue technique, chaque erreur est un objet {{jsxref("Error")}} et possède une propriété `name` (son nom) et une propriété `message`.
 
-<h2 id="Liste_d'erreurs">Liste d'erreurs</h2>
+## Liste d'erreurs
 
-<p>{{ListSubPages("/fr/docs/Web/JavaScript/Reference/Erreurs")}}</p>
+{{ListSubPages("/fr/docs/Web/JavaScript/Reference/Erreurs")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li><a href="/fr/docs/Learn/JavaScript/First_steps/What_went_wrong">Qu'est-ce qui a cloché ? Diagnostiquer un problème JavaScript</a> : un tutoriel introductif pour réparer les erreurs JavaScript</li>
-</ul>
+- [Qu'est-ce qui a cloché ? Diagnostiquer un problème JavaScript](/fr/docs/Learn/JavaScript/First_steps/What_went_wrong) : un tutoriel introductif pour réparer les erreurs JavaScript
diff --git a/files/fr/web/javascript/reference/errors/invalid_array_length/index.md b/files/fr/web/javascript/reference/errors/invalid_array_length/index.md
index aa5fd0d701..b8db76535a 100644
--- a/files/fr/web/javascript/reference/errors/invalid_array_length/index.md
+++ b/files/fr/web/javascript/reference/errors/invalid_array_length/index.md
@@ -8,40 +8,38 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/Invalid_array_length
 original_slug: Web/JavaScript/Reference/Erreurs/Invalid_array_length
 ---
-<div>{{jsSidebar("Erreurs")}}</div>
+{{jsSidebar("Erreurs")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">RangeError: Array length must be a finite positive integer (Edge)
-RangeError: invalid array length (Firefox)
-RangeError: Invalid array length (Chrome)
-RangeError: Invalid array buffer length (Chrome)
-</pre>
+    RangeError: Array length must be a finite positive integer (Edge)
+    RangeError: invalid array length (Firefox)
+    RangeError: Invalid array length (Chrome)
+    RangeError: Invalid array buffer length (Chrome)
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>{{jsxref("RangeError")}}</p>
+{{jsxref("RangeError")}}
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p>Deux cas de figures peuvent causer cette erreur :</p>
+Deux cas de figures peuvent causer cette erreur :
 
-<ul>
- <li>La création d'un tableau {{jsxref("Array")}} ou {{jsxref("ArrayBuffer")}} dont la longueur est négative ou supérieure ou égale à 2^32</li>
- <li>La modification de la propriété {{jsxref("Array.length")}} pour que celle-ci ait une valeur négative ou supérieure ou égale à 2^32.</li>
-</ul>
+- La création d'un tableau {{jsxref("Array")}} ou {{jsxref("ArrayBuffer")}} dont la longueur est négative ou supérieure ou égale à 2^32
+- La modification de la propriété {{jsxref("Array.length")}} pour que celle-ci ait une valeur négative ou supérieure ou égale à 2^32.
 
-<p>Les tailles des objets <code>Array</code> et <code>ArrayBuffer</code> sont limitées car leurs longueurs (<code>length</code>) sont représentées par des entiers non-signés sur 32 bits. Ces valeurs sont donc nécessairement comprises dans l'intervalle allant de 0 à 2^32-1.</p>
+Les tailles des objets `Array` et `ArrayBuffer` sont limitées car leurs longueurs (`length`) sont représentées par des entiers non-signés sur 32 bits. Ces valeurs sont donc nécessairement comprises dans l'intervalle allant de 0 à 2^32-1.
 
-<p>Si vous utilisez le constructeur pour <code>Array</code>, il est probable que vous souhaitiez utiliser la notation littérale plutôt que le constructeur. En effet, le premier argument de ce constructeur correspond à la longueur du tableau.</p>
+Si vous utilisez le constructeur pour `Array`, il est probable que vous souhaitiez utiliser la notation littérale plutôt que le constructeur. En effet, le premier argument de ce constructeur correspond à la longueur du tableau.
 
-<p>Sinon, vous pouvez réduire la longueur utilisée afin que celle-ci soit dans l'intervalle valide avant de l'utiliser pour une telle création ou modification.</p>
+Sinon, vous pouvez réduire la longueur utilisée afin que celle-ci soit dans l'intervalle valide avant de l'utiliser pour une telle création ou modification.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Exemples_invalides">Exemples invalides</h3>
+### Exemples invalides
 
-<pre class="brush: js example-bad">new Array(Math.pow(2, 40))
+```js example-bad
+new Array(Math.pow(2, 40))
 new Array(-1)
 new ArrayBuffer(Math.pow(2, 32))
 new ArrayBuffer(-1)
@@ -51,11 +49,12 @@ a.length = a.length - 1;         // set -1 to the length property
 
 let b = new Array(Math.pow(2, 32) - 1);
 b.length = b.length + 1;         // set 2^32 to the length property
-</pre>
+```
 
-<h3 id="Exemples_valides">Exemples valides</h3>
+### Exemples valides
 
-<pre class="brush: js example-good">[ Math.pow(2, 40) ]                     // [ 1099511627776 ]
+```js example-good
+[ Math.pow(2, 40) ]                     // [ 1099511627776 ]
 [ -1 ]                                  // [ -1 ]
 new ArrayBuffer(Math.pow(2, 32) - 1)
 new ArrayBuffer(0)
@@ -68,13 +67,11 @@ b.length = Math.min(0xffffffff, b.length + 1);
 
 // 0xffffffff est la notation hexadécimale
 // pour 2^32 - 1
-// ce qu'on peut également écrire (-1 &gt;&gt;&gt; 0)
-</pre>
+// ce qu'on peut également écrire (-1 >>> 0)
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("Array")}}</li>
- <li>{{jsxref("Array.length")}}</li>
- <li>{{jsxref("ArrayBuffer")}}</li>
-</ul>
+- {{jsxref("Array")}}
+- {{jsxref("Array.length")}}
+- {{jsxref("ArrayBuffer")}}
diff --git a/files/fr/web/javascript/reference/errors/invalid_assignment_left-hand_side/index.md b/files/fr/web/javascript/reference/errors/invalid_assignment_left-hand_side/index.md
index 5a441e32a9..b35d7cdcc1 100644
--- a/files/fr/web/javascript/reference/errors/invalid_assignment_left-hand_side/index.md
+++ b/files/fr/web/javascript/reference/errors/invalid_assignment_left-hand_side/index.md
@@ -8,24 +8,24 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/Invalid_assignment_left-hand_side
 original_slug: Web/JavaScript/Reference/Erreurs/Invalid_assignment_left-hand_side
 ---
-<div>{{jsSidebar("Errors")}}</div>
+{{jsSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">ReferenceError: invalid assignment left-hand side
-</pre>
+    ReferenceError: invalid assignment left-hand side
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>{{jsxref("ReferenceError")}}.</p>
+{{jsxref("ReferenceError")}}.
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p>Un affectation inattendue a eu lieu. Cela peut être dû à un mélange entre <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_d_affectation">un opérateur d'affectation</a> et <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_comparaison">un opérateur de comparaison</a>. Un seul signe égal affectera une valeur à une variable alors que les opérateurs <code>==</code> ou <code>===</code> comparent des valeurs entre elles.</p>
+Un affectation inattendue a eu lieu. Cela peut être dû à un mélange entre [un opérateur d'affectation](/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_d_affectation) et [un opérateur de comparaison](/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_comparaison). Un seul signe égal affectera une valeur à une variable alors que les opérateurs `==` ou `===` comparent des valeurs entre elles.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<pre class="brush: js example-bad">if (Math.PI = 3 || Math.PI = 4) {
+```js example-bad
+if (Math.PI = 3 || Math.PI = 4) {
   console.log('Nope !');
 }
 // ReferenceError: invalid assignment left-hand side
@@ -34,22 +34,21 @@ var str = 'Hello, '
 += 'is it me '
 += 'you\'re looking for?';
 // ReferenceError: invalid assignment left-hand side
-</pre>
+```
 
-<p>Dans l'instruction <code>if</code>, plutôt qu'une affectation, on voudra plutôt utiliser un opérateur <code>==</code> ou <code>===</code> et l'opérateur de concaténation (+) à la place pour la chaîne.</p>
+Dans l'instruction `if`, plutôt qu'une affectation, on voudra plutôt utiliser un opérateur `==` ou `===` et l'opérateur de concaténation (+) à la place pour la chaîne.
 
-<pre class="brush: js example-good">if (Math.PI == 3 || Math.PI == 4) {
+```js example-good
+if (Math.PI == 3 || Math.PI == 4) {
   console.log('no way!');
 }
 
 var str = 'Hello, '
 + 'from the '
 + 'other side!';
-</pre>
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_d_affectation">Opérateurs d'affectation</a></li>
- <li><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_comparaison">Opérateurs de comparaison</a></li>
-</ul>
+- [Opérateurs d'affectation](/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_d_affectation)
+- [Opérateurs de comparaison](/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_comparaison)
diff --git a/files/fr/web/javascript/reference/errors/invalid_const_assignment/index.md b/files/fr/web/javascript/reference/errors/invalid_const_assignment/index.md
index 76219c8d9f..8205bb266e 100644
--- a/files/fr/web/javascript/reference/errors/invalid_const_assignment/index.md
+++ b/files/fr/web/javascript/reference/errors/invalid_const_assignment/index.md
@@ -8,84 +8,91 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/Invalid_const_assignment
 original_slug: Web/JavaScript/Reference/Erreurs/Invalid_const_assignment
 ---
-<div>{{jsSidebar("Errors")}}</div>
+{{jsSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">TypeError: invalid assignment to const "x" (Firefox)
-TypeError: Assignment to constant variable. (Chrome)
-TypeError: Redeclaration of const 'x' (Edge)
-</pre>
+    TypeError: invalid assignment to const "x" (Firefox)
+    TypeError: Assignment to constant variable. (Chrome)
+    TypeError: Redeclaration of const 'x' (Edge)
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>{{jsxref("TypeError")}}</p>
+{{jsxref("TypeError")}}
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p>Une constante est une valeur qui ne peut pas être modifiée lors de l'exécution du programme. Elle ne peut pas être modifiée grâce à une réaffectation ou grâce à une redéclaration. En JavaScript, les constantes sont déclarées grâce au mot-clé <code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/const">const</a></code>.</p>
+Une constante est une valeur qui ne peut pas être modifiée lors de l'exécution du programme. Elle ne peut pas être modifiée grâce à une réaffectation ou grâce à une redéclaration. En JavaScript, les constantes sont déclarées grâce au mot-clé [`const`](/fr/docs/Web/JavaScript/Reference/Instructions/const).
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Redéclaration_invalide">Redéclaration invalide</h3>
+### Redéclaration invalide
 
-<p>Si on affecte une valeur à une constante dans la même portée de bloc que celui qui contient l'affectation initiale, une exception sera levée :</p>
+Si on affecte une valeur à une constante dans la même portée de bloc que celui qui contient l'affectation initiale, une exception sera levée :
 
-<pre class="brush: js example-bad">const COLUMNS = 80;
+```js example-bad
+const COLUMNS = 80;
 
 // ...
 
-COLUMNS = 120; // TypeError: invalid assignment to const `COLUMNS'</pre>
+COLUMNS = 120; // TypeError: invalid assignment to const `COLUMNS'
+```
 
-<h3 id="Résoudre_le_problème">Résoudre le problème</h3>
+### Résoudre le problème
 
-<p>Il existe plusieurs façons de résoudre ce problème et il faut au préalable comprendre le rôle de la constante en question.</p>
+Il existe plusieurs façons de résoudre ce problème et il faut au préalable comprendre le rôle de la constante en question.
 
-<h4 id="Utiliser_un_autre_nom">Utiliser un autre nom</h4>
+#### Utiliser un autre nom
 
-<p>Si on souhaite déclarer une autre constante, on peut utiliser un autre nom que celui qui est déjà pris dans cette portée :</p>
+Si on souhaite déclarer une autre constante, on peut utiliser un autre nom que celui qui est déjà pris dans cette portée :
 
-<pre class="brush: js example-good">const COLUMNS = 80;
-const WIDE_COLUMNS = 120;</pre>
+```js example-good
+const COLUMNS = 80;
+const WIDE_COLUMNS = 120;
+```
 
-<h4 id="const_let_ou_var"><code>const</code>, <code>let</code> ou <code>var</code> ?</h4>
+#### `const`, `let` ou `var` ?
 
-<p><code>const</code> ne doit pas être utilisé si on ne souhaite pas déclarer de constante. Peut-être qu'on souhaite simplement déclarer une variable avec une portée de bloc grâce à <code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/let">let</a></code> ou une variable globale avec <code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/var">var</a></code>.</p>
+`const` ne doit pas être utilisé si on ne souhaite pas déclarer de constante. Peut-être qu'on souhaite simplement déclarer une variable avec une portée de bloc grâce à [`let`](/fr/docs/Web/JavaScript/Reference/Instructions/let) ou une variable globale avec [`var`](/fr/docs/Web/JavaScript/Reference/Instructions/var).
 
-<pre class="brush: js example-good">let columns = 80;
+```js example-good
+let columns = 80;
 
 // ...
 
 let columns = 120;
-</pre>
+```
 
-<h4 id="Gérer_les_portées">Gérer les portées</h4>
+#### Gérer les portées
 
-<p>On peut également vérifier qu'on est dans la bonne portée. Est-ce que la constante devait apparaître dans la portée en question ou devait être utilisée dans une fonction ?</p>
+On peut également vérifier qu'on est dans la bonne portée. Est-ce que la constante devait apparaître dans la portée en question ou devait être utilisée dans une fonction ?
 
-<pre class="brush: js example-good">const COLUMNS = 80;
+```js example-good
+const COLUMNS = 80;
 
 function setupBigScreenEnvironment() {
   const COLUMNS = 120;
-}</pre>
+}
+```
 
-<h3 id="const_et_l'immuabilité"><code>const</code> et l'immuabilité</h3>
+### `const` et l'immuabilité
 
-<p>La déclaration <code>const</code> crée une référence en lecture seule vers une valeur. Elle ne signifie pas que la valeur en question est immuable mais uniquement que l'identifiant de la référence ne peut pas recevoir de nouvelle valeur. Ainsi, si le contenu est un objet, celui-ci pourra toujours être modifié :</p>
+La déclaration `const` crée une référence en lecture seule vers une valeur. Elle ne signifie pas que la valeur en question est immuable mais uniquement que l'identifiant de la référence ne peut pas recevoir de nouvelle valeur. Ainsi, si le contenu est un objet, celui-ci pourra toujours être modifié :
 
-<pre class="brush: js example-bad">const obj = {toto: 'truc'};
+```js example-bad
+const obj = {toto: 'truc'};
 obj = {toto: 'bidule'}; // TypeError: invalid assignment to const `obj'
-</pre>
+```
 
-<p>En revanche, on peut modifier les propriétés :</p>
+En revanche, on peut modifier les propriétés :
 
-<pre class="brush: js example-good">obj.toto = 'bidule';
-obj; // Object { toto: "bidule" }</pre>
+```js example-good
+obj.toto = 'bidule';
+obj; // Object { toto: "bidule" }
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li><code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/const">const</a></code></li>
- <li><code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/let">let</a></code></li>
- <li><code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/var">var</a></code></li>
-</ul>
+- [`const`](/fr/docs/Web/JavaScript/Reference/Instructions/const)
+- [`let`](/fr/docs/Web/JavaScript/Reference/Instructions/let)
+- [`var`](/fr/docs/Web/JavaScript/Reference/Instructions/var)
diff --git a/files/fr/web/javascript/reference/errors/invalid_date/index.md b/files/fr/web/javascript/reference/errors/invalid_date/index.md
index a89f979fbc..ab0905ac9f 100644
--- a/files/fr/web/javascript/reference/errors/invalid_date/index.md
+++ b/files/fr/web/javascript/reference/errors/invalid_date/index.md
@@ -8,50 +8,52 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/Invalid_date
 original_slug: Web/JavaScript/Reference/Erreurs/Invalid_date
 ---
-<div>{{jsSidebar("Errors")}}</div>
+{{jsSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">RangeError: invalid date (Edge)
-RangeError: invalid date (Firefox)
-RangeError: invalid time value (Chrome)
-RangeError: Provided date is not in valid range (Chrome)
-</pre>
+    RangeError: invalid date (Edge)
+    RangeError: invalid date (Firefox)
+    RangeError: invalid time value (Chrome)
+    RangeError: Provided date is not in valid range (Chrome)
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>{{jsxref("RangeError")}}</p>
+{{jsxref("RangeError")}}
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p>Une chaîne de caractères indiquant une date invalide a été fournie comme argument au constructeur {{jsxref("Date")}} ou à la méthode {{jsxref("Date.parse()")}}.</p>
+Une chaîne de caractères indiquant une date invalide a été fournie comme argument au constructeur {{jsxref("Date")}} ou à la méthode {{jsxref("Date.parse()")}}.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Exemples_invalides">Exemples invalides</h3>
+### Exemples invalides
 
-<p>Les chaînes de caractères qui ne peuvent pas être converties en date ou les dates qui contiennent des éléments illégaux pour le format ISO renvoient généralement {{jsxref("NaN")}}. Cependant, selon l'implémentation, les chaînes de caractères qui ne respectent pas le format ISO pour les dates peuvent déclencher une exception <code>RangeError: invalid date</code>. Les instructions suivantes déclencheront cette erreur dans Firefox :</p>
+Les chaînes de caractères qui ne peuvent pas être converties en date ou les dates qui contiennent des éléments illégaux pour le format ISO renvoient généralement {{jsxref("NaN")}}. Cependant, selon l'implémentation, les chaînes de caractères qui ne respectent pas le format ISO pour les dates peuvent déclencher une exception `RangeError: invalid date`. Les instructions suivantes déclencheront cette erreur dans Firefox :
 
-<pre class="brush: js example-bad">new Date('toto-truc 2014');
+```js example-bad
+new Date('toto-truc 2014');
 new Date('2014-25-23').toISOString();
 new Date('toto-truc 2014').toString();
-</pre>
+```
 
-<p>En revanche, cette instruction renverra {{jsxref("NaN")}} dans Firefox :</p>
+En revanche, cette instruction renverra {{jsxref("NaN")}} dans Firefox :
 
-<pre class="brush: js example-bad">Date.parse('toto-truc 2014'); // NaN</pre>
+```js example-bad
+Date.parse('toto-truc 2014'); // NaN
+```
 
-<p>Pour plus de détails, consulter la documentation sur {{jsxref("Date.parse()")}}.</p>
+Pour plus de détails, consulter la documentation sur {{jsxref("Date.parse()")}}.
 
-<h3 id="Exemples_valides">Exemples valides</h3>
+### Exemples valides
 
-<pre class="brush: js example-good">new Date('05 October 2011 14:48 UTC');
-new Date(1317826080); // timestamp Unix pour le 5 octobre 2011 14:48:00 UTC</pre>
+```js example-good
+new Date('05 October 2011 14:48 UTC');
+new Date(1317826080); // timestamp Unix pour le 5 octobre 2011 14:48:00 UTC
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("Date")}}</li>
- <li>{{jsxref("Date.prototype.parse()")}}</li>
- <li>{{jsxref("Date.prototype.toISOString()")}}</li>
-</ul>
+- {{jsxref("Date")}}
+- {{jsxref("Date.prototype.parse()")}}
+- {{jsxref("Date.prototype.toISOString()")}}
diff --git a/files/fr/web/javascript/reference/errors/invalid_for-in_initializer/index.md b/files/fr/web/javascript/reference/errors/invalid_for-in_initializer/index.md
index 2ae766aadc..64160b2884 100644
--- a/files/fr/web/javascript/reference/errors/invalid_for-in_initializer/index.md
+++ b/files/fr/web/javascript/reference/errors/invalid_for-in_initializer/index.md
@@ -9,28 +9,28 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/Invalid_for-in_initializer
 original_slug: Web/JavaScript/Reference/Erreurs/Invalid_for-in_initializer
 ---
-<div>{{jsSidebar("Errors")}}</div>
+{{jsSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">SyntaxError: for-in loop head declarations cannot have an initializer (Edge)
-SyntaxError: for-in loop head declarations may not have initializers (Firefox)
-SyntaxError: for-in loop variable declaration may not have an initializer. (Chrome)
-</pre>
+    SyntaxError: for-in loop head declarations cannot have an initializer (Edge)
+    SyntaxError: for-in loop head declarations may not have initializers (Firefox)
+    SyntaxError: for-in loop variable declaration may not have an initializer. (Chrome)
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>{{jsxref("SyntaxError")}}, uniquement en <a href="/fr/docs/Web/JavaScript/Reference/Strict_mode">mode strict</a>.</p>
+{{jsxref("SyntaxError")}}, uniquement en [mode strict](/fr/docs/Web/JavaScript/Reference/Strict_mode).
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p>L'en-tête d'une boucle <code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/for...in">for...in</a></code> contient une expression d'initialisation, c'est-à-dire qu'une variable est déclarée et qu'on lui affecte une valeur. Ceci n'est pas autorisé en mode strict (et ignoré en mode non-strict).</p>
+L'en-tête d'une boucle [`for...in`](/fr/docs/Web/JavaScript/Reference/Instructions/for...in) contient une expression d'initialisation, c'est-à-dire qu'une variable est déclarée et qu'on lui affecte une valeur. Ceci n'est pas autorisé en mode strict (et ignoré en mode non-strict).
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<p>Cet exemple déclenchera une exception <code>SyntaxError</code> :</p>
+Cet exemple déclenchera une exception `SyntaxError` :
 
-<pre class="brush: js example-bad">"use strict";
+```js example-bad
+"use strict";
 
 var obj = {a: 1, b: 2, c: 3 };
 
@@ -39,37 +39,38 @@ for (var i = 0 in obj) {
 }
 
 // SyntaxError: for-in loop head declarations may not have initializers
-</pre>
+```
 
-<h3 id="Boucle_for-in_valide">Boucle for-in valide</h3>
+### Boucle for-in valide
 
-<p>On peut retirer l'initialisateur de l'en-tête de la boucle :</p>
+On peut retirer l'initialisateur de l'en-tête de la boucle :
 
-<pre class="brush: js example-good">"use strict";
+```js example-good
+"use strict";
 
 var obj = {a: 1, b: 2, c: 3 };
 
 for (var i in obj) {
   console.log(obj[i]);
 }
-</pre>
+```
 
-<h3 id="Parcours_d'un_tableau">Parcours d'un tableau</h3>
+### Parcours d'un tableau
 
-<p><a href="/fr/docs/Web/JavaScript/Reference/Instructions/for...in#Utiliser_for...in_et_parcourir_un_tableau">Il ne faut pas utiliser de boucle <code>for...in</code> pour parcourir un tableau (<code>Array</code>)</a>. Peut-être souhaitiez-vous utiliser une boucle <code>for</code> pour parcourir le tableau ? Cette boucle <code>for</code> permet également d'utiliser un initialisateur :</p>
+[Il ne faut pas utiliser de boucle `for...in` pour parcourir un tableau (`Array`)](/fr/docs/Web/JavaScript/Reference/Instructions/for...in#Utiliser_for...in_et_parcourir_un_tableau). Peut-être souhaitiez-vous utiliser une boucle `for` pour parcourir le tableau ? Cette boucle `for` permet également d'utiliser un initialisateur :
 
-<pre class="brush: js example-good">var arr = [ "a", "b", "c" ]
+```js example-good
+var arr = [ "a", "b", "c" ]
 
-for (var i = 2; i &lt; arr.length; i++) {
+for (var i = 2; i < arr.length; i++) {
   console.log(arr[i]);
 }
 
-// "c"</pre>
+// "c"
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li><code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/for...in">for...in</a></code></li>
- <li><code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/for...of">for...of</a></code> interdit également d'utiliser un initialisateur en mode strict et non-strict</li>
- <li><code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/for">for</a></code> permet de définir un initialisateur lors de l'itération et doit être privilégié pour parcourir un tableau</li>
-</ul>
+- [`for...in`](/fr/docs/Web/JavaScript/Reference/Instructions/for...in)
+- [`for...of`](/fr/docs/Web/JavaScript/Reference/Instructions/for...of) interdit également d'utiliser un initialisateur en mode strict et non-strict
+- [`for`](/fr/docs/Web/JavaScript/Reference/Instructions/for) permet de définir un initialisateur lors de l'itération et doit être privilégié pour parcourir un tableau
diff --git a/files/fr/web/javascript/reference/errors/invalid_for-of_initializer/index.md b/files/fr/web/javascript/reference/errors/invalid_for-of_initializer/index.md
index 943b5399fc..932f1f44ce 100644
--- a/files/fr/web/javascript/reference/errors/invalid_for-of_initializer/index.md
+++ b/files/fr/web/javascript/reference/errors/invalid_for-of_initializer/index.md
@@ -10,41 +10,43 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/Invalid_for-of_initializer
 original_slug: Web/JavaScript/Reference/Erreurs/Invalid_for-of_initializer
 ---
-<div>{{jsSidebar("Errors")}}</div>
+{{jsSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">SyntaxError: for-of loop head declarations cannot have an initializer (Edge)
-SyntaxError: a declaration in the head of a for-of loop can't have an initializer (Firefox)
-SyntaxError: for-of loop variable declaration may not have an initializer. (Chrome)
-</pre>
+    SyntaxError: for-of loop head declarations cannot have an initializer (Edge)
+    SyntaxError: a declaration in the head of a for-of loop can't have an initializer (Firefox)
+    SyntaxError: for-of loop variable declaration may not have an initializer. (Chrome)
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>{{jsxref("SyntaxError")}}</p>
+{{jsxref("SyntaxError")}}
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p>L'en-tête d'une boucle <code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/for...of">for...of</a></code> contient une expression d'initialisation, c'est-à-dire qu'une variable est déclarée et qu'on lui affecte une valeur. Ceci n'est pas autorisé pour les boucles <code>for-of</code>. En revanche, les boucles <code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/for">for</a></code> permettent d'avoir un initialisateur.</p>
+L'en-tête d'une boucle [`for...of`](/fr/docs/Web/JavaScript/Reference/Instructions/for...of) contient une expression d'initialisation, c'est-à-dire qu'une variable est déclarée et qu'on lui affecte une valeur. Ceci n'est pas autorisé pour les boucles `for-of`. En revanche, les boucles [`for`](/fr/docs/Web/JavaScript/Reference/Instructions/for) permettent d'avoir un initialisateur.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Boucles_for-of_invalides">Boucles <code>for-of</code> invalides</h3>
+### Boucles `for-of` invalides
 
-<pre class="brush: js example-bad">let iterable = [10, 20, 30];
+```js example-bad
+let iterable = [10, 20, 30];
 
 for (let value = 50 of iterable) {
   console.log(value);
 }
 
 // SyntaxError: a declaration in the head of a for-of loop can't
-// have an initializer</pre>
+// have an initializer
+```
 
-<h3 id="Boucles_for-of_valides">Boucles <code>for-of</code> valides</h3>
+### Boucles `for-of` valides
 
-<p>Il faut retirer l'initialisateur de l'en-tête de la boucle pour ne plus avoir l'erreur. Si cette valeur devait servir d'incrément, on peut ajouter l'addition dans le corps de la boucle.</p>
+Il faut retirer l'initialisateur de l'en-tête de la boucle pour ne plus avoir l'erreur. Si cette valeur devait servir d'incrément, on peut ajouter l'addition dans le corps de la boucle.
 
-<pre class="brush: js example-good">let iterable = [10, 20, 30];
+```js example-good
+let iterable = [10, 20, 30];
 
 for (let value of iterable) {
   value += 50;
@@ -53,12 +55,10 @@ for (let value of iterable) {
 // 60
 // 70
 // 80
-</pre>
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li><code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/for...of">for...of</a></code></li>
- <li><code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/for...in">for...in</a></code> interdit également d'utiliser un initialisateur en mode strict (<a href="/fr/docs/Web/JavaScript/Reference/Errors/Invalid_for-in_initializer">SyntaxError: for-in loop head declarations may not have initializers</a>)</li>
- <li><code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/for">for</a></code> permet de définir un initialisateur lors de l'itération</li>
-</ul>
+- [`for...of`](/fr/docs/Web/JavaScript/Reference/Instructions/for...of)
+- [`for...in`](/fr/docs/Web/JavaScript/Reference/Instructions/for...in) interdit également d'utiliser un initialisateur en mode strict ([SyntaxError: for-in loop head declarations may not have initializers](/fr/docs/Web/JavaScript/Reference/Errors/Invalid_for-in_initializer))
+- [`for`](/fr/docs/Web/JavaScript/Reference/Instructions/for) permet de définir un initialisateur lors de l'itération
diff --git a/files/fr/web/javascript/reference/errors/invalid_right_hand_side_instanceof_operand/index.md b/files/fr/web/javascript/reference/errors/invalid_right_hand_side_instanceof_operand/index.md
index a9fe80e977..12e1bc3e14 100644
--- a/files/fr/web/javascript/reference/errors/invalid_right_hand_side_instanceof_operand/index.md
+++ b/files/fr/web/javascript/reference/errors/invalid_right_hand_side_instanceof_operand/index.md
@@ -10,26 +10,27 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/invalid_right_hand_side_instanceof_operand
 original_slug: Web/JavaScript/Reference/Erreurs/invalid_right_hand_side_instanceof_operand
 ---
-<div>{{jsSidebar("Errors")}}</div>
+{{jsSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">TypeError: invalid 'instanceof' operand "x" (Firefox)
-TypeError: "x" is not a function (Firefox)
-TypeError: Right-hand side of 'instanceof' is not an object (Chrome)
-TypeError: Right-hand side of 'instanceof' is not callable (Chrome)</pre>
+    TypeError: invalid 'instanceof' operand "x" (Firefox)
+    TypeError: "x" is not a function (Firefox)
+    TypeError: Right-hand side of 'instanceof' is not an object (Chrome)
+    TypeError: Right-hand side of 'instanceof' is not callable (Chrome)
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>{{jsxref("TypeError")}}</p>
+{{jsxref("TypeError")}}
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p>L'opérateur <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/instanceof"><code>instanceof</code></a> attend un opérande droit qui soit un objet constructeur, c'est-à-dire un objet possédant une propriété <code>prototype</code> et qui puisse être appelé.</p>
+L'opérateur [`instanceof`](/fr/docs/Web/JavaScript/Reference/Opérateurs/instanceof) attend un opérande droit qui soit un objet constructeur, c'est-à-dire un objet possédant une propriété `prototype` et qui puisse être appelé.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<pre class="brush: js example-bad">"test" instanceof ""; // TypeError: invalid 'instanceof' operand ""
+```js example-bad
+"test" instanceof ""; // TypeError: invalid 'instanceof' operand ""
 42 instanceof 0;      // TypeError: invalid 'instanceof' operand 0
 
 function Toto() {}
@@ -38,11 +39,12 @@ var x = new Toto();
 
 x instanceof f;       // TypeError: invalid 'instanceof' operand f
 x instanceof x;       // TypeError: x is not a function
-</pre>
+```
 
-<p>Pour corriger ces erreurs, il faut remplacer l'opérateur <code>instanceof</code> avec l'opérateur <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_typeof"><code>typeof</code></a> ou s'assurer que l'opérande droit est la fonction et non le résultat de son évaluation.</p>
+Pour corriger ces erreurs, il faut remplacer l'opérateur `instanceof` avec l'opérateur [`typeof`](/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_typeof) ou s'assurer que l'opérande droit est la fonction et non le résultat de son évaluation.
 
-<pre class="brush: js example-good">typeof "test" == "string";  // true
+```js example-good
+typeof "test" == "string";  // true
 typeof 42 == "number"       // true
 
 function Toto() {}
@@ -51,13 +53,9 @@ var x = new Toto();
 
 x instanceof f;             // true
 x instanceof Toto;          // true
-</pre>
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>L'opérateur <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/instanceof"><code>instanceof</code></a></li>
- <li>L'opérateur <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_typeof"><code>typeof</code></a></li>
-</ul>
-
-<p> </p>
+- L'opérateur [`instanceof`](/fr/docs/Web/JavaScript/Reference/Opérateurs/instanceof)
+- L'opérateur [`typeof`](/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_typeof)
diff --git a/files/fr/web/javascript/reference/errors/is_not_iterable/index.md b/files/fr/web/javascript/reference/errors/is_not_iterable/index.md
index 1aba992ca7..f2c751c136 100644
--- a/files/fr/web/javascript/reference/errors/is_not_iterable/index.md
+++ b/files/fr/web/javascript/reference/errors/is_not_iterable/index.md
@@ -9,37 +9,38 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/is_not_iterable
 original_slug: Web/JavaScript/Reference/Erreurs/is_not_iterable
 ---
-<div>{{jsSidebar("Errors")}}</div>
+{{jsSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">TypeError: 'x' is not iterable (Firefox, Chrome)
-TypeError: 'x' is not a function or its return value is not iterable (Chrome)
-</pre>
+    TypeError: 'x' is not iterable (Firefox, Chrome)
+    TypeError: 'x' is not a function or its return value is not iterable (Chrome)
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>{{jsxref("TypeError")}}</p>
+{{jsxref("TypeError")}}
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p>La valeur passée comme opérande droit de <a href="/fr/docs/Web/JavaScript/Reference/Instructions/for...of"><code>for…of</code> </a>ou comme argument d'une fonction telle que {{jsxref("Promise.all")}} ou {{jsxref("TypedArray.from")}} n'est pas <a href="/fr/docs/Web/JavaScript/Reference/Les_protocoles_iteration">un objet itérable</a>.  Un objet itérable peut être un objet itérable natif tel qu'un objet {{jsxref("Array")}}, {{jsxref("String")}} ou {{jsxref("Map")}} ou le résultat d'un générateur ou un objet qui implémente <a href="/fr/docs/Web/JavaScript/Reference/Les_protocoles_iteration#Le_protocole_«_itérable_»">le protocole itérable</a>.</p>
+La valeur passée comme opérande droit de [`for…of` ](/fr/docs/Web/JavaScript/Reference/Instructions/for...of)ou comme argument d'une fonction telle que {{jsxref("Promise.all")}} ou {{jsxref("TypedArray.from")}} n'est pas [un objet itérable](/fr/docs/Web/JavaScript/Reference/Les_protocoles_iteration).  Un objet itérable peut être un objet itérable natif tel qu'un objet {{jsxref("Array")}}, {{jsxref("String")}} ou {{jsxref("Map")}} ou le résultat d'un générateur ou un objet qui implémente [le protocole itérable](/fr/docs/Web/JavaScript/Reference/Les_protocoles_iteration#Le_protocole_«_itérable_»).
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Parcourir_les_propriétés_d'un_objet">Parcourir les propriétés d'un objet</h3>
+### Parcourir les propriétés d'un objet
 
-<p>En JavaScript, les objets ne sont pas itérables car ils n'implémentent pas le <a href="/fr/docs/Web/JavaScript/Reference/Les_protocoles_iteration#Le_protocole_«_itérable_»">protocole itérable</a>. On ne peut donc pas utiliser <code>for...of</code> afin d'en parcourir les propriétés.</p>
+En JavaScript, les objets ne sont pas itérables car ils n'implémentent pas le [protocole itérable](/fr/docs/Web/JavaScript/Reference/Les_protocoles_iteration#Le_protocole_«_itérable_»). On ne peut donc pas utiliser `for...of` afin d'en parcourir les propriétés.
 
-<pre class="brush: js example-bad">var obj = { 'France': 'Paris', 'England': 'London' };
+```js example-bad
+var obj = { 'France': 'Paris', 'England': 'London' };
 for (let p of obj) { // TypeError: obj is not iterable
     // …
 }
-</pre>
+```
 
-<p>Si on souhaite utiliser un itérateur pour parcourir les propriétés (leurs noms ou leurs valeurs), on pourra utiliser les méthodes {{jsxref("Object.keys")}} ou {{jsxref("Object.entries")}} qui fournissent des itérateurs :</p>
+Si on souhaite utiliser un itérateur pour parcourir les propriétés (leurs noms ou leurs valeurs), on pourra utiliser les méthodes {{jsxref("Object.keys")}} ou {{jsxref("Object.entries")}} qui fournissent des itérateurs :
 
-<pre class="brush: js example-good">var obj = { 'France': 'Paris', 'England': 'London' };
+```js example-good
+var obj = { 'France': 'Paris', 'England': 'London' };
 // On parcourt les noms des propriétés
 for (let country of Object.keys(obj)) {
     var capital = obj[country];
@@ -48,11 +49,12 @@ for (let country of Object.keys(obj)) {
 
 for (const [country, capital] of Object.entries(obj))
     console.log(country, capital);
-</pre>
+```
 
-<p>On pourrait également utiliser un objet {{jsxref("Map")}} :</p>
+On pourrait également utiliser un objet {{jsxref("Map")}} :
 
-<pre class="brush: js example-good">var map = new Map;
+```js example-good
+var map = new Map;
 map.set('France', 'Paris');
 map.set('England', 'London');
 // On parcourt les noms des propriétés
@@ -66,37 +68,40 @@ for (let capital of map.values())
 
 for (const [country, capital] of map.entries())
     console.log(country, capital);
-</pre>
+```
 
-<h3 id="Itérer_grâce_à_un_générateur">Itérer grâce à un générateur</h3>
+### Itérer grâce à un générateur
 
-<p><a href="/fr/docs/Web/JavaScript/Guide/iterateurs_et_generateurs">Les générateurs</a> sont des fonctions qui, lorsqu'elles sont appelées, produisent des objets itérables.</p>
+[Les générateurs](/fr/docs/Web/JavaScript/Guide/iterateurs_et_generateurs) sont des fonctions qui, lorsqu'elles sont appelées, produisent des objets itérables.
 
-<pre class="brush: js example-bad">function* generate(a, b) {
+```js example-bad
+function* generate(a, b) {
   yield a;
   yield b;
 }
 
 for (let x of generate) // TypeError: generate is not iterable
     console.log(x);
-</pre>
+```
 
-<p>Lorsqu'elles ne sont pas appelées, l'objet {{jsxref("Function")}} correspondant au générateur peut être appelé mais il n'est pass itérable. Il ne faut donc pas oublier d'invoquer le générateur afin de parcourir les valeurs de l'itérateur qu'il produit.</p>
+Lorsqu'elles ne sont pas appelées, l'objet {{jsxref("Function")}} correspondant au générateur peut être appelé mais il n'est pass itérable. Il ne faut donc pas oublier d'invoquer le générateur afin de parcourir les valeurs de l'itérateur qu'il produit.
 
-<pre class="brush: js example-good">function* generate(a, b) {
+```js example-good
+function* generate(a, b) {
     yield a;
     yield b;
 }
 
 for (let x of generate(1,2))
     console.log(x);
-</pre>
+```
 
-<h3 id="Parcourir_un_itérable_spécifique">Parcourir un itérable spécifique</h3>
+### Parcourir un itérable spécifique
 
-<p>Les itérables spécifiques (<em>custom iterables</em>) peuvent être créés en implémentant la méthode {{jsxref("Symbol.iterator")}}. En implémentant cette méthode, il faut s'assurer que la valeur renvoyée est un objet qui est un itérateur. Autrement dit, l'objet renvoyé doit posséder une méthode <code>next()</code>.</p>
+Les itérables spécifiques (_custom iterables_) peuvent être créés en implémentant la méthode {{jsxref("Symbol.iterator")}}. En implémentant cette méthode, il faut s'assurer que la valeur renvoyée est un objet qui est un itérateur. Autrement dit, l'objet renvoyé doit posséder une méthode `next()`.
 
-<pre class="brush: js example-bad">const monIterableVide = {
+```js example-bad
+const monIterableVide = {
     [Symbol.iterator]() {
         return [] // [] est un iterable mais pas un itérateur
                   // car il n'a pas de méthode next
@@ -104,26 +109,25 @@ for (let x of generate(1,2))
 }
 
 Array.from(monIterableVide);  // TypeError: monIterableVide is not iterable
-</pre>
+```
 
-<p>Voici une implémentation correcte :</p>
+Voici une implémentation correcte :
 
-<pre class="brush: js example-good">const monIterableVide = {
+```js example-good
+const monIterableVide = {
     [Symbol.iterator]() {
         return [][Symbol.iterator]()
     }
 }
 
 Array.from(monIterableVide);  // []
-</pre>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li><a href="/fr/docs/Web/JavaScript/Reference/Les_protocoles_iteration#Le_protocole_«_itérable_»">Le protocole itérable</a></li>
- <li>{{jsxref("Object.keys")}}</li>
- <li>{{jsxref("Object.entries")}}</li>
- <li>{{jsxref("Map")}}</li>
- <li><a href="/fr/docs/Web/JavaScript/Guide/iterateurs_et_generateurs#Générateurs">Les générateurs</a></li>
- <li><code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/for...of">for…of</a></code></li>
-</ul>
+```
+
+## Voir aussi
+
+- [Le protocole itérable](/fr/docs/Web/JavaScript/Reference/Les_protocoles_iteration#Le_protocole_«_itérable_»)
+- {{jsxref("Object.keys")}}
+- {{jsxref("Object.entries")}}
+- {{jsxref("Map")}}
+- [Les générateurs](/fr/docs/Web/JavaScript/Guide/iterateurs_et_generateurs#Générateurs)
+- [`for…of`](/fr/docs/Web/JavaScript/Reference/Instructions/for...of)
diff --git a/files/fr/web/javascript/reference/errors/json_bad_parse/index.md b/files/fr/web/javascript/reference/errors/json_bad_parse/index.md
index 800d8fd05f..870dc1812b 100644
--- a/files/fr/web/javascript/reference/errors/json_bad_parse/index.md
+++ b/files/fr/web/javascript/reference/errors/json_bad_parse/index.md
@@ -10,104 +10,110 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/JSON_bad_parse
 original_slug: Web/JavaScript/Reference/Erreurs/JSON_bad_parse
 ---
-<div>{{jsSidebar("Errors")}}</div>
-
-<h2 id="Message">Message</h2>
-
-<pre class="syntaxbox">SyntaxError: JSON.parse: unterminated string literal
-SyntaxError: JSON.parse: bad control character in string literal
-SyntaxError: JSON.parse: bad character in string literal
-SyntaxError: JSON.parse: bad Unicode escape
-SyntaxError: JSON.parse: bad escape character
-SyntaxError: JSON.parse: unterminated string
-SyntaxError: JSON.parse: no number after minus sign
-SyntaxError: JSON.parse: unexpected non-digit
-SyntaxError: JSON.parse: missing digits after decimal point
-SyntaxError: JSON.parse: unterminated fractional number
-SyntaxError: JSON.parse: missing digits after exponent indicator
-SyntaxError: JSON.parse: missing digits after exponent sign
-SyntaxError: JSON.parse: exponent part is missing a number
-SyntaxError: JSON.parse: unexpected end of data
-SyntaxError: JSON.parse: unexpected keyword
-SyntaxError: JSON.parse: unexpected character
-SyntaxError: JSON.parse: end of data while reading object contents
-SyntaxError: JSON.parse: expected property name or '}'
-SyntaxError: JSON.parse: end of data when ',' or ']' was expected
-SyntaxError: JSON.parse: expected ',' or ']' after array element
-SyntaxError: JSON.parse: end of data when property name was expected
-SyntaxError: JSON.parse: expected double-quoted property name
-SyntaxError: JSON.parse: end of data after property name when ':' was expected
-SyntaxError: JSON.parse: expected ':' after property name in object
-SyntaxError: JSON.parse: end of data after property value in object
-SyntaxError: JSON.parse: expected ',' or '}' after property value in object
-SyntaxError: JSON.parse: expected ',' or '}' after property-value pair in object literal
-SyntaxError: JSON.parse: property names must be double-quoted strings
-SyntaxError: JSON.parse: expected property name or '}'
-SyntaxError: JSON.parse: unexpected character
-SyntaxError: JSON.parse: unexpected non-whitespace character after JSON data
-SyntaxError: JSON.parse Error: Invalid character at position {0} (Edge)
-</pre>
-
-<h2 id="Type_d'erreur">Type d'erreur</h2>
-
-<p>{{jsxref("SyntaxError")}}</p>
-
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
-
-<p>Lorsque la méthode {{jsxref("JSON.parse()")}} analyse (<em>parse</em>) une chaîne de caractères en JSON, cette chaîne doit être du JSON valide et une exception sera levée si la syntaxe est incorrecte.</p>
-
-<h2 id="Exemples">Exemples</h2>
-
-<h3 id="JSON.parse()_n'accepte_pas_les_virgules_en_fin_de_tableau"><code>JSON.parse()</code> n'accepte pas les virgules en fin de tableau</h3>
-
-<p>Les deux lignes qui suivent déclencheront une exception <code>SyntaxError</code> :</p>
-
-<pre class="brush: js example-bad">JSON.parse('[1, 2, 3, 4, ]');
+{{jsSidebar("Errors")}}
+
+## Message
+
+    SyntaxError: JSON.parse: unterminated string literal
+    SyntaxError: JSON.parse: bad control character in string literal
+    SyntaxError: JSON.parse: bad character in string literal
+    SyntaxError: JSON.parse: bad Unicode escape
+    SyntaxError: JSON.parse: bad escape character
+    SyntaxError: JSON.parse: unterminated string
+    SyntaxError: JSON.parse: no number after minus sign
+    SyntaxError: JSON.parse: unexpected non-digit
+    SyntaxError: JSON.parse: missing digits after decimal point
+    SyntaxError: JSON.parse: unterminated fractional number
+    SyntaxError: JSON.parse: missing digits after exponent indicator
+    SyntaxError: JSON.parse: missing digits after exponent sign
+    SyntaxError: JSON.parse: exponent part is missing a number
+    SyntaxError: JSON.parse: unexpected end of data
+    SyntaxError: JSON.parse: unexpected keyword
+    SyntaxError: JSON.parse: unexpected character
+    SyntaxError: JSON.parse: end of data while reading object contents
+    SyntaxError: JSON.parse: expected property name or '}'
+    SyntaxError: JSON.parse: end of data when ',' or ']' was expected
+    SyntaxError: JSON.parse: expected ',' or ']' after array element
+    SyntaxError: JSON.parse: end of data when property name was expected
+    SyntaxError: JSON.parse: expected double-quoted property name
+    SyntaxError: JSON.parse: end of data after property name when ':' was expected
+    SyntaxError: JSON.parse: expected ':' after property name in object
+    SyntaxError: JSON.parse: end of data after property value in object
+    SyntaxError: JSON.parse: expected ',' or '}' after property value in object
+    SyntaxError: JSON.parse: expected ',' or '}' after property-value pair in object literal
+    SyntaxError: JSON.parse: property names must be double-quoted strings
+    SyntaxError: JSON.parse: expected property name or '}'
+    SyntaxError: JSON.parse: unexpected character
+    SyntaxError: JSON.parse: unexpected non-whitespace character after JSON data
+    SyntaxError: JSON.parse Error: Invalid character at position {0} (Edge)
+
+## Type d'erreur
+
+{{jsxref("SyntaxError")}}
+
+## Quel est le problème ?
+
+Lorsque la méthode {{jsxref("JSON.parse()")}} analyse (_parse_) une chaîne de caractères en JSON, cette chaîne doit être du JSON valide et une exception sera levée si la syntaxe est incorrecte.
+
+## Exemples
+
+### `JSON.parse()` n'accepte pas les virgules en fin de tableau
+
+Les deux lignes qui suivent déclencheront une exception `SyntaxError` :
+
+```js example-bad
+JSON.parse('[1, 2, 3, 4, ]');
 JSON.parse('{"foo" : 1, }');
 // SyntaxError JSON.parse: unexpected character
 // at line 1 column 14 of the JSON data
-</pre>
+```
 
-<p>Pour que la méthode puisse analyser le JSON correctement, on évitera les virgules en fin de tableau :</p>
+Pour que la méthode puisse analyser le JSON correctement, on évitera les virgules en fin de tableau :
 
-<pre class="brush: js example-good">JSON.parse('[1, 2, 3, 4 ]');
-JSON.parse('{"foo" : 1 }');</pre>
+```js example-good
+JSON.parse('[1, 2, 3, 4 ]');
+JSON.parse('{"foo" : 1 }');
+```
 
-<h3 id="Les_noms_des_propriétés_doivent_être_entre_double_quotes">Les noms des propriétés doivent être entre double quotes</h3>
+### Les noms des propriétés doivent être entre double quotes
 
-<p>On ne peut pas utiliser de quotes simples pour indiquer le nom d'une propriété (ex. <code>'toto'</code>).</p>
+On ne peut pas utiliser de quotes simples pour indiquer le nom d'une propriété (ex. `'toto'`).
 
-<pre class="brush: js example-bad">JSON.parse("{'toto' : 1 }");
+```js example-bad
+JSON.parse("{'toto' : 1 }");
 // SyntaxError: JSON.parse: expected property name or '}'
-// at line 1 column 2 of the JSON data</pre>
+// at line 1 column 2 of the JSON data
+```
 
-<p>À la place, on écrira <code>"toto"</code> :</p>
+À la place, on écrira `"toto"` :
 
-<pre class="brush: js example-good">JSON.parse('{"toto" : 1 }');</pre>
+```js example-good
+JSON.parse('{"toto" : 1 }');
+```
 
-<h3 id="Zéros_en_début_de_nombres_et_points_décimaux">Zéros en début de nombres et points décimaux</h3>
+### Zéros en début de nombres et points décimaux
 
-<p>On ne peut pas utiliser de zéros en début de nombre (ex. 01). Par ailleurs, les nombres décimaux doivent avoir une partie décimale, on ne peut pas terminer un nombre par un point.</p>
+On ne peut pas utiliser de zéros en début de nombre (ex. 01). Par ailleurs, les nombres décimaux doivent avoir une partie décimale, on ne peut pas terminer un nombre par un point.
 
-<pre class="brush: js example-bad">JSON.parse('{"toto" : 01 }');
+```js example-bad
+JSON.parse('{"toto" : 01 }');
 // SyntaxError: JSON.parse: expected ',' or '}' after property value
 // in object at line 1 column 2 of the JSON data
 
 JSON.parse('{"toto" : 1. }');
 // SyntaxError: JSON.parse: unterminated fractional number
 // at line 1 column 2 of the JSON data
-</pre>
+```
 
-<p>Pour que cela fonctionne, on écrira simplement 1 sans 0 devant et au moins un chiffre après le séparateur décimal :</p>
+Pour que cela fonctionne, on écrira simplement 1 sans 0 devant et au moins un chiffre après le séparateur décimal :
 
-<pre class="brush: js example-good">JSON.parse('{"toto" : 1 }');
+```js example-good
+JSON.parse('{"toto" : 1 }');
 JSON.parse('{"toto" : 1.0 }');
-</pre>
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("JSON")}}</li>
- <li>{{jsxref("JSON.parse()")}}</li>
- <li>{{jsxref("JSON.stringify()")}}</li>
-</ul>
+- {{jsxref("JSON")}}
+- {{jsxref("JSON.parse()")}}
+- {{jsxref("JSON.stringify()")}}
diff --git a/files/fr/web/javascript/reference/errors/malformed_formal_parameter/index.md b/files/fr/web/javascript/reference/errors/malformed_formal_parameter/index.md
index a06f5cc5c9..bc5d9e5ba0 100644
--- a/files/fr/web/javascript/reference/errors/malformed_formal_parameter/index.md
+++ b/files/fr/web/javascript/reference/errors/malformed_formal_parameter/index.md
@@ -8,33 +8,33 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/Malformed_formal_parameter
 original_slug: Web/JavaScript/Reference/Erreurs/Malformed_formal_parameter
 ---
-<div>{{jsSidebar("Errors")}}</div>
+{{jsSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">SyntaxError: Expected {x} (Edge)
-SyntaxError: malformed formal parameter (Firefox)
-</pre>
+    SyntaxError: Expected {x} (Edge)
+    SyntaxError: malformed formal parameter (Firefox)
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>{{jsxref("SyntaxError")}}</p>
+{{jsxref("SyntaxError")}}
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p>La méthode {{jsxref("Function()")}} a été utilisée avec au moins deux arguments. Le dernier argument correspond au code source de la nouvelle fonction qui est créée. Les autres arguments sont la liste des arguments passés à la fonction.</p>
+La méthode {{jsxref("Function()")}} a été utilisée avec au moins deux arguments. Le dernier argument correspond au code source de la nouvelle fonction qui est créée. Les autres arguments sont la liste des arguments passés à la fonction.
 
-<p>C'est cette liste d'arguments qui est, pour une certaine raison, invalide. Il s'agit peut-être d'un mot-clé (<code>if</code> ou <code>var</code> par exemple) utilisé comme un nom d'argument, ou d'un signe de ponctuation mal placé. Il peut également s'agir d'une valeur invalide comme un nombre ou un objet.</p>
+C'est cette liste d'arguments qui est, pour une certaine raison, invalide. Il s'agit peut-être d'un mot-clé (`if` ou `var` par exemple) utilisé comme un nom d'argument, ou d'un signe de ponctuation mal placé. Il peut également s'agir d'une valeur invalide comme un nombre ou un objet.
 
-<h2 id="OK_mais_pourquoi_cette_formulation_étrange">OK mais pourquoi cette formulation étrange ?</h2>
+## OK mais pourquoi cette formulation étrange ?
 
-<p>En effet, "Formal parameter" est une manière étrange de dire  « argument de fonction ». Le mot "malformed" (malformé) est utilisé car les ingénieurs travaillant sur Firefox engineers apprécient énormément les romans gothiques du XIXe.</p>
+En effet, "Formal parameter" est une manière étrange de dire  « argument de fonction ». Le mot "malformed" (malformé) est utilisé car les ingénieurs travaillant sur Firefox engineers apprécient énormément les romans gothiques du XIXe.
 
-<h2 id="Examples">Examples</h2>
+## Examples
 
-<h3 id="Exemples_invalides">Exemples invalides</h3>
+### Exemples invalides
 
-<pre class="brush: js example-bad">var f = Function("x y", "return x + y;");
+```js example-bad
+var f = Function("x y", "return x + y;");
 // SyntaxError (virgule manquante)
 
 var f = Function("x,", "return x;");
@@ -42,11 +42,12 @@ var f = Function("x,", "return x;");
 
 var f = Function(37, "console.log('OK')");
 // SyntaxError (des nombres ne peuvent être des noms)
-</pre>
+```
 
-<h3 id="Exemples_valides">Exemples valides</h3>
+### Exemples valides
 
-<pre class="brush: js example-good"> // Ponctuation correcte
+```js example-good
+ // Ponctuation correcte
 var f = Function("x, y", "return x + y;");
 
 var f = Function("x", "return x;");
@@ -54,12 +55,10 @@ var f = Function("x", "return x;");
 // Voici une alternative plus rapide
 // si vous pouvez éviter Function
 var f = function (x) { return x; };
-</pre>
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("Function()")}}</li>
- <li><a href="/fr/docs/Web/JavaScript/Guide/Fonctions">Le chapitre du Guide JavaScript sur les fonctions</a></li>
- <li><a href="https://www.gutenberg.org/ebooks/84"><em>Frankenstein</em> par Mary Wollstonecraft Shelley</a> ("<em>Cursed (although I curse myself) be the hands that formed you! You have made me wretched beyond expression. You have left me no power to consider whether I am just to you or not. Begone! Relieve me from the sight of your detested form.</em>")</li>
-</ul>
+- {{jsxref("Function()")}}
+- [Le chapitre du Guide JavaScript sur les fonctions](/fr/docs/Web/JavaScript/Guide/Fonctions)
+- [_Frankenstein_ par Mary Wollstonecraft Shelley](https://www.gutenberg.org/ebooks/84) ("_Cursed (although I curse myself) be the hands that formed you! You have made me wretched beyond expression. You have left me no power to consider whether I am just to you or not. Begone! Relieve me from the sight of your detested form._")
diff --git a/files/fr/web/javascript/reference/errors/malformed_uri/index.md b/files/fr/web/javascript/reference/errors/malformed_uri/index.md
index dfe037e1aa..3a4c4f4d08 100644
--- a/files/fr/web/javascript/reference/errors/malformed_uri/index.md
+++ b/files/fr/web/javascript/reference/errors/malformed_uri/index.md
@@ -8,60 +8,63 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/Malformed_URI
 original_slug: Web/JavaScript/Reference/Erreurs/Malformed_URI
 ---
-<div>{{jsSidebar("Errors")}}</div>
+{{jsSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">URIError: The URI to be encoded contains invalid character (Edge)
-URIError: malformed URI sequence (Firefox)
-URIError: URI malformed (Chrome)
-</pre>
+    URIError: The URI to be encoded contains invalid character (Edge)
+    URIError: malformed URI sequence (Firefox)
+    URIError: URI malformed (Chrome)
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>{{jsxref("URIError")}}</p>
+{{jsxref("URIError")}}
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p>Il y a eu une erreur lors de l'encodage ou du décodage de l'URI. Un argument fourni à {{jsxref("decodeURI")}}, {{jsxref("encodeURI")}}, {{jsxref("encodeURIComponent")}} ou à {{jsxref("decodeURIComponent")}} n'était pas valide et la fonction concernée n'a pas pu encoder ou décoder la valeur correctement.</p>
+Il y a eu une erreur lors de l'encodage ou du décodage de l'URI. Un argument fourni à {{jsxref("decodeURI")}}, {{jsxref("encodeURI")}}, {{jsxref("encodeURIComponent")}} ou à {{jsxref("decodeURIComponent")}} n'était pas valide et la fonction concernée n'a pas pu encoder ou décoder la valeur correctement.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Encodage">Encodage</h3>
+### Encodage
 
-<p>L'encodage permet de remplacer certains caractères par une, deux, trois voire quatre séquences d'échappement qui représente l'encodage UTF-8 du caractère. Une exception {{jsxref("URIError")}} sera levée si on tente d'encoder un caractère <em>surrogate</em> qui ne fait pas partie d'une paire de codets :</p>
+L'encodage permet de remplacer certains caractères par une, deux, trois voire quatre séquences d'échappement qui représente l'encodage UTF-8 du caractère. Une exception {{jsxref("URIError")}} sera levée si on tente d'encoder un caractère _surrogate_ qui ne fait pas partie d'une paire de codets :
 
-<pre class="brush: js example-bad">encodeURI('\uD800');
+```js example-bad
+encodeURI('\uD800');
 // "URIError: malformed URI sequence"
 
 encodeURI('\uDFFF');
 // "URIError: malformed URI sequence"
-</pre>
+```
 
-<p>En revanche, si on dispose de la paire de codets :</p>
+En revanche, si on dispose de la paire de codets :
 
-<pre class="brush: js example-good">encodeURI('\uD800\uDFFF');
-// "%F0%90%8F%BF"</pre>
+```js example-good
+encodeURI('\uD800\uDFFF');
+// "%F0%90%8F%BF"
+```
 
-<h3 id="Décodage">Décodage</h3>
+### Décodage
 
-<p>Le décodage permet de remplacer chaque séquence d'échappement dans le composant encodé par le caractère qu'elle représente. S'il n'existe aucun caractère correspondant, une exception sera déclenchée :</p>
+Le décodage permet de remplacer chaque séquence d'échappement dans le composant encodé par le caractère qu'elle représente. S'il n'existe aucun caractère correspondant, une exception sera déclenchée :
 
-<pre class="brush: js example-bad">decodeURIComponent('%E0%A4%A');
+```js example-bad
+decodeURIComponent('%E0%A4%A');
 // "URIError: malformed URI sequence"
-</pre>
+```
 
-<p>Avec la valeur d'entrée correcte, on a généralement quelque chose qui ressemble à :</p>
+Avec la valeur d'entrée correcte, on a généralement quelque chose qui ressemble à :
 
-<pre class="brush: js example-good">decodeURIComponent('JavaScript_%D1%88%D0%B5%D0%BB%D0%BB%D1%8B');
-// "JavaScript_шеллы"</pre>
+```js example-good
+decodeURIComponent('JavaScript_%D1%88%D0%B5%D0%BB%D0%BB%D1%8B');
+// "JavaScript_шеллы"
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("URIError")}}</li>
- <li>{{jsxref("decodeURI")}}</li>
- <li>{{jsxref("encodeURI")}}</li>
- <li>{{jsxref("encodeURIComponent")}}</li>
- <li>{{jsxref("decodeURIComponent")}}</li>
-</ul>
+- {{jsxref("URIError")}}
+- {{jsxref("decodeURI")}}
+- {{jsxref("encodeURI")}}
+- {{jsxref("encodeURIComponent")}}
+- {{jsxref("decodeURIComponent")}}
diff --git a/files/fr/web/javascript/reference/errors/missing_bracket_after_list/index.md b/files/fr/web/javascript/reference/errors/missing_bracket_after_list/index.md
index c51fef7551..1aa8577010 100644
--- a/files/fr/web/javascript/reference/errors/missing_bracket_after_list/index.md
+++ b/files/fr/web/javascript/reference/errors/missing_bracket_after_list/index.md
@@ -9,26 +9,26 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/Missing_bracket_after_list
 original_slug: Web/JavaScript/Reference/Erreurs/Missing_bracket_after_list
 ---
-<div>{{jsSidebar("Errors")}}</div>
+{{jsSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">SyntaxError: missing ] after element list
-</pre>
+    SyntaxError: missing ] after element list
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>{{jsxref("SyntaxError")}}.</p>
+{{jsxref("SyntaxError")}}.
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p>Il y a une erreur dans le littéral de tableau qui est uilisé. Il manque un crochet fermant ("<code>]</code>") ou une virgule qui sépare les éléments.</p>
+Il y a une erreur dans le littéral de tableau qui est uilisé. Il manque un crochet fermant ("`]`") ou une virgule qui sépare les éléments.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Littéraux_de_tableaux_incomplets">Littéraux de tableaux incomplets</h3>
+### Littéraux de tableaux incomplets
 
-<pre class="brush: js example-bad">var liste = [1, 2,
+```js example-bad
+var liste = [1, 2,
 
 var instruments = [
   "Ukulele",
@@ -37,11 +37,12 @@ var instruments = [
 };
 
 var data = [{toto: "truc"} {titi: "bidule"}];
-</pre>
+```
 
-<p>Les versions correctes seraient :</p>
+Les versions correctes seraient :
 
-<pre class="brush: js example-good">var liste = [1, 2];
+```js example-good
+var liste = [1, 2];
 
 var instruments = [
  "Ukulele",
@@ -49,10 +50,9 @@ var instruments = [
  "Piano"
 ];
 
-var data = [{toto: "truc"}, {titi: "bidule"}];</pre>
+var data = [{toto: "truc"}, {titi: "bidule"}];
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("Array")}}</li>
-</ul>
+- {{jsxref("Array")}}
diff --git a/files/fr/web/javascript/reference/errors/missing_colon_after_property_id/index.md b/files/fr/web/javascript/reference/errors/missing_colon_after_property_id/index.md
index 9e6595726c..d5170353ac 100644
--- a/files/fr/web/javascript/reference/errors/missing_colon_after_property_id/index.md
+++ b/files/fr/web/javascript/reference/errors/missing_colon_after_property_id/index.md
@@ -8,71 +8,77 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/Missing_colon_after_property_id
 original_slug: Web/JavaScript/Reference/Erreurs/Missing_colon_after_property_id
 ---
-<div>{{jsSidebar("Errors")}}</div>
+{{jsSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">SyntaxError: Expected ':' (Edge)
-SyntaxError: missing : after property id (Firefox)
-</pre>
+    SyntaxError: Expected ':' (Edge)
+    SyntaxError: missing : after property id (Firefox)
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>{{jsxref("SyntaxError")}}</p>
+{{jsxref("SyntaxError")}}
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p>Lorsqu'on crée un objet en utilisant un <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Initialisateur_objet">initialisateur d'objet</a>, il faut utiliser un deux-points ( : ) afin de séparer les clés des valeurs pour les propriétés de l'objet.</p>
+Lorsqu'on crée un objet en utilisant un [initialisateur d'objet](/fr/docs/Web/JavaScript/Reference/Opérateurs/Initialisateur_objet), il faut utiliser un deux-points ( : ) afin de séparer les clés des valeurs pour les propriétés de l'objet.
 
-<pre class="brush: js">var obj = { cleDeLaPropriete: 'valeur' };
-</pre>
+```js
+var obj = { cleDeLaPropriete: 'valeur' };
+```
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Deux-points_et_signe_égal">Deux-points et signe égal</h3>
+### Deux-points et signe égal
 
-<p>Le code qui suit provoquera une erreur car on utilise un signe égal (=) à la place du deux-points.</p>
+Le code qui suit provoquera une erreur car on utilise un signe égal (=) à la place du deux-points.
 
-<pre class="brush: js example-bad">var obj = { cleDeLaPropriete = 'valeur' };
+```js example-bad
+var obj = { cleDeLaPropriete = 'valeur' };
 // SyntaxError: missing : after property id
-</pre>
+```
 
-<p>Pour corriger ce problème, on peut utiliser un deux-points ou bien affecter la nouvelle propriété après avoir créé l'objet :</p>
+Pour corriger ce problème, on peut utiliser un deux-points ou bien affecter la nouvelle propriété après avoir créé l'objet :
 
-<pre class="brush: js example-good">var obj = { cleDeLaPropriete: 'valeur' };
+```js example-good
+var obj = { cleDeLaPropriete: 'valeur' };
 
 // ou encore :
 
 var obj = { };
 obj['cleDeLaPropriete'] = 'valeur';
-</pre>
+```
 
-<h3 id="Propriétés_vides">Propriétés vides</h3>
+### Propriétés vides
 
-<p>On ne peut pas créer de propriétés vides de cette façon :</p>
+On ne peut pas créer de propriétés vides de cette façon :
 
-<pre class="brush: js example-bad">var obj = { cleDeLaPropriete; };
+```js example-bad
+var obj = { cleDeLaPropriete; };
 // SyntaxError: missing : after property id
-</pre>
+```
 
-<p>Si vous souhaitez définir une propriété sans valeur, vous pouvez utiliser le mot-clé {{jsxref("null")}} :</p>
+Si vous souhaitez définir une propriété sans valeur, vous pouvez utiliser le mot-clé {{jsxref("null")}} :
 
-<pre class="brush: js example-good">var obj = { cleDeLaPropriete: null };</pre>
+```js example-good
+var obj = { cleDeLaPropriete: null };
+```
 
-<h3 id="Propriétés_calculées">Propriétés calculées</h3>
+### Propriétés calculées
 
-<p>Si vous souhaitez créer une clé de propriété à partir d'une expression, il faudra utiliser des crochets pour encadrer l'expression (sinon le nom de la propriété ne pourra pas être calculé) :</p>
+Si vous souhaitez créer une clé de propriété à partir d'une expression, il faudra utiliser des crochets pour encadrer l'expression (sinon le nom de la propriété ne pourra pas être calculé) :
 
-<pre class="brush: js example-bad">var obj = { 'tr'+'uc': 'toto' };
+```js example-bad
+var obj = { 'tr'+'uc': 'toto' };
 // SyntaxError: missing : after property id
-</pre>
+```
 
-<p>Pour corriger l'erreur, il faudra placer l'expression entre crochets :</p>
+Pour corriger l'erreur, il faudra placer l'expression entre crochets :
 
-<pre class="brush: js example-good">var obj = { ['tr'+'uc']: 'toto' };</pre>
+```js example-good
+var obj = { ['tr'+'uc']: 'toto' };
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Initialisateur_objet">Initialisateur d'objet</a></li>
-</ul>
+- [Initialisateur d'objet](/fr/docs/Web/JavaScript/Reference/Opérateurs/Initialisateur_objet)
diff --git a/files/fr/web/javascript/reference/errors/missing_curly_after_function_body/index.md b/files/fr/web/javascript/reference/errors/missing_curly_after_function_body/index.md
index c8ee04b3c8..89f612ede3 100644
--- a/files/fr/web/javascript/reference/errors/missing_curly_after_function_body/index.md
+++ b/files/fr/web/javascript/reference/errors/missing_curly_after_function_body/index.md
@@ -8,61 +8,64 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/Missing_curly_after_function_body
 original_slug: Web/JavaScript/Reference/Erreurs/Missing_curly_after_function_body
 ---
-<div>{{jsSidebar("Errors")}}</div>
+{{jsSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">SyntaxError: Expected '}' (Edge)
-SyntaxError: missing } after function body (Firefox)
-</pre>
+    SyntaxError: Expected '}' (Edge)
+    SyntaxError: missing } after function body (Firefox)
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>{{jsxref("SyntaxError")}}</p>
+{{jsxref("SyntaxError")}}
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p>Il y a une erreur de syntaxe près d'une création de fonction. Dans ce cas, il est préférable de vérifier que les parenthèses et accolades fermantes sont bien présentes et dans le bon ordre. Indenter et formater le code peut vous aider à vous y retrouver parmi les éventuels différents niveaux d'imbrication.</p>
+Il y a une erreur de syntaxe près d'une création de fonction. Dans ce cas, il est préférable de vérifier que les parenthèses et accolades fermantes sont bien présentes et dans le bon ordre. Indenter et formater le code peut vous aider à vous y retrouver parmi les éventuels différents niveaux d'imbrication.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Oubli_d'une_accolade_fermante">Oubli d'une accolade fermante</h3>
+### Oubli d'une accolade fermante
 
-<p>La plupart du temps, il s'agit d'une accolade manquante dans le code de la fonction :</p>
+La plupart du temps, il s'agit d'une accolade manquante dans le code de la fonction :
 
-<pre class="brush: js example-bad">var charge = function() {
+```js example-bad
+var charge = function() {
   if (soleil) {
     utiliserPanneauSolaire();
   } else {
     utiliserVelo();
 };
-</pre>
+```
 
-<p>La forme correcte est :</p>
+La forme correcte est :
 
-<pre class="brush: js example-good">var charge = function() {
+```js example-good
+var charge = function() {
   if (soleil) {
     utiliserPanneauSolaire();
   } else {
     utiliserVelo();
   }
-};</pre>
+};
+```
 
-<p>Une erreur de ce type peut être moins visible lorsqu'on utilise les fonctions qui sont appelées immédiatement, <a href="/fr/docs/Web/JavaScript/Closures">les fermetures</a> ou d'autres formes qui utilisent de nombreuses parenthèses et/ou accolades comme par exemple :</p>
+Une erreur de ce type peut être moins visible lorsqu'on utilise les fonctions qui sont appelées immédiatement, [les fermetures](/fr/docs/Web/JavaScript/Closures) ou d'autres formes qui utilisent de nombreuses parenthèses et/ou accolades comme par exemple :
 
-<pre class="brush: js example-bad">(function() { if (true) { return false; } );
-</pre>
+```js example-bad
+(function() { if (true) { return false; } );
+```
 
-<p>Généralement, mettre en forme et vérifier l'indentation permet de repérer ces erreurs.</p>
+Généralement, mettre en forme et vérifier l'indentation permet de repérer ces erreurs.
 
-<pre class="brush: js example-good">(function() {
+```js example-good
+(function() {
   if (true) {
     return false;
   }
-});</pre>
+});
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li><a href="/fr/docs/Web/JavaScript/Guide/Fonctions">Les fonctions</a></li>
-</ul>
+- [Les fonctions](/fr/docs/Web/JavaScript/Guide/Fonctions)
diff --git a/files/fr/web/javascript/reference/errors/missing_curly_after_property_list/index.md b/files/fr/web/javascript/reference/errors/missing_curly_after_property_list/index.md
index f845a673c6..720e6c5cd4 100644
--- a/files/fr/web/javascript/reference/errors/missing_curly_after_property_list/index.md
+++ b/files/fr/web/javascript/reference/errors/missing_curly_after_property_list/index.md
@@ -8,46 +8,45 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/Missing_curly_after_property_list
 original_slug: Web/JavaScript/Reference/Erreurs/Missing_curly_after_property_list
 ---
-<div>{{jsSidebar("Errors")}}</div>
+{{jsSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">SyntaxError: Expected '}' (Edge)
-SyntaxError: missing } after property list (Firefox)
-</pre>
+    SyntaxError: Expected '}' (Edge)
+    SyntaxError: missing } after property list (Firefox)
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>{{jsxref("SyntaxError")}}</p>
+{{jsxref("SyntaxError")}}
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p>Il y a une coquille dans le <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Initialisateur_objet">littéral objet</a> utilisé. Cela peut être dû à une accolade manquante ou à une virgule manquante. Il est aussi utile de vérifier que les accolades et les parenthèses sont bien ordonnées. Pour ce type d'erreur, une bonne indentation permet de repérer plus facilement la coquille parmi les lignes de code.</p>
+Il y a une coquille dans le [littéral objet](/fr/docs/Web/JavaScript/Reference/Opérateurs/Initialisateur_objet) utilisé. Cela peut être dû à une accolade manquante ou à une virgule manquante. Il est aussi utile de vérifier que les accolades et les parenthèses sont bien ordonnées. Pour ce type d'erreur, une bonne indentation permet de repérer plus facilement la coquille parmi les lignes de code.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Une_virgule_oubliée">Une virgule oubliée</h3>
+### Une virgule oubliée
 
-<p>Il arrive parfois que ce soit une virgule absente dans le littéral qui entraîne cette erreur :</p>
+Il arrive parfois que ce soit une virgule absente dans le littéral qui entraîne cette erreur :
 
-<pre class="brush: js example-bad">var obj = {
+```js example-bad
+var obj = {
   a: 1,
   b: { maProp: 2 }
   c: 3
 };
-</pre>
+```
 
-<p>La version correcte correspondante est :</p>
+La version correcte correspondante est :
 
-<pre class="brush: js example-good">var obj = {
+```js example-good
+var obj = {
   a: 1,
   b: { maProp: 2 },
   c: 3
 };
-</pre>
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Initialisateur_objet">Les littéraux objets</a></li>
-</ul>
+- [Les littéraux objets](/fr/docs/Web/JavaScript/Reference/Opérateurs/Initialisateur_objet)
diff --git a/files/fr/web/javascript/reference/errors/missing_formal_parameter/index.md b/files/fr/web/javascript/reference/errors/missing_formal_parameter/index.md
index e5956f0f04..635c238646 100644
--- a/files/fr/web/javascript/reference/errors/missing_formal_parameter/index.md
+++ b/files/fr/web/javascript/reference/errors/missing_formal_parameter/index.md
@@ -8,28 +8,28 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/Missing_formal_parameter
 original_slug: Web/JavaScript/Reference/Erreurs/Missing_formal_parameter
 ---
-<div>{{jsSidebar("Errors")}}</div>
+{{jsSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">SyntaxError: missing formal parameter (Firefox)
-</pre>
+    SyntaxError: missing formal parameter (Firefox)
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>{{jsxref("SyntaxError")}}</p>
+{{jsxref("SyntaxError")}}
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p>« <em>Formal parameter</em> » (ou « paramètre formel ») est une façon de désigner un paramètre d'une fonction. Ici, certains des paramètres de la fonction sont invalides. Lorsqu'on déclare une fonction, les paramètres doivent être des identifiants et non des valeurs (telles que des nombres, des chaînes de caractères ou des objets). La déclaration et l'appel de la fonction forment deux étapes distinctes. Les déclarations utilisent uniquement des identifiants comme paramètres. Lorsqu'on appelle une fonction, on fournit les valeurs à utiliser.</p>
+« _Formal parameter_ » (ou « paramètre formel ») est une façon de désigner un paramètre d'une fonction. Ici, certains des paramètres de la fonction sont invalides. Lorsqu'on déclare une fonction, les paramètres doivent être des identifiants et non des valeurs (telles que des nombres, des chaînes de caractères ou des objets). La déclaration et l'appel de la fonction forment deux étapes distinctes. Les déclarations utilisent uniquement des identifiants comme paramètres. Lorsqu'on appelle une fonction, on fournit les valeurs à utiliser.
 
-<p>En JavaScript, les identifiants peuvent contenir n'importe quel caractère alphanumérique (ou "$" or "_") et ne doivent pas commencer par un nombre. Un identifiant n'est pas une chaîne de caractères, une chaîne de caractères est une donnée alors qu'un identifiant fait partie du code.</p>
+En JavaScript, les identifiants peuvent contenir n'importe quel caractère alphanumérique (ou "$" or "\_") et ne doivent pas commencer par un nombre. Un identifiant n'est pas une chaîne de caractères, une chaîne de caractères est une donnée alors qu'un identifiant fait partie du code.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<p>Lorsqu'on définit une fonction, les paramètres doivent être des identifiants. Aucune des fonctions suivantes ne répond à ce critère (elles lèvent donc toutes une erreur) car elles utilisent des valeurs :</p>
+Lorsqu'on définit une fonction, les paramètres doivent être des identifiants. Aucune des fonctions suivantes ne répond à ce critère (elles lèvent donc toutes une erreur) car elles utilisent des valeurs :
 
-<pre class="brush: js example-bad highlight:[1,6,11]">function carre(3) {
+```js example-bad
+function carre(3) {
   return nombre * nombre;
 };
 // SyntaxError: missing formal parameter
@@ -43,11 +43,12 @@ function log({ obj: "value"}) {
   console.log(arg)
 };
 // SyntaxError: missing formal parameter
-</pre>
+```
 
-<p>Il faut utiliser des identifiants lors de la déclaration des fonctions :</p>
+Il faut utiliser des identifiants lors de la déclaration des fonctions :
 
-<pre class="brush: js example-good highlight:[1,5,9]">function carre(nombre) {
+```js example-good
+function carre(nombre) {
   return nombre * nombre;
 };
 
@@ -57,22 +58,20 @@ function salutation(salut) {
 
 function log(arg) {
   console.log(arg)
-};</pre>
+};
+```
 
-<p>Ensuite, on pourra appeler ces fonctions avec les arguments voulus :</p>
+Ensuite, on pourra appeler ces fonctions avec les arguments voulus :
 
-<pre class="brush: js">carre(2); // 4
+```js
+carre(2); // 4
 salutation("Coucou"); // "Coucou"
 log({obj: "value"});  // Object { obj: "value" }
-</pre>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>Les autres erreurs relatives aux paramètres formels :
-  <ul>
-   <li><a href="/fr/docs/Web/JavaScript/Reference/Errors/Malformed_formal_parameter">SyntaxError: Malformed formal parameter</a></li>
-   <li><a href="/fr/docs/Web/JavaScript/Reference/Errors/Redeclared_parameter">SyntaxError: redeclaration of formal parameter "x"</a></li>
-  </ul>
- </li>
-</ul>
+```
+
+## Voir aussi
+
+- Les autres erreurs relatives aux paramètres formels :
+
+  - [SyntaxError: Malformed formal parameter](/fr/docs/Web/JavaScript/Reference/Errors/Malformed_formal_parameter)
+  - [SyntaxError: redeclaration of formal parameter "x"](/fr/docs/Web/JavaScript/Reference/Errors/Redeclared_parameter)
diff --git a/files/fr/web/javascript/reference/errors/missing_initializer_in_const/index.md b/files/fr/web/javascript/reference/errors/missing_initializer_in_const/index.md
index e368d0982c..5110b755a0 100644
--- a/files/fr/web/javascript/reference/errors/missing_initializer_in_const/index.md
+++ b/files/fr/web/javascript/reference/errors/missing_initializer_in_const/index.md
@@ -8,53 +8,55 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/Missing_initializer_in_const
 original_slug: Web/JavaScript/Reference/Erreurs/Missing_initializer_in_const
 ---
-<div>{{jsSidebar("Errors")}}</div>
+{{jsSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">SyntaxError: Const must be initalized (Edge)
-SyntaxError: missing = in const declaration (Firefox)
-SyntaxError: Missing initializer in const declaration (Chrome)
-</pre>
+    SyntaxError: Const must be initalized (Edge)
+    SyntaxError: missing = in const declaration (Firefox)
+    SyntaxError: Missing initializer in const declaration (Chrome)
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>{{jsxref("SyntaxError")}}</p>
+{{jsxref("SyntaxError")}}
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p>Une constante est une valeur qui ne peut pas être modifiée par le programme pendant l'exécution. Elle ne peut pas être changée avec une réaffectation ou une redéclaration. En JavaScript, les constantes sont déclarées grâce au mot-clé <code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/const">const</a></code>. Il est également nécessaire de fournir une valeur d'initialisation dans l'instruction où on déclare la constante (ce qui est logique vu qu'on ne peut pas la modifier ensuite).</p>
+Une constante est une valeur qui ne peut pas être modifiée par le programme pendant l'exécution. Elle ne peut pas être changée avec une réaffectation ou une redéclaration. En JavaScript, les constantes sont déclarées grâce au mot-clé [`const`](/fr/docs/Web/JavaScript/Reference/Instructions/const). Il est également nécessaire de fournir une valeur d'initialisation dans l'instruction où on déclare la constante (ce qui est logique vu qu'on ne peut pas la modifier ensuite).
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Valeur_d'initialisation_manquante">Valeur d'initialisation manquante</h3>
+### Valeur d'initialisation manquante
 
-<p>À la différence de <code>var</code> ou de <code>let</code>, il est nécessaire d'indiquer une valeur lors de la déclaration. Si aucune valeur n'est indiquée, une exception sera levée :</p>
+À la différence de `var` ou de `let`, il est nécessaire d'indiquer une valeur lors de la déclaration. Si aucune valeur n'est indiquée, une exception sera levée :
 
-<pre class="brush: js example-bad">const COLUMNS;
-// SyntaxError: missing = in const declaration</pre>
+```js example-bad
+const COLUMNS;
+// SyntaxError: missing = in const declaration
+```
 
-<h3 id="Résoudre_le_problème">Résoudre le problème</h3>
+### Résoudre le problème
 
-<p>On a le choix entre plusieurs options pour résoudre ce problème. Il faut comprendre le rôle de la constante en question.</p>
+On a le choix entre plusieurs options pour résoudre ce problème. Il faut comprendre le rôle de la constante en question.
 
-<h4 id="Ajouter_une_valeur_constante">Ajouter une valeur constante</h4>
+#### Ajouter une valeur constante
 
-<p>On peut indiquer la valeur de la constante dans la même instruction :</p>
+On peut indiquer la valeur de la constante dans la même instruction :
 
-<pre class="brush: js example-good">const COLONNES = 80;</pre>
+```js example-good
+const COLONNES = 80;
+```
 
-<h4 id="const_let_ou_var"><code>const</code>, <code>let</code> ou <code>var</code> ?</h4>
+#### `const`, `let` ou `var` ?
 
-<p><code>const</code> ne doit pas être utilisé si on ne souhaite pas déclarer de constante. Peut-être qu'on souhaite simplement déclarer une variable avec une portée de bloc grâce à <code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/let">let</a></code> ou une variable globale avec <code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/var">var</a></code>. Ces deux instructions ne nécessitent pas de valeur initiale.</p>
+`const` ne doit pas être utilisé si on ne souhaite pas déclarer de constante. Peut-être qu'on souhaite simplement déclarer une variable avec une portée de bloc grâce à [`let`](/fr/docs/Web/JavaScript/Reference/Instructions/let) ou une variable globale avec [`var`](/fr/docs/Web/JavaScript/Reference/Instructions/var). Ces deux instructions ne nécessitent pas de valeur initiale.
 
-<pre class="brush: js example-good">let colonnes;
-</pre>
+```js example-good
+let colonnes;
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li><code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/const">const</a></code></li>
- <li><code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/let">let</a></code></li>
- <li><code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/var">var</a></code></li>
-</ul>
+- [`const`](/fr/docs/Web/JavaScript/Reference/Instructions/const)
+- [`let`](/fr/docs/Web/JavaScript/Reference/Instructions/let)
+- [`var`](/fr/docs/Web/JavaScript/Reference/Instructions/var)
diff --git a/files/fr/web/javascript/reference/errors/missing_name_after_dot_operator/index.md b/files/fr/web/javascript/reference/errors/missing_name_after_dot_operator/index.md
index d46591c96f..d777c273e3 100644
--- a/files/fr/web/javascript/reference/errors/missing_name_after_dot_operator/index.md
+++ b/files/fr/web/javascript/reference/errors/missing_name_after_dot_operator/index.md
@@ -8,28 +8,28 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/Missing_name_after_dot_operator
 original_slug: Web/JavaScript/Reference/Erreurs/Missing_name_after_dot_operator
 ---
-<div>{{jsSidebar("Errors")}}</div>
+{{jsSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">SyntaxError: missing name after . operator
-</pre>
+    SyntaxError: missing name after . operator
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>{{jsxref("SyntaxError")}}</p>
+{{jsxref("SyntaxError")}}
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p>L'opérateur <code>.</code> (le point) est utilisé pour <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_membres">accéder aux propriétés d'un objet</a>. Il est nécessaire d'indiquer le nom de la propriété à laquelle on souhaite accéder. Pour les propriétés dont le nom est calculé, il est préférable d'utiliser les crochets pour encadrer le nom. Cela permet de calculer une expression dont le résultat sera le nom de la propriété recherchée. Peut-être cherchiez-vous à utiliser l'opérateur de concaténation ? C'est l'opérateur <code>+</code> qu'il faut utiliser dans ce cas. Pour plus de détails, voir les exemples ci-après.</p>
+L'opérateur `.` (le point) est utilisé pour [accéder aux propriétés d'un objet](/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_membres). Il est nécessaire d'indiquer le nom de la propriété à laquelle on souhaite accéder. Pour les propriétés dont le nom est calculé, il est préférable d'utiliser les crochets pour encadrer le nom. Cela permet de calculer une expression dont le résultat sera le nom de la propriété recherchée. Peut-être cherchiez-vous à utiliser l'opérateur de concaténation ? C'est l'opérateur `+` qu'il faut utiliser dans ce cas. Pour plus de détails, voir les exemples ci-après.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Accéder_à_une_propriété">Accéder à une propriété</h3>
+### Accéder à une propriété
 
-<p><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_membres">Pour accéder à une propriété</a> en JavaScript, on utilise le point (.) ou les crochets (<code>[]</code>) mais pas une combinaison des deux. Les crochets sont notamment utiles lorsqu'on souhaite accéder à des propriétés dont le nom est calculé.</p>
+[Pour accéder à une propriété](/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_membres) en JavaScript, on utilise le point (.) ou les crochets (`[]`) mais pas une combinaison des deux. Les crochets sont notamment utiles lorsqu'on souhaite accéder à des propriétés dont le nom est calculé.
 
-<pre class="brush: js example-bad">var obj = { toto: { truc: "bidule", machin2: "bidule2" } };
+```js example-bad
+var obj = { toto: { truc: "bidule", machin2: "bidule2" } };
 var i = 2;
 
 obj.[toto].[truc]
@@ -37,11 +37,12 @@ obj.[toto].[truc]
 
 obj.toto."machin"+i;
 // SyntaxError: missing name after . operator
-</pre>
+```
 
-<p>Pour corriger ce fragment de code, on pourra accéder aux propriétés de la façon suivante :</p>
+Pour corriger ce fragment de code, on pourra accéder aux propriétés de la façon suivante :
 
-<pre class="brush: js example-good">obj.toto.truc; // "bidule"
+```js example-good
+obj.toto.truc; // "bidule"
 // ou autrement
 obj["toto"]["truc"]; // "bidule"
 
@@ -49,22 +50,24 @@ obj["toto"]["truc"]; // "bidule"
 // nom est calculé, il faut les
 // crochets
 obj.toto["machin" + i]; // "bidule2"
-</pre>
+```
 
-<h3 id="Accéder_à_une_propriété_ou_concaténer">Accéder à une propriété ou concaténer ?</h3>
+### Accéder à une propriété ou concaténer ?
 
-<p>Si vous avez l'habitude de développer en utilisant un autre langage de programmation tel que {{Glossary("PHP")}}, il est possible de mélanger certains opérateurs et d'utiliser le point comme opérateur de concaténation, qui est l'opérateur <code>+</code> en JavaScript :</p>
+Si vous avez l'habitude de développer en utilisant un autre langage de programmation tel que {{Glossary("PHP")}}, il est possible de mélanger certains opérateurs et d'utiliser le point comme opérateur de concaténation, qui est l'opérateur `+` en JavaScript :
 
-<pre class="brush: js example-bad">console.log("Coucou " . "monde");
+```js example-bad
+console.log("Coucou " . "monde");
 
-// SyntaxError: missing name after . operator</pre>
+// SyntaxError: missing name after . operator
+```
 
-<p>À la place, on écrira :</p>
+À la place, on écrira :
 
-<pre class="brush: js example-good">console.log("Coucou " + "monde");</pre>
+```js example-good
+console.log("Coucou " + "monde");
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_membres">Les accesseurs de propriété</a></li>
-</ul>
+- [Les accesseurs de propriété](/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_membres)
diff --git a/files/fr/web/javascript/reference/errors/missing_parenthesis_after_argument_list/index.md b/files/fr/web/javascript/reference/errors/missing_parenthesis_after_argument_list/index.md
index f59707b152..b9bf2d9afb 100644
--- a/files/fr/web/javascript/reference/errors/missing_parenthesis_after_argument_list/index.md
+++ b/files/fr/web/javascript/reference/errors/missing_parenthesis_after_argument_list/index.md
@@ -8,50 +8,53 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/Missing_parenthesis_after_argument_list
 original_slug: Web/JavaScript/Reference/Erreurs/Missing_parenthesis_after_argument_list
 ---
-<div>{{jsSidebar("Errors")}}</div>
+{{jsSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">SyntaxError: Expected ')' (Edge)
-SyntaxError: missing ) after argument list (Firefox)
-</pre>
+    SyntaxError: Expected ')' (Edge)
+    SyntaxError: missing ) after argument list (Firefox)
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>{{jsxref("SyntaxError")}}.</p>
+{{jsxref("SyntaxError")}}.
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p> </p>
 
-<p>Il y a une erreur avec la façon dont une fonction est appelée . Cela peut être une faute de frappe, un opérateur manquant, ou une chaîne non-échappée, par exemple .</p>
 
-<h2 id="Exemple">Exemple</h2>
+Il y a une erreur avec la façon dont une fonction est appelée . Cela peut être une faute de frappe, un opérateur manquant, ou une chaîne non-échappée, par exemple .
 
-<p>Parce qu'il n'y a pas d'opérateur "+" pour concaténer la chaîne de caractères, JavaScript s'attend à trouver une parenthèse après "PI : ", qu'il considère comme  l'argument de la fonction <code>log. </code></p>
+## Exemple
 
-<pre class="brush: js example-bad">console.log("PI: " Math.PI);
+Parce qu'il n'y a pas d'opérateur "+" pour concaténer la chaîne de caractères, JavaScript s'attend à trouver une parenthèse après "PI : ", qu'il considère comme  l'argument de la fonction `log. `
+
+```js example-bad
+console.log("PI: " Math.PI);
 // SyntaxError: missing ) after argument list
-</pre>
+```
 
-<p>La fonction <code>log</code> peut être corrigée en ajoutant un opérateur "+".</p>
+La fonction `log` peut être corrigée en ajoutant un opérateur "+".
 
-<pre class="brush: js example-good">console.log("PI: " + Math.PI);
-// "PI: 3.141592653589793"</pre>
+```js example-good
+console.log("PI: " + Math.PI);
+// "PI: 3.141592653589793"
+```
 
-<h3 id="Chaînes_non_terminées">Chaînes non terminées</h3>
+### Chaînes non terminées
 
-<pre class="brush: js example-bad">console.log('"Java" + "Script" = \"' + 'Java' + 'Script\");
-// SyntaxError: missing ) after argument list</pre>
+```js example-bad
+console.log('"Java" + "Script" = \"' + 'Java' + 'Script\");
+// SyntaxError: missing ) after argument list
+```
 
-<p>Dans cet exemple, le moteur JavaScript considère qu'on souhaitait avoir <code>);</code> dans la chaîne de caractères et l'ignore. Aussi, le moteur considère que l'appelle à <code>console.log</code> n'est pas terminé et qu'il manque une parenthèse fermante. Pour corriger ce problème, on peut rajouter une quote <code>'</code> après la chaîne de caractères <code>"Script"</code> :</p>
+Dans cet exemple, le moteur JavaScript considère qu'on souhaitait avoir `);` dans la chaîne de caractères et l'ignore. Aussi, le moteur considère que l'appelle à `console.log` n'est pas terminé et qu'il manque une parenthèse fermante. Pour corriger ce problème, on peut rajouter une quote `'` après la chaîne de caractères `"Script"` :
 
-<pre class="brush: js example-good">console.log('"Java" + "Script" = \"' + 'Java' + 'Script\"');
+```js example-good
+console.log('"Java" + "Script" = \"' + 'Java' + 'Script\"');
 // '"Java" + "Script" = "JavaScript"'
-</pre>
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li><a href="/fr/docs/Web/JavaScript/Guide/Functions">Functions</a></li>
-</ul>
+- [Functions](/fr/docs/Web/JavaScript/Guide/Functions)
diff --git a/files/fr/web/javascript/reference/errors/missing_parenthesis_after_condition/index.md b/files/fr/web/javascript/reference/errors/missing_parenthesis_after_condition/index.md
index 52018f1d8d..f1afdee5d9 100644
--- a/files/fr/web/javascript/reference/errors/missing_parenthesis_after_condition/index.md
+++ b/files/fr/web/javascript/reference/errors/missing_parenthesis_after_condition/index.md
@@ -8,64 +8,67 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/Missing_parenthesis_after_condition
 original_slug: Web/JavaScript/Reference/Erreurs/Missing_parenthesis_after_condition
 ---
-<div>{{jsSidebar("Errors")}}</div>
+{{jsSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">SyntaxError: Expected ')' (Edge)
-SyntaxError: missing ) after condition (Firefox)
-</pre>
+    SyntaxError: Expected ')' (Edge)
+    SyntaxError: missing ) after condition (Firefox)
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>{{jsxref("SyntaxError")}}</p>
+{{jsxref("SyntaxError")}}
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p>Il y a une erreur pour la condition écrite dans l'instruction <code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/if...else">if</a></code>. Pour chaque langage de programmation, on utilise des instructions pour choisir quel bloc d'instructions exécuter selon les différentes entrées. L'instruction <code>if</code> permet d'exécuter une instruction si une condition donnée est vérifiée. En JavaScript, il faut que cette condition apparaisse entre parenthèses après le mot-clé  <code>if</code> :</p>
+Il y a une erreur pour la condition écrite dans l'instruction [`if`](/fr/docs/Web/JavaScript/Reference/Instructions/if...else). Pour chaque langage de programmation, on utilise des instructions pour choisir quel bloc d'instructions exécuter selon les différentes entrées. L'instruction `if` permet d'exécuter une instruction si une condition donnée est vérifiée. En JavaScript, il faut que cette condition apparaisse entre parenthèses après le mot-clé  `if` :
 
-<pre class="brush: js">if (condition) {
+```js
+if (condition) {
   // faire quelque chose si la condition est vraie
-}</pre>
+}
+```
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<p>Il s'agit peut-être simplement d'une coquille et il suffit alors de vérifier les parenthèses (ou plutôt leur absence) :</p>
+Il s'agit peut-être simplement d'une coquille et il suffit alors de vérifier les parenthèses (ou plutôt leur absence) :
 
-<pre class="brush: js example-bad">if (3 &gt; Math.PI {
+```js example-bad
+if (3 > Math.PI {
   console.log("Pardon ?");
 }
 
 // SyntaxError: missing ) after condition
-</pre>
+```
 
-<p>Pour corriger ce fragment de code, on ajoutera une parenthèse pour fermer la condition :</p>
+Pour corriger ce fragment de code, on ajoutera une parenthèse pour fermer la condition :
 
-<pre class="brush: js example-good">if (3 &gt; Math.PI) {
+```js example-good
+if (3 > Math.PI) {
   console.log("Pardon ?");
-}</pre>
+}
+```
 
-<p>Si vous avez l'habitude d'utiliser un autre langage de programmation, peut-être avez-vous utilisé un mot-clé qui n'existe pas en JavaScript ?</p>
+Si vous avez l'habitude d'utiliser un autre langage de programmation, peut-être avez-vous utilisé un mot-clé qui n'existe pas en JavaScript ?
 
-<pre class="brush: js example-bad">if (done is true) {
+```js example-bad
+if (done is true) {
  console.log("we are done!");
 }
 
 // SyntaxError: missing ) after condition
-</pre>
+```
 
-<p>Pour corriger cette erreur, on utilisera <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_comparaison">un opérateur de comparaison</a> correct :</p>
+Pour corriger cette erreur, on utilisera [un opérateur de comparaison](/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_comparaison) correct :
 
-<pre class="brush: js example-good">if (done === true) {
+```js example-good
+if (done === true) {
  console.log("Et voilà !");
-}</pre>
+}
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li><code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/if...else">if...else</a></code></li>
- <li><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_comparaison">Les opérateurs de comparaisons</a></li>
- <li>
-  <p><a href="/fr/docs/Learn/JavaScript/Building_blocks/conditionals">Choisir quel code exécuter : les structures conditionnelles</a></p>
- </li>
-</ul>
+- [`if...else`](/fr/docs/Web/JavaScript/Reference/Instructions/if...else)
+- [Les opérateurs de comparaisons](/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_comparaison)
+- [Choisir quel code exécuter : les structures conditionnelles](/fr/docs/Learn/JavaScript/Building_blocks/conditionals)
diff --git a/files/fr/web/javascript/reference/errors/missing_semicolon_before_statement/index.md b/files/fr/web/javascript/reference/errors/missing_semicolon_before_statement/index.md
index cb9e5c0312..9ef0310199 100644
--- a/files/fr/web/javascript/reference/errors/missing_semicolon_before_statement/index.md
+++ b/files/fr/web/javascript/reference/errors/missing_semicolon_before_statement/index.md
@@ -9,76 +9,82 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/Missing_semicolon_before_statement
 original_slug: Web/JavaScript/Reference/Erreurs/Missing_semicolon_before_statement
 ---
-<div>{{jsSidebar("Errors")}}</div>
+{{jsSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">SyntaxError: Expected ';' (Edge)
-SyntaxError: missing ; before statement (Firefox)
-</pre>
+    SyntaxError: Expected ';' (Edge)
+    SyntaxError: missing ; before statement (Firefox)
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>{{jsxref("SyntaxError")}}.</p>
+{{jsxref("SyntaxError")}}.
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p>Un point-virgule est absent quelque part. En JavaScript, <a href="/fr/docs/Web/JavaScript/Reference/Instructions">les instructions doivent se terminer par des points-virgules</a>. Certaines de ces instructions sont traitées par <a href="/fr/docs/Web/JavaScript/Reference/Grammaire_lexicale#Insertion_automatique_de_points-virgules">l'insertion automatique de point-virgule (<em>ASI</em> pour <em>Automatic Semicolon Insertion)</em></a>, mais pour le code qui provoque l'erreur, un point-virgule est nécessaire afin que le moteur JavaScript puisse analyser le code source correctement.</p>
+Un point-virgule est absent quelque part. En JavaScript, [les instructions doivent se terminer par des points-virgules](/fr/docs/Web/JavaScript/Reference/Instructions). Certaines de ces instructions sont traitées par [l'insertion automatique de point-virgule (_ASI_ pour _Automatic Semicolon Insertion)_](/fr/docs/Web/JavaScript/Reference/Grammaire_lexicale#Insertion_automatique_de_points-virgules), mais pour le code qui provoque l'erreur, un point-virgule est nécessaire afin que le moteur JavaScript puisse analyser le code source correctement.
 
-<p>La plupart du temps, cette erreur est la conséquence d'une autre erreur : ne pas « fermer » les chaînes de caractères correctement ou utiliser <code>var</code> de façon incorrecte. Il peut également y avoir trop de parenthèses à un endroit. Lorsque cette erreur apparaît, faites attention à la syntaxe du code environnant.</p>
+La plupart du temps, cette erreur est la conséquence d'une autre erreur : ne pas « fermer » les chaînes de caractères correctement ou utiliser `var` de façon incorrecte. Il peut également y avoir trop de parenthèses à un endroit. Lorsque cette erreur apparaît, faites attention à la syntaxe du code environnant.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Les_chaînes_laissées_ouvertes">Les chaînes laissées ouvertes</h3>
+### Les chaînes laissées ouvertes
 
-<p>Cette erreur est parfois simplement provoquée par une chaîne dont les quotes ne sont pas échappées correctement ou qui ne sont pas correctement délimitées. Le moteur JavaScript s'attend donc à trouver la fin de la chaîne. Par exemple :</p>
+Cette erreur est parfois simplement provoquée par une chaîne dont les quotes ne sont pas échappées correctement ou qui ne sont pas correctement délimitées. Le moteur JavaScript s'attend donc à trouver la fin de la chaîne. Par exemple :
 
-<pre class="brush: js example-bad">var toto = 'Ouvrir l'œil';
-// SyntaxError: missing ; before statement</pre>
+```js example-bad
+var toto = 'Ouvrir l'œil';
+// SyntaxError: missing ; before statement
+```
 
-<p>Pour éviter cela, on pourra utiliser des doubles quotes ou échapper l'apostrophe :</p>
+Pour éviter cela, on pourra utiliser des doubles quotes ou échapper l'apostrophe :
 
-<pre class="brush: js example-good">var toto = "Ouvrir l'œil";
+```js example-good
+var toto = "Ouvrir l'œil";
 var toto = 'Ouvrir l\'œil';
-</pre>
+```
 
-<h3 id="Déclarer_des_propriétés_avec_var">Déclarer des propriétés avec <code>var</code></h3>
+### Déclarer des propriétés avec `var`
 
-<p>On <strong>ne peut pas</strong> déclarer de propriétés sur un objet ou un tableau avec une déclaration <code>var</code>.</p>
+On **ne peut pas** déclarer de propriétés sur un objet ou un tableau avec une déclaration `var`.
 
-<pre class="brush: js example-bad">var obj = {};
+```js example-bad
+var obj = {};
 var obj.toto = "coucou"; // SyntaxError missing ; before statement
 
 var array = [];
 var array[0] = "monde"; // SyntaxError missing ; before statement
-</pre>
+```
 
-<p>Pour éviter cela, on n'utilisera pas le mot-clé <code>var</code> qui est inutile dans ces cas :</p>
+Pour éviter cela, on n'utilisera pas le mot-clé `var` qui est inutile dans ces cas :
 
-<pre class="brush: js example-good">var obj = {};
+```js example-good
+var obj = {};
 obj.toto = "coucou";
 
 var array = [];
 array[0] = "monde";
-</pre>
+```
 
-<h3 id="Mauvais_mots-clés">Mauvais mots-clés</h3>
+### Mauvais mots-clés
 
-<p>Il peut arriver, notamment lorsqu'on provient d'un autre langage de programmation, d'utiliser des mots-clés qui n'ont pas du tout le même sens en JavaScript :</p>
+Il peut arriver, notamment lorsqu'on provient d'un autre langage de programmation, d'utiliser des mots-clés qui n'ont pas du tout le même sens en JavaScript :
 
-<pre class="brush: js example-bad">def print(info){
+```js example-bad
+def print(info){
   console.log(info);
-}; // SyntaxError missing ; before statement</pre>
+}; // SyntaxError missing ; before statement
+```
 
-<p>À la place de <code>def</code>, on utilisera le mot-clé <code>function</code> :</p>
+À la place de `def`, on utilisera le mot-clé `function` :
 
-<pre class="brush: js example-good">function print(info){
+```js example-good
+function print(info){
   console.log(info);
-};</pre>
+};
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li><a href="/fr/docs/Web/JavaScript/Reference/Grammaire_lexicale#Insertion_automatique_de_points-virgules">L'insertion automatique de points-virgules</a></li>
- <li><a href="/fr/docs/Web/JavaScript/Reference/Instructions">Les instructions JavaScript</a></li>
-</ul>
+- [L'insertion automatique de points-virgules](/fr/docs/Web/JavaScript/Reference/Grammaire_lexicale#Insertion_automatique_de_points-virgules)
+- [Les instructions JavaScript](/fr/docs/Web/JavaScript/Reference/Instructions)
diff --git a/files/fr/web/javascript/reference/errors/more_arguments_needed/index.md b/files/fr/web/javascript/reference/errors/more_arguments_needed/index.md
index 3417499581..7175be5198 100644
--- a/files/fr/web/javascript/reference/errors/more_arguments_needed/index.md
+++ b/files/fr/web/javascript/reference/errors/more_arguments_needed/index.md
@@ -8,43 +8,43 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/More_arguments_needed
 original_slug: Web/JavaScript/Reference/Erreurs/More_arguments_needed
 ---
-<div>{{jsSidebar("Errors")}}</div>
+{{jsSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">TypeError: argument is not an Object and is not null (Edge)
-TypeError: Object.create requires at least 1 argument, but only 0 were passed
-TypeError: Object.setPrototypeOf requires at least 2 arguments, but only 0 were passed
-TypeError: Object.defineProperties requires at least 1 argument, but only 0 were passed
-</pre>
+    TypeError: argument is not an Object and is not null (Edge)
+    TypeError: Object.create requires at least 1 argument, but only 0 were passed
+    TypeError: Object.setPrototypeOf requires at least 2 arguments, but only 0 were passed
+    TypeError: Object.defineProperties requires at least 1 argument, but only 0 were passed
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>{{jsxref("TypeError")}}.</p>
+{{jsxref("TypeError")}}.
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p>Lors de l'appel de la fonction, il y a eu une erreur due au manque d'argument. La fonction doit recevoir plus de paramètres afin de pouvoir fonctionner.</p>
+Lors de l'appel de la fonction, il y a eu une erreur due au manque d'argument. La fonction doit recevoir plus de paramètres afin de pouvoir fonctionner.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<p>La méthode {{jsxref("Object.create()")}} nécessite au moins un argument et {{jsxref("Object.setPrototypeOf()")}} requiert deux paramètres :</p>
+La méthode {{jsxref("Object.create()")}} nécessite au moins un argument et {{jsxref("Object.setPrototypeOf()")}} requiert deux paramètres :
 
-<pre class="brush: js example-bad">var obj = Object.create();
+```js example-bad
+var obj = Object.create();
 // TypeError: Object.create requires more than 0 arguments
 
 var obj = Object.setPrototypeOf({});
 // TypeError: Object.setPrototypeOf requires more than 1 argument
-</pre>
+```
 
-<p>On peut corriger cet exemple en utilisant {{jsxref("null")}} comme prototype :</p>
+On peut corriger cet exemple en utilisant {{jsxref("null")}} comme prototype :
 
-<pre class="brush: js example-good">var obj = Object.create(null);
+```js example-good
+var obj = Object.create(null);
 
-var obj = Object.setPrototypeOf({}, null);</pre>
+var obj = Object.setPrototypeOf({}, null);
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li><a href="/fr/docs/Web/JavaScript/Guide/Fonctions">Les fonctions</a></li>
-</ul>
+- [Les fonctions](/fr/docs/Web/JavaScript/Guide/Fonctions)
diff --git a/files/fr/web/javascript/reference/errors/negative_repetition_count/index.md b/files/fr/web/javascript/reference/errors/negative_repetition_count/index.md
index 2b653b11f0..e4f0865fbe 100644
--- a/files/fr/web/javascript/reference/errors/negative_repetition_count/index.md
+++ b/files/fr/web/javascript/reference/errors/negative_repetition_count/index.md
@@ -8,39 +8,39 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/Negative_repetition_count
 original_slug: Web/JavaScript/Reference/Erreurs/Negative_repetition_count
 ---
-<div>{{jsSidebar("Errors")}}</div>
+{{jsSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">RangeError: argument out of range (Edge)
-RangeError: repeat count must be non-negative (Firefox)
-RangeError: Invalid count value (Chrome)
-</pre>
+    RangeError: argument out of range (Edge)
+    RangeError: repeat count must be non-negative (Firefox)
+    RangeError: Invalid count value (Chrome)
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>{{jsxref("RangeError")}}</p>
+{{jsxref("RangeError")}}
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p>La méthode {{jsxref("String.prototype.repeat()")}} a été utilisée avec un argument négatif. Or, cet argument doit être compris dans l'intervalle [0, +∞).</p>
+La méthode {{jsxref("String.prototype.repeat()")}} a été utilisée avec un argument négatif. Or, cet argument doit être compris dans l'intervalle \[0, +∞).
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Exemples_invalides">Exemples invalides</h3>
+### Exemples invalides
 
-<pre class="brush: js example-bad">'abc'.repeat(-1); // RangeError </pre>
+```js example-bad
+'abc'.repeat(-1); // RangeError 
+```
 
-<h3 id="Exemples_valides">Exemples valides</h3>
+### Exemples valides
 
-<pre class="brush: js example-good">'abc'.repeat(0);    // ''
+```js example-good
+'abc'.repeat(0);    // ''
 'abc'.repeat(1);    // 'abc'
 'abc'.repeat(2);    // 'abcabc'
 'abc'.repeat(3.5);  // 'abcabcabc' (converti en entier)
-</pre>
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("String.prototype.repeat()")}}</li>
-</ul>
+- {{jsxref("String.prototype.repeat()")}}
diff --git a/files/fr/web/javascript/reference/errors/no_non-null_object/index.md b/files/fr/web/javascript/reference/errors/no_non-null_object/index.md
index 2dd59d1667..d635131c4b 100644
--- a/files/fr/web/javascript/reference/errors/no_non-null_object/index.md
+++ b/files/fr/web/javascript/reference/errors/no_non-null_object/index.md
@@ -8,60 +8,62 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/No_non-null_object
 original_slug: Web/JavaScript/Reference/Erreurs/No_non-null_object
 ---
-<div>{{JSSidebar("Errors")}}</div>
+{{JSSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">TypeError: Invalid descriptor for property {x} (Edge)
-TypeError: "x" is not a non-null object (Firefox)
-TypeError: Property description must be an object: "x" (Chrome)
-TypeError: Invalid value used in weak set (Chrome)
-</pre>
+    TypeError: Invalid descriptor for property {x} (Edge)
+    TypeError: "x" is not a non-null object (Firefox)
+    TypeError: Property description must be an object: "x" (Chrome)
+    TypeError: Invalid value used in weak set (Chrome)
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>{{jsxref("TypeError")}}</p>
+{{jsxref("TypeError")}}
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p>Un objet devrait être trouvé et n'est pas fourni. La valeur {{jsxref("null")}} n'est pas un objet et ne fonctionnera pas, il est nécessaire de fournir un véritable objet pour que le code en question fonctionne.</p>
+Un objet devrait être trouvé et n'est pas fourni. La valeur {{jsxref("null")}} n'est pas un objet et ne fonctionnera pas, il est nécessaire de fournir un véritable objet pour que le code en question fonctionne.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Absence_d'un_descripteur_de_propriété">Absence d'un descripteur de propriété</h3>
+### Absence d'un descripteur de propriété
 
-<p>Lorsqu'on utilise des méthodes telles que {{jsxref("Object.create()")}}, {{jsxref("Object.defineProperty()")}} ou {{jsxref("Object.defineProperties()")}}, le paramètre optionnel de description des propriétés doit être un descripteur sous la forme d'un objet. Si la valeur fournie n'est pas un objet (mais par exemple un nombre), l'appel à la méthode déclenchera une erreur :</p>
+Lorsqu'on utilise des méthodes telles que {{jsxref("Object.create()")}}, {{jsxref("Object.defineProperty()")}} ou {{jsxref("Object.defineProperties()")}}, le paramètre optionnel de description des propriétés doit être un descripteur sous la forme d'un objet. Si la valeur fournie n'est pas un objet (mais par exemple un nombre), l'appel à la méthode déclenchera une erreur :
 
-<pre class="brush: js example-bad">Object.defineProperty({}, 'cle', 1);
+```js example-bad
+Object.defineProperty({}, 'cle', 1);
 // TypeError: 1 is not a non-null object
 
 Object.defineProperty({}, 'cle', null);
 // TypeError: null is not a non-null object
-</pre>
+```
 
-<p>Un descripteur de propriété valide aura la structure suivante :</p>
+Un descripteur de propriété valide aura la structure suivante :
 
-<pre class="brush: js example-good">Object.defineProperty({}, 'cle', { value: 'toto', writable: false });
-</pre>
+```js example-good
+Object.defineProperty({}, 'cle', { value: 'toto', writable: false });
+```
 
-<h3 id="Les_clés_de_WeakMap_et_WeakSet_sont_des_objets">Les clés de <code>WeakMap</code> et <code>WeakSet</code> sont des objets</h3>
+### Les clés de `WeakMap` et `WeakSet` sont des objets
 
-<p>Les objets {{jsxref("WeakMap")}} et {{jsxref("WeakSet")}} utilisent des objets comme clé. On ne peut pas utiliser d'autres types de valeurs pour les clés de ces objets.</p>
+Les objets {{jsxref("WeakMap")}} et {{jsxref("WeakSet")}} utilisent des objets comme clé. On ne peut pas utiliser d'autres types de valeurs pour les clés de ces objets.
 
-<pre class="brush: js example-bad">var ws = new WeakSet();
+```js example-bad
+var ws = new WeakSet();
 ws.add('toto');
-// TypeError: "toto" is not a non-null object</pre>
+// TypeError: "toto" is not a non-null object
+```
 
-<p>À la place, on utilisera des objets :</p>
+À la place, on utilisera des objets :
 
-<pre class="brush: js example-good">ws.add({toto: 'truc'});
+```js example-good
+ws.add({toto: 'truc'});
 ws.add(window);
-</pre>
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("Object.create()")}}</li>
- <li>{{jsxref("Object.defineProperty()")}}, {{jsxref("Object.defineProperties()")}}</li>
- <li>{{jsxref("WeakMap")}}, {{jsxref("WeakSet")}}</li>
-</ul>
+- {{jsxref("Object.create()")}}
+- {{jsxref("Object.defineProperty()")}}, {{jsxref("Object.defineProperties()")}}
+- {{jsxref("WeakMap")}}, {{jsxref("WeakSet")}}
diff --git a/files/fr/web/javascript/reference/errors/no_properties/index.md b/files/fr/web/javascript/reference/errors/no_properties/index.md
index d45bd65c93..8309c98d5e 100644
--- a/files/fr/web/javascript/reference/errors/no_properties/index.md
+++ b/files/fr/web/javascript/reference/errors/no_properties/index.md
@@ -9,35 +9,33 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/No_properties
 original_slug: Web/JavaScript/Reference/Erreurs/No_properties
 ---
-<div>{{jsSidebar("Errors")}}</div>
+{{jsSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">TypeError: Unable to get property {x} of undefined or null reference (Edge)
-TypeError: null has no properties (Firefox)
-TypeError: undefined has no properties (Firefox)
-</pre>
+    TypeError: Unable to get property {x} of undefined or null reference (Edge)
+    TypeError: null has no properties (Firefox)
+    TypeError: undefined has no properties (Firefox)
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>{{jsxref("TypeError")}}.</p>
+{{jsxref("TypeError")}}.
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p>Les valeurs {{jsxref("null")}} et {{jsxref("undefined")}} n'ont aucunes propriétés auxquelles accéder.</p>
+Les valeurs {{jsxref("null")}} et {{jsxref("undefined")}} n'ont aucunes propriétés auxquelles accéder.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<pre class="brush: js example-bad">null.toto;
+```js example-bad
+null.toto;
 // TypeError: null has no properties
 
 undefined.truc;
 // TypeError: undefined has no properties
-</pre>
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("null")}}</li>
- <li>{{jsxref("undefined")}}</li>
-</ul>
+- {{jsxref("null")}}
+- {{jsxref("undefined")}}
diff --git a/files/fr/web/javascript/reference/errors/no_variable_name/index.md b/files/fr/web/javascript/reference/errors/no_variable_name/index.md
index 035c83faa9..def7f7fc2f 100644
--- a/files/fr/web/javascript/reference/errors/no_variable_name/index.md
+++ b/files/fr/web/javascript/reference/errors/no_variable_name/index.md
@@ -8,77 +8,85 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/No_variable_name
 original_slug: Web/JavaScript/Reference/Erreurs/No_variable_name
 ---
-<div>{{jsSidebar("Errors")}}</div>
+{{jsSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">SyntaxError: missing variable name (Firefox)
-SyntaxError: Unexpected token = (Chrome)</pre>
+    SyntaxError: missing variable name (Firefox)
+    SyntaxError: Unexpected token = (Chrome)
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>{{jsxref("SyntaxError")}}</p>
+{{jsxref("SyntaxError")}}
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p>Il manque un nom pour une variable. Cela est probablement dû à une erreur de syntaxe dans le code. Peut-être qu'une variable est placée au mauvais endroit ou peut-être qu'il manque un nom car on n'a pas trouvé de nom pertinent… (ce qui est souvent assez difficile).</p>
+Il manque un nom pour une variable. Cela est probablement dû à une erreur de syntaxe dans le code. Peut-être qu'une variable est placée au mauvais endroit ou peut-être qu'il manque un nom car on n'a pas trouvé de nom pertinent… (ce qui est souvent assez difficile).
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Absence_d'un_nom_pour_une_variable">Absence d'un nom pour une variable</h3>
+### Absence d'un nom pour une variable
 
-<pre class="brush: js example-bad">var = "toto";
-</pre>
+```js example-bad
+var = "toto";
+```
 
-<p>Il est souvent compliqué de trouver le bon nom pour une variable…</p>
+Il est souvent compliqué de trouver le bon nom pour une variable…
 
-<pre class="brush: js example-good">var àDéfautDeMieux = "toto";</pre>
+```js example-good
+var àDéfautDeMieux = "toto";
+```
 
-<h3 id="Les_mots-clés_réservés_ne_peuvent_pas_être_utilisés_comme_noms_de_variables">Les mots-clés réservés ne peuvent pas être utilisés comme noms de variables</h3>
+### Les mots-clés réservés ne peuvent pas être utilisés comme noms de variables
 
-<p>Quelques mots-clés sont <a href="/fr/docs/Web/JavaScript/Reference/Grammaire_lexicale#Mots-clés">réservés</a> et ne peuvent pas être utilisés comme noms de variable :</p>
+Quelques mots-clés sont [réservés](/fr/docs/Web/JavaScript/Reference/Grammaire_lexicale#Mots-clés) et ne peuvent pas être utilisés comme noms de variable :
 
-<pre class="brush: js example-bad">var debugger = "zuuuuut";
+```js example-bad
+var debugger = "zuuuuut";
 // SyntaxError: missing variable name
-</pre>
+```
 
-<h3 id="Déclarer_plusieurs_variables">Déclarer plusieurs variables</h3>
+### Déclarer plusieurs variables
 
-<p>Attention aux virgules lorsqu'on déclare plusieurs variables… Y a-t-il plus de virgules que nécessairee ? Une virgule est-elle utilisée à la place d'un point-virgule ?</p>
+Attention aux virgules lorsqu'on déclare plusieurs variables… Y a-t-il plus de virgules que nécessairee ? Une virgule est-elle utilisée à la place d'un point-virgule ?
 
-<pre class="brush: js example-bad">var x, y = "toto",
+```js example-bad
+var x, y = "toto",
 var x, = "toto"
 
 var un = document.getElementById('un'),
 var deux = document.getElementById('deux'),
 
 // SyntaxError: missing variable name
-</pre>
+```
 
-<p>Voici une version corrigée :</p>
+Voici une version corrigée :
 
-<pre class="brush: js example-good">var x, y = "toto";
+```js example-good
+var x, y = "toto";
 var x = "toto";
 
 var un = document.getElementById('un');
-var deux = document.getElementById('deux');</pre>
+var deux = document.getElementById('deux');
+```
 
-<h3 id="Tableaux">Tableaux</h3>
+### Tableaux
 
-<p>Pour former un littéral de tableau ({{jsxref("Array")}}), il est nécessaire d'ajouter des crochets autour des valeurs des éléments. Le fragment de code suivant ne fonctionnera pas :</p>
+Pour former un littéral de tableau ({{jsxref("Array")}}), il est nécessaire d'ajouter des crochets autour des valeurs des éléments. Le fragment de code suivant ne fonctionnera pas :
 
-<pre class="brush: js example-bad">var arr = 1,2,3,4,5;
+```js example-bad
+var arr = 1,2,3,4,5;
 // SyntaxError: missing variable name
-</pre>
+```
 
-<p>Voici la forme équivalente correcte :</p>
+Voici la forme équivalente correcte :
 
-<pre class="brush: js example-good">var arr = [1,2,3,4,5];</pre>
+```js example-good
+var arr = [1,2,3,4,5];
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li><a href="http://wiki.c2.com/?GoodVariableNames">Choisir de bons noms de variable (en anglais)</a></li>
- <li><code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/var">var</a></code></li>
- <li><a href="/fr/docs/Web/JavaScript/Guide/Types_et_grammaire#Déclarations">Guide JavaScript : Les déclarations de variable</a></li>
-</ul>
+- [Choisir de bons noms de variable (en anglais)](http://wiki.c2.com/?GoodVariableNames)
+- [`var`](/fr/docs/Web/JavaScript/Reference/Instructions/var)
+- [Guide JavaScript : Les déclarations de variable](/fr/docs/Web/JavaScript/Guide/Types_et_grammaire#Déclarations)
diff --git a/files/fr/web/javascript/reference/errors/non_configurable_array_element/index.md b/files/fr/web/javascript/reference/errors/non_configurable_array_element/index.md
index bbb5b3569c..720a30d67c 100644
--- a/files/fr/web/javascript/reference/errors/non_configurable_array_element/index.md
+++ b/files/fr/web/javascript/reference/errors/non_configurable_array_element/index.md
@@ -9,76 +9,77 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/Non_configurable_array_element
 original_slug: Web/JavaScript/Reference/Erreurs/Non_configurable_array_element
 ---
-<div>{{jsSidebar("Errors")}}</div>
+{{jsSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">TypeError: can't delete non-configurable array element (Firefox)
-TypeError: Cannot delete property '2' of [object Array] (Chrome)
-</pre>
+    TypeError: can't delete non-configurable array element (Firefox)
+    TypeError: Cannot delete property '2' of [object Array] (Chrome)
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>{{jsxref("TypeError")}}</p>
+{{jsxref("TypeError")}}
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p>On a voulu <a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Array/length#Tronquer_un_tableau">raccourcir la longueur d'un tableau</a> mais l'un des éléments de ce tableau est <a href="/fr/docs/Web/JavaScript/Structures_de_données#Propriétés">non-configurable</a>. Lorsqu'on tronque un tableau, les éléments situés au-delà de la nouvelle longueur seront supprimés. Dans ce cas, c'est cette suppression qui n'a pas pu être effectuée.</p>
+On a voulu [raccourcir la longueur d'un tableau](/fr/docs/Web/JavaScript/Reference/Objets_globaux/Array/length#Tronquer_un_tableau) mais l'un des éléments de ce tableau est [non-configurable](/fr/docs/Web/JavaScript/Structures_de_données#Propriétés). Lorsqu'on tronque un tableau, les éléments situés au-delà de la nouvelle longueur seront supprimés. Dans ce cas, c'est cette suppression qui n'a pas pu être effectuée.
 
-<p>L'attribut <code>configurable</code> permet de contrôler si la propriété peut être supprimée d'un objet et si ses attributs (en dehors de <code>writable</code>) peuvent être modifiés.</p>
+L'attribut `configurable` permet de contrôler si la propriété peut être supprimée d'un objet et si ses attributs (en dehors de `writable`) peuvent être modifiés.
 
-<p>La plupart du temps, les propriétés d'un objet créé avec <a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Array#Syntaxe">un littéral de tableau</a> sont configurables. Toutefois, si on utilise {{jsxref("Object.defineProperty()")}} par exemple, la propriété n'est pas configurable par défaut.</p>
+La plupart du temps, les propriétés d'un objet créé avec [un littéral de tableau](/fr/docs/Web/JavaScript/Reference/Objets_globaux/Array#Syntaxe) sont configurables. Toutefois, si on utilise {{jsxref("Object.defineProperty()")}} par exemple, la propriété n'est pas configurable par défaut.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Propriétés_non-configurables_créées_avec_Object.defineProperty">Propriétés non-configurables créées avec  <code>Object.defineProperty</code></h3>
+### Propriétés non-configurables créées avec  `Object.defineProperty`
 
-<p>Par défaut, la méthode {{jsxref("Object.defineProperty()")}} crée des propriétés non-configurables si on n'indique pas expressément le contraire :</p>
+Par défaut, la méthode {{jsxref("Object.defineProperty()")}} crée des propriétés non-configurables si on n'indique pas expressément le contraire :
 
-<pre class="brush: js example-bad">var arr = [];
+```js example-bad
+var arr = [];
 Object.defineProperty(arr, 0, {value: 0});
 Object.defineProperty(arr, 1, {value: "1"});
 
 arr.length = 1;
 // TypeError: can't delete non-configurable array element
-</pre>
+```
 
-<p>Si on veut tronquer le tableau, il faut que les éléments excédants soient configurables :</p>
+Si on veut tronquer le tableau, il faut que les éléments excédants soient configurables :
 
-<pre class="brush: js example-good">var arr = [];
+```js example-good
+var arr = [];
 Object.defineProperty(arr, 0, {value: 0, configurable: true});
 Object.defineProperty(arr, 1, {value: "1", configurable: true});
 
 arr.length = 1;
-</pre>
+```
 
-<h3 id="Tableaux_scellés_(seal)">Tableaux scellés (<code>seal</code>)</h3>
+### Tableaux scellés (`seal`)
 
-<p>La méthode {{jsxref("Object.seal()")}} permet de marquer l'ensemble des propriétés (ici les éléments du tableau) comme non-configurables :</p>
+La méthode {{jsxref("Object.seal()")}} permet de marquer l'ensemble des propriétés (ici les éléments du tableau) comme non-configurables :
 
-<pre class="brush: js example-bad">var arr = [1,2,3];
+```js example-bad
+var arr = [1,2,3];
 Object.seal(arr);
 
 arr.length = 1;
 // TypeError: can't delete non-configurable array element
-</pre>
+```
 
-<p>Pour corriger l'erreur, il faut retirer l'appel à {{jsxref("Object.seal()")}} ou réaliser une copie du tableau. Dans ce dernier cas, on notera que tronquer la copie du tableau ne modifie pas la longueur du tableau original.</p>
+Pour corriger l'erreur, il faut retirer l'appel à {{jsxref("Object.seal()")}} ou réaliser une copie du tableau. Dans ce dernier cas, on notera que tronquer la copie du tableau ne modifie pas la longueur du tableau original.
 
-<pre class="brush: js example-good">var arr = [1,2,3];
+```js example-good
+var arr = [1,2,3];
 Object.seal(arr);
 
 // On copie le tableau initial pour tronquer cette copie
 var copie = Array.from(arr);
 copie.length = 1;
 // arr.length == 3
-</pre>
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li><a href="/fr/docs/Web/JavaScript/Structures_de_données#Propriétés">La propriété interne <code>[[Configurable]]</code></a></li>
- <li>{{jsxref("Array.length")}}</li>
- <li>{{jsxref("Object.defineProperty()")}}</li>
- <li>{{jsxref("Object.seal()")}}</li>
-</ul>
+- [La propriété interne `[[Configurable]]`](/fr/docs/Web/JavaScript/Structures_de_données#Propriétés)
+- {{jsxref("Array.length")}}
+- {{jsxref("Object.defineProperty()")}}
+- {{jsxref("Object.seal()")}}
diff --git a/files/fr/web/javascript/reference/errors/not_a_codepoint/index.md b/files/fr/web/javascript/reference/errors/not_a_codepoint/index.md
index 2da0d021ee..5f8bcf650b 100644
--- a/files/fr/web/javascript/reference/errors/not_a_codepoint/index.md
+++ b/files/fr/web/javascript/reference/errors/not_a_codepoint/index.md
@@ -8,50 +8,50 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/Not_a_codepoint
 original_slug: Web/JavaScript/Reference/Erreurs/Not_a_codepoint
 ---
-<div>{{jsSidebar("Errors")}}</div>
+{{jsSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">RangeError: Invalid code point {0} (Edge)
-RangeError: {0} is not a valid code point (Firefox)
-RangeError: Invalid code point {0} (Chrome)
-</pre>
+    RangeError: Invalid code point {0} (Edge)
+    RangeError: {0} is not a valid code point (Firefox)
+    RangeError: Invalid code point {0} (Chrome)
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>{{jsxref("RangeError")}}</p>
+{{jsxref("RangeError")}}
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p>La méthode {{jsxref("String.fromCodePoint()")}} a été utilisée mais elle n'accepte que les points de code valides (<em>code points</em>) et la valeur fournie en argument n'est pas un point de code valide (ex. <code>NaN</code>, <code>-1</code>).</p>
+La méthode {{jsxref("String.fromCodePoint()")}} a été utilisée mais elle n'accepte que les points de code valides (_code points_) et la valeur fournie en argument n'est pas un point de code valide (ex. `NaN`, `-1`).
 
-<p>Un <a href="https://fr.wikipedia.org/wiki/Point_de_code">point de code</a> est une valeur de code Unicode et s'inscrit dans un intervalle allant de <code>0</code> à <code>0x10FFFF</code>.</p>
+Un [point de code](https://fr.wikipedia.org/wiki/Point_de_code) est une valeur de code Unicode et s'inscrit dans un intervalle allant de `0` à `0x10FFFF`.
 
-<p>Les valeurs {{jsxref("NaN")}}, les entiers négatifs (<code>-1</code>), les flottants (<code>3.14</code>) ou les valeur supérieures à <code>0x10FFFF</code> (<code>1114111</code>) ne peuvent pas être utilisées avec cette méthode.</p>
+Les valeurs {{jsxref("NaN")}}, les entiers négatifs (`-1`), les flottants (`3.14`) ou les valeur supérieures à `0x10FFFF` (`1114111`) ne peuvent pas être utilisées avec cette méthode.
 
-<h2 id="Examples">Examples</h2>
+## Examples
 
-<h3 id="Exemples_invalides">Exemples invalides</h3>
+### Exemples invalides
 
-<pre class="brush: js example-bad">String.fromCodePoint('_');      // RangeError
+```js example-bad
+String.fromCodePoint('_');      // RangeError
 String.fromCodePoint(Infinity); // RangeError
 String.fromCodePoint(-1);       // RangeError
 String.fromCodePoint(3.14);     // RangeError
 String.fromCodePoint(3e-2);     // RangeError
-String.fromCodePoint(NaN);      // RangeError</pre>
+String.fromCodePoint(NaN);      // RangeError
+```
 
-<h3 id="Exemples_valides">Exemples valides</h3>
+### Exemples valides
 
-<pre class="brush: js example-good">String.fromCodePoint(42);       // "*"
+```js example-good
+String.fromCodePoint(42);       // "*"
 String.fromCodePoint(65, 90);   // "AZ"
 String.fromCodePoint(0x404);    // "\u0404"
 String.fromCodePoint(0x2F804);  // "\uD87E\uDC04"
 String.fromCodePoint(194564);   // "\uD87E\uDC04"
 String.fromCodePoint(0x1D306, 0x61, 0x1D307) // "\uD834\uDF06a\uD834\uDF07"
-</pre>
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("String.fromCodePoint()")}}</li>
-</ul>
+- {{jsxref("String.fromCodePoint()")}}
diff --git a/files/fr/web/javascript/reference/errors/not_a_constructor/index.md b/files/fr/web/javascript/reference/errors/not_a_constructor/index.md
index 211e4e952c..a6c6372d7d 100644
--- a/files/fr/web/javascript/reference/errors/not_a_constructor/index.md
+++ b/files/fr/web/javascript/reference/errors/not_a_constructor/index.md
@@ -8,39 +8,39 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/Not_a_constructor
 original_slug: Web/JavaScript/Reference/Erreurs/Not_a_constructor
 ---
-<div>{{jsSidebar("Errors")}}</div>
+{{jsSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">TypeError: Object doesn't support this action (Edge)
-TypeError: "x" is not a constructor
+    TypeError: Object doesn't support this action (Edge)
+    TypeError: "x" is not a constructor
 
-TypeError: Math is not a constructor
-TypeError: JSON is not a constructor
-TypeError: Symbol is not a constructor
-TypeError: Reflect is not a constructor
-TypeError: Intl is not a constructor
-TypeError: SIMD is not a constructor
-TypeError: Atomics is not a constructor
-</pre>
+    TypeError: Math is not a constructor
+    TypeError: JSON is not a constructor
+    TypeError: Symbol is not a constructor
+    TypeError: Reflect is not a constructor
+    TypeError: Intl is not a constructor
+    TypeError: SIMD is not a constructor
+    TypeError: Atomics is not a constructor
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>{{jsxref("TypeError")}}</p>
+{{jsxref("TypeError")}}
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p>Une variable ou un objet a été utilisé comme un constructeur alors que cet objet ou cette variable n'est pas un constructeur. Pour plus d'informations sur les constructeurs, voir la page sur <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_new">l'opérateur <code>new</code></a>.</p>
+Une variable ou un objet a été utilisé comme un constructeur alors que cet objet ou cette variable n'est pas un constructeur. Pour plus d'informations sur les constructeurs, voir la page sur [l'opérateur `new`](/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_new).
 
-<p>De nombreux objets globaux tels que {{jsxref("String")}} ou {{jsxref("Array")}}, sont constructibles avec <code>new</code>. Cependant, d'autres objets globaux ne le sont pas (leurs propriétés et méthodes sont statiques). Les objets standards natifs suivants ne sont pas des constructeur : {{jsxref("Math")}}, {{jsxref("JSON")}}, {{jsxref("Symbol")}}, {{jsxref("Reflect")}}, {{jsxref("Intl")}}, {{jsxref("SIMD")}}, {{jsxref("Atomics")}}.</p>
+De nombreux objets globaux tels que {{jsxref("String")}} ou {{jsxref("Array")}}, sont constructibles avec `new`. Cependant, d'autres objets globaux ne le sont pas (leurs propriétés et méthodes sont statiques). Les objets standards natifs suivants ne sont pas des constructeur : {{jsxref("Math")}}, {{jsxref("JSON")}}, {{jsxref("Symbol")}}, {{jsxref("Reflect")}}, {{jsxref("Intl")}}, {{jsxref("SIMD")}}, {{jsxref("Atomics")}}.
 
-<p><a href="/fr/docs/Web/JavaScript/Reference/Instructions/function*">Les fonctions génératrices</a> ne peuvent pas non plus être utilisées comme des constructeurs.</p>
+[Les fonctions génératrices](/fr/docs/Web/JavaScript/Reference/Instructions/function*) ne peuvent pas non plus être utilisées comme des constructeurs.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Exemples_invalides">Exemples invalides</h3>
+### Exemples invalides
 
-<pre class="brush: js example-bad">var Voiture = 1;
+```js example-bad
+var Voiture = 1;
 new Voiture();
 // TypeError: Voiture is not a constructor
 
@@ -53,45 +53,48 @@ new Symbol();
 function* f() {};
 var obj = new f;
 // TypeError: f is not a constructor
-</pre>
+```
 
-<h3 id="Créer_un_constructeur_voiture">Créer un constructeur <code>voiture</code></h3>
+### Créer un constructeur `voiture`
 
-<p>Imaginons qu'on veuille représenter des voitures sous forme d'objets. On appellera ce type <code>voiture</code> et on lui ajoutera des propriétés pour le fabricant, le modèle et l'année. Pour cela, on pourra écrire la fonction suivante :</p>
+Imaginons qu'on veuille représenter des voitures sous forme d'objets. On appellera ce type `voiture` et on lui ajoutera des propriétés pour le fabricant, le modèle et l'année. Pour cela, on pourra écrire la fonction suivante :
 
-<pre class="brush: js">function Voiture(fabriquant, modèle, année) {
+```js
+function Voiture(fabriquant, modèle, année) {
   this.fabriquant = fabriquant;
   this.modèle = modèle;
   this.année = année;
 }
-</pre>
+```
 
-<p>On peut désormais créer un objet <code>maVoiture</code> comme ceci :</p>
+On peut désormais créer un objet `maVoiture` comme ceci :
 
-<pre class="brush: js">var maVoiture = new Voiture("Renault", "Twingo", 2006);</pre>
+```js
+var maVoiture = new Voiture("Renault", "Twingo", 2006);
+```
 
-<h3 id="Avec_les_promesses">Avec les promesses</h3>
+### Avec les promesses
 
-<p>Lorsqu'on renvoie une promesse immédiatement tenue ou rompue, il n'est pas nécessaire d'utiliser <code>new Promise()</code> pour la manipuler. Il faut plutôt utiliser les méthodes statiques {{jsxref("Promise.resolve()")}} ou {{jsxref("Promise.reject()")}} :</p>
+Lorsqu'on renvoie une promesse immédiatement tenue ou rompue, il n'est pas nécessaire d'utiliser `new Promise()` pour la manipuler. Il faut plutôt utiliser les méthodes statiques {{jsxref("Promise.resolve()")}} ou {{jsxref("Promise.reject()")}} :
 
-<pre class="brush: js example-bad">// Dans ce cas on aura une exception
+```js example-bad
+// Dans ce cas on aura une exception
 // "this is not a constructor"
 return new Promise.resolve(true);
-</pre>
+```
 
-<pre class="brush: js">// Cette formulation fonctionne mais
+```js
+// Cette formulation fonctionne mais
 // est inutilement longue
-return new Promise((resolve, reject) =&gt; { resolve(true); });
+return new Promise((resolve, reject) => { resolve(true); });
 
 // On pourra autrement utiliser les
 // méthodes statiques
 return Promise.resolve(true);
 return Promise.reject(false);
-</pre>
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{Glossary("constructor")}}</li>
- <li><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_new">L'opérateur <code>new</code></a></li>
-</ul>
+- {{Glossary("constructor")}}
+- [L'opérateur `new`](/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_new)
diff --git a/files/fr/web/javascript/reference/errors/not_a_function/index.md b/files/fr/web/javascript/reference/errors/not_a_function/index.md
index 8675a249ae..e6b948eebe 100644
--- a/files/fr/web/javascript/reference/errors/not_a_function/index.md
+++ b/files/fr/web/javascript/reference/errors/not_a_function/index.md
@@ -8,82 +8,82 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/Not_a_function
 original_slug: Web/JavaScript/Reference/Erreurs/Not_a_function
 ---
-<div>{{jsSidebar("Errors")}}</div>
+{{jsSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">TypeError: Object doesn't support property or method {x} (Edge)
-TypeError: "x" is not a function
-</pre>
+    TypeError: Object doesn't support property or method {x} (Edge)
+    TypeError: "x" is not a function
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>{{jsxref("TypeError")}}.</p>
+{{jsxref("TypeError")}}.
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p>Une valeur a été utilisée pour un appel de fonction alors que cette valeur n'est pas une fonction. Autrement dit, un fragment de code attendait une fonction mais a reçu des valeurs d'un autre type.</p>
+Une valeur a été utilisée pour un appel de fonction alors que cette valeur n'est pas une fonction. Autrement dit, un fragment de code attendait une fonction mais a reçu des valeurs d'un autre type.
 
-<p>Il est possible qu'il y ait une coquille dans le nom de la fonction. Peut être que l'objet sur lequel la méthode est invoquée ne possède pas cette fonction (par exemple, les objets <code>Array</code> possèdent une fonction <code>map()</code> mais d'autres objets ne l'ont pas).</p>
+Il est possible qu'il y ait une coquille dans le nom de la fonction. Peut être que l'objet sur lequel la méthode est invoquée ne possède pas cette fonction (par exemple, les objets `Array` possèdent une fonction `map()` mais d'autres objets ne l'ont pas).
 
-<p>Il existe de nombreuses fonctions natives qui fonctionnent à l'aide d'une fonction (<em>callback</em>) passée en argument :</p>
+Il existe de nombreuses fonctions natives qui fonctionnent à l'aide d'une fonction (_callback_) passée en argument :
 
-<ul>
- <li>Pour les objets {{jsxref("Array")}} ou {{jsxref("TypedArray")}}, voici les fonctions qui utilisent une fonction en argument :
-  <ul>
-   <li>{{jsxref("Array.prototype.every()")}}, {{jsxref("Array.prototype.some()")}}, {{jsxref("Array.prototype.forEach()")}}, {{jsxref("Array.prototype.map()")}}, {{jsxref("Array.prototype.filter()")}},  {{jsxref("Array.prototype.reduce()")}}, {{jsxref("Array.prototype.reduceRight()")}}, {{jsxref("Array.prototype.find()")}}</li>
-  </ul>
- </li>
- <li>Pour les objets {{jsxref("Map")}} et {{jsxref("Set")}}, voici les méthodes concernées :
-  <ul>
-   <li>{{jsxref("Map.prototype.forEach()")}} and {{jsxref("Set.prototype.forEach()")}}</li>
-  </ul>
- </li>
-</ul>
+- Pour les objets {{jsxref("Array")}} ou {{jsxref("TypedArray")}}, voici les fonctions qui utilisent une fonction en argument :
 
-<h2 id="Exemples">Exemples</h2>
+  - {{jsxref("Array.prototype.every()")}}, {{jsxref("Array.prototype.some()")}}, {{jsxref("Array.prototype.forEach()")}}, {{jsxref("Array.prototype.map()")}}, {{jsxref("Array.prototype.filter()")}},  {{jsxref("Array.prototype.reduce()")}}, {{jsxref("Array.prototype.reduceRight()")}}, {{jsxref("Array.prototype.find()")}}
 
-<h3 id="Une_coquille_dans_le_nom_de_la_fonction">Une coquille dans le nom de la fonction</h3>
+- Pour les objets {{jsxref("Map")}} et {{jsxref("Set")}}, voici les méthodes concernées :
 
-<p>Dans ce cas, qui arrive bien trop souvent, il y a une faute d'orthographe dans le nom de la fonction utilisée :</p>
+  - {{jsxref("Map.prototype.forEach()")}} and {{jsxref("Set.prototype.forEach()")}}
 
-<pre class="brush: js example-bad">var x = document.getElementByID("toto");
+## Exemples
+
+### Une coquille dans le nom de la fonction
+
+Dans ce cas, qui arrive bien trop souvent, il y a une faute d'orthographe dans le nom de la fonction utilisée :
+
+```js example-bad
+var x = document.getElementByID("toto");
 // TypeError: document.getElementByID is not a function
-</pre>
+```
 
-<p>Le nom de la fonction est (dans cet exemple) <code>getElementByI<strong>d</strong></code> (attention à la casse pour les noms en JavaScript) :</p>
+Le nom de la fonction est (dans cet exemple) `getElementById` (attention à la casse pour les noms en JavaScript) :
 
-<pre class="brush: js example-good">var x = document.getElementById("toto");
-</pre>
+```js example-good
+var x = document.getElementById("toto");
+```
 
-<h3 id="Appeler_une_fonction_sur_le_mauvais_objet">Appeler une fonction sur le mauvais objet</h3>
+### Appeler une fonction sur le mauvais objet
 
-<p>Certaines méthodes ne fonctionnent que pour certains types d'objet et utilisent une fonction en argument. Ainsi, dans cet exemple, on utilise {{jsxref("Array.prototype.map()")}} qui ne fonctionne que sur les objets {{jsxref("Array")}}.</p>
+Certaines méthodes ne fonctionnent que pour certains types d'objet et utilisent une fonction en argument. Ainsi, dans cet exemple, on utilise {{jsxref("Array.prototype.map()")}} qui ne fonctionne que sur les objets {{jsxref("Array")}}.
 
-<pre class="brush: js example-bad">var obj = { a: 13, b: 37, c: 42 };
+```js example-bad
+var obj = { a: 13, b: 37, c: 42 };
 
 obj.map(function(num) {
   return num * 2;
 });
 
-// TypeError: obj.map is not a function</pre>
+// TypeError: obj.map is not a function
+```
 
-<p>Il faudra utiliser un tableau à la place :</p>
+Il faudra utiliser un tableau à la place :
 
-<pre class="brush: js example-good">var nombres = [1, 4, 9];
+```js example-good
+var nombres = [1, 4, 9];
 
 nombres.map(function(num) {
   return num * 2;
 });
 
 // Array [ 2, 8, 18 ]
-</pre>
+```
 
-<h3 id="Utiliser_le_même_nom_pour_une_méthode_et_une_propriété">Utiliser le même nom pour une méthode et une propriété</h3>
+### Utiliser le même nom pour une méthode et une propriété
 
-<p>Lorsqu'on écrit une classe, on peut malheureusement utiliser le même nom pour une propriété et une méthode. Lorsqu'on appellera la fonction, celle-ci aura été remplacée par la propriété et cela déclenchera une erreur :</p>
+Lorsqu'on écrit une classe, on peut malheureusement utiliser le même nom pour une propriété et une méthode. Lorsqu'on appellera la fonction, celle-ci aura été remplacée par la propriété et cela déclenchera une erreur :
 
-<pre class="brush: js example-bad">var Chien = function () {
+```js example-bad
+var Chien = function () {
  this.age = 11;
  this.couleur = "noir";
  this.nom = "Ralph";
@@ -98,11 +98,12 @@ Chien.prototype.nom = function(nom) {
 
 var monNouveauChien = new Chien();
 monNouveauChien.nom("Cassidy"); // Uncaught TypeError: monNouveauChien.nom is not a function
-</pre>
+```
 
-<p>Pour résoudre le problème, on utilisera deux noms distincts pour la propriété et la méthode :</p>
+Pour résoudre le problème, on utilisera deux noms distincts pour la propriété et la méthode :
 
-<pre class="brush: js example-good">var Chien = function () {
+```js example-good
+var Chien = function () {
  this.age = 11;
  this.couleur = "noir";
  this.nomChien = "Ralph";
@@ -117,40 +118,45 @@ Chien.prototype.nom = function(nom) {
 
 var monNouveauChien = new Chien();
 monNouveauChien.nom("Cassidy"); // Chien { age: 11, couleur: "noir", nomChien: "Cassidy" }
-</pre>
+```
 
-<h3 id="Utiliser_des_parenthèses_pour_la_multiplication">Utiliser des parenthèses pour la multiplication</h3>
+### Utiliser des parenthèses pour la multiplication
 
-<p>En notation mathématique, on peut écrire 2(3+5) pour indiquer qu'on souhaite multiplier 2 par 3 + 5. Toutefois, une telle écriture n'est pas valide en JavaScript car il faut préciser l'opérateur de multiplication :</p>
+En notation mathématique, on peut écrire 2(3+5) pour indiquer qu'on souhaite multiplier 2 par 3 + 5. Toutefois, une telle écriture n'est pas valide en JavaScript car il faut préciser l'opérateur de multiplication :
 
-<pre class="js example-bad">var seize = 2(3 + 5);
+```js example-bad
+var seize = 2(3 + 5);
 console.log('2 x (3 + 5) vaut ' + String(seize));
-// Uncaught TypeError: 2 is not a function</pre>
+// Uncaught TypeError: 2 is not a function
+```
 
-<p>Pour corriger, il suffit d'ajouter l'opérateur <code>*</code> :</p>
+Pour corriger, il suffit d'ajouter l'opérateur `*` :
 
-<pre class="js example-good">var seize = 2 * (3 + 5);
+```js example-good
+var seize = 2 * (3 + 5);
 console.log('2 x (3 + 5) is ' + String(seize));
 //2 x (3 + 5) is 16
-</pre>
+```
 
-<h3 id="Importer_un_module_exporté_correctement">Importer un module exporté correctement</h3>
+### Importer un module exporté correctement
 
-<p>Assurez-vous d'importer le module correctement. Si par exemple, on dispose d'une bibliothèque <code>helpers.js</code> avec le code suivant :</p>
+Assurez-vous d'importer le module correctement. Si par exemple, on dispose d'une bibliothèque `helpers.js` avec le code suivant :
 
-<pre class="brush: js">let helpers = function () { };
+```js
+let helpers = function () { };
 helpers.log = function(msg) {
   console.log(msg);
 };
 
-export default helpers;</pre>
+export default helpers;
+```
 
-<p>Pour l'importer côté application, on écrira :</p>
+Pour l'importer côté application, on écrira :
 
-<pre class="brush: js">import helpers from './helpers'</pre>
+```js
+import helpers from './helpers'
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li><a href="/fr/docs/Web/JavaScript/Reference/Fonctions">Les fonctions</a></li>
-</ul>
+- [Les fonctions](/fr/docs/Web/JavaScript/Reference/Fonctions)
diff --git a/files/fr/web/javascript/reference/errors/not_defined/index.md b/files/fr/web/javascript/reference/errors/not_defined/index.md
index d88edd4f04..51fa9d1bff 100644
--- a/files/fr/web/javascript/reference/errors/not_defined/index.md
+++ b/files/fr/web/javascript/reference/errors/not_defined/index.md
@@ -9,63 +9,65 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/Not_defined
 original_slug: Web/JavaScript/Reference/Erreurs/Not_defined
 ---
-<div>{{jsSidebar("Errors")}}</div>
+{{jsSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">ReferenceError: "x" is not defined
-</pre>
+    ReferenceError: "x" is not defined
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>{{jsxref("ReferenceError")}}.</p>
+{{jsxref("ReferenceError")}}.
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p>Une variable qui n'existe pas est référencée quelque part. Cette variable doit être déclarée ou il faut vérifier qu'elle est disponible dans le script concerné ou dans la portée utilisée.</p>
+Une variable qui n'existe pas est référencée quelque part. Cette variable doit être déclarée ou il faut vérifier qu'elle est disponible dans le script concerné ou dans la portée utilisée.
 
-<div class="note">
-<p><strong>Note :</strong> Lors du chargement d'une bibliothèque comme jQuery, assurez-vous de bien charger la bibliothèque avant d'accéder aux variables comme <code>$</code>. La balise {{HTMLElement("script")}} utilisée pour charger la bibliothèque doit être présente avant le code qui l'utilise.</p>
-</div>
+> **Note :** Lors du chargement d'une bibliothèque comme jQuery, assurez-vous de bien charger la bibliothèque avant d'accéder aux variables comme `$`. La balise {{HTMLElement("script")}} utilisée pour charger la bibliothèque doit être présente avant le code qui l'utilise.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Exemple_de_variable_non_déclarée">Exemple de variable non déclarée</h3>
+### Exemple de variable non déclarée
 
-<pre class="brush: js example-bad">toto.substring(1); // ReferenceError: toto is not defined
-</pre>
+```js example-bad
+toto.substring(1); // ReferenceError: toto is not defined
+```
 
-<p>La variable <code>toto</code> n'est définie nulle part. De plus, il faut qu'elle soit une chaîne de caractères afin que la méthode {{jsxref("String.prototype.substring()")}} puisse fonctionner.</p>
+La variable `toto` n'est définie nulle part. De plus, il faut qu'elle soit une chaîne de caractères afin que la méthode {{jsxref("String.prototype.substring()")}} puisse fonctionner.
 
-<pre class="brush: js example-good">var toto = "truc";
-toto.substring(1); // "ruc"</pre>
+```js example-good
+var toto = "truc";
+toto.substring(1); // "ruc"
+```
 
-<h3 id="Exemple_de_portée_invalide">Exemple de portée invalide</h3>
+### Exemple de portée invalide
 
-<p>Une variable doit être disponible dans le contexte d'exécution où elle est utilisée. Les variables définies au sein d'une fonction ne peuvent pas être utilisées en dehors de cette fonction car la variable appartient à la <em>portée</em> de la fonction.</p>
+Une variable doit être disponible dans le contexte d'exécution où elle est utilisée. Les variables définies au sein d'une fonction ne peuvent pas être utilisées en dehors de cette fonction car la variable appartient à la _portée_ de la fonction.
 
-<pre class="brush: js example-bad">function numbers () {
+```js example-bad
+function numbers () {
   var num1 = 2,
       num2 = 3;
   return num1 + num2;
 }
 
-console.log(num1); // ReferenceError num1 is not defined.</pre>
+console.log(num1); // ReferenceError num1 is not defined.
+```
 
-<p>Toutefois, une fonction peut accéder aux variables et aux fonctions définies dans la portée dans laquelle elle s'inscrit. Ainsi, une fonction définie dans la portée globale peut utiliser toutes les variables définies dans la portée globale.</p>
+Toutefois, une fonction peut accéder aux variables et aux fonctions définies dans la portée dans laquelle elle s'inscrit. Ainsi, une fonction définie dans la portée globale peut utiliser toutes les variables définies dans la portée globale.
 
-<pre class="brush: js example-good">var num1 = 2,
+```js example-good
+var num1 = 2,
     num2 = 3;
 
 function numbers () {
   return num1 + num2;
 }
 
-console.log(num1); // 2</pre>
+console.log(num1); // 2
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li><a href="/fr/docs/Web/JavaScript/Guide/Types_et_grammaire#Déclaration_de_variables">La déclaration de variables dans le guide JavaScript</a></li>
- <li><a href="/fr/docs/Web/JavaScript/Guide/Fonctions#Portée_d'une_fonction">Les notions de portées dans le guide JavaScript</a></li>
-</ul>
+- [La déclaration de variables dans le guide JavaScript](/fr/docs/Web/JavaScript/Guide/Types_et_grammaire#Déclaration_de_variables)
+- [Les notions de portées dans le guide JavaScript](/fr/docs/Web/JavaScript/Guide/Fonctions#Portée_d'une_fonction)
diff --git a/files/fr/web/javascript/reference/errors/precision_range/index.md b/files/fr/web/javascript/reference/errors/precision_range/index.md
index 52adf5bcd1..7b5ee16527 100644
--- a/files/fr/web/javascript/reference/errors/precision_range/index.md
+++ b/files/fr/web/javascript/reference/errors/precision_range/index.md
@@ -8,66 +8,43 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/Precision_range
 original_slug: Web/JavaScript/Reference/Erreurs/Precision_range
 ---
-<div>{{jsSidebar("Errors")}}</div>
-
-<h2 id="Message">Message</h2>
-
-<pre class="syntaxbox">RangeError: The number of fractional digits is out of range (Edge)
-RangeError: The precision is out of range (Edge)
-RangeError: precision {0} out of range (Firefox)
-RangeError: toExponential() argument must be between 0 and 20 (Chrome)
-RangeError: toFixed() digits argument must be between 0 and 20 (Chrome)
-RangeError: toPrecision() argument must be between 1 and 21 (Chrome)
-</pre>
-
-<h2 id="Type_d'erreur">Type d'erreur</h2>
-
-<p>{{jsxref("RangeError")}}</p>
-
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
-
-<p>Un argument dont la précision est en dehors de l'intervalle valide, prévu par le moteur JavaScript, a été utilisé pour une de ces méthodes :</p>
-
-<ul>
- <li>{{jsxref("Number.prototype.toExponential()")}}</li>
- <li>{{jsxref("Number.prototype.toFixed()")}}</li>
- <li>{{jsxref("Number.prototype.toPrecision()")}}</li>
-</ul>
-
-<p>Généralement, ces méthodes acceptent des arguments de précision compris entre 0 et 20 (voire 21). Cependant, la spécification ECMAScript permet de gérer des valeurs en dehors de cet intervalle.</p>
-
-<table class="standard-table">
- <thead>
-  <tr>
-   <th scope="col">Méthode</th>
-   <th scope="col">Firefox (SpiderMonkey)</th>
-   <th scope="col">Chrome, Opera (V8)</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td>{{jsxref("Number.prototype.toExponential()")}}</td>
-   <td>0 to 100</td>
-   <td>0 to 20</td>
-  </tr>
-  <tr>
-   <td>{{jsxref("Number.prototype.toFixed()")}}</td>
-   <td>-20 to 100</td>
-   <td>0 to 20</td>
-  </tr>
-  <tr>
-   <td>{{jsxref("Number.prototype.toPrecision()")}}</td>
-   <td>1 to 100</td>
-   <td>1 to 21</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Exemples">Exemples</h2>
-
-<h3 id="Exemples_invalides">Exemples invalides</h3>
-
-<pre class="brush: js example-bad">77.1234.toExponential(-1);  // RangeError
+{{jsSidebar("Errors")}}
+
+## Message
+
+    RangeError: The number of fractional digits is out of range (Edge)
+    RangeError: The precision is out of range (Edge)
+    RangeError: precision {0} out of range (Firefox)
+    RangeError: toExponential() argument must be between 0 and 20 (Chrome)
+    RangeError: toFixed() digits argument must be between 0 and 20 (Chrome)
+    RangeError: toPrecision() argument must be between 1 and 21 (Chrome)
+
+## Type d'erreur
+
+{{jsxref("RangeError")}}
+
+## Quel est le problème ?
+
+Un argument dont la précision est en dehors de l'intervalle valide, prévu par le moteur JavaScript, a été utilisé pour une de ces méthodes :
+
+- {{jsxref("Number.prototype.toExponential()")}}
+- {{jsxref("Number.prototype.toFixed()")}}
+- {{jsxref("Number.prototype.toPrecision()")}}
+
+Généralement, ces méthodes acceptent des arguments de précision compris entre 0 et 20 (voire 21). Cependant, la spécification ECMAScript permet de gérer des valeurs en dehors de cet intervalle.
+
+| Méthode                                                      | Firefox (SpiderMonkey) | Chrome, Opera (V8) |
+| ------------------------------------------------------------ | ---------------------- | ------------------ |
+| {{jsxref("Number.prototype.toExponential()")}} | 0 to 100               | 0 to 20            |
+| {{jsxref("Number.prototype.toFixed()")}}         | -20 to 100             | 0 to 20            |
+| {{jsxref("Number.prototype.toPrecision()")}} | 1 to 100               | 1 to 21            |
+
+## Exemples
+
+### Exemples invalides
+
+```js example-bad
+77.1234.toExponential(-1);  // RangeError
 77.1234.toExponential(101); // RangeError
 
 2.34.toFixed(-100);         // RangeError
@@ -75,11 +52,12 @@ RangeError: toPrecision() argument must be between 1 and 21 (Chrome)
 
 1234.5.toPrecision(-1);     // RangeError
 1234.5.toPrecision(101);    // RangeError
-</pre>
+```
 
-<h3 id="Exemples_valides">Exemples valides</h3>
+### Exemples valides
 
-<pre class="brush: js example-good">77.1234.toExponential(4); // 7.7123e+1
+```js example-good
+77.1234.toExponential(4); // 7.7123e+1
 77.1234.toExponential(2); // 7.71e+1
 
 2.34.toFixed(1); // 2.3
@@ -88,12 +66,10 @@ RangeError: toPrecision() argument must be between 1 and 21 (Chrome)
 5.123456.toPrecision(5); // 5.1235
 5.123456.toPrecision(2); // 5.1
 5.123456.toPrecision(1); // 5
-</pre>
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("Number.prototype.toExponential()")}}</li>
- <li>{{jsxref("Number.prototype.toFixed()")}}</li>
- <li>{{jsxref("Number.prototype.toPrecision()")}}</li>
-</ul>
+- {{jsxref("Number.prototype.toExponential()")}}
+- {{jsxref("Number.prototype.toFixed()")}}
+- {{jsxref("Number.prototype.toPrecision()")}}
diff --git a/files/fr/web/javascript/reference/errors/property_access_denied/index.md b/files/fr/web/javascript/reference/errors/property_access_denied/index.md
index cb7818d3c3..2e8b3fc24d 100644
--- a/files/fr/web/javascript/reference/errors/property_access_denied/index.md
+++ b/files/fr/web/javascript/reference/errors/property_access_denied/index.md
@@ -9,40 +9,39 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/Property_access_denied
 original_slug: Web/JavaScript/Reference/Erreurs/Property_access_denied
 ---
-<div>{{jsSidebar("Errors")}}</div>
+{{jsSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">Error: Permission denied to access property "x"
-</pre>
+    Error: Permission denied to access property "x"
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>{{jsxref("Error")}}.</p>
+{{jsxref("Error")}}.
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p><span class="seoSummary">Il y a eu une tentative d'accès non-autorisée à un objet sur lequel vous n'avez pas de permissions. Généralement, cela se produit lorsqu'un élément {{HTMLElement("iframe")}} est chargée depuis un domaine différent et que <a href="/fr/docs/Web/JavaScript/Same_origin_policy_for_JavaScript">la condition de même origine</a> n'est pas respectée.</span></p>
+Il y a eu une tentative d'accès non-autorisée à un objet sur lequel vous n'avez pas de permissions. Généralement, cela se produit lorsqu'un élément {{HTMLElement("iframe")}} est chargée depuis un domaine différent et que [la condition de même origine](/fr/docs/Web/JavaScript/Same_origin_policy_for_JavaScript) n'est pas respectée.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<pre class="brush: html">&lt;!DOCTYPE html&gt;
-&lt;html&gt;
-  &lt;head&gt;
-    &lt;iframe id="myframe" src="http://www1.w3c-test.org/common/blank.html"&gt;&lt;/iframe&gt;
-    &lt;script&gt;
+```html
+<!DOCTYPE html>
+<html>
+  <head>
+    <iframe id="myframe" src="http://www1.w3c-test.org/common/blank.html"></iframe>
+    <script>
       onload = function() {
         console.log(frames[0].document);
         // Error: Permission denied to access property "document"
       }
-    &lt;/script&gt;
-  &lt;/head&gt;
-  &lt;body&gt;&lt;/body&gt;
-&lt;/html&gt;</pre>
+    </script>
+  </head>
+  <body></body>
+</html>
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{HTMLElement("iframe")}}</li>
- <li><a href="/fr/docs/Web/JavaScript/Same_origin_policy_for_JavaScript">Condition d'origine (<em>same-origin policy</em>)</a></li>
-</ul>
+- {{HTMLElement("iframe")}}
+- [Condition d'origine (_same-origin policy_)](/fr/docs/Web/JavaScript/Same_origin_policy_for_JavaScript)
diff --git a/files/fr/web/javascript/reference/errors/read-only/index.md b/files/fr/web/javascript/reference/errors/read-only/index.md
index d46e5a80e7..e207e6dc2a 100644
--- a/files/fr/web/javascript/reference/errors/read-only/index.md
+++ b/files/fr/web/javascript/reference/errors/read-only/index.md
@@ -8,34 +8,34 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/Read-only
 original_slug: Web/JavaScript/Reference/Erreurs/Read-only
 ---
-<div>{{jsSidebar("Errors")}}</div>
+{{jsSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">TypeError: Assignment to read-only properties is not allowed in strict mode (Edge)
-TypeError: "x" is read-only (Firefox)
-TypeError: 0 is read-only (Firefox)
-TypeError: Cannot assign to read only property 'x' of #&lt;Object&gt; (Chrome)
-TypeError: Cannot assign to read only property '0' of [object Array] (Chrome)
-</pre>
+    TypeError: Assignment to read-only properties is not allowed in strict mode (Edge)
+    TypeError: "x" is read-only (Firefox)
+    TypeError: 0 is read-only (Firefox)
+    TypeError: Cannot assign to read only property 'x' of #<Object> (Chrome)
+    TypeError: Cannot assign to read only property '0' of [object Array] (Chrome)
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>{{jsxref("TypeError")}}</p>
+{{jsxref("TypeError")}}
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p>La variable globale ou la propriété ne peut pas recevoir de valeur ou être modifiée car elle est en lecture seule (d'un point de vue technique, il s'agit d'<a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object/defineProperty#Attribut_writable">une propriété de donnée en lecture seule</a>).</p>
+La variable globale ou la propriété ne peut pas recevoir de valeur ou être modifiée car elle est en lecture seule (d'un point de vue technique, il s'agit d'[une propriété de donnée en lecture seule](/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object/defineProperty#Attribut_writable)).
 
-<p>Cette erreur ne se produit qu'avec <a href="/fr/docs/Web/JavaScript/Reference/Strict_mode">le mode strict</a>. En mode non-strict, l'affectation est ignorée silencieusement.</p>
+Cette erreur ne se produit qu'avec [le mode strict](/fr/docs/Web/JavaScript/Reference/Strict_mode). En mode non-strict, l'affectation est ignorée silencieusement.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Exemples_invalides">Exemples invalides</h3>
+### Exemples invalides
 
-<p>Les propriétés en lecture seule ne sont pas fréquemment utilisées mais on peut en créer en utilisant les méthodes {{jsxref("Object.defineProperty()")}} ou {{jsxref("Object.freeze()")}}.</p>
+Les propriétés en lecture seule ne sont pas fréquemment utilisées mais on peut en créer en utilisant les méthodes {{jsxref("Object.defineProperty()")}} ou {{jsxref("Object.freeze()")}}.
 
-<pre class="brush: js example-bad">"use strict";
+```js example-bad
+"use strict";
 var obj = Object.freeze({name: "Elsa", score: 157});
 obj.score = 0;  // TypeError
 
@@ -46,24 +46,27 @@ NB_POUMONS = 3;  // TypeError
 "use strict";
 var frozenArray = Object.freeze([0, 1, 2]);
 frozenArray[0]++;  // TypeError
-</pre>
+```
 
-<p>Quelques propriétés natives JavaScript sont également en lecture seule. Par exemple, on obtient cette erreur lorsqu'on souhaite redéfinir une constante mathématique.</p>
+Quelques propriétés natives JavaScript sont également en lecture seule. Par exemple, on obtient cette erreur lorsqu'on souhaite redéfinir une constante mathématique.
 
-<pre class="brush: js example-bad">"use strict";
+```js example-bad
+"use strict";
 Math.PI = 4;  // TypeError
-</pre>
+```
 
-<p>La variable globale <code>undefined</code> est également en lecture seule. On ne peut donc pas faire disparaître la fameuse erreur "<em>undefined is not a function</em>" avec ce code :</p>
+La variable globale `undefined` est également en lecture seule. On ne peut donc pas faire disparaître la fameuse erreur "_undefined is not a function_" avec ce code :
 
-<pre class="brush: js example-bad">"use strict";
+```js example-bad
+"use strict";
 undefined = function () {};
 // TypeError: "undefined" is read-only
-</pre>
+```
 
-<h3 id="Exemples_valides">Exemples valides</h3>
+### Exemples valides
 
-<pre class="brush: js example-good">"use strict";
+```js example-good
+"use strict";
 var obj = Object.freeze({name: "Score", points: 157});
 obj = {name: obj.name, points: 0};
 // En changeant d'objet, ça fonctionne
@@ -71,11 +74,9 @@ obj = {name: obj.name, points: 0};
 "use strict";
 var NB_POUMONS = 2;  // `var` fonctionne
 NB_POUMONS = 3;  // ok
-</pre>
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("Object.defineProperty()")}}</li>
- <li>{{jsxref("Object.freeze()")}}</li>
-</ul>
+- {{jsxref("Object.defineProperty()")}}
+- {{jsxref("Object.freeze()")}}
diff --git a/files/fr/web/javascript/reference/errors/redeclared_parameter/index.md b/files/fr/web/javascript/reference/errors/redeclared_parameter/index.md
index 55c0e38653..947a60aae8 100644
--- a/files/fr/web/javascript/reference/errors/redeclared_parameter/index.md
+++ b/files/fr/web/javascript/reference/errors/redeclared_parameter/index.md
@@ -8,56 +8,53 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/Redeclared_parameter
 original_slug: Web/JavaScript/Reference/Erreurs/Redeclared_parameter
 ---
-<div>{{jsSidebar("Errors")}}</div>
+{{jsSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">SyntaxError: Let/Const redeclaration (Edge)
-SyntaxError: redeclaration of formal parameter "x" (Firefox)
-SyntaxError: Identifier "x" has already been declared (Chrome)
-</pre>
+    SyntaxError: Let/Const redeclaration (Edge)
+    SyntaxError: redeclaration of formal parameter "x" (Firefox)
+    SyntaxError: Identifier "x" has already been declared (Chrome)
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>{{jsxref("SyntaxError")}}</p>
+{{jsxref("SyntaxError")}}
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p>Le même nom de variable est présent comme paramètre de la fonction et dans une affectation <code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/let">let</a></code> au sein du corps de cette fonction et il n'est pas possible de redéclarer la même variable dans la même fonction ou dans le même bloc avec <code>let</code>.</p>
+Le même nom de variable est présent comme paramètre de la fonction et dans une affectation [`let`](/fr/docs/Web/JavaScript/Reference/Instructions/let) au sein du corps de cette fonction et il n'est pas possible de redéclarer la même variable dans la même fonction ou dans le même bloc avec `let`.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<p>Dans le fragment de code qui suit, la variable <code>arg</code> redéclare l'argument passé à la fonction.</p>
+Dans le fragment de code qui suit, la variable `arg` redéclare l'argument passé à la fonction.
 
-<pre class="brush: js example-bad">function f(arg) {
+```js example-bad
+function f(arg) {
   let arg = "toto";
 }
 
 // SyntaxError: redeclaration of formal parameter "arg"
-</pre>
+```
 
-<p>Si on souhaite changer la valeur de <code>arg</code> dans le corps de la fonction, c'est possible mais il ne faut pas la redéclarer. Autrement dit, on peut retirer le mot-clé <code>let</code>. Si on souhaite plutôt créer une nouvelle variable, mieux vaudra utiliser un autre nom afin d'éviter les conflits avec les noms des paramètres existants.</p>
+Si on souhaite changer la valeur de `arg` dans le corps de la fonction, c'est possible mais il ne faut pas la redéclarer. Autrement dit, on peut retirer le mot-clé `let`. Si on souhaite plutôt créer une nouvelle variable, mieux vaudra utiliser un autre nom afin d'éviter les conflits avec les noms des paramètres existants.
 
-<pre class="brush: js example-good">function f(arg) {
+```js example-good
+function f(arg) {
   arg = "toto";
 }
 
 function f(arg) {
   let truc = "toto";
 }
-</pre>
+```
 
-<h2 id="Notes_de_compatibilité">Notes de compatibilité</h2>
+## Notes de compatibilité
 
-<ul>
- <li>Avant Firefox 49 {{geckoRelease(49)}}, cela provoquait une exception {{jsxref("TypeError")}} ({{bug(1275240)}}).</li>
-</ul>
+- Avant Firefox 49 {{geckoRelease(49)}}, cela provoquait une exception {{jsxref("TypeError")}} ({{bug(1275240)}}).
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li><code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/let">let</a></code></li>
- <li><code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/const">const</a></code></li>
- <li><code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/var">var</a></code></li>
- <li><a href="/fr/docs/Web/JavaScript/Guide/Types_et_grammaire#Déclarations">Déclarer des variables</a> dans le <a href="/fr/docs/Web/JavaScript/Guide">guide JavaScript</a></li>
-</ul>
+- [`let`](/fr/docs/Web/JavaScript/Reference/Instructions/let)
+- [`const`](/fr/docs/Web/JavaScript/Reference/Instructions/const)
+- [`var`](/fr/docs/Web/JavaScript/Reference/Instructions/var)
+- [Déclarer des variables](/fr/docs/Web/JavaScript/Guide/Types_et_grammaire#Déclarations) dans le [guide JavaScript](/fr/docs/Web/JavaScript/Guide)
diff --git a/files/fr/web/javascript/reference/errors/reduce_of_empty_array_with_no_initial_value/index.md b/files/fr/web/javascript/reference/errors/reduce_of_empty_array_with_no_initial_value/index.md
index 4afa3f08ed..aae211ac07 100644
--- a/files/fr/web/javascript/reference/errors/reduce_of_empty_array_with_no_initial_value/index.md
+++ b/files/fr/web/javascript/reference/errors/reduce_of_empty_array_with_no_initial_value/index.md
@@ -9,81 +9,81 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/Reduce_of_empty_array_with_no_initial_value
 original_slug: Web/JavaScript/Reference/Erreurs/Reduce_of_empty_array_with_no_initial_value
 ---
-<div>{{jsSidebar("Errors")}}</div>
+{{jsSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">TypeError: reduce of empty array with no initial value
-</pre>
+    TypeError: reduce of empty array with no initial value
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>{{jsxref("TypeError")}}</p>
+{{jsxref("TypeError")}}
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p>En JavaScript, il existe plusieurs fonctions qui permettent de réduire un tableau :</p>
+En JavaScript, il existe plusieurs fonctions qui permettent de réduire un tableau :
 
-<ul>
- <li>{{jsxref("Array.prototype.reduce()")}}, {{jsxref("Array.prototype.reduceRight()")}} ainsi que</li>
- <li>{{jsxref("TypedArray.prototype.reduce()")}},  {{jsxref("TypedArray.prototype.reduceRight()")}}).</li>
-</ul>
+- {{jsxref("Array.prototype.reduce()")}}, {{jsxref("Array.prototype.reduceRight()")}} ainsi que
+- {{jsxref("TypedArray.prototype.reduce()")}},  {{jsxref("TypedArray.prototype.reduceRight()")}}).
 
-<p>Ces fonctions utilisent un argument optionnel <code>valeurInitiale</code> (qui sera utilisée comme premier argument pour le premier appel du <code>callback</code>). Toutefois, si aucune valeur initiale explicite est fournie, la méthode utilisera le premier élément de l'objet  {{jsxref("Array")}} / {{jsxref("TypedArray")}} comme valeur initiale. Cette exception est déclenchée lorsqu'on souhaite réduire un tableau vide car aucune valeur initiale n'a été fournie.</p>
+Ces fonctions utilisent un argument optionnel `valeurInitiale` (qui sera utilisée comme premier argument pour le premier appel du `callback`). Toutefois, si aucune valeur initiale explicite est fournie, la méthode utilisera le premier élément de l'objet  {{jsxref("Array")}} / {{jsxref("TypedArray")}} comme valeur initiale. Cette exception est déclenchée lorsqu'on souhaite réduire un tableau vide car aucune valeur initiale n'a été fournie.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Exemples_invalides">Exemples invalides</h3>
+### Exemples invalides
 
-<p>Ce problème se produit lorsqu'on combine une méthode de filtrage ({{jsxref("Array.prototype.filter()")}}, {{jsxref("TypedArray.prototype.filter()")}}) qui retire tous les éléments du tableau. Si on applique ensuite une réduction, il n'y aura pas de valeur initiale.</p>
+Ce problème se produit lorsqu'on combine une méthode de filtrage ({{jsxref("Array.prototype.filter()")}}, {{jsxref("TypedArray.prototype.filter()")}}) qui retire tous les éléments du tableau. Si on applique ensuite une réduction, il n'y aura pas de valeur initiale.
 
-<pre class="brush: js example-bad">var ints = [0, -1, -2, -3, -4, -5];
-ints.filter(x =&gt; x &gt; 0)         // cet appel retire tous les éléments
-    .reduce((x, y) =&gt; x + y)    // aucun ne peut alors être utilisé comme valeur initiale</pre>
+```js example-bad
+var ints = [0, -1, -2, -3, -4, -5];
+ints.filter(x => x > 0)         // cet appel retire tous les éléments
+    .reduce((x, y) => x + y)    // aucun ne peut alors être utilisé comme valeur initiale
+```
 
-<p>Cela peut également se produire si on utilise un sélecteur avec une coquille ou que la liste contient un nombre d'élément inattendu:</p>
+Cela peut également se produire si on utilise un sélecteur avec une coquille ou que la liste contient un nombre d'élément inattendu:
 
-<pre class="brush: js example-bad">var names = document.getElementsByClassName("names");
-var name_list = Array.prototype.reduce.call(names, (acc, name) =&gt; acc + ", " + name);
-</pre>
+```js example-bad
+var names = document.getElementsByClassName("names");
+var name_list = Array.prototype.reduce.call(names, (acc, name) => acc + ", " + name);
+```
 
-<h3 id="Exemples_valides">Exemples valides</h3>
+### Exemples valides
 
-<p>On peut résoudre ces problèmes de deux façons.</p>
+On peut résoudre ces problèmes de deux façons.
 
-<p>On peut fournir une valeur initiale qui soit l'élément neutre de la réduction (par exemple 0 si on additionne, 1 si on multiplie ou la chaîne vide si on concatène du texte).</p>
+On peut fournir une valeur initiale qui soit l'élément neutre de la réduction (par exemple 0 si on additionne, 1 si on multiplie ou la chaîne vide si on concatène du texte).
 
-<pre class="brush: js example-good">var ints = [0, -1, -2, -3, -4, -5];
-ints.filter(x =&gt; x &gt; 0)         // removes all elements
-    .reduce((x, y) =&gt; x + y, 0) // the initial value is the neutral element of the addition
-</pre>
+```js example-good
+var ints = [0, -1, -2, -3, -4, -5];
+ints.filter(x => x > 0)         // removes all elements
+    .reduce((x, y) => x + y, 0) // the initial value is the neutral element of the addition
+```
 
-<p>On peut également gérer le cas où le tableau est vide, avant d'appeler <code>reduce</code> ou dans le <em>callback</em> après avoir ajouté une valeur initiale.</p>
+On peut également gérer le cas où le tableau est vide, avant d'appeler `reduce` ou dans le _callback_ après avoir ajouté une valeur initiale.
 
-<pre class="brush: js example-good">var names = document.getElementsByClassName("names");
+```js example-good
+var names = document.getElementsByClassName("names");
 
 var nameList1 = "";
-if (names1.length &gt;= 1)
-  nameList1 = Array.prototype.reduce.call(names, (acc, name) =&gt; acc + ", " + name);
+if (names1.length >= 1)
+  nameList1 = Array.prototype.reduce.call(names, (acc, name) => acc + ", " + name);
 // nameList1 == "" lorsque names est vide
 
-var nameList2 = Array.prototype.reduce.call(names, (acc, name) =&gt; {
+var nameList2 = Array.prototype.reduce.call(names, (acc, name) => {
   if (acc == "") // la valeur initiale
     return name;
   return acc + ", " + name;
 }, "");
 // nameList2 == "" lorsque names est vide
-</pre>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Array.prototype.reduce()")}}</li>
- <li>{{jsxref("Array.prototype.reduceRight()")}}</li>
- <li>{{jsxref("TypedArray.prototype.reduce()")}}</li>
- <li>{{jsxref("TypedArray.prototype.reduceRight()")}}</li>
- <li>{{jsxref("Array")}}</li>
- <li>{{jsxref("TypedArray")}}</li>
- <li>{{jsxref("Array.prototype.filter()")}}</li>
- <li>{{jsxref("TypedArray.prototype.filter()")}}</li>
-</ul>
+```
+
+## Voir aussi
+
+- {{jsxref("Array.prototype.reduce()")}}
+- {{jsxref("Array.prototype.reduceRight()")}}
+- {{jsxref("TypedArray.prototype.reduce()")}}
+- {{jsxref("TypedArray.prototype.reduceRight()")}}
+- {{jsxref("Array")}}
+- {{jsxref("TypedArray")}}
+- {{jsxref("Array.prototype.filter()")}}
+- {{jsxref("TypedArray.prototype.filter()")}}
diff --git a/files/fr/web/javascript/reference/errors/reserved_identifier/index.md b/files/fr/web/javascript/reference/errors/reserved_identifier/index.md
index f632ea336e..e911418f06 100644
--- a/files/fr/web/javascript/reference/errors/reserved_identifier/index.md
+++ b/files/fr/web/javascript/reference/errors/reserved_identifier/index.md
@@ -8,75 +8,74 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/Reserved_identifier
 original_slug: Web/JavaScript/Reference/Erreurs/Reserved_identifier
 ---
-<div>{{jsSidebar("Errors")}}</div>
+{{jsSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">SyntaxError: The use of a future reserved word for an identifier is invalid (Edge)
-SyntaxError: "x" is a reserved identifier (Firefox)
-SyntaxError: Unexpected reserved word (Chrome)</pre>
+    SyntaxError: The use of a future reserved word for an identifier is invalid (Edge)
+    SyntaxError: "x" is a reserved identifier (Firefox)
+    SyntaxError: Unexpected reserved word (Chrome)
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>{{jsxref("SyntaxError")}}</p>
+{{jsxref("SyntaxError")}}
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p><a href="/fr/docs/Web/JavaScript/Reference/Grammaire_lexicale#Mots-clés_réservés_selon_ECMAScript_2015">Les mots-clés réservés</a> lèveront une exception s'ils sont utilisés en tant qu'identifiants. Voici les mots-clés réservés en mode strict et en mode <em>sloppy</em> :</p>
+[Les mots-clés réservés](/fr/docs/Web/JavaScript/Reference/Grammaire_lexicale#Mots-clés_réservés_selon_ECMAScript_2015) lèveront une exception s'ils sont utilisés en tant qu'identifiants. Voici les mots-clés réservés en mode strict et en mode _sloppy_ :
 
-<ul>
- <li><code>enum</code></li>
-</ul>
+- `enum`
 
-<p>Voici les mots-clés uniquement réservés en mode strict :</p>
+Voici les mots-clés uniquement réservés en mode strict :
 
-<ul class="threecolumns">
- <li><code>implements</code></li>
- <li><code>interface</code></li>
- <li>{{jsxref("Statements/let", "let")}}</li>
- <li><code>package</code></li>
- <li><code>private</code></li>
- <li><code>protected</code></li>
- <li><code>public</code></li>
- <li><code>static</code></li>
-</ul>
+- `implements`
+- `interface`
+- {{jsxref("Statements/let", "let")}}
+- `package`
+- `private`
+- `protected`
+- `public`
+- `static`
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Mots-clés_réservés_en_modes_strict_et_non-strict">Mots-clés réservés en modes strict et non-strict</h3>
+### Mots-clés réservés en modes strict et non-strict
 
-<p>L'identifiant <code>enum</code> est réservé dans les différents cas :</p>
+L'identifiant `enum` est réservé dans les différents cas :
 
-<pre class="brush: js example-bad">var enum = { RED: 0, GREEN: 1, BLUE: 2 };
+```js example-bad
+var enum = { RED: 0, GREEN: 1, BLUE: 2 };
 // SyntaxError: enum is a reserved identifier
-</pre>
+```
 
-<p>En mode strict, d'autres mots-clés sont réservés :</p>
+En mode strict, d'autres mots-clés sont réservés :
 
-<pre class="brush: js example-bad">"use strict";
+```js example-bad
+"use strict";
 var package = ["pomme", "poire", "pêches"];
 // SyntaxError: package is a reserved identifier
-</pre>
+```
 
-<p>Pour ne pas avoir l'erreur, il faudra renommer les variables :</p>
+Pour ne pas avoir l'erreur, il faudra renommer les variables :
 
-<pre class="brush: js example-good">var enumCouleurs = { RED: 0, GREEN: 1, BLUE: 2 };
-var liste = ["pomme", "poire", "pêches"];</pre>
+```js example-good
+var enumCouleurs = { RED: 0, GREEN: 1, BLUE: 2 };
+var liste = ["pomme", "poire", "pêches"];
+```
 
-<h3 id="Mettre_à_jour_les_anciens_navigateurs">Mettre à jour les anciens navigateurs</h3>
+### Mettre à jour les anciens navigateurs
 
-<p>Si vous utilisez un ancien navigateur qui n'implémente pas <code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/let">let</a></code> ou <code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/class">class</a></code>, vous devrez mettre à jour votre navigateur :</p>
+Si vous utilisez un ancien navigateur qui n'implémente pas [`let`](/fr/docs/Web/JavaScript/Reference/Instructions/let) ou [`class`](/fr/docs/Web/JavaScript/Reference/Instructions/class), vous devrez mettre à jour votre navigateur :
 
-<pre class="brush: js">"use strict";
+```js
+"use strict";
 class DocArchiver {}
 
 // SyntaxError: class is a reserved identifier
 // (lève une exception dans les anciens navigateurs
 // tels que Firefox 44 et les versions antérieures)
-</pre>
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li><a href="https://wiki.c2.com/?GoodVariableNames">Utiliser de bons noms de variable</a></li>
-</ul>
+- [Utiliser de bons noms de variable](https://wiki.c2.com/?GoodVariableNames)
diff --git a/files/fr/web/javascript/reference/errors/resulting_string_too_large/index.md b/files/fr/web/javascript/reference/errors/resulting_string_too_large/index.md
index 78ad63d9f3..1c4eddce51 100644
--- a/files/fr/web/javascript/reference/errors/resulting_string_too_large/index.md
+++ b/files/fr/web/javascript/reference/errors/resulting_string_too_large/index.md
@@ -8,43 +8,42 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/Resulting_string_too_large
 original_slug: Web/JavaScript/Reference/Erreurs/Resulting_string_too_large
 ---
-<div>{{jsSidebar("Errors")}}</div>
+{{jsSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">RangeError: argument out of range (Edge)
-RangeError: repeat count must be less than infinity and not overflow maximum string size (Firefox)
-RangeError: Invalid count value (Chrome)
-</pre>
+    RangeError: argument out of range (Edge)
+    RangeError: repeat count must be less than infinity and not overflow maximum string size (Firefox)
+    RangeError: Invalid count value (Chrome)
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>{{jsxref("RangeError")}}</p>
+{{jsxref("RangeError")}}
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p>La méthode {{jsxref("String.prototype.repeat()")}}, qui permet de répéter une chaîne de caractères, a été utilisée avec un argument qui n'est pas compris entre 0 et {{jsxref("Infinity")}} (exclue) (ce qui correspond à l'intervalle [0, +∞))</p>
+La méthode {{jsxref("String.prototype.repeat()")}}, qui permet de répéter une chaîne de caractères, a été utilisée avec un argument qui n'est pas compris entre 0 et {{jsxref("Infinity")}} (exclue) (ce qui correspond à l'intervalle \[0, +∞))
 
-<p>La chaîne de caractères crée par cette méthode ne doit pas dépasser la taille maximale d'une chaîne. Cette taille varie selon le moteur JavaScript. Pour Firefox (SpiderMonkey), la taille maximale d'une chaîne de caractères vaut 2^28-1 (<code>0xFFFFFFF</code>).</p>
+La chaîne de caractères crée par cette méthode ne doit pas dépasser la taille maximale d'une chaîne. Cette taille varie selon le moteur JavaScript. Pour Firefox (SpiderMonkey), la taille maximale d'une chaîne de caractères vaut 2^28-1 (`0xFFFFFFF`).
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Exemples_invalides">Exemples invalides</h3>
+### Exemples invalides
 
-<pre class="brush: js example-bad">'abc'.repeat(Infinity); // RangeError
+```js example-bad
+'abc'.repeat(Infinity); // RangeError
 'a'.repeat(2**28);      // RangeError
-</pre>
+```
 
-<h3 id="Exemples_valides">Exemples valides</h3>
+### Exemples valides
 
-<pre class="brush: js example-good">'abc'.repeat(0);    // ''
+```js example-good
+'abc'.repeat(0);    // ''
 'abc'.repeat(1);    // 'abc'
 'abc'.repeat(2);    // 'abcabc'
 'abc'.repeat(3.5);  // 'abcabcabc' (count will be converted to integer)
-</pre>
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("String.prototype.repeat()")}}</li>
-</ul>
+- {{jsxref("String.prototype.repeat()")}}
diff --git a/files/fr/web/javascript/reference/errors/stmt_after_return/index.md b/files/fr/web/javascript/reference/errors/stmt_after_return/index.md
index 4d506a6285..0105e66e3a 100644
--- a/files/fr/web/javascript/reference/errors/stmt_after_return/index.md
+++ b/files/fr/web/javascript/reference/errors/stmt_after_return/index.md
@@ -7,44 +7,40 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/Stmt_after_return
 original_slug: Web/JavaScript/Reference/Erreurs/Stmt_after_return
 ---
-<div>{{jsSidebar("Errors")}}</div>
+{{jsSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">Warning: unreachable code after return statement (Firefox)
-</pre>
+    Warning: unreachable code after return statement (Firefox)
 
-<h2 id="Type_derreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>Avertissement</p>
+Avertissement
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p>Ce problème peut avoir deux origines :</p>
+Ce problème peut avoir deux origines :
 
-<ul>
- <li>Une expression a été utilisée après l'instruction {{jsxref("Instructions/return", "return")}}</li>
- <li>Une instruction <code>return</code> a été utilisée sans point virgule mais une expression suivait cette instruction.</li>
-</ul>
+- Une expression a été utilisée après l'instruction {{jsxref("Instructions/return", "return")}}
+- Une instruction `return` a été utilisée sans point virgule mais une expression suivait cette instruction.
 
-<p>Lorsqu'une expression existe après une instruction <code>return</code> valide, un avertissement est produit pour alerter qu'une portion du code ne peut pas être atteinte et ne sera donc jamais lue et exécutée.</p>
+Lorsqu'une expression existe après une instruction `return` valide, un avertissement est produit pour alerter qu'une portion du code ne peut pas être atteinte et ne sera donc jamais lue et exécutée.
 
-<p>Pourquoi est-il préférable d'ajouter des points-virgules après les instructions <code>return</code> ? Si on utilise une instruction <code>return</code> sans point-virgule, cela peut créer une ambiguïté : est-ce que le développeur souhaite que le code qui suit sur la ligne d'après soit exécuté ou non ? L'avertissement relève cette ambiguïté afin de mieux la percevoir pour la lever.</p>
+Pourquoi est-il préférable d'ajouter des points-virgules après les instructions `return` ? Si on utilise une instruction `return` sans point-virgule, cela peut créer une ambiguïté : est-ce que le développeur souhaite que le code qui suit sur la ligne d'après soit exécuté ou non ? L'avertissement relève cette ambiguïté afin de mieux la percevoir pour la lever.
 
-<p>Les avertissements ne seront pas affichés pour les <code>return</code> sans point-virgule si ces instructions suivent :</p>
+Les avertissements ne seront pas affichés pour les `return` sans point-virgule si ces instructions suivent :
 
-<ul>
- <li>{{jsxref("Instructions/throw", "throw")}}</li>
- <li>{{jsxref("Instructions/break", "break")}}</li>
- <li>{{jsxref("Instructions/var", "var")}}</li>
- <li>{{jsxref("Instructions/function", "function")}}</li>
-</ul>
+- {{jsxref("Instructions/throw", "throw")}}
+- {{jsxref("Instructions/break", "break")}}
+- {{jsxref("Instructions/var", "var")}}
+- {{jsxref("Instructions/function", "function")}}
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Exemples_invalides">Exemples invalides</h3>
+### Exemples invalides
 
-<pre class="brush: js example-bad">function f() {
+```js example-bad
+function f() {
   var x = 3;
   x += 4;
   return x;   // return permet de finir la fonction sur le champ
@@ -55,11 +51,12 @@ function f() {
   return     // Cette instruction est traitée `return;`
     3 + 4;   // La fonction termine et cette ligne n'est jamais traitée
 }
-</pre>
+```
 
-<h3 id="Exemples_valides">Exemples valides</h3>
+### Exemples valides
 
-<pre class="brush: js example-good">function f() {
+```js example-good
+function f() {
   var x = 3;
   x += 4;
   x -= 3;
@@ -71,10 +68,8 @@ function f() {
   return 3 + 4  // OK : un return sans point-virgule
                 // avec une expression sur la même ligne
 }
-</pre>
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("Instructions/return", "L'ajout automatique de point-virgule", "#Ajout_automatique_de_point-virgule", 1)}}</li>
-</ul>
+- {{jsxref("Instructions/return", "L'ajout automatique de point-virgule", "#Ajout_automatique_de_point-virgule", 1)}}
diff --git a/files/fr/web/javascript/reference/errors/strict_non_simple_params/index.md b/files/fr/web/javascript/reference/errors/strict_non_simple_params/index.md
index 26abbf3a40..22d30809a4 100644
--- a/files/fr/web/javascript/reference/errors/strict_non_simple_params/index.md
+++ b/files/fr/web/javascript/reference/errors/strict_non_simple_params/index.md
@@ -9,108 +9,109 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/Strict_Non_Simple_Params
 original_slug: Web/JavaScript/Reference/Erreurs/Strict_Non_Simple_Params
 ---
-<div>{{jsSidebar("Errors")}}</div>
+{{jsSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">Edge:
-Cannot apply strict mode on functions with non-simple parameter list
+    Edge:
+    Cannot apply strict mode on functions with non-simple parameter list
 
-Firefox:
-SyntaxError: "use strict" not allowed in function with default parameter
-SyntaxError: "use strict" not allowed in function with rest parameter
-SyntaxError: "use strict" not allowed in function with destructuring parameter
+    Firefox:
+    SyntaxError: "use strict" not allowed in function with default parameter
+    SyntaxError: "use strict" not allowed in function with rest parameter
+    SyntaxError: "use strict" not allowed in function with destructuring parameter
 
-Chrome:
-SyntaxError: Illegal 'use strict' directive in function with non-simple parameter list
-</pre>
+    Chrome:
+    SyntaxError: Illegal 'use strict' directive in function with non-simple parameter list
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>{{jsxref("SyntaxError")}}.</p>
+{{jsxref("SyntaxError")}}.
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p>Une directive <code>"use strict"</code> apparaît au début d'une fonction qui possède l'un des paramètres suivants :</p>
+Une directive `"use strict"` apparaît au début d'une fonction qui possède l'un des paramètres suivants :
 
-<ul>
- <li>{{jsxref("Fonctions/Valeurs_par_défaut_des_arguments", "Des paramètres par défaut", "", 1)}}</li>
- <li>{{jsxref("Fonctions/paramètres_du_reste", "Des paramètres du reste", "", 1)}}</li>
- <li>{{jsxref("Opérateurs/Affecter_par_décomposition", "Des paramètres décomposés", "", 1)}}</li>
-</ul>
+- {{jsxref("Fonctions/Valeurs_par_défaut_des_arguments", "Des paramètres par défaut", "", 1)}}
+- {{jsxref("Fonctions/paramètres_du_reste", "Des paramètres du reste", "", 1)}}
+- {{jsxref("Opérateurs/Affecter_par_décomposition", "Des paramètres décomposés", "", 1)}}
 
-<p>Selon la spécification ECMAScript, une directive <code>"use strict"</code> ne peut pas être utilisée pour de telles fonctions.</p>
+Selon la spécification ECMAScript, une directive `"use strict"` ne peut pas être utilisée pour de telles fonctions.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Déclaration_de_fonction">Déclaration de fonction</h3>
+### Déclaration de fonction
 
-<p>Dans l'exemple qui suit, la fonction <code>somme</code> possède deux paramètres par défaut <code>a=1</code> et <code>b=2</code>.</p>
+Dans l'exemple qui suit, la fonction `somme` possède deux paramètres par défaut `a=1` et `b=2`.
 
-<pre class="brush: js example-bad">function somme(a = 1, b = 2) {
+```js example-bad
+function somme(a = 1, b = 2) {
   // SyntaxError: "use strict" not allowed in function with default parameter
   "use strict";
   return a + b;
 }
-</pre>
+```
 
-<p>Si on veut que la fonction soit en mode strict et que le script entier ou que la fonction englobante peut être en mode strict, il suffira de déplacer l'instruction <code>"use strict"</code> en dehors du corps de la méthode.</p>
+Si on veut que la fonction soit en mode strict et que le script entier ou que la fonction englobante peut être en mode strict, il suffira de déplacer l'instruction `"use strict"` en dehors du corps de la méthode.
 
-<pre class="brush: js example-good">"use strict";
+```js example-good
+"use strict";
 function somme(a = 1, b = 2) {
   return a + b;
 }
-</pre>
+```
 
-<h3 id="Expression_de_fonction">Expression de fonction</h3>
+### Expression de fonction
 
-<p>Il est également possible d'utiliser les expressions de fonction pour résoudre ce problème :</p>
+Il est également possible d'utiliser les expressions de fonction pour résoudre ce problème :
 
-<pre class="brush: js example-bad">var somme = function somme([a, b]) {
+```js example-bad
+var somme = function somme([a, b]) {
   // SyntaxError: "use strict" not allowed in function with destructuring parameter
   "use strict";
   return a + b;
 };
-</pre>
+```
 
-<p>On peut convertir le fragment de code précédent avec l'expression suivante :</p>
+On peut convertir le fragment de code précédent avec l'expression suivante :
 
-<pre class="brush: js example-good">var somme = (function() {
+```js example-good
+var somme = (function() {
   "use strict";
   return function somme([a, b]) {
     return a + b;
   };
 })();
-</pre>
+```
 
-<h3 id="Fonction_fléchée">Fonction fléchée</h3>
+### Fonction fléchée
 
-<p>Si on a une fonction fléchée qui doit accéder à la variable <code>this</code> on peut utiliser une fonction fléchée comme fonction englobante :</p>
+Si on a une fonction fléchée qui doit accéder à la variable `this` on peut utiliser une fonction fléchée comme fonction englobante :
 
-<pre class="brush: js example-bad">var callback = (...args) =&gt; {
+```js example-bad
+var callback = (...args) => {
   // SyntaxError: "use strict" not allowed in function with rest parameter
   "use strict";
   return this.run(args);
 };
-</pre>
+```
 
-<p>This can be converted into following expression.</p>
+This can be converted into following expression.
 
-<pre class="brush: js example-good">var callback = (() =&gt; {
+```js example-good
+var callback = (() => {
   "use strict";
-  return (...args) =&gt; {
+  return (...args) => {
     return this.run(args);
   };
 })();
-</pre>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Strict_mode", "Le mode strict", "", 1)}}</li>
- <li>{{jsxref("Instructions/function", "L'instruction function", "", 1)}}</li>
- <li>{{jsxref("Op%C3%A9rateurs/L_op%C3%A9rateur_function", "Les expressions de fonction", "", 1)}}</li>
- <li>{{jsxref("Fonctions/Valeurs_par_d%C3%A9faut_des_arguments", "Les paramètres par défaut", "", 1)}}</li>
- <li>{{jsxref("Fonctions/paramètres_du_reste", "Les paramètres du reste", "", 1)}}</li>
- <li>{{jsxref("Opérateurs/Affecter_par_décomposition", "Les paramètres décomposés", "", 1)}}</li>
-</ul>
+```
+
+## Voir aussi
+
+- {{jsxref("Strict_mode", "Le mode strict", "", 1)}}
+- {{jsxref("Instructions/function", "L'instruction function", "", 1)}}
+- {{jsxref("Op%C3%A9rateurs/L_op%C3%A9rateur_function", "Les expressions de fonction", "", 1)}}
+- {{jsxref("Fonctions/Valeurs_par_d%C3%A9faut_des_arguments", "Les paramètres par défaut", "", 1)}}
+- {{jsxref("Fonctions/paramètres_du_reste", "Les paramètres du reste", "", 1)}}
+- {{jsxref("Opérateurs/Affecter_par_décomposition", "Les paramètres décomposés", "", 1)}}
diff --git a/files/fr/web/javascript/reference/errors/too_much_recursion/index.md b/files/fr/web/javascript/reference/errors/too_much_recursion/index.md
index 097eff25b7..62e269f74a 100644
--- a/files/fr/web/javascript/reference/errors/too_much_recursion/index.md
+++ b/files/fr/web/javascript/reference/errors/too_much_recursion/index.md
@@ -9,62 +9,64 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/Too_much_recursion
 original_slug: Web/JavaScript/Reference/Erreurs/Too_much_recursion
 ---
-<div>{{jsSidebar("Errors")}}</div>
+{{jsSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">Error: Out of stack space (Edge)
-InternalError: too much recursion (Firefox)
-RangeError: Maximum call stack size exceeded (Chrome)
-</pre>
+    Error: Out of stack space (Edge)
+    InternalError: too much recursion (Firefox)
+    RangeError: Maximum call stack size exceeded (Chrome)
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>{{jsxref("InternalError")}}.</p>
+{{jsxref("InternalError")}}.
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p>Une fonction qui s'appelle elle-même est une fonction <em>recursive</em>. Lorsqu'une certaine condition est respectée, la fonction arrête de s'appeler elle-même, c'est ce qu'on appelle le cas initial.</p>
+Une fonction qui s'appelle elle-même est une fonction _recursive_. Lorsqu'une certaine condition est respectée, la fonction arrête de s'appeler elle-même, c'est ce qu'on appelle le cas initial.
 
-<p>D'une certaine façon, une récursion est semblable à une boucle. Les deux exécutent le même code plusieurs fois, et les deux ont besoin d'une condition d'arrêt afin d'éviter une boucle infinie ou une récursion infinie. Lorsqu'il y a trop de niveaux de récursion ou une récursion infinie, JavaScript lèvera cette erreur.</p>
+D'une certaine façon, une récursion est semblable à une boucle. Les deux exécutent le même code plusieurs fois, et les deux ont besoin d'une condition d'arrêt afin d'éviter une boucle infinie ou une récursion infinie. Lorsqu'il y a trop de niveaux de récursion ou une récursion infinie, JavaScript lèvera cette erreur.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<p>Cette fonction récursive est exécutée 10 fois comme l'indique la condition de sortie :</p>
+Cette fonction récursive est exécutée 10 fois comme l'indique la condition de sortie :
 
-<pre class="brush: js">function loop(x) {
-  if (x &gt;= 10) // "x &gt;= 10" is the exit condition
+```js
+function loop(x) {
+  if (x >= 10) // "x >= 10" is the exit condition
     return;
   // do stuff
   loop(x + 1); // the recursive call
 }
-loop(0);</pre>
+loop(0);
+```
 
-<p>Si la condition d'arrêt est beaucoup trop grande, cela ne fonctionnera pas :</p>
+Si la condition d'arrêt est beaucoup trop grande, cela ne fonctionnera pas :
 
-<pre class="brush: js example-bad">function loop(x) {
-  if (x &gt;= 1000000000000)
+```js example-bad
+function loop(x) {
+  if (x >= 1000000000000)
     return;
   // do stuff
   loop(x + 1);
 }
 loop(0);
 
-// InternalError: too much recursion</pre>
+// InternalError: too much recursion
+```
 
-<p>Si la fonction récursive ne possède pas de cas initial, il n'y aura pas de condition de sortie et la fonction continuera de s'appeler indéfiniment.</p>
+Si la fonction récursive ne possède pas de cas initial, il n'y aura pas de condition de sortie et la fonction continuera de s'appeler indéfiniment.
 
-<pre class="brush: js example-bad">function boucle(x) {
+```js example-bad
+function boucle(x) {
   boucle(x + 1);
   // il n'y a pas de cas initial
 }
 
 boucle(0);
-</pre>
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{Glossary("Récursion")}}</li>
- <li><a href="/fr/docs/Web/JavaScript/Guide/Fonctions#La_récursivité">Les fonctions récursives</a></li>
-</ul>
+- {{Glossary("Récursion")}}
+- [Les fonctions récursives](/fr/docs/Web/JavaScript/Guide/Fonctions#La_récursivité)
diff --git a/files/fr/web/javascript/reference/errors/undeclared_var/index.md b/files/fr/web/javascript/reference/errors/undeclared_var/index.md
index 26293dc271..8344607e21 100644
--- a/files/fr/web/javascript/reference/errors/undeclared_var/index.md
+++ b/files/fr/web/javascript/reference/errors/undeclared_var/index.md
@@ -8,60 +8,58 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/Undeclared_var
 original_slug: Web/JavaScript/Reference/Erreurs/Undeclared_var
 ---
-<div>{{jsSidebar("Errors")}}</div>
+{{jsSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">ReferenceError: assignment to undeclared variable "x" (Firefox)
-ReferenceError: "x" is not defined (Chrome)
-ReferenceError: Variable undefined in strict mode (Edge)
-</pre>
+    ReferenceError: assignment to undeclared variable "x" (Firefox)
+    ReferenceError: "x" is not defined (Chrome)
+    ReferenceError: Variable undefined in strict mode (Edge)
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>Une erreur {{jsxref("ReferenceError")}}, uniquement <a href="/fr/docs/Web/JavaScript/Reference/Strict_mode">en mode strict</a>.</p>
+Une erreur {{jsxref("ReferenceError")}}, uniquement [en mode strict](/fr/docs/Web/JavaScript/Reference/Strict_mode).
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p>Une valeur a été affectée à une variable non-déclarée. Autrement dit, il y a eu une affectation qui n'utilise pas le mot-clé <code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/var">var</a></code>. Il existe certaines différences entre les variables déclarées et les variables non déclarées ce qui peut entraîner des résultats étranges. C'est pour cette raison que le moteur affiche une erreur en mode strict.</p>
+Une valeur a été affectée à une variable non-déclarée. Autrement dit, il y a eu une affectation qui n'utilise pas le mot-clé [`var`](/fr/docs/Web/JavaScript/Reference/Instructions/var). Il existe certaines différences entre les variables déclarées et les variables non déclarées ce qui peut entraîner des résultats étranges. C'est pour cette raison que le moteur affiche une erreur en mode strict.
 
-<p>Trois choses à noter lorsqu'on évoque les variables déclarées/non déclarées :</p>
+Trois choses à noter lorsqu'on évoque les variables déclarées/non déclarées :
 
-<ul>
- <li>Les variables déclarées sont contraintes dans le contexte d'exécution dans lequel elles sont déclarées. Les variables non déclarées sont toujours globales.</li>
- <li>Les variables déclarées sont créées avant que le code soit exécuté. Les variables non déclarées n'existent pas tant que le code qui leur est affecté est exécuté.</li>
- <li>Les variables déclarées sont des propriétés non-configurables de leur contexte d'exécution (la fonction ou l'espace global). Les variables non-déclarées sont configurables (elles peuvent être supprimées).</li>
-</ul>
+- Les variables déclarées sont contraintes dans le contexte d'exécution dans lequel elles sont déclarées. Les variables non déclarées sont toujours globales.
+- Les variables déclarées sont créées avant que le code soit exécuté. Les variables non déclarées n'existent pas tant que le code qui leur est affecté est exécuté.
+- Les variables déclarées sont des propriétés non-configurables de leur contexte d'exécution (la fonction ou l'espace global). Les variables non-déclarées sont configurables (elles peuvent être supprimées).
 
-<p>Pour plus de détails et d'exemple, se référer à la page sur <code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/var">var</a></code>.</p>
+Pour plus de détails et d'exemple, se référer à la page sur [`var`](/fr/docs/Web/JavaScript/Reference/Instructions/var).
 
-<p>Les erreurs à propos des affectations sur les variables non déclarées se produisent uniquement <a href="/fr/docs/Web/JavaScript/Reference/Strict_mode">en mode strict</a>. En mode non-strict, elles sont ignorées silencieusement.</p>
+Les erreurs à propos des affectations sur les variables non déclarées se produisent uniquement [en mode strict](/fr/docs/Web/JavaScript/Reference/Strict_mode). En mode non-strict, elles sont ignorées silencieusement.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Exemples_invalides">Exemples invalides</h3>
+### Exemples invalides
 
-<p>Ici, la variable <code>truc</code> n'est pas déclarée :</p>
+Ici, la variable `truc` n'est pas déclarée :
 
-<pre class="brush: js example-bad">function toto() {
+```js example-bad
+function toto() {
   "use strict";
   truc = true;
 }
 toto(); // ReferenceError: assignment to undeclared variable truc
-</pre>
+```
 
-<h3 id="Exemples_valides">Exemples valides</h3>
+### Exemples valides
 
-<p>Afin de déclarer <code>truc</code>, on peut ajouter le mot-clé <code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/var">var</a></code> devant.</p>
+Afin de déclarer `truc`, on peut ajouter le mot-clé [`var`](/fr/docs/Web/JavaScript/Reference/Instructions/var) devant.
 
-<pre class="brush: js example-good">function toto() {
+```js example-good
+function toto() {
   "use strict";
   var truc = true;
 }
-toto();</pre>
+toto();
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li><a href="/fr/docs/Web/JavaScript/Reference/Strict_mode">Le mode strict</a></li>
-</ul>
+- [Le mode strict](/fr/docs/Web/JavaScript/Reference/Strict_mode)
diff --git a/files/fr/web/javascript/reference/errors/undefined_prop/index.md b/files/fr/web/javascript/reference/errors/undefined_prop/index.md
index b3b000d302..3577d40eb6 100644
--- a/files/fr/web/javascript/reference/errors/undefined_prop/index.md
+++ b/files/fr/web/javascript/reference/errors/undefined_prop/index.md
@@ -9,38 +9,39 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/Undefined_prop
 original_slug: Web/JavaScript/Reference/Erreurs/Undefined_prop
 ---
-<div>{{jsSidebar("Errors")}}</div>
+{{jsSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">ReferenceError: reference to undefined property "x" (Firefox)
-</pre>
+    ReferenceError: reference to undefined property "x" (Firefox)
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>Uniquement pour Firefox. Une erreur {{jsxref("ReferenceError")}} lancée en avertissement, uniquement si la préférence <code>javascript.options.strict</code> vaut <code>true</code>.</p>
+Uniquement pour Firefox. Une erreur {{jsxref("ReferenceError")}} lancée en avertissement, uniquement si la préférence `javascript.options.strict` vaut `true`.
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p>Le code tente d'accéder à une propriété inexistante d'un objet. Il existe deux méthodes pour accéder aux propriétés. Pour plus de détails, on pourra lire la page de la référence sur <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_membres">les accesseurs de propriété</a>.</p>
+Le code tente d'accéder à une propriété inexistante d'un objet. Il existe deux méthodes pour accéder aux propriétés. Pour plus de détails, on pourra lire la page de la référence sur [les accesseurs de propriété](/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_membres).
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Exemples_invalides">Exemples invalides</h3>
+### Exemples invalides
 
-<p>Ici, la propriété <code>truc</code> n'est pas une propriété définie et on obtient alors une <code>ReferenceError</code>.</p>
+Ici, la propriété `truc` n'est pas une propriété définie et on obtient alors une `ReferenceError`.
 
-<pre class="brush: js example-bad">"use strict";
+```js example-bad
+"use strict";
 
 var toto = {};
 toto.truc; // ReferenceError: reference to undefined property "bar"
-</pre>
+```
 
-<h3 id="Exemples_valides">Exemples valides</h3>
+### Exemples valides
 
-<p>Pour éviter cette erreur, il faut que <code>truc</code> soit une variable  « définie » ou vérifier son existence avant de l'utiliser (en utilisant par exemple la méthode {{jsxref("Object.prototype.hasOwnProperty()")}}).</p>
+Pour éviter cette erreur, il faut que `truc` soit une variable  « définie » ou vérifier son existence avant de l'utiliser (en utilisant par exemple la méthode {{jsxref("Object.prototype.hasOwnProperty()")}}).
 
-<pre class="brush: js example-good">"use strict";
+```js example-good
+"use strict";
 
 var toto = {};
 
@@ -49,10 +50,9 @@ console.log(toto.truc); // "lune"
 
 if (foo.hasOwnProperty("truc")) {
   console.log(toto.truc);
-}</pre>
+}
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("Opérateurs/Opérateurs_de_membres", "Accesseurs de propriété", 0, 1)}}</li>
-</ul>
+- {{jsxref("Opérateurs/Opérateurs_de_membres", "Accesseurs de propriété", 0, 1)}}
diff --git a/files/fr/web/javascript/reference/errors/unexpected_token/index.md b/files/fr/web/javascript/reference/errors/unexpected_token/index.md
index 771455c514..f2a9fb865a 100644
--- a/files/fr/web/javascript/reference/errors/unexpected_token/index.md
+++ b/files/fr/web/javascript/reference/errors/unexpected_token/index.md
@@ -9,70 +9,74 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/Unexpected_token
 original_slug: Web/JavaScript/Reference/Erreurs/Unexpected_token
 ---
-<div>{{jsSidebar("Errors")}}</div>
+{{jsSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">SyntaxError: expected expression, got "x"
-SyntaxError: expected property name, got "x"
-SyntaxError: expected target, got "x"
-SyntaxError: expected rest argument name, got "x"
-SyntaxError: expected closing parenthesis, got "x"
-SyntaxError: expected '=&gt;' after argument list, got "x"
-</pre>
+    SyntaxError: expected expression, got "x"
+    SyntaxError: expected property name, got "x"
+    SyntaxError: expected target, got "x"
+    SyntaxError: expected rest argument name, got "x"
+    SyntaxError: expected closing parenthesis, got "x"
+    SyntaxError: expected '=>' after argument list, got "x"
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>{{jsxref("SyntaxError")}}</p>
+{{jsxref("SyntaxError")}}
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p>La syntaxe du langage « attendait » un élément mais quelque chose d'autre est écrit à la place dans le script. Cela peut simplement être dû à une coquille dans le code.</p>
+La syntaxe du langage « attendait » un élément mais quelque chose d'autre est écrit à la place dans le script. Cela peut simplement être dû à une coquille dans le code.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Expression_attendue">Expression attendue</h3>
+### Expression attendue
 
-<p>Lorsqu'on enchaîne des expressions, par exemple, les virgules ne sont pas autorisées en fin d'expression :</p>
+Lorsqu'on enchaîne des expressions, par exemple, les virgules ne sont pas autorisées en fin d'expression :
 
-<pre class="brush: js example-bad">for (let i = 0; i &lt; 5,; ++i) {
+```js example-bad
+for (let i = 0; i < 5,; ++i) {
   console.log(i);
 }
 // SyntaxError: expected expression, got ')'
-</pre>
+```
 
-<p>Pour corriger cette erreur, on peut retirer la virgule superflue ou bien ajouter une autre expression :</p>
+Pour corriger cette erreur, on peut retirer la virgule superflue ou bien ajouter une autre expression :
 
-<pre class="brush: js example-good">for (let i = 0; i &lt; 5; ++i) {
+```js example-good
+for (let i = 0; i < 5; ++i) {
   console.log(i);
 }
-</pre>
+```
 
-<h3 id="Parenthèses_manquantes">Parenthèses manquantes</h3>
+### Parenthèses manquantes
 
-<p>Il peut également arriver que des parenthèses manquent autour des instructions <code>if</code> :</p>
+Il peut également arriver que des parenthèses manquent autour des instructions `if` :
 
-<pre class="brush: js example-bad">function round(n, upperBound, lowerBound){
-  if(n &gt; upperBound) || (n &lt; lowerBound){
+```js example-bad
+function round(n, upperBound, lowerBound){
+  if(n > upperBound) || (n < lowerBound){
     throw 'Number ' + String(n) + ' is more than ' + String(upperBound) + ' or less than ' + String(lowerBound);
-  }else if(n &lt; ((upperBound + lowerBound)/2)){
+  }else if(n < ((upperBound + lowerBound)/2)){
     return lowerBound;
   }else{
     return upperBound;
   }
-} // SyntaxError: expected expression, got '||'</pre>
+} // SyntaxError: expected expression, got '||'
+```
 
-<p>Si on compte les parenthèses ouvrantes et fermantes, c'est correct mais on peut voir que le OU logique (<code>||</code>) n'est contenu au sein d'aucune paire de parenthèses.</p>
+Si on compte les parenthèses ouvrantes et fermantes, c'est correct mais on peut voir que le OU logique (`||`) n'est contenu au sein d'aucune paire de parenthèses.
 
-<p>Pour corriger ce problème, il suffit d'ajouter une paire de parenthèses englobante :</p>
+Pour corriger ce problème, il suffit d'ajouter une paire de parenthèses englobante :
 
-<pre class="brush: js example-good">function round(n, upperBound, lowerBound){
-  if((n &gt; upperBound) || (n &lt; lowerBound)){
+```js example-good
+function round(n, upperBound, lowerBound){
+  if((n > upperBound) || (n < lowerBound)){
     throw 'Number ' + String(n) + ' is more than ' + String(upperBound) + ' or less than ' + String(lowerBound);
-  }else if(n &lt; ((upperBound + lowerBound)/2)){
+  }else if(n < ((upperBound + lowerBound)/2)){
     return lowerBound;
   }else{
     return upperBound;
   }
 }
-</pre>
+```
diff --git a/files/fr/web/javascript/reference/errors/unexpected_type/index.md b/files/fr/web/javascript/reference/errors/unexpected_type/index.md
index 6b54febd7b..31477ea2b2 100644
--- a/files/fr/web/javascript/reference/errors/unexpected_type/index.md
+++ b/files/fr/web/javascript/reference/errors/unexpected_type/index.md
@@ -9,36 +9,36 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/Unexpected_type
 original_slug: Web/JavaScript/Reference/Erreurs/Unexpected_type
 ---
-<div>{{jsSidebar("Errors")}}</div>
+{{jsSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">TypeError: Unable to get property {x} of undefined or null reference (Edge)
-TypeError: "x" is (not) "y" (Firefox)
+    TypeError: Unable to get property {x} of undefined or null reference (Edge)
+    TypeError: "x" is (not) "y" (Firefox)
 
-Examples:
-TypeError: "x" is undefined
-TypeError: "x" is null
-TypeError: "undefined" is not an object
-TypeError: "x" is not an object or null
-TypeError: "x" is not a symbol
-</pre>
+    Examples:
+    TypeError: "x" is undefined
+    TypeError: "x" is null
+    TypeError: "undefined" is not an object
+    TypeError: "x" is not an object or null
+    TypeError: "x" is not a symbol
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>{{jsxref("TypeError")}}.</p>
+{{jsxref("TypeError")}}.
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p>Un type inattendu a été rencontré. Cela se produit la plupart du temps avec les valeurs {{jsxref("undefined")}} ou {{jsxref("null")}}.</p>
+Un type inattendu a été rencontré. Cela se produit la plupart du temps avec les valeurs {{jsxref("undefined")}} ou {{jsxref("null")}}.
 
-<p>Certaines méthodes comme {{jsxref("Object.create()")}} ou {{jsxref("Symbol.keyFor()")}} ont des contraintes sur le type de valeur qui peut être passé en argument.</p>
+Certaines méthodes comme {{jsxref("Object.create()")}} ou {{jsxref("Symbol.keyFor()")}} ont des contraintes sur le type de valeur qui peut être passé en argument.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Exemples_invalides">Exemples invalides</h3>
+### Exemples invalides
 
-<pre class="brush: js example-bad">// undefined et null : des valeurs
+```js example-bad
+// undefined et null : des valeurs
 // sur lesquelles la méthode substring
 // ne fonctionnera pas
 var toto = undefined;
@@ -55,20 +55,20 @@ Symbol.keyFor(toto); // TypeError: toto is not a symbol
 
 var toto = "truc"
 Object.create(toto); // TypeError: "toto" is not an object or null
-</pre>
+```
 
-<h3 id="Résoudre_le_problème">Résoudre le problème</h3>
+### Résoudre le problème
 
-<p>Pour résoudre ce problème et écarter les cas où la valeur vaut <code>undefined</code>, on peut par exemple utiliser l'opérateur <code><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_typeof">typeof</a></code>.</p>
+Pour résoudre ce problème et écarter les cas où la valeur vaut `undefined`, on peut par exemple utiliser l'opérateur [`typeof`](/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_typeof).
 
-<pre class="brush: js">if (typeof toto !== 'undefined') {
+```js
+if (typeof toto !== 'undefined') {
   // Désormais, on sait que toto est bien
   // défini et on peut poursuivre.
-}</pre>
+}
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("undefined")}}</li>
- <li>{{jsxref("null")}}</li>
-</ul>
+- {{jsxref("undefined")}}
+- {{jsxref("null")}}
diff --git a/files/fr/web/javascript/reference/errors/unnamed_function_statement/index.md b/files/fr/web/javascript/reference/errors/unnamed_function_statement/index.md
index 286bd78e7e..42417c4f4d 100644
--- a/files/fr/web/javascript/reference/errors/unnamed_function_statement/index.md
+++ b/files/fr/web/javascript/reference/errors/unnamed_function_statement/index.md
@@ -8,82 +8,92 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/Unnamed_function_statement
 original_slug: Web/JavaScript/Reference/Erreurs/Unnamed_function_statement
 ---
-<div>{{jsSidebar("Errors")}}</div>
+{{jsSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">Syntax Error: Expected identifier (Edge)
-SyntaxError: function statement requires a name [Firefox]
-SyntaxError: Unexpected token ( [Chrome]
-</pre>
+    Syntax Error: Expected identifier (Edge)
+    SyntaxError: function statement requires a name [Firefox]
+    SyntaxError: Unexpected token ( [Chrome]
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>{{jsxref("SyntaxError")}}</p>
+{{jsxref("SyntaxError")}}
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p><a href="/fr/docs/Web/JavaScript/Reference/Instructions/function">Une déclaration de fonction</a> présente dans le code requiert un nom. Il faut alors vérifier la façon dont la fonction est définie et s'il est nécessaire de lui fournir un nom ou si la fonction en question est une expression de fonction, une fonction immédiatement invoquée ou si le code de la fonction est simplement bien placé dans son contexte.</p>
+[Une déclaration de fonction](/fr/docs/Web/JavaScript/Reference/Instructions/function) présente dans le code requiert un nom. Il faut alors vérifier la façon dont la fonction est définie et s'il est nécessaire de lui fournir un nom ou si la fonction en question est une expression de fonction, une fonction immédiatement invoquée ou si le code de la fonction est simplement bien placé dans son contexte.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Déclaration_Expression">Déclaration / Expression</h3>
+### Déclaration / Expression
 
-<p>Une déclaration de fonction requiert un nom. Le fragment de code suivant ne fonctionnera pas :</p>
+Une déclaration de fonction requiert un nom. Le fragment de code suivant ne fonctionnera pas :
 
-<pre class="brush: js example-bad">function () {
+```js example-bad
+function () {
   return 'Coucou monde :)';
 }
 // SyntaxError: function statement requires a name
-</pre>
+```
 
-<p>On peut utiliser <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_function">une expression de fonction</a> à la place :</p>
+On peut utiliser [une expression de fonction](/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_function) à la place :
 
-<pre class="brush: js example-good">var salutations = function() {
+```js example-good
+var salutations = function() {
   return 'Coucou monde :)';
-};</pre>
+};
+```
 
-<p>Si la fonction devait être appelé immédiatement, il suffit d'ajouter des parenthèses autour :</p>
+Si la fonction devait être appelé immédiatement, il suffit d'ajouter des parenthèses autour :
 
-<pre class="brush: js example-good">(function () {
+```js example-good
+(function () {
 
-})();</pre>
+})();
+```
 
-<h3 id="Fonctions_étiquetées">Fonctions étiquetées</h3>
+### Fonctions étiquetées
 
-<p>Si vous utilisez des <a href="/fr/docs/Web/JavaScript/Reference/Instructions/label">fonctions étiquetées</a>, il faut toujours fournir un nom après le mot-clé <code>function</code>. Le code suivant ne fonctionnera pas :</p>
+Si vous utilisez des [fonctions étiquetées](/fr/docs/Web/JavaScript/Reference/Instructions/label), il faut toujours fournir un nom après le mot-clé `function`. Le code suivant ne fonctionnera pas :
 
-<pre class="brush: js example-bad">function Greeter() {
+```js example-bad
+function Greeter() {
   german: function () {
     return "Moin";
   }
 }
 // SyntaxError: function statement requires a name
-</pre>
+```
 
-<p>En revanche, ceci fonctionnera :</p>
+En revanche, ceci fonctionnera :
 
-<pre class="brush: js example-good">function Greeter() {
+```js example-good
+function Greeter() {
   german: function g() {
     return "Moin";
   }
-}</pre>
+}
+```
 
-<h3 id="Méthodes_d'un_objet">Méthodes d'un objet</h3>
+### Méthodes d'un objet
 
-<p>Si vous souhaitez construire une méthode d'un objet, il faudra d'abord créer l'objet. Dans ce cas, la syntaxe sans le nom après le mot-clé <code>function</code> sera valide :</p>
+Si vous souhaitez construire une méthode d'un objet, il faudra d'abord créer l'objet. Dans ce cas, la syntaxe sans le nom après le mot-clé `function` sera valide :
 
-<pre class="brush: js example-good">var greeter = {
+```js example-good
+var greeter = {
   german: function () {
     return "Moin";
   }
-};</pre>
+};
+```
 
-<h3 id="Syntaxe_et_fonctions_de_rappel_(callbacks)">Syntaxe et fonctions de rappel (<em>callbacks</em>)</h3>
+### Syntaxe et fonctions de rappel (_callbacks_)
 
-<p>Lorsqu'on utilise les <em>callbacks</em>, il est facile de s'emmêler les pinceaux entre les parenthèses et les virgules :</p>
+Lorsqu'on utilise les _callbacks_, il est facile de s'emmêler les pinceaux entre les parenthèses et les virgules :
 
-<pre class="brush: js example-bad">promise.then(
+```js example-bad
+promise.then(
   function() {
     console.log("success");
   });
@@ -91,11 +101,12 @@ SyntaxError: Unexpected token ( [Chrome]
     console.log("error");
 }
 // SyntaxError: function statement requires a name
-</pre>
+```
 
-<p>La forme correcte serait :</p>
+La forme correcte serait :
 
-<pre class="brush: json example-good">promise.then(
+```json example-good
+promise.then(
   function() {
     console.log("success");
   },
@@ -103,14 +114,12 @@ SyntaxError: Unexpected token ( [Chrome]
     console.log("error");
   }
 );
-</pre>
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li><a href="/fr/docs/Web/JavaScript/Guide/Fonctions">Les fonctions dans le guide JavaScript</a></li>
- <li><a href="/fr/docs/Web/JavaScript/Reference/Instructions/function">Les déclarations de fonction</a></li>
- <li><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_function">Les expressions de fonction</a></li>
- <li><a href="https://en.wikipedia.org/wiki/Immediately-invoked_function_expression">Les fonctions immédiatement invoquées (ou <em>IIFE</em> en anglais)</a></li>
- <li><code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/label">label</a></code></li>
-</ul>
+- [Les fonctions dans le guide JavaScript](/fr/docs/Web/JavaScript/Guide/Fonctions)
+- [Les déclarations de fonction](/fr/docs/Web/JavaScript/Reference/Instructions/function)
+- [Les expressions de fonction](/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_function)
+- [Les fonctions immédiatement invoquées (ou _IIFE_ en anglais)](https://en.wikipedia.org/wiki/Immediately-invoked_function_expression)
+- [`label`](/fr/docs/Web/JavaScript/Reference/Instructions/label)
diff --git a/files/fr/web/javascript/reference/errors/unterminated_string_literal/index.md b/files/fr/web/javascript/reference/errors/unterminated_string_literal/index.md
index f6ad8afa09..5797276cdb 100644
--- a/files/fr/web/javascript/reference/errors/unterminated_string_literal/index.md
+++ b/files/fr/web/javascript/reference/errors/unterminated_string_literal/index.md
@@ -9,70 +9,69 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/Unterminated_string_literal
 original_slug: Web/JavaScript/Reference/Erreurs/Unterminated_string_literal
 ---
-<div>{{jsSidebar("Errors")}}</div>
+{{jsSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">SyntaxError: Unterminated string constant (Edge)
-SyntaxError: unterminated string literal (Firefox)
-</pre>
+    SyntaxError: Unterminated string constant (Edge)
+    SyntaxError: unterminated string literal (Firefox)
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>{{jsxref("SyntaxError")}}</p>
+{{jsxref("SyntaxError")}}
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p>Une chaîne de caractères ({{jsxref("String")}}) n'est pas bien délimitée quelque part. Les littéraux de chaînes de caractères doivent être délimités par des simples quotes (') ou par des doubles quotes ("). <a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/String#Échappement_des_caractères">Les séquences d'échappement</a> permet de représenter dans ces chaînes de caractères. Pour réparer cette erreur :</p>
+Une chaîne de caractères ({{jsxref("String")}}) n'est pas bien délimitée quelque part. Les littéraux de chaînes de caractères doivent être délimités par des simples quotes (') ou par des doubles quotes ("). [Les séquences d'échappement](/fr/docs/Web/JavaScript/Reference/Objets_globaux/String#Échappement_des_caractères) permet de représenter dans ces chaînes de caractères. Pour réparer cette erreur :
 
-<ul>
- <li>Vérifiez que la chaîne est bien délimitée au début et à la fin par des doubles quotes ou par des simples quotes,</li>
- <li>Vérifiez que les caractères spéciaux de la chaîne ont bien été échappés,</li>
- <li>Vérifiez que le littéral est bien découpé pour gérer plusieurs lignes (si c'est le cas).</li>
-</ul>
+- Vérifiez que la chaîne est bien délimitée au début et à la fin par des doubles quotes ou par des simples quotes,
+- Vérifiez que les caractères spéciaux de la chaîne ont bien été échappés,
+- Vérifiez que le littéral est bien découpé pour gérer plusieurs lignes (si c'est le cas).
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Gérer_plusieurs_lignes">Gérer plusieurs lignes</h3>
+### Gérer plusieurs lignes
 
-<p>En JavaScript, on ne peut pas écrire une chaîne simple sur plusieurs lignes comme ceci :</p>
+En JavaScript, on ne peut pas écrire une chaîne simple sur plusieurs lignes comme ceci :
 
-<pre class="brush: js example-bad">var longString = "This is a very long string which needs
+```js example-bad
+var longString = "This is a very long string which needs
                   to wrap across multiple lines because
                   otherwise my code is unreadable.";
-// SyntaxError: unterminated string literal</pre>
+// SyntaxError: unterminated string literal
+```
 
-<p>Pour écrire une chaîne sur plusieurs lignes, on pourra utiliser :</p>
+Pour écrire une chaîne sur plusieurs lignes, on pourra utiliser :
 
-<ul>
- <li><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_arithmétiques#Addition_()">L'opérateur +</a>,</li>
- <li>Une barre oblique inversée ("\")</li>
- <li><a href="/fr/docs/Web/JavaScript/Reference/Littéraux_gabarits">Des littéraux de gabarits</a></li>
-</ul>
+- [L'opérateur +](</fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_arithmétiques#Addition_()>),
+- Une barre oblique inversée ("\\")
+- [Des littéraux de gabarits](/fr/docs/Web/JavaScript/Reference/Littéraux_gabarits)
 
-<p>Voici la première variante avec l'opérateur de concaténation :</p>
+Voici la première variante avec l'opérateur de concaténation :
 
-<pre class="brush: js example-good">var longString = "This is a very long string which needs " +
+```js example-good
+var longString = "This is a very long string which needs " +
                  "to wrap across multiple lines because " +
                  "otherwise my code is unreadable.";
-</pre>
+```
 
-<p>Sinon, on peut utiliser une barre oblique inversée à la fin de chaque ligne pour indiquer qu'elle continue sur la ligne suivante. Attention, il faudra qu'il n'y ait aucun espace ou autre caractère après la barre oblique (il peut bien entendu y avoir un saut de ligne) :</p>
+Sinon, on peut utiliser une barre oblique inversée à la fin de chaque ligne pour indiquer qu'elle continue sur la ligne suivante. Attention, il faudra qu'il n'y ait aucun espace ou autre caractère après la barre oblique (il peut bien entendu y avoir un saut de ligne) :
 
-<pre class="brush: js example-good">var longString = "This is a very long string which needs \
+```js example-good
+var longString = "This is a very long string which needs \
 to wrap across multiple lines because \
 otherwise my code is unreadable.";
-</pre>
+```
 
-<p>On pourra également utiliser <a href="/fr/docs/Web/JavaScript/Reference/Littéraux_gabarits">les littéraux de gabarits</a> qui sont pris en charge par les environnement ECMAScript 2015 :</p>
+On pourra également utiliser [les littéraux de gabarits](/fr/docs/Web/JavaScript/Reference/Littéraux_gabarits) qui sont pris en charge par les environnement ECMAScript 2015 :
 
-<pre class="brush: js example-good">var longString = `This is a very long string which needs
+```js example-good
+var longString = `This is a very long string which needs
                   to wrap across multiple lines because
-                  otherwise my code is unreadable.`;</pre>
+                  otherwise my code is unreadable.`;
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("String")}}</li>
- <li><a href="/fr/docs/Web/JavaScript/Reference/Littéraux_gabarits">Les littéraux de gabarits</a></li>
-</ul>
+- {{jsxref("String")}}
+- [Les littéraux de gabarits](/fr/docs/Web/JavaScript/Reference/Littéraux_gabarits)
diff --git a/files/fr/web/javascript/reference/errors/var_hides_argument/index.md b/files/fr/web/javascript/reference/errors/var_hides_argument/index.md
index dda8687316..8e98669ddf 100644
--- a/files/fr/web/javascript/reference/errors/var_hides_argument/index.md
+++ b/files/fr/web/javascript/reference/errors/var_hides_argument/index.md
@@ -8,49 +8,48 @@ tags:
 translation_of: Web/JavaScript/Reference/Errors/Var_hides_argument
 original_slug: Web/JavaScript/Reference/Erreurs/Var_hides_argument
 ---
-<div>{{jsSidebar("Errors")}}</div>
+{{jsSidebar("Errors")}}
 
-<h2 id="Message">Message</h2>
+## Message
 
-<pre class="syntaxbox">TypeError: variable "x" redeclares argument (Firefox)
-</pre>
+    TypeError: variable "x" redeclares argument (Firefox)
 
-<h2 id="Type_d'erreur">Type d'erreur</h2>
+## Type d'erreur
 
-<p>Une erreur {{jsxref("TypeError")}}, uniquement <a href="/fr/docs/Web/JavaScript/Reference/Strict_mode">en mode strict</a>.</p>
+Une erreur {{jsxref("TypeError")}}, uniquement [en mode strict](/fr/docs/Web/JavaScript/Reference/Strict_mode).
 
-<h2 id="Quel_est_le_problème">Quel est le problème ?</h2>
+## Quel est le problème ?
 
-<p>Le même nom de variable est utilisé comme nom pour un paramètre et comme nom de variable via une affectation <code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/var">var</a></code>. Cela peut être lié à un conflit de nommage et le moteur envoie un avertissement.</p>
+Le même nom de variable est utilisé comme nom pour un paramètre et comme nom de variable via une affectation [`var`](/fr/docs/Web/JavaScript/Reference/Instructions/var). Cela peut être lié à un conflit de nommage et le moteur envoie un avertissement.
 
-<p>Cette erreur ne se produit qu'en mode strict. Pour du code non-strict, la redéclaration est ignorée silencieusement..</p>
+Cette erreur ne se produit qu'en mode strict. Pour du code non-strict, la redéclaration est ignorée silencieusement..
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Exemples_invalides">Exemples invalides</h3>
+### Exemples invalides
 
-<p>Ici, la variable <code>arg</code> redéclare l'argument de la fonction :</p>
+Ici, la variable `arg` redéclare l'argument de la fonction :
 
-<pre class="brush: js example-bad">"use strict";
+```js example-bad
+"use strict";
 
 function f(arg) {
   var arg = "foo";
 }
-</pre>
+```
 
-<h3 id="Exemples_valides">Exemples valides</h3>
+### Exemples valides
 
-<p>Pour résoudre ce problème, on pourra généralement retirer l'instruction <code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/var">var</a></code> car la variable existe déjà et peut être utilisée. Si on ne veut pas utiliser cette même variable, mieux vaudra renommer le paramètre ou la variable interne afin de lever l'ambiguïté.</p>
+Pour résoudre ce problème, on pourra généralement retirer l'instruction [`var`](/fr/docs/Web/JavaScript/Reference/Instructions/var) car la variable existe déjà et peut être utilisée. Si on ne veut pas utiliser cette même variable, mieux vaudra renommer le paramètre ou la variable interne afin de lever l'ambiguïté.
 
-<pre class="brush: js example-good">"use strict";
+```js example-good
+"use strict";
 
 function f(arg) {
   arg = "foo";
 }
-</pre>
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li><a href="/fr/docs/Web/JavaScript/Reference/Strict_mode">Le mode strict</a></li>
-</ul>
+- [Le mode strict](/fr/docs/Web/JavaScript/Reference/Strict_mode)
diff --git a/files/fr/web/javascript/reference/functions/arguments/@@iterator/index.md b/files/fr/web/javascript/reference/functions/arguments/@@iterator/index.md
index 406eb7bcdc..e6f4715714 100644
--- a/files/fr/web/javascript/reference/functions/arguments/@@iterator/index.md
+++ b/files/fr/web/javascript/reference/functions/arguments/@@iterator/index.md
@@ -11,19 +11,20 @@ tags:
 translation_of: Web/JavaScript/Reference/Functions/arguments/@@iterator
 original_slug: Web/JavaScript/Reference/Fonctions/arguments/@@iterator
 ---
-<div>{{jsSidebar("Functions")}}</div>
+{{jsSidebar("Functions")}}
 
-<p>La valeur initiale de la propriété <code><strong>@@iterator</strong></code> est le même objet que la fonction utilisée pour la valeur initiale de la propriété {{jsxref("Array.prototype.values")}}.</p>
+La valeur initiale de la propriété **`@@iterator`** est le même objet que la fonction utilisée pour la valeur initiale de la propriété {{jsxref("Array.prototype.values")}}.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>arguments</var>[Symbol.iterator]()</pre>
+    arguments[Symbol.iterator]()
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_une_boucle_for...of">Utiliser une boucle <code>for...of</code></h3>
+### Utiliser une boucle `for...of`
 
-<pre class="brush: js">function f() {
+```js
+function f() {
   // votre environnement doit supporter les
   // boucles for..of et les variables
   // définies avec let dans les boucles
@@ -32,47 +33,21 @@ original_slug: Web/JavaScript/Reference/Fonctions/arguments/@@iterator
   }
 }
 f('w', 'y', 'k', 'o', 'p');
-</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">Statut</th>
-   <th scope="col">Commentaires</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-createunmappedargumentsobject', ' CreateUnmappedArgumentsObject')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-createmappedargumentsobject', ' CreateMappedArgumentsObject')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-createunmappedargumentsobject', 'CreateUnmappedArgumentsObject')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-createmappedargumentsobject', 'CreateMappedArgumentsObject')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
+| Spécification                                                                                                                | Statut                       | Commentaires         |
+| ---------------------------------------------------------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ES6', '#sec-createunmappedargumentsobject', ' CreateUnmappedArgumentsObject')}}     | {{Spec2('ES6')}}         | Définition initiale. |
+| {{SpecName('ES6', '#sec-createmappedargumentsobject', ' CreateMappedArgumentsObject')}}         | {{Spec2('ES6')}}         | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-createunmappedargumentsobject', 'CreateUnmappedArgumentsObject')}} | {{Spec2('ESDraft')}} |                      |
+| {{SpecName('ESDraft', '#sec-createmappedargumentsobject', 'CreateMappedArgumentsObject')}}     | {{Spec2('ESDraft')}} |                      |
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
+{{Compat("javascript.functions.arguments.@@iterator")}}
 
-<p>{{Compat("javascript.functions.arguments.@@iterator")}}</p>
+## Voir aussi
 
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Array.prototype.values()")}}</li>
-</ul>
+- {{jsxref("Array.prototype.values()")}}
diff --git a/files/fr/web/javascript/reference/functions/arguments/callee/index.md b/files/fr/web/javascript/reference/functions/arguments/callee/index.md
index 4f69ce4490..bb8c7d6fa3 100644
--- a/files/fr/web/javascript/reference/functions/arguments/callee/index.md
+++ b/files/fr/web/javascript/reference/functions/arguments/callee/index.md
@@ -11,45 +11,52 @@ tags:
 translation_of: Web/JavaScript/Reference/Functions/arguments/callee
 original_slug: Web/JavaScript/Reference/Fonctions/arguments/callee
 ---
-<div>{{jsSidebar("Functions")}}{{deprecated_header}}</div>
+{{jsSidebar("Functions")}}{{deprecated_header}}
 
-<p>La propriété <strong><code>arguments.callee</code></strong> contient la fonction en cours d'exécution.</p>
+La propriété **`arguments.callee`** contient la fonction en cours d'exécution.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p><code>callee</code> est une propriété de l'objet <code>arguments</code>. Elle peut être utilisée afin de faire référence à la fonction en cours d'exécution à l'intérieur de cette fonction. Cette propriété peut etre utile lorsqu'on ne connait pas le nom de la fonction (fonction anonyme par exemple).</p>
+`callee` est une propriété de l'objet `arguments`. Elle peut être utilisée afin de faire référence à la fonction en cours d'exécution à l'intérieur de cette fonction. Cette propriété peut etre utile lorsqu'on ne connait pas le nom de la fonction (fonction anonyme par exemple).
 
-<div class="warning"><p><strong>Attention :</strong> En <a href="/fr/docs/Web/JavaScript/Reference/Strict_mode">mode strict</a>, ECMAScript 5 interdit la fonction <code>arguments.callee()</code>. Éviter de l'utiliser en utilisant un nom de fonction dans les expressions ou en utilisant une déclaration de fonction où la fonction s'appelle elle-même.</p></div>
+> **Attention :** En [mode strict](/fr/docs/Web/JavaScript/Reference/Strict_mode), ECMAScript 5 interdit la fonction `arguments.callee()`. Éviter de l'utiliser en utilisant un nom de fonction dans les expressions ou en utilisant une déclaration de fonction où la fonction s'appelle elle-même.
 
-<h3 id="Pourquoi_arguments.callee_a-t-il_été_retiré_du_mode_strict_ES5">Pourquoi <code>arguments.callee</code> a-t-il été retiré du mode strict ES5 ?</h3>
+### Pourquoi `arguments.callee` a-t-il été retiré du mode strict ES5 ?
 
-<p>(adapté d'une réponse<a href="http://stackoverflow.com/a/235760/578288" title="http://stackoverflow.com/a/235760/578288"> Stack Overflow par olliej</a>)</p>
+(adapté d'une réponse[ Stack Overflow par olliej](http://stackoverflow.com/a/235760/578288 "http://stackoverflow.com/a/235760/578288"))
 
-<p>Aux débuts de JavaScript, il n'était pas possible d'utiliser des expressions de fonction avec des noms. Il était donc impossible de faire une expression de fonction récursive.</p>
+Aux débuts de JavaScript, il n'était pas possible d'utiliser des expressions de fonction avec des noms. Il était donc impossible de faire une expression de fonction récursive.
 
-<p>Cette syntaxe produisait le résultat escompté :</p>
+Cette syntaxe produisait le résultat escompté :
 
-<pre class="brush: js">function factorielle (n) {
-    return !(n &gt; 1) ? 1 : factorielle(n - 1) * n;
+```js
+function factorielle (n) {
+    return !(n > 1) ? 1 : factorielle(n - 1) * n;
 }
 
-[1,2,3,4,5].map(factorielle);</pre>
+[1,2,3,4,5].map(factorielle);
+```
 
-<p>mais :</p>
+mais :
 
-<pre class="brush: js">[1,2,3,4,5].map(function (n) {
-    return !(n &gt; 1) ? 1 : /* que met-on ici ? */ (n - 1) * n;
-});</pre>
+```js
+[1,2,3,4,5].map(function (n) {
+    return !(n > 1) ? 1 : /* que met-on ici ? */ (n - 1) * n;
+});
+```
 
-<p>ne fonctionnait pas. Pour que cela puisse fonctionner, on ajouta <code>arguments.callee</code> :</p>
+ne fonctionnait pas. Pour que cela puisse fonctionner, on ajouta `arguments.callee` :
 
-<pre class="brush: js">[1,2,3,4,5].map(function (n) {
-    return !(n &gt; 1) ? 1 : arguments.callee(n - 1) * n;
-});</pre>
+```js
+[1,2,3,4,5].map(function (n) {
+    return !(n > 1) ? 1 : arguments.callee(n - 1) * n;
+});
+```
 
-<p>Cependant, ce fut une mauvaise solution (avec <code>caller</code> également) car elle rendit impossible l'<a href="https://fr.wikipedia.org/wiki/Extension_inline">extension inline</a> et la <a href="https://fr.wikipedia.org/wiki/R%C3%A9cursion_terminale">récursion terminale</a> de façon générale (il est possible d'y arriver de certaines façons mais cela entraînerait nécessairement un code moins efficace). Le second problème que cela entraîne est que l'appel récursif aura une autre valeur <code>this</code> :</p>
+Cependant, ce fut une mauvaise solution (avec `caller` également) car elle rendit impossible l'[extension inline](https://fr.wikipedia.org/wiki/Extension_inline) et la [récursion terminale](https://fr.wikipedia.org/wiki/R%C3%A9cursion_terminale) de façon générale (il est possible d'y arriver de certaines façons mais cela entraînerait nécessairement un code moins efficace). Le second problème que cela entraîne est que l'appel récursif aura une autre valeur `this` :
 
-<pre class="brush: js">var global = this;
+```js
+var global = this;
 
 var fonctionTruc = function (recursed) {
     if (!recursed) { return arguments.callee(true); }
@@ -60,51 +67,57 @@ var fonctionTruc = function (recursed) {
     }
 }
 
-fonctionTruc();</pre>
+fonctionTruc();
+```
 
-<p>ECMAScript 3 a introduit les expressions de fonctions nommées pour résoudre le problème. On peut désormais utiliser :</p>
+ECMAScript 3 a introduit les expressions de fonctions nommées pour résoudre le problème. On peut désormais utiliser :
 
-<pre class="brush: js">[1,2,3,4,5].map(function factorielle (n) {
-    return !(n &gt; 1) ? 1 : factorielle(n - 1)*n;
-});</pre>
+```js
+[1,2,3,4,5].map(function factorielle (n) {
+    return !(n > 1) ? 1 : factorielle(n - 1)*n;
+});
+```
 
-<p>Cette méthode possède plusieurs avantages :</p>
+Cette méthode possède plusieurs avantages :
 
-<ul>
- <li>La fonction peut être appelée comme n'importe quelle autre fonction nommée dans le code</li>
- <li>Cela ne crée pas une variable dans la portée extérieure (<a href="http://kangax.github.io/nfe/#example_1_function_expression_identifier_leaks_into_an_enclosing_scope">sauf pour IE 8 et les versions antérieures</a>)</li>
- <li>Cela entraîne de meilleures performances que d'accéder aux propriétés de l'objet <code>arguments</code></li>
-</ul>
+- La fonction peut être appelée comme n'importe quelle autre fonction nommée dans le code
+- Cela ne crée pas une variable dans la portée extérieure ([sauf pour IE 8 et les versions antérieures](http://kangax.github.io/nfe/#example_1_function_expression_identifier_leaks_into_an_enclosing_scope))
+- Cela entraîne de meilleures performances que d'accéder aux propriétés de l'objet `arguments`
 
-<p>Une autre fonctionnalité qui a été déprécié est : <code>arguments.callee.caller</code>, ou plus précisément <code>Function.caller</code>. Pourquoi cela ? Parce que ça permet d'avoir accès à tout moment à la fonction appelante la plus loin dans la pile d'appels. Or, comme évoqué ci-avant, cela a un effet de bord considérable : ça rend beaucoup plus complexes voire impossibles certaines optimisations. Ainsi, on ne peut pas garantir qu'une fonction <code>f</code> n'appellera pas une autre fonction inconnue, ce qui signifie qu'on ne peut pas utiliser l'extension inline. En résumé, cela signifie que n'importe quel site d'appel de fonction (<em>call site</em>) qui aurait pu être développé inline très simplement devra subir de nombreux tests :</p>
+Une autre fonctionnalité qui a été déprécié est : `arguments.callee.caller`, ou plus précisément `Function.caller`. Pourquoi cela ? Parce que ça permet d'avoir accès à tout moment à la fonction appelante la plus loin dans la pile d'appels. Or, comme évoqué ci-avant, cela a un effet de bord considérable : ça rend beaucoup plus complexes voire impossibles certaines optimisations. Ainsi, on ne peut pas garantir qu'une fonction `f` n'appellera pas une autre fonction inconnue, ce qui signifie qu'on ne peut pas utiliser l'extension inline. En résumé, cela signifie que n'importe quel site d'appel de fonction (_call site_) qui aurait pu être développé inline très simplement devra subir de nombreux tests :
 
-<pre class="brush: js">function f (a, b, c, d, e) { return a ? b * c : d * e; }</pre>
+```js
+function f (a, b, c, d, e) { return a ? b * c : d * e; }
+```
 
-<p>Si l'interpréteur JavaScript ne peut pas garantir que l'ensemble des arguments fournis ici sont des nombres à l'instant de l'appel de la fonction, il devra insérer des vérifications pour chaque argument avant le code inline, sinon il ne pourra pas développer la fonction inline. On notera que, dans ce cas, un interpréteur intelligent devrait pouvoir réarranger les vérifications à faire afin qu'elles soient optimales et de se débarrasser des valeurs inutiles. Malgré tout, une telle optimisation ne sera pas possible dans d'autres cas, ce qui signifie que le développement inline n'est pas possible.</p>
+Si l'interpréteur JavaScript ne peut pas garantir que l'ensemble des arguments fournis ici sont des nombres à l'instant de l'appel de la fonction, il devra insérer des vérifications pour chaque argument avant le code inline, sinon il ne pourra pas développer la fonction inline. On notera que, dans ce cas, un interpréteur intelligent devrait pouvoir réarranger les vérifications à faire afin qu'elles soient optimales et de se débarrasser des valeurs inutiles. Malgré tout, une telle optimisation ne sera pas possible dans d'autres cas, ce qui signifie que le développement inline n'est pas possible.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_arguments.callee_pour_une_fonction_anonyme_récursive">Utiliser <code>arguments.callee</code> pour une fonction anonyme récursive</h3>
+### Utiliser `arguments.callee` pour une fonction anonyme récursive
 
-<p>Une fonction récursive, par définition, s'appelle elle-même. Elle fait donc généralement référence à elle-même grâce à son nom. Cependant, une fonction anonyme (créée grâce ) une <a href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/L_op%C3%A9rateur_function">expression de fonction</a> ou au constructeur {{jsxref("Function")}}) n'a pas de nom et la seule façon d'y faire référence est donc d'utiliser <code>arguments.callee</code>.</p>
+Une fonction récursive, par définition, s'appelle elle-même. Elle fait donc généralement référence à elle-même grâce à son nom. Cependant, une fonction anonyme (créée grâce ) une [expression de fonction](/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/L_op%C3%A9rateur_function) ou au constructeur {{jsxref("Function")}}) n'a pas de nom et la seule façon d'y faire référence est donc d'utiliser `arguments.callee`.
 
-<p>L'exemple qui suit illustre une fonction qui définit et renvoie une fonction factorielle. Cet exemple n'a qu'un but démonstratif et ne correspond certainement pas à ce qui serait utilisé en pratique (les expressions de fonctions pouvant être <a href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/L_op%C3%A9rateur_function">nommées</a>).</p>
+L'exemple qui suit illustre une fonction qui définit et renvoie une fonction factorielle. Cet exemple n'a qu'un but démonstratif et ne correspond certainement pas à ce qui serait utilisé en pratique (les expressions de fonctions pouvant être [nommées](/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/L_op%C3%A9rateur_function)).
 
-<pre class="brush: js">function créer() {
+```js
+function créer() {
    return function(n) {
-      if (n &lt;= 1)
+      if (n <= 1)
          return 1;
       return n * arguments.callee(n - 1);
    };
 }
 
-var résultat = create()(5); // renvoie 120 (5 * 4 * 3 * 2 * 1)</pre>
+var résultat = create()(5); // renvoie 120 (5 * 4 * 3 * 2 * 1)
+```
 
-<h3 id="Une_utilisation_d'arguments.callee_qui_ne_possède_pas_de_solution_de_remplacement">Une utilisation d'<code>arguments.callee</code> qui ne possède pas de solution de remplacement</h3>
+### Une utilisation d'`arguments.callee` qui ne possède pas de solution de remplacement
 
-<p>Malgré tout, dans un cas comme le suivant, il n'existe pas d'équivalent pour <code>arguments.callee</code>, c'est pourquoi sa déprécation pourrait être un bug (voir {{Bug("725398")}}):</p>
+Malgré tout, dans un cas comme le suivant, il n'existe pas d'équivalent pour `arguments.callee`, c'est pourquoi sa déprécation pourrait être un bug (voir {{Bug("725398")}}):
 
-<pre class="brush: js">function créerPersonne (sIdentité) {
+```js
+function créerPersonne (sIdentité) {
     var oPersonne = new Function("alert(arguments.callee.identité);");
     oPersonne.identité = sIdentité;
     return oPersonne;
@@ -112,46 +125,22 @@ var résultat = create()(5); // renvoie 120 (5 * 4 * 3 * 2 * 1)</pre>
 
 var jean = créerPersonne("Jean Biche");
 
-jean();</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-10.6', 'Arguments Object')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-arguments-exotic-objects', 'Arguments Exotic Objects')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-arguments-exotic-objects', 'Arguments Exotic Objects')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.functions.arguments.callee")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Function")}}</li>
-</ul>
+jean();
+```
+
+## Spécifications
+
+| Spécification                                                                                                    | État                         | Commentaires                                         |
+| ---------------------------------------------------------------------------------------------------------------- | ---------------------------- | ---------------------------------------------------- |
+| {{SpecName('ES1')}}                                                                                         | {{Spec2('ES1')}}         | Définition initiale. Implémentée avec JavaScript 1.2 |
+| {{SpecName('ES5.1', '#sec-10.6', 'Arguments Object')}}                                         | {{Spec2('ES5.1')}}     |                                                      |
+| {{SpecName('ES6', '#sec-arguments-exotic-objects', 'Arguments Exotic Objects')}}     | {{Spec2('ES6')}}         |                                                      |
+| {{SpecName('ESDraft', '#sec-arguments-exotic-objects', 'Arguments Exotic Objects')}} | {{Spec2('ESDraft')}} |                                                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.functions.arguments.callee")}}
+
+## Voir aussi
+
+- {{jsxref("Function")}}
diff --git a/files/fr/web/javascript/reference/functions/arguments/index.md b/files/fr/web/javascript/reference/functions/arguments/index.md
index c996b904d3..84b1939b72 100644
--- a/files/fr/web/javascript/reference/functions/arguments/index.md
+++ b/files/fr/web/javascript/reference/functions/arguments/index.md
@@ -10,238 +10,228 @@ tags:
 translation_of: Web/JavaScript/Reference/Functions/arguments
 original_slug: Web/JavaScript/Reference/Fonctions/arguments
 ---
-<div>{{jsSidebar("Fonctions")}}</div>
+{{jsSidebar("Fonctions")}}
 
-<p>L'objet <strong><code>arguments</code></strong> est un objet, <strong>semblable</strong> à un tableau, correspondant aux arguments passés à une fonction.</p>
+L'objet **`arguments`** est un objet, **semblable** à un tableau, correspondant aux arguments passés à une fonction.
 
-<div class="note">
-<p><strong>Note :</strong> Si vous pouvez utiliser les fonctionnalités ECMAScript 2015/ES6, il est préférable de manipuler les arguments avec <a href="/fr/docs/Web/JavaScript/Reference/Fonctions/paramètres_du_reste">les paramètres du reste</a>.</p>
-</div>
+> **Note :** Si vous pouvez utiliser les fonctionnalités ECMAScript 2015/ES6, il est préférable de manipuler les arguments avec [les paramètres du reste](/fr/docs/Web/JavaScript/Reference/Fonctions/paramètres_du_reste).
 
-<div class="note">
-<p><strong>Note :</strong> Par « objet semblable à un tableau », on indique que l'objet <code>arguments</code> possède une propriété {{jsxref("Fonctions/arguments.length", "length")}} et que ses propriétés sont indexées à partir de 0 mais qu'il ne possède aucune des méthodes natives de {{jsxref("Array")}} telles que {{jsxref("Array.forEach", "forEach()")}} et {{jsxref("Array.map", "map()")}}.</p>
-</div>
+> **Note :** Par « objet semblable à un tableau », on indique que l'objet `arguments` possède une propriété {{jsxref("Fonctions/arguments.length", "length")}} et que ses propriétés sont indexées à partir de 0 mais qu'il ne possède aucune des méthodes natives de {{jsxref("Array")}} telles que {{jsxref("Array.forEach", "forEach()")}} et {{jsxref("Array.map", "map()")}}.
 
-<div>{{EmbedInteractiveExample("pages/js/functions-arguments.html")}}</div>
+{{EmbedInteractiveExample("pages/js/functions-arguments.html")}}
 
+> **Note :** « Variable ayant la fonction pour portée » correspond à la traduction de « Variable of the function scope » qu'il serait incorrect de traduire par « Variable de la portée de la fonction » car la portée de la fonction est la portée dans laquelle on peut appeler la fonction. Une variable locale de la fonction pourrait quant à elle avoir une portée strictement incluse dans le corps de la fonction (variable définie dans un bloc de la fonction même si cette subtilité n'existe pas en Javascript). Toute suggestion pour éviter cette tournure un peu longue sans altérer le sens est la bienvenue. (variable intrinsèque)
 
+## Syntaxe
 
-<div class="note">
-<p><strong>Note :</strong> « Variable ayant la fonction pour portée » correspond à la traduction de « Variable of the function scope » qu'il serait incorrect de traduire par « Variable de la portée de la fonction » car la portée de la fonction est la portée dans laquelle on peut appeler la fonction. Une variable locale de la fonction pourrait quant à elle avoir une portée strictement incluse dans le corps de la fonction (variable définie dans un bloc de la fonction même si cette subtilité n'existe pas en Javascript). Toute suggestion pour éviter cette tournure un peu longue sans altérer le sens est la bienvenue. (variable intrinsèque)</p>
-</div>
+    arguments
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Description
 
-<pre class="syntaxbox">arguments</pre>
+L'objet `arguments` est une variable locale (intrinsèque et inhérente aux fonctions) disponible dans toutes les fonctions (qui ne sont pas [des fonctions fléchées](/fr/docs/Web/JavaScript/Reference/Fonctions/Fonctions_fl%C3%A9ch%C3%A9es)).
 
-<h2 id="Description">Description</h2>
+Vous pouvez accéder aux arguments d'une fonction à l'intérieur de celle-ci en utilisant l'objet `arguments`. Cet objet contient une entrée pour chaque argument passé à la fonction, l'indice de la première entrée commençant à 0. Par exemple, si une fonction est appelée avec trois arguments, on accède à ceux-ci comme suit :
 
-<p>L'objet <code>arguments</code> est une variable locale (intrinsèque et inhérente aux fonctions) disponible dans toutes les fonctions (qui ne sont pas <a href="/fr/docs/Web/JavaScript/Reference/Fonctions/Fonctions_fl%C3%A9ch%C3%A9es">des fonctions fléchées</a>).</p>
-
-<p>Vous pouvez accéder aux arguments d'une fonction à l'intérieur de celle-ci en utilisant l'objet <code>arguments</code>. Cet objet contient une entrée pour chaque argument passé à la fonction, l'indice de la première entrée commençant à 0. Par exemple, si une fonction est appelée avec trois arguments, on accède à ceux-ci comme suit :</p>
-
-<pre class="brush: js">arguments[0]
+```js
+arguments[0]
 arguments[1]
-arguments[2]</pre>
+arguments[2]
+```
 
-<p>Les arguments peuvent aussi être modifiés :</p>
+Les arguments peuvent aussi être modifiés :
 
-<pre class="brush: js">arguments[1] = 'nouvelle valeur';</pre>
+```js
+arguments[1] = 'nouvelle valeur';
+```
 
-<h3 id="Type_de_l'objet_arguments_et_liens_avec_Array">Type de l'objet <code>arguments</code> et liens avec <code>Array</code></h3>
+### Type de l'objet `arguments` et liens avec `Array`
 
-<p>L'objet <code>arguments</code> n'est pas un {{jsxref("Array")}}. Il est similaire à un <code>Array</code>, mais il n'a pas les propriétés d'un <code>Array,</code> exceptée la propriété {{jsxref("Array.length", "length")}}. Par exemple, il n'a pas la méthode {{jsxref("Array.pop", "pop()")}}. Néanmoins, il peut être converti en un vrai objet de type <code>Array</code> :</p>
+L'objet `arguments` n'est pas un {{jsxref("Array")}}. Il est similaire à un `Array`, mais il n'a pas les propriétés d'un `Array,` exceptée la propriété {{jsxref("Array.length", "length")}}. Par exemple, il n'a pas la méthode {{jsxref("Array.pop", "pop()")}}. Néanmoins, il peut être converti en un vrai objet de type `Array` :
 
-<pre class="brush: js">console.log(typeof arguments); // 'object'
+```js
+console.log(typeof arguments); // 'object'
 var args = Array.prototype.slice.call(arguments);
 
 // Avec ECMAScript 2015 / ES6
 var args = Array.from(arguments);
-</pre>
-
-<h3 id="Utilisation_de_la_décomposition_avec_les_arguments">Utilisation de la décomposition avec les arguments</h3>
+```
 
-<p>On peut utiliser la méthode {{jsxref("Array.from()")}} ou encore <a href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateur_de_d%C3%A9composition">l'opérateur de décomposition</a> afin de convertir cet objet en un <em>vrai</em> <code>Array</code> :</p>
+### Utilisation de la décomposition avec les arguments
 
-<pre class="brush: js">var args = Array.from(arguments);
-var args = [...arguments];</pre>
+On peut utiliser la méthode {{jsxref("Array.from()")}} ou encore [l'opérateur de décomposition](/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateur_de_d%C3%A9composition) afin de convertir cet objet en un _vrai_ `Array` :
 
-<div class="warning">
-<p><strong>Attention :</strong> Il est déconseillé d'utiliser <code>slice</code> sur les arguments car cela peut empêcher certaines optimisations des moteurs JavaScript. Pour ce scénario, on peut par exemple construire un nouveau tableau en parcourant l'objet arguments (à ce sujet, voir <a href="https://github.com/petkaantonov/bluebird/wiki/Optimization-killers#3-managing-arguments">cette page</a> sur les contraintes d'optimisations liées à V8). Pour cet exemple, on pourra utiliser <code>Array.apply</code> :</p>
+```js
+var args = Array.from(arguments);
+var args = [...arguments];
+```
 
-<pre class="brush: js">var args = (arguments.length === 1 ? [arguments[0]] : Array.apply(null, arguments));</pre>
-</div>
+> **Attention :** Il est déconseillé d'utiliser `slice` sur les arguments car cela peut empêcher certaines optimisations des moteurs JavaScript. Pour ce scénario, on peut par exemple construire un nouveau tableau en parcourant l'objet arguments (à ce sujet, voir [cette page](https://github.com/petkaantonov/bluebird/wiki/Optimization-killers#3-managing-arguments) sur les contraintes d'optimisations liées à V8). Pour cet exemple, on pourra utiliser `Array.apply` :
+>
+> ```js
+> var args = (arguments.length === 1 ? [arguments[0]] : Array.apply(null, arguments));
+> ```
 
-<p>L'objet <code>arguments</code> est disponible uniquement dans le corps d'une fonction. Tenter d'accéder à l'objet <code>arguments</code> en dehors de la déclaration d'une fonction renvoie une erreur.</p>
+L'objet `arguments` est disponible uniquement dans le corps d'une fonction. Tenter d'accéder à l'objet `arguments` en dehors de la déclaration d'une fonction renvoie une erreur.
 
-<p>Vous pouvez utiliser l'objet <code>arguments</code> si vous appelez une fonction avec plus de paramètres que ceux déclarés dans sa signature. Cette technique est utile pour les fonctions qui acceptent un nombre variable d'arguments. Vous pouvez utiliser  {{jsxref("Fonctions/arguments/length", "arguments.length")}} pour déterminer le nombre de paramètres passés à la fonction, puis utiliser chaque argument en utilisant l'objet <code>arguments</code>. (Pour déterminer le nombre d'arguments déclarés à la définition de la fonction, il faut utiliser la propriété {{jsxref("Function.length", "length")}}.)</p>
+Vous pouvez utiliser l'objet `arguments` si vous appelez une fonction avec plus de paramètres que ceux déclarés dans sa signature. Cette technique est utile pour les fonctions qui acceptent un nombre variable d'arguments. Vous pouvez utiliser  {{jsxref("Fonctions/arguments/length", "arguments.length")}} pour déterminer le nombre de paramètres passés à la fonction, puis utiliser chaque argument en utilisant l'objet `arguments`. (Pour déterminer le nombre d'arguments déclarés à la définition de la fonction, il faut utiliser la propriété {{jsxref("Function.length", "length")}}.)
 
-<h3 id="Utiliser_typeof_sur_arguments">Utiliser <code>typeof</code> sur <code>arguments</code></h3>
+### Utiliser `typeof` sur `arguments`
 
-<p>L'opérateur {{jsxref("Opérateurs/L_opérateur_typeof","typeof")}} renvoie <code>"object"</code> lorsqu'on l'utilise sur <code>arguments</code></p>
+L'opérateur {{jsxref("Opérateurs/L_opérateur_typeof","typeof")}} renvoie `"object"` lorsqu'on l'utilise sur `arguments`
 
-<pre class="brush: js">console.log(typeof arguments); // "object"</pre>
+```js
+console.log(typeof arguments); // "object"
+```
 
-<p>On peut tout à fait utiliser <code>typeof</code> sur chacun des arguments afin de connaître leur type respectif</p>
+On peut tout à fait utiliser `typeof` sur chacun des arguments afin de connaître leur type respectif
 
-<pre class="brush: js">console.log(typeof arguments[0]); // renvoie le type du premier argument</pre>
+```js
+console.log(typeof arguments[0]); // renvoie le type du premier argument
+```
 
-<h2 id="Propriétés">Propriétés</h2>
+## Propriétés
 
-<dl>
- <dt>{{jsxref("Fonctions/arguments/callee", "arguments.callee")}} {{Deprecated_inline}}</dt>
- <dd>Référence à la fonction en cours d'exécution.</dd>
- <dt>{{jsxref("Fonctions/arguments/caller", "arguments.caller")}} {{Obsolete_inline}}</dt>
- <dd>Référence à la fonction appelante.</dd>
- <dt>{{jsxref("Fonctions/arguments/length", "arguments.length")}}</dt>
- <dd>Référence au nombre d'arguments passés à la fonction.</dd>
- <dt>{{jsxref("Fonctions/arguments/@@iterator", "arguments[@@iterator]")}}</dt>
- <dd>Renvoie un nouvel <a href="/fr/docs/Web/JavaScript/Guide/iterateurs_et_generateurs#Itérateurs">itérateur</a> qui contient les valeurs pour chaque indice d'<code>arguments</code>.</dd>
-</dl>
+- {{jsxref("Fonctions/arguments/callee", "arguments.callee")}} {{Deprecated_inline}}
+  - : Référence à la fonction en cours d'exécution.
+- {{jsxref("Fonctions/arguments/caller", "arguments.caller")}} {{Obsolete_inline}}
+  - : Référence à la fonction appelante.
+- {{jsxref("Fonctions/arguments/length", "arguments.length")}}
+  - : Référence au nombre d'arguments passés à la fonction.
+- {{jsxref("Fonctions/arguments/@@iterator", "arguments[@@iterator]")}}
+  - : Renvoie un nouvel [itérateur](/fr/docs/Web/JavaScript/Guide/iterateurs_et_generateurs#Itérateurs) qui contient les valeurs pour chaque indice d'`arguments`.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Définir_une_fonction_de_concaténation_d'un_nombre_variable_de_chaînes">Définir une fonction de concaténation d'un nombre variable de chaînes</h3>
+### Définir une fonction de concaténation d'un nombre variable de chaînes
 
-<p>Cet exemple définit une fonction qui concatène un nombre variable de chaînes. Le seul argument formel de la fonction est une chaîne spécifiant un séparateur inséré entre les chaînes concaténées. La fonction est définie comme suit :</p>
+Cet exemple définit une fonction qui concatène un nombre variable de chaînes. Le seul argument formel de la fonction est une chaîne spécifiant un séparateur inséré entre les chaînes concaténées. La fonction est définie comme suit :
 
-<pre class="brush:js">function myConcat(separateur) {
+```js
+function myConcat(separateur) {
   var args = Array.prototype.slice.call(arguments, 1);
   return args.join(separateur);
-}</pre>
+}
+```
 
-<p>Vous pouvez passer n'importe quel nombre d'arguments à cette fonction ; elle créera une liste en utilisant chaque argument comme un élément de la liste.</p>
+Vous pouvez passer n'importe quel nombre d'arguments à cette fonction ; elle créera une liste en utilisant chaque argument comme un élément de la liste.
 
-<pre class="brush:js">// renvoie "rouge, orange, bleu"
+```js
+// renvoie "rouge, orange, bleu"
 myConcat(", ", "rouge", "orange", "bleu");
 
 // renvoie "éléphant ; giraffe ; lion ; guépard"
 myConcat(" ; ", "elephant", "giraffe", "lion", "guépard");
-</pre>
+```
 
-<h3 id="Définir_une_fonction_de_création_de_listes_HTML">Définir une fonction de création de listes HTML</h3>
+### Définir une fonction de création de listes HTML
 
-<p>Cet exemple définit une fonction qui crée des chaînes définissant des listes HTML. Le seul argument formel de la fonction est une chaîne pouvant valoir "<code>u</code>" (unordered), si la liste doit être sans numérotation (avec des puces), ou "<code>o</code>" (ordered), si la liste doit être numérotée. La fonction est définie comme suit :</p>
+Cet exemple définit une fonction qui crée des chaînes définissant des listes HTML. Le seul argument formel de la fonction est une chaîne pouvant valoir "`u`" (unordered), si la liste doit être sans numérotation (avec des puces), ou "`o`" (ordered), si la liste doit être numérotée. La fonction est définie comme suit :
 
-<pre class="brush:js">function liste(type) {
-  var resultat = "&lt;" + type + "l&gt;&lt;li&gt;";
+```js
+function liste(type) {
+  var resultat = "<" + type + "l><li>";
   var args = Array.prototype.slice.call(arguments, 1);
-  resultat += args.join("&lt;/li&gt;&lt;li&gt;");
-  resultat += "&lt;/li&gt;&lt;/" + type + "l&gt;"; // end list
+  resultat += args.join("</li><li>");
+  resultat += "</li></" + type + "l>"; // end list
 
   return resultat;
-}</pre>
+}
+```
 
-<p>Vous pouvez passer n'importe quel nombre d'arguments à cette fonction ; elle créera une liste du type indiqué en ajoutant chaque argument comme élément dans la liste. Exemple :</p>
+Vous pouvez passer n'importe quel nombre d'arguments à cette fonction ; elle créera une liste du type indiqué en ajoutant chaque argument comme élément dans la liste. Exemple :
 
-<pre class="brush:js">var listeHTML = liste("u", "Un", "Deux", "Trois");
+```js
+var listeHTML = liste("u", "Un", "Deux", "Trois");
 
 /* listeHTML vaut  :
 
-"&lt;ul&gt;&lt;li&gt;Un&lt;/li&gt;&lt;li&gt;Deux&lt;/li&gt;&lt;li&gt;Trois&lt;/li&gt;&lt;/ul&gt;"
+"<ul><li>Un</li><li>Deux</li><li>Trois</li></ul>"
 
-*/</pre>
+*/
+```
 
-<h3 id="Paramètres_du_reste_paramètres_par_défaut_et_décomposition">Paramètres du reste, paramètres par défaut et décomposition</h3>
+### Paramètres du reste, paramètres par défaut et décomposition
 
-<p>L'objet <code>arguments</code> peut être utilisé en combinaison avec <a href="/fr/docs/Web/JavaScript/Reference/Fonctions/paramètres_du_reste">les paramètres du reste</a>, <a href="/fr/docs/Web/JavaScript/Reference/Fonctions/Valeurs_par_défaut_des_arguments">les paramètres par défaut</a> ou <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Affecter_par_décomposition">les paramètres décomposés</a>.</p>
+L'objet `arguments` peut être utilisé en combinaison avec [les paramètres du reste](/fr/docs/Web/JavaScript/Reference/Fonctions/paramètres_du_reste), [les paramètres par défaut](/fr/docs/Web/JavaScript/Reference/Fonctions/Valeurs_par_défaut_des_arguments) ou [les paramètres décomposés](/fr/docs/Web/JavaScript/Reference/Opérateurs/Affecter_par_décomposition).
 
-<pre class="brush: js">function toto(...args) {
+```js
+function toto(...args) {
   return args;
 }
 toto(1, 2, 3); // [1, 2, 3]
-</pre>
+```
 
-<p>Toutefois, pour les fonctions utilisées en mode non-strict, un<strong> objet <code>arguments</code></strong> n'est fourni à l'intérieur de la fonction uniquement si celle-ci n'utilise pas de <a href="/fr/docs/Web/JavaScript/Reference/Fonctions/paramètres_du_reste">paramètres du reste</a>, pas de <a href="/fr/docs/Web/JavaScript/Reference/Fonctions/Valeurs_par_défaut_des_arguments">paramètres par défaut</a> ou de <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Affecter_par_décomposition">paramètre décomposé</a>. Par exemple, dans la fonction suivante, qui utilise un paramètre par défaut, ce sera 10 qui sera renvoyé (et non 100) :</p>
+Toutefois, pour les fonctions utilisées en mode non-strict, un **objet `arguments`** n'est fourni à l'intérieur de la fonction uniquement si celle-ci n'utilise pas de [paramètres du reste](/fr/docs/Web/JavaScript/Reference/Fonctions/paramètres_du_reste), pas de [paramètres par défaut](/fr/docs/Web/JavaScript/Reference/Fonctions/Valeurs_par_défaut_des_arguments) ou de [paramètre décomposé](/fr/docs/Web/JavaScript/Reference/Opérateurs/Affecter_par_décomposition). Par exemple, dans la fonction suivante, qui utilise un paramètre par défaut, ce sera 10 qui sera renvoyé (et non 100) :
 
-<pre class="brush: js">function truc(a=1) {
+```js
+function truc(a=1) {
   arguments[0] = 100;
   return a;
 }
 truc(10); // 10
-</pre>
+```
 
-<p>Si l'objet <code>arguments</code> est modifié dans la fonction, cela modifiera la valeur du paramètre passé. Dans cet exemple où il n'y a ni <a href="/fr/docs/Web/JavaScript/Reference/Fonctions/param%C3%A8tres_du_reste">paramètres du reste</a>, ni <a href="/fr/docs/Web/JavaScript/Reference/Fonctions/Valeurs_par_défaut_des_arguments">paramètres par défaut</a>, ni <a href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateur_de_d%C3%A9composition">décomposition</a>, le résultat sera 100 :</p>
+Si l'objet `arguments` est modifié dans la fonction, cela modifiera la valeur du paramètre passé. Dans cet exemple où il n'y a ni [paramètres du reste](/fr/docs/Web/JavaScript/Reference/Fonctions/param%C3%A8tres_du_reste), ni [paramètres par défaut](/fr/docs/Web/JavaScript/Reference/Fonctions/Valeurs_par_défaut_des_arguments), ni [décomposition](/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateur_de_d%C3%A9composition), le résultat sera 100 :
 
-<pre class="brush: js">fonction truc(a) {
+```js
+fonction truc(a) {
   arguments[0] = 100;
   return a;
 }
-truc(10); // 100</pre>
+truc(10); // 100
+```
 
-<p>En fait, lorsqu'il n'y a aucun paramètre du reste, paramètre par défaut ou aucune décomposition, les arguments formels feront références aux valeurs de l'objet <code>arguments</code>. Lorsqu'on aura besoin d'accéder à ces valeurs, on accèdera aux valeurs contenues dans <code>arguments</code> et à l'inverse, lorsqu'on modifiera ces valeurs, cela modifiera le contenu d'<code>arguments</code>. Par exemple</p>
+En fait, lorsqu'il n'y a aucun paramètre du reste, paramètre par défaut ou aucune décomposition, les arguments formels feront références aux valeurs de l'objet `arguments`. Lorsqu'on aura besoin d'accéder à ces valeurs, on accèdera aux valeurs contenues dans `arguments` et à l'inverse, lorsqu'on modifiera ces valeurs, cela modifiera le contenu d'`arguments`. Par exemple
 
-<pre class="brush: js">function func(a, b) {
+```js
+function func(a, b) {
   arguments[0] = 99;
   arguments[1] = 99;
   console.log(a + " " +b);
 }
 
 func(1, 2); // 99 99
-</pre>
+```
 
-<p>ou encore :</p>
+ou encore :
 
-<pre class="brush: js">function func(a, b) {
+```js
+function func(a, b) {
   a = 9;
   b = 99;
   console.log(arguments[0] + " " + arguments[1]);
 }
 
 func(3, 4); // 9 99
-</pre>
+```
 
-<p>En revanche, dès qu'on utilise des paramètres du reste, des paramètres par défaut ou la décomposition, c'est le comportement normal qui sera appliqué :</p>
+En revanche, dès qu'on utilise des paramètres du reste, des paramètres par défaut ou la décomposition, c'est le comportement normal qui sera appliqué :
 
-<pre class="brush: js">function func(a, b, c = 9) {
+```js
+function func(a, b, c = 9) {
   arguments[0] = 99;
   arguments[1] = 98;
   console.log(a + " " + b);
 }
 
 func(3, 4); // 3 4
-</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 par JavaScript 1.1</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-10.6', 'Arguments Object')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES2015', '#sec-arguments-exotic-objects', 'Arguments Exotic Objects')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-arguments-exotic-objects', 'Arguments Exotic Objects')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.functions.arguments")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Function")}}</li>
- <li><a href="/fr/docs/Web/JavaScript/Reference/Fonctions/paramètres_du_reste">Les paramètres du reste</a></li>
- <li><a href="https://github.com/petkaantonov/bluebird/wiki/Optimization-killers#3-managing-arguments">Contraintes d'optimisations sous V8 en relation avec <code>arguments</code></a></li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                    | État                         | Commentaires                                        |
+| ---------------------------------------------------------------------------------------------------------------- | ---------------------------- | --------------------------------------------------- |
+| {{SpecName('ES1')}}                                                                                         | {{Spec2('ES1')}}         | Définition initiale. Implémentée par JavaScript 1.1 |
+| {{SpecName('ES5.1', '#sec-10.6', 'Arguments Object')}}                                         | {{Spec2('ES5.1')}}     |                                                     |
+| {{SpecName('ES2015', '#sec-arguments-exotic-objects', 'Arguments Exotic Objects')}} | {{Spec2('ES2015')}}     |                                                     |
+| {{SpecName('ESDraft', '#sec-arguments-exotic-objects', 'Arguments Exotic Objects')}} | {{Spec2('ESDraft')}} |                                                     |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.functions.arguments")}}
+
+## Voir aussi
+
+- {{jsxref("Function")}}
+- [Les paramètres du reste](/fr/docs/Web/JavaScript/Reference/Fonctions/paramètres_du_reste)
+- [Contraintes d'optimisations sous V8 en relation avec `arguments`](https://github.com/petkaantonov/bluebird/wiki/Optimization-killers#3-managing-arguments)
diff --git a/files/fr/web/javascript/reference/functions/arguments/length/index.md b/files/fr/web/javascript/reference/functions/arguments/length/index.md
index 495b0e6f20..7deb32f457 100644
--- a/files/fr/web/javascript/reference/functions/arguments/length/index.md
+++ b/files/fr/web/javascript/reference/functions/arguments/length/index.md
@@ -10,82 +10,56 @@ tags:
 translation_of: Web/JavaScript/Reference/Functions/arguments/length
 original_slug: Web/JavaScript/Reference/Fonctions/arguments/length
 ---
-<div>{{jsSideBar("Functions")}}</div>
+{{jsSideBar("Functions")}}
 
-<p>La propriété <strong><code>arguments.length</code></strong> contient le nombre d'arguments passés à la fonction.</p>
+La propriété **`arguments.length`** contient le nombre d'arguments passés à la fonction.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">arguments.length</pre>
+    arguments.length
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La propriété <code>arguments.length</code> fournit le nombre d'arguments qui ont été passés à la fonction. Cette quantité peut être inférieure ou supérieure au nombre de paramètres explicitement déclarés dans la définition de la fonction (voir également {{jsxref("Function.length")}}).</p>
+La propriété `arguments.length` fournit le nombre d'arguments qui ont été passés à la fonction. Cette quantité peut être inférieure ou supérieure au nombre de paramètres explicitement déclarés dans la définition de la fonction (voir également {{jsxref("Function.length")}}).
 
-<h2 id="Exemple">Exemple</h2>
+## Exemple
 
-<h3 id="Utiliser_arguments.length">Utiliser <code>arguments.length</code></h3>
+### Utiliser `arguments.length`
 
-<p>Dans cet exemple, on définit une fonction qui permet d'additionner plusieurs nombres.</p>
+Dans cet exemple, on définit une fonction qui permet d'additionner plusieurs nombres.
 
-<pre class="brush: js">function somme(x /*, y, z, ...*/) {
+```js
+function somme(x /*, y, z, ...*/) {
    x = Number(x);
-   for (var i = 1; i &lt; arguments.length; i++) {
+   for (var i = 1; i < arguments.length; i++) {
       x += Number(arguments[i]);
    }
    return x;
 }
-</pre>
+```
 
-<pre class="brush: js">résultat = somme(3, 4, 5);        // renvoie 12
+```js
+résultat = somme(3, 4, 5);        // renvoie 12
 résultat = somme(3, 4);           // renvoie 7
 résultat = somme(103, 104, 105);  // renvoie 312
-</pre>
-
-<div class="note">
-<p><strong>Note :</strong> <code>arguments.length</code> ne doit pas être confondu avec {{jsxref("Function.length")}}.</p>
-</div>
-
-<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 par JavaScript 1.1</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-10.6', 'Arguments Object')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-arguments-exotic-objects', 'Arguments Exotic Objects')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-arguments-exotic-objects', 'Arguments Exotic Objects')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-
-<p>{{Compat("javascript.functions.arguments.length")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Function")}}</li>
- <li>{{jsxref("Function.length")}}</li>
-</ul>
+```
+
+> **Note :** `arguments.length` ne doit pas être confondu avec {{jsxref("Function.length")}}.
+
+## Spécifications
+
+| Spécification                                                                                                    | État                         | Commentaires                                        |
+| ---------------------------------------------------------------------------------------------------------------- | ---------------------------- | --------------------------------------------------- |
+| {{SpecName('ES1')}}                                                                                         | {{Spec2('ES1')}}         | Définition initiale. Implémentée par JavaScript 1.1 |
+| {{SpecName('ES5.1', '#sec-10.6', 'Arguments Object')}}                                         | {{Spec2('ES5.1')}}     |                                                     |
+| {{SpecName('ES6', '#sec-arguments-exotic-objects', 'Arguments Exotic Objects')}}     | {{Spec2('ES6')}}         |                                                     |
+| {{SpecName('ESDraft', '#sec-arguments-exotic-objects', 'Arguments Exotic Objects')}} | {{Spec2('ESDraft')}} |                                                     |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.functions.arguments.length")}}
+
+## Voir aussi
+
+- {{jsxref("Function")}}
+- {{jsxref("Function.length")}}
diff --git a/files/fr/web/javascript/reference/functions/arrow_functions/index.md b/files/fr/web/javascript/reference/functions/arrow_functions/index.md
index 8beaaa3098..c40336f008 100644
--- a/files/fr/web/javascript/reference/functions/arrow_functions/index.md
+++ b/files/fr/web/javascript/reference/functions/arrow_functions/index.md
@@ -9,66 +9,62 @@ tags:
 translation_of: Web/JavaScript/Reference/Functions/Arrow_functions
 original_slug: Web/JavaScript/Reference/Fonctions/Fonctions_fléchées
 ---
-<div>{{jsSidebar("Functions")}}</div>
+{{jsSidebar("Functions")}}
 
-<p>Une <strong>expression de fonction fléchée</strong> (<em>arrow function</em> en anglais) permet d’avoir une syntaxe plus courte que <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_function">les expressions de fonction</a> et ne possède pas ses propres valeurs pour <code><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_this">this</a></code>, <code><a href="/fr/docs/Web/JavaScript/Reference/Fonctions/arguments">arguments</a></code>, <code><a href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/super">super</a></code>, ou <code><a href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/new.target">new.target</a></code>. Les fonctions fléchées sont souvent <a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Function/name">anonymes</a> et ne sont pas destinées à être utilisées pour déclarer des méthodes.</p>
+Une **expression de fonction fléchée** (_arrow function_ en anglais) permet d’avoir une syntaxe plus courte que [les expressions de fonction](/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_function) et ne possède pas ses propres valeurs pour [`this`](/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_this), [`arguments`](/fr/docs/Web/JavaScript/Reference/Fonctions/arguments), [`super`](/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/super), ou [`new.target`](/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/new.target). Les fonctions fléchées sont souvent [anonymes](/fr/docs/Web/JavaScript/Reference/Objets_globaux/Function/name) et ne sont pas destinées à être utilisées pour déclarer des méthodes.
 
-<div>{{EmbedInteractiveExample("pages/js/functions-arrow.html")}}</div>
+{{EmbedInteractiveExample("pages/js/functions-arrow.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">([param] [, param]) =&gt; {
-   instructions
-}
+    ([param] [, param]) => {
+       instructions
+    }
 
-(param1, param2, …, param2) =&gt; expression
-// équivalent à
-(param1, param2, …, param2) =&gt; {
-  return expression;
-}
+    (param1, param2, …, param2) => expression
+    // équivalent à
+    (param1, param2, …, param2) => {
+      return expression;
+    }
 
-// Parenthèses non nécessaires quand il n'y a qu'un seul argument
-param =&gt; expression
+    // Parenthèses non nécessaires quand il n'y a qu'un seul argument
+    param => expression
 
-// Une fonction sans paramètre peut s'écrire avec un couple
-// de parenthèses
-() =&gt; {
-  instructions
-}
+    // Une fonction sans paramètre peut s'écrire avec un couple
+    // de parenthèses
+    () => {
+      instructions
+    }
 
-// Gestion des <a href="/en-US/docs/Web/JavaScript/Reference/Functions/rest_parameters">paramètres du reste</a> et <a href="/en-US/docs/Web/JavaScript/Reference/Functions/Default_parameters">paramètres par défaut</a>
-(param1, param2, ...reste) =&gt; {
-  instructions
-}
-(param1 = valeurDefaut1, param2, …, paramN = valeurDefautN) =&gt; {
-  instructions
-}
+    // Gestion des paramètres du reste et paramètres par défaut
+    (param1, param2, ...reste) => {
+      instructions
+    }
+    (param1 = valeurDefaut1, param2, …, paramN = valeurDefautN) => {
+      instructions
+    }
 
-// Gestion de la décomposition pour la liste des paramètres
-let f = ([a, b] = [1, 2], {x: c} = {x: a + b}) =&gt; a + b + c;
-f();
-</pre>
+    // Gestion de la décomposition pour la liste des paramètres
+    let f = ([a, b] = [1, 2], {x: c} = {x: a + b}) => a + b + c;
+    f();
 
-<dl>
- <dt><code>param</code></dt>
- <dd>Le nom d’un argument. S’il n'y a aucun argument, cela doit être indiqué par une paire de parenthèses <code>()</code>. S’il n'y a qu’un argument, les parenthèses ne sont pas nécessaires (ex. : <code>toto =&gt; 1</code>).</dd>
- <dt><code>instructions</code> ou <code>expression</code></dt>
- <dd>Plusieurs instructions doivent être encadrées par des accolades, {}. Une expression simple ne nécessite pas d’accolades. L’expression est également la valeur de retour implicite pour cette fonction.</dd>
-</dl>
+- `param`
+  - : Le nom d’un argument. S’il n'y a aucun argument, cela doit être indiqué par une paire de parenthèses `()`. S’il n'y a qu’un argument, les parenthèses ne sont pas nécessaires (ex. : `toto => 1`).
+- `instructions` ou `expression`
+  - : Plusieurs instructions doivent être encadrées par des accolades, {}. Une expression simple ne nécessite pas d’accolades. L’expression est également la valeur de retour implicite pour cette fonction.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Deux facteurs sont à l’origine de la conception des fonctions fléchées : une syntaxe plus courte et l’absence de <code>this</code> spécifique à la fonction. Sur ce dernier point, cela signifie qu’une fonction fléchée ne lie pas son propre {{jsxref("Opérateurs/L_opérateur_this","this")}} au sein de la fonction (il en va de même avec {{jsxref("Fonctions/arguments","arguments")}}, {{jsxref("Opérateurs/super","super")}} ou {{jsxref("Opérateurs/new.target","new.target")}}).</p>
+Deux facteurs sont à l’origine de la conception des fonctions fléchées : une syntaxe plus courte et l’absence de `this` spécifique à la fonction. Sur ce dernier point, cela signifie qu’une fonction fléchée ne lie pas son propre {{jsxref("Opérateurs/L_opérateur_this","this")}} au sein de la fonction (il en va de même avec {{jsxref("Fonctions/arguments","arguments")}}, {{jsxref("Opérateurs/super","super")}} ou {{jsxref("Opérateurs/new.target","new.target")}}).
 
-<div class="note">
-<p><strong>Note :</strong> Voir aussi l’article sur les fonctions fléchées présent sur <a href="https://tech.mozfr.org/post/2015/06/10/ES6-en-details-%3A-les-fonctions-flechees">https://tech.mozfr.org/post/2015/06/10/ES6-en-details-%3A-les-fonctions-flechees</a> (l’article original en anglais est disponible <a href="https://hacks.mozilla.org/2015/06/es6-in-depth-arrow-functions/">ici</a>).</p>
-</div>
+> **Note :** Voir aussi l’article sur les fonctions fléchées présent sur <https://tech.mozfr.org/post/2015/06/10/ES6-en-details-%3A-les-fonctions-flechees> (l’article original en anglais est disponible [ici](https://hacks.mozilla.org/2015/06/es6-in-depth-arrow-functions/)).
 
-<h3 id="Syntaxe_plus_courte">Syntaxe plus courte</h3>
+### Syntaxe plus courte
 
-<p>Pour des aspects fonctionnels, la légèreté de la syntaxe est bienvenue. Par exemple :</p>
+Pour des aspects fonctionnels, la légèreté de la syntaxe est bienvenue. Par exemple :
 
-<pre class="brush: js">var a = [
+```js
+var a = [
   "We're up all night 'til the sun",
   "We're up all night to get some",
   "We're up all night for good fun",
@@ -80,22 +76,22 @@ var a2 = a.map(function (s) { return s.length });
 // [31, 30, 31, 31]
 
 // Avec, on a quelque chose de plus concis
-var a3 = a.map( s =&gt; s.length);
-// [31, 30, 31, 31]</pre>
+var a3 = a.map( s => s.length);
+// [31, 30, 31, 31]
+```
 
-<h3 id="Pas_de_this_lié_à_la_fonction">Pas de <code>this</code> lié à la fonction</h3>
+### Pas de `this` lié à la fonction
 
-<p>Jusqu’a l’apparition des fonctions fléchées, chaque nouvelle fonction définissait son propre {{jsxref("Opérateurs/L_opérateur_this","this")}} :</p>
+Jusqu’a l’apparition des fonctions fléchées, chaque nouvelle fonction définissait son propre {{jsxref("Opérateurs/L_opérateur_this","this")}} :
 
-<ul>
- <li>un nouvel objet dans le cas d’un constructeur</li>
- <li><code>undefined</code> dans les appels de fonctions en <a href="/fr/docs/Web/JavaScript/Reference/Strict_mode">mode strict</a></li>
- <li>l’objet courant si la fonction est appelée comme une méthode, etc.</li>
-</ul>
+- un nouvel objet dans le cas d’un constructeur
+- `undefined` dans les appels de fonctions en [mode strict](/fr/docs/Web/JavaScript/Reference/Strict_mode)
+- l’objet courant si la fonction est appelée comme une méthode, etc.
 
-<p>Cela a pu entraîner des confusions lorsqu’on utilisait un style de programmation orientée objet.</p>
+Cela a pu entraîner des confusions lorsqu’on utilisait un style de programmation orientée objet.
 
-<pre class="brush: js">function Personne () {
+```js
+function Personne () {
   // Le constructeur Personne() définit `this` comme lui-même.
   this.age = 0;
 
@@ -107,11 +103,13 @@ var a3 = a.map( s =&gt; s.length);
   }, 1000);
 }
 
-var p = new Personne();</pre>
+var p = new Personne();
+```
 
-<p>Avec ECMAScript 3/5, ce problème a pu être résolu en affectant la valeur de <code>this</code> à une autre variable :</p>
+Avec ECMAScript 3/5, ce problème a pu être résolu en affectant la valeur de `this` à une autre variable :
 
-<pre class="brush: js">function Personne () {
+```js
+function Personne () {
   var that = this;
   that.age = 0;
 
@@ -120,46 +118,52 @@ var p = new Personne();</pre>
     // qui est le contexte souhaité
     that.age++;
   }, 1000);
-}</pre>
+}
+```
 
-<p>Autrement, on aurait pu utiliser une <a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Function/bind">fonction de liaison</a> afin que la bonne valeur <code>this</code> soit passée à la fonction <code>grandir</code>.</p>
+Autrement, on aurait pu utiliser une [fonction de liaison](/fr/docs/Web/JavaScript/Reference/Objets_globaux/Function/bind) afin que la bonne valeur `this` soit passée à la fonction `grandir`.
 
-<p>Les fonctions fléchées ne créent pas de nouveau contexte, elles utilisent la valeur <code>this</code> de leur contexte. Aussi, si le mot-clé <code>this</code> est utilisé dans le corps de la fonction, le moteur recherchera la référence à cette valeur dans une portée parente. Le code qui suit fonctionne ainsi de la façon attendue car le <code>this</code> utilisé dans <code>setInterval</code> est le <code>this</code>de la portée de <code>Personne</code> :</p>
+Les fonctions fléchées ne créent pas de nouveau contexte, elles utilisent la valeur `this` de leur contexte. Aussi, si le mot-clé `this` est utilisé dans le corps de la fonction, le moteur recherchera la référence à cette valeur dans une portée parente. Le code qui suit fonctionne ainsi de la façon attendue car le `this` utilisé dans `setInterval` est le `this`de la portée de `Personne` :
 
-<pre class="brush: js">function Personne () {
+```js
+function Personne () {
   this.age = 0;
 
-  setInterval(() =&gt; {
+  setInterval(() => {
     this.age++;
     // |this| fait bien référence à l'objet personne
   }, 1000);
 }
 
-var p = new Personne();</pre>
+var p = new Personne();
+```
 
-<h4 id="Liens_avec_le_mode_strict">Liens avec le mode strict</h4>
+#### Liens avec le mode strict
 
-<p>Ici <code>this</code> provient du contexte englobant, les règles du <a href="/fr/docs/Web/JavaScript/Reference/Fonctions_et_portee_des_fonctions/Strict_mode">mode strict</a> sont donc ignorées pour ce qui concerne <code>this</code>.</p>
+Ici `this` provient du contexte englobant, les règles du [mode strict](/fr/docs/Web/JavaScript/Reference/Fonctions_et_portee_des_fonctions/Strict_mode) sont donc ignorées pour ce qui concerne `this`.
 
-<pre class="brush: js">var f = () =&gt; {'use strict'; return this};
-f() === window; // ou l'objet global</pre>
+```js
+var f = () => {'use strict'; return this};
+f() === window; // ou l'objet global
+```
 
-<p>Le reste des règles du mode strict sont appliquées normalement.</p>
+Le reste des règles du mode strict sont appliquées normalement.
 
-<h4 id="Appel_via_jsxref(Function.prototype.call())_ou_jsxref(Function.prototype.apply())">Appel via {{jsxref("Function.prototype.call()")}} ou {{jsxref("Function.prototype.apply()")}}</h4>
+#### Appel via {{jsxref("Function.prototype.call()")}} ou {{jsxref("Function.prototype.apply()")}}
 
-<p>Étant donné que <code>this</code> provient du contexte englobant, si on invoque une fonction via la méthode <code>call</code> ou <code>apply</code>, cela ne passera que des arguments mais n’aura aucun effet sur <code>this</code> :</p>
+Étant donné que `this` provient du contexte englobant, si on invoque une fonction via la méthode `call` ou `apply`, cela ne passera que des arguments mais n’aura aucun effet sur `this` :
 
-<pre class="brush: js">var ajouter = {
+```js
+var ajouter = {
   base: 1,
 
   add : function (a) {
-    var f = v =&gt; v + this.base;
+    var f = v => v + this.base;
     return f(a);
   },
 
   addViaCall: function (a) {
-    var f = v =&gt; v + this.base;
+    var f = v => v + this.base;
     var b = {
       base: 2
     };
@@ -172,42 +176,47 @@ console.log(ajouter.add(1));
 
 console.log(ajouter.addViaCall(1));
 // Cela affichera toujours 2
-</pre>
+```
 
-<h4 id="Pas_de_liaison_pour_arguments">Pas de liaison pour <code>arguments</code></h4>
+#### Pas de liaison pour `arguments`
 
-<p>Les fonctions fléchées n’exposent pas d’objet <a href="/fr/docs/Web/JavaScript/Reference/Fonctions/arguments"><code>arguments</code></a> : <code>arguments.length</code>, <code>arguments[0]</code>, <code>arguments[1]</code>, et autres ne font donc pas référence aux arguments passés à la fonction fléchés. Dans ce cas <code>arguments</code> est simplement une référence à la variable de même nom si elle est présente dans la portée englobante :</p>
+Les fonctions fléchées n’exposent pas d’objet [`arguments`](/fr/docs/Web/JavaScript/Reference/Fonctions/arguments) : `arguments.length`, `arguments[0]`, `arguments[1]`, et autres ne font donc pas référence aux arguments passés à la fonction fléchés. Dans ce cas `arguments` est simplement une référence à la variable de même nom si elle est présente dans la portée englobante :
 
-<pre class="brush: js">var arguments = [1, 2, 3];
-var arr = () =&gt; arguments[0];
+```js
+var arguments = [1, 2, 3];
+var arr = () => arguments[0];
 
 arr(); // 1
 
 function toto () {
-  var f = (i) =&gt; arguments[0] + i;
+  var f = (i) => arguments[0] + i;
   // lien implicite avec arguments de toto
   return f(2);
 }
 
-toto(3); // 5</pre>
+toto(3); // 5
+```
 
-<p>Les fonctions fléchées n’ont donc pas leur propre objet <code>arguments</code>, mais dans la plupart des cas, <a href="/fr/docs/Web/JavaScript/Reference/Fonctions/paramètres_du_reste">les paramètres du reste</a> représentent une bonne alternative :</p>
+Les fonctions fléchées n’ont donc pas leur propre objet `arguments`, mais dans la plupart des cas, [les paramètres du reste](/fr/docs/Web/JavaScript/Reference/Fonctions/paramètres_du_reste) représentent une bonne alternative :
 
-<pre class="brush: js">function toto () {
-  var f = (...args) =&gt; args[0];
+```js
+function toto () {
+  var f = (...args) => args[0];
   return f(2);
 }
 
-toto(1); // 2</pre>
+toto(1); // 2
+```
 
-<h4 id="Les_fonctions_fléchées_comme_méthodes">Les fonctions fléchées comme méthodes</h4>
+#### Les fonctions fléchées comme méthodes
 
-<p>Comme indiqué précédemment, les fonctions fléchées sont mieux indiquées pour les fonctions qui ne sont pas des méthodes. Prenons un exemple pour illustrer ce point</p>
+Comme indiqué précédemment, les fonctions fléchées sont mieux indiquées pour les fonctions qui ne sont pas des méthodes. Prenons un exemple pour illustrer ce point
 
-<pre class="brush: js">'use strict';
+```js
+'use strict';
 var objet = {
   i: 10,
-  b: () =&gt; console.log(this.i, this),
+  b: () => console.log(this.i, this),
   c: function() {
     console.log(this.i, this);
   }
@@ -217,95 +226,106 @@ objet.b();
 // affiche undefined, Window (ou l'objet global de l'environnement)
 
 objet.c();
-// affiche 10, Object {...}</pre>
+// affiche 10, Object {...}
+```
 
-<h4 id="Utiliser_prototype">Utiliser <code>prototype</code></h4>
+#### Utiliser `prototype`
 
-<p>Les fonctions fléchées ne possèdent pas de prototype :</p>
+Les fonctions fléchées ne possèdent pas de prototype :
 
-<pre class="brush: js">var Toto = () =&gt; {};
+```js
+var Toto = () => {};
 console.log(Toto.prototype);
-</pre>
+```
 
-<h4 id="Utiliser_le_mot-clé_yield">Utiliser le mot-clé <code>yield</code></h4>
+#### Utiliser le mot-clé `yield`
 
-<p>Le mot-clé <code><a href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/yield">yield</a></code> ne peut pas être utilisé dans le corps d’une fonction fléchée (sauf si cela intervient dans une autre fonction, imbriquée dans la fonction fléchée). De fait, les fonctions fléchéees ne peuvent donc pas être utilisées comme générateurs.</p>
+Le mot-clé [`yield`](/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/yield) ne peut pas être utilisé dans le corps d’une fonction fléchée (sauf si cela intervient dans une autre fonction, imbriquée dans la fonction fléchée). De fait, les fonctions fléchéees ne peuvent donc pas être utilisées comme générateurs.
 
-<h4 id="Utiliser_le_mot-clé_new">Utiliser le mot-clé <code>new</code></h4>
+#### Utiliser le mot-clé `new`
 
-<p>Les fonctions fléchées ne peuvent pas être utilisées comme constructeurs et lèveront une exception si elles sont utilisées avec le mot-clé <code>new</code>.</p>
+Les fonctions fléchées ne peuvent pas être utilisées comme constructeurs et lèveront une exception si elles sont utilisées avec le mot-clé `new`.
 
-<pre class="brush: js">var Toto = () =&gt; {};
+```js
+var Toto = () => {};
 var toto = new Toto();
-// TypeError: Toto is not a constructor</pre>
+// TypeError: Toto is not a constructor
+```
 
-<h2 id="Gestion_du_corps_de_la_fonction">Gestion du corps de la fonction</h2>
+## Gestion du corps de la fonction
 
-<p>Les fonctions fléchées peuvent avoir une syntaxe concise ou utiliser un bloc d’instructions classique. Cette dernière syntaxe n’a pas de valeur de retour implicite et il faut donc employer l’instruction <code>return</code>.</p>
+Les fonctions fléchées peuvent avoir une syntaxe concise ou utiliser un bloc d’instructions classique. Cette dernière syntaxe n’a pas de valeur de retour implicite et il faut donc employer l’instruction `return`.
 
-<pre class="brush: js">// méthode concise, retour implicite
-var fonction = x =&gt; x * x;
+```js
+// méthode concise, retour implicite
+var fonction = x => x * x;
 
 // bloc classique, retour explicite
-var fonction = (x, y) =&gt; { return x + y; }
-</pre>
+var fonction = (x, y) => { return x + y; }
+```
 
-<h2 id="Renvoyer_des_littéraux_objets">Renvoyer des littéraux objets</h2>
+## Renvoyer des littéraux objets
 
-<p>Attention à bien utiliser les parenthèses lorsqu’on souhaite renvoyer des objets avec des littéraux :</p>
+Attention à bien utiliser les parenthèses lorsqu’on souhaite renvoyer des objets avec des littéraux :
 
-<pre class="brush: js">// fonction() renverra undefined !
-var fonction = () =&gt; { toto: 1 };
+```js
+// fonction() renverra undefined !
+var fonction = () => { toto: 1 };
 
 // SyntaxError
-var fonction2 = () =&gt;  { toto: function () {} };
-</pre>
+var fonction2 = () =>  { toto: function () {} };
+```
 
-<p>En effet, ici, l’analyse de l’expression trouve des blocs d’instructions au lieu de littéraux objets. Pour éviter cet effet indésirable, on pourra encadrer le littéral objet :</p>
+En effet, ici, l’analyse de l’expression trouve des blocs d’instructions au lieu de littéraux objets. Pour éviter cet effet indésirable, on pourra encadrer le littéral objet :
 
-<pre class="brush: js">var fonction = () =&gt; ({ toto: 1 });</pre>
+```js
+var fonction = () => ({ toto: 1 });
+```
 
-<h2 id="Sauts_de_ligne">Sauts de ligne</h2>
+## Sauts de ligne
 
-<p>Il ne peut pas y avoir de saut de ligne entre les paramètres et la flèche d’une fonction fléchée.</p>
+Il ne peut pas y avoir de saut de ligne entre les paramètres et la flèche d’une fonction fléchée.
 
-<pre class="brush: js">var func = ()
-            =&gt; 1; // SyntaxError: expected expression,
-                  //              got '=&gt;'
-</pre>
+```js
+var func = ()
+            => 1; // SyntaxError: expected expression,
+                  //              got '=>'
+```
 
-<h2 id="Ordre_syntaxique">Ordre syntaxique</h2>
+## Ordre syntaxique
 
-<p>La flèche utilisée pour une fonction fléchée n’est pas un opérateur. Les fonctions fléchées ont des règles spécifiques quant à leur place dans la syntaxe et interagissent différemment de la précédence des opérateurs par rapport à une fonction classique :</p>
+La flèche utilisée pour une fonction fléchée n’est pas un opérateur. Les fonctions fléchées ont des règles spécifiques quant à leur place dans la syntaxe et interagissent différemment de la précédence des opérateurs par rapport à une fonction classique :
 
-<pre class="brush: js">let fonctionRappel;
+```js
+let fonctionRappel;
 
 fonctionRappel = fonctionRappel || function () {};
 // OK
 
-fonctionRappel = fonctionRappel || () =&gt; {};
+fonctionRappel = fonctionRappel || () => {};
 // SyntaxError: invalid arrow-function arguments
 
-fonctionRappel = fonctionRappel || (() =&gt; {});
+fonctionRappel = fonctionRappel || (() => {});
 // OK
-</pre>
+```
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<pre class="brush: js">// Une fonction fléchée vide renvoie undefined
-let vide = () =&gt; {};
+```js
+// Une fonction fléchée vide renvoie undefined
+let vide = () => {};
 
-(() =&gt; "tototruc")()
+(() => "tototruc")()
 // exemple d'une fonction immédiatement
 // invoquée (IIFE en anglais) qui renvoie
 // "tototruc"
 
-var simple = a =&gt; a &gt; 15 ? 15 : a;
+var simple = a => a > 15 ? 15 : a;
 simple(16); // 15
 simple(10); // 10
 
-var complexe = (a, b) =&gt; {
-    if (a &gt; b) {
+var complexe = (a, b) => {
+    if (a > b) {
         return a;
     } else {
         return b;
@@ -314,61 +334,44 @@ var complexe = (a, b) =&gt; {
 
 var arr = [5, 6, 13, 0, 1, 18, 23];
 
-var sum = arr.reduce((a, b) =&gt; a + b);
+var sum = arr.reduce((a, b) => a + b);
 // 66
 
-var even = arr.filter(v =&gt; v % 2 == 0);
+var even = arr.filter(v => v % 2 == 0);
 // [6, 0, 18]
 
-var double = arr.map(v =&gt; v * 2);
+var double = arr.map(v => v * 2);
 // [10, 12, 26, 0, 2, 36, 46]
 
 // On peut aussi construire des chaînes
 // de promesses plus concises
-promise.then(a =&gt; {
+promise.then(a => {
     // ...
-}).then(b =&gt; {
+}).then(b => {
     // ...
 });
 
 // Cela permet de visualiser les
 // fonctions sans paramètres
-setTimeout( () =&gt; {
+setTimeout( () => {
     console.log("Et voilà");
-    setTimeout( () =&gt; {
+    setTimeout( () => {
         console.log("ensuite…");
     }, 1);
 }, 1);
-</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-arrow-function-definitions', 'Arrow Function Definitions')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-arrow-function-definitions', 'Arrow Function Definitions')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.functions.arrow_functions")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>L’article sur les fonctions fléchées présent sur <a href="https://tech.mozfr.org">https ://tech.mozfr.org</a> (l’article original en anglais est disponible <a href="https://hacks.mozilla.org/2015/06/es6-in-depth-arrow-functions/">ici</a>).</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                        | État                         | Commentaires         |
+| -------------------------------------------------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ES2015', '#sec-arrow-function-definitions', 'Arrow Function Definitions')}} | {{Spec2('ES2015')}}     | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-arrow-function-definitions', 'Arrow Function Definitions')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.functions.arrow_functions")}}
+
+## Voir aussi
+
+- L’article sur les fonctions fléchées présent sur [https ://tech.mozfr.org](https://tech.mozfr.org) (l’article original en anglais est disponible [ici](https://hacks.mozilla.org/2015/06/es6-in-depth-arrow-functions/)).
diff --git a/files/fr/web/javascript/reference/functions/default_parameters/index.md b/files/fr/web/javascript/reference/functions/default_parameters/index.md
index abcdcae567..92a5187cf6 100644
--- a/files/fr/web/javascript/reference/functions/default_parameters/index.md
+++ b/files/fr/web/javascript/reference/functions/default_parameters/index.md
@@ -9,28 +9,26 @@ tags:
 translation_of: Web/JavaScript/Reference/Functions/Default_parameters
 original_slug: Web/JavaScript/Reference/Fonctions/Valeurs_par_défaut_des_arguments
 ---
-<div>{{jsSidebar("Functions")}}</div>
+{{jsSidebar("Functions")}}
 
-<p>Cette syntaxe permet d'initialiser des paramètres lors de l'appel de la fonction si aucune valeur n'est passée ou si c'est la valeur {{jsxref("undefined")}} qui est passée.</p>
+Cette syntaxe permet d'initialiser des paramètres lors de l'appel de la fonction si aucune valeur n'est passée ou si c'est la valeur {{jsxref("undefined")}} qui est passée.
 
+{{EmbedInteractiveExample("pages/js/functions-default.html")}}
 
+## Syntaxe
 
-<div>{{EmbedInteractiveExample("pages/js/functions-default.html")}}</div>
+    function [nom]([param1[ = valeurParDéfaut1 ][, ..., paramN[ = valeurParDéfautN ]]]) {
+       instructions
+    }
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Description
 
-<pre class="syntaxbox">function [<em>nom</em>]([<em>param1</em>[ = valeurParDéfaut1 ][, ..., <em>paramN</em>[ = valeurParDéfautN ]]]) {
-   instructions
-}
-</pre>
-
-<h2 id="Description">Description</h2>
-
-<p>En JavaScript, par défaut, la valeur des paramètres d'une fonction sera <code>undefined</code>. Malgré tout, il peut être assez utile de pouvoir définir d'autres valeurs par défaut.</p>
+En JavaScript, par défaut, la valeur des paramètres d'une fonction sera `undefined`. Malgré tout, il peut être assez utile de pouvoir définir d'autres valeurs par défaut.
 
-<p>Auparavant, pour définir une valeur par défaut pour un paramètre, il fallait tester s'il valait <code>undefined</code> et lui affecter une valeur choisie le cas échéant. Dans l'exemple qui suit, le paramètre <code>b</code> n'a pas de valeur fournie lors de l'appel, aussi si on avait utilisé <code>undefined</code> dans la multiplication, la valeur retournée aurait été <code>NaN</code>. Aussi, dans la deuxième ligne du code, on prévoit ce cas :</p>
+Auparavant, pour définir une valeur par défaut pour un paramètre, il fallait tester s'il valait `undefined` et lui affecter une valeur choisie le cas échéant. Dans l'exemple qui suit, le paramètre `b` n'a pas de valeur fournie lors de l'appel, aussi si on avait utilisé `undefined` dans la multiplication, la valeur retournée aurait été `NaN`. Aussi, dans la deuxième ligne du code, on prévoit ce cas :
 
-<pre class="brush: js">function multiplier(a, b) {
+```js
+function multiplier(a, b) {
   var b = (typeof b !== 'undefined') ? b : 1;
 
   return a * b;
@@ -39,26 +37,29 @@ original_slug: Web/JavaScript/Reference/Fonctions/Valeurs_par_défaut_des_argume
 multiplier(5, 2); // 10
 multiplier(5, 1); // 5
 multiplier(5);    // 5
-</pre>
+```
 
-<p>Grâce aux paramètres par défaut qui existent depuis ECMAScript 2015 (ES6), on peut se passer de cette vérification et alléger le code de la fonction :</p>
+Grâce aux paramètres par défaut qui existent depuis ECMAScript 2015 (ES6), on peut se passer de cette vérification et alléger le code de la fonction :
 
-<pre class="brush: js">function multiplier(a, b = 1) {
+```js
+function multiplier(a, b = 1) {
   return a * b;
 }
 
 multiplier(5, 2); // 10
 multiplier(5, 1); // 5
 multiplier(5, undefined); // 5
-multiplier(5); // 5</pre>
+multiplier(5); // 5
+```
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Passer_undefined_en_paramètre">Passer <code>undefined</code> en paramètre</h3>
+### Passer `undefined` en paramètre
 
-<p>Dans l'exemple qui suit, le deuxième appel à la fonction fait explicitement appel à <code>undefined</code>. La valeur par défaut sera utilisée, y compris dans ce cas (en revanche, ce ne serait pas vrai pour <code>null</code> ou les autres valeurs équivalentes à <code>false</code> dans un contexte booléen).</p>
+Dans l'exemple qui suit, le deuxième appel à la fonction fait explicitement appel à `undefined`. La valeur par défaut sera utilisée, y compris dans ce cas (en revanche, ce ne serait pas vrai pour `null` ou les autres valeurs équivalentes à `false` dans un contexte booléen).
 
-<pre class="brush: js">function test(num = 1) {
+```js
+function test(num = 1) {
   console.log(typeof num);
 }
 
@@ -66,38 +67,40 @@ test();           // number (num vaut 1)
 test(undefined);  // number (num vaut 1 également)
 test("");         // string (num vaut "")
 test(null);       // object (num vaut null)
-</pre>
+```
 
-<h3 id="Évaluation_à_l'appel">Évaluation à l'appel</h3>
+### Évaluation à l'appel
 
-<p>L'argument par défaut est évalué à l'instant de l'appel. Ainsi, à la différence d'autres langages comme Python, un nouvel objet est créé à chaque appel de la fonction.</p>
+L'argument par défaut est évalué à l'instant de l'appel. Ainsi, à la différence d'autres langages comme Python, un nouvel objet est créé à chaque appel de la fonction.
 
-<pre class="brush: js">function append(valeur, tableau = []) {
+```js
+function append(valeur, tableau = []) {
   tableau.push(valeur);
   return tableau;
 }
 
 append(1); //[1]
 append(2); //[2], et non [1, 2]
+```
 
-</pre>
+Cela est également valable pour les fonctions et les variables
 
-<p>Cela est également valable pour les fonctions et les variables</p>
-
-<pre class="brush: js">function appelQqc(truc = qqc()) { return truc }
+```js
+function appelQqc(truc = qqc()) { return truc }
 
 appelQqc(); //lève une ReferenceError
 
-let qqc = () =&gt; "machin"
+let qqc = () => "machin"
 
 appelQqc(); // "machin"
-</pre>
+```
 
-<h3 id="Les_paramètres_par_défaut_sont_disponibles_à_la_suite">Les paramètres par défaut sont disponibles à la suite</h3>
+### Les paramètres par défaut sont disponibles à la suite
 
-<p>Les paramètres déjà rencontrés dans la définition peuvent être utilisés comme paramètres par défaut dans la suite de la définition :</p>
+Les paramètres déjà rencontrés dans la définition peuvent être utilisés comme paramètres par défaut dans la suite de la définition :
 
-<pre class="brush: js">function salutation(nom, salut, message = salut + ' ' + nom){
+```js
+function salutation(nom, salut, message = salut + ' ' + nom){
     return [nom, salut, message];
 }
 
@@ -105,11 +108,13 @@ salutation('David', 'Coucou');
 // ["David", "Coucou", "Coucou David"]
 
 salutation('David', 'Coucou', 'Bon anniversaire !');
-// ["David", "Coucou", "Bon anniversaire !"]</pre>
+// ["David", "Coucou", "Bon anniversaire !"]
+```
 
-<p>On peut utiliser cette fonctionnalité afin de gérer beaucoup de cas aux limites :</p>
+On peut utiliser cette fonctionnalité afin de gérer beaucoup de cas aux limites :
 
-<pre class="brush: js">function go() {
+```js
+function go() {
   return ":P"
 }
 
@@ -144,68 +149,55 @@ avecDéfaut.call({value:"=^_^="});
 
 sansDéfaut.call({value:"=^_^="});
 // [undefined, 5, 5, ":P", {value:"=^_^="}, arguments, "=^_^="]
-</pre>
+```
 
-<h3 id="Les_fonctions_définies_dans_le_corps_d'une_fonction">Les fonctions définies dans le corps d'une fonction</h3>
+### Les fonctions définies dans le corps d'une fonction
 
-<p>À partir de Gecko 33 {{geckoRelease(33)}}. Les fonctions déclarées dans le corps de la fonction ne peuvent pas servir comme valeurs par défaut, cela lèvera une exception {{jsxref("ReferenceError")}} (plus précisément une {{jsxref("TypeError")}} avec SpiderMonkey, voir le {{bug(1022967)}}). Les paramètres par défaut sont exécutés en premier, les déclarations de fonctions présentes dans le corps de la fonction sont évaluées ensuite.</p>
+À partir de Gecko 33 {{geckoRelease(33)}}. Les fonctions déclarées dans le corps de la fonction ne peuvent pas servir comme valeurs par défaut, cela lèvera une exception {{jsxref("ReferenceError")}} (plus précisément une {{jsxref("TypeError")}} avec SpiderMonkey, voir le {{bug(1022967)}}). Les paramètres par défaut sont exécutés en premier, les déclarations de fonctions présentes dans le corps de la fonction sont évaluées ensuite.
 
-<pre class="brush: js">// Ne fonctionnera pas, entraîne une ReferenceError.
+```js
+// Ne fonctionnera pas, entraîne une ReferenceError.
 function f(a = go()) {
   function go(){return ":P"}
 }
-</pre>
+```
 
-<h3 id="Utilisation_de_paramètres_sans_valeur_par_défaut_après_les_paramètres_par_défaut">Utilisation de paramètres sans valeur par défaut après les paramètres par défaut</h3>
+### Utilisation de paramètres sans valeur par défaut après les paramètres par défaut
 
-<p>Avant Gecko 26 ({{geckoRelease(26)}}, le code suivant aurait entraîné une exception {{jsxref("SyntaxError")}}. Cela a été corrigé avec le bug {{bug(777060)}}. Les paramètres sont toujours ordonnés de gauche à droite et les valeurs par défaut sont surchargées s'ils viennent avant les autres paramètres :</p>
+Avant Gecko 26 ({{geckoRelease(26)}}, le code suivant aurait entraîné une exception {{jsxref("SyntaxError")}}. Cela a été corrigé avec le bug {{bug(777060)}}. Les paramètres sont toujours ordonnés de gauche à droite et les valeurs par défaut sont surchargées s'ils viennent avant les autres paramètres :
 
-<pre class="brush: js">function f(x=1, y) {
+```js
+function f(x=1, y) {
   return [x, y];
 }
 
 f();  // [1, undefined]
 f(2); // [2, undefined]
-</pre>
+```
 
-<h3 id="Paramètre_par_défaut_et_décomposition_des_paramètres">Paramètre par défaut et décomposition des paramètres</h3>
+### Paramètre par défaut et décomposition des paramètres
 
-<p>Il est possible d'utiliser les valeurs par défaut avec <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Affecter_par_décomposition">la syntaxe de décomposition</a> :</p>
+Il est possible d'utiliser les valeurs par défaut avec [la syntaxe de décomposition](/fr/docs/Web/JavaScript/Reference/Opérateurs/Affecter_par_décomposition) :
 
-<pre class="brush: js">function f([x, y] = [1, 2], {z: z} = {z: 3}) {
+```js
+function f([x, y] = [1, 2], {z: z} = {z: 3}) {
   return x + y + z;
 }
 
-f(); // 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('ES2015', '#sec-function-definitions', 'Function Definitions')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-function-definitions', 'Function Definitions')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.functions.default_parameters")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li><a href="https://wiki.ecmascript.org/doku.php?id=harmony:parameter_default_values">La proposition originale sur ecmascript.org</a></li>
-</ul>
+f(); // 6
+```
+
+## Spécifications
+
+| Spécification                                                                                        | État                         | Commentaires         |
+| ---------------------------------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ES2015', '#sec-function-definitions', 'Function Definitions')}} | {{Spec2('ES2015')}}     | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-function-definitions', 'Function Definitions')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.functions.default_parameters")}}
+
+## Voir aussi
+
+- [La proposition originale sur ecmascript.org](https://wiki.ecmascript.org/doku.php?id=harmony:parameter_default_values)
diff --git a/files/fr/web/javascript/reference/functions/get/index.md b/files/fr/web/javascript/reference/functions/get/index.md
index b999d2d36a..76fa285ff7 100644
--- a/files/fr/web/javascript/reference/functions/get/index.md
+++ b/files/fr/web/javascript/reference/functions/get/index.md
@@ -10,49 +10,46 @@ tags:
 translation_of: Web/JavaScript/Reference/Functions/get
 original_slug: Web/JavaScript/Reference/Fonctions/get
 ---
-<div>{{jsSidebar("Functions")}}</div>
+{{jsSidebar("Functions")}}
 
-<p>La syntaxe <strong><code>get</code></strong> permet de lier une propriété d'un objet à une fonction qui sera appelée lorsqu'on accédera à la propriété.</p>
+La syntaxe **`get`** permet de lier une propriété d'un objet à une fonction qui sera appelée lorsqu'on accédera à la propriété.
 
-<div>{{EmbedInteractiveExample("pages/js/functions-getter.html")}}</div>
+{{EmbedInteractiveExample("pages/js/functions-getter.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">{get <em>prop</em>() { ... } }
-{get [<em>expression</em>]() { ... } }</pre>
+    {get prop() { ... } }
+    {get [expression]() { ... } }
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>prop</code></dt>
- <dd>Le nom de la propriété à lier à la fonction.</dd>
- <dt><code>expression</code></dt>
- <dd>Avec ECMAScript 2015, il est également possible d'utiliser des expressions renvoyant un nom de propriété calculé pour le lier à une fonction.</dd>
-</dl>
+- `prop`
+  - : Le nom de la propriété à lier à la fonction.
+- `expression`
+  - : Avec ECMAScript 2015, il est également possible d'utiliser des expressions renvoyant un nom de propriété calculé pour le lier à une fonction.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Il est parfois utile de créer une propriété qui renvoie une valeur dynamique calculée, ou de ne pas avoir recours à l'appel explicite d'une méthode pour renvoyer le statut d'une variable interne. En JavaScript, il est possible de faire cela en utilisant un <em>accesseur</em>. Il n'est pas possible d'avoir simultanément un <em>accesseur</em> assimilé à une propriété et d'avoir cette propriété initialisée à une valeur, mais il est possible d'utiliser un <em>accesseur</em> et un {{jsxref("Fonctions/set","mutateur","",1)}} pour créer une sorte de pseudo-propriété.</p>
+Il est parfois utile de créer une propriété qui renvoie une valeur dynamique calculée, ou de ne pas avoir recours à l'appel explicite d'une méthode pour renvoyer le statut d'une variable interne. En JavaScript, il est possible de faire cela en utilisant un _accesseur_. Il n'est pas possible d'avoir simultanément un _accesseur_ assimilé à une propriété et d'avoir cette propriété initialisée à une valeur, mais il est possible d'utiliser un _accesseur_ et un {{jsxref("Fonctions/set","mutateur","",1)}} pour créer une sorte de pseudo-propriété.
 
-<p>On notera que l'opérateur <code>get</code> :</p>
+On notera que l'opérateur `get` :
 
-<ul>
- <li>peut être identifié par un nombre ou une chaîne de caractères</li>
- <li>ne doit pas posséder de paramètre (lire la page <a class="external" href="https://whereswalden.com/2010/08/22/incompatible-es5-change-literal-getter-and-setter-functions-must-now-have-exactly-zero-or-one-arguments/" rel="external nofollow">Changement <abbr title="ECMAScript 5th edition">ES5</abbr> : les fonctions <em>d'accession</em> et <em>de mutation</em> littérales doivent avoir maintenant zéro ou un paramètre.</a> <em>(en anglais)</em> pour plus d'informations)</li>
- <li>ne doit pas apparaître dans un littéral objet avec un autre <code>get</code> ou une autre propriété avec le même identifiant (les codes suivants : <code>{ get x() { }, get x() { } }</code> et <code>{ x: ..., get x() { } }</code> sont interdits).</li>
-</ul>
+- peut être identifié par un nombre ou une chaîne de caractères
+- ne doit pas posséder de paramètre (lire la page [Changement ES5 : les fonctions _d'accession_ et _de mutation_ littérales doivent avoir maintenant zéro ou un paramètre.](https://whereswalden.com/2010/08/22/incompatible-es5-change-literal-getter-and-setter-functions-must-now-have-exactly-zero-or-one-arguments/) _(en anglais)_ pour plus d'informations)
+- ne doit pas apparaître dans un littéral objet avec un autre `get` ou une autre propriété avec le même identifiant (les codes suivants : `{ get x() { }, get x() { } }` et `{ x: ..., get x() { } }` sont interdits).
 
-<p>Un <em>accesseur</em> peut être supprimé grâce à l'opérateur {{jsxref("Opérateurs/L_opérateur_delete","delete")}}.</p>
+Un _accesseur_ peut être supprimé grâce à l'opérateur {{jsxref("Opérateurs/L_opérateur_delete","delete")}}.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Définir_un_accesseur_avec_l'opérateur_get">Définir un accesseur avec l'opérateur <code>get</code></h3>
+### Définir un accesseur avec l'opérateur `get`
 
-<p>Ce code va créer une pseudo-propriété <code>dernier</code> de l'objet <code>o</code> qui va retourner la dernière entrée du tableau <code>o.journal </code>:</p>
+Ce code va créer une pseudo-propriété `dernier` de l'objet `o` qui va retourner la dernière entrée du tableau `o.journal `:
 
-<pre class="brush: js">var o = {
+```js
+var o = {
   get dernier() {
-    if (this.journal.length &gt; 0) {
+    if (this.journal.length > 0) {
       return this.journal[this.journal.length - 1];
     }
     else {
@@ -62,65 +59,71 @@ original_slug: Web/JavaScript/Reference/Fonctions/get
   journal: ["toto","actu"]
 }
 console.log(o.dernier); // "actu"
-</pre>
+```
 
-<p>Notez qu'essayer d'assigner à <code>dernier</code> une valeur ne le modifiera pas.</p>
+Notez qu'essayer d'assigner à `dernier` une valeur ne le modifiera pas.
 
-<h3 id="Supprimer_un_accesseur_avec_l'opérateur_delete">Supprimer un accesseur avec l'opérateur <code>delete</code></h3>
+### Supprimer un accesseur avec l'opérateur `delete`
 
-<pre class="brush: js">delete o.dernier;
-</pre>
+```js
+delete o.dernier;
+```
 
-<h3 id="Définir_un_accesseur_sur_des_objets_existants_grâce_à_defineProperty">Définir un accesseur sur des objets existants grâce à <code>defineProperty</code></h3>
+### Définir un accesseur sur des objets existants grâce à `defineProperty`
 
-<p>Afin d'ajouter un accesseur à un objet qui existe déjà, on peut utiliser la méthode {{jsxref("Object.defineProperty()")}}.</p>
+Afin d'ajouter un accesseur à un objet qui existe déjà, on peut utiliser la méthode {{jsxref("Object.defineProperty()")}}.
 
-<pre class="brush: js">var o = { a:0 }
+```js
+var o = { a:0 }
 
 Object.defineProperty(o, "b", { get: function () { return this.a + 1; } });
 
-console.log(o.b) // Utilise l'accesseur qui génère a + 1 (qui correspond à 1)</pre>
+console.log(o.b) // Utilise l'accesseur qui génère a + 1 (qui correspond à 1)
+```
 
-<h3 id="Utiliser_un_nom_de_propriété_calculé">Utiliser un nom de propriété calculé</h3>
+### Utiliser un nom de propriété calculé
 
-<pre class="brush: js">var expr = "toto";
+```js
+var expr = "toto";
 
 var obj = {
   get [expr]() { return "truc"; }
 };
 
-console.log(obj.toto); // "truc"</pre>
+console.log(obj.toto); // "truc"
+```
 
-<h3 id="Accesseurs_mémoïsés">Accesseurs mémoïsés</h3>
+### Accesseurs mémoïsés
 
-<p>Les accesseurs permettent de définir des propriétés sur un objet mais ils ne calculent pas la valeur de la propriété tant qu'il n'y a pas d'accès envers celle-ci. Un accesseur délègue le coût de calcul jusqu'au moment où la valeur est vraiment nécessaire (si cette dernière n'est jamais utilisée, cela ne coûte alors rien).</p>
+Les accesseurs permettent de définir des propriétés sur un objet mais ils ne calculent pas la valeur de la propriété tant qu'il n'y a pas d'accès envers celle-ci. Un accesseur délègue le coût de calcul jusqu'au moment où la valeur est vraiment nécessaire (si cette dernière n'est jamais utilisée, cela ne coûte alors rien).
 
-<p>Une technique supplémentaire pour optimiser ou retarder le calcul d'une valeur d'une propriété et de la mettre en cache pour les accès ultérieurs consiste à utiliser <strong>des accesseurs intelligents « <a href="https://fr.wikipedia.org/wiki/M%C3%A9mo%C3%AFsation">mémoïsés</a> »</strong>. La valeur est calculée lors du premier appel de l'accesseur puis est mise en cache afin que les appels ultérieurs renvoient la valeur en cache sans la recalculer. Cette méthode peut s'avérer utile dans plusieurs situations :</p>
+Une technique supplémentaire pour optimiser ou retarder le calcul d'une valeur d'une propriété et de la mettre en cache pour les accès ultérieurs consiste à utiliser **des accesseurs intelligents « [mémoïsés](https://fr.wikipedia.org/wiki/M%C3%A9mo%C3%AFsation) »**. La valeur est calculée lors du premier appel de l'accesseur puis est mise en cache afin que les appels ultérieurs renvoient la valeur en cache sans la recalculer. Cette méthode peut s'avérer utile dans plusieurs situations :
 
-<ul>
- <li>Si le calcul de la valeur est coûteux (il consomme beaucoup de RAM ou de temps CPU, il crée de nouveaux <em>threads</em>, il utilise des fichiers distants, etc.).</li>
- <li>Si la valeur est utilisée plus tard ou, dans certains cas, n'est pas utilisée du tout.</li>
- <li>Si elle est utilisée plusieurs fois, il n'est pas nécessaire de la recalculer car sa valeur ne changera pas.</li>
-</ul>
+- Si le calcul de la valeur est coûteux (il consomme beaucoup de RAM ou de temps CPU, il crée de nouveaux _threads_, il utilise des fichiers distants, etc.).
+- Si la valeur est utilisée plus tard ou, dans certains cas, n'est pas utilisée du tout.
+- Si elle est utilisée plusieurs fois, il n'est pas nécessaire de la recalculer car sa valeur ne changera pas.
 
-<p>Cela signifie qu'un tel accesseur ne doit pas être utilisé si la valeur peut être modifiée au cours du temps. En effet, avec la définition qu'on vient de lui donner, un tel accesseur ne recalculera pas la valeur.</p>
+Cela signifie qu'un tel accesseur ne doit pas être utilisé si la valeur peut être modifiée au cours du temps. En effet, avec la définition qu'on vient de lui donner, un tel accesseur ne recalculera pas la valeur.
 
-<p>Dans l'exemple suivant, l'objet possède un accesseur en propriété propre. Lors de l'accès à la propriété, la propriété est retirée de l'objet puis réajoutée mais sous forme d'une propriété de donnée (et non d'un accesseur). Enfin, la valeur est renvoyée :</p>
+Dans l'exemple suivant, l'objet possède un accesseur en propriété propre. Lors de l'accès à la propriété, la propriété est retirée de l'objet puis réajoutée mais sous forme d'une propriété de donnée (et non d'un accesseur). Enfin, la valeur est renvoyée :
 
-<pre class="brush: js">get notifier() {
+```js
+get notifier() {
   delete this.notifier;
   return this.notifier = document.getElementById("bookmarked-notification-anchor");
-},</pre>
+},
+```
 
-<p>Cet exemple est utilisé dans le code de Firefox, notamment dans le code du module XPCOMUtils.jsm qui définit la fonction <code><a href="/fr/docs/Mozilla/JavaScript_code_modules/XPCOMUtils.jsm#defineLazyGetter()">defineLazyGetter()</a></code>.</p>
+Cet exemple est utilisé dans le code de Firefox, notamment dans le code du module XPCOMUtils.jsm qui définit la fonction [`defineLazyGetter()`](</fr/docs/Mozilla/JavaScript_code_modules/XPCOMUtils.jsm#defineLazyGetter()>).
 
-<h3 id="get_ou_defineProperty"><code>get</code> ou <code>defineProperty</code> ?</h3>
+### `get` ou `defineProperty` ?
 
-<p>Bien que le mot-clé <code>get</code> et la méthode {{jsxref("Object.defineProperty()")}} aient des résultats similaires, il subsiste une différence lorsqu'on utilise <a href="/fr/docs/Web/JavaScript/Reference/Instructions/class">les classes</a>.</p>
+Bien que le mot-clé `get` et la méthode {{jsxref("Object.defineProperty()")}} aient des résultats similaires, il subsiste une différence lorsqu'on utilise [les classes](/fr/docs/Web/JavaScript/Reference/Instructions/class).
 
-<p>Lorsqu'on utilise <code>get</code>, la propriété sera définie sur le prototype de l'objet. Avec {{jsxref("Object.defineProperty()")}}, la propriété sera définie sur l'instance à laquelle la méthode s'applique.</p>
+Lorsqu'on utilise `get`, la propriété sera définie sur le prototype de l'objet. Avec {{jsxref("Object.defineProperty()")}}, la propriété sera définie sur l'instance à laquelle la méthode s'applique.
 
-<pre class="brush: js">class Exemple {
+```js
+class Exemple {
   get coucou() {
     return 'monde';
   }
@@ -132,46 +135,26 @@ console.log(obj.coucou);
 console.log(Object.getOwnPropertyDescriptor(obj, 'coucou'));
 // undefined
 console.log(Object.getOwnPropertyDescriptor(Object.getPrototypeOf(obj), 'coucou'));
-// { configurable: true, enumerable: false, get: function get coucou() { return 'monde'; }, set: undefined }</pre>
-
-<h2 id="Spécifications">Spécifications</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">État</th>
-   <th scope="col">Commentaires</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-11.1.5', 'Object Initializer')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td>Définition initiale</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES2015', '#sec-method-definitions', 'Method definitions')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Ajout des noms de propriétés calculés.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-method-definitions', 'Method definitions')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.functions.get")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li><code><a href="/fr/docs/Web/JavaScript/Reference/Fonctions/set">set</a></code></li>
- <li>{{jsxref("Opérateurs/L_opérateur_delete", "delete")}}</li>
- <li>{{jsxref("Object.defineProperty()")}}</li>
- <li>{{jsxref("Object.defineGetter", "__defineGetter__")}}</li>
- <li>{{jsxref("Object.defineSetter", "__defineSetter__")}}</li>
- <li><a href="/fr/docs/Web/JavaScript/Guide/Utiliser_les_objets#D.C3.A9finir_des_getters_et_setters">Définir des accesseurs et mutateurs</a>, un chapitre du Guide JavaScript</li>
-</ul>
+// { configurable: true, enumerable: false, get: function get coucou() { return 'monde'; }, set: undefined }
+```
+
+## Spécifications
+
+| Spécification                                                                                    | État                         | Commentaires                           |
+| ------------------------------------------------------------------------------------------------ | ---------------------------- | -------------------------------------- |
+| {{SpecName('ES5.1', '#sec-11.1.5', 'Object Initializer')}}                     | {{Spec2('ES5.1')}}     | Définition initiale                    |
+| {{SpecName('ES2015', '#sec-method-definitions', 'Method definitions')}} | {{Spec2('ES2015')}}     | Ajout des noms de propriétés calculés. |
+| {{SpecName('ESDraft', '#sec-method-definitions', 'Method definitions')}} | {{Spec2('ESDraft')}} |                                        |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.functions.get")}}
+
+## Voir aussi
+
+- [`set`](/fr/docs/Web/JavaScript/Reference/Fonctions/set)
+- {{jsxref("Opérateurs/L_opérateur_delete", "delete")}}
+- {{jsxref("Object.defineProperty()")}}
+- {{jsxref("Object.defineGetter", "__defineGetter__")}}
+- {{jsxref("Object.defineSetter", "__defineSetter__")}}
+- [Définir des accesseurs et mutateurs](/fr/docs/Web/JavaScript/Guide/Utiliser_les_objets#D.C3.A9finir_des_getters_et_setters), un chapitre du Guide JavaScript
diff --git a/files/fr/web/javascript/reference/functions/index.md b/files/fr/web/javascript/reference/functions/index.md
index cfdd7e95b1..90e9f5aa72 100644
--- a/files/fr/web/javascript/reference/functions/index.md
+++ b/files/fr/web/javascript/reference/functions/index.md
@@ -8,23 +8,24 @@ tags:
 translation_of: Web/JavaScript/Reference/Functions
 original_slug: Web/JavaScript/Reference/Fonctions
 ---
-<div>{{jsSidebar("Functions")}}</div>
+{{jsSidebar("Functions")}}
 
-<p>De manière générale, une fonction est un « sous-programme » qui peut être appelé par du code extérieur à la fonction (ou du code interne dans le cas d'une récursion). Comme le programme, une fonction est composée d'une suite d'instructions qui forment le <em>corps de la fonction</em>. Il est parfois possible de <em>passer</em> des valeurs à une fonction et une fonction peut éventuellement <em>retourner </em>(ou <em>renvoyer</em>) une valeur.</p>
+De manière générale, une fonction est un « sous-programme » qui peut être appelé par du code extérieur à la fonction (ou du code interne dans le cas d'une récursion). Comme le programme, une fonction est composée d'une suite d'instructions qui forment le _corps de la fonction_. Il est parfois possible de _passer_ des valeurs à une fonction et une fonction peut éventuellement _retourner_ (ou _renvoyer_) une valeur.
 
-<p>En JavaScript, les fonctions sont des objets de première classe. Cela signifie qu'elles peuvent être manipulées et échangées, qu'elles peuvent avoir des propriétés et des méthodes, comme tous les autres objets JavaScript. Les fonctions sont des objets {{jsxref("Objets_globaux/Function","Function")}}.</p>
+En JavaScript, les fonctions sont des objets de première classe. Cela signifie qu'elles peuvent être manipulées et échangées, qu'elles peuvent avoir des propriétés et des méthodes, comme tous les autres objets JavaScript. Les fonctions sont des objets {{jsxref("Objets_globaux/Function","Function")}}.
 
-<p>Pour plus d'informations et d'exemples, on pourra également consulter le <a href="/fr/docs/Web/JavaScript/Guide/Fonctions">chapitre du Guide JavaScript sur les fonctions.</a></p>
+Pour plus d'informations et d'exemples, on pourra également consulter le [chapitre du Guide JavaScript sur les fonctions.](/fr/docs/Web/JavaScript/Guide/Fonctions)
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Toute fonction JavaScript est en fait un objet <code>Function</code>. Voir la page {{jsxref("Objets_globaux/Function","Function")}} pour des informations sur les propriétés et les méthodes de ces objets.</p>
+Toute fonction JavaScript est en fait un objet `Function`. Voir la page {{jsxref("Objets_globaux/Function","Function")}} pour des informations sur les propriétés et les méthodes de ces objets.
 
-<p>Afin de renvoyer une valeur, la fonction doit comporter une instruction {{jsxref("Instructions/return","return")}} qui définit la valeur à renvoyer (sauf dans le cas d'un <a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object/constructor">constructeur</a> qui a été appelé avec le mot-clé {{jsxref("Opérateurs/L_opérateur_new")}}). Une fonction qui ne renvoie pas de valeur retourne {{jsxref("undefined")}}.</p>
+Afin de renvoyer une valeur, la fonction doit comporter une instruction {{jsxref("Instructions/return","return")}} qui définit la valeur à renvoyer (sauf dans le cas d'un [constructeur](/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object/constructor) qui a été appelé avec le mot-clé {{jsxref("Opérateurs/L_opérateur_new")}}). Une fonction qui ne renvoie pas de valeur retourne {{jsxref("undefined")}}.
 
-<p>Les paramètres donnés lors de l'appel d'une fonction sont appelés les <em>arguments</em> de la fonction. Les arguments sont passés <em>par valeur</em> (<em>by value </em>en anglais). Si la fonction modifie la valeur d'un argument, ce changement ne se répercute pas en dehors de la fonction. Il existe cependant les <em>références</em> d'objets qui sont aussi des valeurs mais qui possèdent la particularité suivante : si la fonction modifie les propriété de l'objet de la référence, ce(s) changement(s) seront perceptibles en dehors de la fonction. Prenons l'exemple suivant :</p>
+Les paramètres donnés lors de l'appel d'une fonction sont appelés les _arguments_ de la fonction. Les arguments sont passés _par valeur_ (_by value_ en anglais). Si la fonction modifie la valeur d'un argument, ce changement ne se répercute pas en dehors de la fonction. Il existe cependant les _références_ d'objets qui sont aussi des valeurs mais qui possèdent la particularité suivante : si la fonction modifie les propriété de l'objet de la référence, ce(s) changement(s) seront perceptibles en dehors de la fonction. Prenons l'exemple suivant :
 
-<pre class="brush: js"> /* Déclaration de la fonction 'maFonction' */
+```js
+ /* Déclaration de la fonction 'maFonction' */
  function maFonction(monObjet)
  {
    monObjet.marque = "Toyota";
@@ -52,268 +53,249 @@ original_slug: Web/JavaScript/Reference/Fonctions
   * de l'objet. C'est ce que la fonction a changé.
   */
  console.log(mavoiture.marque);
-</pre>
+```
 
-<p>Le mot-clé <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_this"><code>this</code></a> ne fait pas référence à la fonction en cours d'exécution. Il faut donc faire référence aux objets <code>Function</code> par leurs noms, et ce même au sein du corps de la fonction.</p>
+Le mot-clé [`this`](/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_this) ne fait pas référence à la fonction en cours d'exécution. Il faut donc faire référence aux objets `Function` par leurs noms, et ce même au sein du corps de la fonction.
 
-<h2 id="Définir_des_fonctions">Définir des fonctions</h2>
+## Définir des fonctions
 
-<p>Il y a plusieurs façons de définir des fonctions</p>
+Il y a plusieurs façons de définir des fonctions
 
-<h3 id="Déclarer_une_fonction_linstruction_function">Déclarer une fonction (l'instruction <code>function</code>)</h3>
+### Déclarer une fonction (l'instruction `function`)
 
-<p>Il existe une syntaxe spécifique pour la déclaration des fonctions (vous pouvez consulter la page de l'instruction {{jsxref("Instructions/function","function")}} pour plus de détails) :</p>
+Il existe une syntaxe spécifique pour la déclaration des fonctions (vous pouvez consulter la page de l'instruction {{jsxref("Instructions/function","function")}} pour plus de détails) :
 
-<pre class="syntaxbox">function <em>nom</em>([<em>param</em>[, <em>param</em>[, ... <em>param</em>]]]) {
-   <em>instructions</em>
-}
-</pre>
+    function nom([param[, param[, ... param]]]) {
+       instructions
+    }
 
-<dl>
- <dt><code>nom</code></dt>
- <dd>Le nom de la fonction.</dd>
- <dt><code>param</code></dt>
- <dd>Le nom d'un argument à passer à la fonction (une fonction pouvant avoir jusqu'à 255 arguments).</dd>
- <dt><code>instructions</code></dt>
- <dd>Les instructions qui forment le corps de la fonction.</dd>
-</dl>
+- `nom`
+  - : Le nom de la fonction.
+- `param`
+  - : Le nom d'un argument à passer à la fonction (une fonction pouvant avoir jusqu'à 255 arguments).
+- `instructions`
+  - : Les instructions qui forment le corps de la fonction.
 
-<h3 id="Utiliser_une_expression_de_fonction_lexpression_function">Utiliser une expression de fonction (l'expression <code>function</code>)</h3>
+### Utiliser une expression de fonction (l'expression `function`)
 
-<p>L'expression d'une fonction se fait d'une façon similaire à la déclaration (veuillez consulter la page de l'expression {{jsxref("Opérateurs/L_opérateur_function","function")}} pour plus d'informations) :</p>
+L'expression d'une fonction se fait d'une façon similaire à la déclaration (veuillez consulter la page de l'expression {{jsxref("Opérateurs/L_opérateur_function","function")}} pour plus d'informations) :
 
-<pre class="syntaxbox">function [<em>nom</em>]([<em>param</em>] [, <em>param</em>] [..., <em>param</em>]) {
-   <em>instructions</em>
-}
-</pre>
+    function [nom]([param] [, param] [..., param]) {
+       instructions
+    }
 
-<dl>
- <dt><code>nom</code></dt>
- <dd>Le nom de la fonction. Il est facultatif, auquel cas la fonction devient une fonction anonyme.</dd>
- <dt><code>param</code></dt>
- <dd>Le nom d'un argument à passer à la fonction.</dd>
- <dt><code>instructions</code></dt>
- <dd>Les instructions qui forment le corps de la fonction.</dd>
-</dl>
+- `nom`
+  - : Le nom de la fonction. Il est facultatif, auquel cas la fonction devient une fonction anonyme.
+- `param`
+  - : Le nom d'un argument à passer à la fonction.
+- `instructions`
+  - : Les instructions qui forment le corps de la fonction.
 
-<p>Voici un exemple d'expression de fonction <strong>anonyme</strong> (il n'y a pas de nom utilisé) :</p>
+Voici un exemple d'expression de fonction **anonyme** (il n'y a pas de nom utilisé) :
 
-<pre class="brush: js">var maFonction = function() {
+```js
+var maFonction = function() {
   /* instructions */
-}</pre>
+}
+```
 
-<p>Il est également possible de fournir un nom lors de la définition afin de créer une expression de fonction <strong>nommée</strong> :</p>
+Il est également possible de fournir un nom lors de la définition afin de créer une expression de fonction **nommée** :
 
-<pre class="brush: js">var maFonction = function fonctionNommée(){
+```js
+var maFonction = function fonctionNommée(){
   /* instructions */
 }
-</pre>
+```
 
-<p>L'un des bénéfices d'utiliser une expression de fonction nommée est que son nom sera utilisé dans la pile d'appel lors qu'on aura une erreur. Avec le nom de la fonction, il sera plus facile de repérer l'origine de l'erreur.</p>
+L'un des bénéfices d'utiliser une expression de fonction nommée est que son nom sera utilisé dans la pile d'appel lors qu'on aura une erreur. Avec le nom de la fonction, il sera plus facile de repérer l'origine de l'erreur.
 
-<p>Comme on peut le voir, ces deux derniers exemples ne commencent pas avec le mot-clé <code>function</code>. Les instructions qui déclarent des fonctions mais qui ne commencent pas avec <code>function</code> sont des expressions de fonction.</p>
+Comme on peut le voir, ces deux derniers exemples ne commencent pas avec le mot-clé `function`. Les instructions qui déclarent des fonctions mais qui ne commencent pas avec `function` sont des expressions de fonction.
 
-<p>Lorsque les fonctions sont utilisées une unique fois, on peut utiliser une <a href="/fr/docs/Glossaire/IIFE">« expression de fonction immédiatement invoquée » (ou plus généralement appelée <em>IIFE</em> pour <em>Immediately Invokable Function Expression</em> en anglais)</a>.</p>
+Lorsque les fonctions sont utilisées une unique fois, on peut utiliser une [« expression de fonction immédiatement invoquée » (ou plus généralement appelée _IIFE_ pour _Immediately Invokable Function Expression_ en anglais)](/fr/docs/Glossaire/IIFE).
 
-<pre class="brush: js">(function() {
+```js
+(function() {
     /* instruction */
-})();</pre>
+})();
+```
 
-<p>Les <em>IIFE</em> sont des expressions de fonction appelées dès que la fonction est déclarée.</p>
+Les _IIFE_ sont des expressions de fonction appelées dès que la fonction est déclarée.
 
-<h3 id="Utiliser_une_déclaration_de_fonction_génératrice_linstruction_function*">Utiliser une déclaration de fonction génératrice (l'instruction <code>function*</code>)</h3>
+### Utiliser une déclaration de fonction génératrice (l'instruction `function*`)
 
-<p>Il existe une syntaxe spéciale pour déclarer des générateurs (voir la page sur l'instruction {{jsxref('Instructions/function*', 'function*')}} pour plus de détails) :</p>
+Il existe une syntaxe spéciale pour déclarer des générateurs (voir la page sur l'instruction {{jsxref('Instructions/function*', 'function*')}} pour plus de détails) :
 
-<pre class="syntaxbox">function* <em>nom</em>([<em>param</em>[, <em>param</em>[, ... <em>param</em>]]]) {
-   <em>instructions</em>
-}</pre>
+    function* nom([param[, param[, ... param]]]) {
+       instructions
+    }
 
-<dl>
- <dt><code>nom</code></dt>
- <dd>Le nom de la fonction.</dd>
- <dt><code>param</code></dt>
- <dd>Le nom d'un argument à passer à la fonction.</dd>
- <dt><code>instructions</code></dt>
- <dd>Les instructions qui forment le corps de la fonction.</dd>
-</dl>
+- `nom`
+  - : Le nom de la fonction.
+- `param`
+  - : Le nom d'un argument à passer à la fonction.
+- `instructions`
+  - : Les instructions qui forment le corps de la fonction.
 
-<h3 id="Utiliser_une_expression_de_générateur_lexpression_function*">Utiliser une expression de générateur (l'expression <code>function*</code>)</h3>
+### Utiliser une expression de générateur (l'expression `function*`)
 
-<p>Une expression de générateur est similaire à une déclaration de fonction génératrice et possède presque la même syntaxe (pour plus de détails, consulter la page sur l'expression {{jsxref('Opérateurs/function*', 'function*')}}) :</p>
+Une expression de générateur est similaire à une déclaration de fonction génératrice et possède presque la même syntaxe (pour plus de détails, consulter la page sur l'expression {{jsxref('Opérateurs/function*', 'function*')}}) :
 
-<pre class="syntaxbox">function* [<em>nom</em>]([<em>param</em>[, <em>param</em>[, ... <em>param</em>]]]) {
-   <em>instructions</em>
-}</pre>
+    function* [nom]([param[, param[, ... param]]]) {
+       instructions
+    }
 
-<dl>
- <dt><code>nom</code></dt>
- <dd>Le nom de la fonction. Ce paramètre peut être omis, auquel cas la fonction sera une fonction anonyme.</dd>
- <dt><code>param</code></dt>
- <dd>Le nom d'un argument à passer à la fonction.</dd>
- <dt><code>instructions</code></dt>
- <dd>Les instructions qui composent le corps de la fonction.</dd>
-</dl>
+- `nom`
+  - : Le nom de la fonction. Ce paramètre peut être omis, auquel cas la fonction sera une fonction anonyme.
+- `param`
+  - : Le nom d'un argument à passer à la fonction.
+- `instructions`
+  - : Les instructions qui composent le corps de la fonction.
 
-<h3 id="Utiliser_une_expression_de_fonction_fléchée_>">Utiliser une expression de fonction fléchée (=&gt;)</h3>
+### Utiliser une expression de fonction fléchée (=>)
 
-<p>Une expression de fonction fléchée possède une syntaxe plus courte et est liée, de façon lexicale, à sa valeur (voir la page sur les <a href="/fr/docs/Web/JavaScript/Reference/Fonctions/Fonctions_fl%C3%A9ch%C3%A9es">fonctions fléchées</a> pour plus de détails) :</p>
+Une expression de fonction fléchée possède une syntaxe plus courte et est liée, de façon lexicale, à sa valeur (voir la page sur les [fonctions fléchées](/fr/docs/Web/JavaScript/Reference/Fonctions/Fonctions_fl%C3%A9ch%C3%A9es) pour plus de détails) :
 
-<pre class="syntaxbox">([param[, param]]) =&gt; {
-   instructions
-}
+    ([param[, param]]) => {
+       instructions
+    }
 
-param =&gt; expression
-</pre>
+    param => expression
 
-<dl>
- <dt><code>param</code></dt>
- <dd>Le nom d'un argument. S'il n'y a pas d'arguments, cela doit être indiqué par <code>()</code>.  S'il y a un seul argument, les parenthèses ne sont pas obligatoires (par exemple :  <code>toto =&gt; 1</code>).</dd>
- <dt><code>instructions </code>ou<code> expression</code></dt>
- <dd>S'il y a plusieurs instructions, elles doivent être encadrées par des accolades. Une expression unique ne doit pas obligatoirement être entourée d'accolades. L'expression est également la valeur de retour implicite de la fonction.</dd>
-</dl>
+- `param`
+  - : Le nom d'un argument. S'il n'y a pas d'arguments, cela doit être indiqué par `()`.  S'il y a un seul argument, les parenthèses ne sont pas obligatoires (par exemple :  `toto => 1`).
+- `instructions `ou` expression`
+  - : S'il y a plusieurs instructions, elles doivent être encadrées par des accolades. Une expression unique ne doit pas obligatoirement être entourée d'accolades. L'expression est également la valeur de retour implicite de la fonction.
 
-<h3 id="Le_constructeur_Function">Le constructeur <code>Function</code></h3>
+### Le constructeur `Function`
 
-<div class="note">
-<p><strong>Note :</strong> L'utilisation du constructeur <code>Function</code> afin de créer des fonction n'est pas recommandée. En effet, il utilise une chaîne pour former le corps de la fonction et cela peut empêcher certaines optimisations du moteur JavaScript ainsi que provoquer d'autres problèmes.</p>
-</div>
+> **Note :** L'utilisation du constructeur `Function` afin de créer des fonction n'est pas recommandée. En effet, il utilise une chaîne pour former le corps de la fonction et cela peut empêcher certaines optimisations du moteur JavaScript ainsi que provoquer d'autres problèmes.
 
-<p>Comme tous les autres objets, les objets {{jsxref("Function")}} peuvent être créés grâce à l'opérateur <code>new</code> :</p>
+Comme tous les autres objets, les objets {{jsxref("Function")}} peuvent être créés grâce à l'opérateur `new` :
 
-<pre class="syntaxbox">new Function (<em>arg1</em>, <em>arg2</em>, ... <em>argN</em>, <em>corpsDeLaFonction</em>)
-</pre>
+    new Function (arg1, arg2, ... argN, corpsDeLaFonction)
 
-<dl>
- <dt><code>arg1, arg2, ... argN</code></dt>
- <dd>Plusieurs (zéro ou plus) noms qui seront utilisés par la fonction comme noms d'arguments formels. Chaque nom doit être une chaîne de caractères valide au sens d'un identifiant JavaScript ou alors être une liste de telles chaînes séparées par des virgules. On aura les exemples suivants : "<code>x</code>", "<code>laValeur</code>", ou "<code>a,b</code>".</dd>
- <dt><code>corpsDeLaFonction</code></dt>
- <dd>Une chaîne de caractères contenant les instructions JavaScript définissant la fonction.</dd>
-</dl>
+- `arg1, arg2, ... argN`
+  - : Plusieurs (zéro ou plus) noms qui seront utilisés par la fonction comme noms d'arguments formels. Chaque nom doit être une chaîne de caractères valide au sens d'un identifiant JavaScript ou alors être une liste de telles chaînes séparées par des virgules. On aura les exemples suivants : "`x`", "`laValeur`", ou "`a,b`".
+- `corpsDeLaFonction`
+  - : Une chaîne de caractères contenant les instructions JavaScript définissant la fonction.
 
-<p>L'invocation du constructeur <code>Function</code> en tant que fonction (sans utiliser l'opérateur <code>new</code>) a le même effet que son invocation en tant que constructeur.</p>
+L'invocation du constructeur `Function` en tant que fonction (sans utiliser l'opérateur `new`) a le même effet que son invocation en tant que constructeur.
 
-<h3 id="Le_constructeur_GeneratorFunction">Le constructeur <code>GeneratorFunction</code></h3>
+### Le constructeur `GeneratorFunction`
 
-<div class="note">
-<p><strong>Note :</strong> <code>GeneratorFunction</code> n'est pas un objet global mais pourrait être obtenu à partir de l'instance de la fonction génératrice (voir la page {{jsxref("GeneratorFunction")}} pour plus de détails).</p>
-</div>
+> **Note :** `GeneratorFunction` n'est pas un objet global mais pourrait être obtenu à partir de l'instance de la fonction génératrice (voir la page {{jsxref("GeneratorFunction")}} pour plus de détails).
 
-<div class="note">
-<p><strong>Note :</strong> Le constructeur <code>GeneratorFunction</code> ne doit pas être utilisé pour créer des fonctions. En effet, il utilise une chaîne pour former le corps de la fonction et cela peut empêcher certaines optimisations du moteur JavaScript ainsi que provoquer d'autres problèmes.</p>
-</div>
+> **Note :** Le constructeur `GeneratorFunction` ne doit pas être utilisé pour créer des fonctions. En effet, il utilise une chaîne pour former le corps de la fonction et cela peut empêcher certaines optimisations du moteur JavaScript ainsi que provoquer d'autres problèmes.
 
-<p>Comme pour tous les autres objets, les objets {{jsxref("GeneratorFunction")}} peuvent être créés grâce à l'opérateur <code>new</code> :</p>
+Comme pour tous les autres objets, les objets {{jsxref("GeneratorFunction")}} peuvent être créés grâce à l'opérateur `new` :
 
-<pre class="syntaxbox">new GeneratorFunction (<em>arg1</em>, <em>arg2</em>, ... <em>argN</em>, <em>corpsFonction</em>)</pre>
+    new GeneratorFunction (arg1, arg2, ... argN, corpsFonction)
 
-<dl>
- <dt><code>arg1, arg2, ... arg<em>N</em></code></dt>
- <dd>Plusieurs (zéro ou plus) noms qui seront utilisés par la fonction comme noms d'arguments formels. Chaque nom doit être une chaîne de caractères valide au sens d'un identifiant JavaScript ou alors être une liste de telles chaînes séparées par des virgules. On aura les exemples suivants : "<code>x</code>", "<code>theValue</code>", ou "<code>a,b</code>".</dd>
- <dt><code>corpsFonction</code></dt>
- <dd>Une chaîne de caractères contenant les instructions JavaScript définissant la fonction.</dd>
-</dl>
+- `arg1, arg2, ... argN`
+  - : Plusieurs (zéro ou plus) noms qui seront utilisés par la fonction comme noms d'arguments formels. Chaque nom doit être une chaîne de caractères valide au sens d'un identifiant JavaScript ou alors être une liste de telles chaînes séparées par des virgules. On aura les exemples suivants : "`x`", "`theValue`", ou "`a,b`".
+- `corpsFonction`
+  - : Une chaîne de caractères contenant les instructions JavaScript définissant la fonction.
 
-<h2 id="Les_paramètres_dune_fonction">Les paramètres d'une fonction</h2>
+## Les paramètres d'une fonction
 
-<h3 id="Les_paramètres_par_défaut">Les paramètres par défaut</h3>
+### Les paramètres par défaut
 
-<p>Les paramètres par défaut permettent aux paramètres déclarés d'une fonction de pouvoir être initialisés avec des valeurs par défaut s'ils ne sont pas fournis à la fonction ou s'ils valent <code>undefined</code>. Pour plus de détails, voir la page de la référence sur <a href="/fr/docs/Web/JavaScript/Reference/Fonctions/Valeurs_par_défaut_des_arguments">les paramètres par défaut</a>.</p>
+Les paramètres par défaut permettent aux paramètres déclarés d'une fonction de pouvoir être initialisés avec des valeurs par défaut s'ils ne sont pas fournis à la fonction ou s'ils valent `undefined`. Pour plus de détails, voir la page de la référence sur [les paramètres par défaut](/fr/docs/Web/JavaScript/Reference/Fonctions/Valeurs_par_défaut_des_arguments).
 
-<h3 id="Les_paramètres_du_reste">Les paramètres du reste</h3>
+### Les paramètres du reste
 
-<p>Cette syntaxe permet de représenter un nombre indéfini d'arguments sous forme d'un tableau. Pour plus de détails, voir la page sur <a href="/fr/docs/Web/JavaScript/Reference/Fonctions/param%C3%A8tres_du_reste">les paramètres du reste</a>.</p>
+Cette syntaxe permet de représenter un nombre indéfini d'arguments sous forme d'un tableau. Pour plus de détails, voir la page sur [les paramètres du reste](/fr/docs/Web/JavaScript/Reference/Fonctions/param%C3%A8tres_du_reste).
 
-<h2 id="Lobjet_arguments">L'objet <code>arguments</code></h2>
+## L'objet `arguments`
 
-<p>Il est possible de faire référence aux arguments d'une fonction au sein de cette fonction en utilisant l'objet <code>arguments</code>. Consulter la page <a href="/fr/docs/Web/JavaScript/Reference/Fonctions/arguments">arguments</a> pour plus d'informations.</p>
+Il est possible de faire référence aux arguments d'une fonction au sein de cette fonction en utilisant l'objet `arguments`. Consulter la page [arguments](/fr/docs/Web/JavaScript/Reference/Fonctions/arguments) pour plus d'informations.
 
-<ul>
- <li><code><a href="/fr/docs/Web/JavaScript/Reference/Fonctions/arguments">arguments</a></code> : Un objet semblable à un tableau qui contient les arguments passés à la fonction qui est exécutée.</li>
- <li><code><a href="/fr/docs/Web/JavaScript/Reference/Fonctions/arguments/callee">arguments.callee</a></code> {{Deprecated_inline}} : La fonction en cours d'exécution.</li>
- <li><code><a href="/fr/docs/Web/JavaScript/Reference/Fonctions/arguments/caller">arguments.caller</a></code> {{Obsolete_inline}} : La fonction qui a appelé la fonction courante.</li>
- <li><code><a href="/fr/docs/Web/JavaScript/Reference/Fonctions/arguments/length">arguments.length</a></code> : Le nombre d'arguments passés à la fonction.</li>
-</ul>
+- [`arguments`](/fr/docs/Web/JavaScript/Reference/Fonctions/arguments) : Un objet semblable à un tableau qui contient les arguments passés à la fonction qui est exécutée.
+- [`arguments.callee`](/fr/docs/Web/JavaScript/Reference/Fonctions/arguments/callee) {{Deprecated_inline}} : La fonction en cours d'exécution.
+- [`arguments.caller`](/fr/docs/Web/JavaScript/Reference/Fonctions/arguments/caller) {{Obsolete_inline}} : La fonction qui a appelé la fonction courante.
+- [`arguments.length`](/fr/docs/Web/JavaScript/Reference/Fonctions/arguments/length) : Le nombre d'arguments passés à la fonction.
 
-<h2 id="Récursion">Récursion</h2>
+## Récursion
 
-<p>Une fonction peut faire référence à elle-même et s'appeler elle-même. Il y a trois façons pour qu'une fonction fasse appel à elle-même :</p>
+Une fonction peut faire référence à elle-même et s'appeler elle-même. Il y a trois façons pour qu'une fonction fasse appel à elle-même :
 
-<ol>
- <li>le nom de la fonction</li>
- <li><code><a href="/fr/docs/Web/JavaScript/Reference/Fonctions/arguments/callee">arguments.callee</a></code></li>
- <li>une variable interne faisant référence à la fonction</li>
-</ol>
+1.  le nom de la fonction
+2.  [`arguments.callee`](/fr/docs/Web/JavaScript/Reference/Fonctions/arguments/callee)
+3.  une variable interne faisant référence à la fonction
 
-<p>Avec l'exemple suivant :</p>
+Avec l'exemple suivant :
 
-<pre class="brush: js">var truc = function toto() {
+```js
+var truc = function toto() {
    // instructions
 };
-</pre>
+```
 
-<p>Ce qui suit sera équivalent au sein de la fonction :</p>
+Ce qui suit sera équivalent au sein de la fonction :
 
-<ol>
- <li><code>toto()</code></li>
- <li><code>arguments.callee()</code></li>
- <li><code>truc()</code></li>
-</ol>
+1.  `toto()`
+2.  `arguments.callee()`
+3.  `truc()`
 
-<p>Une fonction qui s'appelle elle-même est appelée une fonction récursive. D'une certaine manière, une récursion est semblable à une boucle. Une récursion et une boucle exécutent le même code plusieurs fois et s'appuient sur une condition (afin d'éviter une boucle infinie, ou plutôt une récursion infinie ici). Ainsi la boucle suivante :</p>
+Une fonction qui s'appelle elle-même est appelée une fonction récursive. D'une certaine manière, une récursion est semblable à une boucle. Une récursion et une boucle exécutent le même code plusieurs fois et s'appuient sur une condition (afin d'éviter une boucle infinie, ou plutôt une récursion infinie ici). Ainsi la boucle suivante :
 
-<pre class="brush: js">var x = 0;
-// "x &lt; 10" est la condition de la boucle
-while (x &lt; 10) {
+```js
+var x = 0;
+// "x < 10" est la condition de la boucle
+while (x < 10) {
    // faire des choses
    x++;
 }
-</pre>
+```
 
-<p>peut être convertie en une fonction récursive et un appel à cette fonction :</p>
+peut être convertie en une fonction récursive et un appel à cette fonction :
 
-<pre class="brush: js">function boucle(x) {
-   // "x &gt;= 10" est la condition de sortie
-   // (et équivaut à "!(x &lt; 10)")
-   if (x &gt;= 10)
+```js
+function boucle(x) {
+   // "x >= 10" est la condition de sortie
+   // (et équivaut à "!(x < 10)")
+   if (x >= 10)
       return;
    // faire des choses
    boucle(x + 1); // l'appel récursif
 }
 boucle(0);
-</pre>
+```
 
-<p>Cependant, certains algorithmes ne peuvent pas être traduits sous forme de boucles itératives. Ainsi, obtenir tous les nœuds d'un arbre (par exemple le DOM), est beaucoup plus facile à faire de manière récursive.</p>
+Cependant, certains algorithmes ne peuvent pas être traduits sous forme de boucles itératives. Ainsi, obtenir tous les nœuds d'un arbre (par exemple le DOM), est beaucoup plus facile à faire de manière récursive.
 
-<pre class="brush: js">function parcoursArbre(noeud) {
+```js
+function parcoursArbre(noeud) {
    if (noeud == null) //
       return;
    // faire quelque chose avec le noeud
-   for (var i = 0; i &lt; noeud.childNodes.length; i++) {
+   for (var i = 0; i < noeud.childNodes.length; i++) {
       parcoursArbre(noeud.childNodes[i]);
    }
 }
-</pre>
+```
 
-<p>Par rapport à la fonction <code>boucle</code>, chaque appel récursif enchaîne ici plusieurs appels récursifs successifs.</p>
+Par rapport à la fonction `boucle`, chaque appel récursif enchaîne ici plusieurs appels récursifs successifs.
 
-<p>Il est théoriquement possible de convertir tout algorithme récursif en un algorithme non-récursif. Cependant, la logique du problème est souvent beaucoup plus complexe et l'on doit faire recours à une pile pour le résoudre. Mais la récursion n'est en fait rien d'autre que l'utilisation d'une pile : la pile de la fonction.</p>
+Il est théoriquement possible de convertir tout algorithme récursif en un algorithme non-récursif. Cependant, la logique du problème est souvent beaucoup plus complexe et l'on doit faire recours à une pile pour le résoudre. Mais la récursion n'est en fait rien d'autre que l'utilisation d'une pile : la pile de la fonction.
 
-<p>La comportement de la récursion en tant que pile peut être observée avec cet exemple :</p>
+La comportement de la récursion en tant que pile peut être observée avec cet exemple :
 
-<pre class="brush: js">function truc(i) {
-   if (i &lt; 0)
+```js
+function truc(i) {
+   if (i < 0)
       return;
    console.log('début :' + i);
    toto(i - 1);
    console.log('fin :' + i);
 }
 truc(3);
-</pre>
+```
 
-<p>Elle produira le résultat suivant :</p>
+Elle produira le résultat suivant :
 
-<pre class="brush: js">début :3
+```js
+début :3
 début :2
 début :1
 début :0
@@ -321,29 +303,28 @@ fin :0
 fin :1
 fin :2
 fin :3
-</pre>
+```
 
-<h2 id="Fonctions_imbriquées_et_fermetures">Fonctions imbriquées et fermetures</h2>
+## Fonctions imbriquées et fermetures
 
-<p>Il est possible d'imbriquer une fonction au sein d'une fonction. La fonction imbriquée (interne) est privée par rapport à la fonction (externe) qui la contient. Cela forme ce qu'on appelle une fermeture (<em>closure</em> en anglais).</p>
+Il est possible d'imbriquer une fonction au sein d'une fonction. La fonction imbriquée (interne) est privée par rapport à la fonction (externe) qui la contient. Cela forme ce qu'on appelle une fermeture (_closure_ en anglais).
 
-<p>Une fermeture est une expression (généralement une fonction) possédant des variables libres ainsi qu'un environnement qui lie ces variable (autrement dit qui « ferme » l'expression).</p>
+Une fermeture est une expression (généralement une fonction) possédant des variables libres ainsi qu'un environnement qui lie ces variable (autrement dit qui « ferme » l'expression).
 
-<p>Étant donné qu'une fonction imbriquée est une fermeture, cela signifie que la fonction imbriquée peut « hériter » des arguments et des variables de la fonction qui la contient. En d'autres termes, la fonction interne contient la portée de la fonction externe.</p>
+Étant donné qu'une fonction imbriquée est une fermeture, cela signifie que la fonction imbriquée peut « hériter » des arguments et des variables de la fonction qui la contient. En d'autres termes, la fonction interne contient la portée de la fonction externe.
 
-<p>Pour résumer :</p>
+Pour résumer :
 
-<ul>
- <li>on ne peut accéder à la fonction interne seulement avec des instructions contenues dans la fonction externe,</li>
-</ul>
+- on ne peut accéder à la fonction interne seulement avec des instructions contenues dans la fonction externe,
 
-<ul>
- <li>la fonction interne est une fermeture : la fonction interne peut utiliser des arguments et des variables de la fonction externe alors que la fonction externe ne peut pas utiliser de variables et d'arguments de la fonction interne.</li>
-</ul>
+<!---->
 
-<p>L'exemple suivant, montre le cas de fonctions imbriquées :</p>
+- la fonction interne est une fermeture : la fonction interne peut utiliser des arguments et des variables de la fonction externe alors que la fonction externe ne peut pas utiliser de variables et d'arguments de la fonction interne.
 
-<pre class="brush: js">function ajouteCarres(a,b) {
+L'exemple suivant, montre le cas de fonctions imbriquées :
+
+```js
+function ajouteCarres(a,b) {
    function carre(x) {
       return x * x;
    }
@@ -352,11 +333,12 @@ fin :3
 var a = ajouteCarres(2,3); // renvoie 13
 var b = ajouteCarres(3,4); // renvoie 25
 var c = ajouteCarres(4,5); // renvoie 41
-</pre>
+```
 
-<p>Étant donné que la fonction interne est une fermeture, il est possible d'appeler la fonction externe et de définir des arguments pour la fonction externe mais aussi pour la fonction interne :</p>
+Étant donné que la fonction interne est une fermeture, il est possible d'appeler la fonction externe et de définir des arguments pour la fonction externe mais aussi pour la fonction interne :
 
-<pre class="brush: js">function externe(x) {
+```js
+function externe(x) {
    function interne(y) {
       return x + y;
    }
@@ -366,21 +348,22 @@ var fn_interne = externe(3);
 var resultat = fn_interne(5); // renvoie 8
 
 var resultat1 = externe(3)(5); // renvoie 8
-</pre>
+```
 
-<h3 id="Conservation_des_variables">Conservation des variables</h3>
+### Conservation des variables
 
-<p>On voit alors que <code>x</code> est conservé lorsqu'<code>interne</code> est renvoyé. Une fermeture doit conserver les arguments et les variables au sein de toutes les portées auxquelles elle fait référence. Étant donné qu'éventuellement, chaque appel fournira des arguments différents, une nouvelle fermeture est créée pour chaque appel externe. La mémoire peut donc être libérée seulement lorsque <code>inside</code> n'est plus accessible.</p>
+On voit alors que `x` est conservé lorsqu'`interne` est renvoyé. Une fermeture doit conserver les arguments et les variables au sein de toutes les portées auxquelles elle fait référence. Étant donné qu'éventuellement, chaque appel fournira des arguments différents, une nouvelle fermeture est créée pour chaque appel externe. La mémoire peut donc être libérée seulement lorsque `inside` n'est plus accessible.
 
-<p>Cela n'est pas différent du stockage de références avec d'autres objets, mais ça reste plus délicat à observer puisqu'on ne peut inspecter ou définir soi-même les références en question.</p>
+Cela n'est pas différent du stockage de références avec d'autres objets, mais ça reste plus délicat à observer puisqu'on ne peut inspecter ou définir soi-même les références en question.
 
-<h3 id="Imbrication_multiple_de_fonctions">Imbrication multiple de fonctions</h3>
+### Imbrication multiple de fonctions
 
-<p>On peut imbriquer plusieurs fonctions : une fonction (A) contien une fonction (B) qui contient une fonction (C). Ici les fonctions B et C forment des fermetures et aisni B peut accéder à A et C peut accéder à B. On peut donc en déduire, puisque C accède à B qui accède à A que C peut accéder à A. On voit donc que les fermetures peuvent contenir différentes portées. Elles peuvent, récursivement, contenir la portée des fonctions qui la contiennent. Ce mécanisme est appelé « chaînage de portée »  (<em>scope chaining</em> en anglais). (Cette dénomination sera expliquée par la suite.)</p>
+On peut imbriquer plusieurs fonctions : une fonction (A) contien une fonction (B) qui contient une fonction (C). Ici les fonctions B et C forment des fermetures et aisni B peut accéder à A et C peut accéder à B. On peut donc en déduire, puisque C accède à B qui accède à A que C peut accéder à A. On voit donc que les fermetures peuvent contenir différentes portées. Elles peuvent, récursivement, contenir la portée des fonctions qui la contiennent. Ce mécanisme est appelé « chaînage de portée »  (_scope chaining_ en anglais). (Cette dénomination sera expliquée par la suite.)
 
-<p>On peut l'observer avec l'exemple suivant :</p>
+On peut l'observer avec l'exemple suivant :
 
-<pre class="brush: js">function A(x) {
+```js
+function A(x) {
    function B(y) {
       function C(z) {
          console.log(x + y + z);
@@ -390,23 +373,22 @@ var resultat1 = externe(3)(5); // renvoie 8
    B(2);
 }
 A(1); // crée un message d'alerte avec 6 (= 1 + 2 + 3)
-</pre>
+```
 
-<p>Dans cet exemple, C accède à la variable y de B et à la variable x de A. Cela est possible parce que :</p>
+Dans cet exemple, C accède à la variable y de B et à la variable x de A. Cela est possible parce que :
 
-<ol>
- <li><code>B</code> est une fermeture qui contient <code>A</code>, autrement dit <code>B</code> peut accéder aux arguments et aux variables de <code>A</code></li>
- <li><code>C</code> est une fermeture qui contient <code>B</code></li>
- <li>Étant donné que la fermeture de <code>B</code> contient <code>A</code> et que celle de <code>C</code> contient <code>B</code>, <code>C</code> peut accéder à la fois aux arguments et variables de <code>B</code> <em>et</em> <code>A</code>. Autrement dit, <code>C</code> <em>enchaîne les portées de </em> <code>B</code> et <code>A</code> dans cet ordre.</li>
-</ol>
+1.  `B` est une fermeture qui contient `A`, autrement dit `B` peut accéder aux arguments et aux variables de `A`
+2.  `C` est une fermeture qui contient `B`
+3.  Étant donné que la fermeture de `B` contient `A` et que celle de `C` contient `B`, `C` peut accéder à la fois aux arguments et variables de `B` _et_ `A`. Autrement dit, `C` *enchaîne les portées de*  `B` et `A` dans cet ordre.
 
-<p>La réciproque n'est pas vraie. <code>A</code> ne peut avoir accès à <code>C</code>, parce que <code>A</code> ne peut accéder ni aux variables ni aux arguments de <code>B</code>, or <code>C</code> est une variable de <code>B. C</code> est donc privé et seulement pour <code>B</code>.</p>
+La réciproque n'est pas vraie. `A` ne peut avoir accès à `C`, parce que `A` ne peut accéder ni aux variables ni aux arguments de `B`, or `C` est une variable de `B. C` est donc privé et seulement pour `B`.
 
-<h3 id="Conflits_de_noms">Conflits de noms</h3>
+### Conflits de noms
 
-<p>Lorsque deux arguments ou variables appartenant aux portées d'une fermeture ont le même nom, il y a un <em>conflit de noms</em>. La portée la plus interne l'emportera par rapport à la portée la plus externe. C'est ce qu'on appelle la chaîne de portée (<em>scope chain</em> en anglais). Le premier maillon de cette chaîne est la portée la plus interne tandis que le dernier maillon est représenté par la portée la plus externe. Regardons l'exemple suivant :</p>
+Lorsque deux arguments ou variables appartenant aux portées d'une fermeture ont le même nom, il y a un _conflit de noms_. La portée la plus interne l'emportera par rapport à la portée la plus externe. C'est ce qu'on appelle la chaîne de portée (_scope chain_ en anglais). Le premier maillon de cette chaîne est la portée la plus interne tandis que le dernier maillon est représenté par la portée la plus externe. Regardons l'exemple suivant :
 
-<pre class="brush: js">function externe() {
+```js
+function externe() {
    var x = 10;
    function interne(x) {
       return x;
@@ -414,275 +396,292 @@ A(1); // crée un message d'alerte avec 6 (= 1 + 2 + 3)
    return interne;
 }
 resultat = externe()(20); // renvoie 20 et non pas 10
-</pre>
+```
 
-<p>Le conflit de nom apparaît avec l'instruction <code>return x</code> et vient de la dénomination commune de l'argument <code>x </code>de la fonction<code> interne</code> et la variable <code>x </code>de la fonction <code>externe</code>. La chaîne de portée est, pour cet exemple : {<code>interne</code>, <code>externe</code>, objet globalt}. On voit alors que le  <code>x</code> de la fonction interne l'emporte sur le <code>x </code>de la fonction externe. 20 (<code>x</code> de la fonction <code>interne</code>) est donc renvoyé plutôt que 10 (<code>x</code> de la fonction <code>externe</code>).</p>
+Le conflit de nom apparaît avec l'instruction `return x` et vient de la dénomination commune de l'argument `x `de la fonction` interne` et la variable `x `de la fonction `externe`. La chaîne de portée est, pour cet exemple : {`interne`, `externe`, objet globalt}. On voit alors que le  `x` de la fonction interne l'emporte sur le `x `de la fonction externe. 20 (`x` de la fonction `interne`) est donc renvoyé plutôt que 10 (`x` de la fonction `externe`).
 
-<h2 id="Définition_des_méthodes">Définition des méthodes</h2>
+## Définition des méthodes
 
-<h3 id="Les_accesseurs_et_mutateurs_getter_et_setter">Les accesseurs et mutateurs (<em>getter</em> et <em>setter</em>)</h3>
+### Les accesseurs et mutateurs (_getter_ et _setter_)
 
-<p>Il est possible de définir des méthodes qui sont accesseurs ou des mutateurs sur n'importe quel objet qui peut avoir de nouvelles propriétés. La syntaxe utilisée pour définir les <em>getters</em> et <em>setters</em> est celle utilisée avec les littéraux objets.</p>
+Il est possible de définir des méthodes qui sont accesseurs ou des mutateurs sur n'importe quel objet qui peut avoir de nouvelles propriétés. La syntaxe utilisée pour définir les _getters_ et _setters_ est celle utilisée avec les littéraux objets.
 
-<dl>
- <dt><a href="/fr/docs/Web/JavaScript/Reference/Fonctions/get">get</a></dt>
- <dd>
- <p>Permet de lier une propriété d'un objet à une fonction qui sera appelée lorsqu'on accèdera à la propriété.</p>
- </dd>
- <dt><a href="/fr/docs/Web/JavaScript/Reference/Fonctions/set">set</a></dt>
- <dd>Permet de lier une propriété d'un objet à une fonction qui sera appelée lorsqu'on tentera de modifier cette propriété.</dd>
-</dl>
+- [get](/fr/docs/Web/JavaScript/Reference/Fonctions/get)
+  - : Permet de lier une propriété d'un objet à une fonction qui sera appelée lorsqu'on accèdera à la propriété.
+- [set](/fr/docs/Web/JavaScript/Reference/Fonctions/set)
+  - : Permet de lier une propriété d'un objet à une fonction qui sera appelée lorsqu'on tentera de modifier cette propriété.
 
-<h3 id="Syntaxe_des_définitions_de_méthode_ECMAScript_2015">Syntaxe des définitions de méthode ECMAScript <strong>2015</strong></h3>
+### Syntaxe des définitions de méthode ECMAScript **2015**
 
-<p>Avec ECMAScript 2015, il est possible de définir des méthodes de façon plus concise (à la façon de ce qui est déjà possible pour les getters et setters). Voir la page sur <a href="/fr/docs/Web/JavaScript/Reference/Fonctions/Définition_de_méthode">les définitions de méthodes</a> pour plus d'informations.</p>
+Avec ECMAScript 2015, il est possible de définir des méthodes de façon plus concise (à la façon de ce qui est déjà possible pour les getters et setters). Voir la page sur [les définitions de méthodes](/fr/docs/Web/JavaScript/Reference/Fonctions/Définition_de_méthode) pour plus d'informations.
 
-<pre class="brush: js">var obj = {
+```js
+var obj = {
   toto() {},
   truc() {}
-};</pre>
+};
+```
 
-<h2 id="Constructeur_déclaration_expression">Constructeur, déclaration, expression ?</h2>
+## Constructeur, déclaration, expression ?
 
-<p>Comparons les exemples suivants :</p>
+Comparons les exemples suivants :
 
-<ol>
- <li>une fonction définie grâce au constructeur <code>Function</code> assignée à la variable <code>multiplier</code>
+1.  une fonction définie grâce au constructeur `Function` assignée à la variable `multiplier`
 
-  <pre class="brush: js">var multiplier = new Function("x", "y", "return x * y;");
-</pre>
- </li>
- <li>une déclaration de fonction d'une fonction appelée <code>multiplier</code>
-  <pre class="brush: js">function multiplier(x, y) {
-   return x * y;
-}
-</pre>
- </li>
- <li>une expression de fonction d'une fonction anonyme assignée à la variable <code>multiplier</code>
-  <pre class="brush: js">var multiplier = function(x, y) {
-   return x * y;
-};
-</pre>
- </li>
- <li>une expression de fonction d'une fonction nommée <code>fonction_nom</code> assignée à la variable <code>multiplier</code>
-  <pre class="brush: js">var multiplier = function function_nom(x, y) {
-   return x * y;
-};
-</pre>
- </li>
-</ol>
-
-<p>Tous ces exemples effectuent à peu près la même chose, mais différent sur quelques points :</p>
-
-<ul>
- <li>Il y a une distinction entre le nom de la fonction et la variable à laquelle elle est affectée :
-  <ul>
-   <li>le nom de la fonction ne peut être changé alors que la variable à laquelle la fonction a été assignée peut être réassignée.</li>
-   <li>le nom de la fonction ne peut-être utilisé qu'à l'intérieur du corps de la fonction. Toute tentative d'utilisation en dehors du corps de la fonction entraînera une erreur (ou <code>undefined</code> si le nom de la fonction a été déclaré auparavant avec une instruction <code>var</code>). Ainsi :
-    <pre class="brush: js">var y = function x() {};
-console.log(x); // renvoie une erreur
-</pre>
-
-    <p>Le nom de la fonction apparaît également lorsque la fonction est sérialisée avec la <a href="/fr/docs/JavaScript/Reference/R%C3%A9f%C3%A9rence_JavaScript/Objets_globaux/Function/toString">méthode toString de l'objet <code>Function</code></a>.</p>
-
-    <p>La variable à laquelle est assignée la fonction est seulement limitée par rapport à la portée. La portée au sein de laquelle la fonction est déclarée est donc garantie d'être dans la portée de la variable.</p>
-   </li>
-   <li>Comme le montre le quatrième exemple, le nom de la fonction peut être différent du nom de la variable à laquelle a été assignée la fonction. Les deux noms n'ont aucune relation entre eux.</li>
-  </ul>
- </li>
- <li>Une déclaration de fonction peut aussi créer une variable avec le même nom que la fonction. Ainsi, contrairement une expression de fonction, une déclaration de fonction permet d'accéder à la fonction grâce à son nom au sein de la portée dans laquelle elle a été définie :
-  <pre class="brush: js">function x() {}
-console.log(x); // affichera la fonction x sérialisée en une chaîne de caractères
-</pre>
-
-  <p>L'exemple qui suit montre que les noms de fonctions ne sont par liées aux variables auxquelles sont assignées les fonctions. Si une variable de fonction est assignée à une autre valeur, elle aura toujours le même nom de fonction :</p>
-
-  <pre class="brush: js">function toto() {}
-console.log(toto); // message affichant la chaine de caractères "toto"
-var truc = toto;
-console.log(truc); // message affichant la chaine de caractères "toto"
-</pre>
- </li>
- <li>Une fonction définie grâce à « <code>new Function »</code> n'aura pas de nom de fonction. Cependant, le moteur JavaScript <a href="/fr/docs/SpiderMonkey">SpiderMonkey</a>, la forme sérialisée de la fonction apparaît comme si la fonction avait le nom « anonymous ». Le code <code>console.log(new Function())</code> produira :
-  <pre class="brush: js">function anonymous() {
-}
-</pre>
-
-  <p>La fonction n'ayant pas de nom effectif, <code>anonymous</code> n'est pas une variable à laquelle on pourra accéder au sein de la fonction. Par exemple, le code qui suit produira une erreur :</p>
-
-  <pre class="brush: js">var toto = new Function("console.log(anonymous);");
-toto();
-</pre>
- </li>
- <li>À la différence des fonctions définies par les expressions de fonction ou par le constructeur <code>Function</code>, une fonction définie par une déclaration de fonction pourra être utilisée avant la déclaration. Ainsi :
-  <pre class="brush: js">toto(); // affichera TOTO !
-function toto() {
-   console.log('TOTO !');
-}
-</pre>
- </li>
- <li>Une fonction définie par une expression de fonction hérite de la portée courante. La fonction forme donc une fermeture. En revanche, les fonctions définies par le constructeur <code>Function</code> n'héritent que de la portée globale (portée héritée par toutes les fonctions).</li>
- <li>Les fonctions définies par les expressions et les déclarations de fonctions ne sont analysées (parsées) qu'une seule fois. Celles définies grâce au constructeur <code>Function</code> ne le sont pas. Cela signifie que la chaîne de caractère représentant le corps de la fonction doit être analysée à chaque fois qu'elle est évaluée. Bien qu'une expression de fonction crée obligatoirement une fermeture, le corps de la fonction n'est pas parsé à nouveau. Les expressions de fonctions sont donc plus rapides que « <code>new Function(...)</code> ». Il faut donc éviter le constructeur <code>Function</code> autant que possible.<br>
-  Il faut cependant noter que les expressions et les déclarations imbriquées au sein d'une chaîne de caractère pour un constructeur <code>Function</code> ne sont analysées qu'une seule fois. On aura l'exemple suivant :
-  <pre class="brush: js">var toto = (new Function("var truc = \'TOTO !\';\nreturn(function() {\n\tconsole.log(truc);\n});"))();
-toto(); //La partie « function() {\n\tconsole.log(truc);\n} » de la chaîne de caractères n'est pas analysée à nouveau.</pre>
- </li>
-</ul>
-
-<p>Une déclaration de fonction peut très facilement (et souvent involontairement) être transformée en une expression de fonction. Une déclaration de fonction cesse d'en être une lorsque :</p>
-
-<ul>
- <li>elle fait partie d'une expression</li>
- <li>ou elle n'est plus un « élément source » de la fonction ou du script. Un « élément source » est une instruction non-imbriquée du script ou d'un corps de fonction.
-  <pre class="brush: js">var x = 0;                 // élément source
-if (x === 0) {              // élément source
-   x = 10;                 // pas un élément source
-   function titi() {}      // pas un élément source
-}
-function toto() {          // élément source
-   var y = 20;             // élément source
-   function truc() {}      // élément source
-   while (y === 10) {       // élément source
-      function machin() {} // pas un élément source
-      y++;                 // pas un élément source
-   }
-}
-</pre>
- </li>
-</ul>
-
-<h3 id="Exemples">Exemples :</h3>
-
-<ul>
- <li>
-  <pre class="brush: js">// déclaration de fonction
-function toto() {}
-
-// expression de fonction
-(function truc() {})
-
-// expression de fonction
-var x = function bonjour() {}</pre>
- </li>
- <li>
-  <pre class="brush: js">if (x) {
-   // expression de fonction
-   function monde() {}
-}
-</pre>
- </li>
- <li>
-  <pre class="brush: js">// déclaration de fonction
-function a() {
-   // déclaration de fonction
-   function b() {}
-   if (0) {
-      // expression de fonction
-      function c() {}
-   }
-}
-</pre>
- </li>
-</ul>
+    ```js
+    var multiplier = new Function("x", "y", "return x * y;");
+    ```
+
+2.  une déclaration de fonction d'une fonction appelée `multiplier`
+
+    ```js
+    function multiplier(x, y) {
+       return x * y;
+    }
+    ```
+
+3.  une expression de fonction d'une fonction anonyme assignée à la variable `multiplier`
+
+    ```js
+    var multiplier = function(x, y) {
+       return x * y;
+    };
+    ```
+
+4.  une expression de fonction d'une fonction nommée `fonction_nom` assignée à la variable `multiplier`
+
+    ```js
+    var multiplier = function function_nom(x, y) {
+       return x * y;
+    };
+    ```
+
+Tous ces exemples effectuent à peu près la même chose, mais différent sur quelques points :
+
+- Il y a une distinction entre le nom de la fonction et la variable à laquelle elle est affectée :
+
+  - le nom de la fonction ne peut être changé alors que la variable à laquelle la fonction a été assignée peut être réassignée.
+  - le nom de la fonction ne peut-être utilisé qu'à l'intérieur du corps de la fonction. Toute tentative d'utilisation en dehors du corps de la fonction entraînera une erreur (ou `undefined` si le nom de la fonction a été déclaré auparavant avec une instruction `var`). Ainsi :
+
+    ```js
+        var y = function x() {};
+        console.log(x); // renvoie une erreur
+        ```
 
-<h2 id="Définir_une_fonction_de_façon_conditionnelle">Définir une fonction de façon conditionnelle</h2>
+    Le nom de la fonction apparaît également lorsque la fonction est sérialisée avec la [méthode toString de l'objet `Function`](/fr/docs/JavaScript/Reference/R%C3%A9f%C3%A9rence_JavaScript/Objets_globaux/Function/toString).
 
-<p>Il est possible de définir des fonctions de manière conditionnelle en utilisant soit : //function statements// (une extension autorisée par le standard <a href="https://www.ecma-international.org/publications/standards/Ecma-262.htm">ECMA-262 Edition 3</a>) soit le constructeur <code>Function</code>. Il faut noter que de telles instructions ne sont plus autorisées dans le standard <a class="link-https" href="https://bugzilla.mozilla.org/show_bug.cgi?id=609832">ES5 strict</a>. Il faut également savoir que cela ne fonctionne pas de manière homogène sur les différents navigateurs. Il est donc déconseillé d'utiliser cette fonctionnalité.</p>
+    La variable à laquelle est assignée la fonction est seulement limitée par rapport à la portée. La portée au sein de laquelle la fonction est déclarée est donc garantie d'être dans la portée de la variable.
 
-<p>Dans le script qui suit, la fonction <code>zero</code> n'est jamais définie et ne peut donc être appelée car le test « <code>if (0)</code> » est toujours faux :</p>
+  - Comme le montre le quatrième exemple, le nom de la fonction peut être différent du nom de la variable à laquelle a été assignée la fonction. Les deux noms n'ont aucune relation entre eux.
 
-<pre class="brush: js">if (0) {
+- Une déclaration de fonction peut aussi créer une variable avec le même nom que la fonction. Ainsi, contrairement une expression de fonction, une déclaration de fonction permet d'accéder à la fonction grâce à son nom au sein de la portée dans laquelle elle a été définie :
+
+  ```js
+    function x() {}
+    console.log(x); // affichera la fonction x sérialisée en une chaîne de caractères
+    ```
+
+  L'exemple qui suit montre que les noms de fonctions ne sont par liées aux variables auxquelles sont assignées les fonctions. Si une variable de fonction est assignée à une autre valeur, elle aura toujours le même nom de fonction :
+
+  ```js
+    function toto() {}
+    console.log(toto); // message affichant la chaine de caractères "toto"
+    var truc = toto;
+    console.log(truc); // message affichant la chaine de caractères "toto"
+    ```
+
+- Une fonction définie grâce à « `new Function »` n'aura pas de nom de fonction. Cependant, le moteur JavaScript [SpiderMonkey](/fr/docs/SpiderMonkey), la forme sérialisée de la fonction apparaît comme si la fonction avait le nom « anonymous ». Le code `console.log(new Function())` produira :
+
+  ```js
+    function anonymous() {
+    }
+    ```
+
+  La fonction n'ayant pas de nom effectif, `anonymous` n'est pas une variable à laquelle on pourra accéder au sein de la fonction. Par exemple, le code qui suit produira une erreur :
+
+  ```js
+    var toto = new Function("console.log(anonymous);");
+    toto();
+    ```
+
+- À la différence des fonctions définies par les expressions de fonction ou par le constructeur `Function`, une fonction définie par une déclaration de fonction pourra être utilisée avant la déclaration. Ainsi :
+
+  ```js
+    toto(); // affichera TOTO !
+    function toto() {
+       console.log('TOTO !');
+    }
+    ```
+
+- Une fonction définie par une expression de fonction hérite de la portée courante. La fonction forme donc une fermeture. En revanche, les fonctions définies par le constructeur `Function` n'héritent que de la portée globale (portée héritée par toutes les fonctions).
+- Les fonctions définies par les expressions et les déclarations de fonctions ne sont analysées (parsées) qu'une seule fois. Celles définies grâce au constructeur `Function` ne le sont pas. Cela signifie que la chaîne de caractère représentant le corps de la fonction doit être analysée à chaque fois qu'elle est évaluée. Bien qu'une expression de fonction crée obligatoirement une fermeture, le corps de la fonction n'est pas parsé à nouveau. Les expressions de fonctions sont donc plus rapides que « `new Function(...)` ». Il faut donc éviter le constructeur `Function` autant que possible.
+  Il faut cependant noter que les expressions et les déclarations imbriquées au sein d'une chaîne de caractère pour un constructeur `Function` ne sont analysées qu'une seule fois. On aura l'exemple suivant :
+
+  ```js
+    var toto = (new Function("var truc = \'TOTO !\';\nreturn(function() {\n\tconsole.log(truc);\n});"))();
+    toto(); //La partie « function() {\n\tconsole.log(truc);\n} » de la chaîne de caractères n'est pas analysée à nouveau.
+    ```
+
+Une déclaration de fonction peut très facilement (et souvent involontairement) être transformée en une expression de fonction. Une déclaration de fonction cesse d'en être une lorsque :
+
+- elle fait partie d'une expression
+- ou elle n'est plus un « élément source » de la fonction ou du script. Un « élément source » est une instruction non-imbriquée du script ou d'un corps de fonction.
+
+  ```js
+    var x = 0;                 // élément source
+    if (x === 0) {              // élément source
+       x = 10;                 // pas un élément source
+       function titi() {}      // pas un élément source
+    }
+    function toto() {          // élément source
+       var y = 20;             // élément source
+       function truc() {}      // élément source
+       while (y === 10) {       // élément source
+          function machin() {} // pas un élément source
+          y++;                 // pas un élément source
+       }
+    }
+    ```
+
+### Exemples :
+
+- ```js
+    // déclaration de fonction
+    function toto() {}
+
+    // expression de fonction
+    (function truc() {})
+
+    // expression de fonction
+    var x = function bonjour() {}
+    ```
+
+- ```js
+    if (x) {
+       // expression de fonction
+       function monde() {}
+    }
+    ```
+
+- ```js
+    // déclaration de fonction
+    function a() {
+       // déclaration de fonction
+       function b() {}
+       if (0) {
+          // expression de fonction
+          function c() {}
+       }
+    }
+    ```
+
+## Définir une fonction de façon conditionnelle
+
+Il est possible de définir des fonctions de manière conditionnelle en utilisant soit : //function statements// (une extension autorisée par le standard [ECMA-262 Edition 3](https://www.ecma-international.org/publications/standards/Ecma-262.htm)) soit le constructeur `Function`. Il faut noter que de telles instructions ne sont plus autorisées dans le standard [ES5 strict](https://bugzilla.mozilla.org/show_bug.cgi?id=609832). Il faut également savoir que cela ne fonctionne pas de manière homogène sur les différents navigateurs. Il est donc déconseillé d'utiliser cette fonctionnalité.
+
+Dans le script qui suit, la fonction `zero` n'est jamais définie et ne peut donc être appelée car le test « `if (0)` » est toujours faux :
+
+```js
+if (0) {
    function zero() {
       console.log("C'est zero.");
    }
 }
-</pre>
+```
 
-<p>Si le script est changé et que la condition devient « <code>if (1)</code> », la fonction <code>zero</code> sera alors définie.</p>
+Si le script est changé et que la condition devient « `if (1)` », la fonction `zero` sera alors définie.
 
-<p>Bien que cette fonction ressemble à une déclaration de fonction, il s'agit en fait d'une expression (ou instruction) de fonction, car celle-ci est imbriquée au sein d'une autre instruction. (Consulter le paragraphe précédent pour une explication à ce sujet).</p>
+Bien que cette fonction ressemble à une déclaration de fonction, il s'agit en fait d'une expression (ou instruction) de fonction, car celle-ci est imbriquée au sein d'une autre instruction. (Consulter le paragraphe précédent pour une explication à ce sujet).
 
-<div class="note">
-<p><strong>Note :</strong> À la différence de <a href="/fr/docs/SpiderMonkey">SpiderMonkey</a>, certains moteurs JavaScript traîtent incorrectement les expressions de fonction avec un nom comme des définitions de fonction. Cela conduirait à la définition de la fonction <code>zero</code> et ce même avec la condition <code>if</code> valant faux. Une façon plus sûre de définir des fonctions de manière conditionnelle est de définir la fonction et de l'assigner à une variable :</p>
+> **Note :** À la différence de [SpiderMonkey](/fr/docs/SpiderMonkey), certains moteurs JavaScript traîtent incorrectement les expressions de fonction avec un nom comme des définitions de fonction. Cela conduirait à la définition de la fonction `zero` et ce même avec la condition `if` valant faux. Une façon plus sûre de définir des fonctions de manière conditionnelle est de définir la fonction et de l'assigner à une variable :
+>
+> ```js
+> if (0) {
+>    var zero = function() {
+>       console.log("C'est zero");
+>    }
+> }
+> ```
 
-<pre class="brush: js">if (0) {
-   var zero = function() {
-      console.log("C'est zero");
-   }
-}
-</pre>
-</div>
-
-<h2 id="Les_fonctions_en_tant_que_gestionnaires_dévénements">Les fonctions en tant que gestionnaires d'événements</h2>
+## Les fonctions en tant que gestionnaires d'événements
 
-<p>En JavaScript, les gestionnaires d'événements <a href="/fr/docs/DOM">DOM</a> (<em>event handlers</em> en anglais) sont des fonctions (différentes des objets contenant une méthode <code>handleEvent</code> dans d'autres langages de liaison avec le DOM -<em>binding languages</em> en anglais). Les fontions ont l'objet <a href="/fr/docs/DOM/event">event</a> comme seul et unique paramètre. Comme tous les autres paramètres, si l'objet événement, n'a pas besoin d'être utilisé, il peut être absent de la liste des paramètres formels.</p>
+En JavaScript, les gestionnaires d'événements [DOM](/fr/docs/DOM) (_event handlers_ en anglais) sont des fonctions (différentes des objets contenant une méthode `handleEvent` dans d'autres langages de liaison avec le DOM -_binding languages_ en anglais). Les fontions ont l'objet [event](/fr/docs/DOM/event) comme seul et unique paramètre. Comme tous les autres paramètres, si l'objet événement, n'a pas besoin d'être utilisé, il peut être absent de la liste des paramètres formels.
 
-<p>Les objets d'un document HTML susceptibles de recevoir des événements peuvent être par exemple : <code>window</code> (objets<code> Window</code>, y compris les objets frames), <code>document</code> (les objets <code>HTMLDocument</code>), et les éléments (les objets <code>Element</code>). Au sein du <a href="https://www.w3.org/TR/DOM-Level-2-HTML/">DOM HTML</a>, les objets recevant des événements possède des propriétés gestionnaires d'événements. Ces propriétés sont les noms des événements en minuscules préfixés par « on » (par exemple <code>onfocus</code>). Une autre façon, plus fiable, d'ajouter des auditeurs d'événements, est offert par les <a href="https://www.w3.org/TR/DOM-Level-2-Events/">événements DOM de niveau 2</a>.</p>
+Les objets d'un document HTML susceptibles de recevoir des événements peuvent être par exemple : `window` (objets` Window`, y compris les objets frames), `document` (les objets `HTMLDocument`), et les éléments (les objets `Element`). Au sein du [DOM HTML](https://www.w3.org/TR/DOM-Level-2-HTML/), les objets recevant des événements possède des propriétés gestionnaires d'événements. Ces propriétés sont les noms des événements en minuscules préfixés par « on » (par exemple `onfocus`). Une autre façon, plus fiable, d'ajouter des auditeurs d'événements, est offert par les [événements DOM de niveau 2](https://www.w3.org/TR/DOM-Level-2-Events/).
 
-<p>Note : Les événements font partie de la logique DOM et non de celle de JavaScript. (JavaScript n'est qu'un langage permettant de manipuler le DOM.)</p>
+Note : Les événements font partie de la logique DOM et non de celle de JavaScript. (JavaScript n'est qu'un langage permettant de manipuler le DOM.)
 
-<p>L'exemple suivant assigne une fonction au gestionnaire de l'événement « focus ».</p>
+L'exemple suivant assigne une fonction au gestionnaire de l'événement « focus ».
 
-<pre class="brush: js">window.onfocus = function() {
+```js
+window.onfocus = function() {
    document.body.style.backgroundColor = 'white';
 };
-</pre>
+```
 
-<p>Si une fonction est assignée à une variable, il est possible d'assigner la variable à un gestionnaire d'événement. Le fragment de code qui suit assigne une fonction à la variable <code>setBGColor</code>.</p>
+Si une fonction est assignée à une variable, il est possible d'assigner la variable à un gestionnaire d'événement. Le fragment de code qui suit assigne une fonction à la variable `setBGColor`.
 
-<pre class="brush: js">var setBGColor = new Function("document.body.style.backgroundColor = 'white';");
-</pre>
+```js
+var setBGColor = new Function("document.body.style.backgroundColor = 'white';");
+```
 
-<p>Il est alors possible d'utiliser cette variable pour assigner une fonction à un gestionnaire d'événement. Cela peut se faire de plusieurs manières, en voici deux décrites ici :</p>
+Il est alors possible d'utiliser cette variable pour assigner une fonction à un gestionnaire d'événement. Cela peut se faire de plusieurs manières, en voici deux décrites ici :
 
-<ol>
- <li>écrire dans les propriétés de l'évément DOM HTML
-  <pre class="brush: js">document.form1.colorButton.onclick = setBGColor;
-</pre>
- </li>
- <li>l'attribut de l'événement HTML
-  <pre class="brush: html">&lt;input type="button"
-   value="Changer la couleur de fond"
-   onclick="setBGColor();"/&gt;
-</pre>
+1.  écrire dans les propriétés de l'évément DOM HTML
 
-  <p>Un gestionnaire d'événement défini de cette manière sera une fonction, nommée selon l'attribut, encadré du code spécifique nécessaire. C'est pourquoi les parenthèses sont ici nécessaires (<code>setBGColor()</code> et non pas <code>setBGColor</code>). Cela est équivalent à :</p>
+    ```js
+    document.form1.colorButton.onclick = setBGColor;
+    ```
 
-  <pre class="brush: js">document.form1.colorButton.onclick = function onclick(event) {
-   setBGColor();
-};
-</pre>
+2.  l'attribut de l'événement HTML
+
+    ```html
+    <input type="button"
+       value="Changer la couleur de fond"
+       onclick="setBGColor();"/>
+    ```
+
+    Un gestionnaire d'événement défini de cette manière sera une fonction, nommée selon l'attribut, encadré du code spécifique nécessaire. C'est pourquoi les parenthèses sont ici nécessaires (`setBGColor()` et non pas `setBGColor`). Cela est équivalent à :
+
+    ```js
+    document.form1.colorButton.onclick = function onclick(event) {
+       setBGColor();
+    };
+    ```
 
-  <p>Il faut noter la façon dont l'objet événement est passé à la fonction en tant que paramètre <code>event</code>. Cela permet au code d'utiliser l'objet <code>Event</code> :</p>
+    Il faut noter la façon dont l'objet événement est passé à la fonction en tant que paramètre `event`. Cela permet au code d'utiliser l'objet `Event` :
 
-  <pre class="brush: html">&lt;input ...
-    onclick="console.log(event.target.tagName);"/&gt;
-</pre>
- </li>
-</ol>
+    ```html
+    <input ...
+        onclick="console.log(event.target.tagName);"/>
+    ```
 
-<p>Tout comme les autres propriétés faisant référence à une fonction, le gestionnaire d'événement peut agir come une méthode et <code>this</code> ferait alors référence à l'élément contenant le gestionnaire d'événement. Dans l'exemple suivant, la fonction à laquelle <code>onfocus</code> fait référence est appelée avec <code>this</code> qui a la valeur <code>window</code>.</p>
+Tout comme les autres propriétés faisant référence à une fonction, le gestionnaire d'événement peut agir come une méthode et `this` ferait alors référence à l'élément contenant le gestionnaire d'événement. Dans l'exemple suivant, la fonction à laquelle `onfocus` fait référence est appelée avec `this` qui a la valeur `window`.
 
-<pre class="brush: js">window.onfocus();
-</pre>
+```js
+window.onfocus();
+```
 
-<p>Une erreur faite souvent lorsque l'on commence à utiliser JavaScript est d'ajouter des parenthèses et/ou des paramètres à la fin de la variable. Cela revient à appeler le gestionnaire d'événement lorsqu'on l'assigne. Le fait d'ajouter ces parenthèses assignera la valeur de retour du gestionnaire d'événement. Cette valeur sera souvent<code> undefined </code>dans ces cas alors que l'on aurait souhaité obtenir le gestionnaire d'événement.</p>
+Une erreur faite souvent lorsque l'on commence à utiliser JavaScript est d'ajouter des parenthèses et/ou des paramètres à la fin de la variable. Cela revient à appeler le gestionnaire d'événement lorsqu'on l'assigne. Le fait d'ajouter ces parenthèses assignera la valeur de retour du gestionnaire d'événement. Cette valeur sera souvent` undefined `dans ces cas alors que l'on aurait souhaité obtenir le gestionnaire d'événement.
 
-<pre class="brush: js">document.form1.button1.onclick = setBGColor();
-</pre>
+```js
+document.form1.button1.onclick = setBGColor();
+```
 
-<p>Afin de passer des paramètres à un gestionnaire d'événements, le gestionnaire doit être enveloppé dans une autre fonction, comme dans l'exemple suivant :</p>
+Afin de passer des paramètres à un gestionnaire d'événements, le gestionnaire doit être enveloppé dans une autre fonction, comme dans l'exemple suivant :
 
-<pre class="brush: js">document.form1.button1.onclick = function() {
+```js
+document.form1.button1.onclick = function() {
    setBGColor('une valeur');
 };
-</pre>
+```
 
-<h2 id="Les_fonctions_de_bloc">Les fonctions de bloc</h2>
+## Les fonctions de bloc
 
-<p>En <a href="/fr/docs/Web/JavaScript/Reference/Strict_mode">mode strict</a>, à partir d'ES2015 (ES6), la portée des fonctions définies dans un bloc est limitée à ce bloc. Avant ES2015, il était interdit d'utiliser les fonctions de bloc en mode strict..</p>
+En [mode strict](/fr/docs/Web/JavaScript/Reference/Strict_mode), à partir d'ES2015 (ES6), la portée des fonctions définies dans un bloc est limitée à ce bloc. Avant ES2015, il était interdit d'utiliser les fonctions de bloc en mode strict..
 
-<pre class="brush: js">'use strict';
+```js
+'use strict';
 
 function f() {
   return 1;
@@ -697,129 +696,105 @@ function f() {
 f() === 1; // true
 
 // f() === 2 en mode non-strict
-</pre>
+```
 
-<h3 id="Les_fonctions_de_bloc_dans_du_code_non-strict">Les fonctions de bloc dans du code non-strict</h3>
+### Les fonctions de bloc dans du code non-strict
 
-<p>Non.</p>
+Non.
 
-<p>Dans du code non-strict, les déclarations de fonctions placées dans des blocs peuvent se comporter de façon étrange :</p>
+Dans du code non-strict, les déclarations de fonctions placées dans des blocs peuvent se comporter de façon étrange :
 
-<pre class="brush: js">if (onDevraitDéfinirZéro) {
+```js
+if (onDevraitDéfinirZéro) {
    function zéro() { // DANGER: risque de compatibilité
       console.log("Voici zéro.");
    }
 }
-</pre>
+```
 
-<p>ES2015 indique que si <code>onDevraitDéfinirZéro</code> vaut <code>false</code>, <code>zéro</code> ne devrait jamais être défini car le bloc n'est jamais exécuté. En revanche, c'est une nouveauté liée à cette version du standard, non spécifiée auparavant. Certains navigateurs définissent <code>zéro</code> que le bloc soit exécuté ou non.</p>
+ES2015 indique que si `onDevraitDéfinirZéro` vaut `false`, `zéro` ne devrait jamais être défini car le bloc n'est jamais exécuté. En revanche, c'est une nouveauté liée à cette version du standard, non spécifiée auparavant. Certains navigateurs définissent `zéro` que le bloc soit exécuté ou non.
 
-<p>En <a href="/fr/docs/Web/JavaScript/Reference/Strict_mode">mode strict</a>, tous les navigateurs qui prennent en charge ES2015 gère cela de la même façon : <code>zéro</code> est uniquement défini si <code>onDevraitDéfinirZéro</code> vaut <code>true</code> et uniquement dans la portée du bloc induit par <code>if</code>.</p>
+En [mode strict](/fr/docs/Web/JavaScript/Reference/Strict_mode), tous les navigateurs qui prennent en charge ES2015 gère cela de la même façon : `zéro` est uniquement défini si `onDevraitDéfinirZéro` vaut `true` et uniquement dans la portée du bloc induit par `if`.
 
-<p>Une méthode plus sûre est d'utiliser des expressions de fonction :</p>
+Une méthode plus sûre est d'utiliser des expressions de fonction :
 
-<pre class="brush: js">var zéro;
+```js
+var zéro;
 if (0) {
    zéro = function() {
       console.log("Voici zéro.");
    };
 }
-</pre>
+```
 
-<h2 id="Exemples_2">Exemples</h2>
+## Exemples
 
-<h3 id="Renvoyer_un_nombre_formaté">Renvoyer un nombre formaté</h3>
+### Renvoyer un nombre formaté
 
-<p>La fonction qui suit renvoie une chaîne de caractères contenant la représentation formatée d'un nombre avec un certain nombre de zéros préfixant le nombre.</p>
+La fonction qui suit renvoie une chaîne de caractères contenant la représentation formatée d'un nombre avec un certain nombre de zéros préfixant le nombre.
 
-<pre class="brush: js">// Cette fonction renvoie une chaîne de caractères complétée par un préfixe composé de zéros
+```js
+// Cette fonction renvoie une chaîne de caractères complétée par un préfixe composé de zéros
 function padZeros(num, totalLen) {
    var numStr = num.toString();             // On initialise la valeur à renvoyer en chaîne de caractères
    var numZeros = totalLen - numStr.length; // On calcule le nombre de zéros
-   for (var i = 1; i &lt;= numZeros; i++) {
+   for (var i = 1; i <= numZeros; i++) {
       numStr = "0" + numStr;
    }
    return numStr;
 }
-</pre>
+```
 
-<p>Les instructions qui suivent utilisent cette fonction</p>
+Les instructions qui suivent utilisent cette fonction
 
-<pre class="brush: js">var resultat;
+```js
+var resultat;
 resultat = padZeros(42,4); // renvoie "0042"
 resultat = padZeros(42,2); // renvoie "42"
 resultat = padZeros(5,4);  // renvoie "0005"
-</pre>
+```
 
-<h3 id="Déterminer_si_une_fonction_existe">Déterminer si une fonction existe</h3>
+### Déterminer si une fonction existe
 
-<p>Il est possible de déterminer si oui ou non une fonction existe en utilisant l'opérateur <code>typeof</code>. Dans l'exemple qui suit, on teste pour savoir si l'objet<code> window</code> possède une propriété appelé <code>noFunc</code> qui serait une fonction. Si c'est le cas, elle sera utilisée, sinon on fera autre chose.</p>
+Il est possible de déterminer si oui ou non une fonction existe en utilisant l'opérateur `typeof`. Dans l'exemple qui suit, on teste pour savoir si l'objet` window` possède une propriété appelé `noFunc` qui serait une fonction. Si c'est le cas, elle sera utilisée, sinon on fera autre chose.
 
-<pre class="brush: js"> if ('function' === typeof window.noFunc) {
+```js
+ if ('function' === typeof window.noFunc) {
    // utilisation de noFunc()
  } else {
    // faire autre chose
  }
-</pre>
-
-<p>Il est à noter que, dans le test <code>if</code>, on utilise une référence à <code>noFunc</code> - il n'y a pas de parenthèses après le nom de la fonction, la fonction n'est donc pas appelé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.0</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-13', 'Function Definition')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-function-definitions', 'Function definitions')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Nouveautés : fonctions fléchées, générateurs, paramètres par défaut, paramètres du reste</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#', 'function*')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-arrow-function-definitions', 'Arrow Function Definitions')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.functions")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>L'instruction {{jsxref("Instructions/function", "function")}}</li>
- <li>L'expression {{jsxref("Opérateurs/L_opérateur_function", "function")}}</li>
- <li>L'instruction {{jsxref("Instructions/function*", "function*")}}</li>
- <li>L'expression {{jsxref("Opérateurs/function*", "function*")}}</li>
- <li>{{jsxref("Function")}}</li>
- <li>{{jsxref("GeneratorFunction")}}</li>
- <li>{{jsxref("Fonctions/Fonctions_fléchées", "Les fonctions fléchées")}}</li>
- <li>{{jsxref("Fonctions/Valeurs_par_défaut_des_arguments", "Les paramètres par défaut","",1)}}</li>
- <li>{{jsxref("Fonctions/paramètres_du_reste", "Les paramètres du reste","",1)}}</li>
- <li>L'objet {{jsxref("Fonctions/arguments", "arguments")}}</li>
- <li>{{jsxref("Fonctions/get", "getter")}}</li>
- <li>{{jsxref("Fonctions/set", "setter")}}</li>
- <li>{{jsxref("Fonctions/Définition_de_méthode", "Les définitions de méthodes","",1)}}</li>
- <li><a href="/fr/docs/Web/JavaScript/Reference/Fonctions">Fonctions et portée des fonctions</a></li>
-</ul>
+```
+
+Il est à noter que, dans le test `if`, on utilise une référence à `noFunc` - il n'y a pas de parenthèses après le nom de la fonction, la fonction n'est donc pas appelée.
+
+## Spécifications
+
+| Spécification                                                                                                    | État                     | Commentaires                                                                             |
+| ---------------------------------------------------------------------------------------------------------------- | ------------------------ | ---------------------------------------------------------------------------------------- |
+| {{SpecName('ES1')}}                                                                                         | {{Spec2('ES1')}}     | Définition initiale. Implémentée avec JavaScript 1.0                                     |
+| {{SpecName('ES5.1', '#sec-13', 'Function Definition')}}                                         | {{Spec2('ES5.1')}} |                                                                                          |
+| {{SpecName('ES6', '#sec-function-definitions', 'Function definitions')}}                 | {{Spec2('ES6')}}     | Nouveautés : fonctions fléchées, générateurs, paramètres par défaut, paramètres du reste |
+| {{SpecName('ES6', '#', 'function*')}}                                                                 | {{Spec2('ES6')}}     | Définition initiale.                                                                     |
+| {{SpecName('ES6', '#sec-arrow-function-definitions', 'Arrow Function Definitions')}} | {{Spec2('ES6')}}     | Définition initiale.                                                                     |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.functions")}}
+
+## Voir aussi
+
+- L'instruction {{jsxref("Instructions/function", "function")}}
+- L'expression {{jsxref("Opérateurs/L_opérateur_function", "function")}}
+- L'instruction {{jsxref("Instructions/function*", "function*")}}
+- L'expression {{jsxref("Opérateurs/function*", "function*")}}
+- {{jsxref("Function")}}
+- {{jsxref("GeneratorFunction")}}
+- {{jsxref("Fonctions/Fonctions_fléchées", "Les fonctions fléchées")}}
+- {{jsxref("Fonctions/Valeurs_par_défaut_des_arguments", "Les paramètres par défaut","",1)}}
+- {{jsxref("Fonctions/paramètres_du_reste", "Les paramètres du reste","",1)}}
+- L'objet {{jsxref("Fonctions/arguments", "arguments")}}
+- {{jsxref("Fonctions/get", "getter")}}
+- {{jsxref("Fonctions/set", "setter")}}
+- {{jsxref("Fonctions/Définition_de_méthode", "Les définitions de méthodes","",1)}}
+- [Fonctions et portée des fonctions](/fr/docs/Web/JavaScript/Reference/Fonctions)
diff --git a/files/fr/web/javascript/reference/functions/method_definitions/index.md b/files/fr/web/javascript/reference/functions/method_definitions/index.md
index 13c6fdf0fa..a0e36dc8e0 100644
--- a/files/fr/web/javascript/reference/functions/method_definitions/index.md
+++ b/files/fr/web/javascript/reference/functions/method_definitions/index.md
@@ -11,68 +11,70 @@ tags:
 translation_of: Web/JavaScript/Reference/Functions/Method_definitions
 original_slug: Web/JavaScript/Reference/Fonctions/Définition_de_méthode
 ---
-<div>{{JsSidebar("Functions")}}</div>
+{{JsSidebar("Functions")}}
 
-<p>Avec ECMAScript 2015 (ES6), il est possible d'utiliser une notation plus courte pour définir des méthodes au sein des littéraux objets. On peut ainsi définir plus rapidement une fonction qui sera utilisée comme méthode.</p>
+Avec ECMAScript 2015 (ES6), il est possible d'utiliser une notation plus courte pour définir des méthodes au sein des littéraux objets. On peut ainsi définir plus rapidement une fonction qui sera utilisée comme méthode.
 
-<div>{{EmbedInteractiveExample("pages/js/functions-definitions.html")}}</div>
+{{EmbedInteractiveExample("pages/js/functions-definitions.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">var obj = {
-  <var>property</var>( <var>parameters…</var> ) {},
-  *<var>generator</var>( <var>parameters…</var> ) {},
-  async property( <var>parameters…</var> ) {},
-  async* generator( <var>parameters…</var> ) {},
+    var obj = {
+      property( parameters… ) {},
+      *generator( parameters… ) {},
+      async property( parameters… ) {},
+      async* generator( parameters… ) {},
 
-  // avec les noms calculés :
-  [property]( <var>parameters…</var> ) {},
-  *[generator]( <var>parameters…</var> ) {},
-  async [property]( <var>parameters…</var> ) {},
+      // avec les noms calculés :
+      [property]( parameters… ) {},
+      *[generator]( parameters… ) {},
+      async [property]( parameters… ) {},
 
-  // avec la syntaxe pour les accesseurs
-  // mutateurs :
-  get <var>property</var>() {},
-  set <var>property</var>(<var>value</var>) {}
-};
-</pre>
+      // avec la syntaxe pour les accesseurs
+      // mutateurs :
+      get property() {},
+      set property(value) {}
+    };
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La notation raccourcie est semblable à la syntaxe introduite par ECMAScript 5 pour les <a href="/fr/docs/Web/JavaScript/Reference/Fonctions/get">accesseurs</a> et <a href="/fr/docs/Web/JavaScript/Reference/Fonctions/set">mutateurs</a>.</p>
+La notation raccourcie est semblable à la syntaxe introduite par ECMAScript 5 pour les [accesseurs](/fr/docs/Web/JavaScript/Reference/Fonctions/get) et [mutateurs](/fr/docs/Web/JavaScript/Reference/Fonctions/set).
 
-<p>Le code suivant :</p>
+Le code suivant :
 
-<pre class="brush: js">var obj = {
+```js
+var obj = {
   toto: function() {
     /* du code */
   },
   truc: function() {
     /* du code */
   }
-};</pre>
+};
+```
 
-<p>Peut désormais être raccourci en :</p>
+Peut désormais être raccourci en :
 
-<pre class="brush: js">var obj = {
+```js
+var obj = {
   toto() {
     /* du code */
   },
   truc() {
     /* du code */
   }
-};</pre>
+};
+```
 
-<h3 id="Notation_raccourcie_pour_les_générateurs">Notation raccourcie pour les générateurs</h3>
+### Notation raccourcie pour les générateurs
 
-<p><a href="/fr/docs/Web/JavaScript/Reference/Instructions/function*">Les générateurs</a> sont des méthodes et peuvent donc être définis en utilisant la notation raccourci. Lorsqu'on les utilise :</p>
+[Les générateurs](/fr/docs/Web/JavaScript/Reference/Instructions/function*) sont des méthodes et peuvent donc être définis en utilisant la notation raccourci. Lorsqu'on les utilise :
 
-<ul>
- <li>L'astérisque de la notation raccourcie doit être située avant le nom de la propriété pour le générateur. Autrement dit, <code>* g(){}</code> fonctionnera mais <code>g*(){}</code> ne fonctionnera pas.</li>
- <li>Les définitions des méthodes qui ne sont pas des générateurs ne peuvent pas contenir le mot-clé <code>yield</code>. Cela signifie que <a href="/fr/docs/Web/JavaScript/Reference/Instructions/Fonction_génératrice_historique">l'ancienne syntaxe pour les générateurs</a> ne fonctionnera pas et déclenchera une exception {{jsxref("SyntaxError")}}. Il faut toujours utiliser <code>yield</code> avec l'astérisque (<code>*</code>).</li>
-</ul>
+- L'astérisque de la notation raccourcie doit être située avant le nom de la propriété pour le générateur. Autrement dit, `* g(){}` fonctionnera mais `g*(){}` ne fonctionnera pas.
+- Les définitions des méthodes qui ne sont pas des générateurs ne peuvent pas contenir le mot-clé `yield`. Cela signifie que [l'ancienne syntaxe pour les générateurs](/fr/docs/Web/JavaScript/Reference/Instructions/Fonction_génératrice_historique) ne fonctionnera pas et déclenchera une exception {{jsxref("SyntaxError")}}. Il faut toujours utiliser `yield` avec l'astérisque (`*`).
 
-<pre class="brush: js">// Notation utilisant une propriété nommée (avant-ES2015)
+```js
+// Notation utilisant une propriété nommée (avant-ES2015)
 var obj2 = {
   g: function*() {
     var index = 0;
@@ -92,13 +94,15 @@ var obj2 = {
 
 var it = obj2.g();
 console.log(it.next().value); // 0
-console.log(it.next().value); // 1</pre>
+console.log(it.next().value); // 1
+```
 
-<h3 id="Méthodes_asynchrones_avec_notation_raccourcie">Méthodes asynchrones avec notation raccourcie</h3>
+### Méthodes asynchrones avec notation raccourcie
 
-<p><a href="/fr/docs/Web/JavaScript/Reference/Instructions/async_function">Les méthodes asynchrones</a> peuvent également être définies grâce à une syntaxe raccourcie.</p>
+[Les méthodes asynchrones](/fr/docs/Web/JavaScript/Reference/Instructions/async_function) peuvent également être définies grâce à une syntaxe raccourcie.
 
-<pre class="brush: js">// On utilise une propriété nommée
+```js
+// On utilise une propriété nommée
 var obj3 = {
   f: async function () {
     await une_promesse;
@@ -112,13 +116,14 @@ var obj3 = {
     await une_promesse;
   }
 };
-</pre>
+```
 
-<h3 id="Méthodes_génératrices_asynchrones">Méthodes génératrices asynchrones</h3>
+### Méthodes génératrices asynchrones
 
-<p>Les méthodes génératrices peuvent également être asynchrones (cf. <code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/async_function">async</a></code>) :</p>
+Les méthodes génératrices peuvent également être asynchrones (cf. [`async`](/fr/docs/Web/JavaScript/Reference/Instructions/async_function)) :
 
-<pre class="brush: js">var obj4 = {
+```js
+var obj4 = {
   f: async function* () {
     yield 1;
     yield 2;
@@ -134,13 +139,15 @@ var obj4 = {
     yield 2;
     yield 3;
   }
-};</pre>
+};
+```
 
-<h3 id="Les_définitions_de_méthodes_ne_sont_pas_constructibles">Les définitions de méthodes ne sont pas constructibles</h3>
+### Les définitions de méthodes ne sont pas constructibles
 
-<p>Les définitions de méthodes ne sont pas des constructeurs et si on tente de les instancier, cela provoquera une exception {{jsxref("TypeError")}}.</p>
+Les définitions de méthodes ne sont pas des constructeurs et si on tente de les instancier, cela provoquera une exception {{jsxref("TypeError")}}.
 
-<pre class="brush: js">var obj = {
+```js
+var obj = {
   méthode() {},
 };
 new obj.méthode; // TypeError: obj.méthode is not a constructor
@@ -149,24 +156,26 @@ var obj = {
   * g() {}
 };
 new obj.g; // TypeError: obj.g is not a constructuer (changé avec ES2016)
-</pre>
+```
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Cas_de_test">Cas de test</h3>
+### Cas de test
 
-<pre class="brush: js">var obj = {
+```js
+var obj = {
   a : "toto",
   b(){ return this.a; }
 };
 console.log(obj.b()); // "toto"
-</pre>
+```
 
-<h3 id="Noms_de_propriétés_calculés">Noms de propriétés calculés</h3>
+### Noms de propriétés calculés
 
-<p>Cette notation raccourcie peut également être utilisée avec des noms de propriétés calculés.</p>
+Cette notation raccourcie peut également être utilisée avec des noms de propriétés calculés.
 
-<pre class="brush: js">var bar = {
+```js
+var bar = {
   toto0 : function (){return 0;},
   toto1(){return 1;},
   ["toto" + 2](){return 2;},
@@ -174,43 +183,23 @@ console.log(obj.b()); // "toto"
 
 console.log(bar.toto0()); // 0
 console.log(bar.toto1()); // 1
-console.log(bar.toto2()); // 2</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-method-definitions', 'Method definitions')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES2016', '#sec-method-definitions', 'Method definitions')}}</td>
-   <td>{{Spec2('ES2016')}}</td>
-   <td>Les méthodes génératrices ne doivent pas implémenter la trappe [[Construct]] et déclencher une exception lorsqu'elles sont utilisées avec <code>new</code>.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-method-definitions', 'Method definitions')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.functions.method_definitions")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li><code><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_get">get</a></code></li>
- <li><code><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_set">set</a></code></li>
- <li><a href="/fr/docs/Web/JavaScript/Reference/Grammaire_lexicale">Grammaire lexicale de JavaScript</a></li>
-</ul>
+console.log(bar.toto2()); // 2
+```
+
+## Spécifications
+
+| Spécification                                                                                    | État                         | Commentaires                                                                                                                                     |
+| ------------------------------------------------------------------------------------------------ | ---------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
+| {{SpecName('ES2015', '#sec-method-definitions', 'Method definitions')}} | {{Spec2('ES2015')}}     | Définition initiale.                                                                                                                             |
+| {{SpecName('ES2016', '#sec-method-definitions', 'Method definitions')}} | {{Spec2('ES2016')}}     | Les méthodes génératrices ne doivent pas implémenter la trappe [[Construct]] et déclencher une exception lorsqu'elles sont utilisées avec `new`. |
+| {{SpecName('ESDraft', '#sec-method-definitions', 'Method definitions')}} | {{Spec2('ESDraft')}} |                                                                                                                                                  |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.functions.method_definitions")}}
+
+## Voir aussi
+
+- [`get`](/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_get)
+- [`set`](/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_set)
+- [Grammaire lexicale de JavaScript](/fr/docs/Web/JavaScript/Reference/Grammaire_lexicale)
diff --git a/files/fr/web/javascript/reference/functions/rest_parameters/index.md b/files/fr/web/javascript/reference/functions/rest_parameters/index.md
index 90984a9267..6597da94f3 100644
--- a/files/fr/web/javascript/reference/functions/rest_parameters/index.md
+++ b/files/fr/web/javascript/reference/functions/rest_parameters/index.md
@@ -9,24 +9,26 @@ tags:
 translation_of: Web/JavaScript/Reference/Functions/rest_parameters
 original_slug: Web/JavaScript/Reference/Fonctions/paramètres_du_reste
 ---
-<div>{{jsSidebar("Functions")}}</div>
+{{jsSidebar("Functions")}}
 
-<p>Cette syntaxe permet de représenter un nombre indéfini d'arguments sous forme d'un tableau.</p>
+Cette syntaxe permet de représenter un nombre indéfini d'arguments sous forme d'un tableau.
 
-<div>{{EmbedInteractiveExample("pages/js/functions-restparameters.html")}}</div>
+{{EmbedInteractiveExample("pages/js/functions-restparameters.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="brush: js">function f(a, b, ...lesArguments) {
+```js
+function f(a, b, ...lesArguments) {
   // ...
 }
-</pre>
+```
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Si le dernier paramètre nommé fourni à la fonction est préfixé de <code>...</code> (trois points), il devient un tableau dont les éléments entre <code>0</code> (inclus) et <code>lesArguments.length</code> (exclus) sont fournis comme autres arguments à la fonction.</p>
+Si le dernier paramètre nommé fourni à la fonction est préfixé de `...` (trois points), il devient un tableau dont les éléments entre `0` (inclus) et `lesArguments.length` (exclus) sont fournis comme autres arguments à la fonction.
 
-<pre class="brush: js">function maFonction(a, b, ...plusDArguments) {
+```js
+function maFonction(a, b, ...plusDArguments) {
   console.log("a", a);
   console.log("b", b);
   console.log("plusDArguments", plusDArguments);
@@ -36,23 +38,23 @@ maFonction("un", "deux", "trois", "quatre", "cinq");
 // affichera ceci dans la console :
 // a, "un"
 // b, "deux"
-// plusDArguments, ["trois", "quatre", "cinq"]</pre>
+// plusDArguments, ["trois", "quatre", "cinq"]
+```
 
-<h3 id="Les_différences_entre_les_paramètres_du_reste_et_l'objet_arguments">Les différences entre les paramètres du reste et l'objet <code>arguments</code></h3>
+### Les différences entre les paramètres du reste et l'objet `arguments`
 
-<p>Il y a trois principales différences entre les paramètres du reste et l'objet {{jsxref("Fonctions/arguments","arguments")}} :</p>
+Il y a trois principales différences entre les paramètres du reste et l'objet {{jsxref("Fonctions/arguments","arguments")}} :
 
-<ul>
- <li>les paramètres du reste sont uniquement ceux qui ne possèdent pas de noms à part entière (autrement dit ceux qui ne sont pas formellement définis dans l'expression de fonction), l'objet <code>arguments</code> contient chaque argument passé à la fonction</li>
- <li>l'objet <code>arguments</code> n'est pas, à strictement parler, un tableau. Le paramètre représentant les arguments restant est une instance d'{{jsxref("Array","Array")}} à laquelle on peut appliquer directement des méthodes comme {{jsxref("Array/sort","sort")}}, {{jsxref("Array/map","map")}}, {{jsxref("Array/forEach","forEach")}} ou {{jsxref("Array/pop","pop")}}</li>
- <li>l'objet <code>arguments</code> possède des fonctionnalités spécifiques (comme, par exemple, la propriété <code>callee</code>)</li>
-</ul>
+- les paramètres du reste sont uniquement ceux qui ne possèdent pas de noms à part entière (autrement dit ceux qui ne sont pas formellement définis dans l'expression de fonction), l'objet `arguments` contient chaque argument passé à la fonction
+- l'objet `arguments` n'est pas, à strictement parler, un tableau. Le paramètre représentant les arguments restant est une instance d'{{jsxref("Array","Array")}} à laquelle on peut appliquer directement des méthodes comme {{jsxref("Array/sort","sort")}}, {{jsxref("Array/map","map")}}, {{jsxref("Array/forEach","forEach")}} ou {{jsxref("Array/pop","pop")}}
+- l'objet `arguments` possède des fonctionnalités spécifiques (comme, par exemple, la propriété `callee`)
 
-<h3 id="Convertir_arguments_en_un_tableau">Convertir <code>arguments</code> en un tableau</h3>
+### Convertir `arguments` en un tableau
 
-<p>Ces paramètres ont été introduits afin de réduire le code passe-partout souvent induit par les arguments.</p>
+Ces paramètres ont été introduits afin de réduire le code passe-partout souvent induit par les arguments.
 
-<pre class="brush: js">// Avant les paramètres du reste, on observait souvent ce style de code :
+```js
+// Avant les paramètres du reste, on observait souvent ce style de code :
 function f(a, b){
   var args = Array.prototype.slice.call(arguments, f.length);
   // ou encore
@@ -71,36 +73,40 @@ function f(...args) {
   var tabNormal = args;
   var premier = tabNormal.shift();
 }
-</pre>
+```
 
-<h3 id="La_décomposition_sur_les_paramètres_du_reste">La décomposition sur les paramètres du reste</h3>
+### La décomposition sur les paramètres du reste
 
-<p>On peut également décomposer les paramètres du reste en variables distinctes :</p>
+On peut également décomposer les paramètres du reste en variables distinctes :
 
-<pre class="brush: js">function f(...[a, b, c]) {
+```js
+function f(...[a, b, c]) {
   return a + b + c;
 }
 
 f(1);          // NaN (b et c valent undefined)
 f(1, 2, 3);    // 6
 f(1, 2, 3, 4); // 6, le dernier paramètre n'est pas décomposé
-</pre>
+```
 
-<p>Vous pouvez également accéder aux éléments des paramètres du reste :</p>
+Vous pouvez également accéder aux éléments des paramètres du reste :
 
-<pre class="brush: js">function fun1(...lesArguments) {
+```js
+function fun1(...lesArguments) {
     console.log("valeur", lesArguments[0][0]);
 }
 
 fun1([5, 2], [5, 4]); // 5
 fun1([8, 2]); // 8
-fun1([9, 6, 7]); // 9</pre>
+fun1([9, 6, 7]); // 9
+```
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<p>S'il n'y a qu'un seul argument qui est décomposé par la syntaxe, la valeur sera toujours un tableau :</p>
+S'il n'y a qu'un seul argument qui est décomposé par la syntaxe, la valeur sera toujours un tableau :
 
-<pre class="brush: js">function maFonction(a, b, ...autres);
+```js
+function maFonction(a, b, ...autres);
   console.log(a);
   console.log(b);
   console.log(autres);
@@ -111,11 +117,12 @@ maFonction("un", "deux", "trois");
 // "un"
 // "deux"
 // ["trois"]
-</pre>
+```
 
-<p>De même, s'il n'y a pas suffisamment d'arguments, ce sera un tableau vide :</p>
+De même, s'il n'y a pas suffisamment d'arguments, ce sera un tableau vide :
 
-<pre class="brush: js">function maFonction(a, b, ...autres);
+```js
+function maFonction(a, b, ...autres);
   console.log(a);
   console.log(b);
   console.log(autres);
@@ -125,22 +132,25 @@ maFonction("un", "deux");
 // affichera ceci dans la console
 // "un"
 // "deux"
-// []</pre>
+// []
+```
 
-<p><code>lesArguments</code> est un tableau et dispose donc d'une propriété <code>length</code> permettant de compter ses éléments :</p>
+`lesArguments` est un tableau et dispose donc d'une propriété `length` permettant de compter ses éléments :
 
-<pre class="brush: js">function fun1(...lesArguments) {
+```js
+function fun1(...lesArguments) {
   console.log(lesArguments.length);
 }
 
 fun1();  // 0
 fun1(5); // 1
 fun1(5, 6, 7); // 3
-</pre>
+```
 
-<p>Dans l'exemple qui suit, on utilise le paramètre Rest pour collecter les arguments après le premier pour les multiplier par le premier :</p>
+Dans l'exemple qui suit, on utilise le paramètre Rest pour collecter les arguments après le premier pour les multiplier par le premier :
 
-<pre class="brush: js">function multiplier(facteur, ...lesArguments) {
+```js
+function multiplier(facteur, ...lesArguments) {
   return lesArguments.map(function (element) {
     return facteur * element;
   });
@@ -148,11 +158,12 @@ fun1(5, 6, 7); // 3
 
 var arr = multiplier(2, 1, 2, 3);
 console.log(arr); // [2, 4, 6]
-</pre>
+```
 
-<p>L'exemple qui suit illustre comment on peut utiliser des méthodes de <code>Array</code> sur le paramètre Rest mais pas sur l'objet <code>arguments</code> :</p>
+L'exemple qui suit illustre comment on peut utiliser des méthodes de `Array` sur le paramètre Rest mais pas sur l'objet `arguments` :
 
-<pre class="brush: js">function trierParamRest(...lesArguments) {
+```js
+function trierParamRest(...lesArguments) {
   var argumentsTriés = lesArguments.sort();
   return argumentsTriés;
 }
@@ -166,51 +177,35 @@ function trierArguments() {
 
 // renvoie une exception TypeError: arguments.sort n'est pas une function
 console.log(trierArguments(5,3,7,1));
-</pre>
+```
 
-<p>Pour utiliser les méthodes propres aux instances d'<code>Array</code> sur l'objet <code>arguments</code>, il est nécessaire de le convertir.</p>
+Pour utiliser les méthodes propres aux instances d'`Array` sur l'objet `arguments`, il est nécessaire de le convertir.
 
-<pre class="brush: js">function trierAguments() {
+```js
+function trierAguments() {
   var args = Array.from(arguments);
   var argumentsTriés = args.sort();
   return argumentsTriés;
 }
 console.log(trierArguments(5, 3, 7, 1)); // [1, 3, 5, 7]
-</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-function-definitions', 'Function Definitions')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-function-definitions', 'Function Definitions')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.functions.rest_parameters")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>L'objet {{jsxref("Fonctions/arguments","arguments")}}</li>
- <li>{{jsxref("Array","Array")}}</li>
- <li>{{jsxref("Fonctions","Les fonctions et leurs portées","",1)}}</li>
- <li>{{jsxref("Opérateurs/Syntaxe_décomposition","L'opérateur de décomposition","",1)}}</li>
- <li><a class="external" href="https://wiki.ecmascript.org/doku.php?id=harmony:rest_parameters">Proposition originale sur ecmascript.org</a> (en anglais)</li>
- <li><a class="external" href="https://javascriptweblog.wordpress.com/2011/01/18/javascripts-arguments-object-and-beyond/">JavaScript arguments object and beyond</a> (article en anglais)</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                        | État                         | Commentaires         |
+| ---------------------------------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ES6', '#sec-function-definitions', 'Function Definitions')}}     | {{Spec2('ES6')}}         | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-function-definitions', 'Function Definitions')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.functions.rest_parameters")}}
+
+## Voir aussi
+
+- L'objet {{jsxref("Fonctions/arguments","arguments")}}
+- {{jsxref("Array","Array")}}
+- {{jsxref("Fonctions","Les fonctions et leurs portées","",1)}}
+- {{jsxref("Opérateurs/Syntaxe_décomposition","L'opérateur de décomposition","",1)}}
+- [Proposition originale sur ecmascript.org](https://wiki.ecmascript.org/doku.php?id=harmony:rest_parameters) (en anglais)
+- [JavaScript arguments object and beyond](https://javascriptweblog.wordpress.com/2011/01/18/javascripts-arguments-object-and-beyond/) (article en anglais)
diff --git a/files/fr/web/javascript/reference/functions/set/index.md b/files/fr/web/javascript/reference/functions/set/index.md
index 2e7778875e..4ef288d7bc 100644
--- a/files/fr/web/javascript/reference/functions/set/index.md
+++ b/files/fr/web/javascript/reference/functions/set/index.md
@@ -9,82 +9,81 @@ tags:
 translation_of: Web/JavaScript/Reference/Functions/set
 original_slug: Web/JavaScript/Reference/Fonctions/set
 ---
-<div>{{jsSidebar("Functions")}}</div>
+{{jsSidebar("Functions")}}
 
-<p>La syntaxe <strong><code>set</code></strong> permet de lier une propriété d'un objet à une fonction qui sera appelée à chaque tentative de modification de cette propriété.</p>
+La syntaxe **`set`** permet de lier une propriété d'un objet à une fonction qui sera appelée à chaque tentative de modification de cette propriété.
 
-<div>{{EmbedInteractiveExample("pages/js/functions-setter.html")}}</div>
+{{EmbedInteractiveExample("pages/js/functions-setter.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">{set <em>prop</em>(<em>val</em>) { . . .}}
-{set [expression](<em>val</em>) { . . .}}</pre>
+    {set prop(val) { . . .}}
+    {set [expression](val) { . . .}}
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>prop</code></dt>
- <dd>Le nom de la propriété à lier à la fonction.</dd>
- <dt><code>val</code></dt>
- <dd>Un alias pour la variable qui contient la valeur qu'on souhaiterait affecter à <code>prop.</code></dd>
- <dt><code>expression</code></dt>
- <dd>Avec ECMAScript 2015, il est également possible d'utiliser des expressions pour utiliser un nom de propriété calculé à lier à la fonction.</dd>
-</dl>
+- `prop`
+  - : Le nom de la propriété à lier à la fonction.
+- `val`
+  - : Un alias pour la variable qui contient la valeur qu'on souhaiterait affecter à `prop.`
+- `expression`
+  - : Avec ECMAScript 2015, il est également possible d'utiliser des expressions pour utiliser un nom de propriété calculé à lier à la fonction.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>En JavaScript, un mutateur (ou <em>setter</em> en anglais) peut être utiisé afin d'exécuter une fonction à chaque fois qu'on souhaite modifier la valeur d'une propriété donnée. La plupart du temps, les mutateurs sont utilisés avec les accesseurs (<em>getters</em>) afin de créer une pseudo-propriété. Il n'est pas possible d'avoir à la fois un mutateur et une valeur donnée pour une même propriété.</p>
+En JavaScript, un mutateur (ou _setter_ en anglais) peut être utiisé afin d'exécuter une fonction à chaque fois qu'on souhaite modifier la valeur d'une propriété donnée. La plupart du temps, les mutateurs sont utilisés avec les accesseurs (_getters_) afin de créer une pseudo-propriété. Il n'est pas possible d'avoir à la fois un mutateur et une valeur donnée pour une même propriété.
 
-<p>On notera que <code>set</code> :</p>
+On notera que `set` :
 
-<div>
-<ul>
- <li>peut avoir un identifiant qui est soit un nombre soit une chaîne de caractères</li>
- <li>doit avoir exactement un paramètre (voir l'article « <a class="external" href="https://whereswalden.com/2010/08/22/incompatible-es5-change-literal-getter-and-setter-functions-must-now-have-exactly-zero-or-one-arguments/" rel="external nofollow">Incompatible <abbr title="ECMAScript 5th edition">ES5</abbr> change: literal getter and setter functions must now have exactly zero or one arguments</a> » (en anglais) pour plus d'informations)</li>
- <li>ne doit pas apparaître dans un littéral objet qui possède un autre <code>set</code> ou une autre propriété avec la même clé :<br>
-  ( <code>{ set x(v) { }, set x(v) { } }</code> et <code>{ x: ..., set x(v) { } }</code> seront interdits)</li>
-</ul>
-</div>
+- peut avoir un identifiant qui est soit un nombre soit une chaîne de caractères
+- doit avoir exactement un paramètre (voir l'article « [Incompatible ES5 change: literal getter and setter functions must now have exactly zero or one arguments](https://whereswalden.com/2010/08/22/incompatible-es5-change-literal-getter-and-setter-functions-must-now-have-exactly-zero-or-one-arguments/) » (en anglais) pour plus d'informations)
+- ne doit pas apparaître dans un littéral objet qui possède un autre `set` ou une autre propriété avec la même clé :
+  ( `{ set x(v) { }, set x(v) { } }` et `{ x: ..., set x(v) { } }` seront interdits)
 
-<p>On peut retirer un mutateur d'un objet grâce à l'opérateur {{jsxref("Opérateurs/L_opérateur_delete","delete")}}.</p>
+On peut retirer un mutateur d'un objet grâce à l'opérateur {{jsxref("Opérateurs/L_opérateur_delete","delete")}}.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Définir_un_mutateur_sur_de_nouveaux_objets_avec_un_littéral_objet">Définir un mutateur sur de nouveaux objets avec un littéral objet</h3>
+### Définir un mutateur sur de nouveaux objets avec un littéral objet
 
-<p>Dans l'exemple qui suit, on définit une pseudo-propriété <code>courant</code> pour un objet <code>o</code> qui, lorsqu'elle recevra une valeur, mettra à jour la propriété <code>log</code> avec la valeur reçue :</p>
+Dans l'exemple qui suit, on définit une pseudo-propriété `courant` pour un objet `o` qui, lorsqu'elle recevra une valeur, mettra à jour la propriété `log` avec la valeur reçue :
 
-<pre class="brush: js">var o = {
+```js
+var o = {
   set courant (str) {
     this.log[this.log.length] = str;
   },
   log: []
 }
-</pre>
+```
 
-<p>On notera que <code>courant</code> n'est pas défini. Toute tentative pour y accéder renverra <code>undefined</code>.</p>
+On notera que `courant` n'est pas défini. Toute tentative pour y accéder renverra `undefined`.
 
-<h3 id="Supprimer_un_mutateur_grâce_à_l'opérateur_delete">Supprimer un mutateur grâce à l'opérateur <code>delete</code></h3>
+### Supprimer un mutateur grâce à l'opérateur `delete`
 
-<p>Si on souhaite retirer un mutateur, on peut simplement utiliser l'opérateur {{jsxref("Opérateurs/L_opérateur_delete","delete")}} :</p>
+Si on souhaite retirer un mutateur, on peut simplement utiliser l'opérateur {{jsxref("Opérateurs/L_opérateur_delete","delete")}} :
 
-<pre class="brush: js">delete o.courant;
-</pre>
+```js
+delete o.courant;
+```
 
-<h3 id="Définir_un_mutateur_sur_un_objet_existant_avec_defineProperty">Définir un mutateur sur un objet existant avec <code>defineProperty</code></h3>
+### Définir un mutateur sur un objet existant avec `defineProperty`
 
-<p>On peut également ajouter un mutateur sur un objet d'ores et déjà créé. Pour cela, on utilisera la méthode {{jsxref("Object.defineProperty()")}}.</p>
+On peut également ajouter un mutateur sur un objet d'ores et déjà créé. Pour cela, on utilisera la méthode {{jsxref("Object.defineProperty()")}}.
 
-<pre class="brush: js">var o = { a:0 };
+```js
+var o = { a:0 };
 
 Object.defineProperty(o, "b", { set: function (x) { this.a = x / 2; } });
 
 o.b = 10; // On utilise le setter, qui affecte 10 / 2 (5) à 'a'
-console.log(o.a) // 5</pre>
+console.log(o.a) // 5
+```
 
-<h3 id="Utiliser_un_nom_de_propriété_calculé">Utiliser un nom de propriété calculé</h3>
+### Utiliser un nom de propriété calculé
 
-<pre class="brush: js">var expr = "toto";
+```js
+var expr = "toto";
 
 var obj = {
   bidule: "truc",
@@ -94,46 +93,25 @@ var obj = {
 console.log(obj.bidule); // "truc"
 obj.toto = "bidule";      // le mutateur est utilisé
 console.log(obj.bidule); // "bidule"
-</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-11.1.5', 'Object Initializer')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td>Définition initiale</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-method-definitions', 'Method definitions')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Ajout des noms de propriétés calculés</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-method-definitions', 'Method definitions')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.functions.set")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Fonctions/get","get")}}</li>
- <li>{{jsxref("Opérateurs/L_opérateur_delete","delete")}}</li>
- <li>{{jsxref("Object.defineProperty()")}}</li>
- <li>{{jsxref("Object.defineGetter", "__defineGetter__")}}</li>
- <li>{{jsxref("Object.defineSetter", "__defineSetter__")}}</li>
- <li><a href="/fr/docs/Web/JavaScript/Guide/Utiliser_les_objets#D.C3.A9finir_des_getters_et_setters">Définir des accesseurs et des mutateurs</a>, dans le Guide JavaScript</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                    | État                         | Commentaires                          |
+| ------------------------------------------------------------------------------------------------ | ---------------------------- | ------------------------------------- |
+| {{SpecName('ES5.1', '#sec-11.1.5', 'Object Initializer')}}                     | {{Spec2('ES5.1')}}     | Définition initiale                   |
+| {{SpecName('ES6', '#sec-method-definitions', 'Method definitions')}}     | {{Spec2('ES6')}}         | Ajout des noms de propriétés calculés |
+| {{SpecName('ESDraft', '#sec-method-definitions', 'Method definitions')}} | {{Spec2('ESDraft')}} |                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.functions.set")}}
+
+## Voir aussi
+
+- {{jsxref("Fonctions/get","get")}}
+- {{jsxref("Opérateurs/L_opérateur_delete","delete")}}
+- {{jsxref("Object.defineProperty()")}}
+- {{jsxref("Object.defineGetter", "__defineGetter__")}}
+- {{jsxref("Object.defineSetter", "__defineSetter__")}}
+- [Définir des accesseurs et des mutateurs](/fr/docs/Web/JavaScript/Guide/Utiliser_les_objets#D.C3.A9finir_des_getters_et_setters), dans le Guide JavaScript
diff --git a/files/fr/web/javascript/reference/global_objects/aggregateerror/index.md b/files/fr/web/javascript/reference/global_objects/aggregateerror/index.md
index 408d49a007..c649d30c9a 100644
--- a/files/fr/web/javascript/reference/global_objects/aggregateerror/index.md
+++ b/files/fr/web/javascript/reference/global_objects/aggregateerror/index.md
@@ -10,43 +10,41 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/AggregateError
 original_slug: Web/JavaScript/Reference/Objets_globaux/AggregateError
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>Un objet <code><strong>AggregateError</strong></code> représente une erreur lorsque plusieurs erreurs doivent être agrégées en une seule. Ce type d'exception est levée lorsque plusieurs erreurs sont rapportées par une opération, par exemple avec {{JSxRef("Promise.any()")}} lorsque l'ensemble des promesses qui lui sont passées échouent.</p>
+Un objet **`AggregateError`** représente une erreur lorsque plusieurs erreurs doivent être agrégées en une seule. Ce type d'exception est levée lorsque plusieurs erreurs sont rapportées par une opération, par exemple avec {{JSxRef("Promise.any()")}} lorsque l'ensemble des promesses qui lui sont passées échouent.
 
-<h2 id="Constructeur">Constructeur</h2>
+## Constructeur
 
-<dl>
- <dt><a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/AggregateError/AggregateError"><code>AggregateError()</code></a></dt>
- <dd>Crée un nouvel objet <code>AggregateError</code>.</dd>
-</dl>
+- [`AggregateError()`](/fr/docs/Web/JavaScript/Reference/Objets_globaux/AggregateError/AggregateError)
+  - : Crée un nouvel objet `AggregateError`.
 
-<h2 id="Propriétés_des_instances">Propriétés des instances</h2>
+## Propriétés des instances
 
-<dl>
- <dt>{{JSxRef("Error.prototype.message", "AggregateError.prototype.message")}}</dt>
- <dd>Le message d'erreur. La valeur par défaut est <code>""</code>.</dd>
- <dt>{{JSxRef("Error.prototype.name", "AggregateError.prototype.name")}}</dt>
- <dd>Le nom de l'erreur. La valeur par défaut est <code>"AggregateError"</code>.</dd>
-</dl>
+- {{JSxRef("Error.prototype.message", "AggregateError.prototype.message")}}
+  - : Le message d'erreur. La valeur par défaut est `""`.
+- {{JSxRef("Error.prototype.name", "AggregateError.prototype.name")}}
+  - : Le nom de l'erreur. La valeur par défaut est `"AggregateError"`.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Intercepter_une_erreur_AggregateError">Intercepter une erreur <code>AggregateError</code></h3>
+### Intercepter une erreur `AggregateError`
 
-<pre class="brush: js; notranslate">Promise.any([
+```js
+Promise.any([
   Promise.reject(new Error("une erreur")),
-]).catch(e =&gt; {
+]).catch(e => {
   console.log(e instanceof AggregateError); // true
   console.log(e.message);                   // "All Promises rejected"
   console.log(e.name);                      // "AggregateError"
   console.log(e.errors);                    // [ Error: "une erreur" ]
 });
-</pre>
+```
 
-<h3 id="Créer_un_objet_AggregateError">Créer un objet <code>AggregateError</code></h3>
+### Créer un objet `AggregateError`
 
-<pre class="brush: js; notranslate">try {
+```js
+try {
   throw new AggregateError([
     new Error("une erreur"),
   ], 'Coucou');
@@ -56,29 +54,18 @@ original_slug: Web/JavaScript/Reference/Objets_globaux/AggregateError
   console.log(e.name);                      // "AggregateError"
   console.log(e.errors);                    // [ Error: "une erreur" ]
 }
-</pre>
+```
 
-<h2 id="Spécifications">Spécifications</h2>
+## Spécifications
 
-<table class="standard-table">
- <thead>
-  <tr>
-   <th scope="col">Spécification</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td>{{SpecName('Promise.any', '#sec-aggregate-error-object-structure', 'AggregateError')}}</td>
-  </tr>
- </tbody>
-</table>
+| Spécification                                                                                                        |
+| -------------------------------------------------------------------------------------------------------------------- |
+| {{SpecName('Promise.any', '#sec-aggregate-error-object-structure', 'AggregateError')}} |
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.AggregateError")}}</p>
+{{Compat("javascript.builtins.AggregateError")}}
 
-<h2 id="Voir">Voir</h2>
+## Voir
 
-<ul>
- <li>{{JSxRef("Error")}}</li>
-</ul>
+- {{JSxRef("Error")}}
diff --git a/files/fr/web/javascript/reference/global_objects/array/@@iterator/index.md b/files/fr/web/javascript/reference/global_objects/array/@@iterator/index.md
index 44665dcba8..c2ae826291 100644
--- a/files/fr/web/javascript/reference/global_objects/array/@@iterator/index.md
+++ b/files/fr/web/javascript/reference/global_objects/array/@@iterator/index.md
@@ -12,23 +12,24 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Array/@@iterator
 original_slug: Web/JavaScript/Reference/Objets_globaux/Array/@@iterator
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La valeur initiale de la propriété <code><strong>@@iterator</strong></code> correspond à la valeur initiale fournie par l'itérateur {{jsxref("Array.prototype.values()", "values")}}.</p>
+La valeur initiale de la propriété **`@@iterator`** correspond à la valeur initiale fournie par l'itérateur {{jsxref("Array.prototype.values()", "values")}}.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>arr</var>[Symbol.iterator]()</pre>
+    arr[Symbol.iterator]()
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>La première valeur fournie par {{jsxref("Array.prototype.values()","values()")}}. Si on utilise <code>arr[Symbol.iterator]</code> (sans les parenthèses) le navigateur renverra par défaut la fonction {{jsxref("Array.prototype.values()", "values()")}}.</p>
+La première valeur fournie par {{jsxref("Array.prototype.values()","values()")}}. Si on utilise `arr[Symbol.iterator]` (sans les parenthèses) le navigateur renverra par défaut la fonction {{jsxref("Array.prototype.values()", "values()")}}.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Parcourir_un_tableau_avec_une_boucle_for...of">Parcourir un tableau avec une boucle <code>for...of</code></h3>
+### Parcourir un tableau avec une boucle `for...of`
 
-<pre class="brush: js">var arr = ['w', 'y', 'k', 'o', 'p'];
+```js
+var arr = ['w', 'y', 'k', 'o', 'p'];
 var eArr  = arr[Symbol.iterator]();
 // il est nécessaire que l'environnement supporte
 // les boucles for..of et les variables
@@ -36,54 +37,36 @@ var eArr  = arr[Symbol.iterator]();
 for (let letter of eArr) {
   console.log(letter);
 }
-</pre>
+```
 
-<h3 id="Parcourir_un_tableau_avec_next">Parcourir un tableau avec <code>next</code></h3>
+### Parcourir un tableau avec `next`
 
-<pre class="brush: js">var arr = ['w', 'y', 'k', 'o', 'p'];
+```js
+var arr = ['w', 'y', 'k', 'o', 'p'];
 var eArr = arr[Symbol.iterator]();
 console.log(eArr.next().value); // w
 console.log(eArr.next().value); // y
 console.log(eArr.next().value); // k
 console.log(eArr.next().value); // o
 console.log(eArr.next().value); // p
-</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('ES2015', '#sec-array.prototype-@@iterator', 'Array.prototype[@@iterator]()')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-array.prototype-@@iterator', 'Array.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.Array.@@iterator")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Array.prototype.keys()")}}</li>
- <li>{{jsxref("Array.prototype.entries()")}}</li>
- <li>{{jsxref("Array.prototype.forEach()")}}</li>
- <li>{{jsxref("Array.prototype.every()")}}</li>
- <li>{{jsxref("Array.prototype.some()")}}</li>
- <li>{{jsxref("Array.prototype.values()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                            | État                         | Commentaires         |
+| ------------------------------------------------------------------------------------------------------------------------ | ---------------------------- | -------------------- |
+| {{SpecName('ES2015', '#sec-array.prototype-@@iterator', 'Array.prototype[@@iterator]()')}} | {{Spec2('ES2015')}}     | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-array.prototype-@@iterator', 'Array.prototype[@@iterator]()')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Array.@@iterator")}}
+
+## Voir aussi
+
+- {{jsxref("Array.prototype.keys()")}}
+- {{jsxref("Array.prototype.entries()")}}
+- {{jsxref("Array.prototype.forEach()")}}
+- {{jsxref("Array.prototype.every()")}}
+- {{jsxref("Array.prototype.some()")}}
+- {{jsxref("Array.prototype.values()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/array/@@species/index.md b/files/fr/web/javascript/reference/global_objects/array/@@species/index.md
index 8275c5757d..1a4970e0f7 100644
--- a/files/fr/web/javascript/reference/global_objects/array/@@species/index.md
+++ b/files/fr/web/javascript/reference/global_objects/array/@@species/index.md
@@ -10,66 +10,52 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Array/@@species
 original_slug: Web/JavaScript/Reference/Objets_globaux/Array/@@species
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La propriété d'accesseur <code><strong>Array[@@species]</strong></code> renvoie le constructeur <code>Array</code>.</p>
+La propriété d'accesseur **`Array[@@species]`** renvoie le constructeur `Array`.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">Array[Symbol.species]
-</pre>
+    Array[Symbol.species]
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Le constructeur {{jsxref("Array")}}.</p>
+Le constructeur {{jsxref("Array")}}.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>L'accesseur <code>species</code> renvoie le constructeur par défaut pour les objets <code>Array</code>. Les constructeurs des sous-classes peuvent le surcharger afin de modifier l'affectation du constructeur.</p>
+L'accesseur `species` renvoie le constructeur par défaut pour les objets `Array`. Les constructeurs des sous-classes peuvent le surcharger afin de modifier l'affectation du constructeur.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<p>La propriété renvoie le constructeur par défaut, dans le cas des objets <code>Array</code>, c'est le constructeur <code>Array</code> :</p>
+La propriété renvoie le constructeur par défaut, dans le cas des objets `Array`, c'est le constructeur `Array` :
 
-<pre class="brush: js">Array[Symbol.species]; // function Array()</pre>
+```js
+Array[Symbol.species]; // function Array()
+```
 
-<p>Pour un objet dérivé, la valeur de <code>species</code> pour une classe <code>MonArray</code> sera le constructeur de cette classe. Vous pouvez surcharger ce comportement afin de renvoyer le constructeur <code>Array</code> :</p>
+Pour un objet dérivé, la valeur de `species` pour une classe `MonArray` sera le constructeur de cette classe. Vous pouvez surcharger ce comportement afin de renvoyer le constructeur `Array` :
 
-<pre class="brush: js">class MonArray extends Array {
+```js
+class MonArray extends Array {
   // On surcharge le symbole species
   // pour renvoyer le constructeur Array parent
   static get [Symbol.species]() { return Array; }
-}</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-get-array-@@species', 'get Array [ @@species ]')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-get-array-@@species', 'get Array [ @@species ]')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Array.@@species")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Array")}}</li>
- <li>{{jsxref("Symbol.species")}}</li>
-</ul>
+}
+```
+
+## Spécifications
+
+| Spécification                                                                                            | État                         | Commentaires         |
+| -------------------------------------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ES6', '#sec-get-array-@@species', 'get Array [ @@species ]')}}     | {{Spec2('ES6')}}         | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-get-array-@@species', 'get Array [ @@species ]')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Array.@@species")}}
+
+## Voir aussi
+
+- {{jsxref("Array")}}
+- {{jsxref("Symbol.species")}}
diff --git a/files/fr/web/javascript/reference/global_objects/array/@@unscopables/index.md b/files/fr/web/javascript/reference/global_objects/array/@@unscopables/index.md
index c0f9883779..0b5f7a4aee 100644
--- a/files/fr/web/javascript/reference/global_objects/array/@@unscopables/index.md
+++ b/files/fr/web/javascript/reference/global_objects/array/@@unscopables/index.md
@@ -10,27 +10,28 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Array/@@unscopables
 original_slug: Web/JavaScript/Reference/Objets_globaux/Array/@@unscopables
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La propriété symbol <code><strong>@@unscopable</strong></code> contient les noms des propriétés qui ne faisait pas partie du standard ECMAScript avant ES2015 (ES6). Ces propriétés sont exclues lors de liaisons effectuée via l'instruction <code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/with">with</a></code>.</p>
+La propriété symbol **`@@unscopable`** contient les noms des propriétés qui ne faisait pas partie du standard ECMAScript avant ES2015 (ES6). Ces propriétés sont exclues lors de liaisons effectuée via l'instruction [`with`](/fr/docs/Web/JavaScript/Reference/Instructions/with).
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>arr</var>[Symbol.unscopables]</pre>
+    arr[Symbol.unscopables]
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Les propriétés natives d'un objet <code>Array</code> qui sont exclues lorsqu'on utilise <code>with</code> sont <code>copyWithin</code>, <code>entries</code>, <code>fill</code>, <code>find</code>, <code>findIndex</code>, <code>includes</code>, <code>keys</code> et <code>values</code>.</p>
+Les propriétés natives d'un objet `Array` qui sont exclues lorsqu'on utilise `with` sont `copyWithin`, `entries`, `fill`, `find`, `findIndex`, `includes`, `keys` et `values`.
 
-<p>Voir la page sur le symbole {{jsxref("Symbol.unscopables")}} pour manipuler <code>unscopables</code> sur des objets personnalisés.</p>
+Voir la page sur le symbole {{jsxref("Symbol.unscopables")}} pour manipuler `unscopables` sur des objets personnalisés.
 
-<p>{{js_property_attributes(0,0,1)}}</p>
+{{js_property_attributes(0,0,1)}}
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<p>Le code qui suit fonctionne bien pour ES5 et les versions antérieures. En revanche, pour ECMAScript 2015 (ES6) et les versions ultérieures où la méthode  {{jsxref("Array.prototype.keys()")}} existe, lorsqu'on utilise un environnement créé avec <code>with</code>, <code>"keys"</code> serait désormais la méthode et non la variable. C'est là que le symbole natif <code>@@unscopables</code> <code>Array.prototype[@@unscopables]</code> intervient et empêche d'explorer ces méthodes avec <code>with</code>.</p>
+Le code qui suit fonctionne bien pour ES5 et les versions antérieures. En revanche, pour ECMAScript 2015 (ES6) et les versions ultérieures où la méthode  {{jsxref("Array.prototype.keys()")}} existe, lorsqu'on utilise un environnement créé avec `with`, `"keys"` serait désormais la méthode et non la variable. C'est là que le symbole natif `@@unscopables` `Array.prototype[@@unscopables]` intervient et empêche d'explorer ces méthodes avec `with`.
 
-<pre class="brush: js">var keys = [];
+```js
+var keys = [];
 
 with(Array.prototype) {
   keys.push("something");
@@ -38,36 +39,20 @@ with(Array.prototype) {
 
 Object.keys(Array.prototype[Symbol.unscopables]);
 // ["copyWithin", "entries", "fill", "find", "findIndex",
-//  "includes", "keys", "values"]</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-array.prototype-@@unscopables', 'Array.prototype[@@unscopables]')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-array.prototype-@@unscopables', 'Array.prototype[@@unscopables]')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Array.@@unscopables")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Symbol.unscopables")}}</li>
-</ul>
+//  "includes", "keys", "values"]
+```
+
+## Spécifications
+
+| Spécification                                                                                                                    | État                         | Commentaires         |
+| -------------------------------------------------------------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ES2015', '#sec-array.prototype-@@unscopables', 'Array.prototype[@@unscopables]')}}     | {{Spec2('ES2015')}}     | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-array.prototype-@@unscopables', 'Array.prototype[@@unscopables]')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Array.@@unscopables")}}
+
+## Voir aussi
+
+- {{jsxref("Symbol.unscopables")}}
diff --git a/files/fr/web/javascript/reference/global_objects/array/array/index.md b/files/fr/web/javascript/reference/global_objects/array/array/index.md
index c00ef0c0b3..c1958d3879 100644
--- a/files/fr/web/javascript/reference/global_objects/array/array/index.md
+++ b/files/fr/web/javascript/reference/global_objects/array/array/index.md
@@ -9,77 +9,69 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Array/Array
 original_slug: Web/JavaScript/Reference/Objets_globaux/Array/Array
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>Le constructeur <strong><code>Array()</code></strong> permet de créer des objets {{jsxref("Array")}}.</p>
+Le constructeur **`Array()`** permet de créer des objets {{jsxref("Array")}}.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox notranslate">[<var>element0</var>, <var>element1</var>, ..., <var>elementN</var>]
+    [element0, element1, ..., elementN]
 
-new Array(<var>element0</var>, <var>element1</var>[, ...[, <var>elementN</var>]])
-new Array(<var>longueurTableau</var>)</pre>
+    new Array(element0, element1[, ...[, elementN]])
+    new Array(longueurTableau)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>elementN</code></dt>
- <dd>Un tableau JavaScript est initialisé avec les éléments indiqués à moins qu'un seul argument ne soit passé (cf. <code>longueurTableau</code> ci-après). On notera que ce cas au limite ne s'applique qu'avec le constructeur <code>Array</code>. Si on utilise la forme littérale (avec les crochets), on peut initialiser un tableau avec un seul élément.</dd>
- <dt><code>longueurTableau</code></dt>
- <dd>Si le seul argument passé au constructeur <code>Array</code> est un entier entre 0 et 2^32-1 (inclus), le constructeur renverra un tableau dont la propriété <code>length</code> vaut ce nombre. <strong>Note :</strong> le tableau contiendra des éléments vides (à ne pas confondre avec des éléments qui vaudraient <code>undefined</code>). Si l'argument est un autre nombre, une exception {{jsxref("RangeError")}} sera levée.</dd>
-</dl>
+- `elementN`
+  - : Un tableau JavaScript est initialisé avec les éléments indiqués à moins qu'un seul argument ne soit passé (cf. `longueurTableau` ci-après). On notera que ce cas au limite ne s'applique qu'avec le constructeur `Array`. Si on utilise la forme littérale (avec les crochets), on peut initialiser un tableau avec un seul élément.
+- `longueurTableau`
+  - : Si le seul argument passé au constructeur `Array` est un entier entre 0 et 2^32-1 (inclus), le constructeur renverra un tableau dont la propriété `length` vaut ce nombre. **Note :** le tableau contiendra des éléments vides (à ne pas confondre avec des éléments qui vaudraient `undefined`). Si l'argument est un autre nombre, une exception {{jsxref("RangeError")}} sera levée.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utilisation_de_la_notation_littérale">Utilisation de la notation littérale</h3>
+### Utilisation de la notation littérale
 
-<p>Les tableaux peuvent être créés avec une notation <a href="/fr/docs/Web/JavaScript/Reference/Grammaire_lexicale#Litt%C3%A9raux_de_tableaux">littérale</a> :</p>
+Les tableaux peuvent être créés avec une notation [littérale](/fr/docs/Web/JavaScript/Reference/Grammaire_lexicale#Litt%C3%A9raux_de_tableaux) :
 
-<pre class="brush: js notranslate">let fruits = ['Pomme', 'Banane'];
+```js
+let fruits = ['Pomme', 'Banane'];
 
 console.log(fruits.length); // 2
 console.log(fruits[0]);     // "Pomme"
-</pre>
+```
 
-<h3 id="Utilisation_du_constructeur_avec_un_seul_paramètre">Utilisation du constructeur avec un seul paramètre</h3>
+### Utilisation du constructeur avec un seul paramètre
 
-<p>On peut créer des tableaux grâce au constructeur avec un seul paramètre numérique. On crée alors un tableau dont la propriété <code>length</code> vaut le nombre passé en argument et dont les éléments sont vides.</p>
+On peut créer des tableaux grâce au constructeur avec un seul paramètre numérique. On crée alors un tableau dont la propriété `length` vaut le nombre passé en argument et dont les éléments sont vides.
 
-<pre class="brush: js notranslate">let fruits = new Array(2);
+```js
+let fruits = new Array(2);
 
 console.log(fruits.length); // 2
 console.log(fruits[0]);     // undefined
-</pre>
+```
 
-<h3 id="Utilisation_du_constructeur_avec_plusieurs_paramètres">Utilisation du constructeur avec plusieurs paramètres</h3>
+### Utilisation du constructeur avec plusieurs paramètres
 
-<p>Si on utilise plus d'un argument, un nouveau tableau ({{jsxref("Array")}}) sera construit avec les éléments passés en arguments.</p>
+Si on utilise plus d'un argument, un nouveau tableau ({{jsxref("Array")}}) sera construit avec les éléments passés en arguments.
 
-<pre class="brush: js notranslate">let fruits = new Array('Pomme', 'Banane');
+```js
+let fruits = new Array('Pomme', 'Banane');
 
 console.log(fruits.length); // 2
 console.log(fruits[0]);     // "Pomme"
-</pre>
+```
 
-<h2 id="Spécifications">Spécifications</h2>
+## Spécifications
 
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Spécification</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-array-constructor', 'Array constructor')}}</td>
-  </tr>
- </tbody>
-</table>
+| Spécification                                                                                |
+| -------------------------------------------------------------------------------------------- |
+| {{SpecName('ESDraft', '#sec-array-constructor', 'Array constructor')}} |
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.Array.Array")}}</p>
+{{Compat("javascript.builtins.Array.Array")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>La classe {{jsxref("Array")}}</li>
-</ul>
+- La classe {{jsxref("Array")}}
diff --git a/files/fr/web/javascript/reference/global_objects/array/concat/index.md b/files/fr/web/javascript/reference/global_objects/array/concat/index.md
index e39788b6a0..3a68c4f55e 100644
--- a/files/fr/web/javascript/reference/global_objects/array/concat/index.md
+++ b/files/fr/web/javascript/reference/global_objects/array/concat/index.md
@@ -10,63 +10,59 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Array/concat
 original_slug: Web/JavaScript/Reference/Objets_globaux/Array/concat
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>concat()</strong></code> est utilisée afin de fusionner un ou plusieurs tableaux en les concaténant. Cette méthode ne modifie pas les tableaux existants, elle renvoie un nouveau tableau qui est le résultat de l'opération.</p>
+La méthode **`concat()`** est utilisée afin de fusionner un ou plusieurs tableaux en les concaténant. Cette méthode ne modifie pas les tableaux existants, elle renvoie un nouveau tableau qui est le résultat de l'opération.
 
-<div>{{EmbedInteractiveExample("pages/js/array-concat.html")}}</div>
+{{EmbedInteractiveExample("pages/js/array-concat.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">let <var>nouveau_tableau</var> = <var>ancien_tableau</var>.concat(<var>valeur1</var>[, <var>valeur2</var>[, ...[, <var>valeurN</var>]]])</pre>
+    let nouveau_tableau = ancien_tableau.concat(valeur1[, valeur2[, ...[, valeurN]]])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>valeurN</code>{{optional_inline}}</dt>
- <dd>Des tableaux et/ou des valeurs à concaténer dans le nouveau tableau. Si tous les arguments <code>valeurN</code> valent <code>undefined</code>, <code>concat</code> renverra une copie superficielle du tableau sur lequel elle est appelée. Voir ci-après pour plus de détails.</dd>
-</dl>
+- `valeurN`{{optional_inline}}
+  - : Des tableaux et/ou des valeurs à concaténer dans le nouveau tableau. Si tous les arguments `valeurN` valent `undefined`, `concat` renverra une copie superficielle du tableau sur lequel elle est appelée. Voir ci-après pour plus de détails.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une nouvelle instance de {{jsxref("Array")}}.</p>
+Une nouvelle instance de {{jsxref("Array")}}.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La méthode <code>concat</code> permet de créer un nouveau tableau constitué des éléments de l'objet <code>this</code> sur lequel elle a été appelée, suivis dans l'ordre par, pour chaque paramètre, les éléments de ce paramètre (s'il s'agit d'un tableau) ou le paramètre lui-même (s'il ne s'agit pas d'un tableau). La concaténation ne « déplie » pas les tableaux imbriqués.</p>
+La méthode `concat` permet de créer un nouveau tableau constitué des éléments de l'objet `this` sur lequel elle a été appelée, suivis dans l'ordre par, pour chaque paramètre, les éléments de ce paramètre (s'il s'agit d'un tableau) ou le paramètre lui-même (s'il ne s'agit pas d'un tableau). La concaténation ne « déplie » pas les tableaux imbriqués.
 
-<p>La méthode <code>concat</code> ne modifie pas <code>this</code> ni aucun des tableaux passés en paramètres, mais renvoie une copie qui contient des copies des mêmes éléments combinées que ceux des tableaux originaux. Les éléments des tableaux originaux sont copiés dans le nouveau tableau comme suit :</p>
+La méthode `concat` ne modifie pas `this` ni aucun des tableaux passés en paramètres, mais renvoie une copie qui contient des copies des mêmes éléments combinées que ceux des tableaux originaux. Les éléments des tableaux originaux sont copiés dans le nouveau tableau comme suit :
 
-<ul>
- <li>Pour les références à des objets (et non les objets eux-mêmes) : <code>concat</code> copie ces références dans le nouveaux tableau. Le tableau original et le nouveau tableau feront référence au même objet. C'est-à-dire que si un objet référencé est modifié, ces changements seront visibles tant dans le nouveau que dans les tableaux originaux.</li>
-</ul>
+- Pour les références à des objets (et non les objets eux-mêmes) : `concat` copie ces références dans le nouveaux tableau. Le tableau original et le nouveau tableau feront référence au même objet. C'est-à-dire que si un objet référencé est modifié, ces changements seront visibles tant dans le nouveau que dans les tableaux originaux.
 
-<ul>
- <li>Pour les chaînes, les booléens et les nombres « primitifs » (c'est-à-dire pas les objets {{jsxref("String", "String")}}, {{jsxref("Boolean")}} et {{jsxref("Number", "Number")}}) : <code>concat</code> copie les valeurs des chaînes et des nombres dans le nouveau tableau. (voir <a href="/fr/docs/Web/JavaScript/Structures_de_donn%C3%A9es#Les_types_de_donn%C3%A9es">Les types de données en JavaScript</a>).</li>
-</ul>
+<!---->
 
-<div class="note">
-<p><strong>Note :</strong> La concaténation n'impactera pas les tableaux originaux. Par la suite, toute opération sur le nouveau tableau n'aura aucun effet sur les tableaux d'origine, et vice versa.</p>
-</div>
+- Pour les chaînes, les booléens et les nombres « primitifs » (c'est-à-dire pas les objets {{jsxref("String", "String")}}, {{jsxref("Boolean")}} et {{jsxref("Number", "Number")}}) : `concat` copie les valeurs des chaînes et des nombres dans le nouveau tableau. (voir [Les types de données en JavaScript](/fr/docs/Web/JavaScript/Structures_de_donn%C3%A9es#Les_types_de_donn%C3%A9es)).
 
-<h2 id="Exemples">Exemples</h2>
+> **Note :** La concaténation n'impactera pas les tableaux originaux. Par la suite, toute opération sur le nouveau tableau n'aura aucun effet sur les tableaux d'origine, et vice versa.
 
-<h3 id="Concaténer_deux_tableaux">Concaténer deux tableaux</h3>
+## Exemples
 
-<p>Le code qui suit concatène deux tableaux :</p>
+### Concaténer deux tableaux
 
-<pre class="brush: js">let alpha = ["a", "b", "c"];
+Le code qui suit concatène deux tableaux :
+
+```js
+let alpha = ["a", "b", "c"];
 let numerique = [1, 2, 3];
 
 alpha.concat(numerique);
 // donne : ["a", "b", "c", 1, 2, 3]
-</pre>
+```
 
-<h3 id="Concaténer_trois_tableaux">Concaténer trois tableaux</h3>
+### Concaténer trois tableaux
 
-<p>Le code qui suit concatène trois tableaux :</p>
+Le code qui suit concatène trois tableaux :
 
-<pre class="brush: js">let num1 = [1, 2, 3];
+```js
+let num1 = [1, 2, 3];
 let num2 = [4, 5, 6];
 let num3 = [7, 8, 9];
 
@@ -74,25 +70,27 @@ let nums = num1.concat(num2, num3);
 
 console.log(nums);
 // [1, 2, 3, 4, 5, 6, 7, 8, 9]
-</pre>
+```
 
-<h3 id="Concaténer_des_valeurs_avec_un_tableau">Concaténer des valeurs avec un tableau</h3>
+### Concaténer des valeurs avec un tableau
 
-<p>Le code qui suit ajoute trois valeurs à un tableau :</p>
+Le code qui suit ajoute trois valeurs à un tableau :
 
-<pre class="brush: js">let alpha = ['a', 'b', 'c'];
+```js
+let alpha = ['a', 'b', 'c'];
 
 let alphanumerique = alpha.concat(1, [2, 3]);
 
 console.log(alphanumerique);
 // ['a', 'b', 'c', 1, 2, 3]
-</pre>
+```
 
-<h3 id="Concaténer_des_tableaux_imbriqués">Concaténer des tableaux imbriqués</h3>
+### Concaténer des tableaux imbriqués
 
-<p>Dans le code qui suit, on concatène deux tableaux qui ont plusieurs dimensions et on illustre la conservation des références :</p>
+Dans le code qui suit, on concatène deux tableaux qui ont plusieurs dimensions et on illustre la conservation des références :
 
-<pre class="brush: js">let num1 = [[1]];
+```js
+let num1 = [[1]];
 let num2 = [2, [3]];
 
 let nums = num1.concat(num2);
@@ -104,52 +102,26 @@ console.log(nums);
 num1[0].push(4);
 
 console.log(nums);
-// affichera [[1, 4], 2, [3]]</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('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.4.4.4', 'Array.prototype.concat')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-array.prototype.concat', 'Array.prototype.concat')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-array.prototype.concat', 'Array.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.Array.concat")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Array.push", "push")}} / {{jsxref("Array.pop", "pop")}} qui permettent d'ajouter/retirer des éléments à partir de la fin du tableau</li>
- <li>{{jsxref("Array.unshift", "unshift")}} / {{jsxref("Array.shift", "shift")}} qui permettent d'ajouter/retirer des éléments à partir du début du tableau</li>
- <li>{{jsxref("Array.splice", "splice")}} qui permet d'ajouter/retirer des éléments à un endroit donné du tableau</li>
- <li>{{jsxref("String.prototype.concat()")}}</li>
- <li>{{jsxref("Symbol.isConcatSpreadable")}} (permet de contrôler la façon dont un tableau est ramené à une valeur)</li>
-</ul>
+// affichera [[1, 4], 2, [3]]
+```
+
+## 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.4.4.4', 'Array.prototype.concat')}}                         | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-array.prototype.concat', 'Array.prototype.concat')}}         | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-array.prototype.concat', 'Array.prototype.concat')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Array.concat")}}
+
+## Voir aussi
+
+- {{jsxref("Array.push", "push")}} / {{jsxref("Array.pop", "pop")}} qui permettent d'ajouter/retirer des éléments à partir de la fin du tableau
+- {{jsxref("Array.unshift", "unshift")}} / {{jsxref("Array.shift", "shift")}} qui permettent d'ajouter/retirer des éléments à partir du début du tableau
+- {{jsxref("Array.splice", "splice")}} qui permet d'ajouter/retirer des éléments à un endroit donné du tableau
+- {{jsxref("String.prototype.concat()")}}
+- {{jsxref("Symbol.isConcatSpreadable")}} (permet de contrôler la façon dont un tableau est ramené à une valeur)
diff --git a/files/fr/web/javascript/reference/global_objects/array/copywithin/index.md b/files/fr/web/javascript/reference/global_objects/array/copywithin/index.md
index befc06152e..e28200ab55 100644
--- a/files/fr/web/javascript/reference/global_objects/array/copywithin/index.md
+++ b/files/fr/web/javascript/reference/global_objects/array/copywithin/index.md
@@ -12,49 +12,47 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Array/copyWithin
 original_slug: Web/JavaScript/Reference/Objets_globaux/Array/copyWithin
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>copyWithin()</strong></code> effectue une copie superficielle (<em>shallow copy</em>) d'une partie d'un tableau sur ce même tableau et le renvoie, sans modifier sa taille.</p>
+La méthode **`copyWithin()`** effectue une copie superficielle (_shallow copy_) d'une partie d'un tableau sur ce même tableau et le renvoie, sans modifier sa taille.
 
-<div>{{EmbedInteractiveExample("pages/js/array-copywithin.html")}}</div>
+{{EmbedInteractiveExample("pages/js/array-copywithin.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">arr.copyWithin(cible)
-arr.copyWithin(cible, début)
-arr.copyWithin(cible, début, fin)
-</pre>
+    arr.copyWithin(cible)
+    arr.copyWithin(cible, début)
+    arr.copyWithin(cible, début, fin)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>cible</code></dt>
- <dd>
- <p>Indice à partir duquel la séquence sera copiée. Si la valeur est négative, <code>cible </code>sera compté à partir de la fin du tableau.</p>
+- `cible`
 
- <p>Si <code>cible </code>est supérieur ou égal à <code>arr.length</code>, rien ne sera copié. Si <code>cible</code> est positionné apès <code>début</code>, la séquence copiée sera réduite pour correspondre à <code>arr.length</code>.</p>
- </dd>
- <dt><code>début</code> {{optional_inline}}</dt>
- <dd>Indice de début de la séquence a copier. Si la valeur est négative, <code>début</code> sera compté à partir de la fin du tableau. Si <code>début</code> est omis, <code>copyWithin</code> copiera à partir du début du tableau (par défaut 0).</dd>
- <dt><code>fin</code> {{optional_inline}}</dt>
- <dd>Indice de fin de la séquence a copier. <code>copyWithin</code> copie jusqu'à <code>fin</code> (non-inclusif). Si la valeur est négative, <code>end</code> sera compté à partir de la fin du tableau. Si <code>end</code> est omis, <code>copyWithin</code> copiera jusqu'à la fin du tableau (par défaut <code>arr.length</code>).</dd>
-</dl>
+  - : Indice à partir duquel la séquence sera copiée. Si la valeur est négative, `cible `sera compté à partir de la fin du tableau.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+    Si `cible `est supérieur ou égal à `arr.length`, rien ne sera copié. Si `cible` est positionné apès `début`, la séquence copiée sera réduite pour correspondre à `arr.length`.
 
-<p>Le tableau modifié par la méthode.</p>
+- `début` {{optional_inline}}
+  - : Indice de début de la séquence a copier. Si la valeur est négative, `début` sera compté à partir de la fin du tableau. Si `début` est omis, `copyWithin` copiera à partir du début du tableau (par défaut 0).
+- `fin` {{optional_inline}}
+  - : Indice de fin de la séquence a copier. `copyWithin` copie jusqu'à `fin` (non-inclusif). Si la valeur est négative, `end` sera compté à partir de la fin du tableau. Si `end` est omis, `copyWithin` copiera jusqu'à la fin du tableau (par défaut `arr.length`).
 
-<h2 id="Description">Description</h2>
+### Valeur de retour
 
-<p>La fonction <code>copyWithin()</code> fonctionne de la même façon que <code>memmove</code> en C/C++. C'est une méthode très performante pour décaler les données d'un {{jsxref("Array")}} ou d'un {{jsxref("TypedArray")}} (dans ce cas, on pourra utiliser {{jsxref("TypedArray/copyWithin", "TypedArray.copyWithin()")}}). La séquence est copiée et collée en une opération. La séquence collée aura les valeurs copiées même si les zones de copiage et de collage se chevauchent.</p>
+Le tableau modifié par la méthode.
 
-<p>La fonction <code>copyWithin()</code> est intentionnellement générique, il n'est pas nécessaire que <code>this</code> soit un objet {{jsxref("Array", "Array")}}.</p>
+## Description
 
-<p>De plus, <code>copyWithin()</code> est une méthode qui modifie l'objet courant. Elle ne modifie pas la longueur de <code>this</code>, mais change son contenu et créé de nouvelles propriétés si nécessaire.</p>
+La fonction `copyWithin()` fonctionne de la même façon que `memmove` en C/C++. C'est une méthode très performante pour décaler les données d'un {{jsxref("Array")}} ou d'un {{jsxref("TypedArray")}} (dans ce cas, on pourra utiliser {{jsxref("TypedArray/copyWithin", "TypedArray.copyWithin()")}}). La séquence est copiée et collée en une opération. La séquence collée aura les valeurs copiées même si les zones de copiage et de collage se chevauchent.
 
-<h2 id="Exemples">Exemples</h2>
+La fonction `copyWithin()` est intentionnellement générique, il n'est pas nécessaire que `this` soit un objet {{jsxref("Array", "Array")}}.
 
-<pre class="brush: js">[1, 2, 3, 4, 5].copyWithin(-2);
+De plus, `copyWithin()` est une méthode qui modifie l'objet courant. Elle ne modifie pas la longueur de `this`, mais change son contenu et créé de nouvelles propriétés si nécessaire.
+
+## Exemples
+
+```js
+[1, 2, 3, 4, 5].copyWithin(-2);
 // [1, 2, 3, 1, 2]
 
 [1, 2, 3, 4, 5].copyWithin(0, 3);
@@ -78,13 +76,14 @@ i32a.copyWithin(0, 2);
 // Sur les plates-formes qui ne supportent pas encore ES2015 :
 [].copyWithin.call(new Int32Array([1, 2, 3, 4, 5]), 0, 3, 4);
 // Int32Array [4, 2, 3, 4, 5]
-</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 6 et peut ne pas être utilisable dans tous les environnements. Voici un fragment de code qui permet d'émuler cette méthode :</p>
+Cette méthode a été ajoutée à la spécification ECMAScript 6 et peut ne pas être utilisable dans tous les environnements. Voici un fragment de code qui permet d'émuler cette méthode :
 
-<pre class="brush: js">if (!Array.prototype.copyWithin) {
+```js
+if (!Array.prototype.copyWithin) {
   Object.defineProperty(Array.prototype, 'copyWithin', {
     value: function(target, start/*, end*/) {
     // Steps 1-2.
@@ -95,27 +94,27 @@ i32a.copyWithin(0, 2);
     var O = Object(this);
 
     // Steps 3-5.
-    var len = O.length &gt;&gt;&gt; 0;
+    var len = O.length >>> 0;
 
     // Steps 6-8.
-    var relativeTarget = target &gt;&gt; 0;
+    var relativeTarget = target >> 0;
 
-    var to = relativeTarget &lt; 0 ?
+    var to = relativeTarget < 0 ?
       Math.max(len + relativeTarget, 0) :
       Math.min(relativeTarget, len);
 
     // Steps 9-11.
-    var relativeStart = start &gt;&gt; 0;
+    var relativeStart = start >> 0;
 
-    var from = relativeStart &lt; 0 ?
+    var from = relativeStart < 0 ?
       Math.max(len + relativeStart, 0) :
       Math.min(relativeStart, len);
 
     // Steps 12-14.
     var end = arguments[2];
-    var relativeEnd = end === undefined ? len : end &gt;&gt; 0;
+    var relativeEnd = end === undefined ? len : end >> 0;
 
-    var final = relativeEnd &lt; 0 ?
+    var final = relativeEnd < 0 ?
       Math.max(len + relativeEnd, 0) :
       Math.min(relativeEnd, len);
 
@@ -125,14 +124,14 @@ i32a.copyWithin(0, 2);
     // Steps 16-17.
     var direction = 1;
 
-    if (from &lt; to &amp;&amp; to &lt; (from + count)) {
+    if (from < to && to < (from + count)) {
       direction = -1;
       from += count - 1;
       to += count - 1;
     }
 
     // Step 18.
-    while (count &gt; 0) {
+    while (count > 0) {
       if (from in O) {
         O[to] = O[from];
       } else {
@@ -150,43 +149,21 @@ i32a.copyWithin(0, 2);
   configurable: true,
   writable: true
   });
-}</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('ES2015', '#sec-array.prototype.copywithin', 'Array.prototype.copyWithin')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES2016', '#sec-array.prototype.copywithin', 'Array.prototype.copyWithin')}}</td>
-   <td>{{Spec2('ES2016')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-array.prototype.copywithin', 'Array.prototype.copyWithin')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Array.copyWithin")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Array", "Array")}}</li>
-</ul>
+}
+```
+
+## Spécifications
+
+| Spécification                                                                                                        | État                         | Commentaires         |
+| -------------------------------------------------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ES2015', '#sec-array.prototype.copywithin', 'Array.prototype.copyWithin')}} | {{Spec2('ES2015')}}     | Définition initiale. |
+| {{SpecName('ES2016', '#sec-array.prototype.copywithin', 'Array.prototype.copyWithin')}} | {{Spec2('ES2016')}}     |                      |
+| {{SpecName('ESDraft', '#sec-array.prototype.copywithin', 'Array.prototype.copyWithin')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Array.copyWithin")}}
+
+## Voir aussi
+
+- {{jsxref("Array", "Array")}}
diff --git a/files/fr/web/javascript/reference/global_objects/array/entries/index.md b/files/fr/web/javascript/reference/global_objects/array/entries/index.md
index 5ab8acec51..9bfa9f7ca7 100644
--- a/files/fr/web/javascript/reference/global_objects/array/entries/index.md
+++ b/files/fr/web/javascript/reference/global_objects/array/entries/index.md
@@ -11,38 +11,40 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Array/entries
 original_slug: Web/JavaScript/Reference/Objets_globaux/Array/entries
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>entries()</strong></code> renvoie un nouvel objet de type  <code><strong>Array Iterator</strong></code> qui contient le couple clef/valeur pour chaque éléments du tableau.</p>
+La méthode **`entries()`** renvoie un nouvel objet de type  **`Array Iterator`** qui contient le couple clef/valeur pour chaque éléments du tableau.
 
-<div>{{EmbedInteractiveExample("pages/js/array-entries.html")}}</div>
+{{EmbedInteractiveExample("pages/js/array-entries.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>arr</var>.entries()</pre>
+    arr.entries()
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un nouvel objet qui est un itérateur pour {{jsxref("Array")}}.</p>
+Un nouvel objet qui est un itérateur pour {{jsxref("Array")}}.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Parcourir_un_tableau_avec_ses_index_et_éléments">Parcourir un tableau avec ses index et éléments</h3>
+### Parcourir un tableau avec ses index et éléments
 
-<pre class="brush:js">const arr = ["a", "b", "c"];
+```js
+const arr = ["a", "b", "c"];
 for (const [index, element] of arr.entries()) {
   console.log(index, element);
 }
 // 0 "a"
 // 1 "b"
 // 2 "c"
-</pre>
+```
 
-<h3 id="Boucle_for...of">Boucle <code>for...of</code></h3>
+### Boucle `for...of`
 
-<p>On peut avoir le même résultat en utilisant une boucle <a href="/fr/docs/Web/JavaScript/Reference/Instructions/for...of">for...of</a> :</p>
+On peut avoir le même résultat en utilisant une boucle [for...of](/fr/docs/Web/JavaScript/Reference/Instructions/for...of) :
 
-<pre class="brush: js">var arr = ['a', 'b', 'c'];
+```js
+var arr = ['a', 'b', 'c'];
 var eArr = arr.entries();
 
 for (let e of eArr) {
@@ -51,42 +53,25 @@ for (let e of eArr) {
 // [0, 'a']
 // [1, 'b']
 // [2, 'c']
-</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-array.prototype.entries', 'Array.prototype.entries')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-array.prototype.entries', 'Array.prototype.entries')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Array.entries")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Array.prototype.keys()")}}</li>
- <li>{{jsxref("Array.prototype.values()")}}</li>
- <li>{{jsxref("Array.prototype.forEach()")}}</li>
- <li>{{jsxref("Array.prototype.every()")}}</li>
- <li>{{jsxref("Array.prototype.some()")}}</li>
- <li><code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/for...of">for...of</a></code></li>
- <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-array.prototype.entries', 'Array.prototype.entries')}} | {{Spec2('ES2015')}}     | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-array.prototype.entries', 'Array.prototype.entries')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Array.entries")}}
+
+## Voir aussi
+
+- {{jsxref("Array.prototype.keys()")}}
+- {{jsxref("Array.prototype.values()")}}
+- {{jsxref("Array.prototype.forEach()")}}
+- {{jsxref("Array.prototype.every()")}}
+- {{jsxref("Array.prototype.some()")}}
+- [`for...of`](/fr/docs/Web/JavaScript/Reference/Instructions/for...of)
+- [Les protocoles d'itération](/fr/docs/Web/JavaScript/Reference/Les_protocoles_iteration)
diff --git a/files/fr/web/javascript/reference/global_objects/array/every/index.md b/files/fr/web/javascript/reference/global_objects/array/every/index.md
index 65dfaf3c44..030fb9e115 100644
--- a/files/fr/web/javascript/reference/global_objects/array/every/index.md
+++ b/files/fr/web/javascript/reference/global_objects/array/every/index.md
@@ -12,84 +12,83 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Array/every
 original_slug: Web/JavaScript/Reference/Objets_globaux/Array/every
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>every()</strong></code> permet de tester si tous les éléments d'un tableau vérifient une condition donnée par une fonction en argument. Cette méthode renvoie un booléen pour le résultat du test.</p>
+La méthode **`every()`** permet de tester si tous les éléments d'un tableau vérifient une condition donnée par une fonction en argument. Cette méthode renvoie un booléen pour le résultat du test.
 
-<div class="note">
-<p><strong>Note :</strong> Cette méthode renvoie <code>true</code> pour n'importe quelle condition utilisée sur un tableau vide.</p>
-</div>
+> **Note :** Cette méthode renvoie `true` pour n'importe quelle condition utilisée sur un tableau vide.
 
-<div>{{EmbedInteractiveExample("pages/js/array-every.html")}}</div>
+{{EmbedInteractiveExample("pages/js/array-every.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>arr</var>.every(<var>callback</var>[, <var>thisArg</var>])</pre>
+    arr.every(callback[, thisArg])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>callback</code></dt>
- <dd>La fonction sur laquelle on souhaite tester chaque élément du tableau. Elle prend en compte trois arguments :
- <dl>
-  <dt><code>currentValue</code></dt>
-  <dd>La valeur de l'élément à traiter.</dd>
-  <dt><code>index</code>{{Optional_inline}}</dt>
-  <dd>L'indice de l'élément du tableau à tester.</dd>
-  <dt><code>array</code>{{Optional_inline}}</dt>
-  <dd>Le tableau sur lequel on a appelé la méthode <code>every</code>.</dd>
- </dl>
- </dd>
- <dt><code>thisArg</code>{{Optional_inline}}</dt>
- <dd>Paramètre optionnel. La valeur à utiliser pour <code>this</code> lors de l'exécution de la fonction.</dd>
-</dl>
+- `callback`
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+  - : La fonction sur laquelle on souhaite tester chaque élément du tableau. Elle prend en compte trois arguments :
 
-<p><code>true</code> si la fonction de rappel obtient une valeur équivalente à vrai (<em>truthy</em>) pour chaque élément du tableau et <code>false</code> sinon.</p>
+    - `currentValue`
+      - : La valeur de l'élément à traiter.
+    - `index`{{Optional_inline}}
+      - : L'indice de l'élément du tableau à tester.
+    - `array`{{Optional_inline}}
+      - : Le tableau sur lequel on a appelé la méthode `every`.
 
-<h2 id="Description">Description</h2>
+- `thisArg`{{Optional_inline}}
+  - : Paramètre optionnel. La valeur à utiliser pour `this` lors de l'exécution de la fonction.
 
-<p>La méthode <code>every</code> exécute la fonction <code>callback</code> fournie sur chacun des éléments contenus dans le tableau jusqu'à ce qu'un élément pour lequel la fonction <code>callback</code> renvoie une valeur fausse (<em>falsy value</em>) soit trouvé. Si un tel élément est trouvé, la méthode <code>every</code> renvoie directement <code>false</code>. Sinon, si la fonction <code>callback</code> a renvoyé une valeur vraie pour tous les éléments, la méthode <code>every</code> renverra <code>true</code>. La fonction <code>callback</code> n'est appelée que pour les indices du tableau pour lesquels il existe des valeurs affectées. Elle n'est pas appelée pour les indices supprimés ou ceux qui n'ont jamais reçu de valeur.</p>
+### Valeur de retour
 
-<p><code>callback</code> est appelée avec trois arguments : la valeur de l'élément en cours de traitement, l'indice de l'élément dans le tableau et le tableau qui est parcouru.</p>
+`true` si la fonction de rappel obtient une valeur équivalente à vrai (_truthy_) pour chaque élément du tableau et `false` sinon.
 
-<p>Si un paramètre <code>thisArg</code> est fourni à la méthode <code>every</code>, ce sera la valeur <code>this</code> de la fonction <code>callback</code>. Si ce paramètre n'est pas fourni, la valeur <code>undefined</code> sera utilisée comme valeur pour <code>this</code>. La valeur <code>this</code> « définitivement » utilisée par la fonction <code>callback</code> est déterminée selon <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_this">les règles usuelles de détermination de <code>this</code></a>.</p>
+## Description
 
-<p><code>every</code> ne modifie pas le tableau sur lequel elle a été appelée.</p>
+La méthode `every` exécute la fonction `callback` fournie sur chacun des éléments contenus dans le tableau jusqu'à ce qu'un élément pour lequel la fonction `callback` renvoie une valeur fausse (_falsy value_) soit trouvé. Si un tel élément est trouvé, la méthode `every` renvoie directement `false`. Sinon, si la fonction `callback` a renvoyé une valeur vraie pour tous les éléments, la méthode `every` renverra `true`. La fonction `callback` n'est appelée que pour les indices du tableau pour lesquels il existe des valeurs affectées. Elle n'est pas appelée pour les indices supprimés ou ceux qui n'ont jamais reçu de valeur.
 
-<p>Les éléments traités par la méthode <code>every</code> sont définis lors du premier appel à <code>callback</code>. Les éléments ajoutés au tableau après que l'appel à <code>every</code> ait commencé ne seront pas traités par la fonction <code>callback</code>. Si des éléments du tableau sont modifiés, la valeur passée à la fonction <code>callback</code> sera celle qu'ils ont au moment où <code>every</code> les traitera. Les éléments qui sont supprimés ne sont pas traités par la fonction <code>every</code>.</p>
+`callback` est appelée avec trois arguments : la valeur de l'élément en cours de traitement, l'indice de l'élément dans le tableau et le tableau qui est parcouru.
 
-<p><code>every</code> agit de la même façon que le quantificateur mathématiques « pour tous », notamment pour le cas au limite d'un tableau vide pour lequel elle renvoie <code>true</code> (on dit qu'il est trivialement vrai que tous les éléments d'un <a href="https://fr.wikipedia.org/wiki/Ensemble_vide#Difficult.C3.A9s_de_la_notion_d.27ensemble_vide">ensemble vide</a> respectent n'importe quelle condition).</p>
+Si un paramètre `thisArg` est fourni à la méthode `every`, ce sera la valeur `this` de la fonction `callback`. Si ce paramètre n'est pas fourni, la valeur `undefined` sera utilisée comme valeur pour `this`. La valeur `this` « définitivement » utilisée par la fonction `callback` est déterminée selon [les règles usuelles de détermination de `this`](/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_this).
 
-<h2 id="Exemples">Exemples</h2>
+`every` ne modifie pas le tableau sur lequel elle a été appelée.
 
-<h3 id="Tester_la_valeur_des_éléments_d'un_tableau">Tester la valeur des éléments d'un tableau</h3>
+Les éléments traités par la méthode `every` sont définis lors du premier appel à `callback`. Les éléments ajoutés au tableau après que l'appel à `every` ait commencé ne seront pas traités par la fonction `callback`. Si des éléments du tableau sont modifiés, la valeur passée à la fonction `callback` sera celle qu'ils ont au moment où `every` les traitera. Les éléments qui sont supprimés ne sont pas traités par la fonction `every`.
 
-<p>Dans l'exemple suivant, on teste si tous les éléments du tableau sont supérieurs à 10.</p>
+`every` agit de la même façon que le quantificateur mathématiques « pour tous », notamment pour le cas au limite d'un tableau vide pour lequel elle renvoie `true` (on dit qu'il est trivialement vrai que tous les éléments d'un [ensemble vide](https://fr.wikipedia.org/wiki/Ensemble_vide#Difficult.C3.A9s_de_la_notion_d.27ensemble_vide) respectent n'importe quelle condition).
 
-<pre class="brush: js">function estAssezGrand(element, index, array) {
-  return element &gt;= 10;
+## Exemples
+
+### Tester la valeur des éléments d'un tableau
+
+Dans l'exemple suivant, on teste si tous les éléments du tableau sont supérieurs à 10.
+
+```js
+function estAssezGrand(element, index, array) {
+  return element >= 10;
 }
 [12, 5, 8, 130, 44].every(estAssezGrand);   // false
 [12, 54, 18, 130, 44].every(estAssezGrand); // true
-</pre>
+```
 
-<h3 id="Utiliser_les_fonctions_fléchées_avec_every">Utiliser les fonctions fléchées avec <code>every</code></h3>
+### Utiliser les fonctions fléchées avec `every`
 
-<p>{{jsxref("Fonctions/Fonctions_fl%C3%A9ch%C3%A9es","Les fonctions fléchées","","1")}} permettent d'utiliser une syntaxe plus concise pour effectuer le même test.</p>
+{{jsxref("Fonctions/Fonctions_fl%C3%A9ch%C3%A9es","Les fonctions fléchées","","1")}} permettent d'utiliser une syntaxe plus concise pour effectuer le même test.
 
-<pre class="brush: js">[12, 5, 8, 130, 44].every(elem =&gt; elem &gt;= 10); // false
-[12, 54, 18, 130, 44].every(elem =&gt; elem &gt;= 10); // true
-[{a:1, b:2}, {a:1, b:3}].every(elem =&gt; elem.a === 1); // true
-[{a:2, b:2}, {a:1, b:3}].every(elem =&gt; elem.a === 1); // false
-</pre>
+```js
+[12, 5, 8, 130, 44].every(elem => elem >= 10); // false
+[12, 54, 18, 130, 44].every(elem => elem >= 10); // true
+[{a:1, b:2}, {a:1, b:3}].every(elem => elem.a === 1); // true
+[{a:2, b:2}, {a:1, b:3}].every(elem => elem.a === 1); // false
+```
 
-<h2 id="Prothèse_d'émulation_(polyfill)">Prothèse d'émulation (<em>polyfill</em>)</h2>
+## Prothèse d'émulation (_polyfill_)
 
-<p><code>every</code> fut ajouté avec la cinquième édition du standard ECMA-262. Pour cette raison, il n'est pas nécessairement présent dans les différentes implémentations de ce standard. Afin de faire fonctionner du code dans un environnement qui ne possède pas cette fonctionnalité, on pourra utiliser le fragment de code suivant au début des scripts. Cet algorithme correspond exactement à celui défini dans la cinquième édition du standard ECMA-262. On prend l'hypothèse que <code>Object</code> et <code>TypeError</code> ont leurs valeurs originales (n'ont pas été modifiés) et que <code>callbackfn.call</code> correspond bien à la valeur originale de {{jsxref("Function.prototype.call")}}</p>
+`every` fut ajouté avec la cinquième édition du standard ECMA-262. Pour cette raison, il n'est pas nécessairement présent dans les différentes implémentations de ce standard. Afin de faire fonctionner du code dans un environnement qui ne possède pas cette fonctionnalité, on pourra utiliser le fragment de code suivant au début des scripts. Cet algorithme correspond exactement à celui défini dans la cinquième édition du standard ECMA-262. On prend l'hypothèse que `Object` et `TypeError` ont leurs valeurs originales (n'ont pas été modifiés) et que `callbackfn.call` correspond bien à la valeur originale de {{jsxref("Function.prototype.call")}}
 
-<pre class="brush: js">if (!Array.prototype.every) {
+```js
+if (!Array.prototype.every) {
   Array.prototype.every = function(callbackfn, thisArg) {
     'use strict';
     var T, k;
@@ -105,7 +104,7 @@ original_slug: Web/JavaScript/Reference/Objets_globaux/Array/every
     // 2. Soit lenValue le résultat de l'appel de la méthode interne
     //   Get sur O avec l'argument "length".
     // 3. Soit len le résultat de ToUint32(lenValue).
-    var len = O.length &gt;&gt;&gt; 0;
+    var len = O.length >>> 0;
 
     // 4. Si IsCallable(callbackfn) est faux, on lève une exception
     // TypeError.
@@ -114,15 +113,15 @@ original_slug: Web/JavaScript/Reference/Objets_globaux/Array/every
     }
 
     // 5. Si thisArg a été fourni : soit T cette valeur thisArg, undefined sinon.
-    if (arguments.length &gt; 1) {
+    if (arguments.length > 1) {
       T = thisArg;
     }
 
     // 6. Soit k égal à 0.
     k = 0;
 
-    // 7. On répète tant que k &lt; len
-    while (k &lt; len) {
+    // 7. On répète tant que k < len
+    while (k < len) {
 
       var kValue;
 
@@ -153,44 +152,23 @@ original_slug: Web/JavaScript/Reference/Objets_globaux/Array/every
     return 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('ES5.1', '#sec-15.4.4.16', 'Array.prototype.every')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td>Définition initiale. Implémentée avec JavaScript 1.6.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-array.prototype.every', 'Array.prototype.every')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-array.prototype.every', 'Array.prototype.every')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Array.every")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Array.prototype.forEach()")}}</li>
- <li>{{jsxref("Array.prototype.some()")}}</li>
- <li>{{jsxref("Array.prototype.find()")}}</li>
- <li>{{jsxref("TypedArray.prototype.every()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                            | État                         | Commentaires                                          |
+| -------------------------------------------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- |
+| {{SpecName('ES5.1', '#sec-15.4.4.16', 'Array.prototype.every')}}                     | {{Spec2('ES5.1')}}     | Définition initiale. Implémentée avec JavaScript 1.6. |
+| {{SpecName('ES6', '#sec-array.prototype.every', 'Array.prototype.every')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-array.prototype.every', 'Array.prototype.every')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Array.every")}}
+
+## Voir aussi
+
+- {{jsxref("Array.prototype.forEach()")}}
+- {{jsxref("Array.prototype.some()")}}
+- {{jsxref("Array.prototype.find()")}}
+- {{jsxref("TypedArray.prototype.every()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/array/fill/index.md b/files/fr/web/javascript/reference/global_objects/array/fill/index.md
index dc4d155415..7b9928f46d 100644
--- a/files/fr/web/javascript/reference/global_objects/array/fill/index.md
+++ b/files/fr/web/javascript/reference/global_objects/array/fill/index.md
@@ -12,49 +12,47 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Array/fill
 original_slug: Web/JavaScript/Reference/Objets_globaux/Array/fill
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>fill()</code></strong> remplit tous les éléments d'un tableau entre deux index avec une valeur statique. La valeur de l'index de fin n'est pas incluse. Cette méthode renvoie le tableau modifié.</p>
+La méthode **`fill()`** remplit tous les éléments d'un tableau entre deux index avec une valeur statique. La valeur de l'index de fin n'est pas incluse. Cette méthode renvoie le tableau modifié.
 
-<div>{{EmbedInteractiveExample("pages/js/array-fill.html")}}</div>
+{{EmbedInteractiveExample("pages/js/array-fill.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>arr</var>.fill(valeur<var><var>)
-</var>arr</var>.fill(valeur, <var>début<var>)
-</var>arr</var>.fill(valeur, <var>début<var>, <var>fin</var>)</var></var>
-</pre>
+    arr.fill(valeur)
+    arr.fill(valeur, début)
+    arr.fill(valeur, début, fin)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>valeur</code></dt>
- <dd>Valeur avec laquelle remplir le tableau.</dd>
- <dt><code>début</code> {{optional_inline}}</dt>
- <dd>Index de début, la valeur par défaut est 0.</dd>
- <dt><code>fin</code> {{optional_inline}}</dt>
- <dd>Index de fin, la valeur par défaut est <code>this.length</code>.</dd>
-</dl>
+- `valeur`
+  - : Valeur avec laquelle remplir le tableau.
+- `début` {{optional_inline}}
+  - : Index de début, la valeur par défaut est 0.
+- `fin` {{optional_inline}}
+  - : Index de fin, la valeur par défaut est `this.length`.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Le tableau modifié par la méthode.</p>
+Le tableau modifié par la méthode.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Les éléments pour lesquels on utilisera la valeur sont ceux contenus dans l'intervalle de positions [<code>début</code>, <code>fin</code>].</p>
+Les éléments pour lesquels on utilisera la valeur sont ceux contenus dans l'intervalle de positions \[`début`, `fin`].
 
-<p>La méthode <code>fill()</code> prend jusqu'à trois arguments : <code>valeur</code>, <code>début</code> et <code>fin</code>. Les arguments <code>début</code> et <code>fin</code> sont optionnels. Leurs valeurs par défaut sont respectivement <code>0</code> et la taille <code>length</code> de l'objet <code>this</code>.</p>
+La méthode `fill()` prend jusqu'à trois arguments : `valeur`, `début` et `fin`. Les arguments `début` et `fin` sont optionnels. Leurs valeurs par défaut sont respectivement `0` et la taille `length` de l'objet `this`.
 
-<p>Si <code>début</code> est négatif, il sera traité comme <code>length+début</code> où <code>length</code> est la taille du tableau. Si <code>fin</code> est négatif, il est traité comme <code>length+fin</code>.</p>
+Si `début` est négatif, il sera traité comme `length+début` où `length` est la taille du tableau. Si `fin` est négatif, il est traité comme `length+fin`.
 
-<p>La fonction <code>fill()</code> est intentionnellement générique, il n'est pas nécessaire que sa valeur <code>this</code> soit un objet <code>Array</code>.</p>
+La fonction `fill()` est intentionnellement générique, il n'est pas nécessaire que sa valeur `this` soit un objet `Array`.
 
-<p>La méthode <code>fill()</code> est une méthode de modification, elle changera l'objet <code>this</code> lui-même, et renverra l'objet modifié. Elle ne crée pas de copie. Lorsque cette méthode reçoit un objet comme valeur, elle copiera l'objet passé et remplira le tableau avec une référence vers cette copie.</p>
+La méthode `fill()` est une méthode de modification, elle changera l'objet `this` lui-même, et renverra l'objet modifié. Elle ne crée pas de copie. Lorsque cette méthode reçoit un objet comme valeur, elle copiera l'objet passé et remplira le tableau avec une référence vers cette copie.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<pre class="brush: js">[1, 2, 3].fill(4);            // [4, 4, 4]
+```js
+[1, 2, 3].fill(4);            // [4, 4, 4]
 [1, 2, 3].fill(4, 1);         // [1, 4, 4]
 [1, 2, 3].fill(4, 1, 2);      // [1, 4, 3]
 [1, 2, 3].fill(4, 1, 1);      // [1, 2, 3]
@@ -67,11 +65,12 @@ Array(3).fill(4);             // [4, 4, 4]
 // Les objets sont copiés via une référence
 var arr = Array(3).fill({}); // [{}, {}, {}];
 arr[0].yop = "yop"; // [{yop: "yop"}, {yop: "yop"}, {yop: "yop"}]
-</pre>
+```
 
-<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 (!Array.prototype.fill) {
+```js
+if (!Array.prototype.fill) {
   Object.defineProperty(Array.prototype, 'fill', {
     value: function(value) {
 
@@ -83,29 +82,29 @@ arr[0].yop = "yop"; // [{yop: "yop"}, {yop: "yop"}, {yop: "yop"}]
       var O = Object(this);
 
       // Steps 3-5.
-      var len = O.length &gt;&gt;&gt; 0;
+      var len = O.length >>> 0;
 
       // Steps 6-7.
       var start = arguments[1];
-      var relativeStart = start &gt;&gt; 0;
+      var relativeStart = start >> 0;
 
       // Step 8.
-      var k = relativeStart &lt; 0 ?
+      var k = relativeStart < 0 ?
         Math.max(len + relativeStart, 0) :
         Math.min(relativeStart, len);
 
       // Steps 9-10.
       var end = arguments[2];
       var relativeEnd = end === undefined ?
-        len : end &gt;&gt; 0;
+        len : end >> 0;
 
       // Step 11.
-      var final = relativeEnd &lt; 0 ?
+      var final = relativeEnd < 0 ?
         Math.max(len + relativeEnd, 0) :
         Math.min(relativeEnd, len);
 
       // Step 12.
-      while (k &lt; final) {
+      while (k < final) {
         O[k] = value;
         k++;
       }
@@ -114,37 +113,21 @@ arr[0].yop = "yop"; // [{yop: "yop"}, {yop: "yop"}, {yop: "yop"}]
       return O;
     }
   });
-}</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-array.prototype.fill', 'Array.prototype.fill')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-array.prototype.fill', 'Array.prototype.fill')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Array.fill")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Array")}}</li>
- <li>{{jsxref("TypedArray.prototype.fill()")}}</li>
-</ul>
+}
+```
+
+## Spécifications
+
+| Spécification                                                                                        | État                         | Commentaires         |
+| ---------------------------------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ES2015', '#sec-array.prototype.fill', 'Array.prototype.fill')}} | {{Spec2('ES2015')}}     | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-array.prototype.fill', 'Array.prototype.fill')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Array.fill")}}
+
+## Voir aussi
+
+- {{jsxref("Array")}}
+- {{jsxref("TypedArray.prototype.fill()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/array/filter/index.md b/files/fr/web/javascript/reference/global_objects/array/filter/index.md
index 1894ac6f4c..d6f1b51909 100644
--- a/files/fr/web/javascript/reference/global_objects/array/filter/index.md
+++ b/files/fr/web/javascript/reference/global_objects/array/filter/index.md
@@ -12,76 +12,75 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Array/filter
 original_slug: Web/JavaScript/Reference/Objets_globaux/Array/filter
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>filter()</strong></code> crée et retourne un nouveau tableau contenant tous les éléments du tableau d'origine qui remplissent une condition déterminée par la fonction <code>callback</code>.</p>
+La méthode **`filter()`** crée et retourne un nouveau tableau contenant tous les éléments du tableau d'origine qui remplissent une condition déterminée par la fonction `callback`.
 
-<div>{{EmbedInteractiveExample("pages/js/array-filter.html")}}</div>
+{{EmbedInteractiveExample("pages/js/array-filter.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>arr</var>.filter(<var>callback)</var>; // callback(elementCourant[, index[, tableauEntier]])
-var nouveauTableau = arr.filter(callback, <var>thisArg</var>);
-</pre>
+    arr.filter(callback); // callback(elementCourant[, index[, tableauEntier]])
+    var nouveauTableau = arr.filter(callback, thisArg);
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>callback</code></dt>
- <dd>La fonction de test (ou <em>prédicat</em>) à appliquer à chaque élément du tableau. Cette fonction est appelée avec les arguments suivants :
- <dl>
-  <dt><code>elementCourant</code></dt>
-  <dd>L'élément à traiter</dd>
-  <dt><code>index</code></dt>
-  <dd>Son indice.</dd>
-  <dt><code>array</code></dt>
-  <dd>Le tableau complet</dd>
- </dl>
- Cette fonction renvoie <code>true</code> — ou une valeur équivalente — si l'élément doit être conservé pour le tableau résultat et <code>false</code> dans le cas contraire.</dd>
- <dt><code>thisArg</code> {{optional_inline}}</dt>
- <dd>Objet à utiliser en tant que <code>this</code> quand la fonction <code>callback</code> est exécutée.</dd>
-</dl>
+- `callback`
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+  - : La fonction de test (ou _prédicat_) à appliquer à chaque élément du tableau. Cette fonction est appelée avec les arguments suivants :
 
-<p>Un nouveau tableau contenant les éléments qui respectent la condition du filtre. Si aucun élément ne respecte la condition, c'est un tableau vide qui est renvoyé.</p>
+    - `elementCourant`
+      - : L'élément à traiter
+    - `index`
+      - : Son indice.
+    - `array`
+      - : Le tableau complet
 
-<h2 id="Description">Description</h2>
+    Cette fonction renvoie `true` — ou une valeur équivalente — si l'élément doit être conservé pour le tableau résultat et `false` dans le cas contraire.
 
-<p><code>filter()</code> appelle la fonction <code>callback</code> fournie pour chacun des éléments d'un tableau, et construit un nouveau tableau contenant tous les éléments pour lesquels l'appel de <code>callback</code> retourne <code>true</code> ou une valeur équivalente à <code>true</code> dans un contexte booléen. La fonction <code>callback</code> n'est utilisée que pour les éléments du tableau ayant une valeur assignée — les index supprimés ou pour lesquels il n'y a jamais eu de valeur ne sont pas pris en compte. Les éléments du tableau qui ne passent pas le test effectué par la fonction <code>callback</code> sont ignorés, ils ne sont pas inclus dans le nouveau tableau.</p>
+- `thisArg` {{optional_inline}}
+  - : Objet à utiliser en tant que `this` quand la fonction `callback` est exécutée.
 
-<p>La fonction <code>callback</code> est appelée avec trois arguments :</p>
+### Valeur de retour
 
-<ol>
- <li>la valeur de l'élément courant,</li>
- <li>l'index de l'élément courant,</li>
- <li>l'objet <code>Array</code> parcouru.</li>
-</ol>
+Un nouveau tableau contenant les éléments qui respectent la condition du filtre. Si aucun élément ne respecte la condition, c'est un tableau vide qui est renvoyé.
 
-<p>Si le paramètre <code>thisArg</code> est fourni, il sera utilisé comme valeur <code>this</code> lors de l'appel de la fonction <code>callback</code>. S'il n'est pas fourni, la valeur <code>undefined</code> sera utilisée à la place. La valeur de <code>this</code> qui est finalement utilisée par la fonction <code>callback</code> est déterminée selon <a href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/L_op%C3%A9rateur_this">les règles usuelles pour déterminer la valeur <code>this</code> au sein d'une fonction</a>.</p>
+## Description
 
-<p>Noter que <code>filter()</code> ne modifie pas le tableau d'origine.</p>
+`filter()` appelle la fonction `callback` fournie pour chacun des éléments d'un tableau, et construit un nouveau tableau contenant tous les éléments pour lesquels l'appel de `callback` retourne `true` ou une valeur équivalente à `true` dans un contexte booléen. La fonction `callback` n'est utilisée que pour les éléments du tableau ayant une valeur assignée — les index supprimés ou pour lesquels il n'y a jamais eu de valeur ne sont pas pris en compte. Les éléments du tableau qui ne passent pas le test effectué par la fonction `callback` sont ignorés, ils ne sont pas inclus dans le nouveau tableau.
 
-<p>La liste des éléments parcourus par <code>filter()</code> est définie avant la première invocation de la fonction <code>callback</code>. Les éléments qui sont ajoutés à la liste après le début de l'appel de <code>filter()</code> (grâce à la fonction <code>callback</code> par exemple) ne seront pas concernés par le filtre. Si des éléments de la liste sont modifiés ou supprimés au cours du traitement, la valeur fournie à la fonction <code>callback</code> sera la valeur de ces éléments au moment où <code>filter()</code> les traite — les éléments supprimés ne seront pas traités par la fonction.</p>
+La fonction `callback` est appelée avec trois arguments :
 
-<h2 id="Exemples">Exemples</h2>
+1.  la valeur de l'élément courant,
+2.  l'index de l'élément courant,
+3.  l'objet `Array` parcouru.
 
-<h3 id="Filtrer_les_petites_valeurs">Filtrer les petites valeurs</h3>
+Si le paramètre `thisArg` est fourni, il sera utilisé comme valeur `this` lors de l'appel de la fonction `callback`. S'il n'est pas fourni, la valeur `undefined` sera utilisée à la place. La valeur de `this` qui est finalement utilisée par la fonction `callback` est déterminée selon [les règles usuelles pour déterminer la valeur `this` au sein d'une fonction](/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/L_op%C3%A9rateur_this).
 
-<p>L'exemple suivant utilise <code>filter</code> pour créer une nouvelle liste où tous les éléments dont la valeur est inférieure à 10 ont été retirés.</p>
+Noter que `filter()` ne modifie pas le tableau d'origine.
 
-<pre class="brush: js">function suffisammentGrand(element) {
-  return element &gt;= 10;
+La liste des éléments parcourus par `filter()` est définie avant la première invocation de la fonction `callback`. Les éléments qui sont ajoutés à la liste après le début de l'appel de `filter()` (grâce à la fonction `callback` par exemple) ne seront pas concernés par le filtre. Si des éléments de la liste sont modifiés ou supprimés au cours du traitement, la valeur fournie à la fonction `callback` sera la valeur de ces éléments au moment où `filter()` les traite — les éléments supprimés ne seront pas traités par la fonction.
+
+## Exemples
+
+### Filtrer les petites valeurs
+
+L'exemple suivant utilise `filter` pour créer une nouvelle liste où tous les éléments dont la valeur est inférieure à 10 ont été retirés.
+
+```js
+function suffisammentGrand(element) {
+  return element >= 10;
 }
 var filtre = [12, 5, 8, 130, 44].filter(suffisammentGrand);
 // filtre vaut [12, 130, 44]
-</pre>
+```
 
-<h3 id="Filtrer_des_éléments_JSON_invalides_et_les_trier_en_fonction_d'un_identifiant_avec_filter()">Filtrer des éléments JSON invalides et les trier en fonction d'un identifiant avec <code>filter()</code></h3>
+### Filtrer des éléments JSON invalides et les trier en fonction d'un identifiant avec `filter()`
 
-<p>Dans l'exemple qui suit, on utilise <code>filter()</code> pour créer un objet JSON qui contient des éléments dont l'<code>id</code> est un entier.</p>
+Dans l'exemple qui suit, on utilise `filter()` pour créer un objet JSON qui contient des éléments dont l'`id` est un entier.
 
-<pre class="brush: js">var arr = [
+```js
+var arr = [
   { id: 15 },
   { id: -1 },
   { id: 0 },
@@ -97,7 +96,7 @@ var elementsInvalides = 0;
 
 function filtrerParID(obj) {
   // Si c'est un nombre
-  if (obj.id !== undefined &amp;&amp; typeof(obj.id) === 'number' &amp;&amp; !isNaN(obj.id)) {
+  if (obj.id !== undefined && typeof(obj.id) === 'number' && !isNaN(obj.id)) {
     return true;
   } else {
     elementsInvalides++;
@@ -112,13 +111,15 @@ console.log('Tableau filtré\n', arrByID);
 // [{ id: 15 }, { id: -1 }, { id: 0 }, { id: 3 }, { id: 12.2 }]
 
 console.log('Nombre d\'éléments invalides = ', elementsInvalides);
-// Nombre d'éléments invalides 4</pre>
+// Nombre d'éléments invalides 4
+```
 
-<h3 id="Recherche_dans_un_tableau">Recherche dans un tableau</h3>
+### Recherche dans un tableau
 
-<p>Dans l'exemple qui suit, on utilise <code>filter()</code> pour filtrer le contenu d'un tableau selon un critère donné.</p>
+Dans l'exemple qui suit, on utilise `filter()` pour filtrer le contenu d'un tableau selon un critère donné.
 
-<pre class="brush: js">var fruits = ['pomme', 'banane', 'raisin', 'mangue'];
+```js
+var fruits = ['pomme', 'banane', 'raisin', 'mangue'];
 
 function filtreTexte(arr, requete) {
   return arr.filter(function (el) {
@@ -128,32 +129,35 @@ function filtreTexte(arr, requete) {
 
 console.log(filtreTexte(fruits, 'an')); // ['banane', 'mangue'];
 console.log(filtreTexte(fruits, 'm')); // ['pomme', 'mangue'];
-</pre>
+```
 
-<h3 id="Implémentation_avec_la_syntaxe_ECMAScript_2015_(ES6)">Implémentation avec la syntaxe ECMAScript 2015 (ES6)</h3>
+### Implémentation avec la syntaxe ECMAScript 2015 (ES6)
 
-<p>L'exemple suivant utilise <a href="/fr/docs/Web/JavaScript/Reference/Fonctions/Fonctions_fléchées">les fonctions fléchées</a>, et le mot clé <a href="/fr/docs/Web/JavaScript/Reference/Instructions/const"><code>const</code> </a>disponible en ES6.</p>
+L'exemple suivant utilise [les fonctions fléchées](/fr/docs/Web/JavaScript/Reference/Fonctions/Fonctions_fléchées), et le mot clé [`const` ](/fr/docs/Web/JavaScript/Reference/Instructions/const)disponible en ES6.
 
-<pre class="brush: js">const fruits = ['pomme', 'banane', 'raisin', 'mangue'];
+```js
+const fruits = ['pomme', 'banane', 'raisin', 'mangue'];
 
-const filtreTexte = (arr, requete) =&gt; {
-  return arr.filter(el =&gt;  el.toLowerCase().indexOf(requete.toLowerCase()) !== -1);
+const filtreTexte = (arr, requete) => {
+  return arr.filter(el =>  el.toLowerCase().indexOf(requete.toLowerCase()) !== -1);
 }
 
 console.log(filtreTexte(fruits, 'an')); // ['banane', 'mangue'];
-console.log(filtreTexte(fruits, 'm')); // ['pomme', 'mangue'];</pre>
+console.log(filtreTexte(fruits, 'm')); // ['pomme', 'mangue'];
+```
 
-<h2 id="Prothèse_d'émulation_(polyfill)">Prothèse d'émulation (<em>polyfill</em>)</h2>
+## Prothèse d'émulation (_polyfill_)
 
-<p><code>Array.prototype.filter()</code> a été ajoutée avec la cinquième édition du standard ECMA-262 — ainsi elle pourrait ne pas être présente dans toutes les implémentations du standard. Ce problème peut être contourné en ajoutant le code suivant au début des scripts et permettra d'utiliser <code>filter</code> au sein d'implémentations qui n'en bénéficient pas nativement. Cet algorithme est strictement celui spécifié par la cinquième édition d'ECMA-262, en considérant que <code>callbackfn.call</code> est évaluée avec la valeur d'origine de {{jsxref("Function.prototype.call")}} et que {{jsxref("Array.prototype.push")}} a sa valeur d'origine.</p>
+`Array.prototype.filter()` a été ajoutée avec la cinquième édition du standard ECMA-262 — ainsi elle pourrait ne pas être présente dans toutes les implémentations du standard. Ce problème peut être contourné en ajoutant le code suivant au début des scripts et permettra d'utiliser `filter` au sein d'implémentations qui n'en bénéficient pas nativement. Cet algorithme est strictement celui spécifié par la cinquième édition d'ECMA-262, en considérant que `callbackfn.call` est évaluée avec la valeur d'origine de {{jsxref("Function.prototype.call")}} et que {{jsxref("Array.prototype.push")}} a sa valeur d'origine.
 
-<pre class="brush: js">if (!Array.prototype.filter){
+```js
+if (!Array.prototype.filter){
   Array.prototype.filter = function(func, thisArg) {
     'use strict';
-    if ( ! ((typeof func === 'Function' || typeof func === 'function') &amp;&amp; this) )
+    if ( ! ((typeof func === 'Function' || typeof func === 'function') && this) )
         throw new TypeError();
 
-    var len = this.length &gt;&gt;&gt; 0,
+    var len = this.length >>> 0,
         res = new Array(len), // preallocate array
         t = this, c = 0, i = -1;
     if (thisArg === undefined){
@@ -180,44 +184,24 @@ console.log(filtreTexte(fruits, 'm')); // ['pomme', 'mangue'];</pre>
     res.length = c; // shrink down array to proper size
     return res;
   };
-}</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.4.4.20', 'Array.prototype.filter')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td>Définition initiale. Implémentée avec JavaScript 1.6.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES2015', '#sec-array.prototype.filter', 'Array.prototype.filter')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-array.prototype.filter', 'Array.prototype.filter')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Array.filter")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Array.prototype.forEach()")}}</li>
- <li>{{jsxref("Array.prototype.every()")}}</li>
- <li>{{jsxref("Array.prototype.some()")}}</li>
- <li>{{jsxref("Array.prototype.reduce()")}}</li>
-</ul>
+}
+```
+
+## Spécifications
+
+| Spécification                                                                                                | État                         | Commentaires                                          |
+| ------------------------------------------------------------------------------------------------------------ | ---------------------------- | ----------------------------------------------------- |
+| {{SpecName('ES5.1', '#sec-15.4.4.20', 'Array.prototype.filter')}}                     | {{Spec2('ES5.1')}}     | Définition initiale. Implémentée avec JavaScript 1.6. |
+| {{SpecName('ES2015', '#sec-array.prototype.filter', 'Array.prototype.filter')}}     | {{Spec2('ES2015')}}     |                                                       |
+| {{SpecName('ESDraft', '#sec-array.prototype.filter', 'Array.prototype.filter')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Array.filter")}}
+
+## Voir aussi
+
+- {{jsxref("Array.prototype.forEach()")}}
+- {{jsxref("Array.prototype.every()")}}
+- {{jsxref("Array.prototype.some()")}}
+- {{jsxref("Array.prototype.reduce()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/array/find/index.md b/files/fr/web/javascript/reference/global_objects/array/find/index.md
index 19ef805ebd..c66c0ac9db 100644
--- a/files/fr/web/javascript/reference/global_objects/array/find/index.md
+++ b/files/fr/web/javascript/reference/global_objects/array/find/index.md
@@ -12,59 +12,56 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Array/find
 original_slug: Web/JavaScript/Reference/Objets_globaux/Array/find
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>find()</strong></code> renvoie la <strong>valeur</strong> du <strong>premier élément trouvé </strong>dans le tableau qui respecte la condition donnée par la fonction de test passée en argument. Sinon, la valeur {{jsxref("undefined")}} est renvoyée.</p>
+La méthode **`find()`** renvoie la **valeur** du **premier élément trouvé** dans le tableau qui respecte la condition donnée par la fonction de test passée en argument. Sinon, la valeur {{jsxref("undefined")}} est renvoyée.
 
-<div>{{EmbedInteractiveExample("pages/js/array-find.html")}}</div>
+{{EmbedInteractiveExample("pages/js/array-find.html")}}
 
+Voir aussi la méthode {{jsxref("Array.findIndex", "findIndex()")}} qui renvoie l'**index** de l'élément trouvé et non sa valeur. Si on souhaite repérer la position d'un élément donné dans le tableau, on pourra utiliser {{jsxref("Array.prototype.indexOf()")}}. Si on souhaite déterminer si un tableau contient un élément donné, on pourra utiliser la méthode {{jsxref("Array.prototype.includes()")}}.
 
+## Syntaxe
 
-<p>Voir aussi la méthode {{jsxref("Array.findIndex", "findIndex()")}} qui renvoie l'<strong>index</strong> de l'élément trouvé et non sa valeur. Si on souhaite repérer la position d'un élément donné dans le tableau, on pourra utiliser {{jsxref("Array.prototype.indexOf()")}}. Si on souhaite déterminer si un tableau contient un élément donné, on pourra utiliser la méthode {{jsxref("Array.prototype.includes()")}}.</p>
+    arr.find(callback(element[, index[, tableau]])[, thisArg])
 
-<h2 id="Syntaxe">Syntaxe</h2>
+### Paramètres
 
-<pre class="syntaxbox"><var>arr</var>.find(<var>callback</var>(element[, index[, tableau]])[, <var>thisArg</var>])</pre>
+- `callback`
 
-<h3 id="Paramètres">Paramètres</h3>
+  - : Fonction à exécuter sur chaque valeur du tableau, elle prend 3 arguments :
 
-<dl>
- <dt><code>callback</code></dt>
- <dd>Fonction à exécuter sur chaque valeur du tableau, elle prend 3 arguments :
- <dl>
-  <dt><code>element</code></dt>
-  <dd>L'élément actuellement traité dans le tableau.</dd>
-  <dt><code>index</code>{{optional_inline}}</dt>
-  <dd>L'index de l'élément actuellement traité dans le tableau</dd>
-  <dt><code>array</code>{{optional_inline}}</dt>
-  <dd>Le tableau pour lequel la méthode <code>find</code> a été appelée.</dd>
- </dl>
- </dd>
- <dt><code>thisArg</code> {{optional_inline}}</dt>
- <dd>Ce paramètre est optionnel. Objet à utiliser en tant que <code>this</code> lorsque la fonction <code>callback</code> est exécutée.</dd>
-</dl>
+    - `element`
+      - : L'élément actuellement traité dans le tableau.
+    - `index`{{optional_inline}}
+      - : L'index de l'élément actuellement traité dans le tableau
+    - `array`{{optional_inline}}
+      - : Le tableau pour lequel la méthode `find` a été appelée.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+- `thisArg` {{optional_inline}}
+  - : Ce paramètre est optionnel. Objet à utiliser en tant que `this` lorsque la fonction `callback` est exécutée.
 
-<p>La valeur du premier élément du tableau qui réussit le test, sinon {{jsxref("undefined")}}.</p>
+### Valeur de retour
 
-<h2 id="Description">Description</h2>
+La valeur du premier élément du tableau qui réussit le test, sinon {{jsxref("undefined")}}.
 
-<p>La méthode <code>find</code> exécute la fonction <code>callback</code> une fois pour chaque élément présent dans le tableau jusqu'à ce qu'elle retourne une valeur vraie (qui peut être convertie en <code>true</code>). Si un élément est trouvé, <code>find</code> retourne immédiatement la valeur de l'élément. Autrement, <code>find</code> retourne <code>undefined</code>. La méthode <code>callback</code> est seulement appelée pour les index du tableau pour lesquels on dispose d'une valeur. Elle n'est pas appelée pour les index supprimés ou pour ceux qui n'ont pas de valeur.</p>
+## Description
 
-<p>La méthode <code>callback</code> est appelée avec trois arguments : la valeur de l'élément, l'index de l'élément, et l'objet correspondant au tableau traversé.</p>
+La méthode `find` exécute la fonction `callback` une fois pour chaque élément présent dans le tableau jusqu'à ce qu'elle retourne une valeur vraie (qui peut être convertie en `true`). Si un élément est trouvé, `find` retourne immédiatement la valeur de l'élément. Autrement, `find` retourne `undefined`. La méthode `callback` est seulement appelée pour les index du tableau pour lesquels on dispose d'une valeur. Elle n'est pas appelée pour les index supprimés ou pour ceux qui n'ont pas de valeur.
 
-<p>Si le paramètre <code>thisArg</code> est fourni à <code>find</code>, il sera utilisé comme le <code>this</code> pour chaque exécution de la fonction <code>callback</code>. S'il n'est pas fourni, alors {{jsxref("undefined")}} sera utilisé.</p>
+La méthode `callback` est appelée avec trois arguments : la valeur de l'élément, l'index de l'élément, et l'objet correspondant au tableau traversé.
 
-<p><code>find</code> ne modifie pas le tableau à partir duquel elle est appelée.</p>
+Si le paramètre `thisArg` est fourni à `find`, il sera utilisé comme le `this` pour chaque exécution de la fonction `callback`. S'il n'est pas fourni, alors {{jsxref("undefined")}} sera utilisé.
 
-<p>L'intervalle des éléments inspectés par <code>find</code> est défini avant la première exécution de <code>callback</code>. Les éléments ajoutés au tableau après l'appel à <code>find</code> ne seront pas inspectés par la fonction <code>callback</code>. Si un élément existant est modifié avant le passage du <code>callback</code>, alors la valeur traitée par le <code>callback</code> sera celle présente lors du passage de <code>find</code> sur son index. Les éléments supprimés ne seront pas traités.</p>
+`find` ne modifie pas le tableau à partir duquel elle est appelée.
 
-<h2 id="Exemples">Exemples</h2>
+L'intervalle des éléments inspectés par `find` est défini avant la première exécution de `callback`. Les éléments ajoutés au tableau après l'appel à `find` ne seront pas inspectés par la fonction `callback`. Si un élément existant est modifié avant le passage du `callback`, alors la valeur traitée par le `callback` sera celle présente lors du passage de `find` sur son index. Les éléments supprimés ne seront pas traités.
 
-<h3 id="Trouver_un_objet_dans_un_tableau_grâce_à_une_de_ses_propriétés">Trouver un objet dans un tableau grâce à une de ses propriétés</h3>
+## Exemples
 
-<pre class="brush: js">const inventaire = [
+### Trouver un objet dans un tableau grâce à une de ses propriétés
+
+```js
+const inventaire = [
   {nom: 'pommes', quantité: 2},
   {nom: 'bananes', quantité: 0},
   {nom: 'cerises', quantité: 5}
@@ -75,68 +72,55 @@ function estCerises(fruit) {
 }
 
 console.log(inventaire.find(estCerises));
-// { nom: 'cerises', quantité: 5}</pre>
+// { nom: 'cerises', quantité: 5}
+```
 
-<h4 id="Utiliser_les_fonctions_fléchées_ES6ES2015">Utiliser les fonctions fléchées ES6/ES2015</h4>
+#### Utiliser les fonctions fléchées ES6/ES2015
 
-<pre class="brush: js">const inventaire = [
+```js
+const inventaire = [
                      {nom: 'pommes', quantité: 2},
                      {nom: 'bananes', quantité: 0},
                      {nom: 'cerises', quantité: 5}
                    ];
 
-const resultat = inventaire.find( fruit =&gt; fruit.nom === 'cerises');
+const resultat = inventaire.find( fruit => fruit.nom === 'cerises');
 console.log(resultat);
-// { nom: 'cerises', quantité: 5}</pre>
+// { nom: 'cerises', quantité: 5}
+```
 
-<h3 id="Trouver_un_nombre_premier_dans_un_tableau">Trouver un nombre premier dans un tableau</h3>
+### Trouver un nombre premier dans un tableau
 
-<p>Dans l'exemple suivant, on cherche un nombre premier parmi les éléments d'un tableau (ou retourne <code>undefined</code> s'il n'y en a pas ).</p>
+Dans l'exemple suivant, on cherche un nombre premier parmi les éléments d'un tableau (ou retourne `undefined` s'il n'y en a pas ).
 
-<pre class="brush: js">function estPremier(element, index, array) {
+```js
+function estPremier(element, index, array) {
     let début = 2;
-    while (début &lt;= Math.sqrt(element)) {
-        if (element % début ++ &lt; 1) return false;
+    while (début <= Math.sqrt(element)) {
+        if (element % début ++ < 1) return false;
     }
-    return (element &gt; 1);
+    return (element > 1);
 }
 
 console.log( [4, 6, 8, 12].find(estPremier) ); // undefined, rien trouvé
 console.log( [4, 5, 8, 12].find(estPremier) ); // 5
-</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-array.prototype.find', 'Array.prototype.find')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-array.prototype.find', 'Array.prototype.find')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Array.find")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Array.prototype.findIndex()")}} – trouver et renvoyer un index</li>
- <li>{{jsxref("Array.prototype.includes()")}} – tester si une valeur existe dans le tableau</li>
- <li>{{jsxref("Array.prototype.filter()")}} – trouver tous les éléments correspondants</li>
- <li>{{jsxref("Array.prototype.every()")}} – tester l'ensemble des éléments d'un tableau</li>
- <li>{{jsxref("Array.prototype.some()")}} – tester si au moins un élément du tableau respecte un critère</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                        | État                         | Commentaires        |
+| ---------------------------------------------------------------------------------------------------- | ---------------------------- | ------------------- |
+| {{SpecName('ES2015', '#sec-array.prototype.find', 'Array.prototype.find')}} | {{Spec2('ES2015')}}     | Définition initiale |
+| {{SpecName('ESDraft', '#sec-array.prototype.find', 'Array.prototype.find')}} | {{Spec2('ESDraft')}} |                     |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Array.find")}}
+
+## Voir aussi
+
+- {{jsxref("Array.prototype.findIndex()")}} – trouver et renvoyer un index
+- {{jsxref("Array.prototype.includes()")}} – tester si une valeur existe dans le tableau
+- {{jsxref("Array.prototype.filter()")}} – trouver tous les éléments correspondants
+- {{jsxref("Array.prototype.every()")}} – tester l'ensemble des éléments d'un tableau
+- {{jsxref("Array.prototype.some()")}} – tester si au moins un élément du tableau respecte un critère
diff --git a/files/fr/web/javascript/reference/global_objects/array/findindex/index.md b/files/fr/web/javascript/reference/global_objects/array/findindex/index.md
index 9564b24021..5a4a20328c 100644
--- a/files/fr/web/javascript/reference/global_objects/array/findindex/index.md
+++ b/files/fr/web/javascript/reference/global_objects/array/findindex/index.md
@@ -12,88 +12,89 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Array/findIndex
 original_slug: Web/JavaScript/Reference/Objets_globaux/Array/findIndex
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>findIndex()</strong></code> renvoie l'<strong>indice</strong> du <strong>premier élément</strong> du tableau qui satisfait une condition donnée par une fonction. Si la fonction renvoie faux pour tous les éléments du tableau, le résultat vaut -1.</p>
+La méthode **`findIndex()`** renvoie l'**indice** du **premier élément** du tableau qui satisfait une condition donnée par une fonction. Si la fonction renvoie faux pour tous les éléments du tableau, le résultat vaut -1.
 
-<div>{{EmbedInteractiveExample("pages/js/array-findindex.html")}}</div>
+{{EmbedInteractiveExample("pages/js/array-findindex.html")}}
 
+Voir également la méthode {{jsxref("Array.find", "find()")}} qui renvoie la **valeur** (et non l'indice) d'un des éléments trouvés.
 
+## Syntaxe
 
-<p>Voir également la méthode {{jsxref("Array.find", "find()")}} qui renvoie la <strong>valeur</strong> (et non l'indice) d'un des éléments trouvés.</p>
+    arr.findIndex(callback(element[, index[, tableau]])[, thisArg])
 
-<h2 id="Syntaxe">Syntaxe</h2>
+### Paramètres
 
-<pre class="syntaxbox"><var>arr</var>.findIndex(<var>callback</var>(element[, index[, tableau]])[, <var>thisArg</var>])</pre>
+- `callback`
 
-<h3 id="Paramètres">Paramètres</h3>
+  - : Une fonction à exécuter sur chaque valeur du tableau jusqu'à ce que celle-ci renvoie `true`. Cette fonction prend trois arguments :
 
-<dl>
- <dt><code>callback</code></dt>
- <dd>Une fonction à exécuter sur chaque valeur du tableau jusqu'à ce que celle-ci renvoie <code>true</code>. Cette fonction prend trois arguments :
- <dl>
-  <dt><code>élément</code></dt>
-  <dd>L'élément du tableau qui doit être traité.</dd>
-  <dt><code>indice</code>{{optional_inline}}</dt>
-  <dd>L'indice de l'élément du tableau en cours de traitement.</dd>
-  <dt><code>tableau</code>{{optional_inline}}</dt>
-  <dd>Le tableau sur lequel a été appelé <code>findIndex</code>.</dd>
- </dl>
- </dd>
- <dt><code>argumentThis</code>{{optional_inline}}</dt>
- <dd>L'objet à utiliser comme contexte <code>this</code> lorsque le <code>callback</code> est exécuté.</dd>
-</dl>
+    - `élément`
+      - : L'élément du tableau qui doit être traité.
+    - `indice`{{optional_inline}}
+      - : L'indice de l'élément du tableau en cours de traitement.
+    - `tableau`{{optional_inline}}
+      - : Le tableau sur lequel a été appelé `findIndex`.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+- `argumentThis`{{optional_inline}}
+  - : L'objet à utiliser comme contexte `this` lorsque le `callback` est exécuté.
 
-<p>Un indice d'un élément du tableau qui réussit le test décrit, -1 sinon.</p>
+### Valeur de retour
 
-<h2 id="Description">Description</h2>
+Un indice d'un élément du tableau qui réussit le test décrit, -1 sinon.
 
-<p>La méthode <code>findIndex</code> exécute la fonction <code>callback</code> une fois pour chaque élément présent dans le tableau (le tableau est parcouru entre les indices <code>0</code> et <code>length-1</code> compris) jusqu'à ce que <code>callback</code> renvoie une valeur vraie.</p>
+## Description
 
-<p>S'il existe un tel élément, <code>findIndex</code> renverra immédiatement l'indice de l'élément concerné. Sinon, <code>findIndex</code> renverra -1. À la différence des autres méthodes liées aux tableaux comme <code>some()</code>, <code>callback</code> est également appelée pour les indices du tableau pour lesquels aucun élément n'est défini.</p>
+La méthode `findIndex` exécute la fonction `callback` une fois pour chaque élément présent dans le tableau (le tableau est parcouru entre les indices `0` et `length-1` compris) jusqu'à ce que `callback` renvoie une valeur vraie.
 
-<p><code>callback</code> possède trois arguments : la valeur de l'élément, l'indice de l'élément et l'objet Array qui est parcouru</p>
+S'il existe un tel élément, `findIndex` renverra immédiatement l'indice de l'élément concerné. Sinon, `findIndex` renverra -1. À la différence des autres méthodes liées aux tableaux comme `some()`, `callback` est également appelée pour les indices du tableau pour lesquels aucun élément n'est défini.
 
-<p>Si l'argument <code>argumentThis</code> est fourni à la méthode <code>findIndex</code>, il sera utilisé comme « contexte » <code><a href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/L_op%C3%A9rateur_this">this</a></code> pour chaque appel de <code>callback</code>. S'il n'est pas fourni, {{jsxref("undefined")}} sera utilisé.</p>
+`callback` possède trois arguments : la valeur de l'élément, l'indice de l'élément et l'objet Array qui est parcouru
 
-<p><code>findIndex</code> ne modifie pas le tableau sur laquelle elle est appelée. Les éléments qui seront traités par <code>findIndex</code> sont « récoltés » avant le premier appel de <code>callback</code>. Tout élément qui sera ajouté au tableau après l'appel de <code>findIndex</code> ne sera pas utilisé avec <code>callback</code>. Si un élément existant, pas encore visité, est modifié par <code>callback</code>, la valeur qui sera passé au <code>callback</code> pour cet élément modifié sera celle que <code>findIndex</code> utilise lorsqu'elle utilise l'indice de l'élément en question. Les éléments supprimés sont bien parcourus.</p>
+Si l'argument `argumentThis` est fourni à la méthode `findIndex`, il sera utilisé comme « contexte » [`this`](/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/L_op%C3%A9rateur_this) pour chaque appel de `callback`. S'il n'est pas fourni, {{jsxref("undefined")}} sera utilisé.
 
-<h2 id="Exemples">Exemples</h2>
+`findIndex` ne modifie pas le tableau sur laquelle elle est appelée. Les éléments qui seront traités par `findIndex` sont « récoltés » avant le premier appel de `callback`. Tout élément qui sera ajouté au tableau après l'appel de `findIndex` ne sera pas utilisé avec `callback`. Si un élément existant, pas encore visité, est modifié par `callback`, la valeur qui sera passé au `callback` pour cet élément modifié sera celle que `findIndex` utilise lorsqu'elle utilise l'indice de l'élément en question. Les éléments supprimés sont bien parcourus.
 
-<h3 id="Trouver_l'indice_d'un_nombre_premier_dans_un_tableau">Trouver l'indice d'un nombre premier dans un tableau</h3>
+## Exemples
 
-<p>L'exemple qui suit illustre comment trouver l'indice d'un élément qui est un nombre premier dans un tableau (ou qui renvoie -1 s'il n'y a pas de nombre premier).</p>
+### Trouver l'indice d'un nombre premier dans un tableau
 
-<pre class="brush: js">function estPremier(élément, index, array) {
+L'exemple qui suit illustre comment trouver l'indice d'un élément qui est un nombre premier dans un tableau (ou qui renvoie -1 s'il n'y a pas de nombre premier).
+
+```js
+function estPremier(élément, index, array) {
   var début = 2;
-  while (début &lt;= Math.sqrt(élément)) {
-    if (élément % début &lt; 1) {
+  while (début <= Math.sqrt(élément)) {
+    if (élément % début < 1) {
       return false;
     } else {
       début++;
     }
   }
-  return élément &gt; 1;
+  return élément > 1;
 }
 
 console.log([4, 6, 8, 12].findIndex(estPremier)); // -1, aucun trouvé
-console.log([4, 6, 7, 12].findIndex(estPremier)); // 2</pre>
+console.log([4, 6, 7, 12].findIndex(estPremier)); // 2
+```
 
-<h3 id="Trouver_un_indice_avec_une_fonction_fléchée">Trouver un indice avec une fonction fléchée</h3>
+### Trouver un indice avec une fonction fléchée
 
-<p>Dans cet exemple, on utilise <a href="/fr/docs/Web/JavaScript/Reference/Fonctions/Fonctions_fléchées">une fonction fléchée</a> pour trouver l'indice d'un élément :</p>
+Dans cet exemple, on utilise [une fonction fléchée](/fr/docs/Web/JavaScript/Reference/Fonctions/Fonctions_fléchées) pour trouver l'indice d'un élément :
 
-<pre class="brush: js">const fruits = ["pomme", "banane", "melon", "fraise", "raisin"];
+```js
+const fruits = ["pomme", "banane", "melon", "fraise", "raisin"];
 
-const indice = fruits.findIndex(fruit =&gt; fruit === "fraise");
+const indice = fruits.findIndex(fruit => fruit === "fraise");
 console.log(indice); // 3
-console.log(fruits[indice]); // fraise </pre>
+console.log(fruits[indice]); // fraise 
+```
 
-<h2 id="Prothèse_d'émulation_(polyfill)">Prothèse d'émulation (<em>polyfill</em>)</h2>
+## Prothèse d'émulation (_polyfill_)
 
-<pre class="brush: js">// https://tc39.github.io/ecma262/#sec-array.prototype.findindex
+```js
+// https://tc39.github.io/ecma262/#sec-array.prototype.findindex
 if (!Array.prototype.findIndex) {
   Object.defineProperty(Array.prototype, 'findIndex', {
     value: function(predicate) {
@@ -105,7 +106,7 @@ if (!Array.prototype.findIndex) {
       var o = Object(this);
 
       // 2. Let len be ? ToLength(? Get(O, "length")).
-      var len = o.length &gt;&gt;&gt; 0;
+      var len = o.length >>> 0;
 
       // 3. If IsCallable(predicate) is false, throw a TypeError exception.
       if (typeof predicate !== 'function') {
@@ -118,8 +119,8 @@ if (!Array.prototype.findIndex) {
       // 5. Let k be 0.
       var k = 0;
 
-      // 6. Repeat, while k &lt; len
-      while (k &lt; len) {
+      // 6. Repeat, while k < len
+      while (k < len) {
         // a. Let Pk be ! ToString(k).
         // b. Let kValue be ? Get(O, Pk).
         // c. Let testResult be ToBoolean(? Call(predicate, T, « kValue, k, O »)).
@@ -138,39 +139,23 @@ if (!Array.prototype.findIndex) {
     configurable: true,
     writable: true
   });
-}</pre>
-
-<p>S'il est vraiment nécessaire de prendre en charge les moteurs JavaScript qui ne prennent pas en charge {{jsxref("Object.defineProperty()")}}, mieux vaut ne pas ajouter de prothèse aux méthodes d'<code>Array.prototype</code> car on ne peut pas les rendre non-énumérables.</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('ES2015', '#sec-array.prototype.findindex', 'Array.prototype.findIndex')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-array.prototype.findIndex', 'Array.prototype.findIndex')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Array.findIndex")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Array.prototype.find()")}}</li>
- <li>{{jsxref("Array.prototype.indexOf()")}}</li>
-</ul>
+}
+```
+
+S'il est vraiment nécessaire de prendre en charge les moteurs JavaScript qui ne prennent pas en charge {{jsxref("Object.defineProperty()")}}, mieux vaut ne pas ajouter de prothèse aux méthodes d'`Array.prototype` car on ne peut pas les rendre non-énumérables.
+
+## Spécifications
+
+| Spécification                                                                                                        | État                         | Commentaires         |
+| -------------------------------------------------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ES2015', '#sec-array.prototype.findindex', 'Array.prototype.findIndex')}}     | {{Spec2('ES2015')}}     | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-array.prototype.findIndex', 'Array.prototype.findIndex')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Array.findIndex")}}
+
+## Voir aussi
+
+- {{jsxref("Array.prototype.find()")}}
+- {{jsxref("Array.prototype.indexOf()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/array/flat/index.md b/files/fr/web/javascript/reference/global_objects/array/flat/index.md
index 160e1c350b..e9ee2df63b 100644
--- a/files/fr/web/javascript/reference/global_objects/array/flat/index.md
+++ b/files/fr/web/javascript/reference/global_objects/array/flat/index.md
@@ -10,30 +10,29 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Array/flat
 original_slug: Web/JavaScript/Reference/Objets_globaux/Array/flat
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>flat()</strong></code> permet de créer un nouveau tableau contenant les éléments des sous-tableaux du tableau passé en argument, qui sont concaténés récursivement pour atteindre une profondeur donnée.</p>
+La méthode **`flat()`** permet de créer un nouveau tableau contenant les éléments des sous-tableaux du tableau passé en argument, qui sont concaténés récursivement pour atteindre une profondeur donnée.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>var nouveauTableau = monTableau</var>.flat([<var>profondeur</var>]);</pre>
+    var nouveauTableau = monTableau.flat([profondeur]);
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>profondeur</code> {{optional_inline}}</dt>
- <dd>Le niveau de profondeur en termes d'imbrication de tableau. Autrement dit, jusqu'à quel niveau d'imbrication un tableau imbriqué doit il être aplati. La valeur par défaut est 1.</dd>
-</dl>
+- `profondeur` {{optional_inline}}
+  - : Le niveau de profondeur en termes d'imbrication de tableau. Autrement dit, jusqu'à quel niveau d'imbrication un tableau imbriqué doit il être aplati. La valeur par défaut est 1.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un nouveau tableau qui contient la concaténation des éléments des sous-tableaux du tableau passé en argument.</p>
+Un nouveau tableau qui contient la concaténation des éléments des sous-tableaux du tableau passé en argument.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Aplatir_des_tableaux_imbriqués">Aplatir des tableaux imbriqués</h3>
+### Aplatir des tableaux imbriqués
 
-<pre class="brush: js">var arr1 = [1, 2, [3, 4]];
+```js
+var arr1 = [1, 2, [3, 4]];
 arr1.flat();
 // [1, 2, 3, 4]
 
@@ -44,49 +43,54 @@ arr2.flat();
 var arr3 = [1, 2, [3, 4, [5, 6]]];
 arr3.flat(2);
 // [1, 2, 3, 4, 5, 6]
-</pre>
+```
 
-<h3 id="Aplatir_et_combler_les_trous">Aplatir et combler les trous</h3>
+### Aplatir et combler les trous
 
-<p>La méthode <code>flat()</code> permet également de retirer les « trous » d'un tableau :</p>
+La méthode `flat()` permet également de retirer les « trous » d'un tableau :
 
-<pre class="brush: js">var arr4 = [1, 2, , 4, 5];
+```js
+var arr4 = [1, 2, , 4, 5];
 arr4.flat();
-// [1, 2, 4, 5]</pre>
+// [1, 2, 4, 5]
+```
 
-<h2 id="Équivalent">Équivalent</h2>
+## Équivalent
 
-<h3 id="reduce_et_concat"><code>reduce</code> et <code>concat</code></h3>
+### `reduce` et `concat`
 
-<pre class="brush: js">var arr = [1, 2, [3, 4]];
+```js
+var arr = [1, 2, [3, 4]];
 
 // pour un tableau avec un seul niveau de profondeur
 arr.flat();
 // est équivalent à
-arr.reduce((acc, val) =&gt; acc.concat(val), []);
+arr.reduce((acc, val) => acc.concat(val), []);
 // [1, 2, 3, 4]
 
 // avec la décomposition et les compositions flechées, on peut écrire :
-const flat = arr =&gt; [].concat(...arr);
-</pre>
+const flat = arr => [].concat(...arr);
+```
 
-<h3 id="reduce_concat_isArray_récursivité"><code>reduce</code> + <code>concat</code> + <code>isArray</code> + récursivité</h3>
+### `reduce` + `concat` + `isArray` + récursivité
 
-<pre class="brush: js">var arr = [1, 2, [3, 4, [5, 6]]];
+```js
+var arr = [1, 2, [3, 4, [5, 6]]];
 
 // Pour gérer plusieurs niveaux, on pourra utiliser
 // une méthode récursive avec reduce et concat
 function flatDeep(arr) {
-   return arr.reduce((acc, val) =&gt; acc.concat(Array.isArray(val) ? flatDeep(val) : val), []);
+   return arr.reduce((acc, val) => acc.concat(Array.isArray(val) ? flatDeep(val) : val), []);
 };
 
 flatDeep(arr);
 // [1, 2, 3, 4, 5, 6]
-</pre>
+```
 
-<h3 id="Utiliser_une_pile">Utiliser une pile</h3>
+### Utiliser une pile
 
-<pre class="brush: js">var arr = [1, 2, [3, 4]];
+```js
+var arr = [1, 2, [3, 4]];
 
 // Version non récursive utilisant une pile
 function flatStack(input) {
@@ -110,34 +114,21 @@ function flatStack(input) {
 
 flatStack(arr);
 // [1, 2, 3, 4]
-</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><a href="https://www.ecma-international.org/ecma-262/10.0/index.html#sec-array.prototype.flat">ECMAScript 2019</a></td>
-   <td>Finalisé</td>
-   <td>Proposition initiale</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Array.flat")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Array.prototype.flatMap()")}}</li>
- <li>{{jsxref("Array.prototype.map()")}}</li>
- <li>{{jsxref("Array.prototype.reduce()")}}</li>
- <li>{{jsxref("Array.prototype.concat()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                           | État     | Commentaires         |
+| ------------------------------------------------------------------------------------------------------- | -------- | -------------------- |
+| [ECMAScript 2019](https://www.ecma-international.org/ecma-262/10.0/index.html#sec-array.prototype.flat) | Finalisé | Proposition initiale |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Array.flat")}}
+
+## Voir aussi
+
+- {{jsxref("Array.prototype.flatMap()")}}
+- {{jsxref("Array.prototype.map()")}}
+- {{jsxref("Array.prototype.reduce()")}}
+- {{jsxref("Array.prototype.concat()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/array/flatmap/index.md b/files/fr/web/javascript/reference/global_objects/array/flatmap/index.md
index 4117829f18..1c95114d1d 100644
--- a/files/fr/web/javascript/reference/global_objects/array/flatmap/index.md
+++ b/files/fr/web/javascript/reference/global_objects/array/flatmap/index.md
@@ -10,111 +10,100 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Array/flatMap
 original_slug: Web/JavaScript/Reference/Objets_globaux/Array/flatMap
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>flatMap()</strong></code> permet d'appliquer une fonction à chaque élément du tableau puis d'aplatir le résultat en un tableau. Cela correspond à l'enchaînement de {{jsxref("Array.prototype.map()")}} suivi de {{jsxref("Array.prototype.flat()")}} de profondeur 1. <code>flatMap</code> est plus efficace que la combinaison de ces deux opérations, souvent réalisées conjointement.</p>
+La méthode **`flatMap()`** permet d'appliquer une fonction à chaque élément du tableau puis d'aplatir le résultat en un tableau. Cela correspond à l'enchaînement de {{jsxref("Array.prototype.map()")}} suivi de {{jsxref("Array.prototype.flat()")}} de profondeur 1. `flatMap` est plus efficace que la combinaison de ces deux opérations, souvent réalisées conjointement.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>var new_array = arr</var>.flatMap(function <var>callback(currentValue[, index[, array]]) {
-    // return element for new_array
-}</var>[, <var>thisArg</var>])</pre>
+    var new_array = arr.flatMap(function callback(currentValue[, index[, array]]) {
+        // return element for new_array
+    }[, thisArg])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>callback</code></dt>
- <dd>La fonction qui produit un élément du nouveau tableau et qui prend trois arguments :
- <dl>
-  <dt><code>currentValue</code></dt>
-  <dd>La valeur du tableau qui est traitée.</dd>
-  <dt><code>index</code>{{optional_inline}}</dt>
-  <dd>L'indice de l'élément du tableau qui est traitée.</dd>
-  <dt><code>array</code>{{optional_inline}}</dt>
-  <dd>Le tableau sur lequel <code>flatMap</code> a été appelée.</dd>
- </dl>
- </dd>
- <dt><code>thisArg</code>{{optional_inline}}</dt>
- <dd>La valeur à utiliser comme contexte <code>this</code> lors de l'exécution de <code>callback</code>.</dd>
-</dl>
+- `callback`
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+  - : La fonction qui produit un élément du nouveau tableau et qui prend trois arguments :
 
-<p>Un nouveau tableau composé d'éléments résultants de la fonction de rappel (<em>callback</em>) et aplati d'un niveau de profondeur.</p>
+    - `currentValue`
+      - : La valeur du tableau qui est traitée.
+    - `index`{{optional_inline}}
+      - : L'indice de l'élément du tableau qui est traitée.
+    - `array`{{optional_inline}}
+      - : Le tableau sur lequel `flatMap` a été appelée.
 
-<h2 id="Description">Description</h2>
+- `thisArg`{{optional_inline}}
+  - : La valeur à utiliser comme contexte `this` lors de l'exécution de `callback`.
 
-<p>Pour la fonction de rappel, voir {{jsxref("Array.prototype.map()")}}. La méthode <code>flatMap()</code> est identique à un appel de {{jsxref("Array.prototype.map()")}} suivi d'un appel de {{jsxref("Array.prototype.flat()")}} avec la profondeur 1.</p>
+### Valeur de retour
 
-<h2 id="Exemples">Exemples</h2>
+Un nouveau tableau composé d'éléments résultants de la fonction de rappel (_callback_) et aplati d'un niveau de profondeur.
 
-<h3 id="map_et_flatMap"><code>map()</code> et <code>flatMap()</code></h3>
+## Description
 
-<pre class="brush: js">var arr1 = [1, 2, 3, 4];
+Pour la fonction de rappel, voir {{jsxref("Array.prototype.map()")}}. La méthode `flatMap()` est identique à un appel de {{jsxref("Array.prototype.map()")}} suivi d'un appel de {{jsxref("Array.prototype.flat()")}} avec la profondeur 1.
 
-arr1.map(x =&gt; [x * 2]);
+## Exemples
+
+### `map()` et `flatMap()`
+
+```js
+var arr1 = [1, 2, 3, 4];
+
+arr1.map(x => [x * 2]);
 // [[2], [4], [6], [8]]
 
-arr1.flatMap(x =&gt; [x * 2]);
+arr1.flatMap(x => [x * 2]);
 // [2, 4, 6, 8]
 
 // seul un niveau est aplati
-arr1.flatMap(x =&gt; [[x * 2]]);
+arr1.flatMap(x => [[x * 2]]);
 // [[2], [4], [6], [8]]
-</pre>
+```
 
-<p>On peut utiliser un autre exemple où on génère une liste de mots à partir d'une liste de phrases :</p>
+On peut utiliser un autre exemple où on génère une liste de mots à partir d'une liste de phrases :
 
-<pre class="brush: js">let tableau1 = ["Coucou comment", "", "ça va ?"];
+```js
+let tableau1 = ["Coucou comment", "", "ça va ?"];
 
-tableau1.map(x =&gt; x.split(" "));
+tableau1.map(x => x.split(" "));
 // [["Coucou", "comment"], [""], ["ça", "va", "?"]]
 
-tableau1.flatMap(x =&gt; x.split(" "));
+tableau1.flatMap(x => x.split(" "));
 // ["Coucou", "comment", "", "ça", "va", "?"]
-</pre>
+```
 
-<p>On notera que la longueur de la liste obtenue avec <code>flatMap</code> est différente de la longueur de la liste originale.</p>
+On notera que la longueur de la liste obtenue avec `flatMap` est différente de la longueur de la liste originale.
 
-<pre>//=&gt; [1, 2, 3, 4, 5, 6, 7, 8, 9]</pre>
+    //=> [1, 2, 3, 4, 5, 6, 7, 8, 9]
 
-<h2 id="Équivalent">Équivalent</h2>
+## Équivalent
 
-<h3 id="reduce_et_concat"><code>reduce()</code> et <code>concat()</code></h3>
+### `reduce()` et `concat()`
 
-<pre class="brush: js">var arr = [1, 2, 3, 4];
+```js
+var arr = [1, 2, 3, 4];
 
-arr.flatMap(x =&gt; [x, x * 2]);
+arr.flatMap(x => [x, x * 2]);
 // est équivalent à
-arr.reduce((acc, x) =&gt; acc.concat([x, x * 2]), []);
-// [1, 2, 2, 4, 3, 6, 4, 8]</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><a href="https://www.ecma-international.org/ecma-262/10.0/index.html#sec-array.prototype.flatmap">ECMAScript 2019</a></td>
-   <td>Finalisé</td>
-   <td>Proposition initiale</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Array.flatMap")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Array.prototype.flat()")}}</li>
- <li>{{jsxref("Array.prototype.map()")}}</li>
- <li>{{jsxref("Array.prototype.reduce()")}}</li>
- <li>{{jsxref("Array.prototype.concat()")}}</li>
-</ul>
+arr.reduce((acc, x) => acc.concat([x, x * 2]), []);
+// [1, 2, 2, 4, 3, 6, 4, 8]
+```
+
+## Spécifications
+
+| Spécification                                                                                              | État     | Commentaires         |
+| ---------------------------------------------------------------------------------------------------------- | -------- | -------------------- |
+| [ECMAScript 2019](https://www.ecma-international.org/ecma-262/10.0/index.html#sec-array.prototype.flatmap) | Finalisé | Proposition initiale |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Array.flatMap")}}
+
+## Voir aussi
+
+- {{jsxref("Array.prototype.flat()")}}
+- {{jsxref("Array.prototype.map()")}}
+- {{jsxref("Array.prototype.reduce()")}}
+- {{jsxref("Array.prototype.concat()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/array/foreach/index.md b/files/fr/web/javascript/reference/global_objects/array/foreach/index.md
index 1b10baec33..13b7cf4a13 100644
--- a/files/fr/web/javascript/reference/global_objects/array/foreach/index.md
+++ b/files/fr/web/javascript/reference/global_objects/array/foreach/index.md
@@ -12,107 +12,102 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Array/forEach
 original_slug: Web/JavaScript/Reference/Objets_globaux/Array/forEach
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>forEach()</strong></code> permet d'exécuter une fonction donnée sur chaque élément du tableau.</p>
+La méthode **`forEach()`** permet d'exécuter une fonction donnée sur chaque élément du tableau.
 
-<div>{{EmbedInteractiveExample("pages/js/array-foreach.html")}}</div>
+{{EmbedInteractiveExample("pages/js/array-foreach.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>arr</var>.forEach(<var>callback</var>);
-arr.forEach(callback, <var>thisArg</var>);</pre>
+    arr.forEach(callback);
+    arr.forEach(callback, thisArg);
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>callback</code></dt>
- <dd>La fonction à utiliser pour chaque élément du tableau. Elle prend en compte trois arguments :
- <dl>
-  <dt><code>valeurCourante</code></dt>
-  <dd>La valeur de l'élément du tableau en cours de traitement.</dd>
-  <dt><code>index</code> {{optional_inline}}</dt>
-  <dd>L'indice de l'élément du tableau en cours de traitement.</dd>
-  <dt><code>array</code> {{optional_inline}}</dt>
-  <dd>Le tableau sur lequel la méthode <code>forEach</code> est appliquée.</dd>
- </dl>
- </dd>
- <dt><code>thisArg</code> {{optional_inline}}</dt>
- <dd>Paramètre optionnel. La valeur à utiliser pour <code>this</code> lors de l'exécution de <code>callback</code>.</dd>
-</dl>
+- `callback`
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+  - : La fonction à utiliser pour chaque élément du tableau. Elle prend en compte trois arguments :
 
-<p>{{jsxref("undefined")}}.</p>
+    - `valeurCourante`
+      - : La valeur de l'élément du tableau en cours de traitement.
+    - `index` {{optional_inline}}
+      - : L'indice de l'élément du tableau en cours de traitement.
+    - `array` {{optional_inline}}
+      - : Le tableau sur lequel la méthode `forEach` est appliquée.
 
-<h2 id="Description">Description</h2>
+- `thisArg` {{optional_inline}}
+  - : Paramètre optionnel. La valeur à utiliser pour `this` lors de l'exécution de `callback`.
 
-<p><code>forEach()</code> exécute la fonction <code><em>callback</em></code> une fois pour chaque élément du tableau, dans l'ordre croissant des indices. Cette fonction n'est pas appelée pour les indices pour lesquels les éléments ont été supprimés ou qui n'ont pas été définis. Attention, en revanche elle est appelée pour les éléments qui sont présents et qui valent {{jsxref("undefined")}}.</p>
+### Valeur de retour
 
-<p><code>callback</code> est appelé avec trois arguments :</p>
+{{jsxref("undefined")}}.
 
-<ul>
- <li>la valeur de l'élément</li>
- <li>l'index de l'élément</li>
- <li>le tableau utilisé</li>
-</ul>
+## Description
 
-<p>Si un paramètre <code>thisArg</code> est fourni à la méthode <code>forEach</code>, il sera utilisé en tant que valeur <code>this</code> pour chaque appel de <code>callback</code>. Sinon, ce sera la valeur <code>undefined</code> qui sera utilisée comme valeur <code>this</code>. La valeur <code>this</code> finalement prise en compte par la fonction <code>callback</code> est déterminée selon <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_this">les règles usuelles pour déterminer la valeur de <code>this</code> utilisée dans une fonction</a>.</p>
+`forEach()` exécute la fonction `callback` une fois pour chaque élément du tableau, dans l'ordre croissant des indices. Cette fonction n'est pas appelée pour les indices pour lesquels les éléments ont été supprimés ou qui n'ont pas été définis. Attention, en revanche elle est appelée pour les éléments qui sont présents et qui valent {{jsxref("undefined")}}.
 
-<p>L'ensemble des éléments traités par <code>forEach</code> est défini avant le premier appel à <code>callback</code>. Les éléments ajoutés au tableau après que l'appel à <code>forEach</code> ait commencé ne seront pas visités par <code>callback</code>. Si des éléments déjà présents dans le tableau sont modifiés, leur valeur telle qu'elle est passée au <code>callback</code> sera la valeur au moment du passage du <code>forEach</code> ; les éléments supprimés ne sont pas parcourus. Voir <a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Array/forEach#Attention_aux_modifications_en_cours">l'exemple ci-après</a>.</p>
+`callback` est appelé avec trois arguments :
 
-<p><code>forEach()</code> exécute la fonction <code>callback</code> une fois pour chaque élément. À la différence de {{jsxref("Array.prototype.map()", "map()")}} ou de {{jsxref("Array.prototype.reduce()", "reduce()")}} il renvoie toujours la valeur {{jsxref("undefined")}} et ne peut donc pas être « enchaîné ». Généralement, l'effet voulu est de déclencher des effets de bord en fin de chaîne.</p>
+- la valeur de l'élément
+- l'index de l'élément
+- le tableau utilisé
 
-<p><code>forEach()</code> ne modifie pas le tableau sur lequel elle est appelée, en revanche, la fonction de retour (<em>callback</em>) utilisée peut modifier le tableau.</p>
+Si un paramètre `thisArg` est fourni à la méthode `forEach`, il sera utilisé en tant que valeur `this` pour chaque appel de `callback`. Sinon, ce sera la valeur `undefined` qui sera utilisée comme valeur `this`. La valeur `this` finalement prise en compte par la fonction `callback` est déterminée selon [les règles usuelles pour déterminer la valeur de `this` utilisée dans une fonction](/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_this).
 
-<div class="note"><p><strong>Note :</strong> Il n'existe aucun moyen d'arrêter une boucle <code>forEach</code> en dehors de lever une exception. Si vous avez besoin d'arrêter la boucle, étudiez plutôt :</p>
+L'ensemble des éléments traités par `forEach` est défini avant le premier appel à `callback`. Les éléments ajoutés au tableau après que l'appel à `forEach` ait commencé ne seront pas visités par `callback`. Si des éléments déjà présents dans le tableau sont modifiés, leur valeur telle qu'elle est passée au `callback` sera la valeur au moment du passage du `forEach` ; les éléments supprimés ne sont pas parcourus. Voir [l'exemple ci-après](/fr/docs/Web/JavaScript/Reference/Objets_globaux/Array/forEach#Attention_aux_modifications_en_cours).
 
-<ul>
- <li>Une boucle <code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/for">for</a></code> classique</li>
- <li>Une boucle <code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/for...in">for...in</a></code> ou <code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/for...of">for...of</a></code></li>
- <li>{{jsxref("Array.prototype.every()")}}</li>
- <li>{{jsxref("Array.prototype.some()")}}</li>
- <li>{{jsxref("Array.prototype.find()")}}</li>
- <li>{{jsxref("Array.prototype.findIndex()")}}</li>
-</ul>
+`forEach()` exécute la fonction `callback` une fois pour chaque élément. À la différence de {{jsxref("Array.prototype.map()", "map()")}} ou de {{jsxref("Array.prototype.reduce()", "reduce()")}} il renvoie toujours la valeur {{jsxref("undefined")}} et ne peut donc pas être « enchaîné ». Généralement, l'effet voulu est de déclencher des effets de bord en fin de chaîne.
 
-<p>Les autres méthodes associées aux tableaux ({{jsxref("Array.prototype.every()")}}, {{jsxref("Array.prototype.some()")}}, {{jsxref("Array.prototype.find()")}}, {{jsxref("Array.prototype.findIndex()")}}) utilisent une fonction de texte qui permet de renvoyer une valeur équivalente à <code>true</code> si besoin de poursuivre la boucle.</p>
-</div>
+`forEach()` ne modifie pas le tableau sur lequel elle est appelée, en revanche, la fonction de retour (_callback_) utilisée peut modifier le tableau.
 
-<p><code>forEach</code> exécute la fonction <code>callback</code> une fois pour chaque élément ; contrairement à <code>every</code> et <code><code>some</code></code>, cette méthode renvoie toujours <code>undefined</code> et ne peut pas être enchaînée.</p>
+> **Note :** Il n'existe aucun moyen d'arrêter une boucle `forEach` en dehors de lever une exception. Si vous avez besoin d'arrêter la boucle, étudiez plutôt :
+>
+> - Une boucle [`for`](/fr/docs/Web/JavaScript/Reference/Instructions/for) classique
+> - Une boucle [`for...in`](/fr/docs/Web/JavaScript/Reference/Instructions/for...in) ou [`for...of`](/fr/docs/Web/JavaScript/Reference/Instructions/for...of)
+> - {{jsxref("Array.prototype.every()")}}
+> - {{jsxref("Array.prototype.some()")}}
+> - {{jsxref("Array.prototype.find()")}}
+> - {{jsxref("Array.prototype.findIndex()")}}
+>
+> Les autres méthodes associées aux tableaux ({{jsxref("Array.prototype.every()")}}, {{jsxref("Array.prototype.some()")}}, {{jsxref("Array.prototype.find()")}}, {{jsxref("Array.prototype.findIndex()")}}) utilisent une fonction de texte qui permet de renvoyer une valeur équivalente à `true` si besoin de poursuivre la boucle.
 
-<h2 id="Exemples">Exemples</h2>
+`forEach` exécute la fonction `callback` une fois pour chaque élément ; contrairement à `every` et `some`, cette méthode renvoie toujours `undefined` et ne peut pas être enchaînée.
 
-<h3 id="Équivalence_entre_une_boucle_for_et_une_boucle_forEach">Équivalence entre une boucle <code>for</code> et une boucle <code>forEach</code></h3>
+## Exemples
 
-<p>Voici un fragment de code simple qui utilise une boucle <code>for</code></p>
+### Équivalence entre une boucle `for` et une boucle `forEach`
 
-<pre class="brush: js">var items = ["item1", "item2", "item3"];
+Voici un fragment de code simple qui utilise une boucle `for`
+
+```js
+var items = ["item1", "item2", "item3"];
 var copie = [];
 
-for (var i = 0; i &lt; items.length; i++) {
+for (var i = 0; i < items.length; i++) {
   copie.push(items[i]);
 }
-</pre>
+```
 
-<p>Et voici un fragment de code équivalent qui utilise <code>forEach</code> :</p>
+Et voici un fragment de code équivalent qui utilise `forEach` :
 
-<pre class="brush: js">var items = ["item1", "item2", "item3"]
+```js
+var items = ["item1", "item2", "item3"]
 var copie = [];
 
 items.forEach(function(item){
   copie.push(item);
-});</pre>
+});
+```
 
-<h3 id="Afficher_le_contenu_d'un_tableau">Afficher le contenu d'un tableau</h3>
+### Afficher le contenu d'un tableau
 
-<div class="note">
-<p><strong>Note :</strong> Pour afficher le contenu d'un tableau, on pourra utiliser <code><a href="/fr/docs/Web/API/Console/table">console.table()</a></code> qui met en forme les éléments du tableau. L'exemple suivant est laissé à titre d'illustration pour <code>forEach()</code>.</p>
-</div>
+> **Note :** Pour afficher le contenu d'un tableau, on pourra utiliser [`console.table()`](/fr/docs/Web/API/Console/table) qui met en forme les éléments du tableau. L'exemple suivant est laissé à titre d'illustration pour `forEach()`.
 
-<p>Le code suivant affiche une ligne pour chaque élément du tableau :</p>
+Le code suivant affiche une ligne pour chaque élément du tableau :
 
-<pre class="brush:js">function logArrayElements(element, index, array) {
+```js
+function logArrayElements(element, index, array) {
     console.log("a[" + index + "] = " + element);
 }
 [2, 5, , 9].forEach(logArrayElements);
@@ -120,14 +115,14 @@ items.forEach(function(item){
 // a[0] = 2
 // a[1] = 5
 // a[3] = 9
+```
 
-</pre>
-
-<h3 id="Utiliser_l'argument_pour_this">Utiliser l'argument pour <code>this</code></h3>
+### Utiliser l'argument pour `this`
 
-<p>Dans l'exemple qui suit, on met à jour les propriétés d'un objet à partir des éléments d'un tableau :</p>
+Dans l'exemple qui suit, on met à jour les propriétés d'un objet à partir des éléments d'un tableau :
 
-<pre class="brush: js">function Compteur() {
+```js
+function Compteur() {
   this.somme = 0;
   this.compte = 0;
 }
@@ -144,27 +139,24 @@ var obj = new Compteur();
 obj.ajouter([2, 5, 9]);
 console.log(obj.compte); // 3
 console.log(obj.somme);  // 16
-</pre>
+```
 
-<div class="note">
-<p><strong>Note :</strong> Le paramètre pour <code>this</code> est passé à la méthode <code>forEach()</code>, à chaque appel du callback, celui-ci sera utilisé comme valeur pour <code>this</code>.</p>
-</div>
+> **Note :** Le paramètre pour `this` est passé à la méthode `forEach()`, à chaque appel du callback, celui-ci sera utilisé comme valeur pour `this`.
 
-<div class="note">
-<p><strong>Note :</strong> Si la fonction passée en argument est <a href="/fr/docs/Web/JavaScript/Reference/Fonctions/Fonctions_fléchées">une fonction fléchée</a>, il n'est pas nécessaire d'ajouter le paramètre <code>this</code> car les fonctions fléchées utilisent le <code><a href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/L_op%C3%A9rateur_this">this</a></code> fourni par le contexte lexical.</p>
-</div>
+> **Note :** Si la fonction passée en argument est [une fonction fléchée](/fr/docs/Web/JavaScript/Reference/Fonctions/Fonctions_fléchées), il n'est pas nécessaire d'ajouter le paramètre `this` car les fonctions fléchées utilisent le [`this`](/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/L_op%C3%A9rateur_this) fourni par le contexte lexical.
 
-<h3 id="Stopper_une_boucle">Stopper une boucle</h3>
+### Stopper une boucle
 
-<p>Le code qui suit utilise la méthode {{jsxref("Array.prototype.every")}} pour afficher le contenu d'un tableau et s'arrêter lorsqu'il atteint une valeur supérieure à <code>SEUIL_MAX</code>.</p>
+Le code qui suit utilise la méthode {{jsxref("Array.prototype.every")}} pour afficher le contenu d'un tableau et s'arrêter lorsqu'il atteint une valeur supérieure à `SEUIL_MAX`.
 
-<pre class="brush: js">var SEUIL_MAX = 12;
+```js
+var SEUIL_MAX = 12;
 var v = [5, 2, 16, 4, 3, 18, 20];
 var res;
 
 res = v.every(function(element, index, array) {
   console.log('élément :', element);
-  if (element &gt;= SEUIL_MAX) {
+  if (element >= SEUIL_MAX) {
     return false;
   }
 
@@ -179,7 +171,7 @@ console.log('res:', res);
 
 res = v.some(function(element, index, array) {
   console.log('élément:', element);
-  if (element &gt;= SEUIL_MAX) {
+  if (element >= SEUIL_MAX) {
     return true;
   }
 
@@ -190,13 +182,15 @@ console.log('res:', res);
 // élément : 5
 // élément : 2
 // élément : 16
-// res: true</pre>
+// res: true
+```
 
-<h3 id="Une_fonction_de_copie_d'objet">Une fonction de copie d'objet</h3>
+### Une fonction de copie d'objet
 
-<p>Le code qui suit permet de créer une copie d'un objet donné. Il existe différentes façons pour créer une copie d'un objet. L'exemple suivant illustre une de ces façons afin d'expliquer le fonctionnement d'<code>Array.prototype.forEach</code> et d'utiliser les fonctions ECMAScript 5 <code>Object.*</code>.</p>
+Le code qui suit permet de créer une copie d'un objet donné. Il existe différentes façons pour créer une copie d'un objet. L'exemple suivant illustre une de ces façons afin d'expliquer le fonctionnement d'`Array.prototype.forEach` et d'utiliser les fonctions ECMAScript 5 `Object.*`.
 
-<pre class="brush: js">function copie(obj) {
+```js
+function copie(obj) {
   var copie = Object.create(Object.getPrototypeOf(obj));
   var propNames = Object.getOwnPropertyNames(obj);
 
@@ -209,13 +203,15 @@ console.log('res:', res);
 }
 
 var obj1 = { a: 1, b: 2 };
-var obj2 = copie(obj1); // obj2 ressemble désormais à obj1</pre>
+var obj2 = copie(obj1); // obj2 ressemble désormais à obj1
+```
 
-<h3 id="Attention_aux_modifications_en_cours">Attention aux modifications en cours</h3>
+### Attention aux modifications en cours
 
-<p>Dans l'exemple qui suit, on utilise un tableau qui contient quatre élément : <code>"un"</code>, <code>"deux"</code>, <code>"trois"</code>, <code>"quatre"</code>. Lorsque le parcours du tableau arrive à l'élément <code>"deux"</code>, on décale le tableau d'un cran vers les premiers éléments. Aussi, l'élément <code>"quatre"</code> est décalé à la place de <code>"trois"</code> et <code>"trois"</code> est déplacé à la place de <code>"deux"</code>. Pour cette raison, lorsque <code>forEach</code> poursuit son parcours, elle saute la valeur "trois". Autrement dit, <code>forEach</code> n'utilise pas une copie du tableau au moment où elle est appelée, elle manipule le tableau directement. On voit aussi dans cet exemple que les éléments non initialisés ne sont pas traités par la fonction de rappel.</p>
+Dans l'exemple qui suit, on utilise un tableau qui contient quatre élément : `"un"`, `"deux"`, `"trois"`, `"quatre"`. Lorsque le parcours du tableau arrive à l'élément `"deux"`, on décale le tableau d'un cran vers les premiers éléments. Aussi, l'élément `"quatre"` est décalé à la place de `"trois"` et `"trois"` est déplacé à la place de `"deux"`. Pour cette raison, lorsque `forEach` poursuit son parcours, elle saute la valeur "trois". Autrement dit, `forEach` n'utilise pas une copie du tableau au moment où elle est appelée, elle manipule le tableau directement. On voit aussi dans cet exemple que les éléments non initialisés ne sont pas traités par la fonction de rappel.
 
-<pre class="brush: js">var mots = ["un", "deux", "trois",, "quatre"];
+```js
+var mots = ["un", "deux", "trois",, "quatre"];
 mots.forEach(function(mot) {
   console.log(mot);
   if (mot === "deux") {
@@ -224,48 +220,28 @@ mots.forEach(function(mot) {
 });
 // un
 // deux
-// quatre</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.4.4.18', 'Array.prototype.forEach')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td>Définition initiale. Implémentée avec JavaScript 1.6.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-array.prototype.foreach', 'Array.prototype.forEach')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-array.prototype.foreach', 'Array.prototype.forEach')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Array.forEach")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Array.prototype.filter()")}}</li>
- <li>{{jsxref("Array.prototype.find()")}}</li>
- <li>{{jsxref("Array.prototype.findIndex()")}}</li>
- <li>{{jsxref("Array.prototype.map()")}}</li>
- <li>{{jsxref("Array.prototype.every()")}}</li>
- <li>{{jsxref("Array.prototype.some()")}}</li>
- <li>{{jsxref("Map.prototype.forEach()")}}</li>
- <li>{{jsxref("Set.prototype.forEach()")}}</li>
-</ul>
+// quatre
+```
+
+## Spécifications
+
+| Spécification                                                                                                | État                         | Commentaires                                          |
+| ------------------------------------------------------------------------------------------------------------ | ---------------------------- | ----------------------------------------------------- |
+| {{SpecName('ES5.1', '#sec-15.4.4.18', 'Array.prototype.forEach')}}                     | {{Spec2('ES5.1')}}     | Définition initiale. Implémentée avec JavaScript 1.6. |
+| {{SpecName('ES6', '#sec-array.prototype.foreach', 'Array.prototype.forEach')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-array.prototype.foreach', 'Array.prototype.forEach')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Array.forEach")}}
+
+## Voir aussi
+
+- {{jsxref("Array.prototype.filter()")}}
+- {{jsxref("Array.prototype.find()")}}
+- {{jsxref("Array.prototype.findIndex()")}}
+- {{jsxref("Array.prototype.map()")}}
+- {{jsxref("Array.prototype.every()")}}
+- {{jsxref("Array.prototype.some()")}}
+- {{jsxref("Map.prototype.forEach()")}}
+- {{jsxref("Set.prototype.forEach()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/array/from/index.md b/files/fr/web/javascript/reference/global_objects/array/from/index.md
index de22e8feea..cf80abb37e 100644
--- a/files/fr/web/javascript/reference/global_objects/array/from/index.md
+++ b/files/fr/web/javascript/reference/global_objects/array/from/index.md
@@ -11,49 +11,46 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Array/from
 original_slug: Web/JavaScript/Reference/Objets_globaux/Array/from
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>Array.from()</strong></code> permet de créer une nouvelle instance d'<code>Array</code> (une copie superficielle) à partir d'un objet itérable ou semblable à un tableau.</p>
+La méthode **`Array.from()`** permet de créer une nouvelle instance d'`Array` (une copie superficielle) à partir d'un objet itérable ou semblable à un tableau.
 
-<div>{{EmbedInteractiveExample("pages/js/array-from.html")}}</div>
+{{EmbedInteractiveExample("pages/js/array-from.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">Array.from(arrayLike [, fonctionMap[, thisArg]])</pre>
+    Array.from(arrayLike [, fonctionMap[, thisArg]])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>arrayLike</code></dt>
- <dd>Un objet semblable à un tableau ou bien un objet itérable dont on souhaite créer un tableau, instance d'<code>Array</code>.</dd>
- <dt><code>fonctionMap</code> {{optional_inline}}</dt>
- <dd>Argument optionnel, une fonction à appliquer à chacun des éléments du tableau.</dd>
- <dt><code>thisArg</code> {{optional_inline}}</dt>
- <dd>Argument optionnel. La valeur à utiliser pour <code>this</code> lors de l'exécution de la fonction <code>fonctionMap</code>.</dd>
-</dl>
+- `arrayLike`
+  - : Un objet semblable à un tableau ou bien un objet itérable dont on souhaite créer un tableau, instance d'`Array`.
+- `fonctionMap` {{optional_inline}}
+  - : Argument optionnel, une fonction à appliquer à chacun des éléments du tableau.
+- `thisArg` {{optional_inline}}
+  - : Argument optionnel. La valeur à utiliser pour `this` lors de l'exécution de la fonction `fonctionMap`.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une nouvelle instance de {{jsxref("Array")}}.</p>
+Une nouvelle instance de {{jsxref("Array")}}.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p><code>Array.from()</code> permet de créer des instances d'<code>Array</code> à partir :</p>
+`Array.from()` permet de créer des instances d'`Array` à partir :
 
-<ul>
- <li>d'objets semblables à des tableaux (qui disposent d'une propriété <code>length</code> et d'éléments indexés) ou</li>
- <li><a href="/fr/docs/Web/JavaScript/Guide/iterable">d'objets itérables</a> (des objets dont on peut avoir les éléments comme {{jsxref("Map")}} et {{jsxref("Set")}}).</li>
-</ul>
+- d'objets semblables à des tableaux (qui disposent d'une propriété `length` et d'éléments indexés) ou
+- [d'objets itérables](/fr/docs/Web/JavaScript/Guide/iterable) (des objets dont on peut avoir les éléments comme {{jsxref("Map")}} et {{jsxref("Set")}}).
 
-<p><code>Array.from()</code> possède un paramètre optionnel <code>fonctionMap</code>, qui permet d'exécuter une fonction {{jsxref("Array.prototype.map", "map")}} sur chacun des éléments du tableau (ou de l'instance de la classe fille) qui est créé. Autrement dit<code> Array.from(obj, mapFn, thisArg)</code> correspond exactement à <code>Array.from(obj).map(mapFn, thisArg)</code>, sauf qu'il n'y a pas de tableau intermédiaire de créé. Cet aspect est notamment important pour certaines classes filles, comme les <a href="/fr/docs/JavaScript/Tableaux_typ%C3%A9s">tableaux typés</a> (en effet, un tableau intermédiaire aurait eu ses valeurs tronquées pour qu'elles soient du type approprié).</p>
+`Array.from()` possède un paramètre optionnel `fonctionMap`, qui permet d'exécuter une fonction {{jsxref("Array.prototype.map", "map")}} sur chacun des éléments du tableau (ou de l'instance de la classe fille) qui est créé. Autrement dit` Array.from(obj, mapFn, thisArg)` correspond exactement à `Array.from(obj).map(mapFn, thisArg)`, sauf qu'il n'y a pas de tableau intermédiaire de créé. Cet aspect est notamment important pour certaines classes filles, comme les [tableaux typés](/fr/docs/JavaScript/Tableaux_typ%C3%A9s) (en effet, un tableau intermédiaire aurait eu ses valeurs tronquées pour qu'elles soient du type approprié).
 
-<p>La propriété <code>length</code> de la méthode <code>from()</code> est 1.</p>
+La propriété `length` de la méthode `from()` est 1.
 
-<p>Avec ES6, la syntaxe de classe permet d'avoir des sous-classes pour les objets natifs comme pour les objets définis par l'utilisateur. Ainsi, les méthodes statiques de classe comme <code>Array.from()</code> sont héritées par les sous-classes d'<code>Array</code> et créent de nouvelles instances de la sous-classe d'<code>Array</code>.</p>
+Avec ES6, la syntaxe de classe permet d'avoir des sous-classes pour les objets natifs comme pour les objets définis par l'utilisateur. Ainsi, les méthodes statiques de classe comme `Array.from()` sont héritées par les sous-classes d'`Array` et créent de nouvelles instances de la sous-classe d'`Array`.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<pre class="brush: js">// créer une instance d'Array à partir de l'objet arguments qui est semblable à un tableau
+```js
+// créer une instance d'Array à partir de l'objet arguments qui est semblable à un tableau
 function f() {
   return Array.from(arguments);
 }
@@ -88,48 +85,28 @@ Array.from("toto");
 
 // En utilisant une fonction fléchée pour remplacer map
 // et manipuler des éléments
-Array.from([1, 2, 3], x =&gt; x + x);
+Array.from([1, 2, 3], x => x + x);
 // [2, 4, 6]
 
 
 // Pour générer une séquence de nombres
-Array.from({length: 5}, (v, k) =&gt; k);
+Array.from({length: 5}, (v, k) => k);
 // [0, 1, 2, 3, 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('ES2015', '#sec-array.from', 'Array.from')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-array.from', 'Array.from')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Array.from")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Array")}}</li>
- <li>{{jsxref("Array.prototype.map()")}}</li>
- <li>{{jsxref("TypedArray.from()")}}</li>
-</ul>
+## Spécifications
+
+| Spécification                                                                | État                         | Commentaires         |
+| ---------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ES2015', '#sec-array.from', 'Array.from')}}     | {{Spec2('ES2015')}}     | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-array.from', 'Array.from')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Array.from")}}
+
+## Voir aussi
+
+- {{jsxref("Array")}}
+- {{jsxref("Array.prototype.map()")}}
+- {{jsxref("TypedArray.from()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/array/includes/index.md b/files/fr/web/javascript/reference/global_objects/array/includes/index.md
index e63134919f..16ebf55be4 100644
--- a/files/fr/web/javascript/reference/global_objects/array/includes/index.md
+++ b/files/fr/web/javascript/reference/global_objects/array/includes/index.md
@@ -11,44 +11,36 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Array/includes
 original_slug: Web/JavaScript/Reference/Objets_globaux/Array/includes
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>includes()</strong></code> permet de déterminer si un tableau contient une valeur et renvoie <code>true</code> si c'est le cas, <code>false</code> sinon.</p>
+La méthode **`includes()`** permet de déterminer si un tableau contient une valeur et renvoie `true` si c'est le cas, `false` sinon.
 
-<div>{{EmbedInteractiveExample("pages/js/array-includes.html")}}</div>
+{{EmbedInteractiveExample("pages/js/array-includes.html")}}
 
+> **Note :** Cette méthode utilise l'algorithme de comparaison _[SameValueZero](/fr/docs/Web/JavaScript/Les_différents_tests_d_égalité#Un_modèle_pour_mieux_comprendre)_ qui fonctionne comme l'égalité stricte, à la différence que `NaN` est ici égal à lui même.
 
+## Syntaxe
 
-<div class="note">
-<p><strong>Note :</strong> Cette méthode utilise l'algorithme de comparaison <em><a href="/fr/docs/Web/JavaScript/Les_différents_tests_d_égalité#Un_modèle_pour_mieux_comprendre">SameValueZero</a></em> qui fonctionne comme l'égalité stricte, à la différence que <code>NaN</code> est ici égal à lui même.</p>
-</div>
+    array.includes(élémentRecherché)
+    array.includes(élémentRecherché, indiceDépart)
 
-<h2 id="Syntaxe">Syntaxe</h2>
+### Paramètres
 
-<pre class="syntaxbox">array.includes(élémentRecherché)
-array.includes(élémentRecherché, indiceDépart)
-</pre>
+- `élémentRecherché`
+  - : La valeur qu'on souhaite trouver dans le tableau (lorsqu'on manipule des caractères et des chaînes, la comparaison est sensible à la casse).
+- `indiceDépart` {{optional_inline}}
+  - : La position du tableau à partir de laquelle commencer à chercher `élémentRecherché`. Si on utilise une valeur négative, la recherche commencera à partir de la fin du tableau (autrement dit à l'indice `array.length - indiceDépart`). La valeur par défaut est 0.
 
-<h3 id="Paramètres">Paramètres</h3>
+### Valeur de retour
 
-<dl>
- <dt><code>élémentRecherché</code></dt>
- <dd>La valeur qu'on souhaite trouver dans le tableau (lorsqu'on manipule des caractères et des chaînes, la comparaison est sensible à la casse).</dd>
- <dt><code>indiceDépart</code> {{optional_inline}}</dt>
- <dd>La position du tableau à partir de laquelle commencer à chercher <code>élémentRecherché</code>. Si on utilise une valeur négative, la recherche commencera à partir de la fin du tableau (autrement dit à l'indice <code>array.length - indiceDépart</code>). La valeur par défaut est 0.</dd>
-</dl>
+Un {{jsxref("Boolean","booléen","",1)}} qui vaut `true` si `élémentRecherché` est trouvé dans le tableau (à partir de l'`indiceDépart` si celui-ci est indiqué). Les valeurs -0, +0 et 0 sont considérées comme équivalentes mais `false` n'est pas considéré comme équivalent à 0.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+> **Note :** Pour être tout à fait précis, `includes()` utilise l'algorithme _[SameValueZero](/fr/docs/Web/JavaScript/Les_différents_tests_d_égalité#Un_modèle_pour_mieux_comprendre)_ afin de déterminer si un élément donné est trouvé.
 
-<p>Un {{jsxref("Boolean","booléen","",1)}} qui vaut <code>true</code> si <code>élémentRecherché</code> est trouvé dans le tableau (à partir de l'<code>indiceDépart</code> si celui-ci est indiqué). Les valeurs -0, +0 et 0 sont considérées comme équivalentes mais <code>false</code> n'est pas considéré comme équivalent à 0.</p>
+## Exemples
 
-<div class="note">
-<p><strong>Note :</strong> Pour être tout à fait précis, <code>includes()</code> utilise l'algorithme <em><a href="/fr/docs/Web/JavaScript/Les_différents_tests_d_égalité#Un_modèle_pour_mieux_comprendre">SameValueZero</a></em> afin de déterminer si un élément donné est trouvé.</p>
-</div>
-
-<h2 id="Exemples">Exemples</h2>
-
-<pre class="brush: js">[1, 2, 3].includes(2);     // true
+```js
+[1, 2, 3].includes(2);     // true
 [1, 2, 3].includes(4);     // false
 [1, 2, 3].includes(3, 3);  // false
 [1, 2, 3].includes(3, -1); // true
@@ -56,23 +48,25 @@ array.includes(élémentRecherché, indiceDépart)
 
 ['a', 'b', 'c'].includes('c', 5);    // false
 ['a', 'b', 'c'].includes('c', -100); // true
-</pre>
+```
 
-<h3 id="indiceDépart_supérieur_ou_égal_à_la_longueur_du_tableau"><code>indiceDépart</code> supérieur ou égal à la longueur du tableau</h3>
+### `indiceDépart` supérieur ou égal à la longueur du tableau
 
-<p>SI <code>indiceDépart</code> est supérieur ou égal à la longueur du tableau, la méthode retourne <code>false</code>. Le tableau n'est pas parcouru.</p>
+SI `indiceDépart` est supérieur ou égal à la longueur du tableau, la méthode retourne `false`. Le tableau n'est pas parcouru.
 
-<pre class="brush: js">var arr = ['a', 'b', 'c'];
+```js
+var arr = ['a', 'b', 'c'];
 
 arr.includes('c', 3);   // false
 arr.includes('c', 100); // false
-</pre>
+```
 
-<h3 id="indiceDépart_strictement_négatif"><code>indiceDépart</code> strictement négatif</h3>
+### `indiceDépart` strictement négatif
 
-<p>Si <code>indiceDépart</code> est strictement négatif, l'indice de départ effectif est la somme entre la taille du tableau et <code>indiceDépart</code>. Si cette somme est toujours négative, le tableau est intégralement parcouru.</p>
+Si `indiceDépart` est strictement négatif, l'indice de départ effectif est la somme entre la taille du tableau et `indiceDépart`. Si cette somme est toujours négative, le tableau est intégralement parcouru.
 
-<pre class="brush: js">// Le tableau a une taille de 3
+```js
+// Le tableau a une taille de 3
 // indiceDépart vaut -2
 // L'indice de départ effectif vaut is 3 + (-2) = 1
 
@@ -81,54 +75,36 @@ var arr = ['a', 'b', 'c'];
 arr.includes('a', -2); // false
 arr.includes('b', -2); // true
 arr.includes('c', -100); // true
-</pre>
+```
 
-<h3 id="Utilisation_d'includes()_comme_méthode_générique">Utilisation d'<code>includes()</code> comme méthode générique</h3>
+### Utilisation d'`includes()` comme méthode générique
 
-<p><code>includes()</code> est une méhtode générique : l'objet sur lequel elle est appelée ne doit pas nécessairement être un tableau. On peut l'utiliser sur des objets semblables à des tableaux (ex. <code><a href="/fr/docs/Web/JavaScript/Reference/Fonctions/arguments">arguments</a></code> ou des chaînes de caractères) :</p>
+`includes()` est une méhtode générique : l'objet sur lequel elle est appelée ne doit pas nécessairement être un tableau. On peut l'utiliser sur des objets semblables à des tableaux (ex. [`arguments`](/fr/docs/Web/JavaScript/Reference/Fonctions/arguments) ou des chaînes de caractères) :
 
-<pre class="brush: js">function argumentsContientA(){
+```js
+function argumentsContientA(){
   return [].includes.call(arguments, 'a');
 }
 
 console.log(argumentsContientA('a','b','c')); // true
 console.log(argumentsContientA('d','e','f')); // false
-</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('ES7', '#sec-array.prototype.includes', 'Array.prototype.includes')}}</td>
-   <td>{{Spec2('ES7')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-array.prototype.includes', 'Array.prototype.includes')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Array.includes")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("TypedArray.prototype.includes()")}}</li>
- <li>{{jsxref("String.prototype.includes()")}}</li>
- <li>{{jsxref("Array.prototype.indexOf()")}}</li>
- <li>{{jsxref("Array.prototype.find()")}}</li>
- <li>{{jsxref("Array.prototype.findIndex()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                    | État                         | Commentaires         |
+| ---------------------------------------------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ES7', '#sec-array.prototype.includes', 'Array.prototype.includes')}}     | {{Spec2('ES7')}}         | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-array.prototype.includes', 'Array.prototype.includes')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Array.includes")}}
+
+## Voir aussi
+
+- {{jsxref("TypedArray.prototype.includes()")}}
+- {{jsxref("String.prototype.includes()")}}
+- {{jsxref("Array.prototype.indexOf()")}}
+- {{jsxref("Array.prototype.find()")}}
+- {{jsxref("Array.prototype.findIndex()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/array/index.md b/files/fr/web/javascript/reference/global_objects/array/index.md
index 3604ce3910..ad6c63e298 100644
--- a/files/fr/web/javascript/reference/global_objects/array/index.md
+++ b/files/fr/web/javascript/reference/global_objects/array/index.md
@@ -8,79 +8,89 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Array
 original_slug: Web/JavaScript/Reference/Objets_globaux/Array
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>L'objet global <strong><code>Array</code></strong> est utilisé pour créer des tableaux. Les tableaux sont des objets de haut-niveau (en termes de complexité homme-machine) semblables à des listes.</p>
+L'objet global **`Array`** est utilisé pour créer des tableaux. Les tableaux sont des objets de haut-niveau (en termes de complexité homme-machine) semblables à des listes.
 
-<p><strong>Créer un tableau</strong></p>
+**Créer un tableau**
 
-<pre class="brush: js">var fruits = ['Apple', 'Banana'];
+```js
+var fruits = ['Apple', 'Banana'];
 
 console.log(fruits.length);
 // 2
-</pre>
+```
 
-<p><strong>Accéder (via son index) à un élément du tableau</strong></p>
+**Accéder (via son index) à un élément du tableau**
 
-<pre class="brush: js">var first = fruits[0];
+```js
+var first = fruits[0];
 // Apple
 
 var last = fruits[fruits.length - 1];
 // Banana
-</pre>
+```
 
-<p><strong>Boucler sur un tableau</strong></p>
+**Boucler sur un tableau**
 
-<pre class="brush: js">fruits.forEach(function(item, index, array) {
+```js
+fruits.forEach(function(item, index, array) {
   console.log(item, index);
 });
 // Apple 0
 // Banana 1
-</pre>
+```
 
-<p><strong>Ajouter à la fin du tableau</strong></p>
+**Ajouter à la fin du tableau**
 
-<pre class="brush: js">var newLength = fruits.push('Orange');
+```js
+var newLength = fruits.push('Orange');
 // ["Apple", "Banana", "Orange"]
-</pre>
+```
 
-<p><strong>Supprimer le dernier élément du tableau</strong></p>
+**Supprimer le dernier élément du tableau**
 
-<pre class="brush: js">var last = fruits.pop(); // supprime Orange (à la fin)
+```js
+var last = fruits.pop(); // supprime Orange (à la fin)
 // ["Apple", "Banana"];
-</pre>
+```
 
-<p><strong>Supprimer le premier élément du tableau</strong></p>
+**Supprimer le premier élément du tableau**
 
-<pre class="brush: js">var first = fruits.shift(); // supprime Apple (au début)
+```js
+var first = fruits.shift(); // supprime Apple (au début)
 // ["Banana"];
-</pre>
+```
 
-<p><strong>Ajouter au début du tableau</strong></p>
+**Ajouter au début du tableau**
 
-<pre class="brush: js">var newLength = fruits.unshift('Strawberry') // ajoute au début
+```js
+var newLength = fruits.unshift('Strawberry') // ajoute au début
 // ["Strawberry", "Banana"];
-</pre>
+```
 
-<p><strong>Trouver l'index d'un élément dans le tableau</strong></p>
+**Trouver l'index d'un élément dans le tableau**
 
-<pre class="brush: js">fruits.push('Mango');
+```js
+fruits.push('Mango');
 // ["Strawberry", "Banana", "Mango"]
 
 var pos = fruits.indexOf('Banana');
 // 1
-</pre>
+```
 
-<p><strong>Supprimer un élément par son index</strong></p>
+**Supprimer un élément par son index**
 
-<pre class="brush: js">var removedItem = fruits.splice(pos, 1); // supprime 1 élément à la position pos
+```js
+var removedItem = fruits.splice(pos, 1); // supprime 1 élément à la position pos
 
 // ["Strawberry", "Mango"]
-</pre>
+```
 
-<p><strong>Supprimer des éléments à partir d'un index</strong></p>
+**Supprimer des éléments à partir d'un index**
 
-<pre class="brush: js">var vegetables = ['Cabbage', 'Turnip', 'Radish', 'Carrot'];
+```js
+var vegetables = ['Cabbage', 'Turnip', 'Radish', 'Carrot'];
 console.log(vegetables);
 // ["Cabbage", "Turnip", "Radish", "Carrot"]
 
@@ -95,111 +105,130 @@ console.log(vegetables);
 
 console.log(removedItems);
 // ["Turnip", "Radish"] (splice retourne la liste des éléments supprimés)
-</pre>
+```
 
-<p><strong>Copier un tableau</strong></p>
+**Copier un tableau**
 
-<pre class="brush: js">var shallowCopy = fruits.slice(); // crée un nouveau tableau qui contient les éléments de fruits
+```js
+var shallowCopy = fruits.slice(); // crée un nouveau tableau qui contient les éléments de fruits
 // ["Strawberry", "Mango"]
-</pre>
+```
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox notranslate">[<var>element0</var>, <var>element1</var>, ..., <var>elementN</var>]
-new Array(<var>element0</var>, <var>element1</var>[, ...[, <var>elementN</var>]])
-new Array(<var>arrayLength</var>)</pre>
+    [element0, element1, ..., elementN]
+    new Array(element0, element1[, ...[, elementN]])
+    new Array(arrayLength)
 
-<h3 id="Paramètres">Paramètres</h3>
-<dl>
- <dt><code><var>element0</var>, <var>element1</var>, ..., <var>elementN</var> </code></dt>
- <dd>Un tableau est initialisé avec les éléments donnés, sauf dans le cas où un seul argument est passé au constructeur <code>Array</code> et que cet argument est un nombre. (Voir ci-après.) Notez que ce cas spécial s'applique aux tableaux créés avec le constructeur <code>Array</code>, et non aux tableaux créés avec la syntaxe crochets.</dd>
- <dt><code><var>arrayLength</var></code></dt>
- <dd>Si le seul argument passé au constructeur <code>Array</code> est un entier entre 0 et 2^32-1 (inclus), un nouveau tableau sera créé avec ce nombre d'éléments (note : le tableau sera créé avec <code>arrayLength</code> emplacements vides, et non avec de véritables valeurs <code>undefined</code>). Si l'argument est un nombre en dehors de la plage autorisée, une exception {{jsxref("RangeError")}} est levée.</dd>
-</dl>
+### Paramètres
 
-<h2 id="Description">Description</h2>
+- `element0, element1, ..., elementN`
+  - : Un tableau est initialisé avec les éléments donnés, sauf dans le cas où un seul argument est passé au constructeur `Array` et que cet argument est un nombre. (Voir ci-après.) Notez que ce cas spécial s'applique aux tableaux créés avec le constructeur `Array`, et non aux tableaux créés avec la syntaxe crochets.
+- `arrayLength`
+  - : Si le seul argument passé au constructeur `Array` est un entier entre 0 et 2^32-1 (inclus), un nouveau tableau sera créé avec ce nombre d'éléments (note : le tableau sera créé avec `arrayLength` emplacements vides, et non avec de véritables valeurs `undefined`). Si l'argument est un nombre en dehors de la plage autorisée, une exception {{jsxref("RangeError")}} est levée.
 
-<p>Les tableaux sont des objets qui servent de liste et possèdent plusieurs méthodes incorporées pour exécuter des opérations de parcours et de modification.</p>
+## Description
 
-<p>Ni la taille d'un tableau ni le types de ses éléments n'est fixé. Puisque la dimension d'un tableau peut augmenter ou diminuer à tout moment, et que les éléments du tableau peuvent être stockés à des emplacements non contigus, les tableaux ne sont pas garantis d'être compacts. En général, ce sont des caractéristiques pratiques, mais si ces fonctionnalités ne sont pas souhaitables pour votre cas d'utilisation, vous pouvez envisager d'utiliser des tableaux typés.</p>
+Les tableaux sont des objets qui servent de liste et possèdent plusieurs méthodes incorporées pour exécuter des opérations de parcours et de modification.
 
-<p>Les tableaux ne peuvent pas utiliser de chaîne de caractères comme indice (comme dans un <a href="https://fr.wikipedia.org/wiki/Tableau_associatif">tableau associatif</a>) mais des entiers. Utiliser ou accéder à des index non entiers, en utilisant la <a href="https://developer.mozilla.org/fr/docs/Web/JavaScript/Guide/Utiliser_les_objets#Les_objets_et_les_propri%C3%A9t%C3%A9s">notation avec crochets</a> (ou <a href="https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateurs_de_membres">avec point</a>) ne va pas définir ou récupérer un élément sur le tableau lui-même, mais une variable associée à la  <a href="https://developer.mozilla.org/fr/docs/Web/JavaScript/Structures_de_donn%C3%A9es#Propri%C3%A9t%C3%A9s">collection de propriétés d'objet</a> de ce tableau.  Les propriétés du tableau et la liste de ses éléments sont séparées, et les <a href="https://developer.mozilla.org/fr/docs/Web/JavaScript/Guide/Collections_index%C3%A9es#M%C3%A9thodes_des_tableaux">opérations de parcours et de modification</a> ne s'appliquent pas à ces propriétés.</p>
+Ni la taille d'un tableau ni le types de ses éléments n'est fixé. Puisque la dimension d'un tableau peut augmenter ou diminuer à tout moment, et que les éléments du tableau peuvent être stockés à des emplacements non contigus, les tableaux ne sont pas garantis d'être compacts. En général, ce sont des caractéristiques pratiques, mais si ces fonctionnalités ne sont pas souhaitables pour votre cas d'utilisation, vous pouvez envisager d'utiliser des tableaux typés.
 
-<h3 id="Accéder_aux_éléments_dun_tableau">Accéder aux éléments d'un tableau</h3>
+Les tableaux ne peuvent pas utiliser de chaîne de caractères comme indice (comme dans un [tableau associatif](https://fr.wikipedia.org/wiki/Tableau_associatif)) mais des entiers. Utiliser ou accéder à des index non entiers, en utilisant la [notation avec crochets](https://developer.mozilla.org/fr/docs/Web/JavaScript/Guide/Utiliser_les_objets#Les_objets_et_les_propri%C3%A9t%C3%A9s) (ou [avec point](https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateurs_de_membres)) ne va pas définir ou récupérer un élément sur le tableau lui-même, mais une variable associée à la  [collection de propriétés d'objet](https://developer.mozilla.org/fr/docs/Web/JavaScript/Structures_de_donn%C3%A9es#Propri%C3%A9t%C3%A9s) de ce tableau.  Les propriétés du tableau et la liste de ses éléments sont séparées, et les [opérations de parcours et de modification](https://developer.mozilla.org/fr/docs/Web/JavaScript/Guide/Collections_index%C3%A9es#M%C3%A9thodes_des_tableaux) ne s'appliquent pas à ces propriétés.
 
-<p>Les tableaux sont indexés à partir de zéro: le premier élément d'un tableau a pour indice <code>0</code>, et la position du dernier élément est donnée par {{jsxref("Array.length", "length")}} moins 1. Si on utilise un indice en dehors de cet intervalle, le résultat sera {{jsxref("undefined")}} (sous réserve qu'aucune propriété n'ait été ajoutée au préalable avec cet indice).</p>
+### Accéder aux éléments d'un tableau
 
-<pre class="brush: js notranslate">var arr = ["le premier élément", "le deuxième élément", "le dernier élément"];
+Les tableaux sont indexés à partir de zéro: le premier élément d'un tableau a pour indice `0`, et la position du dernier élément est donnée par {{jsxref("Array.length", "length")}} moins 1. Si on utilise un indice en dehors de cet intervalle, le résultat sera {{jsxref("undefined")}} (sous réserve qu'aucune propriété n'ait été ajoutée au préalable avec cet indice).
+
+```js
+var arr = ["le premier élément", "le deuxième élément", "le dernier élément"];
 console.log(arr[0]);             // affiche "le premier élément"
 console.log(arr[1]);             // affiche "le deuxième élément"
-console.log(arr[arr.length - 1]);// affiche "le dernier élément"</pre>
+console.log(arr[arr.length - 1]);// affiche "le dernier élément"
+```
 
-<p>Les éléments d'un tableau sont des propriétés d'objets de la même manière que <code>toString</code> est une propriété. Cependant, essayer d'accéder à un élément du tableau comme suit renverra une erreur car le nom de la propriété utilisé est invalide :</p>
+Les éléments d'un tableau sont des propriétés d'objets de la même manière que `toString` est une propriété. Cependant, essayer d'accéder à un élément du tableau comme suit renverra une erreur car le nom de la propriété utilisé est invalide :
 
-<pre class="brush: js notranslate">console.log(arr.0); // erreur de syntaxe</pre>
+```js
+console.log(arr.0); // erreur de syntaxe
+```
 
-<p>Ce comportement est tout à fait normal. En effet, il n'est pas possible d'accéder aux propriétés dont le nom commence par un chiffre avec cette notation (le point). Il est nécessaire d'utiliser la syntaxe avec les crochets pour accéder à ces propriétés. Ainsi, si pour un objet quelconque, on avait une propriété nommée '<code>3d</code>', on ne pourra y faire référence qu'en utilisant les crochets. Exemple :</p>
+Ce comportement est tout à fait normal. En effet, il n'est pas possible d'accéder aux propriétés dont le nom commence par un chiffre avec cette notation (le point). Il est nécessaire d'utiliser la syntaxe avec les crochets pour accéder à ces propriétés. Ainsi, si pour un objet quelconque, on avait une propriété nommée '`3d`', on ne pourra y faire référence qu'en utilisant les crochets. Exemple :
 
-<pre class="brush: js notranslate">var années = [1950, 1960, 1970, 1980, 1990, 2000, 2010];
+```js
+var années = [1950, 1960, 1970, 1980, 1990, 2000, 2010];
 
 console.log(années.0);  // erreur de syntaxe
-console.log(années[0]); // fonctionne correctement</pre>
+console.log(années[0]); // fonctionne correctement
+```
 
-<pre class="brush: js notranslate">renderer.3d.setTexture(model, "personnage.png");   // erreur de syntaxe
-renderer["3d"].setTexture(model, "personnage.png");// fonctionne correctement </pre>
+```js
+renderer.3d.setTexture(model, "personnage.png");   // erreur de syntaxe
+renderer["3d"].setTexture(model, "personnage.png");// fonctionne correctement 
+```
 
-<p>Dans cet exemple, on utilise des doubles quotes autour de <code>3d</code>. On peut aussi utiliser les doubles quotes pour accéder aux éléments d'un tableau (ex. : <code>années["2"]</code> au lieu de <code>années[2]</code>), mais ce n'est pas obligatoire. Dans l'instruction <code>années[2]</code>, le nombre sera converti en une chaîne de caractères par le moteur JavaScript. Pour cette raison, si on utilise les noms de propriété "2" et "02", on fera référence à deux propriétés différentes, et le fragment de code suivant renvoie donc <code>true</code>:</p>
+Dans cet exemple, on utilise des doubles quotes autour de `3d`. On peut aussi utiliser les doubles quotes pour accéder aux éléments d'un tableau (ex. : `années["2"]` au lieu de `années[2]`), mais ce n'est pas obligatoire. Dans l'instruction `années[2]`, le nombre sera converti en une chaîne de caractères par le moteur JavaScript. Pour cette raison, si on utilise les noms de propriété "2" et "02", on fera référence à deux propriétés différentes, et le fragment de code suivant renvoie donc `true`:
 
-<pre class="brush: js notranslate">console.log(années["2"] != années["02"]); </pre>
+```js
+console.log(années["2"] != années["02"]); 
+```
 
-<p>De manière similaire, les propriétés nommées avec des mots-clés réservés ne peuvent être consultées qu'en utilisant la syntaxe avec crochets :</p>
+De manière similaire, les propriétés nommées avec des mots-clés réservés ne peuvent être consultées qu'en utilisant la syntaxe avec crochets :
 
-<pre class="brush: js notranslate">var promise = {
+```js
+var promise = {
   'var' : 'text',
   'array': [1, 2, 3, 4]
 };
 
-console.log(promise['var']);</pre>
+console.log(promise['var']);
+```
 
-<div class="note">
-<p><strong>Note :</strong> Depuis Firefox 40.0a2, il est possible d'utiliser la notation avec le point pour accéder aux propriétés dont les noms ne sont pas des identifiants valides.</p>
-</div>
+> **Note :** Depuis Firefox 40.0a2, il est possible d'utiliser la notation avec le point pour accéder aux propriétés dont les noms ne sont pas des identifiants valides.
 
-<h3 id="Relation_entre_length_et_les_propriétés_numériques">Relation entre <code>length</code> et les propriétés numériques</h3>
+### Relation entre `length` et les propriétés numériques
 
-<p>La propriété {{jsxref("Array.length", "length")}} d'un tableau est liée aux propriétés numériques du tableau. Plusieurs méthodes natives utilisent cette propriété : {{jsxref("Array.join", "join()")}}, {{jsxref("Array.slice", "slice()")}}, {{jsxref("Array.indexOf", "indexOf()")}}, etc. D'autres méthodes comme {{jsxref("Array.push", "push()")}} et {{jsxref("Array.splice", "splice()")}} modifient le tableau et la propriété {{jsxref("Array.length", "length")}}.</p>
+La propriété {{jsxref("Array.length", "length")}} d'un tableau est liée aux propriétés numériques du tableau. Plusieurs méthodes natives utilisent cette propriété : {{jsxref("Array.join", "join()")}}, {{jsxref("Array.slice", "slice()")}}, {{jsxref("Array.indexOf", "indexOf()")}}, etc. D'autres méthodes comme {{jsxref("Array.push", "push()")}} et {{jsxref("Array.splice", "splice()")}} modifient le tableau et la propriété {{jsxref("Array.length", "length")}}.
 
-<pre class="brush: js notranslate">var fruits = [];
+```js
+var fruits = [];
 fruits.push("banane", "pomme", "pêche");
 
-console.log(fruits.length); // 3</pre>
+console.log(fruits.length); // 3
+```
 
-<p>Lorsqu'on définit une nouvelle propriété numérique pour un tableau, que l'index utilisé est valide et que celui-ci est dehors des limites actuelles du tableau, le moteur JavaScript mettra à jour la propriété {{jsxref("Array.length", "length")}} :</p>
+Lorsqu'on définit une nouvelle propriété numérique pour un tableau, que l'index utilisé est valide et que celui-ci est dehors des limites actuelles du tableau, le moteur JavaScript mettra à jour la propriété {{jsxref("Array.length", "length")}} :
 
-<pre class="brush: js notranslate">fruits[5] = "mangue";
+```js
+fruits[5] = "mangue";
 console.log(fruits[5]);  // "mangue"
 console.log(Object.keys(fruits)); // ['0', '1', '2', '5']
-console.log(fruits.length); // 6 </pre>
+console.log(fruits.length); // 6 
+```
 
-<p>On peut également modifier la propriété directement (cela n'ajoutera pas de nouveaux éléments) :</p>
+On peut également modifier la propriété directement (cela n'ajoutera pas de nouveaux éléments) :
 
-<pre class="brush: js notranslate">fruits.length = 10;
+```js
+fruits.length = 10;
 console.log(Object.keys(fruits)); // ['0', '1', '2', '5']
-console.log(fruits.length);  // 10</pre>
+console.log(fruits.length);  // 10
+```
 
-<p>En revanche, si on diminue la valeur de {{jsxref("Array.length", "length")}}, cela supprimera des éléments :</p>
+En revanche, si on diminue la valeur de {{jsxref("Array.length", "length")}}, cela supprimera des éléments :
 
-<pre class="brush: js notranslate">fruits.length = 2;
+```js
+fruits.length = 2;
 console.log(Object.keys(fruits)); // ['0', '1']
-console.log(fruits.length); // 2</pre>
+console.log(fruits.length); // 2
+```
 
-<p>Pour plus d'informations sur le comportement de cette propriété, voir la page {{jsxref("Array.length")}}.</p>
+Pour plus d'informations sur le comportement de cette propriété, voir la page {{jsxref("Array.length")}}.
 
-<h3 id="Création_dun_tableau_utilisant_le_résultat_dune_correspondance">Création d'un tableau utilisant le résultat d'une correspondance</h3>
+### Création d'un tableau utilisant le résultat d'une correspondance
 
-<p>Le résultat d'une correspondance entre une expression rationnelle et une chaîne peut créer un tableau. Ce tableau possède des propriétés et des éléments qui fournissent des informations sur cette correspondance. Il est possible d'obtenir un tableau grâce aux méthodes {{jsxref("RegExp.exec")}}, {{jsxref("String.match")}}, and {{jsxref("String.replace")}}. Pour mieux comprendre le fonctionnement de ces propriétés et de ces éléments, on pourra utiliser l'exemple et le tableau qui suivent :</p>
+Le résultat d'une correspondance entre une expression rationnelle et une chaîne peut créer un tableau. Ce tableau possède des propriétés et des éléments qui fournissent des informations sur cette correspondance. Il est possible d'obtenir un tableau grâce aux méthodes {{jsxref("RegExp.exec")}}, {{jsxref("String.match")}}, and {{jsxref("String.replace")}}. Pour mieux comprendre le fonctionnement de ces propriétés et de ces éléments, on pourra utiliser l'exemple et le tableau qui suivent :
 
-<pre class="brush: js notranslate">// Matche un "d" suivit par un ou plusieurs "b" et suivit d'un "d"
+```js
+// Matche un "d" suivit par un ou plusieurs "b" et suivit d'un "d"
 // Capture les "b" et le "d" qui suit
 // Ignore la casse
 
@@ -207,137 +236,150 @@ var maRegexp = /d(b+)(d)/i;
 var monTableau = maRegexp.exec("cdbBdbsbz");
 
 console.log(monTableau);
-// [ 0:"dbBd", 1:"bB", 2:"d", index:1, input:"cdbBdbsbz", length:3 ]</pre>
+// [ 0:"dbBd", 1:"bB", 2:"d", index:1, input:"cdbBdbsbz", length:3 ]
+```
 
-<p>Les propriétés et les éléments retournés depuis cette correspondance sont les suivants :</p>
+Les propriétés et les éléments retournés depuis cette correspondance sont les suivants :
 
 <table class="fullwidth-table">
- <tbody>
-  <tr>
-   <td class="header">Propriété/Élément</td>
-   <td class="header">Description</td>
-   <td class="header">Exemple</td>
-  </tr>
-  <tr>
-   <td><code>input</code></td>
-   <td>Une propriété en lecture seule qui reflète la chaîne originale sur laquelle l'expression rationnelle a été appliquée.</td>
-   <td>cdbBdbsbz</td>
-  </tr>
-  <tr>
-   <td><code>index</code></td>
-   <td>Une propriété en lecture seule qui est l'indice de la correspondance dans la chaîne (les indices commencent à 0)</td>
-   <td>1</td>
-  </tr>
-  <tr>
-   <td><code>[0]</code></td>
-   <td>Une propriété en lecture seule qui spécifie les derniers caractères correspondants.</td>
-   <td>dbBd</td>
-  </tr>
-  <tr>
-   <td><code>[1], ...[n]</code></td>
-   <td>Des éléments en lecture seule qui contiennent les groupes capturés, s'il y en a dans l'expression régulière. Le nombre de groupes capturés possibles est illimité.</td>
-   <td>[1]: bB<br>
-    [2]: d</td>
-  </tr>
- </tbody>
+  <tbody>
+    <tr>
+      <td class="header">Propriété/Élément</td>
+      <td class="header">Description</td>
+      <td class="header">Exemple</td>
+    </tr>
+    <tr>
+      <td><code>input</code></td>
+      <td>
+        Une propriété en lecture seule qui reflète la chaîne originale sur
+        laquelle l'expression rationnelle a été appliquée.
+      </td>
+      <td>cdbBdbsbz</td>
+    </tr>
+    <tr>
+      <td><code>index</code></td>
+      <td>
+        Une propriété en lecture seule qui est l'indice de la correspondance
+        dans la chaîne (les indices commencent à 0)
+      </td>
+      <td>1</td>
+    </tr>
+    <tr>
+      <td><code>[0]</code></td>
+      <td>
+        Une propriété en lecture seule qui spécifie les derniers caractères
+        correspondants.
+      </td>
+      <td>dbBd</td>
+    </tr>
+    <tr>
+      <td><code>[1], ...[n]</code></td>
+      <td>
+        Des éléments en lecture seule qui contiennent les groupes capturés, s'il
+        y en a dans l'expression régulière. Le nombre de groupes capturés
+        possibles est illimité.
+      </td>
+      <td>[1]: bB<br />[2]: d</td>
+    </tr>
+  </tbody>
 </table>
 
-<h2 id="Propriétés">Propriétés</h2>
+## Propriétés
 
-<dl>
- <dt>{{jsxref("Array.prototype.length")}}</dt>
- <dd>La propriété de longueur pour le constructeur <code>Array</code>, elle vaut 1.</dd>
- <dt>{{jsxref("Array.@@species", "get Array[@@species]")}}</dt>
- <dd>La fonction de construction utilisée pour créer les objets dérivés.</dd>
- <dt>{{jsxref("Array.prototype")}}</dt>
- <dd>Cette propriété permet d'ajouter des propriétés à tous les tableaux.</dd>
-</dl>
+- {{jsxref("Array.prototype.length")}}
+  - : La propriété de longueur pour le constructeur `Array`, elle vaut 1.
+- {{jsxref("Array.@@species", "get Array[@@species]")}}
+  - : La fonction de construction utilisée pour créer les objets dérivés.
+- {{jsxref("Array.prototype")}}
+  - : Cette propriété permet d'ajouter des propriétés à tous les tableaux.
 
-<h2 id="Méthodes">Méthodes</h2>
+## Méthodes
 
-<dl>
- <dt>{{jsxref("Array.from()")}}</dt>
- <dd>Cette méthode permet de créer une nouvelle instance d'<code>Array</code> à partir d'un objet semblable à un tableau ou d'un itérable.</dd>
- <dt>{{jsxref("Array.isArray()")}}</dt>
- <dd>Cette méthode renvoie <code>true</code> si la variable est un tableau, <code>false</code> sinon.</dd>
- <dt>{{jsxref("Array.of()")}}</dt>
- <dd>Cette méthode permet de créer une nouvelle instance d'<code>Array</code> à partir d'un nombre variable d'arguments (peu importe la quantité ou le type des arguments utilisés).</dd>
-</dl>
+- {{jsxref("Array.from()")}}
+  - : Cette méthode permet de créer une nouvelle instance d'`Array` à partir d'un objet semblable à un tableau ou d'un itérable.
+- {{jsxref("Array.isArray()")}}
+  - : Cette méthode renvoie `true` si la variable est un tableau, `false` sinon.
+- {{jsxref("Array.of()")}}
+  - : Cette méthode permet de créer une nouvelle instance d'`Array` à partir d'un nombre variable d'arguments (peu importe la quantité ou le type des arguments utilisés).
 
-<h2 id="Instances_dArray">Instances d'<code>Array</code></h2>
+## Instances d'`Array`
 
-<p>Toutes les instances d'<code>Array</code> héritent de {{jsxref("Array.prototype")}}. Le prototype du constructeur <code>Array</code> peut être modifié afin d'affecter l'ensemble des instances grâce à l'héritage.</p>
+Toutes les instances d'`Array` héritent de {{jsxref("Array.prototype")}}. Le prototype du constructeur `Array` peut être modifié afin d'affecter l'ensemble des instances grâce à l'héritage.
 
-<h3 id="Les_propriétés">Les propriétés</h3>
+### Les propriétés
 
-<div>{{page('fr/docs/Web/JavaScript/Reference/Objets_globaux/Array/prototype', 'Propriétés')}}</div>
+{{page('fr/docs/Web/JavaScript/Reference/Objets_globaux/Array/prototype', 'Propriétés')}}
 
-<h3 id="Les_méthodes">Les méthodes</h3>
+### Les méthodes
 
-<h4 id="Les_mutateurs">Les mutateurs</h4>
+#### Les mutateurs
 
-<div>{{page('fr/docs/Web/JavaScript/Reference/Objets_globaux/Array/prototype', 'Mutateurs')}}</div>
+{{page('fr/docs/Web/JavaScript/Reference/Objets_globaux/Array/prototype', 'Mutateurs')}}
 
-<h4 id="Les_accesseurs">Les accesseurs</h4>
+#### Les accesseurs
 
-<div>{{page('fr/docs/Web/JavaScript/Reference/Objets_globaux/Array/prototype', 'Accesseurs')}}</div>
+{{page('fr/docs/Web/JavaScript/Reference/Objets_globaux/Array/prototype', 'Accesseurs')}}
 
-<h4 id="Les_méthodes_ditération">Les méthodes d'itération</h4>
+#### Les méthodes d'itération
 
-<div>{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/Array/prototype', 'Méthodes_itératives')}}</div>
+{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/Array/prototype', 'Méthodes_itératives')}}
 
-<h2 id="Les_méthodes_génériques_de_manipulation_de_tableaux">Les méthodes génériques de manipulation de tableaux</h2>
+## Les méthodes génériques de manipulation de tableaux
 
-<div class="warning">
-<p><strong>Attention :</strong> Ces méthodes génériques ne sont pas standard. Elles sont dépréciées et seront retirées dans un avenir proche. Celles-ci ne peuvent être utilisées sur tous les navigateurs. Toutefois, il existe <a href="https://github.com/plusdude/array-generics">un <em>shim</em> disponible sur GitHub</a>.</p>
-</div>
+> **Attention :** Ces méthodes génériques ne sont pas standard. Elles sont dépréciées et seront retirées dans un avenir proche. Celles-ci ne peuvent être utilisées sur tous les navigateurs. Toutefois, il existe [un _shim_ disponible sur GitHub](https://github.com/plusdude/array-generics).
 
-<p>Parfois, on peut vouloir appliquer des méthodes pour les tableaux sur des chaînes ou d'autres objets semblables aux tableaux (ex. : l'objet {{jsxref("Fonctions/arguments", "arguments", "", 1)}}). Une chaîne sera donc traitée comme un tableau de caractères. Ainsi, si on souhaite vérifier que chaque caractère d'une chaîne <code><var>str</var></code> est bien une lettre comprise entre 'a' et 'z', on pourra utiliser :</p>
+Parfois, on peut vouloir appliquer des méthodes pour les tableaux sur des chaînes ou d'autres objets semblables aux tableaux (ex. : l'objet {{jsxref("Fonctions/arguments", "arguments", "", 1)}}). Une chaîne sera donc traitée comme un tableau de caractères. Ainsi, si on souhaite vérifier que chaque caractère d'une chaîne `str` est bien une lettre comprise entre 'a' et 'z', on pourra utiliser :
 
-<pre class="brush: js notranslate">function estUneLettre(caractère) {
-  return caractère &gt;= 'a' &amp;&amp; caractère &lt;= 'z';
+```js
+function estUneLettre(caractère) {
+  return caractère >= 'a' && caractère <= 'z';
 }
 
 if (Array.prototype.every.call(str, estUneLettre)) {
   console.log("La chaîne '" + str + "' ne contient que des lettres entre a et z!");
 }
-</pre>
+```
 
-<p>Cette notation étant plutôt verbeuse, une notation raccourcie a été introduite avec JavaScript 1.6 :</p>
+Cette notation étant plutôt verbeuse, une notation raccourcie a été introduite avec JavaScript 1.6 :
 
-<pre class="brush: js notranslate">if (Array.every(str,estUneLettre)) {
+```js
+if (Array.every(str,estUneLettre)) {
   console.log("La chaîne '" + str + "' ne contient que des lettres entre a et z !");
 }
-</pre>
+```
 
-<p>Des {{jsxref("Objets_globaux/String", "méthodes génériques", "#Méthodes_génériques_de_String", 1)}} sont également disponibles pour les {{jsxref("Objets_globaux/String", "String")}}.</p>
+Des {{jsxref("Objets_globaux/String", "méthodes génériques", "#Méthodes_génériques_de_String", 1)}} sont également disponibles pour les {{jsxref("Objets_globaux/String", "String")}}.
 
-<p>Cette fonctionnalité ne fait pas partie du standard ECMAScript et n'est pas prise en charge par les navigateurs qui ne sont pas basés sur Gecko. Comme alternative standard, vous pouvez convertir votre objet en véritable tableau grâce à la méthode {{jsxref("Array.from()")}} (attention, cette méthode n'est pas supportée dans les anciens navigateurs) :</p>
+Cette fonctionnalité ne fait pas partie du standard ECMAScript et n'est pas prise en charge par les navigateurs qui ne sont pas basés sur Gecko. Comme alternative standard, vous pouvez convertir votre objet en véritable tableau grâce à la méthode {{jsxref("Array.from()")}} (attention, cette méthode n'est pas supportée dans les anciens navigateurs) :
 
-<pre class="brush: js notranslate">if (Array.from(str).every(estUneLettre)) {
+```js
+if (Array.from(str).every(estUneLettre)) {
   console.log("La chaîne '" + str + "' contient uniquement des lettres !");
-}</pre>
+}
+```
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Créer_un_tableau">Créer un tableau</h3>
+### Créer un tableau
 
-<p>Dans l'exemple suivant, on crée un tableau <code>tableauMsg</code>, d'une longueur nulle. Ensuite, on lui affecte des valeurs pour <code>tableauMsg[0]</code> et <code>tableauMsg[99]</code>, ce qui aura pour effet de modifier la propriété <code>length</code> (qui vaudra alors 100).</p>
+Dans l'exemple suivant, on crée un tableau `tableauMsg`, d'une longueur nulle. Ensuite, on lui affecte des valeurs pour `tableauMsg[0]` et `tableauMsg[99]`, ce qui aura pour effet de modifier la propriété `length` (qui vaudra alors 100).
 
-<pre class="brush: js notranslate">var tableauMsg = [];
+```js
+var tableauMsg = [];
 tableauMsg[0] = 'Coucou';
 tableauMsg[99] = 'monde';
 
 if (tableauMsg.length === 100) {
   console.log('La longueur du tableau vaut 100.');
 }
-</pre>
+```
 
-<h3 id="Créer_un_tableau_à_deux_dimensions">Créer un tableau à deux dimensions</h3>
+### Créer un tableau à deux dimensions
 
-<p>Dans l'exemple qui suit, on crée un plateau d'échec grâce à un tableau en deux dimensions qui contient des caractères. Le premier mouvement est effectué en copiant 'p' de (6,4) vers (4,4). La position anciennement occupée par le pion (6,4) devient vide.</p>
+Dans l'exemple qui suit, on crée un plateau d'échec grâce à un tableau en deux dimensions qui contient des caractères. Le premier mouvement est effectué en copiant 'p' de (6,4) vers (4,4). La position anciennement occupée par le pion (6,4) devient vide.
 
-<pre class="brush: js notranslate">var plateau = [
+```js
+var plateau = [
   ['T','C','F','R','K','F','C','T'],
   ['P','P','P','P','P','P','P','P'],
   [' ',' ',' ',' ',' ',' ',' ',' '],
@@ -353,44 +395,45 @@ console.log(plateau.join('\n') + '\n\n');
 plateau[4][4] = plateau[6][4];
 plateau[6][4] = ' ';
 console.log(plateau.join('\n'));
-</pre>
-
-<p>Voici le résultat affiché :</p>
-
-<pre class="eval notranslate">T,C,F,R,K,F,C,T
-P,P,P,P,P,P,P,P
- , , , , , , ,
- , , , , , , ,
- , , , , , , ,
- , , , , , , ,
-p,p,p,p,p,p,p,p
-t,c,f,k,r,f,c,t
-
-T,C,F,R,K,F,C,T
-P,P,P,P,P,P,P,P
- , , , , , , ,
- , , , , , , ,
- , , , ,p, , ,
- , , , , , , ,
-p,p,p,p, ,p,p,p
-t,c,f,k,r,f,c,t
-</pre>
-
-<h3 id="Utiliser_un_tableau_pour_tabuler_un_ensemble_de_valeurs">Utiliser un tableau pour tabuler un ensemble de valeurs</h3>
-
-<pre class="brush: js">values = [];
-for (var x = 0; x &lt; 10; x++){
+```
+
+Voici le résultat affiché :
+
+    T,C,F,R,K,F,C,T
+    P,P,P,P,P,P,P,P
+     , , , , , , ,
+     , , , , , , ,
+     , , , , , , ,
+     , , , , , , ,
+    p,p,p,p,p,p,p,p
+    t,c,f,k,r,f,c,t
+
+    T,C,F,R,K,F,C,T
+    P,P,P,P,P,P,P,P
+     , , , , , , ,
+     , , , , , , ,
+     , , , ,p, , ,
+     , , , , , , ,
+    p,p,p,p, ,p,p,p
+    t,c,f,k,r,f,c,t
+
+### Utiliser un tableau pour tabuler un ensemble de valeurs
+
+```js
+values = [];
+for (var x = 0; x < 10; x++){
  values.push([
   2 ** x,
   2 * x ** 2
  ])
 };
 console.table(values)
-</pre>
+```
 
-<p>Résulte en</p>
+Résulte en
 
-<pre class="brush: plain">0	1	0
+```plain
+0	1	0
 1	2	2
 2	4	8
 3	8	18
@@ -400,57 +443,28 @@ console.table(values)
 7	128	98
 8	256	128
 9	512	162
-</pre>
-
-<p>(Le première colonne est l'index)</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</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.4', 'Array')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td>Ajout de nouvelles méthodes : {{jsxref("Array.isArray")}}, {{jsxref("Array.prototype.indexOf", "indexOf")}}, {{jsxref("Array.prototype.lastIndexOf", "lastIndexOf")}}, {{jsxref("Array.prototype.every", "every")}}, {{jsxref("Array.prototype.some", "some")}}, {{jsxref("Array.prototype.forEach", "forEach")}}, {{jsxref("Array.prototype.map", "map")}}, {{jsxref("Array.prototype.filter", "filter")}}, {{jsxref("Array.prototype.reduce", "reduce")}}, {{jsxref("Array.prototype.reduceRight", "reduceRight")}}</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-array-objects', 'Array')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Ajout de nouvelles méthodes : {{jsxref("Array.from")}}, {{jsxref("Array.of")}}, {{jsxref("Array.prototype.find", "find")}}, {{jsxref("Array.prototype.findIndex", "findIndex")}}, {{jsxref("Array.prototype.fill", "fill")}}, {{jsxref("Array.prototype.copyWithin", "copyWithin")}}</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES7', '#sec-array-objects', 'Array')}}</td>
-   <td>{{Spec2('ES7')}}</td>
-   <td>Ajout de la méthode {{jsxref("Array.prototype.includes()")}}.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-array-objects', 'Array')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
+```
+
+(Le première colonne est l'index)
+
+## Spécifications
+
+| Spécification                                                            | État                         | Commentaires                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| ------------------------------------------------------------------------ | ---------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| {{SpecName('ES1')}}                                                 | {{Spec2('ES1')}}         | Définition initiale                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| {{SpecName('ES5.1', '#sec-15.4', 'Array')}}                 | {{Spec2('ES5.1')}}     | Ajout de nouvelles méthodes : {{jsxref("Array.isArray")}}, {{jsxref("Array.prototype.indexOf", "indexOf")}}, {{jsxref("Array.prototype.lastIndexOf", "lastIndexOf")}}, {{jsxref("Array.prototype.every", "every")}}, {{jsxref("Array.prototype.some", "some")}}, {{jsxref("Array.prototype.forEach", "forEach")}}, {{jsxref("Array.prototype.map", "map")}}, {{jsxref("Array.prototype.filter", "filter")}}, {{jsxref("Array.prototype.reduce", "reduce")}}, {{jsxref("Array.prototype.reduceRight", "reduceRight")}} |
+| {{SpecName('ES6', '#sec-array-objects', 'Array')}}     | {{Spec2('ES6')}}         | Ajout de nouvelles méthodes : {{jsxref("Array.from")}}, {{jsxref("Array.of")}}, {{jsxref("Array.prototype.find", "find")}}, {{jsxref("Array.prototype.findIndex", "findIndex")}}, {{jsxref("Array.prototype.fill", "fill")}}, {{jsxref("Array.prototype.copyWithin", "copyWithin")}}                                                                                                                                                                                                                                                                                                             |
+| {{SpecName('ES7', '#sec-array-objects', 'Array')}}     | {{Spec2('ES7')}}         | Ajout de la méthode {{jsxref("Array.prototype.includes()")}}.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| {{SpecName('ESDraft', '#sec-array-objects', 'Array')}} | {{Spec2('ESDraft')}} |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.Array")}}</p>
+{{Compat("javascript.builtins.Array")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li><a href="/fr/docs/Web/JavaScript/Guide/Utiliser_les_objets#Indexer_les_propri.C3.A9t.C3.A9s_d'un_objet">Guide JavaScript : indexer les propriétés d'un objet</a></li>
- <li><a href="/fr/docs/Web/JavaScript/Guide/Objets_élémentaires_JavaScript#Les_tableaux_.3A_objet_Array">Guide JavaScript : Les objets natifs : l'objet <code>Array</code></a></li>
- <li><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Compréhensions_de_tableau">Les compréhensions de tableau</a></li>
- <li><a href="https://github.com/plusdude/array-generics">Émulation pour les méthodes génériques et autres fonctionnalités ECMAScript 5 pour les tableaux</a> (en anglais)</li>
- <li><a href="/fr/docs/Web/JavaScript/Tableaux_typés">Les tableaux typés</a></li>
-</ul>
+- [Guide JavaScript : indexer les propriétés d'un objet](/fr/docs/Web/JavaScript/Guide/Utiliser_les_objets#Indexer_les_propri.C3.A9t.C3.A9s_d'un_objet)
+- [Guide JavaScript : Les objets natifs : l'objet `Array`](/fr/docs/Web/JavaScript/Guide/Objets_élémentaires_JavaScript#Les_tableaux_.3A_objet_Array)
+- [Les compréhensions de tableau](/fr/docs/Web/JavaScript/Reference/Opérateurs/Compréhensions_de_tableau)
+- [Émulation pour les méthodes génériques et autres fonctionnalités ECMAScript 5 pour les tableaux](https://github.com/plusdude/array-generics) (en anglais)
+- [Les tableaux typés](/fr/docs/Web/JavaScript/Tableaux_typés)
diff --git a/files/fr/web/javascript/reference/global_objects/array/indexof/index.md b/files/fr/web/javascript/reference/global_objects/array/indexof/index.md
index cdd545abc9..14d8d2e1f4 100644
--- a/files/fr/web/javascript/reference/global_objects/array/indexof/index.md
+++ b/files/fr/web/javascript/reference/global_objects/array/indexof/index.md
@@ -11,57 +11,55 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Array/indexOf
 original_slug: Web/JavaScript/Reference/Objets_globaux/Array/indexOf
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>indexOf()</strong></code> renvoie le premier indice pour lequel on trouve un élément donné dans un tableau. Si l'élément cherché n'est pas présent dans le tableau, la méthode renverra -1.</p>
+La méthode **`indexOf()`** renvoie le premier indice pour lequel on trouve un élément donné dans un tableau. Si l'élément cherché n'est pas présent dans le tableau, la méthode renverra -1.
 
-<div class="note">
-<p><strong>Note :</strong> pour la méthode associée aux chaînes de caractères, voir la page {{jsxref("String.prototype.indexOf()")}}.</p>
-</div>
+> **Note :** pour la méthode associée aux chaînes de caractères, voir la page {{jsxref("String.prototype.indexOf()")}}.
 
-<div>{{EmbedInteractiveExample("pages/js/array-indexof.html")}}</div>
+{{EmbedInteractiveExample("pages/js/array-indexof.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>arr</var>.indexOf(<var>élémentRecherché</var>)
-<var>arr</var>.indexOf(<var>élémentRecherché</var>, indiceDébut)
-</pre>
+    arr.indexOf(élémentRecherché)
+    arr.indexOf(élémentRecherché, indiceDébut)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>élémentRecherché</code></dt>
- <dd>L'élément qu'on cherche dans le tableau</dd>
- <dt><code>indiceDébut</code> {{optional_inline}}</dt>
- <dd>L'index à partir duquel commencer la recherche. La valeur par défaut est 0 (le tableau sera parcouru dans sa totalité). Si l'index est plus grand ou égal à la longueur du tableau, la méthode renverra -1. Si l'index est négatif, la recherche commencera d'autant d'éléments, à partir de la fin du tableau. À noter que même si l'index est négatif, la recherche s'effectue toujours du début jusqu'à la fin du tableau. Si l'index fourni est inférieur à 0, le tableau sera entièrement parcouru.</dd>
-</dl>
+- `élémentRecherché`
+  - : L'élément qu'on cherche dans le tableau
+- `indiceDébut` {{optional_inline}}
+  - : L'index à partir duquel commencer la recherche. La valeur par défaut est 0 (le tableau sera parcouru dans sa totalité). Si l'index est plus grand ou égal à la longueur du tableau, la méthode renverra -1. Si l'index est négatif, la recherche commencera d'autant d'éléments, à partir de la fin du tableau. À noter que même si l'index est négatif, la recherche s'effectue toujours du début jusqu'à la fin du tableau. Si l'index fourni est inférieur à 0, le tableau sera entièrement parcouru.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Le premier index de l'élément dans le tableau ou -1 si la valeur n'est pas trouvée.</p>
+Le premier index de l'élément dans le tableau ou -1 si la valeur n'est pas trouvée.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p><code>indexOf</code> compare <code>élémentRecherché</code> aux éléments contenus dans le tableau en utilisant une <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_comparaison#.C3.89galit.C3.A9_stricte_(.3D.3D.3D)">égalité stricte</a> (la même méthode utilisée par l'opérateur <code>===</code>).</p>
+`indexOf` compare `élémentRecherché` aux éléments contenus dans le tableau en utilisant une [égalité stricte](</fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_comparaison#.C3.89galit.C3.A9_stricte_(.3D.3D.3D)>) (la même méthode utilisée par l'opérateur `===`).
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_indexOf()">Utiliser <code>indexOf()</code></h3>
+### Utiliser `indexOf()`
 
-<p>Dans l'exemple qui suit, on peut utiliser <code>indexOf</code> afin de trouver l'emplacement d'un élément dans un tableau.</p>
+Dans l'exemple qui suit, on peut utiliser `indexOf` afin de trouver l'emplacement d'un élément dans un tableau.
 
-<pre class="brush: js">var tableau = [2, 9, 9];
+```js
+var tableau = [2, 9, 9];
 tableau.indexOf(2);     // 0
 tableau.indexOf(7);     // -1
 tableau.indexOf(9, 2);  // 2
 tableau.indexOf(2, -1); // -1
-tableau.indexOf(2, -3); // 0</pre>
+tableau.indexOf(2, -3); // 0
+```
 
-<h3 id="Trouver_toutes_les_occurences_d'un_élément">Trouver toutes les occurences d'un élément</h3>
+### Trouver toutes les occurences d'un élément
 
-<p>Dans l'exemple qui suit, on utilise <code>indexOf()</code> afin de trouver tous les indices d'un élément dans un tableau. On peut utiliser la méthode {{jsxref("Array.prototype.push", "push")}} afin d'ajouter ces indices dans un autre tableau.</p>
+Dans l'exemple qui suit, on utilise `indexOf()` afin de trouver tous les indices d'un élément dans un tableau. On peut utiliser la méthode {{jsxref("Array.prototype.push", "push")}} afin d'ajouter ces indices dans un autre tableau.
 
-<pre class="brush: js">var indices = [];
+```js
+var indices = [];
 var tableau = ['a', 'b', 'a', 'c', 'a', 'd'];
 var élément = 'a';
 var idx = tableau.indexOf(élément);
@@ -70,15 +68,17 @@ while (idx != -1) {
   idx = tableau.indexOf(élément, idx + 1);
 }
 console.log(indices);
-// [0, 2, 4]</pre>
+// [0, 2, 4]
+```
 
-<h3 id="Trouver_si_un_élément_existe_et_l'ajouter_dans_le_tableau_si_ce_n'est_pas_le_cas">Trouver si un élément existe et l'ajouter dans le tableau si ce n'est pas le cas</h3>
+### Trouver si un élément existe et l'ajouter dans le tableau si ce n'est pas le cas
 
-<pre class="brush: js">function mettreAJourLegumes(tabLégumes, légume) {
+```js
+function mettreAJourLegumes(tabLégumes, légume) {
     if (tabLégumes.indexOf(légume) === -1) {
         tabLégumes.push(légume);
         console.log('Le nouveau tableau est : ' + tabLégumes);
-    } else if (tabLégumes.indexOf(légume) &gt; -1) {
+    } else if (tabLégumes.indexOf(légume) > -1) {
         console.log(légume + ' existe déjà dans le tableau.');
     }
 }
@@ -88,13 +88,15 @@ var tabLégumes = ['pomme de terre', 'tomate', 'poivron'];
 mettreAJourLegumes(tabLégumes, 'épinard');
 // Le nouveau tableau est : pomme de terre,tomate,poivron,épinard
 mettreAJourLegumes(tabLégumes, 'épinard');
-// épinard existe déjà dans le tableau.</pre>
+// épinard existe déjà dans le tableau.
+```
 
-<h2 id="Prothèse_d'émulation_(polyfill)">Prothèse d'émulation (<em>polyfill</em>)</h2>
+## Prothèse d'émulation (_polyfill_)
 
-<p><code>indexOf</code> fut ajouté avec la cinquième édition du standard ECMA-262 ; il peut donc ne pas être présent dans tous les navigateurs web. Vous pouvez contourner ce problème en insérant le code suivant au début de vos scripts. Il permet d'utiliser <code>indexOf</code> dans les environnements qui ne le supportent pas nativement. L'algorithme est le même que celui spécifié dans ECMAScript 5 si on a bien {{jsxref("TypeError", "TypeError")}} et {{jsxref("Math.abs")}} qui ont leurs valeurs originales :</p>
+`indexOf` fut ajouté avec la cinquième édition du standard ECMA-262 ; il peut donc ne pas être présent dans tous les navigateurs web. Vous pouvez contourner ce problème en insérant le code suivant au début de vos scripts. Il permet d'utiliser `indexOf` dans les environnements qui ne le supportent pas nativement. L'algorithme est le même que celui spécifié dans ECMAScript 5 si on a bien {{jsxref("TypeError", "TypeError")}} et {{jsxref("Math.abs")}} qui ont leurs valeurs originales :
 
-<pre class="brush: js">// Production steps of ECMA-262, Edition 5, 15.4.4.14
+```js
+// Production steps of ECMA-262, Edition 5, 15.4.4.14
 // Référence : http://es5.github.io/#x15.4.4.14
 if (!Array.prototype.indexOf) {
   Array.prototype.indexOf = function(searchElement, fromIndex) {
@@ -113,7 +115,7 @@ if (!Array.prototype.indexOf) {
     //    méthode interne Get de O avec l'argument
     //    "length".
     // 3. Soit len le résultat de ToUint32(lenValue).
-    var len = O.length &gt;&gt;&gt; 0;
+    var len = O.length >>> 0;
 
     // 4. Si len vaut 0, on renvoie -1.
     if (len === 0) {
@@ -129,18 +131,18 @@ if (!Array.prototype.indexOf) {
       n = 0;
     }
 
-    // 6. Si n &gt;= len, on renvoie -1.
-    if (n &gt;= len) {
+    // 6. Si n >= len, on renvoie -1.
+    if (n >= len) {
       return -1;
     }
 
-    // 7. Si n &gt;= 0, soit k égal à n.
-    // 8. Sinon, si n&lt;0, soit k égal à len - abs(n).
+    // 7. Si n >= 0, soit k égal à n.
+    // 8. Sinon, si n<0, soit k égal à len - abs(n).
     //    Si k est inférieur à 0, on ramène k égal à 0.
-    k = Math.max(n &gt;= 0 ? n : len - Math.abs(n), 0);
+    k = Math.max(n >= 0 ? n : len - Math.abs(n), 0);
 
-    // 9. On répète tant que k &lt; len
-    while (k &lt; len) {
+    // 9. On répète tant que k < len
+    while (k < len) {
       // a. Soit Pk égal à ToString(k).
       //    Ceci est implicite pour l'opérande gauche de in
       // b. Soit kPresent le résultat de l'appel de la
@@ -155,55 +157,33 @@ if (!Array.prototype.indexOf) {
       //        l'algorithme d'égalité stricte entre
       //        searchElement et elementK.
       //  iii.  Si same vaut true, on renvoie k.
-      if (k in O &amp;&amp; O[k] === searchElement) {
+      if (k in O && O[k] === searchElement) {
         return k;
       }
       k++;
     }
     return -1;
   };
-}</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.4.4.14', 'Array.prototype.indexOf')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td>Définition initiale. Implémentée avec JavaScript 1.6.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-array.prototype.indexof', 'Array.prototype.indexOf')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-array.prototype.indexof', 'Array.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.Array.indexOf")}}</p>
-
-<h2 id="Notes_de_compatibilité">Notes de compatibilité</h2>
-
-<ul>
- <li>À partir de Firefox 47 ({{geckoRelease(47)}}), cette méthode ne renverra plus <code>-0</code>. Ainsi, <code>[0].indexOf(0, -0)</code> renverra toujours <code>+0</code> (cf. {{bug(1242043)}}).</li>
-</ul>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Array.prototype.lastIndexOf()")}}</li>
- <li>{{jsxref("TypedArray.prototype.indexOf()")}}</li>
-</ul>
+}
+```
+
+## Spécifications
+
+| Spécification                                                                                                | État                         | Commentaires                                          |
+| ------------------------------------------------------------------------------------------------------------ | ---------------------------- | ----------------------------------------------------- |
+| {{SpecName('ES5.1', '#sec-15.4.4.14', 'Array.prototype.indexOf')}}                     | {{Spec2('ES5.1')}}     | Définition initiale. Implémentée avec JavaScript 1.6. |
+| {{SpecName('ES6', '#sec-array.prototype.indexof', 'Array.prototype.indexOf')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-array.prototype.indexof', 'Array.prototype.indexOf')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Array.indexOf")}}
+
+## Notes de compatibilité
+
+- À partir de Firefox 47 ({{geckoRelease(47)}}), cette méthode ne renverra plus `-0`. Ainsi, `[0].indexOf(0, -0)` renverra toujours `+0` (cf. {{bug(1242043)}}).
+
+## Voir aussi
+
+- {{jsxref("Array.prototype.lastIndexOf()")}}
+- {{jsxref("TypedArray.prototype.indexOf()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/array/isarray/index.md b/files/fr/web/javascript/reference/global_objects/array/isarray/index.md
index f57266afff..c4b10b3082 100644
--- a/files/fr/web/javascript/reference/global_objects/array/isarray/index.md
+++ b/files/fr/web/javascript/reference/global_objects/array/isarray/index.md
@@ -11,40 +11,40 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Array/isArray
 original_slug: Web/JavaScript/Reference/Objets_globaux/Array/isArray
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>Array.isArray()</strong></code> permet de déterminer si l'objet passé en argument est un objet {{jsxref("Array")}}, elle renvoie <code>true</code> si le paramètre passé à la fonction est de type <code>Array</code> et <code>false</code> dans le cas contraire.</p>
+La méthode **`Array.isArray()`** permet de déterminer si l'objet passé en argument est un objet {{jsxref("Array")}}, elle renvoie `true` si le paramètre passé à la fonction est de type `Array` et `false` dans le cas contraire.
 
-<pre class="brush: js">Array.isArray([1, 2, 3]);   // true
+```js
+Array.isArray([1, 2, 3]);   // true
 Array.isArray({toto: 123}); // false
 Array.isArray("tototruc");  // false
 Array.isArray(undefined);   // false
-</pre>
+```
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">Array.isArray(<var>value</var>)</pre>
+    Array.isArray(value)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>value</code></dt>
- <dd>La valeur dont on veut vérifier le type</dd>
-</dl>
+- `value`
+  - : La valeur dont on veut vérifier le type
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p><code>true</code> si la valeur est un tableau (une instance de {{jsxref("Array")}}), <code>false</code> sinon.</p>
+`true` si la valeur est un tableau (une instance de {{jsxref("Array")}}), `false` sinon.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Si l'objet indiqué en paramètre est un {{jsxref("Array")}}, la méthode renvoie <code>true</code>, sinon, elle renvoie <code>false</code>.</p>
+Si l'objet indiqué en paramètre est un {{jsxref("Array")}}, la méthode renvoie `true`, sinon, elle renvoie `false`.
 
-<p>Voir aussi : « <a href="http://web.mit.edu/jwalden/www/isArray.html">Determining with absolute accuracy whether or not a JavaScript object is an array</a> » (en anglais) pour avoir plus de détails. Si on passe un objet {{jsxref("TypedArray")}} en argument, ce sera toujours la valeur <code>false</code> qui sera renvoyée.</p>
+Voir aussi : « [Determining with absolute accuracy whether or not a JavaScript object is an array](http://web.mit.edu/jwalden/www/isArray.html) » (en anglais) pour avoir plus de détails. Si on passe un objet {{jsxref("TypedArray")}} en argument, ce sera toujours la valeur `false` qui sera renvoyée.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<pre class="brush: js">// Tous les appels suivant renvoient true
+```js
+// Tous les appels suivant renvoient true
 Array.isArray([]);
 Array.isArray([1]);
 Array.isArray(new Array());
@@ -64,51 +64,32 @@ Array.isArray(true);
 Array.isArray(false);
 Array.isArray(new Uint8Array(32));
 Array.isArray({ __proto__ : Array.prototype });
-</pre>
+```
 
-<h2 id="Prothèse_d'émulation_(polyfill)">Prothèse d'émulation (<em>polyfill</em>)</h2>
+## Prothèse d'émulation (_polyfill_)
 
-<p>Exécuter ce code avant tout les autres aboutira à la création de la méthode <code>Array.isArray()</code>si elle n'est pas nativement prise en charge par le navigateur.</p>
+Exécuter ce code avant tout les autres aboutira à la création de la méthode `Array.isArray()`si elle n'est pas nativement prise en charge par le navigateur.
 
-<pre class="brush: js">if(!Array.isArray) {
+```js
+if(!Array.isArray) {
   Array.isArray = function(arg) {
     return Object.prototype.toString.call(arg) === '[object Array]';
   };
-}</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.4.3.2', 'Array.isArray')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td>Définition initiale. Implémentée avec JavaScript 1.8.5.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-array.isarray', 'Array.isArray')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-array.isarray', 'Array.isArray')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Array.isArray")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Array")}}</li>
-</ul>
+}
+```
+
+## Spécifications
+
+| Spécification                                                                        | État                         | Commentaires                                            |
+| ------------------------------------------------------------------------------------ | ---------------------------- | ------------------------------------------------------- |
+| {{SpecName('ES5.1', '#sec-15.4.3.2', 'Array.isArray')}}             | {{Spec2('ES5.1')}}     | Définition initiale. Implémentée avec JavaScript 1.8.5. |
+| {{SpecName('ES6', '#sec-array.isarray', 'Array.isArray')}}         | {{Spec2('ES6')}}         |                                                         |
+| {{SpecName('ESDraft', '#sec-array.isarray', 'Array.isArray')}} | {{Spec2('ESDraft')}} |                                                         |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Array.isArray")}}
+
+## Voir aussi
+
+- {{jsxref("Array")}}
diff --git a/files/fr/web/javascript/reference/global_objects/array/join/index.md b/files/fr/web/javascript/reference/global_objects/array/join/index.md
index cdb8f6b0f6..860e358953 100644
--- a/files/fr/web/javascript/reference/global_objects/array/join/index.md
+++ b/files/fr/web/javascript/reference/global_objects/array/join/index.md
@@ -10,98 +10,71 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Array/join
 original_slug: Web/JavaScript/Reference/Objets_globaux/Array/join
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>join()</strong></code> crée et renvoie une nouvelle chaîne de caractères en concaténant tous les éléments d'un tableau (ou d'<a href="/fr/docs/Web/JavaScript/Guide/Collections_indexées#Manipuler_des_objets_semblables_à_des_tableaux">un objet semblable à un tableau</a>). La concaténation utilise la virgule ou une autre chaîne, fournie en argument, comme séparateur.</p>
+La méthode **`join()`** crée et renvoie une nouvelle chaîne de caractères en concaténant tous les éléments d'un tableau (ou d'[un objet semblable à un tableau](/fr/docs/Web/JavaScript/Guide/Collections_indexées#Manipuler_des_objets_semblables_à_des_tableaux)). La concaténation utilise la virgule ou une autre chaîne, fournie en argument, comme séparateur.
 
-<div>{{EmbedInteractiveExample("pages/js/array-join.html")}}</div>
+{{EmbedInteractiveExample("pages/js/array-join.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>arr</var>.join()
-<var>arr</var>.join(<var>séparateur</var>)
-</pre>
+    arr.join()
+    arr.join(séparateur)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>séparateur</code> {{optional_inline}}</dt>
- <dd>Ce paramètre optionnel indique une chaine de caractères pour séparer chaque élément du tableau. Le séparateur est converti en une chaine de caractères si nécessaire. Si ce paramètre n'est pas utilisé, les éléments du tableau seront séparés par une virgule (,). Si ce paramètre est la chaîne vide, les éléments seront accolés les uns aux autres sans espace entre. La valeur par défaut de ce paramètre est <code>","</code>.</dd>
-</dl>
+- `séparateur` {{optional_inline}}
+  - : Ce paramètre optionnel indique une chaine de caractères pour séparer chaque élément du tableau. Le séparateur est converti en une chaine de caractères si nécessaire. Si ce paramètre n'est pas utilisé, les éléments du tableau seront séparés par une virgule (,). Si ce paramètre est la chaîne vide, les éléments seront accolés les uns aux autres sans espace entre. La valeur par défaut de ce paramètre est `","`.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une chaîne de caractères composée de tous les éléments du tableau joints les uns aux autres. Si la longueur du tableau (<code>arr.length</code>) vaut <code>0</code>, c'est la chaîne vide qui est renvoyée. Si le tableau ne contient qu'un élément, sa version texte sera renvoyée sans être suivie du séparateur.</p>
+Une chaîne de caractères composée de tous les éléments du tableau joints les uns aux autres. Si la longueur du tableau (`arr.length`) vaut `0`, c'est la chaîne vide qui est renvoyée. Si le tableau ne contient qu'un élément, sa version texte sera renvoyée sans être suivie du séparateur.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Les différents éléments du tableau sont convertis en une chaîne de caractères puis fusionnés en une seule chaîne. Si un élément vaut <code>undefined</code> ou <code>null</code>, il sera converti en la chaîne vide. Cette fonction est générique et peut donc être utilisée avec <a href="/fr/docs/Web/JavaScript/Guide/Collections_indexées#Manipuler_des_objets_semblables_à_des_tableaux">les objets semblables aux tableaux</a>.</p>
+Les différents éléments du tableau sont convertis en une chaîne de caractères puis fusionnés en une seule chaîne. Si un élément vaut `undefined` ou `null`, il sera converti en la chaîne vide. Cette fonction est générique et peut donc être utilisée avec [les objets semblables aux tableaux](/fr/docs/Web/JavaScript/Guide/Collections_indexées#Manipuler_des_objets_semblables_à_des_tableaux).
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Fusionner_un_tableau_de_quatre_façons_différentes">Fusionner un tableau de quatre façons différentes</h3>
+### Fusionner un tableau de quatre façons différentes
 
-<p>L'exemple suivant crée un tableau, <code>a</code>, avec trois éléments, puis joint le tableau à trois reprises : en utilisant le séparateur par défaut, une virgule et un espace, puis un plus, puis avec la chaîne vide.</p>
+L'exemple suivant crée un tableau, `a`, avec trois éléments, puis joint le tableau à trois reprises : en utilisant le séparateur par défaut, une virgule et un espace, puis un plus, puis avec la chaîne vide.
 
-<pre class="brush: js">var a = new Array("Vent","Pluie","Feu");
+```js
+var a = new Array("Vent","Pluie","Feu");
 a.join();      // "Vent,Pluie,Feu"
 a.join(", ");  // "Vent, Pluie, Feu"
 a.join(" + "); // "Vent + Pluie + Feu"
-a.join("");    // "VentPluieFeu"</pre>
+a.join("");    // "VentPluieFeu"
+```
 
-<h3 id="Fusionner_un_objet_semblable_à_un_tableau">Fusionner un objet semblable à un tableau</h3>
+### Fusionner un objet semblable à un tableau
 
-<p>Dans l'exemple suivant, on effectue la fusion sur un objet semblable à un tableau (<code><a href="/fr/docs/Web/JavaScript/Reference/Fonctions/arguments">arguments</a></code>) en appelant {{jsxref("Function.prototype.call")}} sur <code>Array.prototype.join</code>.</p>
+Dans l'exemple suivant, on effectue la fusion sur un objet semblable à un tableau ([`arguments`](/fr/docs/Web/JavaScript/Reference/Fonctions/arguments)) en appelant {{jsxref("Function.prototype.call")}} sur `Array.prototype.join`.
 
-<pre class="brush: js">function f(a, b, c) {
+```js
+function f(a, b, c) {
   var s = Array.prototype.join.call(arguments);
   console.log(s);
 }
 f(1, 'a', true); // '1,a,true'
-</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.1.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.4.4.5', 'Array.prototype.join')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-array.prototype.join', 'Array.prototype.join')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-array.prototype.join', 'Array.prototype.join')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Array.join")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("String.prototype.split()")}}</li>
- <li>{{jsxref("Array.prototype.toString()")}}</li>
- <li>{{jsxref("TypedArray.prototype.join()")}}</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.4.4.5', 'Array.prototype.join')}}                 | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-array.prototype.join', 'Array.prototype.join')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-array.prototype.join', 'Array.prototype.join')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Array.join")}}
+
+## Voir aussi
+
+- {{jsxref("String.prototype.split()")}}
+- {{jsxref("Array.prototype.toString()")}}
+- {{jsxref("TypedArray.prototype.join()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/array/keys/index.md b/files/fr/web/javascript/reference/global_objects/array/keys/index.md
index 88e747da9c..51483bec61 100644
--- a/files/fr/web/javascript/reference/global_objects/array/keys/index.md
+++ b/files/fr/web/javascript/reference/global_objects/array/keys/index.md
@@ -12,71 +12,57 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Array/keys
 original_slug: Web/JavaScript/Reference/Objets_globaux/Array/keys
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>keys()</strong></code> renvoie un nouvel objet <code><strong>Array Iterator</strong></code> qui contient les clefs pour chaque indice du tableau.</p>
+La méthode **`keys()`** renvoie un nouvel objet **`Array Iterator`** qui contient les clefs pour chaque indice du tableau.
 
-<div>{{EmbedInteractiveExample("pages/js/array-keys.html")}}</div>
+{{EmbedInteractiveExample("pages/js/array-keys.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>arr</var>.keys()</pre>
+    arr.keys()
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un nouvel objet itérateur pour {{jsxref("Array")}}.</p>
+Un nouvel objet itérateur pour {{jsxref("Array")}}.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utilisation_simple">Utilisation simple</h3>
+### Utilisation simple
 
-<pre class="brush:js">var arr = ["a","b","c"];
+```js
+var arr = ["a","b","c"];
 var itérateur = arr.keys();
 
 console.log(itérateur.next()); // { value: 0, done: false }
 console.log(itérateur.next()); // { value: 1, done: false }
 console.log(itérateur.next()); // { value: 2, done: false }
 console.log(itérateur.next()); // { value: undefined, done: true }
-</pre>
+```
 
-<h3 id="Un_itérateur_de_clés_prend_en_compte_les_trous">Un itérateur de clés prend en compte les trous</h3>
+### Un itérateur de clés prend en compte les trous
 
-<pre class="brush: js">var arr = ["a", , "c"];
+```js
+var arr = ["a", , "c"];
 var clésCreuses = Object.keys(arr);
 var clésDenses = [...arr.keys()];
 console.log(clésCreuses); // ["0", "2"]
-console.log(clésDenses);  // [0, 1, 2]</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-array.prototype.keys', 'Array.prototype.keys')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-array.prototype.keys', 'Array.prototype.keys')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Array.keys")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Array.prototype.entries()")}}</li>
- <li>{{jsxref("Array.prototype.values()")}}</li>
- <li><a href="/fr/docs/Web/JavaScript/Reference/Les_protocoles_iteration">Les protocoles d'itération</a></li>
-</ul>
+console.log(clésDenses);  // [0, 1, 2]
+```
+
+## Spécifications
+
+| Spécification                                                                                        | État                         | Commentaires         |
+| ---------------------------------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ES2015', '#sec-array.prototype.keys', 'Array.prototype.keys')}} | {{Spec2('ES2015')}}     | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-array.prototype.keys', 'Array.prototype.keys')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Array.keys")}}
+
+## Voir aussi
+
+- {{jsxref("Array.prototype.entries()")}}
+- {{jsxref("Array.prototype.values()")}}
+- [Les protocoles d'itération](/fr/docs/Web/JavaScript/Reference/Les_protocoles_iteration)
diff --git a/files/fr/web/javascript/reference/global_objects/array/lastindexof/index.md b/files/fr/web/javascript/reference/global_objects/array/lastindexof/index.md
index eb2c70d644..abd24ae929 100644
--- a/files/fr/web/javascript/reference/global_objects/array/lastindexof/index.md
+++ b/files/fr/web/javascript/reference/global_objects/array/lastindexof/index.md
@@ -12,73 +12,74 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf
 original_slug: Web/JavaScript/Reference/Objets_globaux/Array/lastIndexOf
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>lastIndexOf()</strong></code> permet de renvoyer le dernier indice pour lequel une valeur donnée est présente dans un tableau. Si la valeur recherchée n'est pas présente, le résultat sera -1. Lors de la recherche, le tableau est parcouru dans le sens des index décroissants, à partir de l'index <code>indexDébut</code>.</p>
+La méthode **`lastIndexOf()`** permet de renvoyer le dernier indice pour lequel une valeur donnée est présente dans un tableau. Si la valeur recherchée n'est pas présente, le résultat sera -1. Lors de la recherche, le tableau est parcouru dans le sens des index décroissants, à partir de l'index `indexDébut`.
 
-<div>{{EmbedInteractiveExample("pages/js/array-lastindexof.html")}}</div>
+{{EmbedInteractiveExample("pages/js/array-lastindexof.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>arr</var>.lastIndexOf(<var>élémentRecherché</var>)
-<var>arr</var>.lastIndexOf(<var>élémentRecherché</var>, <var>indexDébut</var>)
-</pre>
+    arr.lastIndexOf(élémentRecherché)
+    arr.lastIndexOf(élémentRecherché, indexDébut)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>élémentRecherché</code></dt>
- <dd>L'élément à qu'on cherche dans le tableau.</dd>
- <dt><code>indexDébut</code> {{optional_inline}}</dt>
- <dd>L'index à partir duquel commencer la recherche dans le tableau (la recherche s'effectuant à l'envers). Si le paramètre est absent, sa valeur par défaut sera la longueur du tableau moins 1 (c'est-à-dire <code>arr.length - 1</code>), le tableau sera alors parcouru dans sa totalité. Si l'index est plus grand ou égal à la longueur du tableau, le tableau sera parcouru en entier. Si l'index est négatif, la recherche commencera d'autant d'éléments à partir de la fin du tableau. À noter que, même si l'index est négatif, la recherche s'effectuera toujours de la fin jusqu'au début du tableau. Si l'index calculé est inférieur à 0, la méthode renverra -1 et le tableau ne sera pas parcouru.</dd>
-</dl>
+- `élémentRecherché`
+  - : L'élément à qu'on cherche dans le tableau.
+- `indexDébut` {{optional_inline}}
+  - : L'index à partir duquel commencer la recherche dans le tableau (la recherche s'effectuant à l'envers). Si le paramètre est absent, sa valeur par défaut sera la longueur du tableau moins 1 (c'est-à-dire `arr.length - 1`), le tableau sera alors parcouru dans sa totalité. Si l'index est plus grand ou égal à la longueur du tableau, le tableau sera parcouru en entier. Si l'index est négatif, la recherche commencera d'autant d'éléments à partir de la fin du tableau. À noter que, même si l'index est négatif, la recherche s'effectuera toujours de la fin jusqu'au début du tableau. Si l'index calculé est inférieur à 0, la méthode renverra -1 et le tableau ne sera pas parcouru.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Le dernier index auquel on trouve la valeur dans le tableau, -1 si elle n'est pas trouvée.</p>
+Le dernier index auquel on trouve la valeur dans le tableau, -1 si elle n'est pas trouvée.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p><code>lastIndexOf</code> compare <code>élémentRecherché</code> aux éléments contenus dans le tableau en utilisant une <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_comparaison#.C3.89galit.C3.A9_stricte_(.3D.3D.3D)">égalité stricte</a> (l'égalité utilisée par l'opérateur ===).</p>
+`lastIndexOf` compare `élémentRecherché` aux éléments contenus dans le tableau en utilisant une [égalité stricte](</fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_comparaison#.C3.89galit.C3.A9_stricte_(.3D.3D.3D)>) (l'égalité utilisée par l'opérateur ===).
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_lastIndexOf">Utiliser <code>lastIndexOf</code></h3>
+### Utiliser `lastIndexOf`
 
-<p>Dans l'exemple suivant, on utilise <code>lastIndexOf</code> afin de situer une valeur dans un tableau.</p>
+Dans l'exemple suivant, on utilise `lastIndexOf` afin de situer une valeur dans un tableau.
 
-<pre class="brush: js">var tableau = [2, 5, 9, 2];
+```js
+var tableau = [2, 5, 9, 2];
 tableau.lastIndexOf(2);     // 3
 tableau.lastIndexOf(7);     // -1
 tableau.lastIndexOf(2, 3);  // 3
 tableau.lastIndexOf(2, 2);  // 0
 tableau.lastIndexOf(2, -2); // 0
-tableau.lastIndexOf(2, -1); // 3</pre>
+tableau.lastIndexOf(2, -1); // 3
+```
 
-<h3 id="Trouver_toutes_les_occurrences_dun_élément">Trouver toutes les occurrences d'un élément</h3>
+### Trouver toutes les occurrences d'un élément
 
-<p>L’exemple suivant utilise <code>lastIndexOf</code> pour trouver tous les index (<code>indices</code>) d’un élément dans un tableau donné, en utilisant {{jsxref("Array.prototype.push", "push")}} pour les ajouter dans un autre tableau quand ils sont trouvés.</p>
+L’exemple suivant utilise `lastIndexOf` pour trouver tous les index (`indices`) d’un élément dans un tableau donné, en utilisant {{jsxref("Array.prototype.push", "push")}} pour les ajouter dans un autre tableau quand ils sont trouvés.
 
-<pre class="brush: js">var indices = [];
+```js
+var indices = [];
 var tableau = ['a', 'b', 'a', 'c', 'a', 'd'];
 var élément = 'a';
 var idx = tableau.lastIndexOf(élément);
 while (idx !== -1) {
   indices.push(idx);
-  idx = (idx &gt; 0 ? tableau.lastIndexOf(élément, idx - 1) : -1);
+  idx = (idx > 0 ? tableau.lastIndexOf(élément, idx - 1) : -1);
 }
 
 console.log(indices);
-// [4, 2, 0]</pre>
+// [4, 2, 0]
+```
 
-<p>Remarquez que nous avons dû traiter le cas de <code>idx === 0</code> séparément (<code>idx &gt; 0</code>) parce que l’élément sera toujours trouvé, indépendamment du paramètre de <code>fromIndex</code>, si c’est le premier élément du tableau. C’est une différence avec la méthode {{jsxref("Array.prototype.indexOf", "indexOf")}}.</p>
+Remarquez que nous avons dû traiter le cas de `idx === 0` séparément (`idx > 0`) parce que l’élément sera toujours trouvé, indépendamment du paramètre de `fromIndex`, si c’est le premier élément du tableau. C’est une différence avec la méthode {{jsxref("Array.prototype.indexOf", "indexOf")}}.
 
+## Prothèse d'émulation (_polyfill_)
 
-<h2 id="Prothèse_démulation_polyfill">Prothèse d'émulation (<em>polyfill</em>)</h2>
+`lastIndexOf` a été ajouté avec la cinquième édition du standard ECMA-262 ; il peut donc ne pas être présent dans tous les navigateurs web. Vous pouvez contourner ce problème en insérant le code suivant au début de vos scripts. Il vous permettra d'utiliser `lastIndexOf` avec les navigateurs qui ne le supportent pas nativement. L'algorithme qui suit est le même que celui spécifié par ECMAScript 5 si {{jsxref("Object", "Object")}}, {{jsxref("TypeError", "TypeError")}}, {{jsxref("Number", "Number")}}, {{jsxref("Math.floor")}}, {{jsxref("Math.abs")}}, et {{jsxref("Math.min")}} n'ont pas été modifiés et conservent leurs valeurs originales.
 
-<p><code>lastIndexOf</code> a été ajouté avec la cinquième édition du standard ECMA-262 ; il peut donc ne pas être présent dans tous les navigateurs web. Vous pouvez contourner ce problème en insérant le code suivant au début de vos scripts. Il vous permettra d'utiliser <code>lastIndexOf</code> avec les navigateurs qui ne le supportent pas nativement. L'algorithme qui suit est le même que celui spécifié par ECMAScript 5 si {{jsxref("Object", "Object")}}, {{jsxref("TypeError", "TypeError")}}, {{jsxref("Number", "Number")}}, {{jsxref("Math.floor")}}, {{jsxref("Math.abs")}}, et {{jsxref("Math.min")}} n'ont pas été modifiés et conservent leurs valeurs originales.</p>
-
-<pre class="brush: js">// Production steps of ECMA-262, Edition 5, 15.4.4.15
+```js
+// Production steps of ECMA-262, Edition 5, 15.4.4.15
 // Reference: http://es5.github.io/#x15.4.4.15
 if (!Array.prototype.lastIndexOf) {
   Array.prototype.lastIndexOf = function(searchElement /*, fromIndex*/) {
@@ -90,73 +91,51 @@ if (!Array.prototype.lastIndexOf) {
 
     var n, k,
       t = Object(this),
-      len = t.length &gt;&gt;&gt; 0;
+      len = t.length >>> 0;
     if (len === 0) {
       return -1;
     }
 
     n = len - 1;
-    if (arguments.length &gt; 1) {
+    if (arguments.length > 1) {
       n = Number(arguments[1]);
       if (n != n) {
         n = 0;
       }
-      else if (n != 0 &amp;&amp; n != (1 / 0) &amp;&amp; n != -(1 / 0)) {
-        n = (n &gt; 0 || -1) * Math.floor(Math.abs(n));
+      else if (n != 0 && n != (1 / 0) && n != -(1 / 0)) {
+        n = (n > 0 || -1) * Math.floor(Math.abs(n));
       }
     }
 
-    for (k = n &gt;= 0 ? Math.min(n, len - 1) : len - Math.abs(n); k &gt;= 0; k--) {
-      if (k in t &amp;&amp; t[k] === searchElement) {
+    for (k = n >= 0 ? Math.min(n, len - 1) : len - Math.abs(n); k >= 0; k--) {
+      if (k in t && t[k] === searchElement) {
         return k;
       }
     }
     return -1;
   };
-}</pre>
-
-<p>On notera que cette implémentation vise une compatibilité absolue de <code>lastIndexOf</code> dans Firefox et le moteur JavaScript SpiderMonkey, incluant plusieurs cas très particuliers. Si vous comptez l'utiliser dans une application, vous devriez pouvoir calculer <code>from</code> avec un code beaucoup moins compliqué.</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('ES5.1', '#sec-15.4.4.15', 'Array.prototype.lastIndexOf')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td>Définition initiale. Implémentée avec JavaScript 1.6.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-array.prototype.lastindexof', 'Array.prototype.lastIndexOf')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-array.prototype.lastindexof', 'Array.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.Array.lastIndexOf")}}</p>
-
-<h2 id="Notes_de_compatibilité">Notes de compatibilité</h2>
-
-<ul>
- <li>À partir de Firefox 47 ({{geckoRelease(47)}}), cette méthode ne renverra plus <code>-0</code>. Ainsi, <code>[0].lastIndexOf(0, -0)</code> renverra toujours <code>+0</code> (cf. {{bug(1242043)}}).</li>
-</ul>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Array.prototype.indexOf()")}}</li>
- <li>{{jsxref("TypedArray.prototype.lastIndexOf()")}}</li>
-</ul>
+}
+```
+
+On notera que cette implémentation vise une compatibilité absolue de `lastIndexOf` dans Firefox et le moteur JavaScript SpiderMonkey, incluant plusieurs cas très particuliers. Si vous comptez l'utiliser dans une application, vous devriez pouvoir calculer `from` avec un code beaucoup moins compliqué.
+
+## Spécifications
+
+| Spécification                                                                                                            | État                         | Commentaires                                          |
+| ------------------------------------------------------------------------------------------------------------------------ | ---------------------------- | ----------------------------------------------------- |
+| {{SpecName('ES5.1', '#sec-15.4.4.15', 'Array.prototype.lastIndexOf')}}                             | {{Spec2('ES5.1')}}     | Définition initiale. Implémentée avec JavaScript 1.6. |
+| {{SpecName('ES6', '#sec-array.prototype.lastindexof', 'Array.prototype.lastIndexOf')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-array.prototype.lastindexof', 'Array.prototype.lastIndexOf')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Array.lastIndexOf")}}
+
+## Notes de compatibilité
+
+- À partir de Firefox 47 ({{geckoRelease(47)}}), cette méthode ne renverra plus `-0`. Ainsi, `[0].lastIndexOf(0, -0)` renverra toujours `+0` (cf. {{bug(1242043)}}).
+
+## Voir aussi
+
+- {{jsxref("Array.prototype.indexOf()")}}
+- {{jsxref("TypedArray.prototype.lastIndexOf()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/array/length/index.md b/files/fr/web/javascript/reference/global_objects/array/length/index.md
index 4e05fe8940..caa912f99a 100644
--- a/files/fr/web/javascript/reference/global_objects/array/length/index.md
+++ b/files/fr/web/javascript/reference/global_objects/array/length/index.md
@@ -9,19 +9,18 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Array/length
 original_slug: Web/JavaScript/Reference/Objets_globaux/Array/length
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La propriété <code><strong>length</strong></code> (longueur) est un entier non-signé de 32 bits qui indique le nombre d'éléments présents dans le tableau. Elle est toujours supérieure au plus grand indice du tableau.</p>
+La propriété **`length`** (longueur) est un entier non-signé de 32 bits qui indique le nombre d'éléments présents dans le tableau. Elle est toujours supérieure au plus grand indice du tableau.
 
-<div>{{EmbedInteractiveExample("pages/js/array-length.html")}}</div>
+{{EmbedInteractiveExample("pages/js/array-length.html")}}
 
+## Description
 
+La valeur de la propriété `length` est un entier de signe positif dont la valeur est inférieure à 2 à la puissance 32 (2^32).
 
-<h2 id="Description">Description</h2>
-
-<p>La valeur de la propriété <code>length</code> est un entier de signe positif dont la valeur est inférieure à 2 à la puissance 32 (2^32).</p>
-
-<pre class="brush: js notranslate">var tableauA = new Array(4294967296); // 2 à la puissance 32 = 4294967296
+```js
+var tableauA = new Array(4294967296); // 2 à la puissance 32 = 4294967296
 var tableauC = new Array(-100) // une valeur négative
 
 console.log(tableauA.length); // RangeError: Invalid array length
@@ -30,91 +29,71 @@ console.log(tableauC.length); // RangeError: Invalid array length
 var tableauB = [];
 tableauB.length = Math.pow(2,32)-1; // On déclare une longueur inférieure à 2 puissance 32
 console.log(tableauB.length); // 4294967295
-</pre>
+```
 
-<p>Vous pouvez modifier la propriété <code>length</code> d'un tableau à loisir pour le tronquer. Quand vous étendez un tableau en modifiant la valeur de sa propriété <code>length</code>, le nombre d'éléments réellement présents dans ce tableau n'augmente pas : par exemple, si vous affectez la valeur 3 à la propriété <code>length</code> d'un tableau alors qu'elle vaut 2, le tableau contiendra toujours seulement 2 éléments. La troisième « case » ne sera pas itérable. De ce fait, la propriété <code>length</code> d'un tableau ne renseigne en rien sur le nombre de valeurs définies dans le tableau. Voir aussi <a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Array#Relation_entre_length_et_les_propri.C3.A9t.C3.A9s_num.C3.A9riques">la relation entre longueur et propriétés numériques</a>.</p>
+Vous pouvez modifier la propriété `length` d'un tableau à loisir pour le tronquer. Quand vous étendez un tableau en modifiant la valeur de sa propriété `length`, le nombre d'éléments réellement présents dans ce tableau n'augmente pas : par exemple, si vous affectez la valeur 3 à la propriété `length` d'un tableau alors qu'elle vaut 2, le tableau contiendra toujours seulement 2 éléments. La troisième « case » ne sera pas itérable. De ce fait, la propriété `length` d'un tableau ne renseigne en rien sur le nombre de valeurs définies dans le tableau. Voir aussi [la relation entre longueur et propriétés numériques](/fr/docs/Web/JavaScript/Reference/Objets_globaux/Array#Relation_entre_length_et_les_propri.C3.A9t.C3.A9s_num.C3.A9riques).
 
-<pre class="brush: js notranslate">const arr = [1, 2, 3];
+```js
+const arr = [1, 2, 3];
 console.table(arr);
 // [1, 2]
 
 arr.length = 5; // On définit une longueur à 5
 console.table(arr);
-// [1, 2, &lt;3 éléments vides&gt;]
+// [1, 2, <3 éléments vides>]
 
-arr.forEach(element =&gt; console.log(element));
+arr.forEach(element => console.log(element));
 // 1
 // 2
-</pre>
+```
 
-<p>{{js_property_attributes(1,0,0)}}</p>
+{{js_property_attributes(1,0,0)}}
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Renvoyer_la_longueur_dun_tableau">Renvoyer la longueur d'un tableau</h3>
+### Renvoyer la longueur d'un tableau
 
-<pre class="brush: js notranslate">var items = ["chaise", "bureau", "table", "sac"];
+```js
+var items = ["chaise", "bureau", "table", "sac"];
 items.length; // 4
-</pre>
+```
 
-<h3 id="Parcourir_un_tableau">Parcourir un tableau</h3>
+### Parcourir un tableau
 
-<p>Dans l'exemple suivant, on itère sur le tableau <code>nombres</code> en utilisant la propriété <code>length</code> afin de connaître son nombre d'élément. La valeur de chaque élément est ensuite multipliée par deux :</p>
+Dans l'exemple suivant, on itère sur le tableau `nombres` en utilisant la propriété `length` afin de connaître son nombre d'élément. La valeur de chaque élément est ensuite multipliée par deux :
 
-<pre class="brush:js notranslate">var nombres = [1,2,3,4,5];
+```js
+var nombres = [1,2,3,4,5];
 
-for (var i = 0; i &lt; nombres.length; i++) {
+for (var i = 0; i < nombres.length; i++) {
   nombres[i] *= 2;
 }
 // nombres vaut maintenant [2,4,6,8,10];
-</pre>
+```
 
-<h3 id="Tronquer_un_tableau">Tronquer un tableau</h3>
+### Tronquer un tableau
 
-<p>L'exemple suivant raccourcit le tableau <code>etatsUS</code> à 50 si sa longueur actuelle est supérieure à 50.</p>
+L'exemple suivant raccourcit le tableau `etatsUS` à 50 si sa longueur actuelle est supérieure à 50.
 
-<pre class="brush:js notranslate">if (etatsUS.length &gt; 50) {
+```js
+if (etatsUS.length > 50) {
    etatsUS.length = 50;
-}</pre>
-
-<h2 id="Specifications">Specifications</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.4.5.2', 'Array.length')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-properties-of-array-instances-length', 'Array.length')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-properties-of-array-instances-length', 'Array.length')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Array.length")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Array")}}</li>
-</ul>
+}
+```
+
+## Specifications
+
+| Spécification                                                                                                    | État                         | Commentaires         |
+| ---------------------------------------------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ES1')}}                                                                                         | {{Spec2('ES1')}}         | Définition initiale. |
+| {{SpecName('ES5.1', '#sec-15.4.5.2', 'Array.length')}}                                         | {{Spec2('ES5.1')}}     |                      |
+| {{SpecName('ES6', '#sec-properties-of-array-instances-length', 'Array.length')}}     | {{Spec2('ES6')}}         |                      |
+| {{SpecName('ESDraft', '#sec-properties-of-array-instances-length', 'Array.length')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Array.length")}}
+
+## Voir aussi
+
+- {{jsxref("Array")}}
diff --git a/files/fr/web/javascript/reference/global_objects/array/map/index.md b/files/fr/web/javascript/reference/global_objects/array/map/index.md
index 48a9be07f5..b5a56e9db7 100644
--- a/files/fr/web/javascript/reference/global_objects/array/map/index.md
+++ b/files/fr/web/javascript/reference/global_objects/array/map/index.md
@@ -12,84 +12,83 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Array/map
 original_slug: Web/JavaScript/Reference/Objets_globaux/Array/map
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>map()</strong></code> crée un nouveau tableau avec les résultats de l'appel d'une fonction fournie sur chaque élément du tableau appelant.</p>
+La méthode **`map()`** crée un nouveau tableau avec les résultats de l'appel d'une fonction fournie sur chaque élément du tableau appelant.
 
-<div>{{EmbedInteractiveExample("pages/js/array-map.html")}}</div>
+{{EmbedInteractiveExample("pages/js/array-map.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>var nouveauTableau = arr</var>.map(<var>callback</var> [, <var>thisArg</var>])</pre>
+    var nouveauTableau = arr.map(callback [, thisArg])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>callback</code></dt>
- <dd>La fonction qui est utilisée pour créer un élément du nouveau tableau. Elle utilise trois arguments :
- <dl>
-  <dt><code>valeurCourante</code></dt>
-  <dd>La valeur de l'élément du tableau à traiter.</dd>
-  <dt><code>index</code>{{optional_inline}}</dt>
-  <dd>L'index de l'élément qui est traité par la fonction.</dd>
-  <dt><code>tableau</code>{{optional_inline}}</dt>
-  <dd>Le tableau sur lequel on a appelé la méthode <code>map</code>.</dd>
- </dl>
- </dd>
- <dt><code>thisArg</code> {{optional_inline}}</dt>
- <dd>La valeur à utiliser pour <code>this</code> lors de l'exécution de <code>callback</code>. La valeur par défaut est l'objet global de l'environnement (<code>Window</code> pour un navigateur).</dd>
-</dl>
+- `callback`
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+  - : La fonction qui est utilisée pour créer un élément du nouveau tableau. Elle utilise trois arguments :
 
-<p>Un nouveau tableau composé des images de la fonction de rappel.</p>
+    - `valeurCourante`
+      - : La valeur de l'élément du tableau à traiter.
+    - `index`{{optional_inline}}
+      - : L'index de l'élément qui est traité par la fonction.
+    - `tableau`{{optional_inline}}
+      - : Le tableau sur lequel on a appelé la méthode `map`.
 
-<h2 id="Description">Description</h2>
+- `thisArg` {{optional_inline}}
+  - : La valeur à utiliser pour `this` lors de l'exécution de `callback`. La valeur par défaut est l'objet global de l'environnement (`Window` pour un navigateur).
 
-<p>Lorsqu'on utilise <code>map</code>, la fonction <code>callback</code> fournie en argument est exécutée une fois pour chacun des éléments du tableau, dans l'ordre du tableau. Chaque résultat de l'opération sur un élément sera un élément du nouveau tableau. La fonction <code>callback</code> est appelée uniquement pour les indices du tableau pour lesquels il y a des valeurs affectées (y compris si cette valeur est {{jsxref("undefined")}}). Si les valeurs ont été supprimées ou qu'elles n'ont jamais été initialisées, la fonction ne sera pas appelée.</p>
+### Valeur de retour
 
-<p><code>callback</code> est appelée avec trois arguments : la valeur de l'élément du tableau, l'index de cet élément et l'objet {{jsxref("Array")}} qui est parcouru.</p>
+Un nouveau tableau composé des images de la fonction de rappel.
 
-<div class="warning">
-<p><strong>Attention :</strong> <code>map()</code> construit un nouveau tableau. Si on utilise cette méthode sans utiliser le résultat, mieux vaudra utiliser <code><a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Array/forEach">forEach</a></code> ou <code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/for...of">for...of</a></code>.  Pour mieux décider si <code>map()</code>est adéquat, regardez si vous utilisez la valeur de retour et/ou si vous renvoyez une valeur avec la fonction <code>callback</code> : si ce n'est pas le cas, il ne faut pas utiliser <code>map()</code>.</p>
-</div>
+## Description
 
-<p>Si le paramètre <code>thisArg</code> est utilisé, il sera utilisé en tant que <code>this</code> par la fonction <code>callback</code> lorsqu'elle sera appelée. S'il n'est pas utilisé, ce sera la valeur {{jsxref("undefined")}} qui sera utilisée pour définir <code>this</code>. La valeur <code>this</code> finalement prise en compte par la fonction <code>callback</code> est définie <a href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/L_op%C3%A9rateur_this">selon les règles usuelles qui déterminent la valeur <code>this</code> observée par une fonction</a>.</p>
+Lorsqu'on utilise `map`, la fonction `callback` fournie en argument est exécutée une fois pour chacun des éléments du tableau, dans l'ordre du tableau. Chaque résultat de l'opération sur un élément sera un élément du nouveau tableau. La fonction `callback` est appelée uniquement pour les indices du tableau pour lesquels il y a des valeurs affectées (y compris si cette valeur est {{jsxref("undefined")}}). Si les valeurs ont été supprimées ou qu'elles n'ont jamais été initialisées, la fonction ne sera pas appelée.
 
-<p><code>map</code> ne modifie pas le tableau sur lequel elle est appelée (bien que la fonction <code>callback</code>, si elle est appelée, puisse modifier le tableau).</p>
+`callback` est appelée avec trois arguments : la valeur de l'élément du tableau, l'index de cet élément et l'objet {{jsxref("Array")}} qui est parcouru.
 
-<p>La liste des éléments à traiter lors de l'opération <code>map</code> est définie avant le premier appel à <code>callback</code>. Les éléments qui sont ajoutés au tableau après que l'appel à <code>map</code> ait été initié ne seront pas traités par la fonction <code>callback</code>. Si des éléments ont été modifiés, la valeur utilisée par la fonction <code>callback</code> sera celle au moment où <code>map</code> est utilisée. Les éléments qui sont supprimés ne sont pas traités. De la même façon, si on applique <code>map</code> sur un tableau dont certains éléments sont indéfinis, le résultat possèdera également les mêmes éléments indéfinis.</p>
+> **Attention :** `map()` construit un nouveau tableau. Si on utilise cette méthode sans utiliser le résultat, mieux vaudra utiliser [`forEach`](/fr/docs/Web/JavaScript/Reference/Objets_globaux/Array/forEach) ou [`for...of`](/fr/docs/Web/JavaScript/Reference/Instructions/for...of).  Pour mieux décider si `map()`est adéquat, regardez si vous utilisez la valeur de retour et/ou si vous renvoyez une valeur avec la fonction `callback` : si ce n'est pas le cas, il ne faut pas utiliser `map()`.
 
-<h2 id="Exemples">Exemples</h2>
+Si le paramètre `thisArg` est utilisé, il sera utilisé en tant que `this` par la fonction `callback` lorsqu'elle sera appelée. S'il n'est pas utilisé, ce sera la valeur {{jsxref("undefined")}} qui sera utilisée pour définir `this`. La valeur `this` finalement prise en compte par la fonction `callback` est définie [selon les règles usuelles qui déterminent la valeur `this` observée par une fonction](/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/L_op%C3%A9rateur_this).
 
-<h3 id="Créer_un_tableau_des_racines_carrées_d'un_tableau_de_nombre">Créer un tableau des racines carrées d'un tableau de nombre</h3>
+`map` ne modifie pas le tableau sur lequel elle est appelée (bien que la fonction `callback`, si elle est appelée, puisse modifier le tableau).
 
-<p>Dans l'exemple suivant, on crée un tableau composé des racines carrées des éléments d'un premier tableau :</p>
+La liste des éléments à traiter lors de l'opération `map` est définie avant le premier appel à `callback`. Les éléments qui sont ajoutés au tableau après que l'appel à `map` ait été initié ne seront pas traités par la fonction `callback`. Si des éléments ont été modifiés, la valeur utilisée par la fonction `callback` sera celle au moment où `map` est utilisée. Les éléments qui sont supprimés ne sont pas traités. De la même façon, si on applique `map` sur un tableau dont certains éléments sont indéfinis, le résultat possèdera également les mêmes éléments indéfinis.
 
-<pre class="brush: js">var nombres = [1, 4, 9];
+## Exemples
+
+### Créer un tableau des racines carrées d'un tableau de nombre
+
+Dans l'exemple suivant, on crée un tableau composé des racines carrées des éléments d'un premier tableau :
+
+```js
+var nombres = [1, 4, 9];
 var racines = nombres.map(Math.sqrt);
 // racines vaut désormais [1, 2, 3]
 // nombres vaut toujours [1, 4, 9]
-</pre>
+```
 
-<h3 id="Créer_un_tableau_de_nombres_avec_une_fonction_à_un_argument">Créer un tableau de nombres avec une fonction à un argument</h3>
+### Créer un tableau de nombres avec une fonction à un argument
 
-<p>Ici, on illustre le fonctionnement de <code>map</code> avec une fonction à un argument. Cet argument sera automatiquement remplacé par chaque élément du tableau au fur et à mesure que <code>map</code> parcourt le tableau :</p>
+Ici, on illustre le fonctionnement de `map` avec une fonction à un argument. Cet argument sera automatiquement remplacé par chaque élément du tableau au fur et à mesure que `map` parcourt le tableau :
 
-<pre class="brush: js">var nombres = [1, 4, 9];
+```js
+var nombres = [1, 4, 9];
 var doubles = nombres.map(function(num) {
   return num * 2;
 });
 // doubles vaut désormais [2, 8, 18].
 // nombres vaut toujours [1, 4, 9]
-</pre>
+```
 
-<h3 id="Utiliser_map_pour_changer_le_format_d'objets_dans_un_tableau">Utiliser <code>map</code> pour changer le format d'objets dans un tableau</h3>
+### Utiliser `map` pour changer le format d'objets dans un tableau
 
-<p>Dans le code qui suit, on utilise un tableau d'objets pour créer un autre tableau contenant de nouveaux objets dans un autre format :</p>
+Dans le code qui suit, on utilise un tableau d'objets pour créer un autre tableau contenant de nouveaux objets dans un autre format :
 
-<pre class="brush: js">var tableauOrig = [{clé:1, valeur:10}, {clé:2, valeur:20}, {clé:3, valeur: 30}];
-var tableauFormaté = tableauOrig.map(obj =&gt; {
+```js
+var tableauOrig = [{clé:1, valeur:10}, {clé:2, valeur:20}, {clé:3, valeur: 30}];
+var tableauFormaté = tableauOrig.map(obj => {
   var rObj = {};
   rObj[obj.clé] = obj.valeur;
   return rObj;
@@ -100,36 +99,39 @@ var tableauFormaté = tableauOrig.map(obj =&gt; {
 //  {clé:2, valeur:20},
 //  {clé:3, valeur: 30}
 // ]
-</pre>
+```
 
-<h3 id="Utiliser_map_de_façon_générique">Utiliser <code>map</code> de façon générique</h3>
+### Utiliser `map` de façon générique
 
-<p>Dans cet exemple, on voit comment utiliser la fonction <code>map</code> sur une chaîne de caractères pour obtenir un tableau contenant les codes ASCII des valeurs encodées :</p>
+Dans cet exemple, on voit comment utiliser la fonction `map` sur une chaîne de caractères pour obtenir un tableau contenant les codes ASCII des valeurs encodées :
 
-<pre class="brush: js">var map = Array.prototype.map;
+```js
+var map = Array.prototype.map;
 var a = map.call('Hello World', function(x) { return x.charCodeAt(0); });
 // a vaut désormais [72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100]
-</pre>
+```
 
-<h3 id="Utiliser_map_avec_querySelectorAll">Utiliser <code>map</code> avec <code>querySelectorAll</code></h3>
+### Utiliser `map` avec `querySelectorAll`
 
-<p>Dans cet exemple, on illustre comment utiliser la méthode map de façon générique, sur un tableau d'objets collectés grâce à <code>querySelectorAll</code> :</p>
+Dans cet exemple, on illustre comment utiliser la méthode map de façon générique, sur un tableau d'objets collectés grâce à `querySelectorAll` :
 
-<pre class="brush: js">var elems = document.querySelectorAll('select option:checked');
+```js
+var elems = document.querySelectorAll('select option:checked');
 var values = Array.prototype.map.call(elems, function(obj) {
   return obj.value;
 });
-</pre>
+```
 
-<p>On aurait également pu utiliser la méthode {{jsxref("Array.from()")}} qui permet de produire un tableau à partir d'un objet itérable.</p>
+On aurait également pu utiliser la méthode {{jsxref("Array.from()")}} qui permet de produire un tableau à partir d'un objet itérable.
 
-<h3 id="Un_résultat_inattendu">Un résultat inattendu</h3>
+### Un résultat inattendu
 
-<p><a href="https://www.wirfs-brock.com/allen/posts/166">Exemple inspiré par ce billet</a> (en anglais)</p>
+[Exemple inspiré par ce billet](https://www.wirfs-brock.com/allen/posts/166) (en anglais)
 
-<p>Il est fréquent d'utiliser la fonction <code>callback</code> avec un seul argument (l'élément en cours). Certaines fonctions natives sont également souvent appelées avec un unique argument même si elles peuvent prendre en compte plusieurs arguments. En combinant ces deux « habitudes », on peut obtenir certains résultats inattendus :</p>
+Il est fréquent d'utiliser la fonction `callback` avec un seul argument (l'élément en cours). Certaines fonctions natives sont également souvent appelées avec un unique argument même si elles peuvent prendre en compte plusieurs arguments. En combinant ces deux « habitudes », on peut obtenir certains résultats inattendus :
 
-<pre class="brush: js">// Si on utilise :
+```js
+// Si on utilise :
 ['1', '2', '3'].map(parseInt);
 // On s'attend à obtenir [1, 2, 3]
 // Le résultat qu'on obtient est en fait [1, NaN, NaN]
@@ -161,50 +163,29 @@ function returnInt(element) {
 
 // Formulation équivalente plus concise avec
 // une fonction fléchée
-['1', '2', '3'].map( str =&gt; parseInt(str));
+['1', '2', '3'].map( str => parseInt(str));
 
 // Une autre méthode, plus simple
 ['1', '2', '3'].map(Number); // [1, 2, 3]
 // à la différence de parseInt, cela fonctionnera pour les
 // nombres décimaux ou en notation exponentielle
 ['1.1', '2.2e2', '3e300'].map(Number); // [1.1, 220, 3e+300]
-</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.4.4.19', 'Array.prototype.map')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td>Définition initiale. Implémentée avec JavaScript 1.6.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-array.prototype.map', 'Array.prototype.map')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-array.prototype.map', 'Array.prototype.map')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Array.map")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Array.prototype.forEach()")}}</li>
- <li>L'objet {{jsxref("Map")}}</li>
- <li>{{jsxref("Array.from()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                        | État                         | Commentaires                                          |
+| ---------------------------------------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- |
+| {{SpecName('ES5.1', '#sec-15.4.4.19', 'Array.prototype.map')}}                 | {{Spec2('ES5.1')}}     | Définition initiale. Implémentée avec JavaScript 1.6. |
+| {{SpecName('ES6', '#sec-array.prototype.map', 'Array.prototype.map')}}         | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-array.prototype.map', 'Array.prototype.map')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Array.map")}}
+
+## Voir aussi
+
+- {{jsxref("Array.prototype.forEach()")}}
+- L'objet {{jsxref("Map")}}
+- {{jsxref("Array.from()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/array/of/index.md b/files/fr/web/javascript/reference/global_objects/array/of/index.md
index 68508d936f..cbc2b0c156 100644
--- a/files/fr/web/javascript/reference/global_objects/array/of/index.md
+++ b/files/fr/web/javascript/reference/global_objects/array/of/index.md
@@ -10,93 +10,78 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Array/of
 original_slug: Web/JavaScript/Reference/Objets_globaux/Array/of
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La methode <code><strong>Array.of()</strong></code> permet de créer une nouvelle instance d'objet <code>Array</code> à partir d'un nombre variable d'arguments, quels que soient leur nombre ou leur type.</p>
+La methode **`Array.of()`** permet de créer une nouvelle instance d'objet `Array` à partir d'un nombre variable d'arguments, quels que soient leur nombre ou leur type.
 
-<p>La différence entre <code><strong>Array.of()</strong></code> et le constructeur <code><strong>Array</strong></code> se situe dans la gestion de d'arguments entiers : <strong><code>Array.of(7)</code></strong> crée un tableau avec un seul élément, 7, tandis que <strong><code>Array(7)</code></strong> produit un tableau avec 7 éléments vides (à ne pas confondre avec des éléments qui auraient explicitement la valeur <code><a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/undefined">undefined</a></code>).</p>
+La différence entre **`Array.of()`** et le constructeur **`Array`** se situe dans la gestion de d'arguments entiers : **`Array.of(7)`** crée un tableau avec un seul élément, 7, tandis que **`Array(7)`** produit un tableau avec 7 éléments vides (à ne pas confondre avec des éléments qui auraient explicitement la valeur [`undefined`](/fr/docs/Web/JavaScript/Reference/Objets_globaux/undefined)).
 
-<pre class="brush: js">Array.of(7);       // [7]
+```js
+Array.of(7);       // [7]
 Array.of(1, 2, 3); // [1, 2, 3]
 
 Array(7);          // un tableau avec 7 emplacements vides
 Array(1, 2, 3);    // [1, 2, 3]
-</pre>
+```
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">Array.of(<em>element0[, element1[, ...[, elementN]]]</em>)
-</pre>
+    Array.of(element0[, element1[, ...[, elementN]]])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><em><code>element0</code>, <code>element1</code>, ..., <code>elementN</code></em></dt>
- <dd>Les éléments avec lesquels on souhaite construire le nouveau tableau.</dd>
-</dl>
+- _`element0`, `element1`, ..., `elementN`_
+  - : Les éléments avec lesquels on souhaite construire le nouveau tableau.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une nouvelle instance de {{jsxref("Array")}}.</p>
+Une nouvelle instance de {{jsxref("Array")}}.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Cette fonction fait partie du standard ECMAScript 2015. Pour plus d'informations, voir les pages sur <a href="https://gist.github.com/rwaldron/1074126">la proposition pour <code>Array.of</code> et <code>Array.from</code></a> ainsi que la page sur le <a href="https://gist.github.com/rwaldron/3186576">fragment d'émulation pour <code>Array.of</code></a>.</p>
+Cette fonction fait partie du standard ECMAScript 2015. Pour plus d'informations, voir les pages sur [la proposition pour `Array.of` et `Array.from`](https://gist.github.com/rwaldron/1074126) ainsi que la page sur le [fragment d'émulation pour `Array.of`](https://gist.github.com/rwaldron/3186576).
 
-<pre class="brush: js">Array.of(7);       // [7]
+```js
+Array.of(7);       // [7]
 Array.of(1, 2, 3); // [1, 2, 3]
 
 Array(7);          // [ , , , , , , ]
 Array(1, 2, 3);    // [1, 2, 3]
-</pre>
+```
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<pre class="brush: js">Array.of(1);         // [1]
+```js
+Array.of(1);         // [1]
 Array.of(1, 2, 3);   // [1, 2, 3]
 Array.of(undefined); // [undefined]
-</pre>
+```
 
-<h2 id="Prothèse_d'émulation_(polyfill)">Prothèse d'émulation (<em>polyfill</em>)</h2>
+## Prothèse d'émulation (_polyfill_)
 
-<p>Exécuter ce code avant tout autre code permettra de créer la méthode <strong><code>Array.of()</code></strong> si elle n'est pas prise en charge nativement.</p>
+Exécuter ce code avant tout autre code permettra de créer la méthode **`Array.of()`** si elle n'est pas prise en charge nativement.
 
-<pre class="brush: js">if (!Array.of) {
+```js
+if (!Array.of) {
   Array.of = function() {
     return Array.prototype.slice.call(arguments);
   };
-}</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-array.of', 'Array.of')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-array.of', 'Array.of')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Array.of")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Array", "Array")}}</li>
- <li>{{jsxref("Array/from", "Array.from")}}</li>
- <li>{{jsxref("TypedArray.of()")}}</li>
-</ul>
+}
+```
+
+## Spécifications
+
+| Spécification                                                        | État                         | Commentaires         |
+| -------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ES2015', '#sec-array.of', 'Array.of')}} | {{Spec2('ES2015')}}     | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-array.of', 'Array.of')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Array.of")}}
+
+## Voir aussi
+
+- {{jsxref("Array", "Array")}}
+- {{jsxref("Array/from", "Array.from")}}
+- {{jsxref("TypedArray.of()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/array/pop/index.md b/files/fr/web/javascript/reference/global_objects/array/pop/index.md
index 6a5345dd88..7b9862f6fb 100644
--- a/files/fr/web/javascript/reference/global_objects/array/pop/index.md
+++ b/files/fr/web/javascript/reference/global_objects/array/pop/index.md
@@ -10,97 +10,73 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Array/pop
 original_slug: Web/JavaScript/Reference/Objets_globaux/Array/pop
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>pop()</strong></code> supprime le <strong>dernier</strong> élément d'un tableau et retourne cet élément. Cette méthode modifie la longueur du tableau.</p>
+La méthode **`pop()`** supprime le **dernier** élément d'un tableau et retourne cet élément. Cette méthode modifie la longueur du tableau.
 
-<div>{{EmbedInteractiveExample("pages/js/array-pop.html")}}</div>
+{{EmbedInteractiveExample("pages/js/array-pop.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>arr</var>.pop()</pre>
+    arr.pop()
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>L'élément qui a été retiré du tableau. Si le tableau est vide, elle renvoie {{jsxref("undefined")}}.</p>
+L'élément qui a été retiré du tableau. Si le tableau est vide, elle renvoie {{jsxref("undefined")}}.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La méthode <code>pop()</code> supprime le dernier élément d'un tableau et retourne cette valeur.</p>
+La méthode `pop()` supprime le dernier élément d'un tableau et retourne cette valeur.
 
-<p><code>pop()</code> est volontairement générique ; cette méthode peut être {{jsxref("Function.call", "appelée")}} ou {{jsxref("Function.apply", "appliquée")}} pour des objets ressemblant à des tableaux. Les objets qui ne contiennent pas une propriété <code>length</code> reflétant la fin d'une série de propriétés consécutives numérotées peuvent se comporter bizarrement.</p>
+`pop()` est volontairement générique ; cette méthode peut être {{jsxref("Function.call", "appelée")}} ou {{jsxref("Function.apply", "appliquée")}} pour des objets ressemblant à des tableaux. Les objets qui ne contiennent pas une propriété `length` reflétant la fin d'une série de propriétés consécutives numérotées peuvent se comporter bizarrement.
 
-<p>Si vous appelez <code>pop()</code> sur un tableau vide, il renverra la valeur {{jsxref("undefined")}}.</p>
+Si vous appelez `pop()` sur un tableau vide, il renverra la valeur {{jsxref("undefined")}}.
 
-<div class="blockIndicator note">
-<p><strong>Note :</strong> La méthode {{jsxref("Array.prototype.shift()")}} possède un comportement analogue mais retire le <em>premier</em> élément du tableau.</p>
-</div>
+> **Note :** La méthode {{jsxref("Array.prototype.shift()")}} possède un comportement analogue mais retire le _premier_ élément du tableau.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Supprimer_le_dernier_élément_d'un_tableau">Supprimer le dernier élément d'un tableau</h3>
+### Supprimer le dernier élément d'un tableau
 
-<p>Le code suivant crée le tableau <code>mesPoissons</code> qui contient quatre éléments puis supprime le dernier élément.</p>
+Le code suivant crée le tableau `mesPoissons` qui contient quatre éléments puis supprime le dernier élément.
 
-<pre class="brush:js">var mesPoissons = ["angel", "clown", "mandarin", "sturgeon"];
+```js
+var mesPoissons = ["angel", "clown", "mandarin", "sturgeon"];
 
 var popped = mesPoissons.pop();
 
 console.table(mesPoissons); // angel, clown, madarin
-console.log(popped);        // sturgeon</pre>
+console.log(popped);        // sturgeon
+```
 
-<h3 id="Utiliser_apply()_ou_call()_sur_les_objets_semblables_aux_tableaux">Utiliser <code>apply()</code> ou <code>call()</code> sur les objets semblables aux tableaux</h3>
+### Utiliser `apply()` ou `call()` sur les objets semblables aux tableaux
 
-<p>Le code suivant crée un objet <code>mesPoissons</code> semblable à un tableau, qui contient 4 propriétés indexées avec des nombres et une propriété <code>length</code>. On utilise la méthode {{jsxref("Function.call()")}} pour invoquer <code>pop()</code> sur cet objet :</p>
+Le code suivant crée un objet `mesPoissons` semblable à un tableau, qui contient 4 propriétés indexées avec des nombres et une propriété `length`. On utilise la méthode {{jsxref("Function.call()")}} pour invoquer `pop()` sur cet objet :
 
-<pre class="brush: js">var mesPoissons = {0: 'angel', 1: 'clown', 2: 'mandarin', 3: 'sturgeon', length: 4};
+```js
+var mesPoissons = {0: 'angel', 1: 'clown', 2: 'mandarin', 3: 'sturgeon', length: 4};
 
 var popped = Array.prototype.pop.call(mesPoissons); // on aurait pu utiliser apply()
 console.log(mesPoissons); // {0: 'angel', 1: 'clown', 2: 'mandarin', length: 3}
 console.log(popped);      // 'sturgeon'
-</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.4.4.6', 'Array.prototype.pop')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-array.prototype.pop', 'Array.prototype.pop')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-array.prototype.pop', 'Array.prototype.pop')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Array.pop")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Array.prototype.push()")}}</li>
- <li>{{jsxref("Array.prototype.shift()")}}</li>
- <li>{{jsxref("Array.prototype.unshift()")}}</li>
- <li>{{jsxref("Array.prototype.splice()")}}</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.4.4.6', 'Array.prototype.pop')}}                     | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-array.prototype.pop', 'Array.prototype.pop')}}         | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-array.prototype.pop', 'Array.prototype.pop')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Array.pop")}}
+
+## Voir aussi
+
+- {{jsxref("Array.prototype.push()")}}
+- {{jsxref("Array.prototype.shift()")}}
+- {{jsxref("Array.prototype.unshift()")}}
+- {{jsxref("Array.prototype.splice()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/array/push/index.md b/files/fr/web/javascript/reference/global_objects/array/push/index.md
index c7f18ce86b..0472582660 100644
--- a/files/fr/web/javascript/reference/global_objects/array/push/index.md
+++ b/files/fr/web/javascript/reference/global_objects/array/push/index.md
@@ -10,72 +10,72 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Array/push
 original_slug: Web/JavaScript/Reference/Objets_globaux/Array/push
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>push()</strong></code> ajoute un ou plusieurs éléments à la fin d'un tableau et retourne la nouvelle taille du tableau.</p>
+La méthode **`push()`** ajoute un ou plusieurs éléments à la fin d'un tableau et retourne la nouvelle taille du tableau.
 
-<div>{{EmbedInteractiveExample("pages/js/array-push.html")}}</div>
+{{EmbedInteractiveExample("pages/js/array-push.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>arr</var>.push(<var>élément1</var>, ..., <var>élémentN</var>)</pre>
+    arr.push(élément1, ..., élémentN)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>élément1, ...,élémentN</code></dt>
- <dd>Les éléments à ajouter à la fin du tableau.</dd>
-</dl>
+- `élément1, ...,élémentN`
+  - : Les éléments à ajouter à la fin du tableau.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>La nouvelle valeur de la propriété {{jsxref("Array.length", "length")}} de l'objet sur lequel la méthode a été appelée.</p>
+La nouvelle valeur de la propriété {{jsxref("Array.length", "length")}} de l'objet sur lequel la méthode a été appelée.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La méthode <code>push</code> permet d'ajouter des valeurs à un tableau.</p>
+La méthode `push` permet d'ajouter des valeurs à un tableau.
 
-<p><code>push</code> est une méthode générique. Cette méthode peut ainsi être utilisée avec les méthodes {{jsxref("Function.call()")}} ou {{jsxref("Function.apply()")}} sur des objets similaires aux tableaux.</p>
+`push` est une méthode générique. Cette méthode peut ainsi être utilisée avec les méthodes {{jsxref("Function.call()")}} ou {{jsxref("Function.apply()")}} sur des objets similaires aux tableaux.
 
-<p>La méthode <code>push</code> se base sur la propriété <code>length</code> pour déterminer à partir de quel index les valeurs données doivent être insérées. Si la propriété <code>length</code> ne peut pas être convertie en nombre, l'index utilisé est 0. Si la propriété <code>length</code> n'est pas définie, elle est alors créée.</p>
+La méthode `push` se base sur la propriété `length` pour déterminer à partir de quel index les valeurs données doivent être insérées. Si la propriété `length` ne peut pas être convertie en nombre, l'index utilisé est 0. Si la propriété `length` n'est pas définie, elle est alors créée.
 
-<p>Bien que <code>push</code> soit une méthode générique, elle ne peut pas être utilisée sur les chaînes de caractères ou sur l'objet <code>arguments</code> car ils sont immuables.</p>
+Bien que `push` soit une méthode générique, elle ne peut pas être utilisée sur les chaînes de caractères ou sur l'objet `arguments` car ils sont immuables.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Ajouter_des_éléments_à_un_tableau">Ajouter des éléments à un tableau</h3>
+### Ajouter des éléments à un tableau
 
-<p>Le code suivant crée un tableau <code>sports</code> contenant à sa création deux éléments, auxquels sont ajoutés deux nouveaux éléments. La variable <code>total</code> contient la nouvelle taille du tableau.</p>
+Le code suivant crée un tableau `sports` contenant à sa création deux éléments, auxquels sont ajoutés deux nouveaux éléments. La variable `total` contient la nouvelle taille du tableau.
 
-<pre class="brush: js">var sports = ["plongée", "baseball"];
+```js
+var sports = ["plongée", "baseball"];
 var total = sports.push("football", "tennis");
 
 console.log(sports); // ["plongée", "baseball", "football", "tennis"]
 console.log(total);  // 4
-</pre>
+```
 
-<h3 id="Fusionner_deux_tableaux">Fusionner deux tableaux</h3>
+### Fusionner deux tableaux
 
-<p>Dans l'exemple qui suit, on utilise la méthode {{jsxref("Function.apply()")}} pour ajouter les différents éléments d'un second tableau</p>
+Dans l'exemple qui suit, on utilise la méthode {{jsxref("Function.apply()")}} pour ajouter les différents éléments d'un second tableau
 
-<pre class="brush: js">var legumes = ['navet', 'pomme de terre'];
+```js
+var legumes = ['navet', 'pomme de terre'];
 var autresLegumes = ['céleri', 'radis'];
 
 // On fusionne les deux tableaux
 // Équivalent à legumes.push('céleri', 'radis');
 Array.prototype.push.apply(legumes, autresLegumes);
 
-console.log(legumes); // ['navet', 'pomme de terre', 'céleri', 'radis']</pre>
+console.log(legumes); // ['navet', 'pomme de terre', 'céleri', 'radis']
+```
 
-<div class="note">
-<p><strong>Note :</strong> Attention à ne pas utiliser cette méthode lorsque les tableaux sont très grands car une fonction n'accepte qu'un nombre limité d'arguments. Voir {{jsxref("Function.apply","apply()")}} pour plus d'informations sur ces limites.</p>
-</div>
+> **Note :** Attention à ne pas utiliser cette méthode lorsque les tableaux sont très grands car une fonction n'accepte qu'un nombre limité d'arguments. Voir {{jsxref("Function.apply","apply()")}} pour plus d'informations sur ces limites.
 
-<h3 id="Utiliser_un_objet_comme_on_utiliserait_un_tableau">Utiliser un objet comme on utiliserait un tableau</h3>
+### Utiliser un objet comme on utiliserait un tableau
 
-<p>Comme nous l'avons vu auparavant, <code>push</code> est une méthode générique et nous pouvons donc utiliser <code>Array.prototype.push</code> sur les objets. On notera qu'il n'est pas nécessaire de stocker un ensemble d'objets. En fait, on enregistre l'ensemble dans l'objet et on utilise <code>call</code> sur <code>Array.prototype.push</code> :</p>
+Comme nous l'avons vu auparavant, `push` est une méthode générique et nous pouvons donc utiliser `Array.prototype.push` sur les objets. On notera qu'il n'est pas nécessaire de stocker un ensemble d'objets. En fait, on enregistre l'ensemble dans l'objet et on utilise `call` sur `Array.prototype.push` :
 
-<pre class="brush: js">var obj = {
+```js
+var obj = {
     length: 0,
 
     ajoutElem: function ajoutElem (elem) {
@@ -91,49 +91,24 @@ obj.ajoutElem({});
 obj.ajoutElem({});
 console.log(obj.length);
 // → 2
-</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.4.4.7', 'Array.prototype.push')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-array.prototype.push', 'Array.prototype.push')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-array.prototype.push', 'Array.prototype.push')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Array.push")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Array.prototype.pop()")}}</li>
- <li>{{jsxref("Array.prototype.shift()")}}</li>
- <li>{{jsxref("Array.prototype.unshift()")}}</li>
- <li>{{jsxref("Array.prototype.concat()")}}</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.4.4.7', 'Array.prototype.push')}}                 | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-array.prototype.push', 'Array.prototype.push')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-array.prototype.push', 'Array.prototype.push')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Array.push")}}
+
+## Voir aussi
+
+- {{jsxref("Array.prototype.pop()")}}
+- {{jsxref("Array.prototype.shift()")}}
+- {{jsxref("Array.prototype.unshift()")}}
+- {{jsxref("Array.prototype.concat()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/array/reduce/index.md b/files/fr/web/javascript/reference/global_objects/array/reduce/index.md
index 6ec6af3488..183efdeb71 100644
--- a/files/fr/web/javascript/reference/global_objects/array/reduce/index.md
+++ b/files/fr/web/javascript/reference/global_objects/array/reduce/index.md
@@ -11,225 +11,231 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Array/Reduce
 original_slug: Web/JavaScript/Reference/Objets_globaux/Array/reduce
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>reduce()</strong></code> applique une fonction qui est un « accumulateur » et qui traite chaque valeur d'une liste (de la gauche vers la droite) afin de la réduire à une seule valeur.</p>
+La méthode **`reduce()`** applique une fonction qui est un « accumulateur » et qui traite chaque valeur d'une liste (de la gauche vers la droite) afin de la réduire à une seule valeur.
 
-<div>{{EmbedInteractiveExample("pages/js/array-reduce.html")}}</div>
+{{EmbedInteractiveExample("pages/js/array-reduce.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>arr</var>.reduce(<var>callback</var>)
-<var>arr</var>.reduce(<var>callback</var>, valeurInitiale)</pre>
+    arr.reduce(callback)
+    arr.reduce(callback, valeurInitiale)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>callback</code></dt>
- <dd>La fonction à exécuter sur chaque valeur de la liste (sauf le premier si aucune <code>valeurInitiale</code> n'est fournie), elle prend quatre arguments en entrée :
- <dl>
-  <dt><code>accumulateur</code></dt>
-  <dd>La valeur précédemment retournée par le dernier appel du callback, ou <code>valeurInitiale</code>, si elle est fournie (voir ci-après) (c'est la valeur « accumulée » au fur et à mesure des appels</dd>
-  <dt><code>valeurCourante</code></dt>
-  <dd>La valeur de l'élément courant actuellement manipulé dans le tableau.</dd>
-  <dt><code>index</code>{{optional_inline}}</dt>
-  <dd>L'index de l'élément courant actuellement manipulé dans le tableau.</dd>
-  <dt><code>array</code>{{optional_inline}}</dt>
-  <dd>Le tableau sur lequel on a appelé la méthode <code>reduce()</code>.</dd>
- </dl>
- </dd>
- <dt><code>valeurInitiale</code>{{optional_inline}}</dt>
- <dd>Une valeur utilisée comme premier argument lors du premier appel de la fonction <code>callback</code>. Si aucune valeur initiale n'est fournie, le premier élément du tableau est utilisé (et la boucle de traitement ne le parcourera pas). Si on appelle <code>reduce()</code> sur un tableau vide sans fournir de valeur initiale, on aura une erreur.</dd>
-</dl>
+- `callback`
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+  - : La fonction à exécuter sur chaque valeur de la liste (sauf le premier si aucune `valeurInitiale` n'est fournie), elle prend quatre arguments en entrée :
 
-<p>La valeur obtenue grâce à la fonction de réduction.</p>
+    - `accumulateur`
+      - : La valeur précédemment retournée par le dernier appel du callback, ou `valeurInitiale`, si elle est fournie (voir ci-après) (c'est la valeur « accumulée » au fur et à mesure des appels
+    - `valeurCourante`
+      - : La valeur de l'élément courant actuellement manipulé dans le tableau.
+    - `index`{{optional_inline}}
+      - : L'index de l'élément courant actuellement manipulé dans le tableau.
+    - `array`{{optional_inline}}
+      - : Le tableau sur lequel on a appelé la méthode `reduce()`.
 
-<h2 id="Description">Description</h2>
+- `valeurInitiale`{{optional_inline}}
+  - : Une valeur utilisée comme premier argument lors du premier appel de la fonction `callback`. Si aucune valeur initiale n'est fournie, le premier élément du tableau est utilisé (et la boucle de traitement ne le parcourera pas). Si on appelle `reduce()` sur un tableau vide sans fournir de valeur initiale, on aura une erreur.
 
-<p><code>reduce()</code> exécute la fonction <code>callback</code> une fois pour chaque élément présent dans le tableau et ignore les éléments vides du tableau. La fonction <code>callback</code> utilise quatre arguments :</p>
+### Valeur de retour
 
-<ol>
- <li>L'accumulateur (la valeur retournée par le précédent appel de la fonction <code>callback</code>), ou la valeur initiale s'il sagit du premier appel ;</li>
- <li>la valeur de l'élément courant ;</li>
- <li>l'index de l'élément courant ;</li>
- <li>le tableau parcouru par la méthode.</li>
-</ol>
+La valeur obtenue grâce à la fonction de réduction.
 
-<p>La première fois que la fonction <code>callback</code> est appelée, <code>valeurInitiale</code> et <code>valeurCourante</code> peuvent correspondre à un ou deux éléments. Si <code>valeurInitiale</code> est fournie dans l'appel de <code>reduce()</code>, alors <code>accumulateur</code> sera égale à <code>valeurInitiale</code> et <code>valeurCourante</code> sera égale à la première valeur de la liste. Si <code>valeurInitiale</code> n'est pas fournie, alors <code>accumulateur</code> sera égale à la première valeur de la liste, et <code>valeurCourante</code> sera alors égale à la seconde.</p>
+## Description
 
-<p>Autrement dit, si <code>valeurInitiale</code> n'est pas fournie, <code>reduce</code> exécutera la fonction de rappel à partir de l'indice 1 et la première valeur du tableau (d'indice 0) sera utilisée pour <code>valeurInitiale</code>.</p>
+`reduce()` exécute la fonction `callback` une fois pour chaque élément présent dans le tableau et ignore les éléments vides du tableau. La fonction `callback` utilise quatre arguments :
 
-<p>En considérant le code suivant :</p>
+1.  L'accumulateur (la valeur retournée par le précédent appel de la fonction `callback`), ou la valeur initiale s'il sagit du premier appel ;
+2.  la valeur de l'élément courant ;
+3.  l'index de l'élément courant ;
+4.  le tableau parcouru par la méthode.
 
-<pre class="brush:js">[0, 1, 2, 3, 4].reduce(function(accumulateur, valeurCourante, index, array){
+La première fois que la fonction `callback` est appelée, `valeurInitiale` et `valeurCourante` peuvent correspondre à un ou deux éléments. Si `valeurInitiale` est fournie dans l'appel de `reduce()`, alors `accumulateur` sera égale à `valeurInitiale` et `valeurCourante` sera égale à la première valeur de la liste. Si `valeurInitiale` n'est pas fournie, alors `accumulateur` sera égale à la première valeur de la liste, et `valeurCourante` sera alors égale à la seconde.
+
+Autrement dit, si `valeurInitiale` n'est pas fournie, `reduce` exécutera la fonction de rappel à partir de l'indice 1 et la première valeur du tableau (d'indice 0) sera utilisée pour `valeurInitiale`.
+
+En considérant le code suivant :
+
+```js
+[0, 1, 2, 3, 4].reduce(function(accumulateur, valeurCourante, index, array){
   return accumulateur + valeurCourante;
 });
-</pre>
+```
 
-<p>La fonction <code>callback</code> sera appelée quatre fois, avec les arguments et les valeurs de retour de chaque appel suivant :</p>
+La fonction `callback` sera appelée quatre fois, avec les arguments et les valeurs de retour de chaque appel suivant :
 
 <table class="standard-table">
- <thead>
-  <tr>
-   <th scope="col"></th>
-   <th scope="col"><code>accumulateur</code></th>
-   <th scope="col"><code>valeurCourante</code></th>
-   <th scope="col"><code>index</code></th>
-   <th scope="col"><code>array</code></th>
-   <th scope="col">valeur retournée</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <th scope="row">premier appel</th>
-   <td><code>0</code></td>
-   <td><code>1</code></td>
-   <td><code>1</code></td>
-   <td><code>[0,1,2,3,4]</code></td>
-   <td><code>1</code></td>
-  </tr>
-  <tr>
-   <th scope="row">deuxième appel</th>
-   <td><code>1</code></td>
-   <td><code>2</code></td>
-   <td><code>2</code></td>
-   <td><code>[0,1,2,3,4]</code></td>
-   <td><code>3</code></td>
-  </tr>
-  <tr>
-   <th scope="row">troisième appel</th>
-   <td><code>3</code></td>
-   <td><code>3</code></td>
-   <td><code>3</code></td>
-   <td><code>[0,1,2,3,4]</code></td>
-   <td><code>6</code></td>
-  </tr>
-  <tr>
-   <th scope="row">quatrième appel</th>
-   <td><code>6</code></td>
-   <td><code>4</code></td>
-   <td><code>4</code></td>
-   <td><code>[0,1,2,3,4]</code></td>
-   <td><code>10</code></td>
-  </tr>
- </tbody>
+  <thead>
+    <tr>
+      <th scope="col"></th>
+      <th scope="col"><code>accumulateur</code></th>
+      <th scope="col"><code>valeurCourante</code></th>
+      <th scope="col"><code>index</code></th>
+      <th scope="col"><code>array</code></th>
+      <th scope="col">valeur retournée</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <th scope="row">premier appel</th>
+      <td><code>0</code></td>
+      <td><code>1</code></td>
+      <td><code>1</code></td>
+      <td><code>[0,1,2,3,4]</code></td>
+      <td><code>1</code></td>
+    </tr>
+    <tr>
+      <th scope="row">deuxième appel</th>
+      <td><code>1</code></td>
+      <td><code>2</code></td>
+      <td><code>2</code></td>
+      <td><code>[0,1,2,3,4]</code></td>
+      <td><code>3</code></td>
+    </tr>
+    <tr>
+      <th scope="row">troisième appel</th>
+      <td><code>3</code></td>
+      <td><code>3</code></td>
+      <td><code>3</code></td>
+      <td><code>[0,1,2,3,4]</code></td>
+      <td><code>6</code></td>
+    </tr>
+    <tr>
+      <th scope="row">quatrième appel</th>
+      <td><code>6</code></td>
+      <td><code>4</code></td>
+      <td><code>4</code></td>
+      <td><code>[0,1,2,3,4]</code></td>
+      <td><code>10</code></td>
+    </tr>
+  </tbody>
 </table>
 
-<p>La valeur retournée par <code>reduce()</code> sera alors celle du dernier appel de la callback (ici <code>10</code>).</p>
+La valeur retournée par `reduce()` sera alors celle du dernier appel de la callback (ici `10`).
 
-<p>Il est aussi possible d'utiliser une {{jsxref("Fonctions/Fonctions_fléchées","fonction fléchée","",1)}} au lieu d'une fonction classique. Le code suivant, par exemple, produit le même résultat que l'exemple précédent :</p>
+Il est aussi possible d'utiliser une {{jsxref("Fonctions/Fonctions_fléchées","fonction fléchée","",1)}} au lieu d'une fonction classique. Le code suivant, par exemple, produit le même résultat que l'exemple précédent :
 
-<pre class="brush: js">[0, 1, 2, 3, 4].reduce(
-  (accumulateur, valeurCourante) =&gt; accumulateur + valeurCourante;
-);</pre>
+```js
+[0, 1, 2, 3, 4].reduce(
+  (accumulateur, valeurCourante) => accumulateur + valeurCourante;
+);
+```
 
-<p>Si on fournit une valeur initiale comme second argument à l'appel de <code>reduce()</code>, le résultat sera alors le suivant :</p>
+Si on fournit une valeur initiale comme second argument à l'appel de `reduce()`, le résultat sera alors le suivant :
 
-<pre class="brush:js">[0, 1, 2, 3, 4].reduce(function(accumulateur, valeurCourante, index, array){
+```js
+[0, 1, 2, 3, 4].reduce(function(accumulateur, valeurCourante, index, array){
   return accumulateur + valeurCourante;
 }, 10);
-</pre>
+```
 
 <table class="standard-table">
- <thead>
-  <tr>
-   <th scope="col"></th>
-   <th scope="col"><code>accumulateur</code></th>
-   <th scope="col"><code>valeurCourante</code></th>
-   <th scope="col"><code>index</code></th>
-   <th scope="col"><code>array</code></th>
-   <th scope="col">valeur retournée</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <th scope="row">premier appel</th>
-   <td><code>10</code></td>
-   <td><code>0</code></td>
-   <td><code>0</code></td>
-   <td><code>[0,1,2,3,4]</code></td>
-   <td><code>10</code></td>
-  </tr>
-  <tr>
-   <th scope="row">deuxième appel</th>
-   <td><code>10</code></td>
-   <td><code>1</code></td>
-   <td><code>1</code></td>
-   <td><code>[0,1,2,3,4]</code></td>
-   <td><code>11</code></td>
-  </tr>
-  <tr>
-   <th scope="row">troisième appel</th>
-   <td><code>11</code></td>
-   <td><code>2</code></td>
-   <td><code>2</code></td>
-   <td><code>[0,1,2,3,4]</code></td>
-   <td><code>13</code></td>
-  </tr>
-  <tr>
-   <th scope="row">quatrième appel</th>
-   <td><code>13</code></td>
-   <td><code>3</code></td>
-   <td><code>3</code></td>
-   <td><code>[0,1,2,3,4]</code></td>
-   <td><code>16</code></td>
-  </tr>
-  <tr>
-   <th scope="row">cinquième appel</th>
-   <td><code>16</code></td>
-   <td><code>4</code></td>
-   <td><code>4</code></td>
-   <td><code>[0,1,2,3,4]</code></td>
-   <td><code>20</code></td>
-  </tr>
- </tbody>
+  <thead>
+    <tr>
+      <th scope="col"></th>
+      <th scope="col"><code>accumulateur</code></th>
+      <th scope="col"><code>valeurCourante</code></th>
+      <th scope="col"><code>index</code></th>
+      <th scope="col"><code>array</code></th>
+      <th scope="col">valeur retournée</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <th scope="row">premier appel</th>
+      <td><code>10</code></td>
+      <td><code>0</code></td>
+      <td><code>0</code></td>
+      <td><code>[0,1,2,3,4]</code></td>
+      <td><code>10</code></td>
+    </tr>
+    <tr>
+      <th scope="row">deuxième appel</th>
+      <td><code>10</code></td>
+      <td><code>1</code></td>
+      <td><code>1</code></td>
+      <td><code>[0,1,2,3,4]</code></td>
+      <td><code>11</code></td>
+    </tr>
+    <tr>
+      <th scope="row">troisième appel</th>
+      <td><code>11</code></td>
+      <td><code>2</code></td>
+      <td><code>2</code></td>
+      <td><code>[0,1,2,3,4]</code></td>
+      <td><code>13</code></td>
+    </tr>
+    <tr>
+      <th scope="row">quatrième appel</th>
+      <td><code>13</code></td>
+      <td><code>3</code></td>
+      <td><code>3</code></td>
+      <td><code>[0,1,2,3,4]</code></td>
+      <td><code>16</code></td>
+    </tr>
+    <tr>
+      <th scope="row">cinquième appel</th>
+      <td><code>16</code></td>
+      <td><code>4</code></td>
+      <td><code>4</code></td>
+      <td><code>[0,1,2,3,4]</code></td>
+      <td><code>20</code></td>
+    </tr>
+  </tbody>
 </table>
 
-<p>Ici, la valeur renvoyée par <code>reduce()</code> serait <code>20</code>.</p>
+Ici, la valeur renvoyée par `reduce()` serait `20`.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Additionner_toutes_les_valeurs_dun_tableau">Additionner toutes les valeurs d'un tableau</h3>
+### Additionner toutes les valeurs d'un tableau
 
-<pre class="brush:js">var total = [0, 1, 2, 3].reduce((a, b)=&gt; a + b,0);
+```js
+var total = [0, 1, 2, 3].reduce((a, b)=> a + b,0);
 // total == 6
-</pre>
+```
 
-<h3 id="Additionner_les_valeurs_dune_propriétés_pour_un_tableau_dobjets">Additionner les valeurs d'une propriétés pour un tableau d'objets</h3>
+### Additionner les valeurs d'une propriétés pour un tableau d'objets
 
-<p>Pour additionner les valeurs d'une propriété donnée des objets d'un tableau, il sera nécessaire de fournir une valeur initiale afin que tous les éléments soient parcourus :</p>
+Pour additionner les valeurs d'une propriété donnée des objets d'un tableau, il sera nécessaire de fournir une valeur initiale afin que tous les éléments soient parcourus :
 
-<pre class="brush: js">var valeurInitiale = 0;
+```js
+var valeurInitiale = 0;
 var somme = [{x: 1}, {x:2}, {x:3}].reduce(function (accumulateur, valeurCourante) {
     return accumulateur + valeurCourante.x;
 }, valeurInitiale);
 
 console.log(somme); // affiche 6 dans la console
-</pre>
+```
 
-<p>On peut également écrire une version plus concise avec les fonctions fléchées :</p>
+On peut également écrire une version plus concise avec les fonctions fléchées :
 
-<pre class="brush: js">var valeurInitiale = 0;
+```js
+var valeurInitiale = 0;
 var somme = [{x: 1}, {x:2}, {x:3}].reduce(
-    (accumulateur, valeurCourante) =&gt; accumulateur + valeurCourante.x
+    (accumulateur, valeurCourante) => accumulateur + valeurCourante.x
     , valeurInitiale
 );
 
-console.log(somme); // affiche 6 dans la console</pre>
+console.log(somme); // affiche 6 dans la console
+```
 
-<h3 id="Aplatir_une_liste_de_listes">Aplatir une liste de listes</h3>
+### Aplatir une liste de listes
 
-<pre class="brush:js">var applati = [[0, 1], [2, 3], [4, 5]].reduce(function(a, b) {
+```js
+var applati = [[0, 1], [2, 3], [4, 5]].reduce(function(a, b) {
     return a.concat(b);
 });
 // applati vaut [0, 1, 2, 3, 4, 5]
-</pre>
+```
 
-<h3 id="Utiliser_le_paramètre_valeurInitiale">Utiliser le paramètre <code>valeurInitiale</code></h3>
+### Utiliser le paramètre `valeurInitiale`
 
-<pre class="brush: js">var amis = [
+```js
+var amis = [
   { "nom": "Quentin", "livres": ["City Hall", "Harry Potter"]},
   { "nom": "Alice", "livres": ["L'Avare", "Les Fleurs du Mal"]}
 ]
@@ -239,56 +245,59 @@ var tousLivres = amis.reduce(function(prev, curr) {
 }, ["Perceval"]);
 
 // tousLivres = ["Perceval", "City Hall", "Harry Potter",
-//               "L'Avare", "Les Fleurs du Mal"]</pre>
+//               "L'Avare", "Les Fleurs du Mal"]
+```
 
-<h3 id="Exécuter_une_suite_de_promesses_stockées_dans_un_tableau">Exécuter une suite de promesses stockées dans un tableau</h3>
+### Exécuter une suite de promesses stockées dans un tableau
 
-<pre class="brush: js">/**
+```js
+/**
  * Exécuter un enchaînement de promesses à partir d'un tableau
  *
  * @param {array} arr - un tableau de promesses
  * @return {Object} un objet Promise
  */
 function runPromiseInSequense(arr) {
-  return arr.reduce((promiseChain, currentPromise) =&gt; {
-    return promiseChain.then((chainedResult) =&gt; {
+  return arr.reduce((promiseChain, currentPromise) => {
+    return promiseChain.then((chainedResult) => {
       return currentPromise(chainedResult)
-        .then((res) =&gt; res)
+        .then((res) => res)
     })
   }, Promise.resolve());
 }
 
 // promise function 1
 function p1() {
-  return new Promise((resolve, reject) =&gt; {
+  return new Promise((resolve, reject) => {
     resolve(5);
   });
 }
 
 // promise function 2
 function p2(a) {
-  return new Promise((resolve, reject) =&gt; {
+  return new Promise((resolve, reject) => {
     resolve(a * 2);
   });
 }
 
 // promise function 3
 function p3(a) {
-  return new Promise((resolve, reject) =&gt; {
+  return new Promise((resolve, reject) => {
     resolve(a * 3);
   });
 }
 
 const promiseArr = [p1, p2, p3];
 runPromiseInSequense(promiseArr)
-  .then((res) =&gt; {
+  .then((res) => {
     console.log(res);   // 30
   });
-</pre>
+```
 
-<h3 id="Regrouper_des_objets_selon_une_propriété">Regrouper des objets selon une propriété</h3>
+### Regrouper des objets selon une propriété
 
-<pre class="brush: js">var personnes = [
+```js
+var personnes = [
   { nom: "Alice", age: 21 },
   { nom: "Bob", age: 20 },
   { nom: "Charlie", age: 20 }
@@ -314,18 +323,19 @@ var personnesParAge = groupBy(personnes, "age");
 //    ],
 //    21: [{ nom: "Alice", age: 21 }]
 // }
-</pre>
+```
 
-<h3 id="Composition_de_fonctions">Composition de fonctions</h3>
+### Composition de fonctions
 
-<pre class="brush: js">// Les briques de base que nous allons composer
-const double = x =&gt; x + x;
-const triple = x =&gt; 3 * x;
-const quadruple = x =&gt; 4 * x;
+```js
+// Les briques de base que nous allons composer
+const double = x => x + x;
+const triple = x => 3 * x;
+const quadruple = x => 4 * x;
 
 // Une fonction qui permet d'appliquer une composition
-const pipe = (...functions) =&gt; input =&gt; functions.reduce(
-    (acc, fn) =&gt; fn(acc),
+const pipe = (...functions) => input => functions.reduce(
+    (acc, fn) => fn(acc),
     input
 );
 
@@ -340,19 +350,22 @@ multiply6(6); // 36
 multiply9(9); // 81
 multiply16(16); // 256
 multiply24(10); // 240
-</pre>
+```
 
-<h3 id="Retirer_les_doublons_dun_tableau">Retirer les doublons d'un tableau</h3>
+### Retirer les doublons d'un tableau
 
-<h4 id="Avec_ECMAScript_2015_ES6">Avec ECMAScript 2015 (ES6)</h4>
+#### Avec ECMAScript 2015 (ES6)
 
-<pre class="brush: js">let tableauAvecDoublons = [1, 2, 3, 1, 4, 5, 4, 6];
+```js
+let tableauAvecDoublons = [1, 2, 3, 1, 4, 5, 4, 6];
 let tableauSansDoublon = Array.from(new Set(tableauAvecDoublons));
-console.table(tableauSansDoublon); // [1, 2, 3, 4, 5, 6]</pre>
+console.table(tableauSansDoublon); // [1, 2, 3, 4, 5, 6]
+```
 
-<h4 id="Avec_reduce">Avec <code>reduce()</code></h4>
+#### Avec `reduce()`
 
-<pre class="brush: js">var tableauAvecDoublons = [1, 2, 3, 1, 4, 5, 4, 6];
+```js
+var tableauAvecDoublons = [1, 2, 3, 1, 4, 5, 4, 6];
 var tableauSansDoublon = tableauAvecDoublon.reduce(function (acc, valCourante) {
   if(acc.indexOf(valCourante) === -1) {
     acc.push(valCourante);
@@ -361,42 +374,20 @@ var tableauSansDoublon = tableauAvecDoublon.reduce(function (acc, valCourante) {
 }, []);
 
 console.log(tableauSansDoublon); // [1, 2, 3, 4, 5, 6]
-</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('ES5.1', '#sec-15.4.4.21', 'Array.prototype.reduce()')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td>Définition initiale.<br>
-    Implémenté dans JavaScript 1.8</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-array.prototype.reduce', 'Array.prototype.reduce()')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-array.prototype.reduce', 'Array.prototype.reduce()')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
+| Spécification                                                                                                | État                         | Commentaires                                        |
+| ------------------------------------------------------------------------------------------------------------ | ---------------------------- | --------------------------------------------------- |
+| {{SpecName('ES5.1', '#sec-15.4.4.21', 'Array.prototype.reduce()')}}                     | {{Spec2('ES5.1')}}     | Définition initiale. Implémenté dans JavaScript 1.8 |
+| {{SpecName('ES6', '#sec-array.prototype.reduce', 'Array.prototype.reduce()')}}     | {{Spec2('ES6')}}         |                                                     |
+| {{SpecName('ESDraft', '#sec-array.prototype.reduce', 'Array.prototype.reduce()')}} | {{Spec2('ESDraft')}} |                                                     |
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.Array.reduce")}}</p>
+{{Compat("javascript.builtins.Array.reduce")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("Array.prototype.reduceRight()")}}</li>
-</ul>
+- {{jsxref("Array.prototype.reduceRight()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/array/reduceright/index.md b/files/fr/web/javascript/reference/global_objects/array/reduceright/index.md
index 63222a2191..dbb7001bf8 100644
--- a/files/fr/web/javascript/reference/global_objects/array/reduceright/index.md
+++ b/files/fr/web/javascript/reference/global_objects/array/reduceright/index.md
@@ -11,199 +11,202 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Array/ReduceRight
 original_slug: Web/JavaScript/Reference/Objets_globaux/Array/reduceRight
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>reduceRight()</strong></code> applique une fonction sur un accumulateur et chaque valeur d'un tableau (de la droite vers la gauche) de sorte à réduire le tableau en une seule valeur.</p>
+La méthode **`reduceRight()`** applique une fonction sur un accumulateur et chaque valeur d'un tableau (de la droite vers la gauche) de sorte à réduire le tableau en une seule valeur.
 
-<div>{{EmbedInteractiveExample("pages/js/array-reduce-right.html")}}</div>
+{{EmbedInteractiveExample("pages/js/array-reduce-right.html")}}
 
+Voir également {{jsxref("Array.prototype.reduce()")}} pour une méthode qui réduit de gauche à droite.
 
+## Syntaxe
 
-<p>Voir également {{jsxref("Array.prototype.reduce()")}} pour une méthode qui réduit de gauche à droite.</p>
+    arr.reduceRight(callback[, valeurInitiale])
 
-<h2 id="Syntaxe">Syntaxe</h2>
+### Paramètres
 
-<pre class="syntaxbox"><var>arr</var>.reduceRight(<var>callback</var>[, valeurInitiale])</pre>
+- `callback`
 
-<h3 id="Paramètres">Paramètres</h3>
+  - : La fonction à éxécuter sur chaque valeur de la liste. Elle utilise quatres arguments :
 
-<dl>
- <dt><code>callback</code></dt>
- <dd>La fonction à éxécuter sur chaque valeur de la liste. Elle utilise quatres arguments :
- <dl>
-  <dt><code>accumulator</code></dt>
-  <dd>La valeur précédemment retournée par le dernier appel de la fonction <code>callback</code>, ou <code>valeurInitial</code> si elle est fournie. (Voir ci-après.)</dd>
-  <dt><code>valeurCourante</code></dt>
-  <dd>La valeur de l'élément courant dans le tableau.</dd>
-  <dt><code>index</code></dt>
-  <dd>L'index de l'élément du tableau actuellement manipulé.</dd>
-  <dt><code>array</code></dt>
-  <dd>Le tableau sur lequel <code>reduceRight()</code> est appelée.</dd>
- </dl>
- </dd>
- <dt><code>valeurInitiale</code> {{optional_inline}}</dt>
- <dd>C'est l'objet à utiliser comme accumulateur/premier argument lors du premier appel de la fonction <code>callback</code>. Si aucune valeur n'est fournie, c'est le dernier élément du tableau qui sera utilisé. Si on appelle <code>reduce()</code> ou <code>reduceRight()</code> sur un tableau vide sans fournir de valeur initiale, on aura une exception {{jsxref("TypeError")}}.</dd>
-</dl>
+    - `accumulator`
+      - : La valeur précédemment retournée par le dernier appel de la fonction `callback`, ou `valeurInitial` si elle est fournie. (Voir ci-après.)
+    - `valeurCourante`
+      - : La valeur de l'élément courant dans le tableau.
+    - `index`
+      - : L'index de l'élément du tableau actuellement manipulé.
+    - `array`
+      - : Le tableau sur lequel `reduceRight()` est appelée.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+- `valeurInitiale` {{optional_inline}}
+  - : C'est l'objet à utiliser comme accumulateur/premier argument lors du premier appel de la fonction `callback`. Si aucune valeur n'est fournie, c'est le dernier élément du tableau qui sera utilisé. Si on appelle `reduce()` ou `reduceRight()` sur un tableau vide sans fournir de valeur initiale, on aura une exception {{jsxref("TypeError")}}.
 
-<p>La valeur obtenue grâce à la fonction de réduction.</p>
+### Valeur de retour
 
-<h2 id="Description">Description</h2>
+La valeur obtenue grâce à la fonction de réduction.
 
-<p><code>reduceRight</code> exécute la fonction <code>callback</code> une fois pour chaque élément présent dans le tableau, les éléments vides sont ignorés. La fonction <code>callback</code> utilise quatre arguments : la valeur initiale (ou la valeur retournée par le précédent appel de la fonction<code> callback</code>), la valeur de l'élément courant, l'index de l'élément courant, et le tableau qui est parcouru.</p>
+## Description
 
-<p>L'usage de <code>reduceRight</code> avec définition d'un <code>callback</code> devrait ressembler à ceci :</p>
+`reduceRight` exécute la fonction `callback` une fois pour chaque élément présent dans le tableau, les éléments vides sont ignorés. La fonction `callback` utilise quatre arguments : la valeur initiale (ou la valeur retournée par le précédent appel de la fonction` callback`), la valeur de l'élément courant, l'index de l'élément courant, et le tableau qui est parcouru.
 
-<pre class="brush: js">array.reduceRight(function(accumulator, valeurCourante, index, array) {
+L'usage de `reduceRight` avec définition d'un `callback` devrait ressembler à ceci :
+
+```js
+array.reduceRight(function(accumulator, valeurCourante, index, array) {
     // ...
-});</pre>
+});
+```
 
-<p>La première fois que la fonction de callback est appelée, <code>accumulator</code> et <code>valeurCourante</code> peuvent correspondre à un ou deux éléments. Si <code>valeurInitiale</code> est fournie lors de l'appel à <code>reduceRight</code>, alors <code>accumulator</code> sera égale à <code>valeurInitiale</code> et <code>valeurCourante</code> sera égale à la dernière valeur de la liste. Si <code>valeurInitiale</code> n'est pas fournie, alors <code>accumulator</code> sera égale à la dernière valeur de la liste, et <code>valeurCourante</code> sera alors égale à l'avant-dernière valeur du tableau.</p>
+La première fois que la fonction de callback est appelée, `accumulator` et `valeurCourante` peuvent correspondre à un ou deux éléments. Si `valeurInitiale` est fournie lors de l'appel à `reduceRight`, alors `accumulator` sera égale à `valeurInitiale` et `valeurCourante` sera égale à la dernière valeur de la liste. Si `valeurInitiale` n'est pas fournie, alors `accumulator` sera égale à la dernière valeur de la liste, et `valeurCourante` sera alors égale à l'avant-dernière valeur du tableau.
 
-<p>Si on utilise la méthode <code>reduceRight</code> de la façon suivante :</p>
+Si on utilise la méthode `reduceRight` de la façon suivante :
 
-<pre class="brush: js">[0, 1, 2, 3, 4].reduceRight(function(accumulator, valeurCourante, index, array) {
+```js
+[0, 1, 2, 3, 4].reduceRight(function(accumulator, valeurCourante, index, array) {
     return accumulator + valeurCourante;
 });
-</pre>
+```
 
-<p>La fonction <code>callback</code> sera appelée quatre fois, avec les arguments et les valeurs de retour de chaque appel suivant :</p>
+La fonction `callback` sera appelée quatre fois, avec les arguments et les valeurs de retour de chaque appel suivant :
 
 <table>
- <thead>
-  <tr>
-   <th scope="col"><code>callback</code></th>
-   <th scope="col"><code>accumulator</code></th>
-   <th scope="col"><code>valeurCourante</code></th>
-   <th scope="col"><code>index</code></th>
-   <th scope="col"><code>array</code></th>
-   <th scope="col">Valeur renvoyée</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <th scope="row">premier appel</th>
-   <td>4</td>
-   <td>3</td>
-   <td>3</td>
-   <td><code>[0,1,2,3,4]</code></td>
-   <td>7</td>
-  </tr>
-  <tr>
-   <th scope="row">second appel</th>
-   <td>7</td>
-   <td><code>2</code></td>
-   <td><code>2</code></td>
-   <td><code>[0,1,2,3,4]</code></td>
-   <td>9</td>
-  </tr>
-  <tr>
-   <th scope="row">troisième appel</th>
-   <td>9</td>
-   <td>1</td>
-   <td>1</td>
-   <td><code>[0,1,2,3,4]</code></td>
-   <td>10</td>
-  </tr>
-  <tr>
-   <th scope="row">quatrième appel</th>
-   <td>10</td>
-   <td>0</td>
-   <td>0</td>
-   <td><code>[0,1,2,3,4]</code></td>
-   <td><code>10</code></td>
-  </tr>
- </tbody>
+  <thead>
+    <tr>
+      <th scope="col"><code>callback</code></th>
+      <th scope="col"><code>accumulator</code></th>
+      <th scope="col"><code>valeurCourante</code></th>
+      <th scope="col"><code>index</code></th>
+      <th scope="col"><code>array</code></th>
+      <th scope="col">Valeur renvoyée</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <th scope="row">premier appel</th>
+      <td>4</td>
+      <td>3</td>
+      <td>3</td>
+      <td><code>[0,1,2,3,4]</code></td>
+      <td>7</td>
+    </tr>
+    <tr>
+      <th scope="row">second appel</th>
+      <td>7</td>
+      <td><code>2</code></td>
+      <td><code>2</code></td>
+      <td><code>[0,1,2,3,4]</code></td>
+      <td>9</td>
+    </tr>
+    <tr>
+      <th scope="row">troisième appel</th>
+      <td>9</td>
+      <td>1</td>
+      <td>1</td>
+      <td><code>[0,1,2,3,4]</code></td>
+      <td>10</td>
+    </tr>
+    <tr>
+      <th scope="row">quatrième appel</th>
+      <td>10</td>
+      <td>0</td>
+      <td>0</td>
+      <td><code>[0,1,2,3,4]</code></td>
+      <td><code>10</code></td>
+    </tr>
+  </tbody>
 </table>
 
-<p>La valeur retournée par <code>reduceRight</code> sera alors celle du dernier appel de la fonction <code>callback</code> (<code>10</code>).</p>
+La valeur retournée par `reduceRight` sera alors celle du dernier appel de la fonction `callback` (`10`).
 
-<p>Si vous fournissez une valeur initiale comme second argument à l'appel de <code>reduceRight</code>, le résultat sera alors le suivant :</p>
+Si vous fournissez une valeur initiale comme second argument à l'appel de `reduceRight`, le résultat sera alors le suivant :
 
-<pre class="brush: js">[0, 1, 2, 3, 4].reduceRight(function(accumulator, valeurCourante, index, array) {
+```js
+[0, 1, 2, 3, 4].reduceRight(function(accumulator, valeurCourante, index, array) {
     return accumulator + valeurCourante;
 }, 10);
-</pre>
+```
 
 <table>
- <thead>
-  <tr>
-   <th scope="col"></th>
-   <th scope="col"><code>accumulator</code></th>
-   <th scope="col"><code>valeurCourante</code></th>
-   <th scope="col"><code>index</code></th>
-   <th scope="col"><code>array</code></th>
-   <th scope="col">Valeur renvoyée</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <th scope="row">premier appel</th>
-   <td><code>10</code></td>
-   <td>4</td>
-   <td>4</td>
-   <td><code>[0,1,2,3,4]</code></td>
-   <td><code>14</code></td>
-  </tr>
-  <tr>
-   <th scope="row">second appel</th>
-   <td>14</td>
-   <td>3</td>
-   <td>3</td>
-   <td><code>[0,1,2,3,4]</code></td>
-   <td><code>17</code></td>
-  </tr>
-  <tr>
-   <th scope="row">troisième appel</th>
-   <td>17</td>
-   <td><code>2</code></td>
-   <td><code>2</code></td>
-   <td><code>[0,1,2,3,4]</code></td>
-   <td><code>19</code></td>
-  </tr>
-  <tr>
-   <th scope="row">quatrième appel</th>
-   <td>19</td>
-   <td>1</td>
-   <td>1</td>
-   <td><code>[0,1,2,3,4]</code></td>
-   <td>20</td>
-  </tr>
-  <tr>
-   <th scope="row">cinquième appel</th>
-   <td>20</td>
-   <td>0</td>
-   <td>0</td>
-   <td><code>[0,1,2,3,4]</code></td>
-   <td><code>20</code></td>
-  </tr>
- </tbody>
+  <thead>
+    <tr>
+      <th scope="col"></th>
+      <th scope="col"><code>accumulator</code></th>
+      <th scope="col"><code>valeurCourante</code></th>
+      <th scope="col"><code>index</code></th>
+      <th scope="col"><code>array</code></th>
+      <th scope="col">Valeur renvoyée</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <th scope="row">premier appel</th>
+      <td><code>10</code></td>
+      <td>4</td>
+      <td>4</td>
+      <td><code>[0,1,2,3,4]</code></td>
+      <td><code>14</code></td>
+    </tr>
+    <tr>
+      <th scope="row">second appel</th>
+      <td>14</td>
+      <td>3</td>
+      <td>3</td>
+      <td><code>[0,1,2,3,4]</code></td>
+      <td><code>17</code></td>
+    </tr>
+    <tr>
+      <th scope="row">troisième appel</th>
+      <td>17</td>
+      <td><code>2</code></td>
+      <td><code>2</code></td>
+      <td><code>[0,1,2,3,4]</code></td>
+      <td><code>19</code></td>
+    </tr>
+    <tr>
+      <th scope="row">quatrième appel</th>
+      <td>19</td>
+      <td>1</td>
+      <td>1</td>
+      <td><code>[0,1,2,3,4]</code></td>
+      <td>20</td>
+    </tr>
+    <tr>
+      <th scope="row">cinquième appel</th>
+      <td>20</td>
+      <td>0</td>
+      <td>0</td>
+      <td><code>[0,1,2,3,4]</code></td>
+      <td><code>20</code></td>
+    </tr>
+  </tbody>
 </table>
 
-<p>La valeur renvoyée par <code>reduceRight</code> sera ici <code>20</code>.</p>
+La valeur renvoyée par `reduceRight` sera ici `20`.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Additionner_toutes_les_valeurs_d'une_liste">Additionner toutes les valeurs d'une liste</h3>
+### Additionner toutes les valeurs d'une liste
 
-<pre class="brush: js">var total = [0, 1, 2, 3].reduceRight(function(a, b) {
+```js
+var total = [0, 1, 2, 3].reduceRight(function(a, b) {
     return a + b;
 });
 // total == 6
-</pre>
+```
 
-<h3 id="Aplatir_une_liste_de_listes">Aplatir une liste de listes</h3>
+### Aplatir une liste de listes
 
-<pre class="brush: js">var aplati = [[0, 1], [2, 3], [4, 5]].reduceRight(function(a, b) {
+```js
+var aplati = [[0, 1], [2, 3], [4, 5]].reduceRight(function(a, b) {
     return a.concat(b);
 }, []);
 // aplati [4, 5, 2, 3, 0, 1]
-</pre>
+```
 
-<h3 id="Différence_entre_reduce_et_reduceRight">Différence entre <code>reduce</code> et <code>reduceRight</code></h3>
+### Différence entre `reduce` et `reduceRight`
 
-<pre class="brush: js">var a = ['1', '2', '3', '4','5']
+```js
+var a = ['1', '2', '3', '4','5']
 var gauche = a.reduce(function(prev, cur) {
   return prev + cur;
 });
@@ -213,67 +216,48 @@ var droite = a.reduceRight(function(prev, cur) {
 });
 
 console.log(gauche); // "12345"
-console.log(droite); // "54321"</pre>
+console.log(droite); // "54321"
+```
 
-<h3 id="Composition_de_fonctions_à_l'aide_de_reduce">Composition de fonctions à l'aide de <code>reduce</code></h3>
+### Composition de fonctions à l'aide de `reduce`
 
-<p>La composition de fonctions consiste en l'enchaînement de n fonctions l'une après l'autre (où les appels sont généralement exécutés de droite à gauche.</p>
+La composition de fonctions consiste en l'enchaînement de n fonctions l'une après l'autre (où les appels sont généralement exécutés de droite à gauche.
 
-<pre class="brush: js">/**
+```js
+/**
  *
  * h(x) = f(g(x))
  *
  * https://fr.wikipedia.org/wiki/Composition_de_fonctions
  */
 
-const compose = (...args) =&gt; (value) =&gt; args.reduceRight((acc, fn) =&gt; fn(acc), value)
+const compose = (...args) => (value) => args.reduceRight((acc, fn) => fn(acc), value)
 
 // On incrémente un nombre passé en argument
-const inc = (n) =&gt; n + 1
+const inc = (n) => n + 1
 
 // On double la valeur passée en argument
-const double = (n) =&gt; n * 2
+const double = (n) => n * 2
 
 // On compose double(inc(x))
 compose(double, inc)(2) // 6
 
 // On compose inc(double(x))
 compose(inc, double)(2) // 5
-</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.4.4.22', 'Array.prototype.reduceRight')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td>Définition initiale. Implémentée avec JavaScript 1.8.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-array.prototype.reduceright', 'Array.prototype.reduceRight')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-array.prototype.reduceright', 'Array.prototype.reduceRight')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
+```
+
+## Spécifications
+
+| Spécification                                                                                                            | État                         | Commentaires                                          |
+| ------------------------------------------------------------------------------------------------------------------------ | ---------------------------- | ----------------------------------------------------- |
+| {{SpecName('ES5.1', '#sec-15.4.4.22', 'Array.prototype.reduceRight')}}                             | {{Spec2('ES5.1')}}     | Définition initiale. Implémentée avec JavaScript 1.8. |
+| {{SpecName('ES6', '#sec-array.prototype.reduceright', 'Array.prototype.reduceRight')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-array.prototype.reduceright', 'Array.prototype.reduceRight')}} | {{Spec2('ESDraft')}} |                                                       |
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.Array.reduceRight")}}</p>
+{{Compat("javascript.builtins.Array.reduceRight")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("Array.prototype.reduce()")}}</li>
-</ul>
+- {{jsxref("Array.prototype.reduce()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/array/reverse/index.md b/files/fr/web/javascript/reference/global_objects/array/reverse/index.md
index cfd6d0029a..034a9a73e9 100644
--- a/files/fr/web/javascript/reference/global_objects/array/reverse/index.md
+++ b/files/fr/web/javascript/reference/global_objects/array/reverse/index.md
@@ -10,91 +10,68 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Array/reverse
 original_slug: Web/JavaScript/Reference/Objets_globaux/Array/reverse
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>reverse()</strong></code> transpose les éléments d'un tableau : le premier élément devient le dernier et le dernier devient le premier et ainsi de suite.</p>
+La méthode **`reverse()`** transpose les éléments d'un tableau : le premier élément devient le dernier et le dernier devient le premier et ainsi de suite.
 
-<div>{{EmbedInteractiveExample("pages/js/array-reverse.html")}}</div>
+{{EmbedInteractiveExample("pages/js/array-reverse.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>arr</var>.reverse()</pre>
+    arr.reverse()
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Le tableau inversé.</p>
+Le tableau inversé.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La méthode <code>reverse()</code> permet d'inverser l'ordre des éléments du tableau. La méthode modifie le tableau courant et renvoie une référence à ce tableau.</p>
+La méthode `reverse()` permet d'inverser l'ordre des éléments du tableau. La méthode modifie le tableau courant et renvoie une référence à ce tableau.
 
-<p>Cette méthode est intentionnellement générique et peut être appelée (via {{jsxref("Function.call()")}}) ou appliquée (via {{jsxref("Function.apply()")}}) sur des objets semblables à des tableaux. Les objets qui ne contiennent pas de propriété <code>length</code> qui soit cohérente avec leurs propriétés indexées sur des nombres ne seront pas traités par <code>reverse()</code>.</p>
+Cette méthode est intentionnellement générique et peut être appelée (via {{jsxref("Function.call()")}}) ou appliquée (via {{jsxref("Function.apply()")}}) sur des objets semblables à des tableaux. Les objets qui ne contiennent pas de propriété `length` qui soit cohérente avec leurs propriétés indexées sur des nombres ne seront pas traités par `reverse()`.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Inverser_l'ordre_des_éléments_d'un_tableau">Inverser l'ordre des éléments d'un tableau</h3>
+### Inverser l'ordre des éléments d'un tableau
 
-<p>L'exemple qui suit crée un tableau <code>monArray</code>, qui contient trois éléments, puis inverse celui-ci.</p>
+L'exemple qui suit crée un tableau `monArray`, qui contient trois éléments, puis inverse celui-ci.
 
-<pre class="brush: js">var monArray = ["un", "deux", "trois"];
+```js
+var monArray = ["un", "deux", "trois"];
 monArray.reverse();
 
 console.log(monArray) // ["trois", "deux", "un"]
-</pre>
+```
 
-<h3 id="Inverser_l'ordre_des_éléments_d'un_objet_semblable_à_un_tableau">Inverser l'ordre des éléments d'un objet semblable à un tableau</h3>
+### Inverser l'ordre des éléments d'un objet semblable à un tableau
 
-<p>Dans l'exemple suivant, on crée un objet semblable à un tableau <code>a</code> qui contient trois éléments et une propriété <code>length</code>. On appelle ensuite <code>reverse()</code> grâce à <code>call()</code> sur cet objet pour inverser ses éléments :</p>
+Dans l'exemple suivant, on crée un objet semblable à un tableau `a` qui contient trois éléments et une propriété `length`. On appelle ensuite `reverse()` grâce à `call()` sur cet objet pour inverser ses éléments :
 
-<pre class="brush: js">const a = {0: 1, 1: 2, 2: 3, length: 3};
+```js
+const a = {0: 1, 1: 2, 2: 3, length: 3};
 
 console.log(a); // {0: 1, 1: 2, 2: 3, length: 3}
 
 Array.prototype.reverse.call(a); // On aurait pu utiliser apply() également
 
 console.log(a); // {0: 3, 1: 2, 2 : 1, length: 3}
-</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.4.4.8', 'Array.prototype.reverse')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-array.prototype.reverse', 'Array.prototype.reverse')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-array.prototype.reverse', 'Array.prototype.reverse')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Array.reverse")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Array.prototype.join()")}}</li>
- <li>{{jsxref("Array.prototype.sort()")}}</li>
- <li>{{jsxref("TypedArray.prototype.reverse()")}}</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.4.4.8', 'Array.prototype.reverse')}}                     | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-array.prototype.reverse', 'Array.prototype.reverse')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-array.prototype.reverse', 'Array.prototype.reverse')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Array.reverse")}}
+
+## Voir aussi
+
+- {{jsxref("Array.prototype.join()")}}
+- {{jsxref("Array.prototype.sort()")}}
+- {{jsxref("TypedArray.prototype.reverse()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/array/shift/index.md b/files/fr/web/javascript/reference/global_objects/array/shift/index.md
index aa853937b2..f34d0d73da 100644
--- a/files/fr/web/javascript/reference/global_objects/array/shift/index.md
+++ b/files/fr/web/javascript/reference/global_objects/array/shift/index.md
@@ -10,39 +10,38 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Array/shift
 original_slug: Web/JavaScript/Reference/Objets_globaux/Array/shift
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>shift()</code></strong> permet de retirer le <strong>premier</strong> élément d'un tableau et de renvoyer cet élément. Cette méthode modifie la longueur du tableau.</p>
+La méthode **`shift()`** permet de retirer le **premier** élément d'un tableau et de renvoyer cet élément. Cette méthode modifie la longueur du tableau.
 
-<div>{{EmbedInteractiveExample("pages/js/array-shift.html")}}</div>
+{{EmbedInteractiveExample("pages/js/array-shift.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>arr</var>.shift()</pre>
+    arr.shift()
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>L'élément retiré du tableau ou {{jsxref("undefined")}} si le tableau est vide.</p>
+L'élément retiré du tableau ou {{jsxref("undefined")}} si le tableau est vide.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La méthode <code>shift</code> retire l'élément situé à l'index zéro et décrémente l'index des éléments suivant avant de retourner l'élément supprimé. Si la propriété {{jsxref("Array.length", "length")}} vaut 0, {{jsxref("undefined")}} est retourné.</p>
+La méthode `shift` retire l'élément situé à l'index zéro et décrémente l'index des éléments suivant avant de retourner l'élément supprimé. Si la propriété {{jsxref("Array.length", "length")}} vaut 0, {{jsxref("undefined")}} est retourné.
 
-<p>Cette méthode est générique et peut être {{jsxref("Function.call", "appelée","",1)}} ou {{jsxref("Function.apply", "appliquée","",1)}} sur des objets similaires à des tableaux. </p>
+Cette méthode est générique et peut être {{jsxref("Function.call", "appelée","",1)}} ou {{jsxref("Function.apply", "appliquée","",1)}} sur des objets similaires à des tableaux.
 
-<p>Cette méthode n'est pas exploitable pour les objets dont la propriété <code>length</code> ne reflète pas la taille du contenu, ou pour lesquels la propriété <code>length</code> n'est pas définie.</p>
+Cette méthode n'est pas exploitable pour les objets dont la propriété `length` ne reflète pas la taille du contenu, ou pour lesquels la propriété `length` n'est pas définie.
 
-<div class="blockIndicator note">
-<p><strong>Note :</strong> La méthode {{jsxref("Array.prototype.pop()")}} possède un comportement similaire mais retire le dernier élément du tableau (et non le premier).</p>
-</div>
+> **Note :** La méthode {{jsxref("Array.prototype.pop()")}} possède un comportement similaire mais retire le dernier élément du tableau (et non le premier).
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Supprimer_un_élément_d'un_tableau">Supprimer un élément d'un tableau</h3>
+### Supprimer un élément d'un tableau
 
-<p>Le code suivant affiche le tableau <code>mesPoissons</code> avant et après avoir enlevé le premier élément. Il affiche aussi l'élément supprimé :</p>
+Le code suivant affiche le tableau `mesPoissons` avant et après avoir enlevé le premier élément. Il affiche aussi l'élément supprimé :
 
-<pre class="brush:js">var mesPoissons = ["ange", "clown", "mandarin", "chirurgien"];
+```js
+var mesPoissons = ["ange", "clown", "mandarin", "chirurgien"];
 
 console.log("mesPoissons avant : " + JSON.stringify(mesPoissons));
 // mesPoissons avant : ["ange","clown","mandarin","chirurgien"]
@@ -54,60 +53,36 @@ console.log("mesPoissons après :", mesPoissons);
 
 console.log("Cet élément a été enlevé :", premierÉlément);
 // "Cet élément a été enlevé : ange"
-</pre>
+```
 
-<h3 id="Utiliser_shift()_dans_une_boucle_while">Utiliser <code>shift()</code> dans une boucle <code>while</code></h3>
+### Utiliser `shift()` dans une boucle `while`
 
-<p>La méthode <code>shift()</code> peut être utilisée dans une boucle <code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/while">while</a></code>. Dans l'exemple suivant, chaque itération de la boucle retire un élément du tableau et l'affiche dans la console, jusqu'à ce que ce dernier soit vide.</p>
+La méthode `shift()` peut être utilisée dans une boucle [`while`](/fr/docs/Web/JavaScript/Reference/Instructions/while). Dans l'exemple suivant, chaque itération de la boucle retire un élément du tableau et l'affiche dans la console, jusqu'à ce que ce dernier soit vide.
 
-<pre class="brush: js">var noms = ["André", "Édouard", "Paul", "Christophe", "Jean"];
+```js
+var noms = ["André", "Édouard", "Paul", "Christophe", "Jean"];
 while ( (i = noms.shift()) !== undefined ) {
   console.log(i);
 }
 // André, Édouard, Paul, Christophe, Jean
-</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.4.4.9', 'Array.prototype.shift')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-array.prototype.shift', 'Array.prototype.shift')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-array.prototype.shift', 'Array.prototype.shift')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Array.shift")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Array.prototype.push()")}}</li>
- <li>{{jsxref("Array.prototype.pop()")}}</li>
- <li>{{jsxref("Array.prototype.unshift()")}}</li>
- <li>{{jsxref("Array.prototype.concat()")}}</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.4.4.9', 'Array.prototype.shift')}}                     | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-array.prototype.shift', 'Array.prototype.shift')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-array.prototype.shift', 'Array.prototype.shift')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Array.shift")}}
+
+## Voir aussi
+
+- {{jsxref("Array.prototype.push()")}}
+- {{jsxref("Array.prototype.pop()")}}
+- {{jsxref("Array.prototype.unshift()")}}
+- {{jsxref("Array.prototype.concat()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/array/slice/index.md b/files/fr/web/javascript/reference/global_objects/array/slice/index.md
index 988565123b..35f56b4c80 100644
--- a/files/fr/web/javascript/reference/global_objects/array/slice/index.md
+++ b/files/fr/web/javascript/reference/global_objects/array/slice/index.md
@@ -10,60 +10,60 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Array/slice
 original_slug: Web/JavaScript/Reference/Objets_globaux/Array/slice
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>slice()</code></strong> renvoie un objet tableau, contenant une copie superficielle (<em>shallow copy</em>) d'une portion du tableau d'origine, la portion est définie par un indice de début et un indice de fin (exclus). Le tableau original ne sera pas modifié.</p>
+La méthode **`slice()`** renvoie un objet tableau, contenant une copie superficielle (_shallow copy_) d'une portion du tableau d'origine, la portion est définie par un indice de début et un indice de fin (exclus). Le tableau original ne sera pas modifié.
 
-<div>{{EmbedInteractiveExample("pages/js/array-slice.html")}}</div>
+{{EmbedInteractiveExample("pages/js/array-slice.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>arr</var>.slice()
-<var>arr</var>.slice(<em>début</em>)
-<var>arr</var>.slice(<em>début</em>, <em>fin</em>)
-</pre>
+    arr.slice()
+    arr.slice(début)
+    arr.slice(début, fin)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>début</code> {{optional_inline}}</dt>
- <dd>Indice (à partir de zéro) depuis lequel commencer l'extraction. S'il s'agit d'un indice négatif, <code>début</code> indique un décalage depuis la fin de la séquence. Par exemple, <code>slice(-2)</code> extrait les avant-dernier et dernier éléments dans la séquence.<br>
- <br>
- Si <code>début</code> est absent, <code>slice()</code> commencera depuis 0. Si <code>début</code> est supérieur à la taille du tableau, c'est un tableau vide qui sera renvoyé.</dd>
- <dt><code>fin</code> {{optional_inline}}</dt>
- <dd>Indice (à partir de zéro) auquel arrêter l'extraction. <code>slice()</code> extrait jusqu'à cet indice, mais pas l'élément situé en <code>fin</code> lui-même. <code>slice(1,4)</code> extrait du deuxième au quatrième élément (les éléments d'indices 1, 2 et 3). S'il s'agit d'un indice négatif, <code>fin</code> indique un décalage depuis la fin de la séquence. <code>slice(2,-1)</code> extrait du troisième à l'avant-dernier élément dans la séquence. Si <code>fin</code> n'est pas fourni, <code>slice()</code> extraira jusqu'à la fin de la séquence (<code>arr.length</code>). Si <code>fin</code> est supérieur à la longueur de la séquence, <code>slice()</code> fera une extraction jusqu'à la fin de la séquence.</dd>
-</dl>
+- `début` {{optional_inline}}
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+  - : Indice (à partir de zéro) depuis lequel commencer l'extraction. S'il s'agit d'un indice négatif, `début` indique un décalage depuis la fin de la séquence. Par exemple, `slice(-2)` extrait les avant-dernier et dernier éléments dans la séquence.
 
-<p>Un nouveau tableau contenant les éléments extraits.</p>
+    Si `début` est absent, `slice()` commencera depuis 0. Si `début` est supérieur à la taille du tableau, c'est un tableau vide qui sera renvoyé.
 
-<h2 id="Description">Description</h2>
+- `fin` {{optional_inline}}
+  - : Indice (à partir de zéro) auquel arrêter l'extraction. `slice()` extrait jusqu'à cet indice, mais pas l'élément situé en `fin` lui-même. `slice(1,4)` extrait du deuxième au quatrième élément (les éléments d'indices 1, 2 et 3). S'il s'agit d'un indice négatif, `fin` indique un décalage depuis la fin de la séquence. `slice(2,-1)` extrait du troisième à l'avant-dernier élément dans la séquence. Si `fin` n'est pas fourni, `slice()` extraira jusqu'à la fin de la séquence (`arr.length`). Si `fin` est supérieur à la longueur de la séquence, `slice()` fera une extraction jusqu'à la fin de la séquence.
 
-<p><code>slice()</code> ne modifie pas le tableau original, mais renvoie une nouvelle copie du tableau (<em>shallow copy</em> — copie superficielle) dont les éléments sont des copies des éléments extraits du tableau original. Les éléments du tableau original sont copiés dans le nouveau tableau de la manière suivante :</p>
+### Valeur de retour
 
-<ul>
- <li>Pour les références à des objets (et non les objets eux-mêmes), <code>slice()</code> copie ces références dans le nouveau tableau. Tant l'original que le nouveau tableau font référence au même objet. Si un objet référencé est modifié, ces changements sont visibles tant pour le nouveau que pour l'ancien tableau.</li>
- <li>Pour les chaines de caractères, les nombres et les booléens, <code>slice()</code> copie ces chaines de caractères, ces nombres et ces valeurs booléennes dans le nouveau tableau. Les modifications sur ces chaînes, nombres ou booléens dans l'un des tableaux n'affectent pas l'autre tableau (NB : lorsque l'on parle de chaine de caractères, de nombre ou de booléen ici, on parle exclusivement de leur <em>type primitif</em>, pas des <em>objets</em> {{jsxref("String")}}, {{jsxref("Number")}} ou {{jsxref("Boolean")}} — voir par exemple <a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/String#Les_différences_entre_les_objets_String_et_le_type_primitif_pour_les_chaînes_de_caractères">différences entre objet String et type primitif pour les chaines de caractères</a>).</li>
-</ul>
+Un nouveau tableau contenant les éléments extraits.
 
-<p>Si un nouvel élément est ajouté à l'un ou l'autre tableau, le second n'est pas affecté.</p>
+## Description
 
-<h2 id="Exemples">Exemples</h2>
+`slice()` ne modifie pas le tableau original, mais renvoie une nouvelle copie du tableau (_shallow copy_ — copie superficielle) dont les éléments sont des copies des éléments extraits du tableau original. Les éléments du tableau original sont copiés dans le nouveau tableau de la manière suivante :
 
-<h3 id="Renvoyer_un_fragment_d'un_tableau_existant">Renvoyer un fragment d'un tableau existant</h3>
+- Pour les références à des objets (et non les objets eux-mêmes), `slice()` copie ces références dans le nouveau tableau. Tant l'original que le nouveau tableau font référence au même objet. Si un objet référencé est modifié, ces changements sont visibles tant pour le nouveau que pour l'ancien tableau.
+- Pour les chaines de caractères, les nombres et les booléens, `slice()` copie ces chaines de caractères, ces nombres et ces valeurs booléennes dans le nouveau tableau. Les modifications sur ces chaînes, nombres ou booléens dans l'un des tableaux n'affectent pas l'autre tableau (NB : lorsque l'on parle de chaine de caractères, de nombre ou de booléen ici, on parle exclusivement de leur _type primitif_, pas des _objets_ {{jsxref("String")}}, {{jsxref("Number")}} ou {{jsxref("Boolean")}} — voir par exemple [différences entre objet String et type primitif pour les chaines de caractères](/fr/docs/Web/JavaScript/Reference/Objets_globaux/String#Les_différences_entre_les_objets_String_et_le_type_primitif_pour_les_chaînes_de_caractères)).
 
-<pre class="brush: js">var fruits = ["Banane", "Orange", "Citron", "Pomme", "Mangue"];
+Si un nouvel élément est ajouté à l'un ou l'autre tableau, le second n'est pas affecté.
+
+## Exemples
+
+### Renvoyer un fragment d'un tableau existant
+
+```js
+var fruits = ["Banane", "Orange", "Citron", "Pomme", "Mangue"];
 var agrumes = fruits.slice(1, 3);
 
-// fruits vaut --&gt; ["Banane", "Orange", "Citron", "Pomme", "Mangue"]
-// agrumes vaut --&gt; ["Orange", "Citron"]</pre>
+// fruits vaut --> ["Banane", "Orange", "Citron", "Pomme", "Mangue"]
+// agrumes vaut --> ["Orange", "Citron"]
+```
 
-<h3 id="Utiliser_slice()">Utiliser <code>slice()</code></h3>
+### Utiliser `slice()`
 
-<p>Dans l'exemple qui suit, <code>slice()</code> crée un nouveau tableau, <code>nouvelleVoiture</code>, à partir de <code>maVoiture</code>. Chacun d'entre eux contient une référence à l'objet <code>maHonda</code>. Lorsque la couleur de <code>maHonda</code> est changée en bordeaux, les deux tableaux reflètent ce changement.</p>
+Dans l'exemple qui suit, `slice()` crée un nouveau tableau, `nouvelleVoiture`, à partir de `maVoiture`. Chacun d'entre eux contient une référence à l'objet `maHonda`. Lorsque la couleur de `maHonda` est changée en bordeaux, les deux tableaux reflètent ce changement.
 
-<pre class="brush: js">// Avec slice, crée nouvelleVoiture depuis maVoiture
+```js
+// Avec slice, crée nouvelleVoiture depuis maVoiture
 var maHonda = { couleur : "rouge", roues : 4, moteur : { cylindres : 4, capacité : 2.2 } };
 var maVoiture = [maHonda, 2, "excellente condition", "achetée en 1997"];
 var nouvelleVoiture = maVoiture.slice(0, 2);
@@ -82,11 +82,12 @@ console.log("La nouvelle couleur de ma Honda est " + maHonda.couleur);
 // Affiche la couleur de maHonda référencées depuis les deux tableaux.
 console.log("maVoiture[0].couleur = " + maVoiture[0].couleur);
 console.log("nouvelleVoiture[0].couleur = " + nouvelleVoiture[0].couleur);
-</pre>
+```
 
-<p>Ce script affichera :</p>
+Ce script affichera :
 
-<pre class="brush: js">maVoiture = [{couleur:"rouge", roues:4, moteur:{cylindres:4, capacité:2.2}}, 2,
+```js
+maVoiture = [{couleur:"rouge", roues:4, moteur:{cylindres:4, capacité:2.2}}, 2,
              "excellente condition", "achetée en 1997"]
 nouvelleVoiture = [{couleur:"rouge", roues:4, moteur:{cylindres:4, capacité:2.2}}, 2]
 maVoiture[0].couleur = rouge
@@ -94,22 +95,24 @@ nouvelleVoiture[0].couleur = rouge
 La nouvelle couleur de ma Honda est bordeaux
 maVoiture[0].couleur = bordeaux
 nouvelleVoiture[0].couleur = bordeaux
-</pre>
+```
 
-<h2 id="Utilisation_avec_les_objets_similaires_aux_tableaux">Utilisation avec les objets similaires aux tableaux</h2>
+## Utilisation avec les objets similaires aux tableaux
 
-<p>La méthode <code>slice()</code> peut aussi être appelée pour convertir des objets/collections similaires à des tableaux, en un nouveau tableau. L'objet {{jsxref("Fonctions/arguments", "arguments")}} d'une fonction est un exemple d'objet similaire à un tableau.</p>
+La méthode `slice()` peut aussi être appelée pour convertir des objets/collections similaires à des tableaux, en un nouveau tableau. L'objet {{jsxref("Fonctions/arguments", "arguments")}} d'une fonction est un exemple d'objet similaire à un tableau.
 
-<pre class="brush: js">function list() {
+```js
+function list() {
   return Array.prototype.slice.call(arguments, 0);
 }
 
 var list1 = list(1, 2, 3); // [1, 2, 3]
-</pre>
+```
 
-<p>Il est possible de lier avec la fonction .<code>call</code> de {{jsxref("Function.prototype")}} et on peut effectuer la réduction avec <code>[].slice.call(arguments)</code> plutôt qu'avec <code>Array.prototype.slice.call</code>. Voici comment on peut simplifier avec {{jsxref("Function.prototype.bind", "bind")}} :</p>
+Il est possible de lier avec la fonction .`call` de {{jsxref("Function.prototype")}} et on peut effectuer la réduction avec `[].slice.call(arguments)` plutôt qu'avec `Array.prototype.slice.call`. Voici comment on peut simplifier avec {{jsxref("Function.prototype.bind", "bind")}} :
 
-<pre class="brush: js">var unboundSlice = Array.prototype.slice;
+```js
+var unboundSlice = Array.prototype.slice;
 var slice = Function.prototype.call.bind(unboundSlice);
 
 function list() {
@@ -117,50 +120,23 @@ function list() {
 }
 
 var list1 = list(1, 2, 3); // [1, 2, 3]
-</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('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.4.4.10', 'Array.prototype.slice')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-array.prototype.slice', 'Array.prototype.slice')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-array.prototype.slice', 'Array.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.Array.slice")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Function.prototype.call()")}}</li>
- <li>{{jsxref("Function.prototype.bind()")}}</li>
- <li>{{jsxref("Array.prototype.splice()")}}</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.4.4.10', 'Array.prototype.slice')}}                     | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-array.prototype.slice', 'Array.prototype.slice')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-array.prototype.slice', 'Array.prototype.slice')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Array.slice")}}
+
+## Voir aussi
+
+- {{jsxref("Function.prototype.call()")}}
+- {{jsxref("Function.prototype.bind()")}}
+- {{jsxref("Array.prototype.splice()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/array/some/index.md b/files/fr/web/javascript/reference/global_objects/array/some/index.md
index b9a15a2855..e24fc4cf20 100644
--- a/files/fr/web/javascript/reference/global_objects/array/some/index.md
+++ b/files/fr/web/javascript/reference/global_objects/array/some/index.md
@@ -12,117 +12,93 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Array/some
 original_slug: Web/JavaScript/Reference/Objets_globaux/Array/some
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>some()</code></strong> teste si au moins un élément du tableau passe le test implémenté par la fonction fournie. Elle renvoie un booléen indiquant le résultat du test.</p>
+La méthode **`some()`** teste si au moins un élément du tableau passe le test implémenté par la fonction fournie. Elle renvoie un booléen indiquant le résultat du test.
 
-<div class="note">
-<p><strong>Note :</strong> Cette méthode renverra <code>false</code>, quelle que soit la condition, si elle est utilisée sur un tableau vide.</p>
-</div>
+> **Note :** Cette méthode renverra `false`, quelle que soit la condition, si elle est utilisée sur un tableau vide.
 
-<div>{{EmbedInteractiveExample("pages/js/array-some.html")}}</div>
+{{EmbedInteractiveExample("pages/js/array-some.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>arr</var>.some(<var>callback</var>[, <var>objetThis</var>])</pre>
+    arr.some(callback[, objetThis])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>callback</code></dt>
- <dd>La fonction à tester pour chaque élément du tableau. Cette fonction utilise trois arguments :
- <dl>
-  <dt><code>valeurCourante</code></dt>
-  <dd>L'élément du tableau à traiter par la fonction.</dd>
-  <dt><code>index</code> {{optional_inline}}</dt>
-  <dd>L'indice de l'élément qui est traité par la fonction.</dd>
-  <dt><code>array </code>{{optional_inline}}</dt>
-  <dd>Le tableau sur lequel on a appelé la méthode <code>some</code>.</dd>
- </dl>
- </dd>
- <dt><code>objetThis</code> {{optional_inline}}</dt>
- <dd>Paramètre optionnel. Il correspond à la valeur à utiliser pour <code>this</code> lors de l'exécution de la fonction <code>callback</code>.</dd>
-</dl>
+- `callback`
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+  - : La fonction à tester pour chaque élément du tableau. Cette fonction utilise trois arguments :
 
-<p><code>true</code> si la fonction <code>callback</code> renvoie une valeur équivalente à <code>true</code> pour au moins un des éléments du tableau, sinon elle renvoie <code>false</code>.</p>
+    - `valeurCourante`
+      - : L'élément du tableau à traiter par la fonction.
+    - `index` {{optional_inline}}
+      - : L'indice de l'élément qui est traité par la fonction.
+    - `array `{{optional_inline}}
+      - : Le tableau sur lequel on a appelé la méthode `some`.
 
-<h2 id="Description">Description</h2>
+- `objetThis` {{optional_inline}}
+  - : Paramètre optionnel. Il correspond à la valeur à utiliser pour `this` lors de l'exécution de la fonction `callback`.
 
-<p>La méthode <code>some()</code> exécute la fonction <code>callback</code> une seule fois pour chaque élément présent dans le tableau jusqu'à ce qu'elle en trouve un pour lequel <code>callback</code> renvoie une valeur équivalente à <code>true</code> dans un contexte booléen. Si un tel élément est trouvé, <code>some()</code> renvoie immédiatement <code>true</code>. Dans le cas contraire, <code>some</code> renvoie <code>false</code>. <code>callback</code> n'est invoquée que pour les indices du tableau auxquels des valeurs sont assignées ; elle n'est pas invoquée pour les indices qui ont été supprimés ou auxquels aucune valeur n'a jamais été assignée.</p>
+### Valeur de retour
 
-<p>La fonction <code>callback</code> est invoquée avec trois paramètres : la valeur de l'élément, l'indice de l'élément et l'objet <code>Array</code> parcouru.</p>
+`true` si la fonction `callback` renvoie une valeur équivalente à `true` pour au moins un des éléments du tableau, sinon elle renvoie `false`.
 
-<p>Si un paramètre <code>objetThis</code> est fourni à <code>some()</code>, il sera utilisé comme valeur de <code>this</code> pour chaque invocation du <code>callback</code>. Sinon, la valeur  {{jsxref("undefined")}} sera passée pour utilisation comme valeur <code>this</code>. La valeur <code>this</code> finalement utilisée par <code>callback</code> est déterminée en fonction <a href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/L_op%C3%A9rateur_this">des règles habituelles pour déterminer <code>this</code> pour une fonction</a>.</p>
+## Description
 
-<p>La méthode <code>some()</code> ne modifie pas le tableau sur lequel elle est appelée.</p>
+La méthode `some()` exécute la fonction `callback` une seule fois pour chaque élément présent dans le tableau jusqu'à ce qu'elle en trouve un pour lequel `callback` renvoie une valeur équivalente à `true` dans un contexte booléen. Si un tel élément est trouvé, `some()` renvoie immédiatement `true`. Dans le cas contraire, `some` renvoie `false`. `callback` n'est invoquée que pour les indices du tableau auxquels des valeurs sont assignées ; elle n'est pas invoquée pour les indices qui ont été supprimés ou auxquels aucune valeur n'a jamais été assignée.
 
-<p>La liste des éléments traités par <code>some()</code> est définie avant la première invocation du <code>callback</code>. Les éléments qui sont ajoutés au tableau après le début de l'appel à <code>some</code> ne seront pas visités par <code>callback</code>. Si un élément existant non encore visité est modifié par <code>callback</code>, sa valeur passée à <code>callback</code> sera sa valeur au moment où <code>some</code> visite l'indice de cet élément ; les éléments supprimés ne seront pas visités.</p>
+La fonction `callback` est invoquée avec trois paramètres : la valeur de l'élément, l'indice de l'élément et l'objet `Array` parcouru.
 
-<h2 id="Exemples">Exemples</h2>
+Si un paramètre `objetThis` est fourni à `some()`, il sera utilisé comme valeur de `this` pour chaque invocation du `callback`. Sinon, la valeur  {{jsxref("undefined")}} sera passée pour utilisation comme valeur `this`. La valeur `this` finalement utilisée par `callback` est déterminée en fonction [des règles habituelles pour déterminer `this` pour une fonction](/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/L_op%C3%A9rateur_this).
 
-<h3 id="Tester_la_valeur_des_éléments_d'un_tableau">Tester la valeur des éléments d'un tableau</h3>
+La méthode `some()` ne modifie pas le tableau sur lequel elle est appelée.
 
-<p>L'exemple suivant teste si certains éléments d'un tableau sont plus grands que 10.</p>
+La liste des éléments traités par `some()` est définie avant la première invocation du `callback`. Les éléments qui sont ajoutés au tableau après le début de l'appel à `some` ne seront pas visités par `callback`. Si un élément existant non encore visité est modifié par `callback`, sa valeur passée à `callback` sera sa valeur au moment où `some` visite l'indice de cet élément ; les éléments supprimés ne seront pas visités.
 
-<pre class="brush: js">function estAssezGrand(element, indice, array) {
-  return (element &gt;= 10);
+## Exemples
+
+### Tester la valeur des éléments d'un tableau
+
+L'exemple suivant teste si certains éléments d'un tableau sont plus grands que 10.
+
+```js
+function estAssezGrand(element, indice, array) {
+  return (element >= 10);
 }
 var resultat = [2, 5, 8, 1, 4].some(estAssezGrand);
 // resultat vaut false
 passed = [12, 5, 8, 1, 4].some(estAssezGrand);
 // passed vaut true
-</pre>
-
-<h3 id="Tester_la_valeur_des_éléments_avec_les_fonctions_fléchées">Tester la valeur des éléments avec les fonctions fléchées</h3>
-
-<p><a href="/fr/docs/Web/JavaScript/Reference/Fonctions/Fonctions_fl%C3%A9ch%C3%A9es">Les fonctions fléchées </a>permettent d'utiliser une syntaxe plus concise pour réaliser la même opération que l'exemple précédent.</p>
-
-<pre class="brush: js">[2, 5, 8, 1, 4].some(elem =&gt; elem &gt; 10); // false
-[12, 5, 8, 1, 4].some(elem =&gt; elem &gt; 10); // true</pre>
-
-<div class="note">
-<p><strong>Note :</strong> Si on veut vérifier qu'un élément est dans un tableau, on pourra utiliser la méthode {{jsxref("Array.prototype.includes()")}}.</p>
-</div>
-
-<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.4.4.17', 'Array.prototype.some')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td>Définition initiale. Implémentée avec JavaScript 1.6.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-array.prototype.some', 'Array.prototype.some')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-array.prototype.some', 'Array.prototype.some')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Array.some")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Array.prototype.find()")}}</li>
- <li>{{jsxref("Array.prototype.forEach()")}}</li>
- <li>{{jsxref("Array.prototype.every()")}}</li>
- <li>{{jsxref("Array.prototype.includes()")}}</li>
- <li>{{jsxref("TypedArray.prototype.some()")}}</li>
-</ul>
+```
+
+### Tester la valeur des éléments avec les fonctions fléchées
+
+[Les fonctions fléchées ](/fr/docs/Web/JavaScript/Reference/Fonctions/Fonctions_fl%C3%A9ch%C3%A9es)permettent d'utiliser une syntaxe plus concise pour réaliser la même opération que l'exemple précédent.
+
+```js
+[2, 5, 8, 1, 4].some(elem => elem > 10); // false
+[12, 5, 8, 1, 4].some(elem => elem > 10); // true
+```
+
+> **Note :** Si on veut vérifier qu'un élément est dans un tableau, on pourra utiliser la méthode {{jsxref("Array.prototype.includes()")}}.
+
+## Spécifications
+
+| Spécification                                                                                        | État                         | Commentaires                                          |
+| ---------------------------------------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- |
+| {{SpecName('ES5.1', '#sec-15.4.4.17', 'Array.prototype.some')}}                 | {{Spec2('ES5.1')}}     | Définition initiale. Implémentée avec JavaScript 1.6. |
+| {{SpecName('ES6', '#sec-array.prototype.some', 'Array.prototype.some')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-array.prototype.some', 'Array.prototype.some')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Array.some")}}
+
+## Voir aussi
+
+- {{jsxref("Array.prototype.find()")}}
+- {{jsxref("Array.prototype.forEach()")}}
+- {{jsxref("Array.prototype.every()")}}
+- {{jsxref("Array.prototype.includes()")}}
+- {{jsxref("TypedArray.prototype.some()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/array/sort/index.md b/files/fr/web/javascript/reference/global_objects/array/sort/index.md
index 84ce52113f..75fe8a8ce3 100644
--- a/files/fr/web/javascript/reference/global_objects/array/sort/index.md
+++ b/files/fr/web/javascript/reference/global_objects/array/sort/index.md
@@ -10,85 +10,85 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Array/sort
 original_slug: Web/JavaScript/Reference/Objets_globaux/Array/sort
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>sort()</code></strong> trie les éléments d'un tableau, dans ce même tableau, et renvoie le tableau. Par défaut, le tri s'effectue sur les éléments du tableau convertis en chaînes de caractères et triées selon les valeurs des unités de code UTF-16 des caractères.</p>
+La méthode **`sort()`** trie les éléments d'un tableau, dans ce même tableau, et renvoie le tableau. Par défaut, le tri s'effectue sur les éléments du tableau convertis en chaînes de caractères et triées selon les valeurs des unités de code UTF-16 des caractères.
 
-<p>La complexité en espace mémoire et en temps utilisée pour le tri ne peut pas être garantie car elle dépend de l'implémentation.</p>
+La complexité en espace mémoire et en temps utilisée pour le tri ne peut pas être garantie car elle dépend de l'implémentation.
 
-<div>{{EmbedInteractiveExample("pages/js/array-sort.html")}}</div>
+{{EmbedInteractiveExample("pages/js/array-sort.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>arr</var>.sort()
-<var>arr</var>.sort(fonctionComparaison)</pre>
+    arr.sort()
+    arr.sort(fonctionComparaison)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>fonctionComparaison</code> {{optional_inline}}</dt>
- <dd>Ce paramètre optionnel permet de spécifier une fonction définissant l'ordre de tri. Si absente, le tableau est trié selon la valeur de point de code <a href="/fr/docs/Web/JavaScript/Guide/Valeurs,_variables,_et_litt%C3%A9raux#Unicode">Unicode</a> de chaque caractère, d'après la conversion en chaine de caractères de chaque élément. Cette fonction prendra deux arguments : le premier élément à comparer et le deuxième élément à comparer.</dd>
-</dl>
+- `fonctionComparaison` {{optional_inline}}
+  - : Ce paramètre optionnel permet de spécifier une fonction définissant l'ordre de tri. Si absente, le tableau est trié selon la valeur de point de code [Unicode](/fr/docs/Web/JavaScript/Guide/Valeurs,_variables,_et_litt%C3%A9raux#Unicode) de chaque caractère, d'après la conversion en chaine de caractères de chaque élément. Cette fonction prendra deux arguments : le premier élément à comparer et le deuxième élément à comparer.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Le tableau trié (le tri est effectué sur le tableau courant qui est modifié, aucune copie n'est réalisée).</p>
+Le tableau trié (le tri est effectué sur le tableau courant qui est modifié, aucune copie n'est réalisée).
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Si le paramètre <code>fonctionComparaison</code> n'est pas fourni, les éléments qui ne valent pas <code>undefined</code> sont triés en les convertissant en chaines de caractères et en comparant ces chaines selon l'ordre des points de code Unicode. Par exemple, "banane" sera trié avant "cerise", mais "Cerise" arrivera avant "banane" à cause de la majuscule (les majuscules arrivent avant dans la liste). Dans un tri numérique, 9 sera trié avant 80, mais comme ces nombres sont convertis en chaînes de caractères, "80" arrive avant "9" selon l'ordre des unités de code UTF-16. Les éléments valant <code>undefined</code> sont placés à la fin du tableau.</p>
+Si le paramètre `fonctionComparaison` n'est pas fourni, les éléments qui ne valent pas `undefined` sont triés en les convertissant en chaines de caractères et en comparant ces chaines selon l'ordre des points de code Unicode. Par exemple, "banane" sera trié avant "cerise", mais "Cerise" arrivera avant "banane" à cause de la majuscule (les majuscules arrivent avant dans la liste). Dans un tri numérique, 9 sera trié avant 80, mais comme ces nombres sont convertis en chaînes de caractères, "80" arrive avant "9" selon l'ordre des unités de code UTF-16. Les éléments valant `undefined` sont placés à la fin du tableau.
 
-<div class="note">
-<p><strong>Note :</strong> En UTF-16, les caractères Unicode situés après <code>\uFFFF</code> sont encodés avec deux unités de code <em>surrogates</em> sur l'intervalle <code>\uD800</code>-<code>\uDFFF</code>. Pour comparer les chaînes de caractères entre elles, ce sont les unités de code séparées qui sont prises en compte. Ainsi, le caractère formé par la paire <em>surrogate</em> <code>\uD655 \uDE55</code> sera trié avant le caractère <code>\uFF3A</code>.</p>
-</div>
+> **Note :** En UTF-16, les caractères Unicode situés après `\uFFFF` sont encodés avec deux unités de code _surrogates_ sur l'intervalle `\uD800`-`\uDFFF`. Pour comparer les chaînes de caractères entre elles, ce sont les unités de code séparées qui sont prises en compte. Ainsi, le caractère formé par la paire _surrogate_ `\uD655 \uDE55` sera trié avant le caractère `\uFF3A`.
 
-<p>Si le paramètre <code>fonctionComparaison</code> est fourni, les éléments du tableau (qui ne valent pas <code>undefined</code>) sont triés selon la valeur de retour de la fonction de comparaison. Si <code>a</code> et <code>b</code> sont deux éléments à comparer, alors :</p>
+Si le paramètre `fonctionComparaison` est fourni, les éléments du tableau (qui ne valent pas `undefined`) sont triés selon la valeur de retour de la fonction de comparaison. Si `a` et `b` sont deux éléments à comparer, alors :
 
-<ul>
- <li>Si <code>fonctionComparaison(a, b)</code> est inférieur à 0, on trie <code>a</code> avec un indice inférieur à <code>b</code> (<code>a</code> sera classé avant <code>b</code>)</li>
- <li>Si <code>fonctionComparaison(a, b)</code> renvoie 0, on laisse <code>a</code> et <code>b</code> inchangés l'un par rapport à l'autre, mais triés par rapport à tous les autres éléments. Note : la norme ECMAScript ne garantit pas ce comportement, par conséquent tous les navigateurs (par exemple les versions de Mozilla antérieures à 2003) ne respectent pas ceci.</li>
- <li>Si <code>fonctionComparaison(a, b)</code> est supérieur à 0, on trie <code>b</code> avec un indice inférieur à <code>a</code>.</li>
- <li><code>fonctionComparaison(a, b)</code> doit toujours renvoyer le même résultat à partir de la même paire d'arguments. Si la fonction renvoie des résultats incohérents, alors l’ordre dans lequel sont triés les éléments n’est pas défini.</li>
-</ul>
+- Si `fonctionComparaison(a, b)` est inférieur à 0, on trie `a` avec un indice inférieur à `b` (`a` sera classé avant `b`)
+- Si `fonctionComparaison(a, b)` renvoie 0, on laisse `a` et `b` inchangés l'un par rapport à l'autre, mais triés par rapport à tous les autres éléments. Note : la norme ECMAScript ne garantit pas ce comportement, par conséquent tous les navigateurs (par exemple les versions de Mozilla antérieures à 2003) ne respectent pas ceci.
+- Si `fonctionComparaison(a, b)` est supérieur à 0, on trie `b` avec un indice inférieur à `a`.
+- `fonctionComparaison(a, b)` doit toujours renvoyer le même résultat à partir de la même paire d'arguments. Si la fonction renvoie des résultats incohérents, alors l’ordre dans lequel sont triés les éléments n’est pas défini.
 
-<p>Une fonction de comparaison aura donc généralement la forme suivante :</p>
+Une fonction de comparaison aura donc généralement la forme suivante :
 
-<pre class="brush: js">function compare(a, b) {
-  if (<em>a est inférieur à b selon les critères de tri</em>)
+```js
+function compare(a, b) {
+  if (a est inférieur à b selon les critères de tri)
      return -1;
-  if (<em>a est supérieur à b selon les critères de tri</em>)
+  if (a est supérieur à b selon les critères de tri)
      return 1;
   // a doit être égal à b
   return 0;
 }
-</pre>
+```
 
-<p>Pour comparer des nombres plutôt que des chaînes, la fonction de comparaison peut simplement soustraire <code>b</code> à <code>a</code> (cela fonctionnera si le tableau ne contient pas {{jsxref("NaN")}} ou {{jsxref("Infinity")}}) :</p>
+Pour comparer des nombres plutôt que des chaînes, la fonction de comparaison peut simplement soustraire `b` à `a` (cela fonctionnera si le tableau ne contient pas {{jsxref("NaN")}} ou {{jsxref("Infinity")}}) :
 
-<pre class="brush: js">function compareNombres(a, b) {
+```js
+function compareNombres(a, b) {
   return a - b;
 }
-</pre>
+```
 
-<p>L'usage des {{jsxref("Opérateurs/L_opérateur_function", "expressions de fonctions","",11)}} s'avère très pratique avec la méthode <code>sort()</code> :</p>
+L'usage des {{jsxref("Opérateurs/L_opérateur_function", "expressions de fonctions","",11)}} s'avère très pratique avec la méthode `sort()` :
 
-<pre class="brush: js">var nombres = [4, 2, 5, 1, 3];
+```js
+var nombres = [4, 2, 5, 1, 3];
 nombres.sort(function(a, b) {
   return a - b;
 });
 console.log(nombres);
 // [1, 2, 3, 4, 5]
-</pre>
+```
 
-<p>ECMAScript 2015 permet d'utiliser <a href="/fr/docs/Web/JavaScript/Reference/Fonctions/Fonctions_fl%C3%A9ch%C3%A9es">les fonctions fléchées</a> et ainsi d'obtenir une syntaxe plus concise :</p>
+ECMAScript 2015 permet d'utiliser [les fonctions fléchées](/fr/docs/Web/JavaScript/Reference/Fonctions/Fonctions_fl%C3%A9ch%C3%A9es) et ainsi d'obtenir une syntaxe plus concise :
 
-<pre class="brush: js">let nombres = [4, 2, 5, 1, 3];
-nombres.sort((a, b) =&gt; a - b);
-console.log(nombres);</pre>
+```js
+let nombres = [4, 2, 5, 1, 3];
+nombres.sort((a, b) => a - b);
+console.log(nombres);
+```
 
-<p>Les objets peuvent être triés d'après les valeurs d'une de leurs propriétés.</p>
+Les objets peuvent être triés d'après les valeurs d'une de leurs propriétés.
 
-<pre class="brush: js">var items = [
+```js
+var items = [
   { name: "Edward", value: 21 },
   { name: "Sharpe", value: 37 },
   { name: "And", value: 45 },
@@ -98,28 +98,30 @@ console.log(nombres);</pre>
 ];
 items.sort(function (a, b) {
   return a.value - b.value;
-});</pre>
+});
+```
 
-<h3 id="Différences_dimplémentation">Différences d'implémentation</h3>
+### Différences d'implémentation
 
-<p>Certaines implémentations de JavaScript utilisent un tri stable : l'ordre partiel de <code>a</code> et <code>b</code> ne change pas si <code>a</code> et <code>b</code> sont égaux. Si l'indice de <code>a</code> était inférieur à celui de <code>b</code> avant le tri, il le sera toujours après, quels que soient les mouvements de <code>a</code> et <code>b</code> dus au tri.</p>
+Certaines implémentations de JavaScript utilisent un tri stable : l'ordre partiel de `a` et `b` ne change pas si `a` et `b` sont égaux. Si l'indice de `a` était inférieur à celui de `b` avant le tri, il le sera toujours après, quels que soient les mouvements de `a` et `b` dus au tri.
 
-<p>Le tri est stable dans <a href="/fr/docs/SpiderMonkey">SpiderMonkey</a> et tous les navigateurs basés sur Mozilla à partir de <a href="/fr/docs/Gecko">Gecko</a> 1.9 (voir le {{ Bug(224128) }}).</p>
+Le tri est stable dans [SpiderMonkey](/fr/docs/SpiderMonkey) et tous les navigateurs basés sur Mozilla à partir de [Gecko](/fr/docs/Gecko) 1.9 (voir le {{ Bug(224128) }}).
 
-<p>Le comportement de la méthode <code>sort()</code> a changé entre JavaScript 1.1 et JavaScript 1.2.</p>
+Le comportement de la méthode `sort()` a changé entre JavaScript 1.1 et JavaScript 1.2.
 
-<p>En JavaScript 1.1, sur certaines plateformes, la méthode <code>sort</code> ne fonctionnait pas. Le tri fonctionne sur toutes les plateformes à partir de JavaScript 1.2.</p>
+En JavaScript 1.1, sur certaines plateformes, la méthode `sort` ne fonctionnait pas. Le tri fonctionne sur toutes les plateformes à partir de JavaScript 1.2.
 
-<p>En JavaScript 1.2, cette méthode ne convertit plus les éléments non définis (<code>undefined</code>) en <code>null</code> ; elle les place en fin de tableau. Par exemple, supposons que vous ayez ce script :</p>
+En JavaScript 1.2, cette méthode ne convertit plus les éléments non définis (`undefined`) en `null` ; elle les place en fin de tableau. Par exemple, supposons que vous ayez ce script :
 
-<pre class="brush: js">var a = [];
+```js
+var a = [];
 a[0] = "araignée";
 a[5] = "zèbre";
 
 function writeArray(x) {
-  for (i = 0; i &lt; x.length; i++) {
+  for (i = 0; i < x.length; i++) {
     console.log(x[i]);
-    if (i &lt; x.length-1)
+    if (i < x.length-1)
       console.log(", ");
   }
 }
@@ -128,27 +130,26 @@ writeArray(a);
 a.sort();
 console.log("\n");
 writeArray(a);
-</pre>
+```
 
-<p>En JavaScript 1.1, cette fonction affichait :</p>
+En JavaScript 1.1, cette fonction affichait :
 
-<pre class="eval">araignée, null, null, null, null, zèbre
-araignée, null, null, null, null, zèbre
-</pre>
+    araignée, null, null, null, null, zèbre
+    araignée, null, null, null, null, zèbre
 
-<p>En JavaScript 1.2, elle affichera :</p>
+En JavaScript 1.2, elle affichera :
 
-<pre class="eval">araignée, undefined, undefined, undefined, undefined, zèbre
-araignée, zèbre, undefined, undefined, undefined, undefined
-</pre>
+    araignée, undefined, undefined, undefined, undefined, zèbre
+    araignée, zèbre, undefined, undefined, undefined, undefined
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Création_affichage_et_tri_dun_tableau">Création, affichage et tri d'un tableau</h3>
+### Création, affichage et tri d'un tableau
 
-<p>L'exemple qui suit crée quatre tableaux et affiche le tableau original, puis les tableaux triés. Les tableaux numériques sont triés d'abord sans, puis avec une fonction de comparaison.</p>
+L'exemple qui suit crée quatre tableaux et affiche le tableau original, puis les tableaux triés. Les tableaux numériques sont triés d'abord sans, puis avec une fonction de comparaison.
 
-<pre class="brush: js">var stringArray = ["Bosse", "Bleue", "Béluga"];
+```js
+var stringArray = ["Bosse", "Bleue", "Béluga"];
 var numericStringArray = ["80", "9", "700"];
 var numberArray = [40, 1, 5, 200];
 var mixedNumericArray = ["80", "9", "700", 40, 1, 5, 200];
@@ -171,42 +172,44 @@ console.log("Triées avec compareNombres : " + numericStringArray.sort(compareN
 console.log("Nombres et chaînes numériques : " + mixedNumericArray.join() +"\n");
 console.log("Triés sans fonction de comparaison : " + mixedNumericArray.sort() +"\n");
 console.log("Triés avec compareNombres : " + mixedNumericArray.sort(compareNombres) +"\n\n");
-</pre>
+```
 
-<p>Cet exemple produit la sortie suivante. Comme on peut le voir, lorsqu'on utilise la fonction de comparaison, les nombres sont triés correctement qu'ils soient des nombres ou des chaînes numériques.</p>
+Cet exemple produit la sortie suivante. Comme on peut le voir, lorsqu'on utilise la fonction de comparaison, les nombres sont triés correctement qu'ils soient des nombres ou des chaînes numériques.
 
-<pre class="eval">Chaînes : Bosse,Bleue,Béluga
-Triées : Bleue,Bosse,Béluga
+    Chaînes : Bosse,Bleue,Béluga
+    Triées : Bleue,Bosse,Béluga
 
-Nombres : 40,1,5,200
-Triés sans fonction de comparaison : 1,200,40,5
-Triés avec compareNombres : 1,5,40,200
+    Nombres : 40,1,5,200
+    Triés sans fonction de comparaison : 1,200,40,5
+    Triés avec compareNombres : 1,5,40,200
 
-Chaînes numériques : 80,9,700
-Triées sans fonction de comparaison : 700,80,9
-Triées avec compareNombres : 9,80,700
+    Chaînes numériques : 80,9,700
+    Triées sans fonction de comparaison : 700,80,9
+    Triées avec compareNombres : 9,80,700
 
-Nombres et chaînes numériques : 80,9,700,40,1,5,200
-Triés sans fonction de comparaison : 1,200,40,5,700,80,9
-Triés avec compareNombres : 1,5,9,40,80,200,700
-</pre>
+    Nombres et chaînes numériques : 80,9,700,40,1,5,200
+    Triés sans fonction de comparaison : 1,200,40,5,700,80,9
+    Triés avec compareNombres : 1,5,9,40,80,200,700
 
-<h3 id="Trier_des_caractères_non-ASCII">Trier des caractères non-ASCII</h3>
+### Trier des caractères non-ASCII
 
-<p>Pour des chaines de caractères contenant des caractères non ASCII, c'est à dire des chaines de caractères contenant par exemple des accents (é, è, a, ä, etc.) : utilisez {{jsxref("String.localeCompare")}}. Cette fonction peut comparer ces caractères afin qu'ils apparaissent dans le bon ordre.</p>
+Pour des chaines de caractères contenant des caractères non ASCII, c'est à dire des chaines de caractères contenant par exemple des accents (é, è, a, ä, etc.) : utilisez {{jsxref("String.localeCompare")}}. Cette fonction peut comparer ces caractères afin qu'ils apparaissent dans le bon ordre.
 
-<pre class="brush: js">var items = ["réservé", "premier", "cliché", "communiqué", "café" ,"adieu"];
+```js
+var items = ["réservé", "premier", "cliché", "communiqué", "café" ,"adieu"];
 items.sort(function (a, b) {
   return a.localeCompare(b);
 });
 
-// items is [ 'adieu', 'café', 'cliché', 'communiqué', 'premier', 'réservé' ]</pre>
+// items is [ 'adieu', 'café', 'cliché', 'communiqué', 'premier', 'réservé' ]
+```
 
-<h3 id="Trier_avec_map">Trier avec map</h3>
+### Trier avec map
 
-<p>La fonction de comparaison peut être amenée à être appelée plusieurs fois pour un même élément du tableau. Selon la fonction utilisée, cela peut entraîner des problèmes de performances. Plus le tableau est grand et plus la fonction de comparaison est complexe, plus il sera judicieux d'envisager des opérations de fonctions appliquées au tableau (<em>map</em>). L'idée est la suivante : on extrait les valeurs du tableau original, en appliquant des opérations dans un tableau temporaire, puis on trie ce tableau temporaire. Enfin, on recompose le tableau final avec les éléments du premier tableau et l'ordre obtenu.</p>
+La fonction de comparaison peut être amenée à être appelée plusieurs fois pour un même élément du tableau. Selon la fonction utilisée, cela peut entraîner des problèmes de performances. Plus le tableau est grand et plus la fonction de comparaison est complexe, plus il sera judicieux d'envisager des opérations de fonctions appliquées au tableau (_map_). L'idée est la suivante : on extrait les valeurs du tableau original, en appliquant des opérations dans un tableau temporaire, puis on trie ce tableau temporaire. Enfin, on recompose le tableau final avec les éléments du premier tableau et l'ordre obtenu.
 
-<pre class="brush: js">// le tableau à trier
+```js
+// le tableau à trier
 var liste = ['Delta', 'alpha', 'CHARLIE', 'bravo'];
 
 // Création d'objet temporaire qui contient les positions
@@ -217,10 +220,10 @@ var mapped = liste.map(function(e, i) {
 
 // on trie l'objet temporaire avec les valeurs réduites
 mapped.sort(function(a, b) {
-  if (a.value &gt; b.value) {
+  if (a.value > b.value) {
     return 1;
   }
-  if (a.value &lt; b.value) {
+  if (a.value < b.value) {
     return -1;
   }
   return 0;
@@ -230,54 +233,25 @@ mapped.sort(function(a, b) {
 var result = mapped.map(function(e){
   return liste[e.index];
 });
-</pre>
-
-<div class="note">
-<p><strong>Note :</strong> Une bibliothèque <em>open source</em> utilise cette approche : <code><a href="https://null.house/open-source/mapsort">mapsort</a></code>.</p>
-</div>
-
-<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.4.4.11', 'Array.prototype.sort')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-array.prototype.sort', 'Array.prototype.sort')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-array.prototype.sort', 'Array.prototype.sort')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Array.sort")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Array.prototype.reverse()")}}</li>
- <li>{{jsxref("String.prototype.localeCompare()")}}</li>
- <li><a href="https://v8.dev/blog/array-sort">À propos de la stabilité du tri pour le moteur V8</a></li>
-</ul>
+```
+
+> **Note :** Une bibliothèque _open source_ utilise cette approche : [`mapsort`](https://null.house/open-source/mapsort).
+
+## Spécifications
+
+| Spécification                                                                                        | État                         | Commentaires         |
+| ---------------------------------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ES1')}}                                                                             | {{Spec2('ES1')}}         | Définition initiale. |
+| {{SpecName('ES5.1', '#sec-15.4.4.11', 'Array.prototype.sort')}}                 | {{Spec2('ES5.1')}}     |                      |
+| {{SpecName('ES6', '#sec-array.prototype.sort', 'Array.prototype.sort')}}     | {{Spec2('ES6')}}         |                      |
+| {{SpecName('ESDraft', '#sec-array.prototype.sort', 'Array.prototype.sort')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Array.sort")}}
+
+## Voir aussi
+
+- {{jsxref("Array.prototype.reverse()")}}
+- {{jsxref("String.prototype.localeCompare()")}}
+- [À propos de la stabilité du tri pour le moteur V8](https://v8.dev/blog/array-sort)
diff --git a/files/fr/web/javascript/reference/global_objects/array/splice/index.md b/files/fr/web/javascript/reference/global_objects/array/splice/index.md
index a4fc4f2ad5..8ce0f4aaf2 100644
--- a/files/fr/web/javascript/reference/global_objects/array/splice/index.md
+++ b/files/fr/web/javascript/reference/global_objects/array/splice/index.md
@@ -10,44 +10,42 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Array/splice
 original_slug: Web/JavaScript/Reference/Objets_globaux/Array/splice
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>splice()</code></strong> modifie le contenu d'un tableau en retirant des éléments et/ou en ajoutant de nouveaux éléments <a href="https://en.wikipedia.org/wiki/In-place_algorithm">à même le tableau</a>.On peut ainsi vider ou remplacer une partie d'un tableau.</p>
+La méthode **`splice()`** modifie le contenu d'un tableau en retirant des éléments et/ou en ajoutant de nouveaux éléments [à même le tableau](https://en.wikipedia.org/wiki/In-place_algorithm).On peut ainsi vider ou remplacer une partie d'un tableau.
 
-<div>{{EmbedInteractiveExample("pages/js/array-splice.html")}}</div>
+{{EmbedInteractiveExample("pages/js/array-splice.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>var tabElementsSupprimes = array</var>.splice(<var>début</var>, nbASupprimer[, <var>élem1</var>[, élem2[, ...]]])
-</pre>
+    var tabElementsSupprimes = array.splice(début, nbASupprimer[, élem1[, élem2[, ...]]])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>début</code></dt>
- <dd>L'indice à partir duquel commencer à changer le tableau (l'indice du premier élement étant <code>0</code>). Si sa valeur est supérieure à la longueur du tableau <code><var>array</var>.length</code>, <code>début</code> est ramené à la longueur du tableau <code><var>array</var>.length</code>. S'il est négatif, le changement commencera d'autant d'éléments à partir de la fin du tableau, c'est à dire à partir de l'index  <code><var>array</var>.length + <var>début</var></code>. Si <code><var>array</var>.length + <var>début</var></code> est inférieur à <code>0</code>, le changement commencera à l'index <code>0</code>.</dd>
- <dt><code>nbASupprimer</code></dt>
- <dd>Un entier indiquant le nombre d'anciens éléments à remplacer.<br>
- Si ce paramètre est absent ou si sa valeur est supérieure ou égale à <code>array.length - début</code>, alors les éléments entre <code>début</code> et la fin du tableau seront supprimés. Si <code>nbASupprimer</code> vaut 0, aucun élément ne sera supprimé. Dans ce cas, il est nécessaire de spécifier au moins un nouvel élément.</dd>
- <dt><code>élemN</code></dt>
- <dd>Les éléments à ajouter au tableau à partir de <code>début</code>. Si vous ne spécifiez pas de nouvel élément, les anciens éléments seront simplement supprimés du tableau.</dd>
-</dl>
+- `début`
+  - : L'indice à partir duquel commencer à changer le tableau (l'indice du premier élement étant `0`). Si sa valeur est supérieure à la longueur du tableau `array.length`, `début` est ramené à la longueur du tableau `array.length`. S'il est négatif, le changement commencera d'autant d'éléments à partir de la fin du tableau, c'est à dire à partir de l'index  `array.length + début`. Si `array.length + début` est inférieur à `0`, le changement commencera à l'index `0`.
+- `nbASupprimer`
+  - : Un entier indiquant le nombre d'anciens éléments à remplacer.
+    Si ce paramètre est absent ou si sa valeur est supérieure ou égale à `array.length - début`, alors les éléments entre `début` et la fin du tableau seront supprimés. Si `nbASupprimer` vaut 0, aucun élément ne sera supprimé. Dans ce cas, il est nécessaire de spécifier au moins un nouvel élément.
+- `élemN`
+  - : Les éléments à ajouter au tableau à partir de `début`. Si vous ne spécifiez pas de nouvel élément, les anciens éléments seront simplement supprimés du tableau.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un tableau contenant les éléments supprimés. Si un seul élément est supprimé, un tableau contenant un unique élément est retourné.</p>
+Un tableau contenant les éléments supprimés. Si un seul élément est supprimé, un tableau contenant un unique élément est retourné.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Si vous spécifiez un nombre différent d'éléments à insérer et d'éléments à supprimer, le tableau aura une longueur différente après l'appel de la méthode.</p>
+Si vous spécifiez un nombre différent d'éléments à insérer et d'éléments à supprimer, le tableau aura une longueur différente après l'appel de la méthode.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_splice">Utiliser <code>splice</code></h3>
+### Utiliser `splice`
 
-<p>Le script suivant illustre l'utilisation de <code>splice</code> :</p>
+Le script suivant illustre l'utilisation de `splice` :
 
-<pre class="brush: js">var mesPoissons  = ["scalaire", "clown", "mandarin", "chirurgien"];
+```js
+var mesPoissons  = ["scalaire", "clown", "mandarin", "chirurgien"];
 
 // supprime 0 élément à partir de l'index 2, et insère "tambour"
 var enleves = mesPoissons.splice(2, 0, "tambour");
@@ -85,48 +83,23 @@ enleves = mesAnimaux.splice(-2, 1);
 
 // mesAnimaux vaut ["cheval", "chien", "dauphin"]
 // enleves vaut ["chat"]
-</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-array.prototype.splice', 'Array.prototype.splice')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-array.prototype.splice', 'Array.prototype.splice')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.4.4.12', 'Array.prototype.splice')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES3')}}</td>
-   <td>{{Spec2('ES3')}}</td>
-   <td>Définition initiale. Implémentée avec JavaScript 1.2.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Array.splice")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Array.prototype.push", "push")}} / {{jsxref("Array.prototype.pop", "pop")}} pour ajouter/supprimer des éléments en fin de tableau</li>
- <li>{{jsxref("Array.prototype.unshift", "unshift")}} / {{jsxref("Array.prototype.shift", "shift")}} pour ajouter/supprimer des éléments en début de tableau</li>
- <li>{{jsxref("Array.prototype.concat", "concat")}} qui renvoie un nouveau tableau résultat de la concaténation d'un tableau avec un autre tableau ou d'autres valeurs</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                | État                         | Commentaires                                          |
+| ------------------------------------------------------------------------------------------------------------ | ---------------------------- | ----------------------------------------------------- |
+| {{SpecName('ESDraft', '#sec-array.prototype.splice', 'Array.prototype.splice')}} | {{Spec2('ESDraft')}} |                                                       |
+| {{SpecName('ES6', '#sec-array.prototype.splice', 'Array.prototype.splice')}}         | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ES5.1', '#sec-15.4.4.12', 'Array.prototype.splice')}}                     | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES3')}}                                                                                     | {{Spec2('ES3')}}         | Définition initiale. Implémentée avec JavaScript 1.2. |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Array.splice")}}
+
+## Voir aussi
+
+- {{jsxref("Array.prototype.push", "push")}} / {{jsxref("Array.prototype.pop", "pop")}} pour ajouter/supprimer des éléments en fin de tableau
+- {{jsxref("Array.prototype.unshift", "unshift")}} / {{jsxref("Array.prototype.shift", "shift")}} pour ajouter/supprimer des éléments en début de tableau
+- {{jsxref("Array.prototype.concat", "concat")}} qui renvoie un nouveau tableau résultat de la concaténation d'un tableau avec un autre tableau ou d'autres valeurs
diff --git a/files/fr/web/javascript/reference/global_objects/array/tolocalestring/index.md b/files/fr/web/javascript/reference/global_objects/array/tolocalestring/index.md
index 8e790d06f6..22c82a4be5 100644
--- a/files/fr/web/javascript/reference/global_objects/array/tolocalestring/index.md
+++ b/files/fr/web/javascript/reference/global_objects/array/tolocalestring/index.md
@@ -13,57 +13,54 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Array/toLocaleString
 original_slug: Web/JavaScript/Reference/Objets_globaux/Array/toLocaleString
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>toLocaleString()</strong></code> renvoie une chaîne de caractères qui représente les éléments du tableau. Les éléments sont convertis en chaînes de caractères grâce à leurs méthodes <code>toLocaleString</code> et chacune de ces chaînes est séparée des autres avec un séparateur propre à la locale courante (par exemple une virgule ou un point).</p>
+La méthode **`toLocaleString()`** renvoie une chaîne de caractères qui représente les éléments du tableau. Les éléments sont convertis en chaînes de caractères grâce à leurs méthodes `toLocaleString` et chacune de ces chaînes est séparée des autres avec un séparateur propre à la locale courante (par exemple une virgule ou un point).
 
-<div>{{EmbedInteractiveExample("pages/js/array-tolocalestring.html")}}</div>
+{{EmbedInteractiveExample("pages/js/array-tolocalestring.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>arr</var>.toLocaleString();
-<var>arr</var>.toLocaleString(<var>locales</var>);
-<var>arr</var>.toLocaleString(<var>locales</var>, <var>options</var>);
-</pre>
+    arr.toLocaleString();
+    arr.toLocaleString(locales);
+    arr.toLocaleString(locales, options);
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>locales</code> {{optional_inline}}</dt>
- <dd>Une chaine de caractères avec un identifiant de langue BCP 47, ou un tableau de ce type de chaine de caractères. Pour le format général et l'interprétation de l'argument <code>locales</code>. Pour plus de détails quant à la forme et l'interprétation de l'argument <code>locales</code>, on consultera la page {{jsxref("Intl")}}.</dd>
- <dt><code>options</code> {{optional_inline}}</dt>
- <dd>Un objet qui contient des propriétés de configuration. Pour les nombres, consulter {{jsxref("Number.prototype.toLocaleString()")}}, pour les dates, consulter {{jsxref("Date.prototype.toLocaleString()")}}.</dd>
-</dl>
+- `locales` {{optional_inline}}
+  - : Une chaine de caractères avec un identifiant de langue BCP 47, ou un tableau de ce type de chaine de caractères. Pour le format général et l'interprétation de l'argument `locales`. Pour plus de détails quant à la forme et l'interprétation de l'argument `locales`, on consultera la page {{jsxref("Intl")}}.
+- `options` {{optional_inline}}
+  - : Un objet qui contient des propriétés de configuration. Pour les nombres, consulter {{jsxref("Number.prototype.toLocaleString()")}}, pour les dates, consulter {{jsxref("Date.prototype.toLocaleString()")}}.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une chaîne de caractères qui représente les éléments du tableau.</p>
+Une chaîne de caractères qui représente les éléments du tableau.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_les_arguments_locales_et_options">Utiliser les arguments <code>locales</code> et <code>options</code></h3>
+### Utiliser les arguments `locales` et `options`
 
-<p>Les éléments du tableau sont converties en chaînes de caractères via leurs méthodes <code>toLocaleString()</code>.</p>
+Les éléments du tableau sont converties en chaînes de caractères via leurs méthodes `toLocaleString()`.
 
-<ul>
- <li><code>Object</code> : {{jsxref("Object.prototype.toLocaleString()")}}</li>
- <li><code>Number</code> : {{jsxref("Number.prototype.toLocaleString()")}}</li>
- <li><code>Date</code> : {{jsxref("Date.prototype.toLocaleString()")}}</li>
-</ul>
+- `Object` : {{jsxref("Object.prototype.toLocaleString()")}}
+- `Number` : {{jsxref("Number.prototype.toLocaleString()")}}
+- `Date` : {{jsxref("Date.prototype.toLocaleString()")}}
 
-<p>Ici, on voit qu'on affiche le symbole de la devise de la locale pour chacun des éléments (nombres ou chaînes de caractères) du tableau <code>prix</code> :</p>
+Ici, on voit qu'on affiche le symbole de la devise de la locale pour chacun des éléments (nombres ou chaînes de caractères) du tableau `prix` :
 
-<pre class="brush: js">var prix = ["￥7", 500, 8123, 12];
+```js
+var prix = ["￥7", 500, 8123, 12];
 prix.toLocaleString('ja-JP', { style: 'currency', currency: 'JPY' });
 
 // "￥7,￥500,￥8,123,￥12"
-</pre>
+```
 
-<p>Pour plus d'exemples, on peut se référer aux pages {{jsxref("Intl")}}, {{jsxref("NumberFormat")}} et {{jsxref("DateTimeFormat")}}.</p>
+Pour plus d'exemples, on peut se référer aux pages {{jsxref("Intl")}}, {{jsxref("NumberFormat")}} et {{jsxref("DateTimeFormat")}}.
 
-<h2 id="Prothèse_d'émulation_(polyfill)">Prothèse d'émulation (<em>polyfill</em>)</h2>
+## Prothèse d'émulation (_polyfill_)
 
-<pre class="brush: js">// https://tc39.github.io/ecma402/#sup-array.prototype.tolocalestring
+```js
+// https://tc39.github.io/ecma402/#sup-array.prototype.tolocalestring
 if (!Array.prototype.toLocaleString) {
   Object.defineProperty(Array.prototype, 'toLocaleString', {
     value: function(locales, options) {
@@ -75,7 +72,7 @@ if (!Array.prototype.toLocaleString) {
       var a = Object(this);
 
       // 2. Let len be ? ToLength(? Get(A, "length")).
-      var len = a.length &gt;&gt;&gt; 0;
+      var len = a.length >>> 0;
 
       // 3. Let separator be the String value for the
       //    list-separator String appropriate for the
@@ -108,8 +105,8 @@ if (!Array.prototype.toLocaleString) {
       // 8. Let k be 1.
       var k = 1;
 
-      // 9. Repeat, while k &lt; len
-      while (k &lt; len) {
+      // 9. Repeat, while k < len
+      while (k < len) {
         // a. Let S be a String value produced by
         //   concatenating R and separator.
         var s = r + separator;
@@ -144,42 +141,25 @@ if (!Array.prototype.toLocaleString) {
     }
   });
 }
-</pre>
-
-<p>S'il faut absolument prendre en charge les moteurs JavaScript qui ne supportent pas {{jsxref("Object.defineProperty()")}}, mieux vaut ne pas ajouter de prothèse pour les méthodes <code>Array.prototype</code> car elles ne peuvent pas être rendues non-énumérables.</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('ESDraft', '#sec-array.prototype.tolocalestring', 'Array.prototype.toLocaleString')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td>Définition initiale dans ECMAScript 3.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES Int Draft', '#sup-array.prototype.tolocalestring', 'Array.prototype.toLocaleString')}}</td>
-   <td>{{Spec2('ES Int Draft')}}</td>
-   <td>Cette définition remplace la définition fournit dans ECMA-262.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Array.toLocaleString")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Array.prototype.toString()")}}</li>
- <li>{{jsxref("Intl")}}</li>
- <li>{{jsxref("Object.prototype.toLocaleString()")}}</li>
- <li>{{jsxref("Number.prototype.toLocaleString()")}}</li>
- <li>{{jsxref("Date.prototype.toLocaleString()")}}</li>
-</ul>
+```
+
+S'il faut absolument prendre en charge les moteurs JavaScript qui ne supportent pas {{jsxref("Object.defineProperty()")}}, mieux vaut ne pas ajouter de prothèse pour les méthodes `Array.prototype` car elles ne peuvent pas être rendues non-énumérables.
+
+## Spécifications
+
+| Spécification                                                                                                                            | État                             | Commentaires                                                   |
+| ---------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------- | -------------------------------------------------------------- |
+| {{SpecName('ESDraft', '#sec-array.prototype.tolocalestring', 'Array.prototype.toLocaleString')}}         | {{Spec2('ESDraft')}}     | Définition initiale dans ECMAScript 3.                         |
+| {{SpecName('ES Int Draft', '#sup-array.prototype.tolocalestring', 'Array.prototype.toLocaleString')}} | {{Spec2('ES Int Draft')}} | Cette définition remplace la définition fournit dans ECMA-262. |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Array.toLocaleString")}}
+
+## Voir aussi
+
+- {{jsxref("Array.prototype.toString()")}}
+- {{jsxref("Intl")}}
+- {{jsxref("Object.prototype.toLocaleString()")}}
+- {{jsxref("Number.prototype.toLocaleString()")}}
+- {{jsxref("Date.prototype.toLocaleString()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/array/tosource/index.md b/files/fr/web/javascript/reference/global_objects/array/tosource/index.md
index d4c832779b..def1a9901d 100644
--- a/files/fr/web/javascript/reference/global_objects/array/tosource/index.md
+++ b/files/fr/web/javascript/reference/global_objects/array/tosource/index.md
@@ -11,57 +11,55 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Array/toSource
 original_slug: Web/JavaScript/Reference/Objets_globaux/Array/toSource
 ---
-<div>{{JSRef}}{{Non-standard_header}}</div>
+{{JSRef}}{{Non-standard_header}}
 
-<p>La méthode <strong><code>toSource()</code></strong> renvoie une chaine de caractères représentant le code source du tableau.</p>
+La méthode **`toSource()`** renvoie une chaine de caractères représentant le code source du tableau.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>arr</var>.toSource()</pre>
+    arr.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 du tableau.</p>
+Une chaîne de caractères qui représente le code source du tableau.
 
-<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 {{jsxref("Array")}} natif, <code>toSource()</code> renvoie la chaîne de caractères suivante indiquant que le code source n'est pas disponible :
+- Pour l'objet {{jsxref("Array")}} natif, `toSource()` renvoie la chaîne de caractères suivante indiquant que le code source n'est pas disponible :
 
-  <pre class="brush: js">function Array() {
-    [native code]
-}
-</pre>
- </li>
- <li>Pour les instances d'{{jsxref("Array")}}, <code>toSource()</code> renvoie une chaîne représentant le code source.</li>
-</ul>
+  ```js
+    function Array() {
+        [native code]
+    }
+    ```
 
-<p>Cette méthode est habituellement appelée en interne par le moteur JavaScript et n'est pas utilisée explicitement dans du code. Il est cependant possible d'appeler <code>toSource()</code> lors du débogage pour examiner le contenu d'un tableau.</p>
+- Pour les instances d'{{jsxref("Array")}}, `toSource()` renvoie une chaîne représentant le code source.
 
-<h2 id="Exemples">Exemples</h2>
+Cette méthode est habituellement appelée en interne par le moteur JavaScript et n'est pas utilisée explicitement dans du code. Il est cependant possible d'appeler `toSource()` lors du débogage pour examiner le contenu d'un tableau.
 
-<h3 id="Examiner_le_code_source_d'un_tableau">Examiner le code source d'un tableau</h3>
+## Exemples
 
-<p>Pour examiner le code source d'un tableau :</p>
+### Examiner le code source d'un tableau
 
-<pre class="brush: js">var alpha = new Array("a", "b", "c");
+Pour examiner le code source d'un tableau :
+
+```js
+var alpha = new Array("a", "b", "c");
 alpha.toSource();
 // renvoie ["a", "b", "c"]
-</pre>
+```
 
-<h2 id="Spécifications">Spécifications</h2>
+## Spécifications
 
-<p>Ne fait partie d'aucun standard. Implémenté dans JavaScript 1.3.</p>
+Ne fait partie d'aucun standard. Implémenté dans JavaScript 1.3.
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.Array.toSource")}}</p>
+{{Compat("javascript.builtins.Array.toSource")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("Object.prototype.toSource()")}}</li>
- <li>{{jsxref("Array.prototype.toString()")}}</li>
-</ul>
+- {{jsxref("Object.prototype.toSource()")}}
+- {{jsxref("Array.prototype.toString()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/array/tostring/index.md b/files/fr/web/javascript/reference/global_objects/array/tostring/index.md
index 2c9944f5dd..a14b6b7b8d 100644
--- a/files/fr/web/javascript/reference/global_objects/array/tostring/index.md
+++ b/files/fr/web/javascript/reference/global_objects/array/tostring/index.md
@@ -10,69 +10,44 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Array/toString
 original_slug: Web/JavaScript/Reference/Objets_globaux/Array/toString
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>toString()</code></strong> renvoie une chaine de caractères représentant le tableau spécifié et ses éléments.</p>
+La méthode **`toString()`** renvoie une chaine de caractères représentant le tableau spécifié et ses éléments.
 
-<div>{{EmbedInteractiveExample("pages/js/array-tostring.html")}}</div>
+{{EmbedInteractiveExample("pages/js/array-tostring.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>arr</var>.toString()</pre>
+    arr.toString()
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une chaîne de caractères qui représente les éléments du tableau.</p>
+Une chaîne de caractères qui représente les éléments du tableau.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>L'objet {{jsxref("Array")}} redéfinit la méthode <code>toString</code> d'{{jsxref("Object")}}. Pour les objets <code>Array</code>, la méthode <code>toString()</code> concatène les éléments du tableau et renvoie une chaîne contenant chacun des éléments, séparés par des virgules.</p>
+L'objet {{jsxref("Array")}} redéfinit la méthode `toString` d'{{jsxref("Object")}}. Pour les objets `Array`, la méthode `toString()` concatène les éléments du tableau et renvoie une chaîne contenant chacun des éléments, séparés par des virgules.
 
-<p>JavaScript appelle la méthode <code>toString()</code> automatiquement lorsqu'un tableau doit être représenté par une valeur texte ou lorsqu'on fait référence à un tableau dans une concaténation de chaines de caractères.</p>
+JavaScript appelle la méthode `toString()` automatiquement lorsqu'un tableau doit être représenté par une valeur texte ou lorsqu'on fait référence à un tableau dans une concaténation de chaines de caractères.
 
-<h3 id="Sémantique_d'ECMAScript_5">Sémantique d'ECMAScript 5</h3>
+### Sémantique d'ECMAScript 5
 
-<p>À partir de JavaScript 1.8.5 (Firefox 4), et en cohérence avec la 5e édition d'ECMAScript, la méthode <code>toString()</code> est générique et peut être utilisé avec n'importe quel objet. {{jsxref("Object.prototype.toString()")}} sera appelée, et la valeur résultante sera renvoyée.</p>
+À partir de JavaScript 1.8.5 (Firefox 4), et en cohérence avec la 5e édition d'ECMAScript, la méthode `toString()` est générique et peut être utilisé avec n'importe quel objet. {{jsxref("Object.prototype.toString()")}} sera appelée, et la valeur résultante sera renvoyée.
 
-<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.1.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.4.4.2', 'Array.prototype.toString')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-array.prototype.tostring', 'Array.prototype.toString')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-array.prototype.tostring', 'Array.prototype.toString')}}</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.1. |
+| {{SpecName('ES5.1', '#sec-15.4.4.2', 'Array.prototype.toString')}}                         | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-array.prototype.tostring', 'Array.prototype.toString')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-array.prototype.tostring', 'Array.prototype.toString')}} | {{Spec2('ESDraft')}} |                                                       |
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.Array.toString")}}</p>
+{{Compat("javascript.builtins.Array.toString")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("Object.prototype.toSource()")}}</li>
- <li>{{jsxref("Array.prototype.join()")}}</li>
-</ul>
+- {{jsxref("Object.prototype.toSource()")}}
+- {{jsxref("Array.prototype.join()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/array/unshift/index.md b/files/fr/web/javascript/reference/global_objects/array/unshift/index.md
index 77ba3d8eeb..9dc04db950 100644
--- a/files/fr/web/javascript/reference/global_objects/array/unshift/index.md
+++ b/files/fr/web/javascript/reference/global_objects/array/unshift/index.md
@@ -10,36 +10,35 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Array/unshift
 original_slug: Web/JavaScript/Reference/Objets_globaux/Array/unshift
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>unshift()</strong></code> ajoute un ou plusieurs éléments au début d'un tableau et renvoie la nouvelle longueur du tableau.</p>
+La méthode **`unshift()`** ajoute un ou plusieurs éléments au début d'un tableau et renvoie la nouvelle longueur du tableau.
 
-<div>{{EmbedInteractiveExample("pages/js/array-unshift.html")}}</div>
+{{EmbedInteractiveExample("pages/js/array-unshift.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>arr</var>.unshift([<var>élém1</var>[, ...[, <var>élémN</var>]]])</pre>
+    arr.unshift([élém1[, ...[, élémN]]])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>élém<em>N</em> </code></dt>
- <dd>Les éléments que l'on souhaite ajouter en début de tableau.</dd>
-</dl>
+- `élémN`
+  - : Les éléments que l'on souhaite ajouter en début de tableau.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>La nouvelle valeur de la propriété {{jsxref("Array.length", "length")}} du tableau sur lequel a été appelée la méthode.</p>
+La nouvelle valeur de la propriété {{jsxref("Array.length", "length")}} du tableau sur lequel a été appelée la méthode.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La méthode <code>unshift()</code> insère les valeurs renseignées au début d'un objet ressemblant à un tableau.</p>
+La méthode `unshift()` insère les valeurs renseignées au début d'un objet ressemblant à un tableau.
 
-<p><code>unshift()</code> est volontairement générique ; cette méthode peut être {{jsxref("Function.call", "appelée","",1)}} ou {{jsxref("Function.apply", "appliquée","",1)}} sur des objets ressemblant à des tableaux. Les objets qui ne contiennent pas une propriété <code>length</code> reflètant la fin d'une série de propriétés indexées numériquement pourront ne pas avoir un comportement cohérent avec cette méthode.</p>
+`unshift()` est volontairement générique ; cette méthode peut être {{jsxref("Function.call", "appelée","",1)}} ou {{jsxref("Function.apply", "appliquée","",1)}} sur des objets ressemblant à des tableaux. Les objets qui ne contiennent pas une propriété `length` reflètant la fin d'une série de propriétés indexées numériquement pourront ne pas avoir un comportement cohérent avec cette méthode.
 
-<p>Attention, lorsqu'on utilise <code>unshift()</code> avec plusieurs arguments, ceux-ci sont insérés au début du tableau dans l'ordre selon lequel ils sont passés en arguments. Aussi, on n'obtiendra pas le même résultat en appelant <code>unshift()</code> <em>n</em> fois avec 1 arguments ou en appelant <code>unshift()</code> avec <em>n</em> arguments.</p>
+Attention, lorsqu'on utilise `unshift()` avec plusieurs arguments, ceux-ci sont insérés au début du tableau dans l'ordre selon lequel ils sont passés en arguments. Aussi, on n'obtiendra pas le même résultat en appelant `unshift()` _n_ fois avec 1 arguments ou en appelant `unshift()` avec _n_ arguments.
 
-<pre class="brush: js">let arr = [4, 5, 6];
+```js
+let arr = [4, 5, 6];
 
 arr.unshift(1, 2, 3);
 console.table(arr);
@@ -52,11 +51,13 @@ arr2.unshift(2);
 arr2.unshift(3);
 
 console.table(arr2);
-// [3, 2, 1, 4, 5, 6]</pre>
+// [3, 2, 1, 4, 5, 6]
+```
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<pre class="brush:js">var arr = [1, 2];
+```js
+var arr = [1, 2];
 
 arr.unshift(0); // renvoie 3, la nouvelle longueur du tableau
 // arr est [0, 1, 2]
@@ -69,49 +70,24 @@ arr.unshift( [-3] ); // 6
 
 arr.unshift([-7, -6], [-5]); // 8
 // arr est [[-7, -6], [-5], [-3], -2, -1, 0, 1, 2]
-</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.4.4.13', 'Array.prototype.unshift')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-array.prototype.unshift', 'Array.prototype.unshift')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-array.prototype.unshift', 'Array.prototype.unshift')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Array.unshift")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Array.prototype.push()")}}</li>
- <li>{{jsxref("Array.prototype.pop()")}}</li>
- <li>{{jsxref("Array.prototype.shift()")}}</li>
- <li>{{jsxref("Array.prototype.concat()")}}</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.4.4.13', 'Array.prototype.unshift')}}                     | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-array.prototype.unshift', 'Array.prototype.unshift')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-array.prototype.unshift', 'Array.prototype.unshift')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Array.unshift")}}
+
+## Voir aussi
+
+- {{jsxref("Array.prototype.push()")}}
+- {{jsxref("Array.prototype.pop()")}}
+- {{jsxref("Array.prototype.shift()")}}
+- {{jsxref("Array.prototype.concat()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/array/values/index.md b/files/fr/web/javascript/reference/global_objects/array/values/index.md
index 881e840bd4..d7f591029d 100644
--- a/files/fr/web/javascript/reference/global_objects/array/values/index.md
+++ b/files/fr/web/javascript/reference/global_objects/array/values/index.md
@@ -12,13 +12,14 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Array/values
 original_slug: Web/JavaScript/Reference/Objets_globaux/Array/values
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>values()</code></strong> renvoie un nouvel objet <strong><code>Array Iterator</code></strong> qui contient les valeurs pour chaque indice du tableau. Cette méthode est l'implémentation par défaut de <code>Array.prototype[Symbol.Iterator]</code>.</p>
+La méthode **`values()`** renvoie un nouvel objet **`Array Iterator`** qui contient les valeurs pour chaque indice du tableau. Cette méthode est l'implémentation par défaut de `Array.prototype[Symbol.Iterator]`.
 
-<p>{{EmbedInteractiveExample("pages/js/array-values.html")}}</p>
+{{EmbedInteractiveExample("pages/js/array-values.html")}}
 
-<pre class="brush: js">var a = ['t', 'i', 't', 'o', 'u'];
+```js
+var a = ['t', 'i', 't', 'o', 'u'];
 var iterateur = a.values();
 
 console.log(iterateur.next().value); // t
@@ -26,72 +27,57 @@ console.log(iterateur.next().value); // i
 console.log(iterateur.next().value); // t
 console.log(iterateur.next().value); // o
 console.log(iterateur.next().value); // u
-</pre>
+```
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>array</var>.values()</pre>
+    array.values()
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un nouvel objet itérateur sur {{jsxref("Array")}}.</p>
+Un nouvel objet itérateur sur {{jsxref("Array")}}.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Itérer_avec_une_boucle_for...of">Itérer avec une boucle <code>for...of</code></h3>
+### Itérer avec une boucle `for...of`
 
-<pre class="brush: js">var arr = ['w', 'y', 'k', 'o', 'p'];
+```js
+var arr = ['w', 'y', 'k', 'o', 'p'];
 var eArr = arr.values();
 // votre navigateur doit supporter les boucles for..of
 // et les variables définies avec let
 for (let lettre of eArr) {
   console.log(lettre);
 }
-</pre>
+```
 
-<h3 id="Itérer_avec_next()">Itérer avec <code>next()</code></h3>
+### Itérer avec `next()`
 
-<pre class="brush: js">var arr = ['w', 'y', 'k', 'o', 'p'];
+```js
+var arr = ['w', 'y', 'k', 'o', 'p'];
 var eArr = arr.values();
 console.log(eArr.next().value); // w
 console.log(eArr.next().value); // y
 console.log(eArr.next().value); // k
 console.log(eArr.next().value); // o
 console.log(eArr.next().value); // p
-</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-array.prototype.values', 'Array.prototype.values')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-array.prototype.values', 'Array.prototype.values')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Array.values")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Array.prototype.keys()")}}</li>
- <li>{{jsxref("Array.prototype.entries()")}}</li>
- <li>{{jsxref("Array.prototype.forEach()")}}</li>
- <li>{{jsxref("Array.prototype.every()")}}</li>
- <li>{{jsxref("Array.prototype.some()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                | État                         | Commentaires         |
+| ------------------------------------------------------------------------------------------------------------ | ---------------------------- | -------------------- |
+| {{SpecName('ES2015', '#sec-array.prototype.values', 'Array.prototype.values')}}     | {{Spec2('ES2015')}}     | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-array.prototype.values', 'Array.prototype.values')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Array.values")}}
+
+## Voir aussi
+
+- {{jsxref("Array.prototype.keys()")}}
+- {{jsxref("Array.prototype.entries()")}}
+- {{jsxref("Array.prototype.forEach()")}}
+- {{jsxref("Array.prototype.every()")}}
+- {{jsxref("Array.prototype.some()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/arraybuffer/@@species/index.md b/files/fr/web/javascript/reference/global_objects/arraybuffer/@@species/index.md
index d86f413799..7a9b7c3e7e 100644
--- a/files/fr/web/javascript/reference/global_objects/arraybuffer/@@species/index.md
+++ b/files/fr/web/javascript/reference/global_objects/arraybuffer/@@species/index.md
@@ -10,62 +10,48 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/ArrayBuffer/@@species
 original_slug: Web/JavaScript/Reference/Objets_globaux/ArrayBuffer/@@species
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La propriété d'accesseur <code><strong>ArrayBuffer[@@species]</strong></code> renvoie le constructeur <code>ArrayBuffer</code>.</p>
+La propriété d'accesseur **`ArrayBuffer[@@species]`** renvoie le constructeur `ArrayBuffer`.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">ArrayBuffer[Symbol.species]
-</pre>
+    ArrayBuffer[Symbol.species]
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>L'accesseur <code>species</code> renvoie le constructeur par défaut pour les objets <code>ArrayBuffer</code>. Les constructeurs des sous-classes peuvent surcharger ce symbole pour modifier l'affectation du constructeur.</p>
+L'accesseur `species` renvoie le constructeur par défaut pour les objets `ArrayBuffer`. Les constructeurs des sous-classes peuvent surcharger ce symbole pour modifier l'affectation du constructeur.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<p>La propriété <code>species</code> renvoie le constructeur par défaut, soit <code>ArrayBuffer</code> dans le cas des objets <code>ArrayBuffer</code> :</p>
+La propriété `species` renvoie le constructeur par défaut, soit `ArrayBuffer` dans le cas des objets `ArrayBuffer` :
 
-<pre class="brush: js">ArrayBuffer[Symbol.species]; // function ArrayBuffer()</pre>
+```js
+ArrayBuffer[Symbol.species]; // function ArrayBuffer()
+```
 
-<p>Pour un objet dérivé (par exemple une classe sur mesure <code>MonArrayBuffer</code>), le symbole <code>species</code> renverra le constructeur <code>MonArrayBuffer</code>. Il est possible de surcharger ce comportement pour renvoyer le constructeur <code>ArrayBuffer</code> :</p>
+Pour un objet dérivé (par exemple une classe sur mesure `MonArrayBuffer`), le symbole `species` renverra le constructeur `MonArrayBuffer`. Il est possible de surcharger ce comportement pour renvoyer le constructeur `ArrayBuffer` :
 
-<pre class="brush: js">class MonArrayBuffer extends ArrayBuffer {
+```js
+class MonArrayBuffer extends ArrayBuffer {
   // On surcharge species pour renvoyer
   // le constructeur parent ArrayBuffer
   static get [Symbol.species]() { return ArrayBuffer; }
-}</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-get-arraybuffer-@@species', 'get ArrayBuffer [ @@species ]')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-get-arraybuffer-@@species', 'get ArrayBuffer [ @@species ]')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.ArrayBuffer.@@species")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("ArrayBuffer")}}</li>
- <li>{{jsxref("Symbol.species")}}</li>
-</ul>
+}
+```
+
+## Spécifications
+
+| Spécification                                                                                                            | État                         | Commentaires         |
+| ------------------------------------------------------------------------------------------------------------------------ | ---------------------------- | -------------------- |
+| {{SpecName('ES6', '#sec-get-arraybuffer-@@species', 'get ArrayBuffer [ @@species ]')}}     | {{Spec2('ES6')}}         | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-get-arraybuffer-@@species', 'get ArrayBuffer [ @@species ]')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.ArrayBuffer.@@species")}}
+
+## Voir aussi
+
+- {{jsxref("ArrayBuffer")}}
+- {{jsxref("Symbol.species")}}
diff --git a/files/fr/web/javascript/reference/global_objects/arraybuffer/bytelength/index.md b/files/fr/web/javascript/reference/global_objects/arraybuffer/bytelength/index.md
index 8839c62408..5bbc57d6a2 100644
--- a/files/fr/web/javascript/reference/global_objects/arraybuffer/bytelength/index.md
+++ b/files/fr/web/javascript/reference/global_objects/arraybuffer/bytelength/index.md
@@ -10,59 +10,39 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/ArrayBuffer/byteLength
 original_slug: Web/JavaScript/Reference/Objets_globaux/ArrayBuffer/byteLength
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>L'accesseur <code><strong>byteLength</strong></code> est une propriété représentant la longueur d'un {{jsxref("ArrayBuffer")}} en octets.</p>
+L'accesseur **`byteLength`** est une propriété représentant la longueur d'un {{jsxref("ArrayBuffer")}} en octets.
 
-<div>{{EmbedInteractiveExample("pages/js/arraybuffer-bytelength.html")}}</div>
+{{EmbedInteractiveExample("pages/js/arraybuffer-bytelength.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>arr</var>aybuffer.byteLength</pre>
+    arraybuffer.byteLength
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La propriété <code>byteLength</code> est un accesseur dont le mutateur associé vaut <code>undefined</code>. Cela signifie que cette propriété est en lecture seule. La valeur est déterminée lors de la construction du tableau et ne peut pas être changée par la suite. Cette propriété renvoie 0 si ce <code>ArrayBuffer</code> a été détaché.</p>
+La propriété `byteLength` est un accesseur dont le mutateur associé vaut `undefined`. Cela signifie que cette propriété est en lecture seule. La valeur est déterminée lors de la construction du tableau et ne peut pas être changée par la suite. Cette propriété renvoie 0 si ce `ArrayBuffer` a été détaché.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<pre class="brush:js">var buffer = new ArrayBuffer(8);
+```js
+var buffer = new ArrayBuffer(8);
 buffer.byteLength; // 8
-</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">Statut</th>
-   <th scope="col">Commentaires</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('Typed Array')}}</td>
-   <td>{{Spec2('Typed Array')}}</td>
-   <td>Remplacée dans ECMAScript 2015.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES2015', '#sec-get-arraybuffer.prototype.bytelength', 'ArrayBuffer.prototype.byteLength')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale au sein d'un standard ECMA.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-get-arraybuffer.prototype.bytelength', 'ArrayBuffer.prototype.byteLength')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
+| Spécification                                                                                                                                | Statut                           | Commentaires                                    |
+| -------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------- | ----------------------------------------------- |
+| {{SpecName('Typed Array')}}                                                                                                         | {{Spec2('Typed Array')}} | Remplacée dans ECMAScript 2015.                 |
+| {{SpecName('ES2015', '#sec-get-arraybuffer.prototype.bytelength', 'ArrayBuffer.prototype.byteLength')}}     | {{Spec2('ES2015')}}         | Définition initiale au sein d'un standard ECMA. |
+| {{SpecName('ESDraft', '#sec-get-arraybuffer.prototype.bytelength', 'ArrayBuffer.prototype.byteLength')}} | {{Spec2('ESDraft')}}     |                                                 |
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.ArrayBuffer.byteLength")}}</p>
+{{Compat("javascript.builtins.ArrayBuffer.byteLength")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("ArrayBuffer")}}</li>
-</ul>
+- {{jsxref("ArrayBuffer")}}
diff --git a/files/fr/web/javascript/reference/global_objects/arraybuffer/index.md b/files/fr/web/javascript/reference/global_objects/arraybuffer/index.md
index 7c46a860de..df2c70beba 100644
--- a/files/fr/web/javascript/reference/global_objects/arraybuffer/index.md
+++ b/files/fr/web/javascript/reference/global_objects/arraybuffer/index.md
@@ -10,133 +10,105 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/ArrayBuffer
 original_slug: Web/JavaScript/Reference/Objets_globaux/ArrayBuffer
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>L'objet <strong><code>ArrayBuffer</code></strong> est utilisé afin de représenter un tampon (<em>buffer</em>) de données binaires de longueur fixe de façon générique. C'est un tableau d'octets. La manipulation du contenu d'un <code>ArrayBuffer</code> se fait de façon indirecte en créant un <a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/TypedArray">tableau typé</a> ou un objet {{jsxref("DataView")}} qui permet de représenter le tampon dans un format donné qui permet de lire/écrire des contenus dans le tampon de mémoire.</p>
+L'objet **`ArrayBuffer`** est utilisé afin de représenter un tampon (_buffer_) de données binaires de longueur fixe de façon générique. C'est un tableau d'octets. La manipulation du contenu d'un `ArrayBuffer` se fait de façon indirecte en créant un [tableau typé](/fr/docs/Web/JavaScript/Reference/Objets_globaux/TypedArray) ou un objet {{jsxref("DataView")}} qui permet de représenter le tampon dans un format donné qui permet de lire/écrire des contenus dans le tampon de mémoire.
 
-<div>{{EmbedInteractiveExample("pages/js/arraybuffer-constructor.html")}}</div>
+{{EmbedInteractiveExample("pages/js/arraybuffer-constructor.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">new ArrayBuffer(longueur)
-</pre>
+    new ArrayBuffer(longueur)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>longueur</code></dt>
- <dd>La taille, exprimée en octets, du tableau représentant le tampon.</dd>
-</dl>
+- `longueur`
+  - : La taille, exprimée en octets, du tableau représentant le tampon.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un nouvel objet <code>ArrayBuffer</code> de la taille donnée. Ses éléments sont initialisés à 0.</p>
+Un nouvel objet `ArrayBuffer` de la taille donnée. Ses éléments sont initialisés à 0.
 
-<h3 id="Exceptions">Exceptions</h3>
+### Exceptions
 
-<p>Une exception {{jsxref("RangeError")}} est levée lorsque l'argument <code>longueur</code> est supérieur à {{jsxref("Number.MAX_SAFE_INTEGER")}} (soit 2^53) ou s'il est négatif.</p>
+Une exception {{jsxref("RangeError")}} est levée lorsque l'argument `longueur` est supérieur à {{jsxref("Number.MAX_SAFE_INTEGER")}} (soit 2^53) ou s'il est négatif.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Le constructeur <code>ArrayBuffer</code> crée une nouvelle instance d'<code>ArrayBuffer</code> dont la longueur est celle donnée lors de la construction.</p>
+Le constructeur `ArrayBuffer` crée une nouvelle instance d'`ArrayBuffer` dont la longueur est celle donnée lors de la construction.
 
-<h3 id="Obtenir_un_tampon_mémoire_depuis_des_données_existantes">Obtenir un tampon mémoire depuis des données existantes</h3>
+### Obtenir un tampon mémoire depuis des données existantes
 
-<ul>
- <li><a href="/fr/docs/Décoder_encoder_en_base64#Annexe_.3A_D.C3.A9coder_une_cha.C3.AEne_en_base64_en_un_objet_Uint8Array_ou_ArrayBuffer">À partir d'une chaîne de caractères en Base 64</a></li>
- <li><a href="/fr/docs/Web/API/FileReader">À partir d'un fichier local</a></li>
-</ul>
+- [À partir d'une chaîne de caractères en Base 64](/fr/docs/Décoder_encoder_en_base64#Annexe_.3A_D.C3.A9coder_une_cha.C3.AEne_en_base64_en_un_objet_Uint8Array_ou_ArrayBuffer)
+- [À partir d'un fichier local](/fr/docs/Web/API/FileReader)
 
-<h2 id="Propriétés">Propriétés</h2>
+## Propriétés
 
-<dl>
- <dt><code>ArrayBuffer.length</code></dt>
- <dd>La longueur du constructeur <code>ArrayBuffer</code>. Elle vaut 1.</dd>
- <dt>{{jsxref("ArrayBuffer.@@species", "get ArrayBuffer[@@species]")}}</dt>
- <dd>La fonction de construction utilisée pour créer les objets dérivés.</dd>
- <dt>{{jsxref("ArrayBuffer.prototype")}}</dt>
- <dd>Cette propriété permet d'ajouter des propriétés à tous les objets <code>ArrayBuffer</code>.</dd>
-</dl>
+- `ArrayBuffer.length`
+  - : La longueur du constructeur `ArrayBuffer`. Elle vaut 1.
+- {{jsxref("ArrayBuffer.@@species", "get ArrayBuffer[@@species]")}}
+  - : La fonction de construction utilisée pour créer les objets dérivés.
+- {{jsxref("ArrayBuffer.prototype")}}
+  - : Cette propriété permet d'ajouter des propriétés à tous les objets `ArrayBuffer`.
 
-<h2 id="Méthodes">Méthodes</h2>
+## Méthodes
 
-<dl>
- <dt>{{jsxref("ArrayBuffer.isView", "ArrayBuffer.isView(arg)")}}</dt>
- <dd>Cette méthode renvoie <code>true</code> si <code>arg</code> est une des vues sur l'<code>ArrayBuffer</code> telle qu'un <a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/TypedArray">tableau typé</a> ou un objet {{jsxref("DataView")}}, sinon elle renvoie <code>false</code>.</dd>
- <dt>{{jsxref("ArrayBuffer.transfer", "ArrayBuffer.transfer(ancienTampon [, nouvelleLongueur])")}} {{experimental_inline}}</dt>
- <dd>
- <div>Cette méthode renvoie un nouvel objet <code>ArrayBuffer</code> dont le contenu est transféré depuis les données de <code>ancienTampon</code> et qui est ensuite tronqué ou rallongé avec des zéros pour que la taille du nouveau tampon soit <code>nouvelleLongueur</code>.</div>
- </dd>
-</dl>
+- {{jsxref("ArrayBuffer.isView", "ArrayBuffer.isView(arg)")}}
+  - : Cette méthode renvoie `true` si `arg` est une des vues sur l'`ArrayBuffer` telle qu'un [tableau typé](/fr/docs/Web/JavaScript/Reference/Objets_globaux/TypedArray) ou un objet {{jsxref("DataView")}}, sinon elle renvoie `false`.
+- {{jsxref("ArrayBuffer.transfer", "ArrayBuffer.transfer(ancienTampon [, nouvelleLongueur])")}} {{experimental_inline}}
+  - : Cette méthode renvoie un nouvel objet `ArrayBuffer` dont le contenu est transféré depuis les données de `ancienTampon` et qui est ensuite tronqué ou rallongé avec des zéros pour que la taille du nouveau tampon soit `nouvelleLongueur`.
 
-<h2 id="Les_instances_d'ArrayBuffer">Les instances d'<code>ArrayBuffer</code></h2>
+## Les instances d'`ArrayBuffer`
 
-<p>Toutes les instances d'<code>ArrayBuffer</code> héritent de {{jsxref("ArrayBuffer.prototype")}}.</p>
+Toutes les instances d'`ArrayBuffer` héritent de {{jsxref("ArrayBuffer.prototype")}}.
 
-<h3 id="Propriétés_2">Propriétés</h3>
+### Propriétés
 
-<p>{{page('fr/docs/Web/JavaScript/Reference/Objets_globaux/ArrayBuffer/prototype','Propri.C3.A9t.C3.A9s')}}</p>
+{{page('fr/docs/Web/JavaScript/Reference/Objets_globaux/ArrayBuffer/prototype','Propri.C3.A9t.C3.A9s')}}
 
-<h3 id="Méthodes_2">Méthodes</h3>
+### Méthodes
 
-<p>{{page('fr/docs/Web/JavaScript/Reference/Objets_globaux/ArrayBuffer/prototype','M.C3.A9thodes')}}</p>
+{{page('fr/docs/Web/JavaScript/Reference/Objets_globaux/ArrayBuffer/prototype','M.C3.A9thodes')}}
 
-<dl>
- <dt>{{jsxref("ArrayBuffer.slice()")}} {{non-standard_inline}}</dt>
- <dd>Cette méthode fournit la même fonctionnalité que {{jsxref("ArrayBuffer.prototype.slice()")}}.</dd>
-</dl>
+- {{jsxref("ArrayBuffer.slice()")}} {{non-standard_inline}}
+  - : Cette méthode fournit la même fonctionnalité que {{jsxref("ArrayBuffer.prototype.slice()")}}.
 
-<h2 id="Exemple">Exemple</h2>
+## Exemple
 
-<p>Dans cet exemple, on crée un tampon sur 8 octets avec une vue {{jsxref("Int32Array")}} qui fait référence à ce tampon :</p>
+Dans cet exemple, on crée un tampon sur 8 octets avec une vue {{jsxref("Int32Array")}} qui fait référence à ce tampon :
 
-<pre class="brush: js">var tampon = new ArrayBuffer(8);
-var vue    = new Int32Array(tampon);</pre>
+```js
+var tampon = new ArrayBuffer(8);
+var vue    = new Int32Array(tampon);
+```
 
-<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('Typed Array')}}</td>
-   <td>{{Spec2('Typed Array')}}</td>
-   <td>Remplacée par ECMAScript 6.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-arraybuffer-constructor', 'ArrayBuffer')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Définition initiale au sein d'un standard ECMA. <code>new</code> est obligaoire pour utiliser le constructeur.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-arraybuffer-constructor', 'ArrayBuffer')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
+| Spécification                                                                                | État                             | Commentaires                                                                                        |
+| -------------------------------------------------------------------------------------------- | -------------------------------- | --------------------------------------------------------------------------------------------------- |
+| {{SpecName('Typed Array')}}                                                         | {{Spec2('Typed Array')}} | Remplacée par ECMAScript 6.                                                                         |
+| {{SpecName('ES6', '#sec-arraybuffer-constructor', 'ArrayBuffer')}}     | {{Spec2('ES6')}}             | Définition initiale au sein d'un standard ECMA. `new` est obligaoire pour utiliser le constructeur. |
+| {{SpecName('ESDraft', '#sec-arraybuffer-constructor', 'ArrayBuffer')}} | {{Spec2('ESDraft')}}     |                                                                                                     |
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.ArrayBuffer")}}</p>
+{{Compat("javascript.builtins.ArrayBuffer")}}
 
-<h2 id="Notes_de_compatibilité">Notes de compatibilité</h2>
+## Notes de compatibilité
 
-<p>À partir d'ECMAScript 2015 (ES6),<code> ArrayBuffer</code> doit être utilisée avec {{jsxref("Opérateurs/L_opérateur_new", "new")}}. Appeler un constructeur <code>ArrayBuffer</code> comme une fonction, sans <code>new</code>, provoquera une exception {{jsxref("TypeError")}}.</p>
+À partir d'ECMAScript 2015 (ES6),` ArrayBuffer` doit être utilisée avec {{jsxref("Opérateurs/L_opérateur_new", "new")}}. Appeler un constructeur `ArrayBuffer` comme une fonction, sans `new`, provoquera une exception {{jsxref("TypeError")}}.
 
-<pre class="brush: js example-bad">var dv = ArrayBuffer(10);
+```js example-bad
+var dv = ArrayBuffer(10);
 // TypeError: calling a builtin ArrayBuffer constructor
-// without new is forbidden</pre>
+// without new is forbidden
+```
 
-<pre class="brush: js example-good">var dv = new ArrayBuffer(10);</pre>
+```js example-good
+var dv = new ArrayBuffer(10);
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li><a href="/fr/docs/Web/JavaScript/Tableaux_typés">Les tableaux typés JavaScript</a></li>
- <li>{{jsxref("SharedArrayBuffer")}}</li>
-</ul>
+- [Les tableaux typés JavaScript](/fr/docs/Web/JavaScript/Tableaux_typés)
+- {{jsxref("SharedArrayBuffer")}}
diff --git a/files/fr/web/javascript/reference/global_objects/arraybuffer/isview/index.md b/files/fr/web/javascript/reference/global_objects/arraybuffer/isview/index.md
index 876fdd595b..d5224cac4c 100644
--- a/files/fr/web/javascript/reference/global_objects/arraybuffer/isview/index.md
+++ b/files/fr/web/javascript/reference/global_objects/arraybuffer/isview/index.md
@@ -10,30 +10,29 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/ArrayBuffer/isView
 original_slug: Web/JavaScript/Reference/Objets_globaux/ArrayBuffer/isView
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>ArrayBuffer.isView()</strong></code> renvoie <code>true</code> si l'argument passé est une des vues <code>ArrayBuffer</code>, comme par exemple <a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/TypedArray">un tableau typé</a> ou une {{jsxref("DataView")}} ; <code>false</code> sinon.</p>
+La méthode **`ArrayBuffer.isView()`** renvoie `true` si l'argument passé est une des vues `ArrayBuffer`, comme par exemple [un tableau typé](/fr/docs/Web/JavaScript/Reference/Objets_globaux/TypedArray) ou une {{jsxref("DataView")}} ; `false` sinon.
 
-<div>{{EmbedInteractiveExample("pages/js/arraybuffer-isview.html")}}</div>
+{{EmbedInteractiveExample("pages/js/arraybuffer-isview.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">ArrayBuffer.isView(<var>arg</var>)</pre>
+    ArrayBuffer.isView(arg)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>arg</code></dt>
- <dd>L'argument dont on souhaite savoir s'il est une vue.</dd>
-</dl>
+- `arg`
+  - : L'argument dont on souhaite savoir s'il est une vue.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p><code>true</code> si la valeur passée en argument est une des vues du tableau <code>ArrayBuffer</code>, <code>false</code> sinon.</p>
+`true` si la valeur passée en argument est une des vues du tableau `ArrayBuffer`, `false` sinon.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<pre class="brush: js">ArrayBuffer.isView();                    // false
+```js
+ArrayBuffer.isView();                    // false
 ArrayBuffer.isView([]);                  // false
 ArrayBuffer.isView({});                  // false
 ArrayBuffer.isView(null);                // false
@@ -47,41 +46,20 @@ ArrayBuffer.isView(new Int8Array(10).subarray(0, 3)); // true
 var buffer = new ArrayBuffer(2);
 var dv = new DataView(buffer);
 ArrayBuffer.isView(dv); // 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('Typed Array')}}</td>
-   <td>{{Spec2('Typed Array')}}</td>
-   <td>Remplacée par ECMAScript 2015</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES2015', '#sec-arraybuffer.isview', 'ArrayBuffer.isView')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale dans un standard ECMA.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-arraybuffer.isview', 'ArrayBuffer.isView')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.ArrayBuffer.isView")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li><a href="/fr/docs/Web/JavaScript/Tableaux_typés">Les tableaux typés en JavaScript</a></li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                    | État                             | Commentaires                               |
+| ------------------------------------------------------------------------------------------------ | -------------------------------- | ------------------------------------------ |
+| {{SpecName('Typed Array')}}                                                             | {{Spec2('Typed Array')}} | Remplacée par ECMAScript 2015              |
+| {{SpecName('ES2015', '#sec-arraybuffer.isview', 'ArrayBuffer.isView')}} | {{Spec2('ES2015')}}         | Définition initiale dans un standard ECMA. |
+| {{SpecName('ESDraft', '#sec-arraybuffer.isview', 'ArrayBuffer.isView')}} | {{Spec2('ESDraft')}}     |                                            |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.ArrayBuffer.isView")}}
+
+## Voir aussi
+
+- [Les tableaux typés en JavaScript](/fr/docs/Web/JavaScript/Tableaux_typés)
diff --git a/files/fr/web/javascript/reference/global_objects/arraybuffer/slice/index.md b/files/fr/web/javascript/reference/global_objects/arraybuffer/slice/index.md
index e52b95fd86..e776d858bb 100644
--- a/files/fr/web/javascript/reference/global_objects/arraybuffer/slice/index.md
+++ b/files/fr/web/javascript/reference/global_objects/arraybuffer/slice/index.md
@@ -10,73 +10,52 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/ArrayBuffer/slice
 original_slug: Web/JavaScript/Reference/Objets_globaux/ArrayBuffer/slice
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>slice()</strong></code> renvoie un nouvel <code>ArrayBuffer</code> dont le contenu est une copie des octets du <code>ArrayBuffer</code> courant, contenus entre <code>début</code> (compris) et <code>fin</code> (non-compris).</p>
+La méthode **`slice()`** renvoie un nouvel `ArrayBuffer` dont le contenu est une copie des octets du `ArrayBuffer` courant, contenus entre `début` (compris) et `fin` (non-compris).
 
-<div>{{EmbedInteractiveExample("pages/js/arraybuffer-slice.html")}}</div>
+{{EmbedInteractiveExample("pages/js/arraybuffer-slice.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">arraybuffer.slice(début[, fin])</pre>
+    arraybuffer.slice(début[, fin])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>début</code></dt>
- <dd>Indice (numérotation commençant à zéro) de l'octet à partir duquel découper le tableau.</dd>
- <dt><code>fin</code></dt>
- <dd>Indice de l'octet auquel finir la découpe du tableau. Si ce paramètre n'est pas fourni, le nouvel <code>ArrayBuffer</code> contiendra tous les octets entre <code>début </code>et la fin du <code>ArrayBuffer</code> courant. L'intervalle défini par les valeurs <code>début</code> et <code>fin</code> est réduit à un intervalle valide pour le tableau courant si nécessaire. Si la longueur du nouveau tableau <code>ArrayBuffer</code> sera négative, l'intervalle est réduit à zéro.</dd>
-</dl>
+- `début`
+  - : Indice (numérotation commençant à zéro) de l'octet à partir duquel découper le tableau.
+- `fin`
+  - : Indice de l'octet auquel finir la découpe du tableau. Si ce paramètre n'est pas fourni, le nouvel `ArrayBuffer` contiendra tous les octets entre `début `et la fin du `ArrayBuffer` courant. L'intervalle défini par les valeurs `début` et `fin` est réduit à un intervalle valide pour le tableau courant si nécessaire. Si la longueur du nouveau tableau `ArrayBuffer` sera négative, l'intervalle est réduit à zéro.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un nouvel objet <code>ArrayBuffer</code>.</p>
+Un nouvel objet `ArrayBuffer`.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La méthode <code>slice</code> copie les octets contenus jusqu'au (au sens exclusif) paramètre <code>fin</code>. Si le paramètre <code>début </code>ou  <code>fin</code> est négatif, il fera référence à l'indice à partir de la fin du tableau et non pas à l'indice à partir du début du tableau.</p>
+La méthode `slice` copie les octets contenus jusqu'au (au sens exclusif) paramètre `fin`. Si le paramètre `début `ou  `fin` est négatif, il fera référence à l'indice à partir de la fin du tableau et non pas à l'indice à partir du début du tableau.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Copier_un_ArrayBuffer">Copier un <code>ArrayBuffer</code></h3>
+### Copier un `ArrayBuffer`
 
-<pre class="brush: js">var buf1 = new ArrayBuffer(8);
-var buf2 = buf1.slice(0)</pre>
+```js
+var buf1 = new ArrayBuffer(8);
+var buf2 = buf1.slice(0)
+```
 
-<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">Commentaires</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('Typed Array')}}</td>
-   <td>{{Spec2('Typed Array')}}</td>
-   <td>Remplacée dans EMCAScript 6.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-arraybuffer.prototype.slice', 'ArrayBuffer.prototype.slice')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Définition initiale au sein d'un standard ECMA.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-arraybuffer.prototype.slice', 'ArrayBuffer.prototype.slice')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
+| Spécification                                                                                                            | Statut                           | Commentaires                                    |
+| ------------------------------------------------------------------------------------------------------------------------ | -------------------------------- | ----------------------------------------------- |
+| {{SpecName('Typed Array')}}                                                                                     | {{Spec2('Typed Array')}} | Remplacée dans EMCAScript 6.                    |
+| {{SpecName('ES6', '#sec-arraybuffer.prototype.slice', 'ArrayBuffer.prototype.slice')}}     | {{Spec2('ES6')}}             | Définition initiale au sein d'un standard ECMA. |
+| {{SpecName('ESDraft', '#sec-arraybuffer.prototype.slice', 'ArrayBuffer.prototype.slice')}} | {{Spec2('ESDraft')}}     |                                                 |
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.ArrayBuffer.slice")}}</p>
+{{Compat("javascript.builtins.ArrayBuffer.slice")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("ArrayBuffer")}}</li>
-</ul>
+- {{jsxref("ArrayBuffer")}}
diff --git a/files/fr/web/javascript/reference/global_objects/asyncfunction/index.md b/files/fr/web/javascript/reference/global_objects/asyncfunction/index.md
index 778e94b924..53d4c091aa 100644
--- a/files/fr/web/javascript/reference/global_objects/asyncfunction/index.md
+++ b/files/fr/web/javascript/reference/global_objects/asyncfunction/index.md
@@ -9,66 +9,62 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/AsyncFunction
 original_slug: Web/JavaScript/Reference/Objets_globaux/AsyncFunction
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>Le constructeur <code><strong>Async</strong></code><strong><code>Function</code></strong> crée un nouvel objet pour {{jsxref("Instructions/async function", "une fonction asynchrone","",1)}}. En JavaScript, chaque fonction asynchrone est en fait un objet <code>AsyncFunction</code>.</p>
+Le constructeur **`Async`\*\***`Function`\*\* crée un nouvel objet pour {{jsxref("Instructions/async function", "une fonction asynchrone","",1)}}. En JavaScript, chaque fonction asynchrone est en fait un objet `AsyncFunction`.
 
-<p>Attention, <code>AsyncFunction</code> n'est pas un objet global. On peut l'obtenir grâce au code suivant :</p>
+Attention, `AsyncFunction` n'est pas un objet global. On peut l'obtenir grâce au code suivant :
 
-<pre class="brush: js">Object.getPrototypeOf(async function(){}).constructor
-</pre>
+```js
+Object.getPrototypeOf(async function(){}).constructor
+```
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">new AsyncFunction ([<var>arg1</var>[, <var>arg2</var>[, ...<var>argN</var>]],] <var>functionBody</var>)</pre>
+    new AsyncFunction ([arg1[, arg2[, ...argN]],] functionBody)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>arg1, arg2, ... arg<em>N</em></code></dt>
- <dd>Les noms des paramètres passés à la fonction. Chacun doit être une chaîne de caractères qui puisse être un identifiant JavaScript valide ou une liste de telles chaînes séparées par une virgule (ex. "<code>x</code>", "<code>laValeur</code>", ou "<code>a,b</code>").</dd>
- <dt><code>functionBody</code></dt>
- <dd>Une chaîne de caractères qui contient les instructions JavaScript définissant la définition de la fonction.</dd>
-</dl>
+- `arg1, arg2, ... argN`
+  - : Les noms des paramètres passés à la fonction. Chacun doit être une chaîne de caractères qui puisse être un identifiant JavaScript valide ou une liste de telles chaînes séparées par une virgule (ex. "`x`", "`laValeur`", ou "`a,b`").
+- `functionBody`
+  - : Une chaîne de caractères qui contient les instructions JavaScript définissant la définition de la fonction.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Les objets des {{jsxref("Instructions/async_function", "fonctions asynchrones","",1)}} créés avec le constructeur <code>AsyncFunction</code> sont analysés lorsque la fonction est créée. C'est moins efficace que de déclarer une fonction asynchrone avec une {{jsxref("Instructions/async_function", "expression de fonction asynchrone")}} et de l'appeler depuis le code car ces fonctions sont analysées avec le reste du code.</p>
+Les objets des {{jsxref("Instructions/async_function", "fonctions asynchrones","",1)}} créés avec le constructeur `AsyncFunction` sont analysés lorsque la fonction est créée. C'est moins efficace que de déclarer une fonction asynchrone avec une {{jsxref("Instructions/async_function", "expression de fonction asynchrone")}} et de l'appeler depuis le code car ces fonctions sont analysées avec le reste du code.
 
-<p>Tous les arguments passés à la fonction sont traités comme les noms des identifiants des paramètres de la fonction qui sera créée, dans l'ordre dans lequel ils sont passés.</p>
+Tous les arguments passés à la fonction sont traités comme les noms des identifiants des paramètres de la fonction qui sera créée, dans l'ordre dans lequel ils sont passés.
 
-<div class="note">
-<p><strong>Note :</strong> Les fonctions asynchrones créées avec le constructeur <code>AsyncFunction</code> ne créent pas de fermetutres dans leurs contextes de création. Elles sont toujours créées dans la portée globale. Lorsqu'on les exécute, ellee ne pourront accéder qu'à leurs variables locales et aux variables globales, pas à celles qui appartiennent à la portée dans laquelle <code>AsyncFunction</code> a été appelé. On aurait donc un comportement différent  si on appelait {{jsxref("Objets_globaux/eval", "eval")}} avec le code de l'expression de la fonction asynchrone.</p>
-</div>
+> **Note :** Les fonctions asynchrones créées avec le constructeur `AsyncFunction` ne créent pas de fermetutres dans leurs contextes de création. Elles sont toujours créées dans la portée globale. Lorsqu'on les exécute, ellee ne pourront accéder qu'à leurs variables locales et aux variables globales, pas à celles qui appartiennent à la portée dans laquelle `AsyncFunction` a été appelé. On aurait donc un comportement différent  si on appelait {{jsxref("Objets_globaux/eval", "eval")}} avec le code de l'expression de la fonction asynchrone.
 
-<p>Si on appelle <code>AsyncFunction</code> comme une fonction (c'est-à-dire sans <code>new</code>), cela aura le même effet que s'il est appelé comme un constructeur.</p>
+Si on appelle `AsyncFunction` comme une fonction (c'est-à-dire sans `new`), cela aura le même effet que s'il est appelé comme un constructeur.
 
-<h2 id="Propriétés">Propriétés</h2>
+## Propriétés
 
-<dl>
- <dt><code><strong>AsyncFunction.length</strong></code></dt>
- <dd>La propriété de longueur du constructeur <code>AsyncFunction</code> dont la valeur est 1.</dd>
- <dt>{{jsxref("AsyncFunction.prototype")}}</dt>
- <dd>Le prototype permet d'ajouter des propriétés à tous les objets représentant les fonctions asynchrones.</dd>
-</dl>
+- **`AsyncFunction.length`**
+  - : La propriété de longueur du constructeur `AsyncFunction` dont la valeur est 1.
+- {{jsxref("AsyncFunction.prototype")}}
+  - : Le prototype permet d'ajouter des propriétés à tous les objets représentant les fonctions asynchrones.
 
-<h2 id="Prototype_de_l'objet_AsyncFunction">Prototype de l'objet <code>AsyncFunction</code></h2>
+## Prototype de l'objet `AsyncFunction`
 
-<h3 id="Propriétés_2">Propriétés</h3>
+### Propriétés
 
-<div>{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/AsyncFunction/prototype', 'Propriétés')}}</div>
+{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/AsyncFunction/prototype', 'Propriétés')}}
 
-<h2 id="Instances_AsyncFunction">Instances <code>AsyncFunction</code></h2>
+## Instances `AsyncFunction`
 
-<p>Les instances d'<code>AsyncFunction</code> héritent des méthodes et des propriétés de {{jsxref("AsyncFunction.prototype")}}. Comme avec les autres constructeurs, on peut changer l'objet prototype du constructeur afin de modifier l'ensemble des instances <code>AsyncFunction</code>.</p>
+Les instances d'`AsyncFunction` héritent des méthodes et des propriétés de {{jsxref("AsyncFunction.prototype")}}. Comme avec les autres constructeurs, on peut changer l'objet prototype du constructeur afin de modifier l'ensemble des instances `AsyncFunction`.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Créer_une_fonction_asynchrone_avec_un_constructeur_AsyncFunction">Créer une fonction asynchrone avec un constructeur <code>AsyncFunction</code></h3>
+### Créer une fonction asynchrone avec un constructeur `AsyncFunction`
 
-<pre class="brush: js">function resolveAfter2Seconds(x) {
-  return new Promise(resolve =&gt; {
-    setTimeout(() =&gt; {
+```js
+function resolveAfter2Seconds(x) {
+  return new Promise(resolve => {
+    setTimeout(() => {
       resolve(x);
     }, 2000);
   });
@@ -78,41 +74,26 @@ var AsyncFunction = Object.getPrototypeOf(async function(){}).constructor
 var a = new AsyncFunction("a",
                           "b",
                           "return await resolveAfter2Seconds(a) + await resolveAfter2Seconds(b);");
-a(10, 20).then(v =&gt; {
+a(10, 20).then(v => {
   console.log(v); // affiche 30 après 4 secondes
 });
-</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-async-function-objects', 'AsyncFunction object')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td>Définition initiale dans ES2017.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.AsyncFunction")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>Instruction {{jsxref("Instructions/async_function", "async function")}}</li>
- <li>Expression {{jsxref("Opérateurs/async_function","async function")}}</li>
- <li>{{jsxref("Objets_globaux/Function", "Function")}}</li>
- <li>Instruction {{jsxref("Instructions/function", "function")}}</li>
- <li>Expression {{jsxref("Opérateurs/function", "function")}}</li>
- <li>{{jsxref("Fonctions", "Fonctions et portées des fonctions", "", 1)}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                            | État                         | Commentaires                     |
+| -------------------------------------------------------------------------------------------------------- | ---------------------------- | -------------------------------- |
+| {{SpecName('ESDraft', '#sec-async-function-objects', 'AsyncFunction object')}} | {{Spec2('ESDraft')}} | Définition initiale dans ES2017. |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.AsyncFunction")}}
+
+## Voir aussi
+
+- Instruction {{jsxref("Instructions/async_function", "async function")}}
+- Expression {{jsxref("Opérateurs/async_function","async function")}}
+- {{jsxref("Objets_globaux/Function", "Function")}}
+- Instruction {{jsxref("Instructions/function", "function")}}
+- Expression {{jsxref("Opérateurs/function", "function")}}
+- {{jsxref("Fonctions", "Fonctions et portées des fonctions", "", 1)}}
diff --git a/files/fr/web/javascript/reference/global_objects/atomics/add/index.md b/files/fr/web/javascript/reference/global_objects/atomics/add/index.md
index d09496b255..9967dde934 100644
--- a/files/fr/web/javascript/reference/global_objects/atomics/add/index.md
+++ b/files/fr/web/javascript/reference/global_objects/atomics/add/index.md
@@ -10,72 +10,56 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Atomics/add
 original_slug: Web/JavaScript/Reference/Objets_globaux/Atomics/add
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode statique <code><strong>Atomics</strong></code><strong><code>.add()</code></strong> ajoute une valeur donnée à un élément du tableau à une position donnée. Elle renvoie l'ancienne valeur qui était contenue à cet emplacement. Cette opération atomique garantit qu'aucune autre opération d'écriture n'est appliquée tant que la valeur modifiée n'est pas écrite.</p>
+La méthode statique **`Atomics`\*\***`.add()`\*\* ajoute une valeur donnée à un élément du tableau à une position donnée. Elle renvoie l'ancienne valeur qui était contenue à cet emplacement. Cette opération atomique garantit qu'aucune autre opération d'écriture n'est appliquée tant que la valeur modifiée n'est pas écrite.
 
-<div>{{EmbedInteractiveExample("pages/js/atomics-add.html")}}</div>
+{{EmbedInteractiveExample("pages/js/atomics-add.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">Atomics.add(typedArray, index, valeur)
-</pre>
+    Atomics.add(typedArray, index, valeur)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>typedArray</code></dt>
- <dd>Un tableau typé entier partagé parmi {{jsxref("Int8Array")}}, {{jsxref("Uint8Array")}}, {{jsxref("Int16Array")}}, {{jsxref("Uint16Array")}}, {{jsxref("Int32Array")}} ou {{jsxref("Uint32Array")}}.</dd>
- <dt><code>index</code></dt>
- <dd>La position du tableau <code>typedArray</code> auquel on souhaite ajouter une <code>valeur</code>.</dd>
- <dt><code>valeur</code></dt>
- <dd>La valeur à ajouter.</dd>
-</dl>
+- `typedArray`
+  - : Un tableau typé entier partagé parmi {{jsxref("Int8Array")}}, {{jsxref("Uint8Array")}}, {{jsxref("Int16Array")}}, {{jsxref("Uint16Array")}}, {{jsxref("Int32Array")}} ou {{jsxref("Uint32Array")}}.
+- `index`
+  - : La position du tableau `typedArray` auquel on souhaite ajouter une `valeur`.
+- `valeur`
+  - : La valeur à ajouter.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>L'ancienne valeur qui était contenue à (<code>typedArray[index]</code>).</p>
+L'ancienne valeur qui était contenue à (`typedArray[index]`).
 
-<h3 id="Exceptions_levées">Exceptions levées</h3>
+### Exceptions levées
 
-<ul>
- <li>Cette méthode lève {{jsxref("TypeError")}} si le type de <code>typedArray</code> n'est pas un des types entiers autorisés.</li>
- <li>Cette méthode lève {{jsxref("TypeError")}} si <code>typedArray</code> n'est pas tableau typé partagé.</li>
- <li>Cette méthode lève {{jsxref("RangeError")}} si <code>index</code> est en dehors des limites de <code>typedArray</code>.</li>
-</ul>
+- Cette méthode lève {{jsxref("TypeError")}} si le type de `typedArray` n'est pas un des types entiers autorisés.
+- Cette méthode lève {{jsxref("TypeError")}} si `typedArray` n'est pas tableau typé partagé.
+- Cette méthode lève {{jsxref("RangeError")}} si `index` est en dehors des limites de `typedArray`.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<pre class="brush: js">var sab = new SharedArrayBuffer(1024);
+```js
+var sab = new SharedArrayBuffer(1024);
 var ta = new Uint8Array(sab);
 
 Atomics.add(ta, 0, 12); // renvoie 0, l'ancienne valeur
-Atomics.load(ta, 0);    // 12</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-atomics.add', 'Atomics.add')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td>Définition initiale avec ES2017.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Atomics.add")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Atomics")}}</li>
- <li>{{jsxref("Atomics.sub()")}}</li>
-</ul>
+Atomics.load(ta, 0);    // 12
+```
+
+## Spécifications
+
+| Spécification                                                                | État                         | Commentaires                     |
+| ---------------------------------------------------------------------------- | ---------------------------- | -------------------------------- |
+| {{SpecName('ESDraft', '#sec-atomics.add', 'Atomics.add')}} | {{Spec2('ESDraft')}} | Définition initiale avec ES2017. |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Atomics.add")}}
+
+## Voir aussi
+
+- {{jsxref("Atomics")}}
+- {{jsxref("Atomics.sub()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/atomics/and/index.md b/files/fr/web/javascript/reference/global_objects/atomics/and/index.md
index 80e18842ac..d3fba9dc8f 100644
--- a/files/fr/web/javascript/reference/global_objects/atomics/and/index.md
+++ b/files/fr/web/javascript/reference/global_objects/atomics/and/index.md
@@ -10,118 +10,76 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Atomics/and
 original_slug: Web/JavaScript/Reference/Objets_globaux/Atomics/and
 ---
-<div>{{JSRef}}</div>
-
-<p>La méthode statique <code><strong>Atomics</strong></code><strong><code>.and()</code></strong> calcule un ET binaire avec une valeur donnée, à un emplacement donné du tableau. Elle renvoie l'ancienne valeur qui était contenue à cet emplacement. Cette opération atomique garantit qu'aucune autre opération d'écriture n'est appliquée tant que la valeur modifiée n'est pas écrite.</p>
-
-<div>{{EmbedInteractiveExample("pages/js/atomics-and.html")}}</div>
-
-<h2 id="Syntaxe">Syntaxe</h2>
-
-<pre class="syntaxbox">Atomics.and(typedArray, index, valeur)
-</pre>
-
-<h3 id="Paramètres">Paramètres</h3>
-
-<dl>
- <dt><code>typedArray</code></dt>
- <dd>Un tableau typé entier partagé parmi {{jsxref("Int8Array")}}, {{jsxref("Uint8Array")}}, {{jsxref("Int16Array")}}, {{jsxref("Uint16Array")}}, {{jsxref("Int32Array")}} ou {{jsxref("Uint32Array")}}.</dd>
- <dt><code>index</code></dt>
- <dd>La position dans <code>typedArray</code> où calculer le ET binaire.</dd>
- <dt><code>valeur</code></dt>
- <dd>Le nombre avec lequel on souhaite calculer le ET binaire.</dd>
-</dl>
-
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
-
-<p>L'ancienne valeur qui était contenue à (<code>typedArray[index]</code>).</p>
-
-<h3 id="Exceptions_levée">Exceptions levée</h3>
-
-<ul>
- <li>Cette méthode lève {{jsxref("TypeError")}} si le type de <code>typedArray</code> n'est pas un des types entiers autorisés.</li>
- <li>Cette méthode lève {{jsxref("TypeError")}} si <code>typedArray</code> n'est pas tableau typé partagé.</li>
- <li>Cette méthode lève {{jsxref("RangeError")}} si <code>index</code> est en dehors des limites de <code>typedArray</code>.</li>
-</ul>
-
-<h2 id="Description">Description</h2>
-
-<p>Un ET binaire fournit la valeur 1 uniquement si <code>a</code> et <code>b</code> valent 1. La table de vérité pour l'opération ET est :</p>
-
-<table class="standard-table">
- <thead>
-  <tr>
-   <th><code>a</code></th>
-   <th><code>b</code></th>
-   <th><code>a &amp; b</code></th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td>0</td>
-   <td>0</td>
-   <td>0</td>
-  </tr>
-  <tr>
-   <td>0</td>
-   <td>1</td>
-   <td>0</td>
-  </tr>
-  <tr>
-   <td>1</td>
-   <td>0</td>
-   <td>0</td>
-  </tr>
-  <tr>
-   <td>1</td>
-   <td>1</td>
-   <td>1</td>
-  </tr>
- </tbody>
-</table>
-
-<p>Ainsi, si on calcule le ET binaire de 5 et 1 avec l'instruction <code>5 &amp; 1</code>, cela fournira la valeur <code>0001</code>, qui correspond à 1 en notation décimale.</p>
-
-<pre>5  0101
-1  0001
-   ----
-1  0001</pre>
-
-<h2 id="Exemples">Exemples</h2>
-
-<pre class="brush: js">var sab = new SharedArrayBuffer(1024);
+{{JSRef}}
+
+La méthode statique **`Atomics`\*\***`.and()`\*\* calcule un ET binaire avec une valeur donnée, à un emplacement donné du tableau. Elle renvoie l'ancienne valeur qui était contenue à cet emplacement. Cette opération atomique garantit qu'aucune autre opération d'écriture n'est appliquée tant que la valeur modifiée n'est pas écrite.
+
+{{EmbedInteractiveExample("pages/js/atomics-and.html")}}
+
+## Syntaxe
+
+    Atomics.and(typedArray, index, valeur)
+
+### Paramètres
+
+- `typedArray`
+  - : Un tableau typé entier partagé parmi {{jsxref("Int8Array")}}, {{jsxref("Uint8Array")}}, {{jsxref("Int16Array")}}, {{jsxref("Uint16Array")}}, {{jsxref("Int32Array")}} ou {{jsxref("Uint32Array")}}.
+- `index`
+  - : La position dans `typedArray` où calculer le ET binaire.
+- `valeur`
+  - : Le nombre avec lequel on souhaite calculer le ET binaire.
+
+### Valeur de retour
+
+L'ancienne valeur qui était contenue à (`typedArray[index]`).
+
+### Exceptions levée
+
+- Cette méthode lève {{jsxref("TypeError")}} si le type de `typedArray` n'est pas un des types entiers autorisés.
+- Cette méthode lève {{jsxref("TypeError")}} si `typedArray` n'est pas tableau typé partagé.
+- Cette méthode lève {{jsxref("RangeError")}} si `index` est en dehors des limites de `typedArray`.
+
+## Description
+
+Un ET binaire fournit la valeur 1 uniquement si `a` et `b` valent 1. La table de vérité pour l'opération ET est :
+
+| `a` | `b` | `a & b` |
+| --- | --- | ------- |
+| 0   | 0   | 0       |
+| 0   | 1   | 0       |
+| 1   | 0   | 0       |
+| 1   | 1   | 1       |
+
+Ainsi, si on calcule le ET binaire de 5 et 1 avec l'instruction `5 & 1`, cela fournira la valeur `0001`, qui correspond à 1 en notation décimale.
+
+    5  0101
+    1  0001
+       ----
+    1  0001
+
+## Exemples
+
+```js
+var sab = new SharedArrayBuffer(1024);
 var ta = new Uint8Array(sab);
 ta[0] = 5;
 
 Atomics.and(ta, 0, 1); // renvoie 0, l'ancienne valeur
 Atomics.load(ta, 0);   // 1
-</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-atomics.and', 'Atomics.and')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td>Définition initiale avec ES2017.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Atomics.and")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Atomics")}}</li>
- <li>{{jsxref("Atomics.or()")}}</li>
- <li>{{jsxref("Atomics.xor()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                | État                         | Commentaires                     |
+| ---------------------------------------------------------------------------- | ---------------------------- | -------------------------------- |
+| {{SpecName('ESDraft', '#sec-atomics.and', 'Atomics.and')}} | {{Spec2('ESDraft')}} | Définition initiale avec ES2017. |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Atomics.and")}}
+
+## Voir aussi
+
+- {{jsxref("Atomics")}}
+- {{jsxref("Atomics.or()")}}
+- {{jsxref("Atomics.xor()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/atomics/compareexchange/index.md b/files/fr/web/javascript/reference/global_objects/atomics/compareexchange/index.md
index add0ccdd87..e606b19bd4 100644
--- a/files/fr/web/javascript/reference/global_objects/atomics/compareexchange/index.md
+++ b/files/fr/web/javascript/reference/global_objects/atomics/compareexchange/index.md
@@ -10,75 +10,59 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Atomics/compareExchange
 original_slug: Web/JavaScript/Reference/Objets_globaux/Atomics/compareExchange
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode statique <code><strong>Atomics</strong></code><strong><code>.compareExchange()</code></strong> échange une valeur d'un tableau à un emplacement donné si la valeur qui était dans le tableau correspond à une valeur donnée. Cette méthode renvoie l'ancienne valeur à cet emplacement, qu'il y ait eu remplacement ou non. Cette opération atomique garantit qu'aucune autre opération d'écriture n'est appliquée tant que la valeur modifiée n'est pas écrite.</p>
+La méthode statique **`Atomics`\*\***`.compareExchange()`\*\* échange une valeur d'un tableau à un emplacement donné si la valeur qui était dans le tableau correspond à une valeur donnée. Cette méthode renvoie l'ancienne valeur à cet emplacement, qu'il y ait eu remplacement ou non. Cette opération atomique garantit qu'aucune autre opération d'écriture n'est appliquée tant que la valeur modifiée n'est pas écrite.
 
-<div>{{EmbedInteractiveExample("pages/js/atomics-compareexchange.html")}}</div>
+{{EmbedInteractiveExample("pages/js/atomics-compareexchange.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">Atomics.compareExchange(typedArray, index, valeurAttendue, valeurRemplacement)
-</pre>
+    Atomics.compareExchange(typedArray, index, valeurAttendue, valeurRemplacement)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>typedArray</code></dt>
- <dd>Un tableau typé entier partagé parmi {{jsxref("Int8Array")}}, {{jsxref("Uint8Array")}}, {{jsxref("Int16Array")}}, {{jsxref("Uint16Array")}}, {{jsxref("Int32Array")}} ou {{jsxref("Uint32Array")}}.</dd>
- <dt><code>index</code></dt>
- <dd>La position du tableau <code>typedArray</code> à laquelle on veut échanger les valeurs.</dd>
- <dt><code>valeurAttendue</code></dt>
- <dd>La valeur avec laquelle on teste l'égalité.</dd>
- <dt><code>valeurRemplacement</code></dt>
- <dd>Le nombre qu'on souhaite placer dans le tableau si l'ancienne valeur est égale avec <code>valeurAttendue</code>.</dd>
-</dl>
+- `typedArray`
+  - : Un tableau typé entier partagé parmi {{jsxref("Int8Array")}}, {{jsxref("Uint8Array")}}, {{jsxref("Int16Array")}}, {{jsxref("Uint16Array")}}, {{jsxref("Int32Array")}} ou {{jsxref("Uint32Array")}}.
+- `index`
+  - : La position du tableau `typedArray` à laquelle on veut échanger les valeurs.
+- `valeurAttendue`
+  - : La valeur avec laquelle on teste l'égalité.
+- `valeurRemplacement`
+  - : Le nombre qu'on souhaite placer dans le tableau si l'ancienne valeur est égale avec `valeurAttendue`.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>L'ancienne valeur présente à <code>typedArray[index]</code>.</p>
+L'ancienne valeur présente à `typedArray[index]`.
 
-<h3 id="Exceptions_levées">Exceptions levées</h3>
+### Exceptions levées
 
-<ul>
- <li>Cette méthode lève {{jsxref("TypeError")}} si le type de <code>typedArray</code> n'est pas un des types entiers autorisés.</li>
- <li>Cette méthode lève {{jsxref("TypeError")}} si <code>typedArray</code> n'est pas tableau typé partagé.</li>
- <li>Cette méthode lève {{jsxref("RangeError")}} si <code>index</code> est en dehors des limites de <code>typedArray</code>.</li>
-</ul>
+- Cette méthode lève {{jsxref("TypeError")}} si le type de `typedArray` n'est pas un des types entiers autorisés.
+- Cette méthode lève {{jsxref("TypeError")}} si `typedArray` n'est pas tableau typé partagé.
+- Cette méthode lève {{jsxref("RangeError")}} si `index` est en dehors des limites de `typedArray`.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<pre class="brush: js">var sab = new SharedArrayBuffer(1024);
+```js
+var sab = new SharedArrayBuffer(1024);
 var ta = new Uint8Array(sab);
 ta[0] = 7;
 
 Atomics.compareExchange(ta, 0, 7, 12); // renvoie 7, l'ancienne valeur
-Atomics.load(ta, 0);                   // 12</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-atomics.compareexchange', 'Atomics.compareExchange')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td>Définition initiale avec ES2017.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Atomics.compareExchange")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Atomics")}}</li>
- <li>{{jsxref("Atomics.exchange()")}}</li>
-</ul>
+Atomics.load(ta, 0);                   // 12
+```
+
+## Spécifications
+
+| Spécification                                                                                                | État                         | Commentaires                     |
+| ------------------------------------------------------------------------------------------------------------ | ---------------------------- | -------------------------------- |
+| {{SpecName('ESDraft', '#sec-atomics.compareexchange', 'Atomics.compareExchange')}} | {{Spec2('ESDraft')}} | Définition initiale avec ES2017. |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Atomics.compareExchange")}}
+
+## Voir aussi
+
+- {{jsxref("Atomics")}}
+- {{jsxref("Atomics.exchange()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/atomics/exchange/index.md b/files/fr/web/javascript/reference/global_objects/atomics/exchange/index.md
index 7a01cb04b1..05b78da455 100644
--- a/files/fr/web/javascript/reference/global_objects/atomics/exchange/index.md
+++ b/files/fr/web/javascript/reference/global_objects/atomics/exchange/index.md
@@ -10,74 +10,56 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Atomics/exchange
 original_slug: Web/JavaScript/Reference/Objets_globaux/Atomics/exchange
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode statique <code><strong>Atomics</strong></code><strong><code>.exchange()</code></strong> permet d'enregistrer une valeur à une position donnée d'un tableau et de renvoyer l'ancienne valeur qui était contenue dans le tableau. Cette opération atomique garantit qu'aucune autre opération d'écriture n'est appliquée tant que la valeur modifiée n'est pas écrite.</p>
+La méthode statique **`Atomics`\*\***`.exchange()`\*\* permet d'enregistrer une valeur à une position donnée d'un tableau et de renvoyer l'ancienne valeur qui était contenue dans le tableau. Cette opération atomique garantit qu'aucune autre opération d'écriture n'est appliquée tant que la valeur modifiée n'est pas écrite.
 
-<div>{{EmbedInteractiveExample("pages/js/atomics-exchange.html")}}</div>
+{{EmbedInteractiveExample("pages/js/atomics-exchange.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">Atomics.exchange(typedArray, index, valeur)
-</pre>
+    Atomics.exchange(typedArray, index, valeur)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>typedArray</code></dt>
- <dd>Un tableau typé entier partagé parmi {{jsxref("Int8Array")}}, {{jsxref("Uint8Array")}}, {{jsxref("Int16Array")}}, {{jsxref("Uint16Array")}}, {{jsxref("Int32Array")}} ou {{jsxref("Uint32Array")}}.</dd>
- <dt><code>index</code></dt>
- <dd>La position dans le tableau <code>typedArray</code> à laquelle on veut placer <code>valeur</code>.</dd>
- <dt><code>valeur</code></dt>
- <dd>Le nombre qu'on souhaite échanger.</dd>
-</dl>
+- `typedArray`
+  - : Un tableau typé entier partagé parmi {{jsxref("Int8Array")}}, {{jsxref("Uint8Array")}}, {{jsxref("Int16Array")}}, {{jsxref("Uint16Array")}}, {{jsxref("Int32Array")}} ou {{jsxref("Uint32Array")}}.
+- `index`
+  - : La position dans le tableau `typedArray` à laquelle on veut placer `valeur`.
+- `valeur`
+  - : Le nombre qu'on souhaite échanger.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>L'ancienne valeur qui était contenue à (<code>typedArray[index]</code>).</p>
+L'ancienne valeur qui était contenue à (`typedArray[index]`).
 
-<h3 id="Exceptions_levées">Exceptions levées</h3>
+### Exceptions levées
 
-<ul>
- <li>Cette méthode lève {{jsxref("TypeError")}} si le type de <code>typedArray</code> n'est pas un des types entiers autorisés.</li>
- <li>Cette méthode lève {{jsxref("TypeError")}} si <code>typedArray</code> n'est pas tableau typé partagé.</li>
- <li>Cette méthode lève {{jsxref("RangeError")}} si <code>index</code> est en dehors des limites de <code>typedArray</code>.</li>
-</ul>
+- Cette méthode lève {{jsxref("TypeError")}} si le type de `typedArray` n'est pas un des types entiers autorisés.
+- Cette méthode lève {{jsxref("TypeError")}} si `typedArray` n'est pas tableau typé partagé.
+- Cette méthode lève {{jsxref("RangeError")}} si `index` est en dehors des limites de `typedArray`.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<pre class="brush: js">var sab = new SharedArrayBuffer(1024);
+```js
+var sab = new SharedArrayBuffer(1024);
 var ta = new Uint8Array(sab);
 
 Atomics.exchange(ta, 0, 12);  // renvoie 0, l'ancienne valeur
-Atomics.load(ta, 0);          // 12</pre>
+Atomics.load(ta, 0);          // 12
+```
 
-<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">Commentaires</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-atomics.exchange', 'Atomics.exchange')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td>Définition initiale avec ES2017.</td>
-  </tr>
- </tbody>
-</table>
+| Spécification                                                                                | Statut                       | Commentaires                     |
+| -------------------------------------------------------------------------------------------- | ---------------------------- | -------------------------------- |
+| {{SpecName('ESDraft', '#sec-atomics.exchange', 'Atomics.exchange')}} | {{Spec2('ESDraft')}} | Définition initiale avec ES2017. |
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
+{{Compat("javascript.builtins.Atomics.exchange")}}
 
+## Voir aussi
 
-<p>{{Compat("javascript.builtins.Atomics.exchange")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Atomics")}}</li>
- <li>{{jsxref("Atomics.compareExchange()")}}</li>
-</ul>
+- {{jsxref("Atomics")}}
+- {{jsxref("Atomics.compareExchange()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/atomics/index.md b/files/fr/web/javascript/reference/global_objects/atomics/index.md
index b358b66964..c9d61aaa85 100644
--- a/files/fr/web/javascript/reference/global_objects/atomics/index.md
+++ b/files/fr/web/javascript/reference/global_objects/atomics/index.md
@@ -8,107 +8,78 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Atomics
 original_slug: Web/JavaScript/Reference/Objets_globaux/Atomics
 ---
-<div>{{JSRef}}</div>
-
-<p>L'objet <strong><code>Atomics</code></strong> fournit des opérations atomiques sous la forme de méthodes statiques. Celles-ci sont utilisées avec les objets {{jsxref("SharedArrayBuffer")}}.</p>
-
-<p>Les opérations atomiques sont installées sur un module <code>Atomics</code>. À la différence des autres objets globaux, <code>Atomics</code> n'est pas un constructeur. Pour cette raison, il ne peut être utilisé avec l'opérateur {{jsxref("Opérateurs/L_opérateur_new")}} et il ne peut pas être appelé comme une fonction. Les propriétés et les méthodes d'<code>Atomics</code> sont statiques (<code>Atomics</code> fonctionne ainsi comme l'objet {{jsxref("Math")}}).</p>
-
-<h2 id="Propriétés">Propriétés</h2>
-
-<dl>
- <dt><code>Atomics[Symbol.toStringTag]</code></dt>
- <dd>
- <p>La valeur de cette propriété vaut <code>"Atomics"</code>.</p>
- </dd>
-</dl>
-
-<h2 id="Méthodes">Méthodes</h2>
-
-<h3 id="Opérations_atomiques">Opérations atomiques</h3>
-
-<p>Lorsque la mémoire est partagée, plusieurs <em>threads</em> peuvent lire et écrire sur les mêmes données en mémoire. Les opérations atomiques permettent de s'assurer que des valeurs prévisibles sont écrites et lues, que les opérations sont finies avant que la prochaine débute et que les opérations ne sont pas interrompues.</p>
-
-<dl>
- <dt>{{jsxref("Atomics.add()")}}</dt>
- <dd>Cette méthode ajoute la valeur fournie à la position indiquée dans le tableau. Elle renvoie l'ancienne valeur qui était à cette position.</dd>
- <dt>{{jsxref("Atomics.and()")}}</dt>
- <dd>Cette méthode calcule un ET binaire sur la position indiquée dans le tableau. Elle renvoie l'ancienne valeur qui était à cette position.</dd>
- <dt>{{jsxref("Atomics.compareExchange()")}}</dt>
- <dd>Cette méthode stocke la valeur fournie à la position indiquée dans le tableau si elle est égale à une valeur donnée. Elle renvoie l'ancienne valeur.</dd>
- <dt>{{jsxref("Atomics.exchange()")}}</dt>
- <dd>Cette méthode stocke la valeur fournie à la position indiquée dans le tableau. Elle renvoie l'ancienne valeur.</dd>
- <dt>{{jsxref("Atomics.load()")}}</dt>
- <dd>Cette méthode renvoie la valeur à la position indiquée dans le tableau.</dd>
- <dt>{{jsxref("Atomics.or()")}}</dt>
- <dd>Cette méthode calcule un OU binaire entre la valeur fournie et la position indiquée dans le tableau. Elle renvoie l'ancienne valeur qui était à cette position.</dd>
- <dt>{{jsxref("Atomics.store()")}}</dt>
- <dd>Cette méthode stocke une valeur à une position indiquée dans le tableau. Elle renvoie la valeur.</dd>
- <dt>{{jsxref("Atomics.sub()")}}</dt>
- <dd>Cette méthode soustrait la valeur fournie à la position indiquée dans le tableau. Elle renvoie l'ancienne valeur qui était contenue à cette position.</dd>
- <dt>{{jsxref("Atomics.xor()")}}</dt>
- <dd>Cette méthode calcule un OU exclusif binaire sur une position donnée dans le tableau. Elle renvoie l'ancienne valeur qui était à cette position.</dd>
-</dl>
-
-<h3 id="Attente_et_notification_(wait_et_notify)">Attente et notification (<code>wait</code> et <code>notify</code>)</h3>
-
-<p>Le méthodes <code>wait</code>() et <code>notify()</code> sont basées sur les <em>futex</em> Linux (selon le vocabulaire employé sur Linux où ça signifie « <em>fast user-space mutex</em> » ou encore « mutex rapide pour l'espace utilisateur ») fournissent des outils pour attendre jusqu'à ce qu'une condition donnée soit vérifiée. Généralement ces méthodes sont utilisées pour bloquer des opérations.</p>
-
-<dl>
- <dt>{{jsxref("Atomics.wait()")}}</dt>
- <dd>Cette méthode vérifie qu'une position donnée du tableau contient bien une valeur donnée puis dort ou expire. Elle renvoie une des chaînes suivantes <code>"ok"</code>, <code>"not-equal"</code>, <code>"timed-out"</code>. Si l'agent appelant ne permet pas d'attente, cela lèvera une exception <code>Error</code> (la plupart des navigateurs ne permettront pas que <code>futexWait()</code> soit utilisé sur le <em>thread</em> principal du navigateur).</dd>
- <dt>{{jsxref("Atomics.notify()")}}</dt>
- <dd>Cette méthode notifient les agents qui attendent dans la file d'attente à une position donnée. Elle renvoie le nombre d'agents notifiés.</dd>
- <dt>{{jsxref("Atomics.isLockFree()")}}</dt>
- <dd>Une primitive d'optimisation qui peut être utilisée afin de déterminer s'il faut utiliser des verrous (<em>locks</em>) ou des opérations atomiques. Elle renvoie <code>true</code> si la taille donnée est l'une des propriétés <code>BYTES_PER_ELEMENT</code> des types <code>TypedArray</code> et qu'on peut donc implémenter l'opération de façon atomique plutôt que d'utiliser un verrou.</dd>
-</dl>
-
-<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-atomics-object', 'Atomics')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES8', '#sec-atomics-object', 'Atomics')}}</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.Atomics")}}</p>
-
-<h3 id="Notes_de_compatibilité">Notes de compatibilité</h3>
-
-<p>Avant Firefox 48 {{geckoRelease(48)}}, les noms les plus récents et la sémantique la plus récente n'étaient pas encore implémentés. Les changements qui ont eu lieu entre la version 46 et la version 48 de Firefox sont :</p>
-
-<ul>
- <li>Les méthodes <code>Atomics.futexWakeOrRequeue()</code> et <code>Atomics.fence()</code> sont désormais complètement retirées (cf. {{bug(1259544)}} et {{bug(1225028)}}).</li>
- <li>Les méthodes {{jsxref("Atomics.wait()")}} et  {{jsxref("Atomics.wake()")}} qui étaient nommées <code>Atomics.futexWait()</code> ete <code>Atomics.futexWake()</code> (cf. {{bug(1260910)}}). Les anciens noms seront  définitivement supprimés à partir de la version 49 ({{bug(1262062)}}). <code>Atomics.wake()</code> a été renommé en <code>Atomics.notify()</code> à partir de la version 63.</li>
- <li>Les propriétés <code>Atomics.OK</code>, <code>Atomics.TIMEDOUT</code>, <code>Atomics.NOTEQUAL</code> ont été retirées. La méthode {{jsxref("Atomics.wait()")}} renvoie désormais les chaînes de caractères <code>"ok"</code>, <code>"timed-out"</code> ou <code>"not-equal"</code> (cf. {{bug(1260835)}}).</li>
- <li>
-  <p>Le paramètre <code>count</code> de la méthode {{jsxref("Atomics.wake()")}} a été modifié, sa valeur par défaut est désormais <code>+Infinity</code> et non <code>0</code> ({{bug(1253350)}}).</p>
- </li>
-</ul>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("ArrayBuffer")}}</li>
- <li><a href="/fr/docs/Web/JavaScript/Tableaux_typés">Les tableaux typés en JavaScript</a></li>
- <li><a href="/fr/docs/Web/API/Web_Workers_API">Web Workers</a></li>
- <li><a href="https://github.com/lars-t-hansen/parlib-simple">parlib-simple </a>– un bibliothèque simple qui fournit des abstractions pour synchronisers et distribuer des tâches.</li>
- <li><a href="https://github.com/tc39/ecmascript_sharedmem/blob/master/TUTORIAL.md">La mémoire partagée – un rapide tutoriel</a></li>
- <li><a href="https://hacks.mozilla.org/2016/05/a-taste-of-javascripts-new-parallel-primitives/">A Taste of JavaScript’s New Parallel Primitives – Mozilla Hacks (en anglais)</a></li>
-</ul>
+{{JSRef}}
+
+L'objet **`Atomics`** fournit des opérations atomiques sous la forme de méthodes statiques. Celles-ci sont utilisées avec les objets {{jsxref("SharedArrayBuffer")}}.
+
+Les opérations atomiques sont installées sur un module `Atomics`. À la différence des autres objets globaux, `Atomics` n'est pas un constructeur. Pour cette raison, il ne peut être utilisé avec l'opérateur {{jsxref("Opérateurs/L_opérateur_new")}} et il ne peut pas être appelé comme une fonction. Les propriétés et les méthodes d'`Atomics` sont statiques (`Atomics` fonctionne ainsi comme l'objet {{jsxref("Math")}}).
+
+## Propriétés
+
+- `Atomics[Symbol.toStringTag]`
+  - : La valeur de cette propriété vaut `"Atomics"`.
+
+## Méthodes
+
+### Opérations atomiques
+
+Lorsque la mémoire est partagée, plusieurs _threads_ peuvent lire et écrire sur les mêmes données en mémoire. Les opérations atomiques permettent de s'assurer que des valeurs prévisibles sont écrites et lues, que les opérations sont finies avant que la prochaine débute et que les opérations ne sont pas interrompues.
+
+- {{jsxref("Atomics.add()")}}
+  - : Cette méthode ajoute la valeur fournie à la position indiquée dans le tableau. Elle renvoie l'ancienne valeur qui était à cette position.
+- {{jsxref("Atomics.and()")}}
+  - : Cette méthode calcule un ET binaire sur la position indiquée dans le tableau. Elle renvoie l'ancienne valeur qui était à cette position.
+- {{jsxref("Atomics.compareExchange()")}}
+  - : Cette méthode stocke la valeur fournie à la position indiquée dans le tableau si elle est égale à une valeur donnée. Elle renvoie l'ancienne valeur.
+- {{jsxref("Atomics.exchange()")}}
+  - : Cette méthode stocke la valeur fournie à la position indiquée dans le tableau. Elle renvoie l'ancienne valeur.
+- {{jsxref("Atomics.load()")}}
+  - : Cette méthode renvoie la valeur à la position indiquée dans le tableau.
+- {{jsxref("Atomics.or()")}}
+  - : Cette méthode calcule un OU binaire entre la valeur fournie et la position indiquée dans le tableau. Elle renvoie l'ancienne valeur qui était à cette position.
+- {{jsxref("Atomics.store()")}}
+  - : Cette méthode stocke une valeur à une position indiquée dans le tableau. Elle renvoie la valeur.
+- {{jsxref("Atomics.sub()")}}
+  - : Cette méthode soustrait la valeur fournie à la position indiquée dans le tableau. Elle renvoie l'ancienne valeur qui était contenue à cette position.
+- {{jsxref("Atomics.xor()")}}
+  - : Cette méthode calcule un OU exclusif binaire sur une position donnée dans le tableau. Elle renvoie l'ancienne valeur qui était à cette position.
+
+### Attente et notification (`wait` et `notify`)
+
+Le méthodes `wait`() et `notify()` sont basées sur les _futex_ Linux (selon le vocabulaire employé sur Linux où ça signifie « _fast user-space mutex_ » ou encore « mutex rapide pour l'espace utilisateur ») fournissent des outils pour attendre jusqu'à ce qu'une condition donnée soit vérifiée. Généralement ces méthodes sont utilisées pour bloquer des opérations.
+
+- {{jsxref("Atomics.wait()")}}
+  - : Cette méthode vérifie qu'une position donnée du tableau contient bien une valeur donnée puis dort ou expire. Elle renvoie une des chaînes suivantes `"ok"`, `"not-equal"`, `"timed-out"`. Si l'agent appelant ne permet pas d'attente, cela lèvera une exception `Error` (la plupart des navigateurs ne permettront pas que `futexWait()` soit utilisé sur le _thread_ principal du navigateur).
+- {{jsxref("Atomics.notify()")}}
+  - : Cette méthode notifient les agents qui attendent dans la file d'attente à une position donnée. Elle renvoie le nombre d'agents notifiés.
+- {{jsxref("Atomics.isLockFree()")}}
+  - : Une primitive d'optimisation qui peut être utilisée afin de déterminer s'il faut utiliser des verrous (_locks_) ou des opérations atomiques. Elle renvoie `true` si la taille donnée est l'une des propriétés `BYTES_PER_ELEMENT` des types `TypedArray` et qu'on peut donc implémenter l'opération de façon atomique plutôt que d'utiliser un verrou.
+
+## Spécifications
+
+| Spécification                                                                | État                         | Commentaires         |
+| ---------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ESDraft', '#sec-atomics-object', 'Atomics')}} | {{Spec2('ESDraft')}} |                      |
+| {{SpecName('ES8', '#sec-atomics-object', 'Atomics')}}     | {{Spec2('ES8')}}         | Définition initiale. |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Atomics")}}
+
+### Notes de compatibilité
+
+Avant Firefox 48 {{geckoRelease(48)}}, les noms les plus récents et la sémantique la plus récente n'étaient pas encore implémentés. Les changements qui ont eu lieu entre la version 46 et la version 48 de Firefox sont :
+
+- Les méthodes `Atomics.futexWakeOrRequeue()` et `Atomics.fence()` sont désormais complètement retirées (cf. {{bug(1259544)}} et {{bug(1225028)}}).
+- Les méthodes {{jsxref("Atomics.wait()")}} et  {{jsxref("Atomics.wake()")}} qui étaient nommées `Atomics.futexWait()` ete `Atomics.futexWake()` (cf. {{bug(1260910)}}). Les anciens noms seront  définitivement supprimés à partir de la version 49 ({{bug(1262062)}}). `Atomics.wake()` a été renommé en `Atomics.notify()` à partir de la version 63.
+- Les propriétés `Atomics.OK`, `Atomics.TIMEDOUT`, `Atomics.NOTEQUAL` ont été retirées. La méthode {{jsxref("Atomics.wait()")}} renvoie désormais les chaînes de caractères `"ok"`, `"timed-out"` ou `"not-equal"` (cf. {{bug(1260835)}}).
+- Le paramètre `count` de la méthode {{jsxref("Atomics.wake()")}} a été modifié, sa valeur par défaut est désormais `+Infinity` et non `0` ({{bug(1253350)}}).
+
+## Voir aussi
+
+- {{jsxref("ArrayBuffer")}}
+- [Les tableaux typés en JavaScript](/fr/docs/Web/JavaScript/Tableaux_typés)
+- [Web Workers](/fr/docs/Web/API/Web_Workers_API)
+- [parlib-simple ](https://github.com/lars-t-hansen/parlib-simple)– un bibliothèque simple qui fournit des abstractions pour synchronisers et distribuer des tâches.
+- [La mémoire partagée – un rapide tutoriel](https://github.com/tc39/ecmascript_sharedmem/blob/master/TUTORIAL.md)
+- [A Taste of JavaScript’s New Parallel Primitives – Mozilla Hacks (en anglais)](https://hacks.mozilla.org/2016/05/a-taste-of-javascripts-new-parallel-primitives/)
diff --git a/files/fr/web/javascript/reference/global_objects/atomics/islockfree/index.md b/files/fr/web/javascript/reference/global_objects/atomics/islockfree/index.md
index be1df1cda2..a13dde87ca 100644
--- a/files/fr/web/javascript/reference/global_objects/atomics/islockfree/index.md
+++ b/files/fr/web/javascript/reference/global_objects/atomics/islockfree/index.md
@@ -10,62 +10,48 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Atomics/isLockFree
 original_slug: Web/JavaScript/Reference/Objets_globaux/Atomics/isLockFree
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode statique <code><strong>Atomics</strong></code><strong><code>.isLockFree()</code></strong> est utilisée afin de déterminer si on doit utiliser des verrous (<em>locks</em>) ou des opérations atomiques. Elle renvoie <code>true</code> si la taille donnée correspond à une des propriétés <code><a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/TypedArray/BYTES_PER_ELEMENT">BYTES_PER_ELEMENT</a></code> d'un des types <code>TypedArray</code>.</p>
+La méthode statique **`Atomics`\*\***`.isLockFree()`\** est utilisée afin de déterminer si on doit utiliser des verrous (*locks\*) ou des opérations atomiques. Elle renvoie `true` si la taille donnée correspond à une des propriétés [`BYTES_PER_ELEMENT`](/fr/docs/Web/JavaScript/Reference/Objets_globaux/TypedArray/BYTES_PER_ELEMENT) d'un des types `TypedArray`.
 
-<div>{{EmbedInteractiveExample("pages/js/atomics-islockfree.html")}}</div>
+{{EmbedInteractiveExample("pages/js/atomics-islockfree.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">Atomics.isLockFree(taille)
-</pre>
+    Atomics.isLockFree(taille)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>taille</code></dt>
- <dd>La taille en octets qu'on souhaite vérifier.</dd>
-</dl>
+- `taille`
+  - : La taille en octets qu'on souhaite vérifier.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un {{jsxref("Boolean","booléen","",1)}} indiquant si l'opération se déroule sans verrou.</p>
+Un {{jsxref("Boolean","booléen","",1)}} indiquant si l'opération se déroule sans verrou.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<pre class="brush: js">Atomics.isLockFree(1); // true
+```js
+Atomics.isLockFree(1); // true
 Atomics.isLockFree(2); // true
 Atomics.isLockFree(3); // false
 Atomics.isLockFree(4); // true
 Atomics.isLockFree(5); // false
 Atomics.isLockFree(6); // false
 Atomics.isLockFree(7); // false
-Atomics.isLockFree(8); // 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('ESDraft', '#sec-atomics.islockfree', 'Atomics.isLockFree')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td>Définition initiale avec ES2017.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Atomics.isLockFree")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Atomics")}}</li>
-</ul>
+Atomics.isLockFree(8); // true
+```
+
+## Spécifications
+
+| Spécification                                                                                    | État                         | Commentaires                     |
+| ------------------------------------------------------------------------------------------------ | ---------------------------- | -------------------------------- |
+| {{SpecName('ESDraft', '#sec-atomics.islockfree', 'Atomics.isLockFree')}} | {{Spec2('ESDraft')}} | Définition initiale avec ES2017. |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Atomics.isLockFree")}}
+
+## Voir aussi
+
+- {{jsxref("Atomics")}}
diff --git a/files/fr/web/javascript/reference/global_objects/atomics/load/index.md b/files/fr/web/javascript/reference/global_objects/atomics/load/index.md
index 8e692f4ce8..9ada195398 100644
--- a/files/fr/web/javascript/reference/global_objects/atomics/load/index.md
+++ b/files/fr/web/javascript/reference/global_objects/atomics/load/index.md
@@ -10,70 +10,54 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Atomics/load
 original_slug: Web/JavaScript/Reference/Objets_globaux/Atomics/load
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode statique <code><strong>Atomics</strong></code><strong><code>.load()</code></strong> renvoie une valeur située à une position donnée du tableau.</p>
+La méthode statique **`Atomics`\*\***`.load()`\*\* renvoie une valeur située à une position donnée du tableau.
 
-<div>{{EmbedInteractiveExample("pages/js/atomics-load.html")}}</div>
+{{EmbedInteractiveExample("pages/js/atomics-load.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">Atomics.load(typedArray, index)
-</pre>
+    Atomics.load(typedArray, index)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>typedArray</code></dt>
- <dd>Un tableau typé entier partagé parmi {{jsxref("Int8Array")}}, {{jsxref("Uint8Array")}}, {{jsxref("Int16Array")}}, {{jsxref("Uint16Array")}}, {{jsxref("Int32Array")}} ou {{jsxref("Uint32Array")}}.</dd>
- <dt><code>index</code></dt>
- <dd>La position du tableau <code>typedArray</code> qu'on souhaite charger.</dd>
-</dl>
+- `typedArray`
+  - : Un tableau typé entier partagé parmi {{jsxref("Int8Array")}}, {{jsxref("Uint8Array")}}, {{jsxref("Int16Array")}}, {{jsxref("Uint16Array")}}, {{jsxref("Int32Array")}} ou {{jsxref("Uint32Array")}}.
+- `index`
+  - : La position du tableau `typedArray` qu'on souhaite charger.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>La valeur à la position indiquée (<code>typedArray[index]</code>).</p>
+La valeur à la position indiquée (`typedArray[index]`).
 
-<h3 id="Exceptions_levées">Exceptions levées</h3>
+### Exceptions levées
 
-<ul>
- <li>Cette méthode lève {{jsxref("TypeError")}} si le type de <code>typedArray</code> n'est pas un des types entiers autorisés.</li>
- <li>Cette méthode lève {{jsxref("TypeError")}} si <code>typedArray</code> n'est pas tableau typé partagé.</li>
- <li>Cette méthode lève {{jsxref("RangeError")}} si <code>index</code> est en dehors des limites de <code>typedArray</code>.</li>
-</ul>
+- Cette méthode lève {{jsxref("TypeError")}} si le type de `typedArray` n'est pas un des types entiers autorisés.
+- Cette méthode lève {{jsxref("TypeError")}} si `typedArray` n'est pas tableau typé partagé.
+- Cette méthode lève {{jsxref("RangeError")}} si `index` est en dehors des limites de `typedArray`.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<pre class="brush: js">var sab = new SharedArrayBuffer(1024);
+```js
+var sab = new SharedArrayBuffer(1024);
 var ta = new Uint8Array(sab);
 
 Atomics.add(ta, 0, 12);
-Atomics.load(ta, 0); // 12</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-atomics.load', 'Atomics.load')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td>Définition initiale avec ES2017.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Atomics.load")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Atomics")}}</li>
- <li>{{jsxref("Atomics.store()")}}</li>
-</ul>
+Atomics.load(ta, 0); // 12
+```
+
+## Spécifications
+
+| Spécification                                                                    | État                         | Commentaires                     |
+| -------------------------------------------------------------------------------- | ---------------------------- | -------------------------------- |
+| {{SpecName('ESDraft', '#sec-atomics.load', 'Atomics.load')}} | {{Spec2('ESDraft')}} | Définition initiale avec ES2017. |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Atomics.load")}}
+
+## Voir aussi
+
+- {{jsxref("Atomics")}}
+- {{jsxref("Atomics.store()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/atomics/notify/index.md b/files/fr/web/javascript/reference/global_objects/atomics/notify/index.md
index 81135aa541..ca6dd91a0a 100644
--- a/files/fr/web/javascript/reference/global_objects/atomics/notify/index.md
+++ b/files/fr/web/javascript/reference/global_objects/atomics/notify/index.md
@@ -10,84 +10,69 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Atomics/notify
 original_slug: Web/JavaScript/Reference/Objets_globaux/Atomics/notify
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode statique <code><strong>Atomics</strong></code><strong><code>.notify()</code></strong> permet de réveiller des agents dormants qui sont dans la file d'attente.</p>
+La méthode statique **`Atomics`\*\***`.notify()`\*\* permet de réveiller des agents dormants qui sont dans la file d'attente.
 
-<div class="note">
-<p><strong>Note :</strong> Cette opération ne fonctionne que sur un tableau typé partagé de type {{jsxref("Int32Array")}}.</p>
-</div>
+> **Note :** Cette opération ne fonctionne que sur un tableau typé partagé de type {{jsxref("Int32Array")}}.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">Atomics.notify(typedArray, index, count)
-</pre>
+    Atomics.notify(typedArray, index, count)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>typedArray</code></dt>
- <dd>Un table typé partagé de type {{jsxref("Int32Array")}}.</dd>
- <dt><code>index</code></dt>
- <dd>La position sur le tableau <code>typedArray</code> pour laquelle réveiller les agents.</dd>
- <dt><code>count</code></dt>
- <dd>Le nombre d'agents dormants à réveiller.</dd>
-</dl>
+- `typedArray`
+  - : Un table typé partagé de type {{jsxref("Int32Array")}}.
+- `index`
+  - : La position sur le tableau `typedArray` pour laquelle réveiller les agents.
+- `count`
+  - : Le nombre d'agents dormants à réveiller.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Le nombre d'agents réveillés.</p>
+Le nombre d'agents réveillés.
 
-<h3 id="Exceptions_levées">Exceptions levées</h3>
+### Exceptions levées
 
-<ul>
- <li>Cette méthode lève {{jsxref("TypeError")}} si <code>typedArray</code> n'est pas un tableau typé partagé de type{{jsxref("Int32Array")}}.</li>
- <li>Cette méthode lève {{jsxref("RangeError")}} si <code>index</code> est en dehors des limites de <code>typedArray</code>.</li>
-</ul>
+- Cette méthode lève {{jsxref("TypeError")}} si `typedArray` n'est pas un tableau typé partagé de type{{jsxref("Int32Array")}}.
+- Cette méthode lève {{jsxref("RangeError")}} si `index` est en dehors des limites de `typedArray`.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<p>Soit un tableau typé partagé <code>Int32Array</code>:</p>
+Soit un tableau typé partagé `Int32Array`:
 
-<pre class="brush: js">var sab = new SharedArrayBuffer(1024);
+```js
+var sab = new SharedArrayBuffer(1024);
 var int32 = new Int32Array(sab);
-</pre>
+```
 
-<p>Un <em>thread</em> de lecture est en sommeil et surveille l'emplacement 0 et s'attend à ce que la valeur soit 0. Tant que cette condition est vérifiée, l'exécution n'ira pas plus loin. Lorsque le <em>thread</em> d'écriture a enregistré une nouvelle valeur, le <em>thread</em> de lecture sera réveillé par le <em>thread</em> d'écriture et renverra la nouvelle valeur (123).</p>
+Un _thread_ de lecture est en sommeil et surveille l'emplacement 0 et s'attend à ce que la valeur soit 0. Tant que cette condition est vérifiée, l'exécution n'ira pas plus loin. Lorsque le _thread_ d'écriture a enregistré une nouvelle valeur, le _thread_ de lecture sera réveillé par le _thread_ d'écriture et renverra la nouvelle valeur (123).
 
-<pre class="brush: js">Atomics.wait(int32, 0, 0);
-console.log(int32[0]); // 123</pre>
+```js
+Atomics.wait(int32, 0, 0);
+console.log(int32[0]); // 123
+```
 
-<p>Un <em>thread</em> d'écriture stocke une nouvelle valeur et notifie le <em>thread</em> de lecture une fois que la valeur a bien été écrite :</p>
+Un _thread_ d'écriture stocke une nouvelle valeur et notifie le _thread_ de lecture une fois que la valeur a bien été écrite :
 
-<pre class="brush: js">console.log(int32[0]); // 0;
+```js
+console.log(int32[0]); // 0;
 Atomics.store(int32, 0, 123);
-Atomics.notify(int32, 0, 1);</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('ESDraft', '#sec-atomics.notify', 'Atomics.notify')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td>Définition initiale avec ES2017.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Atomics.notify")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Atomics")}}</li>
- <li>{{jsxref("Atomics.wait()")}}</li>
-</ul>
+Atomics.notify(int32, 0, 1);
+```
+
+## Spécifications
+
+| Spécification                                                                        | Statut                       | Commentaires                     |
+| ------------------------------------------------------------------------------------ | ---------------------------- | -------------------------------- |
+| {{SpecName('ESDraft', '#sec-atomics.notify', 'Atomics.notify')}} | {{Spec2('ESDraft')}} | Définition initiale avec ES2017. |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Atomics.notify")}}
+
+## Voir aussi
+
+- {{jsxref("Atomics")}}
+- {{jsxref("Atomics.wait()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/atomics/or/index.md b/files/fr/web/javascript/reference/global_objects/atomics/or/index.md
index 0147a2d36e..26c37fcd96 100644
--- a/files/fr/web/javascript/reference/global_objects/atomics/or/index.md
+++ b/files/fr/web/javascript/reference/global_objects/atomics/or/index.md
@@ -10,118 +10,76 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Atomics/or
 original_slug: Web/JavaScript/Reference/Objets_globaux/Atomics/or
 ---
-<div>{{JSRef}}</div>
-
-<p>La méthode statique <code><strong>Atomics</strong></code><strong><code>.or()</code></strong> calcule le résultat d'un OU binaire entre une valeur donnée et une valeur du tableau typé et y place le résultat obtenu. Cette opération atomique garantit qu'aucune autre opération d'écriture n'est appliquée tant que la valeur modifiée n'est pas écrite.</p>
-
-<div>{{EmbedInteractiveExample("pages/js/atomics-or.html")}}</div>
-
-<h2 id="Syntaxe">Syntaxe</h2>
-
-<pre class="syntaxbox">Atomics.or(typedArray, index, value)
-</pre>
-
-<h3 id="Paramètres">Paramètres</h3>
-
-<dl>
- <dt><code>typedArray</code></dt>
- <dd>Un tableau typé entier partagé parmi {{jsxref("Int8Array")}}, {{jsxref("Uint8Array")}}, {{jsxref("Int16Array")}}, {{jsxref("Uint16Array")}}, {{jsxref("Int32Array")}} ou {{jsxref("Uint32Array")}}.</dd>
- <dt><code>index</code></dt>
- <dd>La position du tableau <code>typedArray</code> sur laquelle calculer le OU binaire.</dd>
- <dt><code>valeur</code></dt>
- <dd>Le nombre avec lequel calculer le OU binaire.</dd>
-</dl>
-
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
-
-<p>L'ancienne valeur contenue à l'emplacement du tableau (<code>typedArray[index]</code>).</p>
-
-<h3 id="Exceptions_levées">Exceptions levées</h3>
-
-<ul>
- <li>Cette méthode lève {{jsxref("TypeError")}} si le type de <code>typedArray</code> n'est pas un des types entiers autorisés.</li>
- <li>Cette méthode lève {{jsxref("TypeError")}} si <code>typedArray</code> n'est pas tableau typé partagé.</li>
- <li>Cette méthode lève {{jsxref("RangeError")}} si <code>index</code> est en dehors des limites de <code>typedArray</code>.</li>
-</ul>
-
-<h2 id="Description">Description</h2>
-
-<p>L'opération binaire OU renvoie 1 si <code>a</code> ou <code>b</code> valent 1. La table de vérité de cette opération est :</p>
-
-<table class="standard-table">
- <thead>
-  <tr>
-   <th><code>a</code></th>
-   <th><code>b</code></th>
-   <th><code>a | b</code></th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td>0</td>
-   <td>0</td>
-   <td>0</td>
-  </tr>
-  <tr>
-   <td>0</td>
-   <td>1</td>
-   <td>1</td>
-  </tr>
-  <tr>
-   <td>1</td>
-   <td>0</td>
-   <td>1</td>
-  </tr>
-  <tr>
-   <td>1</td>
-   <td>1</td>
-   <td>1</td>
-  </tr>
- </tbody>
-</table>
-
-<p>Par exemple, un OU binaire appliqué entre 5 et 1 (<code>5 | 1</code>) renvoie <code>0101</code>, ce qui correspond à 5 en notation décimale.</p>
-
-<pre>5  0101
-1  0001
-   ----
-5  0101
-</pre>
-
-<h2 id="Exemples">Exemples</h2>
-
-<pre class="brush: js">var sab = new SharedArrayBuffer(1024);
+{{JSRef}}
+
+La méthode statique **`Atomics`\*\***`.or()`\*\* calcule le résultat d'un OU binaire entre une valeur donnée et une valeur du tableau typé et y place le résultat obtenu. Cette opération atomique garantit qu'aucune autre opération d'écriture n'est appliquée tant que la valeur modifiée n'est pas écrite.
+
+{{EmbedInteractiveExample("pages/js/atomics-or.html")}}
+
+## Syntaxe
+
+    Atomics.or(typedArray, index, value)
+
+### Paramètres
+
+- `typedArray`
+  - : Un tableau typé entier partagé parmi {{jsxref("Int8Array")}}, {{jsxref("Uint8Array")}}, {{jsxref("Int16Array")}}, {{jsxref("Uint16Array")}}, {{jsxref("Int32Array")}} ou {{jsxref("Uint32Array")}}.
+- `index`
+  - : La position du tableau `typedArray` sur laquelle calculer le OU binaire.
+- `valeur`
+  - : Le nombre avec lequel calculer le OU binaire.
+
+### Valeur de retour
+
+L'ancienne valeur contenue à l'emplacement du tableau (`typedArray[index]`).
+
+### Exceptions levées
+
+- Cette méthode lève {{jsxref("TypeError")}} si le type de `typedArray` n'est pas un des types entiers autorisés.
+- Cette méthode lève {{jsxref("TypeError")}} si `typedArray` n'est pas tableau typé partagé.
+- Cette méthode lève {{jsxref("RangeError")}} si `index` est en dehors des limites de `typedArray`.
+
+## Description
+
+L'opération binaire OU renvoie 1 si `a` ou `b` valent 1. La table de vérité de cette opération est :
+
+| `a` | `b` | `a \| b` |
+| --- | --- | -------- |
+| 0   | 0   | 0        |
+| 0   | 1   | 1        |
+| 1   | 0   | 1        |
+| 1   | 1   | 1        |
+
+Par exemple, un OU binaire appliqué entre 5 et 1 (`5 | 1`) renvoie `0101`, ce qui correspond à 5 en notation décimale.
+
+    5  0101
+    1  0001
+       ----
+    5  0101
+
+## Exemples
+
+```js
+var sab = new SharedArrayBuffer(1024);
 var ta = new Uint8Array(sab);
 ta[0] = 2;
 
 Atomics.or(ta, 0, 1); // renvoie 2, l'ancienne valeur
-Atomics.load(ta, 0);  // 3</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-atomics.or', 'Atomics.or')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td>Définition initiale avec 2017.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Atomics.or")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Atomics")}}</li>
- <li>{{jsxref("Atomics.and()")}}</li>
- <li>{{jsxref("Atomics.xor()")}}</li>
-</ul>
+Atomics.load(ta, 0);  // 3
+```
+
+## Spécifications
+
+| Spécification                                                                | État                         | Commentaires                   |
+| ---------------------------------------------------------------------------- | ---------------------------- | ------------------------------ |
+| {{SpecName('ESDraft', '#sec-atomics.or', 'Atomics.or')}} | {{Spec2('ESDraft')}} | Définition initiale avec 2017. |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Atomics.or")}}
+
+## Voir aussi
+
+- {{jsxref("Atomics")}}
+- {{jsxref("Atomics.and()")}}
+- {{jsxref("Atomics.xor()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/atomics/store/index.md b/files/fr/web/javascript/reference/global_objects/atomics/store/index.md
index 4f31079d58..bb609861db 100644
--- a/files/fr/web/javascript/reference/global_objects/atomics/store/index.md
+++ b/files/fr/web/javascript/reference/global_objects/atomics/store/index.md
@@ -10,43 +10,39 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Atomics/store
 original_slug: Web/JavaScript/Reference/Objets_globaux/Atomics/store
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode statique <code><strong>Atomics</strong></code><strong><code>.store()</code></strong> enregistre une valeur donnée à un emplacement donné du tableau partagé et renvoie cette valeur.</p>
+La méthode statique **`Atomics`\*\***`.store()`\*\* enregistre une valeur donnée à un emplacement donné du tableau partagé et renvoie cette valeur.
 
-<div>{{EmbedInteractiveExample("pages/js/atomics-store.html")}}</div>
+{{EmbedInteractiveExample("pages/js/atomics-store.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">Atomics.store(typedArray, index, valeur)
-</pre>
+    Atomics.store(typedArray, index, valeur)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>typedArray</code></dt>
- <dd>Un tableau typé entier partagé parmi {{jsxref("Int8Array")}}, {{jsxref("Uint8Array")}}, {{jsxref("Int16Array")}}, {{jsxref("Uint16Array")}}, {{jsxref("Int32Array")}} ou {{jsxref("Uint32Array")}}.</dd>
- <dt><code>index</code></dt>
- <dd>La position du tableau <code>typedArray</code> à laquelle on souhaite stocker la valeur.</dd>
- <dt><code>valeur</code></dt>
- <dd>Le nombre à enregistrer.</dd>
-</dl>
+- `typedArray`
+  - : Un tableau typé entier partagé parmi {{jsxref("Int8Array")}}, {{jsxref("Uint8Array")}}, {{jsxref("Int16Array")}}, {{jsxref("Uint16Array")}}, {{jsxref("Int32Array")}} ou {{jsxref("Uint32Array")}}.
+- `index`
+  - : La position du tableau `typedArray` à laquelle on souhaite stocker la valeur.
+- `valeur`
+  - : Le nombre à enregistrer.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>La valeur qui a été enregistrée.</p>
+La valeur qui a été enregistrée.
 
-<h3 id="Exceptions">Exceptions</h3>
+### Exceptions
 
-<ul>
- <li>Cette méthode lève {{jsxref("TypeError")}} si le type de <code>typedArray</code> n'est pas un des types entiers autorisés.</li>
- <li>Cette méthode lève {{jsxref("TypeError")}} si <code>typedArray</code> n'est pas tableau typé partagé.</li>
- <li>Cette méthode lève {{jsxref("RangeError")}} si <code>index</code> est en dehors des limites de <code>typedArray</code>.</li>
-</ul>
+- Cette méthode lève {{jsxref("TypeError")}} si le type de `typedArray` n'est pas un des types entiers autorisés.
+- Cette méthode lève {{jsxref("TypeError")}} si `typedArray` n'est pas tableau typé partagé.
+- Cette méthode lève {{jsxref("RangeError")}} si `index` est en dehors des limites de `typedArray`.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<pre class="brush: js">var buffer = new ArrayBuffer(4);         // Buffer classique
+```js
+var buffer = new ArrayBuffer(4);         // Buffer classique
 var float32 = new Float32Array(buffer);  // Nombre flottant
 var uint32 = new Uint32Array(buffer);    // Représentation IEEE754
 
@@ -55,33 +51,19 @@ console.log("0x" + uint32[0].toString(16));
 
 uint32[0] = 0x3f000000;   /// Représentation sur 32 bits de 0.5 (IEEE754)
 console.log(float32[0]);
+```
 
-</pre>
+## Spécifications
 
-<h2 id="Spécifications">Spécifications</h2>
+| Spécification                                                                        | État                         | Commentaires                     |
+| ------------------------------------------------------------------------------------ | ---------------------------- | -------------------------------- |
+| {{SpecName('ESDraft', '#sec-atomics.store', 'Atomics.store')}} | {{Spec2('ESDraft')}} | Définition initiale avec ES2017. |
 
-<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-atomics.store', 'Atomics.store')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td>Définition initiale avec ES2017.</td>
-  </tr>
- </tbody>
-</table>
+## Compatibilité des navigateurs
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+{{Compat("javascript.builtins.Atomics.store")}}
 
-<p>{{Compat("javascript.builtins.Atomics.store")}}</p>
+## Voir aussi
 
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Atomics")}}</li>
- <li>{{jsxref("Atomics.load()")}}</li>
-</ul>
+- {{jsxref("Atomics")}}
+- {{jsxref("Atomics.load()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/atomics/sub/index.md b/files/fr/web/javascript/reference/global_objects/atomics/sub/index.md
index 313fc0577e..d219dfead1 100644
--- a/files/fr/web/javascript/reference/global_objects/atomics/sub/index.md
+++ b/files/fr/web/javascript/reference/global_objects/atomics/sub/index.md
@@ -10,74 +10,57 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Atomics/sub
 original_slug: Web/JavaScript/Reference/Objets_globaux/Atomics/sub
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode statique <code><strong>Atomics</strong></code><strong><code>.sub()</code></strong> permet de soustraire une valeur donnée à une position donnée du tableau partagé. Elle renvoie l'ancienne valeur qui était contenue dans le tableau avant l'opération. Cette opération atomique garantit qu'aucune autre opération d'écriture n'est appliquée tant que la valeur modifiée n'est pas écrite.</p>
+La méthode statique **`Atomics`\*\***`.sub()`\*\* permet de soustraire une valeur donnée à une position donnée du tableau partagé. Elle renvoie l'ancienne valeur qui était contenue dans le tableau avant l'opération. Cette opération atomique garantit qu'aucune autre opération d'écriture n'est appliquée tant que la valeur modifiée n'est pas écrite.
 
-<div>{{EmbedInteractiveExample("pages/js/atomics-sub.html")}}</div>
+{{EmbedInteractiveExample("pages/js/atomics-sub.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">Atomics.sub(typedArray, index, valeur)
-</pre>
+    Atomics.sub(typedArray, index, valeur)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>typedArray</code></dt>
- <dd>Un tableau typé entier partagé parmi {{jsxref("Int8Array")}}, {{jsxref("Uint8Array")}}, {{jsxref("Int16Array")}}, {{jsxref("Uint16Array")}}, {{jsxref("Int32Array")}} ou {{jsxref("Uint32Array")}}.</dd>
- <dt><code>index</code></dt>
- <dd>La position du tableau typé <code>typedArray</code> à laquelle on veut soustraire <code>valeur</code>.</dd>
- <dt><code>valeur</code></dt>
- <dd>La quantité qu'on souhaite soustraire.</dd>
-</dl>
+- `typedArray`
+  - : Un tableau typé entier partagé parmi {{jsxref("Int8Array")}}, {{jsxref("Uint8Array")}}, {{jsxref("Int16Array")}}, {{jsxref("Uint16Array")}}, {{jsxref("Int32Array")}} ou {{jsxref("Uint32Array")}}.
+- `index`
+  - : La position du tableau typé `typedArray` à laquelle on veut soustraire `valeur`.
+- `valeur`
+  - : La quantité qu'on souhaite soustraire.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>L'ancienne valeur qui était contenue à (<code>typedArray[index]</code>).</p>
+L'ancienne valeur qui était contenue à (`typedArray[index]`).
 
-<h3 id="Exceptions_levées">Exceptions levées</h3>
+### Exceptions levées
 
-<ul>
- <li>Cette méthode lève {{jsxref("TypeError")}} si le type de <code>typedArray</code> n'est pas un des types entiers autorisés.</li>
- <li>Cette méthode lève {{jsxref("TypeError")}} si <code>typedArray</code> n'est pas tableau typé partagé.</li>
- <li>Cette méthode lève {{jsxref("RangeError")}} si <code>index</code> est en dehors des limites de <code>typedArray</code>.</li>
-</ul>
+- Cette méthode lève {{jsxref("TypeError")}} si le type de `typedArray` n'est pas un des types entiers autorisés.
+- Cette méthode lève {{jsxref("TypeError")}} si `typedArray` n'est pas tableau typé partagé.
+- Cette méthode lève {{jsxref("RangeError")}} si `index` est en dehors des limites de `typedArray`.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<pre class="brush: js">var sab = new SharedArrayBuffer(1024);
+```js
+var sab = new SharedArrayBuffer(1024);
 var ta = new Uint8Array(sab);
 ta[0] = 48;
 
 Atomics.sub(ta, 0, 12); // renvoie 48, l'ancienne valeur
 Atomics.load(ta, 0);    // 36
-</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-atomics.sub', 'Atomics.sub')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td>Définition initiale avec ES2017.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Atomics.sub")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Atomics")}}</li>
- <li>{{jsxref("Atomics.add()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                | État                         | Commentaires                     |
+| ---------------------------------------------------------------------------- | ---------------------------- | -------------------------------- |
+| {{SpecName('ESDraft', '#sec-atomics.sub', 'Atomics.sub')}} | {{Spec2('ESDraft')}} | Définition initiale avec ES2017. |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Atomics.sub")}}
+
+## Voir aussi
+
+- {{jsxref("Atomics")}}
+- {{jsxref("Atomics.add()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/atomics/wait/index.md b/files/fr/web/javascript/reference/global_objects/atomics/wait/index.md
index 0a25246d86..ac14c69920 100644
--- a/files/fr/web/javascript/reference/global_objects/atomics/wait/index.md
+++ b/files/fr/web/javascript/reference/global_objects/atomics/wait/index.md
@@ -10,86 +10,71 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Atomics/wait
 original_slug: Web/JavaScript/Reference/Objets_globaux/Atomics/wait
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode statique <code><strong>Atomics</strong></code><strong><code>.wait()</code></strong> permet de vérifier qu'un emplacement d'un tableau {{jsxref("Int32Array")}} contient toujours une valeur donnée et, si c'est le cas, l'agent dort en attendant un réveil ou un délai d'expiration. La méthode renvoie une chaîne qui vaut <code>"ok"</code>, <code>"not-equal"</code> ou <code>"timed-out"</code>.</p>
+La méthode statique **`Atomics`\*\***`.wait()`\*\* permet de vérifier qu'un emplacement d'un tableau {{jsxref("Int32Array")}} contient toujours une valeur donnée et, si c'est le cas, l'agent dort en attendant un réveil ou un délai d'expiration. La méthode renvoie une chaîne qui vaut `"ok"`, `"not-equal"` ou `"timed-out"`.
 
-<div class="note">
-<p><strong>Note :</strong> Cette opération ne fonctionne qu'avec un tableau typé partagé {{jsxref("Int32Array")}} et peut ne pas être autorisée sur le <em>thread</em> principal.</p>
-</div>
+> **Note :** Cette opération ne fonctionne qu'avec un tableau typé partagé {{jsxref("Int32Array")}} et peut ne pas être autorisée sur le _thread_ principal.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">Atomics.wait(typedArray, index, valeur[, timeout])
-</pre>
+    Atomics.wait(typedArray, index, valeur[, timeout])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>typedArray</code></dt>
- <dd>Un tableau typé partagé de type {{jsxref("Int32Array")}}.</dd>
- <dt><code>index</code></dt>
- <dd>La position du tableau typé <code>typedArray</code> sur laquelle on attend un changement.</dd>
- <dt><code>valeur</code></dt>
- <dd>La valeur attendue qu'on souhaite tester.</dd>
- <dt><code>timeout</code> {{optional_inline}}</dt>
- <dd>Le temps à attendre pour le changement de valeur, exprimé en millisecondes. La valeur par défaut est {{jsxref("Infinity")}}.</dd>
-</dl>
+- `typedArray`
+  - : Un tableau typé partagé de type {{jsxref("Int32Array")}}.
+- `index`
+  - : La position du tableau typé `typedArray` sur laquelle on attend un changement.
+- `valeur`
+  - : La valeur attendue qu'on souhaite tester.
+- `timeout` {{optional_inline}}
+  - : Le temps à attendre pour le changement de valeur, exprimé en millisecondes. La valeur par défaut est {{jsxref("Infinity")}}.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une chaîne de caractères ({{jsxref("String")}} qui vaut <code>"ok"</code>, <code>"not-equal"</code> ou <code>"timed-out"</code> selon le cas.</p>
+Une chaîne de caractères ({{jsxref("String")}} qui vaut `"ok"`, `"not-equal"` ou `"timed-out"` selon le cas.
 
-<h3 id="Exceptions_levées">Exceptions levées</h3>
+### Exceptions levées
 
-<ul>
- <li>Cette méthode lève {{jsxref("TypeError")}} si <code>typedArray</code> n'est pas un tableau typé partagé de type {{jsxref("Int32Array")}}.</li>
- <li>Cette méthode lève {{jsxref("RangeError")}} si <code>index</code> est en dehors des limites de <code>typedArray</code>.</li>
-</ul>
+- Cette méthode lève {{jsxref("TypeError")}} si `typedArray` n'est pas un tableau typé partagé de type {{jsxref("Int32Array")}}.
+- Cette méthode lève {{jsxref("RangeError")}} si `index` est en dehors des limites de `typedArray`.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<p>Soit un tableau typé partagé <code>Int32Array</code>:</p>
+Soit un tableau typé partagé `Int32Array`:
 
-<pre class="brush: js">var sab = new SharedArrayBuffer(1024);
+```js
+var sab = new SharedArrayBuffer(1024);
 var int32 = new Int32Array(sab);
-</pre>
+```
 
-<p>Un <em>thread</em> de lecture est en sommeille et surveille l'emplacement 0 et s'attend à ce que la valeur soit 0. Tant que cette condition est vérifiée, l'exécution n'ira pas plus loin. Lorsque le <em>thread</em> d'écriture a enregistré une nouvelle valeur, le <em>thread</em> de lecture sera notifié par le <em>thread</em> d'écriture et renverra la nouvelle valeur (123).</p>
+Un _thread_ de lecture est en sommeille et surveille l'emplacement 0 et s'attend à ce que la valeur soit 0. Tant que cette condition est vérifiée, l'exécution n'ira pas plus loin. Lorsque le _thread_ d'écriture a enregistré une nouvelle valeur, le _thread_ de lecture sera notifié par le _thread_ d'écriture et renverra la nouvelle valeur (123).
 
-<pre class="brush: js">Atomics.wait(int32, 0, 0);
-console.log(int32[0]); // 123</pre>
+```js
+Atomics.wait(int32, 0, 0);
+console.log(int32[0]); // 123
+```
 
-<p>Un <em>thread</em> d'écriture stocke une nouvelle valeur et notifie le <em>thread</em> de lecture une fois que la valeur a bien été écrite :</p>
+Un _thread_ d'écriture stocke une nouvelle valeur et notifie le _thread_ de lecture une fois que la valeur a bien été écrite :
 
-<pre class="brush: js">console.log(int32[0]); // 0;
+```js
+console.log(int32[0]); // 0;
 Atomics.store(int32, 0, 123);
-Atomics.notify(int32, 0, 1);</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-atomics.wait', 'Atomics.wait')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td>Définition initiale avec ES2017.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Atomics.wait")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Atomics")}}</li>
- <li>{{jsxref("Atomics.notify()")}}</li>
-</ul>
+Atomics.notify(int32, 0, 1);
+```
+
+## Spécifications
+
+| Spécification                                                                    | État                         | Commentaires                     |
+| -------------------------------------------------------------------------------- | ---------------------------- | -------------------------------- |
+| {{SpecName('ESDraft', '#sec-atomics.wait', 'Atomics.wait')}} | {{Spec2('ESDraft')}} | Définition initiale avec ES2017. |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Atomics.wait")}}
+
+## Voir aussi
+
+- {{jsxref("Atomics")}}
+- {{jsxref("Atomics.notify()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/atomics/xor/index.md b/files/fr/web/javascript/reference/global_objects/atomics/xor/index.md
index c3de46ad67..935579982a 100644
--- a/files/fr/web/javascript/reference/global_objects/atomics/xor/index.md
+++ b/files/fr/web/javascript/reference/global_objects/atomics/xor/index.md
@@ -10,118 +10,76 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Atomics/xor
 original_slug: Web/JavaScript/Reference/Objets_globaux/Atomics/xor
 ---
-<div>{{JSRef}}</div>
-
-<p>La méthode statique <code><strong>Atomics</strong></code><strong><code>.xor()</code></strong> calcule le résultat d'un OU exclusif (XOR) binaire entre une valeur donnée et une valeur du tableau partagé à un emplacement donné. Elle renvoie l'ancienne valeur qui était contenue à cette position. Cette opération atomique garantit qu'aucune autre opération d'écriture n'est appliquée tant que la valeur modifiée n'est pas écrite.</p>
-
-<div>{{EmbedInteractiveExample("pages/js/atomics-xor.html")}}</div>
-
-<h2 id="Syntaxe">Syntaxe</h2>
-
-<pre class="syntaxbox">Atomics.xor(typedArray, index, valeur)
-</pre>
-
-<h3 id="Paramètres">Paramètres</h3>
-
-<dl>
- <dt><code>typedArray</code></dt>
- <dd>Un tableau typé entier partagé parmi {{jsxref("Int8Array")}}, {{jsxref("Uint8Array")}}, {{jsxref("Int16Array")}}, {{jsxref("Uint16Array")}}, {{jsxref("Int32Array")}} ou {{jsxref("Uint32Array")}}.</dd>
- <dt><code>index</code></dt>
- <dd>La position du tableau <code>typedArray</code> à laquelle calculer le OU exclusif binaire.</dd>
- <dt><code>valeur</code></dt>
- <dd>La valeur avec laquelle on souhaite calculer le OU exclusif binaire.</dd>
-</dl>
-
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
-
-<p>L'ancienne valeur située à cet emplacement du tableau (<code>typedArray[index]</code>).</p>
-
-<h3 id="Exceptions">Exceptions</h3>
-
-<ul>
- <li>Cette méthode lève {{jsxref("TypeError")}} si le type de <code>typedArray</code> n'est pas un des types entiers autorisés.</li>
- <li>Cette méthode lève {{jsxref("TypeError")}} si <code>typedArray</code> n'est pas tableau typé partagé.</li>
- <li>Cette méthode lève {{jsxref("RangeError")}} si <code>index</code> est en dehors des limites de <code>typedArray</code>.</li>
-</ul>
-
-<h2 id="Description">Description</h2>
-
-<p>L'opération binaire OU exclusif (XOR) renvoie 1 si <code>a</code> et <code>b</code> sont différents. La table de vérité correspondante est :</p>
-
-<table class="standard-table">
- <thead>
-  <tr>
-   <th><code>a</code></th>
-   <th><code>b</code></th>
-   <th><code>a ^ b</code></th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td>0</td>
-   <td>0</td>
-   <td>0</td>
-  </tr>
-  <tr>
-   <td>0</td>
-   <td>1</td>
-   <td>1</td>
-  </tr>
-  <tr>
-   <td>1</td>
-   <td>0</td>
-   <td>1</td>
-  </tr>
-  <tr>
-   <td>1</td>
-   <td>1</td>
-   <td>0</td>
-  </tr>
- </tbody>
-</table>
-
-<p>Par exemple, le calcul d'un OU exclusif binaire entre 5 et 1 (<code>5 ^ 1</code>) renvoie <code>0100</code>, qui correspond à 4 en notation décimale.</p>
-
-<pre>5  0101
-1  0001
-   ----
-4  0100
-</pre>
-
-<h2 id="Exemples">Exemples</h2>
-
-<pre class="brush: js">var sab = new SharedArrayBuffer(1024);
+{{JSRef}}
+
+La méthode statique **`Atomics`\*\***`.xor()`\*\* calcule le résultat d'un OU exclusif (XOR) binaire entre une valeur donnée et une valeur du tableau partagé à un emplacement donné. Elle renvoie l'ancienne valeur qui était contenue à cette position. Cette opération atomique garantit qu'aucune autre opération d'écriture n'est appliquée tant que la valeur modifiée n'est pas écrite.
+
+{{EmbedInteractiveExample("pages/js/atomics-xor.html")}}
+
+## Syntaxe
+
+    Atomics.xor(typedArray, index, valeur)
+
+### Paramètres
+
+- `typedArray`
+  - : Un tableau typé entier partagé parmi {{jsxref("Int8Array")}}, {{jsxref("Uint8Array")}}, {{jsxref("Int16Array")}}, {{jsxref("Uint16Array")}}, {{jsxref("Int32Array")}} ou {{jsxref("Uint32Array")}}.
+- `index`
+  - : La position du tableau `typedArray` à laquelle calculer le OU exclusif binaire.
+- `valeur`
+  - : La valeur avec laquelle on souhaite calculer le OU exclusif binaire.
+
+### Valeur de retour
+
+L'ancienne valeur située à cet emplacement du tableau (`typedArray[index]`).
+
+### Exceptions
+
+- Cette méthode lève {{jsxref("TypeError")}} si le type de `typedArray` n'est pas un des types entiers autorisés.
+- Cette méthode lève {{jsxref("TypeError")}} si `typedArray` n'est pas tableau typé partagé.
+- Cette méthode lève {{jsxref("RangeError")}} si `index` est en dehors des limites de `typedArray`.
+
+## Description
+
+L'opération binaire OU exclusif (XOR) renvoie 1 si `a` et `b` sont différents. La table de vérité correspondante est :
+
+| `a` | `b` | `a ^ b` |
+| --- | --- | ------- |
+| 0   | 0   | 0       |
+| 0   | 1   | 1       |
+| 1   | 0   | 1       |
+| 1   | 1   | 0       |
+
+Par exemple, le calcul d'un OU exclusif binaire entre 5 et 1 (`5 ^ 1`) renvoie `0100`, qui correspond à 4 en notation décimale.
+
+    5  0101
+    1  0001
+       ----
+    4  0100
+
+## Exemples
+
+```js
+var sab = new SharedArrayBuffer(1024);
 var ta = new Uint8Array(sab);
 ta[0] = 5;
 
 Atomics.xor(ta, 0, 1); // renvoie 5, l'ancienne valeur
-Atomics.load(ta, 0);   // 4</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-atomics.xor', 'Atomics.xor')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td>Définition initiale avec ES2017.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Atomics.xor")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Atomics")}}</li>
- <li>{{jsxref("Atomics.and()")}}</li>
- <li>{{jsxref("Atomics.or()")}}</li>
-</ul>
+Atomics.load(ta, 0);   // 4
+```
+
+## Spécifications
+
+| Spécification                                                                | État                         | Commentaires                     |
+| ---------------------------------------------------------------------------- | ---------------------------- | -------------------------------- |
+| {{SpecName('ESDraft', '#sec-atomics.xor', 'Atomics.xor')}} | {{Spec2('ESDraft')}} | Définition initiale avec ES2017. |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Atomics.xor")}}
+
+## Voir aussi
+
+- {{jsxref("Atomics")}}
+- {{jsxref("Atomics.and()")}}
+- {{jsxref("Atomics.or()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/bigint/asintn/index.md b/files/fr/web/javascript/reference/global_objects/bigint/asintn/index.md
index 13023405cf..3465ce6c21 100644
--- a/files/fr/web/javascript/reference/global_objects/bigint/asintn/index.md
+++ b/files/fr/web/javascript/reference/global_objects/bigint/asintn/index.md
@@ -9,34 +9,33 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/BigInt/asIntN
 original_slug: Web/JavaScript/Reference/Objets_globaux/BigInt/asIntN
 ---
-<p>{{JSRef}}</p>
+{{JSRef}}
 
-<p>La méthode statique <strong><code>BigInt.asIntN()</code></strong> permet d'écréter un nombre <code>BigInt</code> pour obtenir un entier signé entre 2^(largeur-1) et 2^(largeur-1)-1.</p>
+La méthode statique **`BigInt.asIntN()`** permet d'écréter un nombre `BigInt` pour obtenir un entier signé entre 2^(largeur-1) et 2^(largeur-1)-1.
 
-<div>{{EmbedInteractiveExample("pages/js/bigint-asintn.html")}}</div>
+{{EmbedInteractiveExample("pages/js/bigint-asintn.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">var <var>resultat</var> = BigInt.asIntN(<var>largeur</var>, <var>bigint</var>);</pre>
+    var resultat = BigInt.asIntN(largeur, bigint);
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>largeur</code></dt>
- <dd>La quantité de bits disponible pour stocker l'entier.</dd>
- <dt><code>bigint</code></dt>
- <dd>L'entier qu'on souhaite stocker sur le nombre de bits indiqués.</dd>
-</dl>
+- `largeur`
+  - : La quantité de bits disponible pour stocker l'entier.
+- `bigint`
+  - : L'entier qu'on souhaite stocker sur le nombre de bits indiqués.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>La valeur de <code>bigint</code> modulo 2^<code>largeur</code> comme entier signé.</p>
+La valeur de `bigint` modulo 2^`largeur` comme entier signé.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<p>La méthode <code>BigInt.asIntN()</code> peut être utile pour rester dans une arithmétique sur 64 bits :</p>
+La méthode `BigInt.asIntN()` peut être utile pour rester dans une arithmétique sur 64 bits :
 
-<pre class="brush: js">const max = 2n ** (64n - 1n) - 1n;
+```js
+const max = 2n ** (64n - 1n) - 1n;
 
 BigInt.asIntN(64, max);
 // ↪ 9223372036854775807n
@@ -44,30 +43,19 @@ BigInt.asIntN(64, max);
 BigInt.asIntN(64, max + 1n);
 // ↪ -9223372036854775807n
 // négatif car dépassement sur le nombre de bits
-</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>
-  </tr>
-  <tr>
-   <td><a href="https://tc39.github.io/proposal-bigint/#sec-bigint.asintn">BigInt proposal</a></td>
-   <td>Proposition de niveau 3.</td>
-  </tr>
- </tbody>
-</table>
+| Spécification                                                                | État                     |
+| ---------------------------------------------------------------------------- | ------------------------ |
+| [BigInt proposal](https://tc39.github.io/proposal-bigint/#sec-bigint.asintn) | Proposition de niveau 3. |
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.BigInt.asIntN")}}</p>
+{{Compat("javascript.builtins.BigInt.asIntN")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{JSxRef("BigInt")}}</li>
- <li>{{JSxRef("BigInt.asUintN()")}}</li>
-</ul>
+- {{JSxRef("BigInt")}}
+- {{JSxRef("BigInt.asUintN()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/bigint/asuintn/index.md b/files/fr/web/javascript/reference/global_objects/bigint/asuintn/index.md
index 5331dbae11..096fc6af73 100644
--- a/files/fr/web/javascript/reference/global_objects/bigint/asuintn/index.md
+++ b/files/fr/web/javascript/reference/global_objects/bigint/asuintn/index.md
@@ -10,64 +10,53 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/BigInt/asUintN
 original_slug: Web/JavaScript/Reference/Objets_globaux/BigInt/asUintN
 ---
-<p>{{JSRef}}</p>
+{{JSRef}}
 
-<p>La méthode statique <strong><code>BigInt.asUintN()</code></strong> permet d'écréter un <code>BigInt</code> pour ramener sa valeur sur un entier non-signé entre 0 et 2^(largeur)-1.</p>
+La méthode statique **`BigInt.asUintN()`** permet d'écréter un `BigInt` pour ramener sa valeur sur un entier non-signé entre 0 et 2^(largeur)-1.
 
-<div>{{EmbedInteractiveExample("pages/js/bigint-asuintn.html")}}</div>
+{{EmbedInteractiveExample("pages/js/bigint-asuintn.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">var <var>résultat</var> = BigInt.asUintN(<var>largeur</var>, <var>bigint</var>);</pre>
+    var résultat = BigInt.asUintN(largeur, bigint);
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>largeur</code></dt>
- <dd>Le nombre de bits disponible pour stocker l'entier.</dd>
- <dt><code>bigint</code></dt>
- <dd>L'entier qu'on souhaite stocker sur le nombre de bits indiqués.</dd>
-</dl>
+- `largeur`
+  - : Le nombre de bits disponible pour stocker l'entier.
+- `bigint`
+  - : L'entier qu'on souhaite stocker sur le nombre de bits indiqués.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>La valeur de <code>bigint</code> modulo 2^<code>largeur</code> comme un entier non signé.</p>
+La valeur de `bigint` modulo 2^`largeur` comme un entier non signé.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<p>La méthode <code>BigInt.asUintN()</code> peut s'avérer utile pour rester dans une arithmétique exprimée sur 64 bits .</p>
+La méthode `BigInt.asUintN()` peut s'avérer utile pour rester dans une arithmétique exprimée sur 64 bits .
 
-<pre class="brush: js">const max = 2n ** 64n - 1n;
+```js
+const max = 2n ** 64n - 1n;
 
 BigInt.asUintN(64, max);
 // ↪ 18446744073709551615n
 
 BigInt.asUintN(64, max + 1n);
 // ↪ 0n
-// zéro en raison du dépassement</pre>
+// zéro en raison du dépassement
+```
 
-<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>
-  </tr>
-  <tr>
-   <td><a href="https://tc39.github.io/proposal-bigint/#sec-bigint.asuintn">Proposition pour BigInt</a></td>
-   <td>Proposition de niveau 3</td>
-  </tr>
- </tbody>
-</table>
+| Spécification                                                                         | État                    |
+| ------------------------------------------------------------------------------------- | ----------------------- |
+| [Proposition pour BigInt](https://tc39.github.io/proposal-bigint/#sec-bigint.asuintn) | Proposition de niveau 3 |
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.BigInt.asUintN")}}</p>
+{{Compat("javascript.builtins.BigInt.asUintN")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{JSxRef("BigInt")}}</li>
- <li>{{JSxRef("BigInt.asIntN()")}}</li>
-</ul>
+- {{JSxRef("BigInt")}}
+- {{JSxRef("BigInt.asIntN()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/bigint/index.md b/files/fr/web/javascript/reference/global_objects/bigint/index.md
index 6e842994cc..4cb7b392cf 100644
--- a/files/fr/web/javascript/reference/global_objects/bigint/index.md
+++ b/files/fr/web/javascript/reference/global_objects/bigint/index.md
@@ -9,39 +9,33 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/BigInt
 original_slug: Web/JavaScript/Reference/Objets_globaux/BigInt
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p><strong><code>BigInt</code></strong> est un objet natif qui permet de représenter des nombres entiers supérieurs à 2^53 (la plus grande valeur entière qui puisse être représentée par le type primitif {{jsxref("Number")}}). <code>BigInt</code> peut être utilisé afin de représenter de grands entiers de n'importe quelle taille.</p>
+**`BigInt`** est un objet natif qui permet de représenter des nombres entiers supérieurs à 2^53 (la plus grande valeur entière qui puisse être représentée par le type primitif {{jsxref("Number")}}). `BigInt` peut être utilisé afin de représenter de grands entiers de n'importe quelle taille.
 
-<div class="blockIndicator note">
-<p><strong>Note :</strong> BigInt est actuellement une <strong>proposition de niveau 3</strong> pour la <a href="#Spécifications">spécification</a> ECMAScript.</p>
+> **Note :** BigInt est actuellement une **proposition de niveau 3** pour la [spécification](#Spécifications) ECMAScript.
+>
+> Lorsque cette proposition atteindra le niveau 4 (soit la spécification finale), BigInt sera le deuxième type natif disponible en JavaScript pour représenter des valeurs numériques.
+>
+> **`BigInt`** sera ainsi le prochain type primitif ajouté à JavaScript depuis {{JSxRef("Symbol")}} avec ES2015
 
-<p>Lorsque cette proposition atteindra le niveau 4 (soit la spécification finale), BigInt sera le deuxième type natif disponible en JavaScript pour représenter des valeurs numériques.</p>
+## Syntaxe
 
-<p><strong><code>BigInt</code></strong> sera ainsi le prochain type primitif ajouté à JavaScript depuis {{JSxRef("Symbol")}} avec ES2015</p>
-</div>
+    BigInt(valeur);
 
-<h2 id="Syntaxe">Syntaxe</h2>
+### Paramètres
 
-<pre class="syntaxbox">BigInt(valeur);
-</pre>
+- `valeur`
+  - : La valeur numérique de l'objet qu'on souhaite créer. Cet argument peut être une chaîne de caractères ou un entier.
 
-<h3 id="Paramètres">Paramètres</h3>
+> **Note :** `BigInt()` n'est pas censé être utilisé avec l'opérateur {{jsxref("Opérateurs/L_opérateur_new", "new")}}.
 
-<dl>
- <dt><code>valeur</code></dt>
- <dd>La valeur numérique de l'objet qu'on souhaite créer. Cet argument peut être une chaîne de caractères ou un entier.</dd>
-</dl>
+## Description
 
-<div class="blockIndicator note">
-<p><strong>Note :</strong> <code>BigInt()</code> n'est pas censé être utilisé avec l'opérateur {{jsxref("Opérateurs/L_opérateur_new", "new")}}.</p>
-</div>
+Un objet `BigInt` est créé en ajoutant un `n` à la fin d'un littéral d'entier — `10n` par exemple — ou en appelant la fonction `BigInt()`.
 
-<h2 id="Description">Description</h2>
-
-<p>Un objet <code>BigInt</code> est créé en ajoutant un <code>n</code> à la fin d'un littéral d'entier — <code>10n</code> par exemple — ou en appelant la fonction <code>BigInt()</code>.</p>
-
-<pre class="brush: js">const plusGrandEntier = 9007199254740991n;
+```js
+const plusGrandEntier = 9007199254740991n;
 
 const grandNombre = BigInt(9007199254740991);
 // ↪ 9007199254740991n
@@ -53,32 +47,36 @@ const grandeNombreHexa = BigInt("0x1fffffffffffff");
 // ↪ 9007199254740991n
 
 const grandeNombreBinaire = BigInt("0b11111111111111111111111111111111111111111111111111111");
-// ↪ 9007199254740991n</pre>
-
-<p>Les objets <code>BigInt</code> sont semblables aux objets {{jsxref("Number")}} selon certains aspects mais avec quelques différences clés. Les objets <code>BigInt</code> ne peuvent pas êre utilisés avec l'objet {{jsxref("Math")}} et ne peuvent pas être manipulés avec des opérations qui impliquent des objets {{jsxref("Number")}}.</p>
+// ↪ 9007199254740991n
+```
 
-<div class="warning">
-<p><strong>Attention :</strong> Il est nécessaire de convertir des valeurs {{jsxref("Number")}} ou <code>BigInt</code> dans les opérations qui les combinent.</p>
+Les objets `BigInt` sont semblables aux objets {{jsxref("Number")}} selon certains aspects mais avec quelques différences clés. Les objets `BigInt` ne peuvent pas êre utilisés avec l'objet {{jsxref("Math")}} et ne peuvent pas être manipulés avec des opérations qui impliquent des objets {{jsxref("Number")}}.
 
-<p>Attention lors de ces conversions car la précision d'une valeur <code>BigInt</code> peut être perdue lorsque ce dernier est converti en {{jsxref("Number")}}.</p>
-</div>
+> **Attention :** Il est nécessaire de convertir des valeurs {{jsxref("Number")}} ou `BigInt` dans les opérations qui les combinent.
+>
+> Attention lors de ces conversions car la précision d'une valeur `BigInt` peut être perdue lorsque ce dernier est converti en {{jsxref("Number")}}.
 
-<h3 id="Type">Type</h3>
+### Type
 
-<p>Lorsqu'on utilise <code>typeof</code> sur une valeur <code>BigInt</code>, cet opérateur renverra <code>"bigint"</code> :</p>
+Lorsqu'on utilise `typeof` sur une valeur `BigInt`, cet opérateur renverra `"bigint"` :
 
-<pre class="brush: js">typeof 1n === "bigint"; // true
-typeof BigInt("1") === "bigint"; // true</pre>
+```js
+typeof 1n === "bigint"; // true
+typeof BigInt("1") === "bigint"; // true
+```
 
-<p>Lorsqu'on « enveloppe » la valeur dans un objet, on aura alors un type <code>"object"</code> (comme pour les autres valeurs primitives lorsqu'on les enveloppe dans le constructeur objet) :</p>
+Lorsqu'on « enveloppe » la valeur dans un objet, on aura alors un type `"object"` (comme pour les autres valeurs primitives lorsqu'on les enveloppe dans le constructeur objet) :
 
-<pre class="brush: js">typeof Object(1n) === "object"; // true</pre>
+```js
+typeof Object(1n) === "object"; // true
+```
 
-<h3 id="Opérateurs">Opérateurs</h3>
+### Opérateurs
 
-<p>On peut utiliser les opérateurs suivants avec les objets <code>BigInt</code> : <code>+</code>, `<code>*</code>`, `<code>-</code>`, `<code>**</code>`, `<code>%</code>` , <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_binaires">les opérateurs binaires</a> (à l'exception de <code>&gt;&gt;&gt;</code> / décalage à droite avec des zéros) car les grands entiers sont signés. Le <code>+</code> unaire n'est pas non plus pris en charge (afin de <a href="https://github.com/tc39/proposal-bigint/blob/master/ADVANCED.md#dont-break-asmjs">ne pas casser asm.js</a>).</p>
+On peut utiliser les opérateurs suivants avec les objets `BigInt` : `+`, \``*`\`, \``-`\`, \``**`\`, \``%`\` , [les opérateurs binaires](/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_binaires) (à l'exception de `>>>` / décalage à droite avec des zéros) car les grands entiers sont signés. Le `+` unaire n'est pas non plus pris en charge (afin de [ne pas casser asm.js](https://github.com/tc39/proposal-bigint/blob/master/ADVANCED.md#dont-break-asmjs)).
 
-<pre class="brush: js">const nombreSain = BigInt(Number.MAX_SAFE_INTEGER);
+```js
+const nombreSain = BigInt(Number.MAX_SAFE_INTEGER);
 // ↪ 9007199254740991
 
 const maxPlusUn = nombreSain + 1n;
@@ -101,66 +99,75 @@ const bigN = 2n ** 54n;
 
 bigN * -1n
 // ↪ –18014398509481984n
-</pre>
+```
 
-<p>L'opérateur <code>/</code> fonctionne de façon analogue aux nombres classiques. Toutefois, les objets <code>BigInt</code> permettent uniquement de représenter des entiers et non des nombres décimaux. Aussi, la division ne produira pas de partie décimale pour les <code>BigInt</code>.</p>
+L'opérateur `/` fonctionne de façon analogue aux nombres classiques. Toutefois, les objets `BigInt` permettent uniquement de représenter des entiers et non des nombres décimaux. Aussi, la division ne produira pas de partie décimale pour les `BigInt`.
 
-<pre class="brush: js">const attendu = 4n / 2n;
+```js
+const attendu = 4n / 2n;
 // ↪ 2n
 
 const tronque = 5n / 2n;
 // ↪ 2n et pas 2.5n
+```
 
-</pre>
+### Comparaisons
 
-<h3 id="Comparaisons">Comparaisons</h3>
+Un objet `BigInt` n'est pas strictement égal à {{jsxref( "Number")}} mais peut l'être au sens de l'égalité faible.
 
-<p>Un objet <code>BigInt</code> n'est pas strictement égal à {{jsxref( "Number")}} mais peut l'être au sens de l'égalité faible.</p>
-
-<pre class="brush: js">0n === 0
+```js
+0n === 0
 // ↪ false
 
 0n == 0
-// ↪ true</pre>
+// ↪ true
+```
 
-<p>On peut toutefois comparer des objets {{jsxref("Number")}} et <code>BigInt</code> :</p>
+On peut toutefois comparer des objets {{jsxref("Number")}} et `BigInt` :
 
-<pre class="brush: js">1n &lt; 2
+```js
+1n < 2
 // ↪ true
 
-2n &gt; 1
+2n > 1
 // ↪ true
 
-2 &gt; 2
+2 > 2
 // ↪ false
 
-2n &gt; 2
+2n > 2
 // ↪ false
 
-2n &gt;= 2
-// ↪ true</pre>
+2n >= 2
+// ↪ true
+```
 
-<p>On peut également mélanger ces valeurs au sein de tableaux :</p>
+On peut également mélanger ces valeurs au sein de tableaux :
 
-<pre class="brush: js">const mixed = [4n, 6, -12n, 10, 4, 0, 0n];
+```js
+const mixed = [4n, 6, -12n, 10, 4, 0, 0n];
 // ↪  [4n, 6, -12n, 10, 4, 0, 0n]
 
 mixed.sort();
-// ↪ [-12n, 0, 0n, 10, 4n, 4, 6]</pre>
+// ↪ [-12n, 0, 0n, 10, 4n, 4, 6]
+```
 
-<p>On notera que les comparaisons entre les valeurs <code>BigInt</code> et les mêmes valeurs, passées dans le constructeur <code>Object()</code> ne seront pas équivalentes au sens strict :</p>
+On notera que les comparaisons entre les valeurs `BigInt` et les mêmes valeurs, passées dans le constructeur `Object()` ne seront pas équivalentes au sens strict :
 
-<pre class="brush: js">0n === Object(0n); // false
+```js
+0n === Object(0n); // false
 Object(0n) === Object(0n); // false
 
 const o = Object(0n);
-o === o; // true</pre>
+o === o; // true
+```
 
-<h3 id="Opérations_conditionnelles">Opérations conditionnelles</h3>
+### Opérations conditionnelles
 
-<p>Un objet <code>BigInt</code> se comporte comme un objet {{jsxref("Number")}} lorsqu'il est utilisé dans un contexte booléen : comme argument pour le constructeur {{jsxref("Boolean")}}, comme opérandes pour les opérateurs logiques <code>||</code>, `<code>&amp;&amp;</code>` et <code>!</code> ou avec les instructions conditonnelles telles que <code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/if...else">if</a></code>.</p>
+Un objet `BigInt` se comporte comme un objet {{jsxref("Number")}} lorsqu'il est utilisé dans un contexte booléen : comme argument pour le constructeur {{jsxref("Boolean")}}, comme opérandes pour les opérateurs logiques `||`, \``&&`\` et `!` ou avec les instructions conditonnelles telles que [`if`](/fr/docs/Web/JavaScript/Reference/Instructions/if...else).
 
-<pre class="brush: js">if (0n) {
+```js
+if (0n) {
   console.log('Nous voici dans le if !');
 } else {
   console.log('Et nous voilà dans le else !');
@@ -171,7 +178,7 @@ o === o; // true</pre>
 0n || 12n
 // ↪ 12n
 
-0n &amp;&amp; 12n
+0n && 12n
 // ↪ 0n
 
 Boolean(0n)
@@ -185,48 +192,45 @@ Boolean(12n)
 
 !0n
 // ↪ true
-</pre>
+```
 
-<h2 id="Méthodes">Méthodes</h2>
+## Méthodes
 
-<dl>
- <dt><strong><code>BigInt.asIntN()</code></strong></dt>
- <dd>Écrète un objet <code>BigInt</code> pour obtenir un entier signé entre -2^(largeur-1) et 2^(largeur-1)-1</dd>
- <dt><code>BigInt.asUintN()</code></dt>
- <dd>Écrète un objet <code>BigInt</code> pour obtenir un entier non-signé entre 0 et 2^(largeur)-1</dd>
-</dl>
+- **`BigInt.asIntN()`**
+  - : Écrète un objet `BigInt` pour obtenir un entier signé entre -2^(largeur-1) et 2^(largeur-1)-1
+- `BigInt.asUintN()`
+  - : Écrète un objet `BigInt` pour obtenir un entier non-signé entre 0 et 2^(largeur)-1
 
-<h2 id="Propriétés">Propriétés</h2>
+## Propriétés
 
-<dl>
- <dt>{{jsxref("BigInt.prototype")}}</dt>
- <dd>Cette propriété permet d'ajouter des propriétés aux objets <code>BigInt</code>.</dd>
-</dl>
+- {{jsxref("BigInt.prototype")}}
+  - : Cette propriété permet d'ajouter des propriétés aux objets `BigInt`.
 
-<h2 id="Instances_de_BigInt">Instances de <code>BigInt</code></h2>
+## Instances de `BigInt`
 
-<p>L'ensemble des instances de <code>BigInt</code> héritent de <code>BigInt.prototype</code>. Le prototype du constructeur <code>BigInt</code> peut être modifié afin de modifier l'ensemble des instances de <code>BigInt</code>.</p>
+L'ensemble des instances de `BigInt` héritent de `BigInt.prototype`. Le prototype du constructeur `BigInt` peut être modifié afin de modifier l'ensemble des instances de `BigInt`.
 
-<h3 id="Méthodes_2">Méthodes</h3>
+### Méthodes
 
-<p>{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/BigInt/prototype', 'Méthodes')}}</p>
+{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/BigInt/prototype', 'Méthodes')}}
 
-<h2 id="Recommandations">Recommandations</h2>
+## Recommandations
 
-<h3 id="Coercition_en_Number">Coercition en <code>Number</code></h3>
+### Coercition en `Number`
 
-<p>Lorsqu'on convertit une valeur <code>BigInt</code> en {{jsxref("Objets_globaux/Number","Number")}}, on perd en précision. Si on effectue des allers-retours entre ces deux types, on ne conservera pas la même valeur. Aussi, il est recommandé d'utiliser uniquement <code>BigInt</code> lorsque les valeurs qu'on manipule seront supérieures à 2^53 et qu'il ne sera pas nécessaire de passer d'un type à l'autre.</p>
+Lorsqu'on convertit une valeur `BigInt` en {{jsxref("Objets_globaux/Number","Number")}}, on perd en précision. Si on effectue des allers-retours entre ces deux types, on ne conservera pas la même valeur. Aussi, il est recommandé d'utiliser uniquement `BigInt` lorsque les valeurs qu'on manipule seront supérieures à 2^53 et qu'il ne sera pas nécessaire de passer d'un type à l'autre.
 
-<h3 id="Cryptographie">Cryptographie</h3>
+### Cryptographie
 
-<p>Les opérations prises en charge pour les valeurs <code>BigInt</code> ne s'effectuent pas à temps constant. Aussi, <code>BigInt</code> ne serait être utilisé à <a href="https://www.chosenplaintext.ca/articles/beginners-guide-constant-time-cryptography.html">des fins cryptographiques</a>.</p>
+Les opérations prises en charge pour les valeurs `BigInt` ne s'effectuent pas à temps constant. Aussi, `BigInt` ne serait être utilisé à [des fins cryptographiques](https://www.chosenplaintext.ca/articles/beginners-guide-constant-time-cryptography.html).
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Calculer_des_nombres_premiers">Calculer des nombres premiers</h3>
+### Calculer des nombres premiers
 
-<pre class="brush: js">function isPrime(p) {
-  for (let i = 2n; i * i &lt;= p; i++) {
+```js
+function isPrime(p) {
+  for (let i = 2n; i * i <= p; i++) {
     if (p % i === 0n) return false;
   }
   return true;
@@ -237,7 +241,7 @@ function nthPrime(nth) {
   let maybePrime = 2n;
   let prime = 0n;
 
-  while (nth &gt;= 0n) {
+  while (nth >= 0n) {
     if (isPrime(maybePrime)) {
       nth -= 1n;
       prime = maybePrime;
@@ -249,31 +253,19 @@ function nthPrime(nth) {
 }
 
 nthPrime(20n)
-// ↪ 73n</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>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td><code><a href="https://tc39.es/proposal-bigint/#sec-bigint-objects">BigInt</a></code></td>
-   <td>Brouillon de niveau 3</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.BigInt")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Number")}}</li>
-</ul>
+// ↪ 73n
+```
+
+## Spécifications
+
+| Spécification                                                   | État                  |
+| --------------------------------------------------------------- | --------------------- |
+| [`BigInt`](https://tc39.es/proposal-bigint/#sec-bigint-objects) | Brouillon de niveau 3 |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.BigInt")}}
+
+## Voir aussi
+
+- {{jsxref("Number")}}
diff --git a/files/fr/web/javascript/reference/global_objects/bigint/tolocalestring/index.md b/files/fr/web/javascript/reference/global_objects/bigint/tolocalestring/index.md
index 05c8d2860a..ba569b8723 100644
--- a/files/fr/web/javascript/reference/global_objects/bigint/tolocalestring/index.md
+++ b/files/fr/web/javascript/reference/global_objects/bigint/tolocalestring/index.md
@@ -12,46 +12,46 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/BigInt/toLocaleString
 original_slug: Web/JavaScript/Reference/Objets_globaux/BigInt/toLocaleString
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>toLocaleString()</code></strong> renvoie une chaîne de caractères représentant le grand entier pour la ou les locale(s) indiquée(s).</p>
+La méthode **`toLocaleString()`** renvoie une chaîne de caractères représentant le grand entier pour la ou les locale(s) indiquée(s).
 
-<div>{{EmbedInteractiveExample("pages/js/bigint-tolocalestring.html")}}</div>
+{{EmbedInteractiveExample("pages/js/bigint-tolocalestring.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><code><em>bigIntObj</em>.toLocaleString(</code><code>[locales [, options]])</code></pre>
+    bigIntObj.toLocaleString([locales [, options]])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>locales</code> {{optional_inline}}</dt>
- <dd>Une chaine de caractères avec un identifiant de langue BCP 47, ou un tableau de ce type de chaine de caractères. Pour le format général et l'interprétation de l'argument <code>locales</code>. Pour plus de détails quant à la forme et l'interprétation de l'argument <code>locales</code>, on consultera la page {{jsxref("Intl")}}.</dd>
- <dt><code>options</code> {{optional_inline}}</dt>
- <dd>Un objet qui contient des propriétés de configuration. Pour les nombres, consulter {{jsxref("Number.prototype.toLocaleString()")}}, pour les dates, consulter {{jsxref("Date.prototype.toLocaleString()")}}.</dd>
-</dl>
+- `locales` {{optional_inline}}
+  - : Une chaine de caractères avec un identifiant de langue BCP 47, ou un tableau de ce type de chaine de caractères. Pour le format général et l'interprétation de l'argument `locales`. Pour plus de détails quant à la forme et l'interprétation de l'argument `locales`, on consultera la page {{jsxref("Intl")}}.
+- `options` {{optional_inline}}
+  - : Un objet qui contient des propriétés de configuration. Pour les nombres, consulter {{jsxref("Number.prototype.toLocaleString()")}}, pour les dates, consulter {{jsxref("Date.prototype.toLocaleString()")}}.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une chaîne de caractères qui représente le grand entier selon la ou les locales et les options indiquées.</p>
+Une chaîne de caractères qui représente le grand entier selon la ou les locales et les options indiquées.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_toLocaleString()">Utiliser <code>toLocaleString()</code></h3>
+### Utiliser `toLocaleString()`
 
-<p>Voici un exemple d'utilisation simple, sans indiquer de locale ni d'options.</p>
+Voici un exemple d'utilisation simple, sans indiquer de locale ni d'options.
 
-<pre class="brush: js">var bigint = 3500n;
+```js
+var bigint = 3500n;
 
 bigint.toLocaleString();
 // Affichera "3500" en français
-</pre>
+```
 
-<h3 id="Utiliser_locales">Utiliser <code>locales</code></h3>
+### Utiliser `locales`
 
-<p>Cet exemple illustre certaines variations pour la représentation d'une même valeur en fonction des différentes locales. En fonction de la langue utilisée par l'utilisateur et par votre interface, vous pourrez utiliser <code>locales</code> pour indiquer la locale ciblée :</p>
+Cet exemple illustre certaines variations pour la représentation d'une même valeur en fonction des différentes locales. En fonction de la langue utilisée par l'utilisateur et par votre interface, vous pourrez utiliser `locales` pour indiquer la locale ciblée :
 
-<pre class="brush: js">var bigint = 123456789123456789n;
+```js
+var bigint = 123456789123456789n;
 
 // En allemand, on utilise les points pour séparer
 // les milliers
@@ -59,7 +59,7 @@ console.log(bigint.toLocaleString('de-DE'));
 // → 123.456.789.123.456.789
 
 // La plupart des pays arabes utilise
-// des chiffres <a href="https://en.wikipedia.org/wiki/Eastern_Arabic_numerals">hindoux-arabes</a>
+// des chiffres hindoux-arabes
 console.log(bigint.toLocaleString('ar-EG'));
 // → ١٢٣٬٤٥٦٬٧٨٩٬١٢٣٬٤٥٦٬٧٨٩
 
@@ -78,13 +78,14 @@ console.log(bigint.toLocaleString('zh-Hans-CN-u-nu-hanidec'));
 // locale qui sera utilisée en recours (ici l'indonésien)
 console.log(bigint.toLocaleString(['ban', 'id']));
 // → 123.456.789.123.456.789
-</pre>
+```
 
-<h3 id="Utiliser_options">Utiliser <code>options</code></h3>
+### Utiliser `options`
 
-<p>Ici, on personnalise le résultat fourni par <code>toLocaleString()</code> grâce à l'argument <code>options</code> :</p>
+Ici, on personnalise le résultat fourni par `toLocaleString()` grâce à l'argument `options` :
 
-<pre class="brush: js">var bigint = 123456789123456789n;
+```js
+var bigint = 123456789123456789n;
 
 // On utilise un format avec une devise
 console.log(bigint.toLocaleString('de-DE', { style: 'currency', currency: 'EUR' }));
@@ -97,33 +98,22 @@ console.log(bigint.toLocaleString('ja-JP', { style: 'currency', currency: 'JPY'
 // On limite l'écriture aux trois premiers chiffres significatifs
 console.log(bigint.toLocaleString('en-IN', { maximumSignificantDigits: 3 }));
 // → 1,23,00,00,00,00,00,00,000
-</pre>
+```
 
-<h2 id="Performance">Performance</h2>
+## Performance
 
-<p>Lorsqu'on souhaite mettre en forme une grande quantité de nombres, mieux vaudra créer un objet {{jsxref("NumberFormat")}} et utiliser la fonction fournie par sa propriété {{jsxref("NumberFormat.format")}}.</p>
+Lorsqu'on souhaite mettre en forme une grande quantité de nombres, mieux vaudra créer un objet {{jsxref("NumberFormat")}} et utiliser la fonction fournie par sa propriété {{jsxref("NumberFormat.format")}}.
 
-<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>
-  </tr>
-  <tr>
-   <td><code><a href="https://tc39.es/ecma402/#sup-bigint.prototype.tolocalestring">BigInt</a></code></td>
-   <td>Proposition de niveau 3.</td>
-  </tr>
- </tbody>
-</table>
+| Spécification                                                            | État                     |
+| ------------------------------------------------------------------------ | ------------------------ |
+| [`BigInt`](https://tc39.es/ecma402/#sup-bigint.prototype.tolocalestring) | Proposition de niveau 3. |
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.BigInt.toLocaleString")}}</p>
+{{Compat("javascript.builtins.BigInt.toLocaleString")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("BigInt.toString()")}}</li>
-</ul>
+- {{jsxref("BigInt.toString()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/bigint/tostring/index.md b/files/fr/web/javascript/reference/global_objects/bigint/tostring/index.md
index 4fbc9eab99..b1fdcdbef7 100644
--- a/files/fr/web/javascript/reference/global_objects/bigint/tostring/index.md
+++ b/files/fr/web/javascript/reference/global_objects/bigint/tostring/index.md
@@ -10,85 +10,73 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/BigInt/toString
 original_slug: Web/JavaScript/Reference/Objets_globaux/BigInt/toString
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>The <strong><code>toString()</code></strong> method returns a string representing the specified {{jsxref("BigInt")}} object. The trailing "n" is not part of the string.</p>
+The **`toString()`** method returns a string representing the specified {{jsxref("BigInt")}} object. The trailing "n" is not part of the string.
 
-<div>{{EmbedInteractiveExample("pages/js/bigint-tostring.html")}}</div>
+{{EmbedInteractiveExample("pages/js/bigint-tostring.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><code><var>bigIntObj</var>.toString([<var>base</var>])</code></pre>
+    bigIntObj.toString([base])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>base</code>{{optional_inline}}</dt>
- <dd>Ce paramètre optionnel est compris entre 2 et 36 et indique la base à utiliser pour représenter les valeurs numériques.</dd>
-</dl>
+- `base`{{optional_inline}}
+  - : Ce paramètre optionnel est compris entre 2 et 36 et indique la base à utiliser pour représenter les valeurs numériques.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une chaîne de caractères représentant l'objet {{jsxref("BigInt")}} courant.</p>
+Une chaîne de caractères représentant l'objet {{jsxref("BigInt")}} courant.
 
-<h3 id="Exceptions">Exceptions</h3>
+### Exceptions
 
-<dl>
- <dt>{{jsxref("RangeError")}}</dt>
- <dd>Si la base fournie comme argument <code>toString()</code> est inférieure à 2 ou supérieure à 36, cela déclenchera une exception {{jsxref("RangeError")}}.</dd>
-</dl>
+- {{jsxref("RangeError")}}
+  - : Si la base fournie comme argument `toString()` est inférieure à 2 ou supérieure à 36, cela déclenchera une exception {{jsxref("RangeError")}}.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>L'objet {{jsxref("BigInt")}} surcharge la méthode <code>toString()</code> de {{jsxref("Object")}}. Il n'hérite pas ou n'utilise pas {{jsxref("Object.prototype.toString()")}}. Pour les objets {{jsxref( "BigInt")}}, la méthode <code>toString()</code> renvoie une représentation textuelle de l'objet dans la base indiquée.</p>
+L'objet {{jsxref("BigInt")}} surcharge la méthode `toString()` de {{jsxref("Object")}}. Il n'hérite pas ou n'utilise pas {{jsxref("Object.prototype.toString()")}}. Pour les objets {{jsxref( "BigInt")}}, la méthode `toString()` renvoie une représentation textuelle de l'objet dans la base indiquée.
 
-<p>La méthode <code>toString()</code> analyse le premier argument qui lui est passé et tente de renvoyer une représentation textuelle dans cette base. Pour les bases supérieures à 10, ce seront les lettres de l'alphabet pour indiquer les chiffres supérieurs à 9. Pour les nombres hexadécimaux (base 16), les lettres <code>a</code> à <code>f</code> sont utilisées par exemple.</p>
+La méthode `toString()` analyse le premier argument qui lui est passé et tente de renvoyer une représentation textuelle dans cette base. Pour les bases supérieures à 10, ce seront les lettres de l'alphabet pour indiquer les chiffres supérieurs à 9. Pour les nombres hexadécimaux (base 16), les lettres `a` à `f` sont utilisées par exemple.
 
-<p>Si l'argument <code>base</code> n'est pas indiquée, ce sera la base 10 qui sera considérée par défaut.</p>
+Si l'argument `base` n'est pas indiquée, ce sera la base 10 qui sera considérée par défaut.
 
-<p>Si <code>bigIntObj</code> est négatif, le signe est conservé, y compris lorsque la base est 2 (dans ce cas, la chaîne renvoyée sera la représentation binaire précédée par un signe <code>-</code> et <strong>non</strong> le complément à deux de <code>bigIntObj</code>).</p>
+Si `bigIntObj` est négatif, le signe est conservé, y compris lorsque la base est 2 (dans ce cas, la chaîne renvoyée sera la représentation binaire précédée par un signe `-` et **non** le complément à deux de `bigIntObj`).
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_toString()">Utiliser <code>toString()</code></h3>
+### Utiliser `toString()`
 
-<pre class="brush: js">17n.toString();      // '17'
+```js
+17n.toString();      // '17'
 66n.toString(2);     // '1000010'
 254n.toString(16);   // 'fe'
 -10n.toString(2);    // -1010'
 -0xffn.toString(2);  // '-11111111'
-</pre>
+```
 
-<h3 id="Gestion_du_zéro_négatif_en_BigInt">Gestion du zéro négatif en <code>BigInt</code></h3>
+### Gestion du zéro négatif en `BigInt`
 
-<p>Il n'existe pas de zéro négatif pour <code>BigInt</code> car les entiers ne gèrent pas de concept de zéro négatif. <code>-0.0</code> est un concept relatif à la représentation flottante IEEE et n'est présent que pour le type {{jsxref("Number")}}.</p>
+Il n'existe pas de zéro négatif pour `BigInt` car les entiers ne gèrent pas de concept de zéro négatif. `-0.0` est un concept relatif à la représentation flottante IEEE et n'est présent que pour le type {{jsxref("Number")}}.
 
-<pre class="brush: js">(-0n).toString();      // '0'
-BigInt(-0).toString(); // '0'</pre>
+```js
+(-0n).toString();      // '0'
+BigInt(-0).toString(); // '0'
+```
 
-<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>
-  </tr>
-  <tr>
-   <td><a href="https://tc39.github.io/proposal-bigint/#sec-bigint.prototype.tostring">Proposition pour <code>BigInt</code></a></td>
-   <td>Proposition de niveau 3</td>
-  </tr>
- </tbody>
-</table>
+| Spécification                                                                                      | État                    |
+| -------------------------------------------------------------------------------------------------- | ----------------------- |
+| [Proposition pour `BigInt`](https://tc39.github.io/proposal-bigint/#sec-bigint.prototype.tostring) | Proposition de niveau 3 |
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.BigInt.toString")}}</p>
+{{Compat("javascript.builtins.BigInt.toString")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("BigInt.prototype.toLocaleString()")}}</li>
- <li>{{jsxref("BigInt.prototype.valueOf()")}}</li>
- <li>{{jsxref("Number.prototype.toString()")}}</li>
-</ul>
+- {{jsxref("BigInt.prototype.toLocaleString()")}}
+- {{jsxref("BigInt.prototype.valueOf()")}}
+- {{jsxref("Number.prototype.toString()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/bigint/valueof/index.md b/files/fr/web/javascript/reference/global_objects/bigint/valueof/index.md
index 92a6e74350..fae0cd160f 100644
--- a/files/fr/web/javascript/reference/global_objects/bigint/valueof/index.md
+++ b/files/fr/web/javascript/reference/global_objects/bigint/valueof/index.md
@@ -11,49 +11,39 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/BigInt/valueOf
 original_slug: Web/JavaScript/Reference/Objets_globaux/BigInt/valueOf
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>valueOf()</code></strong> renvoie la valeur primitive encapsulée dans un objet {{jsxref("BigInt")}}.</p>
+La méthode **`valueOf()`** renvoie la valeur primitive encapsulée dans un objet {{jsxref("BigInt")}}.
 
-<div>{{EmbedInteractiveExample("pages/js/bigint-valueof.html")}}</div>
+{{EmbedInteractiveExample("pages/js/bigint-valueof.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>bigIntObj</var>.valueOf()</pre>
+    bigIntObj.valueOf()
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un grand entier (<em>big int</em>) représentant la valeur primitive de l'objet {{jsxref("BigInt")}} courant.</p>
+Un grand entier (_big int_) représentant la valeur primitive de l'objet {{jsxref("BigInt")}} courant.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_valueOf()">Utiliser <code>valueOf()</code></h3>
+### Utiliser `valueOf()`
 
-<pre class="brush: js">typeof Object(1n); // object
+```js
+typeof Object(1n); // object
 typeof Object(1n).valueOf(); // bigint
-</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>
-  </tr>
-  <tr>
-   <td><a href="https://tc39.github.io/proposal-bigint/#sec-bigint.prototype.valueof">Proposition pour <code>BigInt</code></a></td>
-   <td>Proposition de niveau 3</td>
-  </tr>
- </tbody>
-</table>
+| Spécification                                                                                     | État                    |
+| ------------------------------------------------------------------------------------------------- | ----------------------- |
+| [Proposition pour `BigInt`](https://tc39.github.io/proposal-bigint/#sec-bigint.prototype.valueof) | Proposition de niveau 3 |
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.BigInt.valueOf")}}</p>
+{{Compat("javascript.builtins.BigInt.valueOf")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("BigInt.prototype.toString()")}}</li>
-</ul>
+- {{jsxref("BigInt.prototype.toString()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/bigint64array/index.md b/files/fr/web/javascript/reference/global_objects/bigint64array/index.md
index 3631f56e60..8c4ec7637a 100644
--- a/files/fr/web/javascript/reference/global_objects/bigint64array/index.md
+++ b/files/fr/web/javascript/reference/global_objects/bigint64array/index.md
@@ -11,123 +11,116 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/BigInt64Array
 original_slug: Web/JavaScript/Reference/Objets_globaux/BigInt64Array
 ---
-<div>{{JSRef}}</div>
-
-<p>Le tableau typé <strong><code>BigInt64Array</code></strong> permet de représenter un tableau d'entiers signés représentés sur 64 bits, où l'ordre des octets correspond à celui de la plateforme utilisée. Si on souhaite contrôler l'ordre des octets utilisé (le « boutisme »), on utilisera un objet {{jsxref("DataView")}} à la place. Les éléments du tableau sont initialisés à <code>0n</code>. Une fois que le tableau est construit, on peut manipuler ses différents éléments grâce aux méthodes de l'objet ou grâce à la notation usuelle (avec les crochets).</p>
-
-<h2 id="Syntaxe">Syntaxe</h2>
-
-<pre class="syntaxbox">new BigInt64Array();
-new BigInt64Array(longueur);
-new BigInt64Array(tableauTypé);
-new BigInt64Array(objet);
-new BigInt64Array(tampon [, décalage [, longueur]]);</pre>
-
-<p>Pour plus d'informations sur la syntaxe du constructeur et le rôle des différents paramètres, voir la page <em><a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/TypedArray#Syntaxe">TypedArray</a></em>.</p>
-
-<h2 id="Propriétés">Propriétés</h2>
-
-<dl>
- <dt>{{jsxref("TypedArray.BYTES_PER_ELEMENT", "BigInt64Array.BYTES_PER_ELEMENT")}}</dt>
- <dd>Cette propriété renvoie un nombre correspondant à la quantité d'octets pour un élément du tableau. Dans le cas d'<code>BigInt64Array</code>, ce sera <code>8</code>.</dd>
- <dt><code>BigInt64Array.length</code></dt>
- <dd>La propriété de longueur statique qui vaut 3. Pour connaître le nombre d'élément, voir {{jsxref("TypedArray.prototype.length", "BigInt64Array.prototype.length")}}.</dd>
- <dt>{{jsxref("TypedArray.name", "BigInt64Array.name")}}</dt>
- <dd>Cette propriété renvoie la chaîne de caractères correspondant au nom du constructeur. Pour <code>BigInt64Array</code> ce sera : "BigInt64Array".</dd>
- <dt>{{jsxref("TypedArray.prototype", "BigInt64Array.prototype")}}</dt>
- <dd>Le prototype des objets <em>TypedArray</em>.</dd>
-</dl>
-
-<h2 id="Méthodes">Méthodes</h2>
-
-<dl>
- <dt>{{jsxref("TypedArray.from", "BigInt64Array.from()")}}</dt>
- <dd>Cette méthode permet de créer un nouveau tableau typé <code>BigInt64Array</code> à partir d'un itérable ou d'un objet semblable à un tableau. Voir aussi {{jsxref("Array.from()")}}.</dd>
- <dt>{{jsxref("TypedArray.of", "BigInt64Array.of()")}}</dt>
- <dd>Cette méthode permet de créer un nouvel objet <code>BigInt64Array</code> à partir d'un nombre d'arguments variables. Voir aussi {{jsxref("Array.of()")}}.</dd>
-</dl>
-
-<h2 id="Prototype_BigInt64Array">Prototype <code>BigInt64Array</code></h2>
-
-<p>Tous les objets <code>BigInt64Array</code> héritent de {{jsxref("TypedArray.prototype", "%TypedArray%.prototype")}}.</p>
-
-<h3 id="Propriétés_2">Propriétés</h3>
-
-<dl>
- <dt><code>BigInt64Array.prototype.constructor</code></dt>
- <dd>Cette propriété renvoie la fonction qui a créé l'instance du prototype. Par défaut, ce sera le constructeur <code>BigInt64Array</code>.</dd>
- <dt>{{jsxref("TypedArray.prototype.buffer", "BigInt64Array.prototype.buffer")}} {{readonlyInline}}</dt>
- <dd>Cette propriété renvoie l'objet {{jsxref("ArrayBuffer")}} référencé par l'objet <code>BigInt64Array</code> Elle est déterminée lors de la construction et est accessible uniquement en <strong>lecture seule</strong>.</dd>
- <dt>{{jsxref("TypedArray.prototype.byteLength", "BigInt64Array.prototype.byteLength")}} {{readonlyInline}}</dt>
- <dd>Cette propriété renvoie la longueur, exprimée en octets, de l'objet <code>BigInt64Array</code> à partir du début de l'objet {{jsxref("ArrayBuffer")}} correspondant. Elle est déterminée lors de la construction et est accessible uniquement en <strong>lecture seule</strong>.</dd>
- <dt>{{jsxref("TypedArray.prototype.byteOffset", "BigInt64Array.prototype.byteOffset")}} {{readonlyInline}}</dt>
- <dd>Cette propriété renvoie le décalage, en nombre d'octets, entre le début du tableau typé courant et du début du {{jsxref("ArrayBuffer")}} correspondant. Elle est déterminée lors de la construction et est accessible uniquement en <strong>lecture seule</strong>.</dd>
- <dt>{{jsxref("TypedArray.prototype.length", "BigInt64Array.prototype.length")}} {{readonlyInline}}</dt>
- <dd>Cette propriété renvoie le nombre d'éléments contenus dans le tableau <code>BigInt64Array</code>. Elle est déterminée lors de la construction et est accessible uniquement en <strong>lecture seule</strong>.</dd>
-</dl>
-
-<h3 id="Méthodes_2">Méthodes</h3>
-
-<dl>
- <dt>{{jsxref("TypedArray.copyWithin", "BigInt64Array.prototype.copyWithin()")}}</dt>
- <dd>Copie une suite d'éléments d'un tableau dans le tableau. Voir également {{jsxref("Array.prototype.copyWithin()")}}.</dd>
- <dt>{{jsxref("TypedArray.entries", "BigInt64Array.prototype.entries()")}}</dt>
- <dd>Renvoie un nouvel objet <code>Array Iterator</code> qui contient les paires clé/valeur pour chaque indice du tableau. Voir également {{jsxref("Array.prototype.entries()")}}.</dd>
- <dt>{{jsxref("TypedArray.every", "BigInt64Array.prototype.every()")}}</dt>
- <dd>Teste si l'ensemble des éléments du tableau remplissent une certaine condition donnée par une fonction de test. Voir également {{jsxref("Array.prototype.every()")}}.</dd>
- <dt>{{jsxref("TypedArray.fill", "BigInt64Array.prototype.fill()")}}</dt>
- <dd>Remplit les éléments d'un tableau avec une certaine valeur pour les éléments compris entre un indice de début et un indice de fin. Voir également {{jsxref("Array.prototype.fill()")}}.</dd>
- <dt>{{jsxref("TypedArray.filter", "BigInt64Array.prototype.filter()")}}</dt>
- <dd>Crée un nouveau tableau dont tous les éléments proviennent de ce tableau et respectent une condition fournie par une fonction de test. Voir également {{jsxref("Array.prototype.filter()")}}.</dd>
- <dt>{{jsxref("TypedArray.find", "BigInt64Array.prototype.find()")}}</dt>
- <dd>Renvoie une valeur trouvée dans le tableau s'il existe un élément du tableau qui satisfait une condition fournie par une fonction de test, s'il n'y a pas de tel élément <code>undefined</code> sera renvoyé. Voir également {{jsxref("Array.prototype.find()")}}.</dd>
- <dt>{{jsxref("TypedArray.findIndex", "BigInt64Array.prototype.findIndex()")}}</dt>
- <dd>Renvoie l'indice d'un élément qui satisfait une condition fournie par une fonction de test, si aucun élément ne remplit la condition -1 sera renvoyé. Voir également {{jsxref("Array.prototype.findIndex()")}}.</dd>
- <dt>{{jsxref("TypedArray.forEach", "BigInt64Array.prototype.forEach()")}}</dt>
- <dd>Appelle une fonction pour chacun des élément du tableau. Voir également {{jsxref("Array.prototype.forEach()")}}.</dd>
- <dt>{{jsxref("TypedArray.includes", "BigInt64Array.prototype.includes()")}}</dt>
- <dd>Détermine si le tableau typé contient un élément donné. Cette méthode renvoie <code>true</code> ou <code>false</code> selon le cas de figure. Voir également {{jsxref("Array.prototype.includes()")}}.</dd>
- <dt>{{jsxref("TypedArray.indexOf", "BigInt64Array.prototype.indexOf()")}}</dt>
- <dd>Renvoie le premier indice (le plus petit) d'un élément du tableau qui est égal à la valeur fournie. Si aucun élément ne correspond, la valeur -1 sera renvoyée. Voir également {{jsxref("Array.prototype.indexOf()")}}.</dd>
- <dt>{{jsxref("TypedArray.join", "BigInt64Array.prototype.join()")}}</dt>
- <dd>Fusionne l'ensemble des éléments du tableau en une chaîne de caractères. Voir également {{jsxref("Array.prototype.join()")}}.</dd>
- <dt>{{jsxref("TypedArray.keys", "BigInt64Array.prototype.keys()")}}</dt>
- <dd>Renvoie un nouvel objet <code>Array Iterator</code> qui contient les clés de chaque indice du tableau. Voir également {{jsxref("Array.prototype.keys()")}}.</dd>
- <dt>{{jsxref("TypedArray.lastIndexOf", "BigInt64Array.prototype.lastIndexOf()")}}</dt>
- <dd>Renvoie le dernier indice (le plus élevé) d'un élément du tableau qui est égal à la valeur fournie. Si aucun élément ne correspond, la valeur -1 sera renvoyée. Voir également {{jsxref("Array.prototype.lastIndexOf()")}}.</dd>
- <dt>{{jsxref("TypedArray.map", "BigInt64Array.prototype.map()")}}</dt>
- <dd>Crée un nouveau tableau dont les éléments sont les images des éléments du tableau courant par une fonction donnée. Voir également {{jsxref("Array.prototype.map()")}}.</dd>
- <dt>{{jsxref("TypedArray.reduce", "BigInt64Array.prototype.reduce()")}}</dt>
- <dd>Applique une fonction sur un accumulateur et chaque élément du tableau (de gauche à droite) afin de réduire le tableau en une seule valeur. Voir également {{jsxref("Array.prototype.reduce()")}}.</dd>
- <dt>{{jsxref("TypedArray.reduceRight", "BigInt64Array.prototype.reduceRight()")}}</dt>
- <dd>Applique une fonction sur un accumulateur et chaque élément du tableau (de droite à gauche) afin de réduire le tableau en une seule valeur. Voir également {{jsxref("Array.prototype.reduceRight()")}}.</dd>
- <dt>{{jsxref("TypedArray.reverse", "BigInt64Array.prototype.reverse()")}}</dt>
- <dd>Inverse l'ordre des éléments d'un tableau. Le premier élément du tableau devient le dernier et le dernier devient le premier (et ainsi de suite). Voir également {{jsxref("Array.prototype.reverse()")}}.</dd>
- <dt>{{jsxref("TypedArray.set", "BigInt64Array.prototype.set()")}}</dt>
- <dd>Enregistre plusieurs valeurs dans le tableau typé à partir de valeurs d'un autre tableau.</dd>
- <dt>{{jsxref("TypedArray.slice", "BigInt64Array.prototype.slice()")}}</dt>
- <dd>Extrait un fragment d'un tableau et renvoie ce fragment. Voir également {{jsxref("Array.prototype.slice()")}}.</dd>
- <dt>{{jsxref("TypedArray.some", "BigInt64Array.prototype.some()")}}</dt>
- <dd>Renvoie <code>true</code> si au moins un des éléments remplit une condition donnée par une fonction de test. Voir également {{jsxref("Array.prototype.some()")}}.</dd>
- <dt>{{jsxref("TypedArray.sort", "BigInt64Array.prototype.sort()")}}</dt>
- <dd>Trie les éléments du tableau et renvoie ce tableau. Voir également {{jsxref("Array.prototype.sort()")}}.</dd>
- <dt>{{jsxref("TypedArray.subarray", "BigInt64Array.prototype.subarray()")}}</dt>
- <dd>Renvoie un nouvel objet <code>BigInt64Array</code> qui est le fragment du tableau courant, entre les indices de début et de fin donnés.</dd>
- <dt>{{jsxref("TypedArray.values", "BigInt64Array.prototype.values()")}}</dt>
- <dd>Renvoie un nouvel objet <code>Array Iterator</code> qui contient les valeurs correspondantes à chaque indice du tableau. Voir également {{jsxref("Array.prototype.values()")}}.</dd>
- <dt>{{jsxref("TypedArray.toLocaleString", "BigInt64Array.prototype.toLocaleString()")}}</dt>
- <dd>Renvoie une chaîne de caractères localisée qui représente le tableau et ses éléments. Voir également {{jsxref("Array.prototype.toLocaleString()")}}.</dd>
- <dt>{{jsxref("TypedArray.toString", "BigInt64Array.prototype.toString()")}}</dt>
- <dd>Renvoie une chaîne de caractère qui représente le tableau et ses éléments. Voir également {{jsxref("Array.prototype.toString()")}}.</dd>
- <dt>{{jsxref("TypedArray.@@iterator", "BigInt64Array.prototype[@@iterator]()")}}</dt>
- <dd>Renvoie un nouvel objet <code>Array Iterator</code> qui contient les valeurs correspondantes à chaque indice du tableau.</dd>
-</dl>
-
-<h2 id="Exemples">Exemples</h2>
-
-<p>Différentes façons de créer un objet <code>BigInt64Array</code> :</p>
-
-<pre class="brush: js">// Construction à partir d'une longueur
+{{JSRef}}
+
+Le tableau typé **`BigInt64Array`** permet de représenter un tableau d'entiers signés représentés sur 64 bits, où l'ordre des octets correspond à celui de la plateforme utilisée. Si on souhaite contrôler l'ordre des octets utilisé (le « boutisme »), on utilisera un objet {{jsxref("DataView")}} à la place. Les éléments du tableau sont initialisés à `0n`. Une fois que le tableau est construit, on peut manipuler ses différents éléments grâce aux méthodes de l'objet ou grâce à la notation usuelle (avec les crochets).
+
+## Syntaxe
+
+    new BigInt64Array();
+    new BigInt64Array(longueur);
+    new BigInt64Array(tableauTypé);
+    new BigInt64Array(objet);
+    new BigInt64Array(tampon [, décalage [, longueur]]);
+
+Pour plus d'informations sur la syntaxe du constructeur et le rôle des différents paramètres, voir la page _[TypedArray](/fr/docs/Web/JavaScript/Reference/Objets_globaux/TypedArray#Syntaxe)_.
+
+## Propriétés
+
+- {{jsxref("TypedArray.BYTES_PER_ELEMENT", "BigInt64Array.BYTES_PER_ELEMENT")}}
+  - : Cette propriété renvoie un nombre correspondant à la quantité d'octets pour un élément du tableau. Dans le cas d'`BigInt64Array`, ce sera `8`.
+- `BigInt64Array.length`
+  - : La propriété de longueur statique qui vaut 3. Pour connaître le nombre d'élément, voir {{jsxref("TypedArray.prototype.length", "BigInt64Array.prototype.length")}}.
+- {{jsxref("TypedArray.name", "BigInt64Array.name")}}
+  - : Cette propriété renvoie la chaîne de caractères correspondant au nom du constructeur. Pour `BigInt64Array` ce sera : "BigInt64Array".
+- {{jsxref("TypedArray.prototype", "BigInt64Array.prototype")}}
+  - : Le prototype des objets _TypedArray_.
+
+## Méthodes
+
+- {{jsxref("TypedArray.from", "BigInt64Array.from()")}}
+  - : Cette méthode permet de créer un nouveau tableau typé `BigInt64Array` à partir d'un itérable ou d'un objet semblable à un tableau. Voir aussi {{jsxref("Array.from()")}}.
+- {{jsxref("TypedArray.of", "BigInt64Array.of()")}}
+  - : Cette méthode permet de créer un nouvel objet `BigInt64Array` à partir d'un nombre d'arguments variables. Voir aussi {{jsxref("Array.of()")}}.
+
+## Prototype `BigInt64Array`
+
+Tous les objets `BigInt64Array` héritent de {{jsxref("TypedArray.prototype", "%TypedArray%.prototype")}}.
+
+### Propriétés
+
+- `BigInt64Array.prototype.constructor`
+  - : Cette propriété renvoie la fonction qui a créé l'instance du prototype. Par défaut, ce sera le constructeur `BigInt64Array`.
+- {{jsxref("TypedArray.prototype.buffer", "BigInt64Array.prototype.buffer")}} {{readonlyInline}}
+  - : Cette propriété renvoie l'objet {{jsxref("ArrayBuffer")}} référencé par l'objet `BigInt64Array` Elle est déterminée lors de la construction et est accessible uniquement en **lecture seule**.
+- {{jsxref("TypedArray.prototype.byteLength", "BigInt64Array.prototype.byteLength")}} {{readonlyInline}}
+  - : Cette propriété renvoie la longueur, exprimée en octets, de l'objet `BigInt64Array` à partir du début de l'objet {{jsxref("ArrayBuffer")}} correspondant. Elle est déterminée lors de la construction et est accessible uniquement en **lecture seule**.
+- {{jsxref("TypedArray.prototype.byteOffset", "BigInt64Array.prototype.byteOffset")}} {{readonlyInline}}
+  - : Cette propriété renvoie le décalage, en nombre d'octets, entre le début du tableau typé courant et du début du {{jsxref("ArrayBuffer")}} correspondant. Elle est déterminée lors de la construction et est accessible uniquement en **lecture seule**.
+- {{jsxref("TypedArray.prototype.length", "BigInt64Array.prototype.length")}} {{readonlyInline}}
+  - : Cette propriété renvoie le nombre d'éléments contenus dans le tableau `BigInt64Array`. Elle est déterminée lors de la construction et est accessible uniquement en **lecture seule**.
+
+### Méthodes
+
+- {{jsxref("TypedArray.copyWithin", "BigInt64Array.prototype.copyWithin()")}}
+  - : Copie une suite d'éléments d'un tableau dans le tableau. Voir également {{jsxref("Array.prototype.copyWithin()")}}.
+- {{jsxref("TypedArray.entries", "BigInt64Array.prototype.entries()")}}
+  - : Renvoie un nouvel objet `Array Iterator` qui contient les paires clé/valeur pour chaque indice du tableau. Voir également {{jsxref("Array.prototype.entries()")}}.
+- {{jsxref("TypedArray.every", "BigInt64Array.prototype.every()")}}
+  - : Teste si l'ensemble des éléments du tableau remplissent une certaine condition donnée par une fonction de test. Voir également {{jsxref("Array.prototype.every()")}}.
+- {{jsxref("TypedArray.fill", "BigInt64Array.prototype.fill()")}}
+  - : Remplit les éléments d'un tableau avec une certaine valeur pour les éléments compris entre un indice de début et un indice de fin. Voir également {{jsxref("Array.prototype.fill()")}}.
+- {{jsxref("TypedArray.filter", "BigInt64Array.prototype.filter()")}}
+  - : Crée un nouveau tableau dont tous les éléments proviennent de ce tableau et respectent une condition fournie par une fonction de test. Voir également {{jsxref("Array.prototype.filter()")}}.
+- {{jsxref("TypedArray.find", "BigInt64Array.prototype.find()")}}
+  - : Renvoie une valeur trouvée dans le tableau s'il existe un élément du tableau qui satisfait une condition fournie par une fonction de test, s'il n'y a pas de tel élément `undefined` sera renvoyé. Voir également {{jsxref("Array.prototype.find()")}}.
+- {{jsxref("TypedArray.findIndex", "BigInt64Array.prototype.findIndex()")}}
+  - : Renvoie l'indice d'un élément qui satisfait une condition fournie par une fonction de test, si aucun élément ne remplit la condition -1 sera renvoyé. Voir également {{jsxref("Array.prototype.findIndex()")}}.
+- {{jsxref("TypedArray.forEach", "BigInt64Array.prototype.forEach()")}}
+  - : Appelle une fonction pour chacun des élément du tableau. Voir également {{jsxref("Array.prototype.forEach()")}}.
+- {{jsxref("TypedArray.includes", "BigInt64Array.prototype.includes()")}}
+  - : Détermine si le tableau typé contient un élément donné. Cette méthode renvoie `true` ou `false` selon le cas de figure. Voir également {{jsxref("Array.prototype.includes()")}}.
+- {{jsxref("TypedArray.indexOf", "BigInt64Array.prototype.indexOf()")}}
+  - : Renvoie le premier indice (le plus petit) d'un élément du tableau qui est égal à la valeur fournie. Si aucun élément ne correspond, la valeur -1 sera renvoyée. Voir également {{jsxref("Array.prototype.indexOf()")}}.
+- {{jsxref("TypedArray.join", "BigInt64Array.prototype.join()")}}
+  - : Fusionne l'ensemble des éléments du tableau en une chaîne de caractères. Voir également {{jsxref("Array.prototype.join()")}}.
+- {{jsxref("TypedArray.keys", "BigInt64Array.prototype.keys()")}}
+  - : Renvoie un nouvel objet `Array Iterator` qui contient les clés de chaque indice du tableau. Voir également {{jsxref("Array.prototype.keys()")}}.
+- {{jsxref("TypedArray.lastIndexOf", "BigInt64Array.prototype.lastIndexOf()")}}
+  - : Renvoie le dernier indice (le plus élevé) d'un élément du tableau qui est égal à la valeur fournie. Si aucun élément ne correspond, la valeur -1 sera renvoyée. Voir également {{jsxref("Array.prototype.lastIndexOf()")}}.
+- {{jsxref("TypedArray.map", "BigInt64Array.prototype.map()")}}
+  - : Crée un nouveau tableau dont les éléments sont les images des éléments du tableau courant par une fonction donnée. Voir également {{jsxref("Array.prototype.map()")}}.
+- {{jsxref("TypedArray.reduce", "BigInt64Array.prototype.reduce()")}}
+  - : Applique une fonction sur un accumulateur et chaque élément du tableau (de gauche à droite) afin de réduire le tableau en une seule valeur. Voir également {{jsxref("Array.prototype.reduce()")}}.
+- {{jsxref("TypedArray.reduceRight", "BigInt64Array.prototype.reduceRight()")}}
+  - : Applique une fonction sur un accumulateur et chaque élément du tableau (de droite à gauche) afin de réduire le tableau en une seule valeur. Voir également {{jsxref("Array.prototype.reduceRight()")}}.
+- {{jsxref("TypedArray.reverse", "BigInt64Array.prototype.reverse()")}}
+  - : Inverse l'ordre des éléments d'un tableau. Le premier élément du tableau devient le dernier et le dernier devient le premier (et ainsi de suite). Voir également {{jsxref("Array.prototype.reverse()")}}.
+- {{jsxref("TypedArray.set", "BigInt64Array.prototype.set()")}}
+  - : Enregistre plusieurs valeurs dans le tableau typé à partir de valeurs d'un autre tableau.
+- {{jsxref("TypedArray.slice", "BigInt64Array.prototype.slice()")}}
+  - : Extrait un fragment d'un tableau et renvoie ce fragment. Voir également {{jsxref("Array.prototype.slice()")}}.
+- {{jsxref("TypedArray.some", "BigInt64Array.prototype.some()")}}
+  - : Renvoie `true` si au moins un des éléments remplit une condition donnée par une fonction de test. Voir également {{jsxref("Array.prototype.some()")}}.
+- {{jsxref("TypedArray.sort", "BigInt64Array.prototype.sort()")}}
+  - : Trie les éléments du tableau et renvoie ce tableau. Voir également {{jsxref("Array.prototype.sort()")}}.
+- {{jsxref("TypedArray.subarray", "BigInt64Array.prototype.subarray()")}}
+  - : Renvoie un nouvel objet `BigInt64Array` qui est le fragment du tableau courant, entre les indices de début et de fin donnés.
+- {{jsxref("TypedArray.values", "BigInt64Array.prototype.values()")}}
+  - : Renvoie un nouvel objet `Array Iterator` qui contient les valeurs correspondantes à chaque indice du tableau. Voir également {{jsxref("Array.prototype.values()")}}.
+- {{jsxref("TypedArray.toLocaleString", "BigInt64Array.prototype.toLocaleString()")}}
+  - : Renvoie une chaîne de caractères localisée qui représente le tableau et ses éléments. Voir également {{jsxref("Array.prototype.toLocaleString()")}}.
+- {{jsxref("TypedArray.toString", "BigInt64Array.prototype.toString()")}}
+  - : Renvoie une chaîne de caractère qui représente le tableau et ses éléments. Voir également {{jsxref("Array.prototype.toString()")}}.
+- {{jsxref("TypedArray.@@iterator", "BigInt64Array.prototype[@@iterator]()")}}
+  - : Renvoie un nouvel objet `Array Iterator` qui contient les valeurs correspondantes à chaque indice du tableau.
+
+## Exemples
+
+Différentes façons de créer un objet `BigInt64Array` :
+
+```js
+// Construction à partir d'une longueur
 var bigInt64 = new BigInt64Array(2);
 bigInt64[0] = 42n;
 console.log(bigInt64[0]); // 42n
@@ -151,33 +144,20 @@ var z = new BigInt64Array(buffer, 0, 4);
 var iterable = function*(){ yield* [1n, 2n, 3n]; }();
 var BigInt64 = new BigInt64Array(iterable);
 // BigInt64Array[1n, 2n, 3n]
-</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><a href="https://tc39.github.io/proposal-bigint/#sec-typedarrays-and-dataview">Proposition pour <code>BigInt</code></a></td>
-   <td>Proposition de niveau 3</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.BigInt64Array")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li><a href="/fr/docs/Web/JavaScript/Tableaux_typés">Les tableaux typés en JavaScript</a></li>
- <li>{{jsxref("BigUint64Array")}}</li>
- <li>{{jsxref("DataView")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                     | État                    | Commentaires |
+| ------------------------------------------------------------------------------------------------- | ----------------------- | ------------ |
+| [Proposition pour `BigInt`](https://tc39.github.io/proposal-bigint/#sec-typedarrays-and-dataview) | Proposition de niveau 3 |              |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.BigInt64Array")}}
+
+## Voir aussi
+
+- [Les tableaux typés en JavaScript](/fr/docs/Web/JavaScript/Tableaux_typés)
+- {{jsxref("BigUint64Array")}}
+- {{jsxref("DataView")}}
diff --git a/files/fr/web/javascript/reference/global_objects/biguint64array/index.md b/files/fr/web/javascript/reference/global_objects/biguint64array/index.md
index 3eca7d67bd..12be32dff7 100644
--- a/files/fr/web/javascript/reference/global_objects/biguint64array/index.md
+++ b/files/fr/web/javascript/reference/global_objects/biguint64array/index.md
@@ -11,123 +11,116 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/BigUint64Array
 original_slug: Web/JavaScript/Reference/Objets_globaux/BigUint64Array
 ---
-<div>{{JSRef}}</div>
-
-<p>Le tableau typé <strong><code>BigUint64Array</code></strong> permet de représenter un tableau d'entiers non signés représentés sur 64 bits, où l'ordre des octets correspond à celui de la plateforme utilisée. Si on souhaite contrôler l'ordre des octets utilisé (le « boutisme »), on utilisera un objet {{jsxref("DataView")}} à la place. Les éléments du tableau sont initialisés à <code>0n</code>. Une fois que le tableau est construit, on peut manipuler ses différents éléments grâce aux méthodes de l'objet ou grâce à la notation usuelle (avec les crochets).</p>
-
-<h2 id="Syntaxe">Syntaxe</h2>
-
-<pre class="syntaxbox">new BigUint64Array();
-new BigUint64Array(longueur);
-new BigUint64Array(tableauTypé);
-new BigUint64Array(objet);
-new BigUint64Array(tampon [, décalage [, longueur]]);</pre>
-
-<p>Pour plus d'informations sur la syntaxe du constructeur et le rôle des différents paramètres, voir la page <em><a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/TypedArray#Syntaxe">TypedArray</a></em>.</p>
-
-<h2 id="Propriétés">Propriétés</h2>
-
-<dl>
- <dt>{{jsxref("TypedArray.BYTES_PER_ELEMENT", "BigUint64Array.BYTES_PER_ELEMENT")}}</dt>
- <dd>Cette propriété renvoie un nombre correspondant à la quantité d'octets pour un élément du tableau. Dans le cas d'<code>BigUint64Array</code>, ce sera <code>8</code>.</dd>
- <dt><code>BigUint64Array.length</code></dt>
- <dd>La propriété de longueur statique qui vaut 3. Pour connaître le nombre d'élément, voir {{jsxref("TypedArray.prototype.length", "BigUint64Array.prototype.length")}}.</dd>
- <dt>{{jsxref("TypedArray.name", "BigUint64Array.name")}}</dt>
- <dd>Cette propriété renvoie la chaîne de caractères correspondant au nom du constructeur. Pour <code>BigUint64Array</code> ce sera : "BigUint64Array".</dd>
- <dt>{{jsxref("TypedArray.prototype", "BigUint64Array.prototype")}}</dt>
- <dd>Le prototype des objets <em>TypedArray</em>.</dd>
-</dl>
-
-<h2 id="Méthodes">Méthodes</h2>
-
-<dl>
- <dt>{{jsxref("TypedArray.from", "BigUint64Array.from()")}}</dt>
- <dd>Cette méthode permet de créer un nouveau tableau typé <code>BigUint64Array</code> à partir d'un itérable ou d'un objet semblable à un tableau. Voir aussi {{jsxref("Array.from()")}}.</dd>
- <dt>{{jsxref("TypedArray.of", "BigUint64Array.of()")}}</dt>
- <dd>Cette méthode permet de créer un nouvel objet <code>BigUint64Array</code> à partir d'un nombre d'arguments variables. Voir aussi {{jsxref("Array.of()")}}.</dd>
-</dl>
-
-<h2 id="Prototype_BigUint64Array">Prototype <code>BigUint64Array</code></h2>
-
-<p>Tous les objets <code>BigUint64Array</code> héritent de {{jsxref("TypedArray.prototype", "%TypedArray%.prototype")}}.</p>
-
-<h3 id="Propriétés_2">Propriétés</h3>
-
-<dl>
- <dt><code>BigUint64Array.prototype.constructor</code></dt>
- <dd>Cette propriété renvoie la fonction qui a créé l'instance du prototype. Par défaut, ce sera le constructeur <code>BigUint64Array</code>.</dd>
- <dt>{{jsxref("TypedArray.prototype.buffer", "BigUint64Array.prototype.buffer")}} {{readonlyInline}}</dt>
- <dd>Cette propriété renvoie l'objet {{jsxref("ArrayBuffer")}} référencé par l'objet <code>BigUint64Array</code> Elle est déterminée lors de la construction et est accessible uniquement en <strong>lecture seule</strong>.</dd>
- <dt>{{jsxref("TypedArray.prototype.byteLength", "BigUint64Array.prototype.byteLength")}} {{readonlyInline}}</dt>
- <dd>Cette propriété renvoie la longueur, exprimée en octets, de l'objet <code>BigUint64Array</code> à partir du début de l'objet {{jsxref("ArrayBuffer")}} correspondant. Elle est déterminée lors de la construction et est accessible uniquement en <strong>lecture seule</strong>.</dd>
- <dt>{{jsxref("TypedArray.prototype.byteOffset", "BigUint64Array.prototype.byteOffset")}} {{readonlyInline}}</dt>
- <dd>Cette propriété renvoie le décalage, en nombre d'octets, entre le début du tableau typé courant et du début du {{jsxref("ArrayBuffer")}} correspondant. Elle est déterminée lors de la construction et est accessible uniquement en <strong>lecture seule</strong>.</dd>
- <dt>{{jsxref("TypedArray.prototype.length", "BigUint64Array.prototype.length")}} {{readonlyInline}}</dt>
- <dd>Cette propriété renvoie le nombre d'éléments contenus dans le tableau <code>BigUint64Array</code>. Elle est déterminée lors de la construction et est accessible uniquement en <strong>lecture seule</strong>.</dd>
-</dl>
-
-<h3 id="Méthodes_2">Méthodes</h3>
-
-<dl>
- <dt>{{jsxref("TypedArray.copyWithin", "BigUint64Array.prototype.copyWithin()")}}</dt>
- <dd>Copie une suite d'éléments d'un tableau dans le tableau. Voir également {{jsxref("Array.prototype.copyWithin()")}}.</dd>
- <dt>{{jsxref("TypedArray.entries", "BigUint64Array.prototype.entries()")}}</dt>
- <dd>Renvoie un nouvel objet <code>Array Iterator</code> qui contient les paires clé/valeur pour chaque indice du tableau. Voir également {{jsxref("Array.prototype.entries()")}}.</dd>
- <dt>{{jsxref("TypedArray.every", "BigUint64Array.prototype.every()")}}</dt>
- <dd>Teste si l'ensemble des éléments du tableau remplissent une certaine condition donnée par une fonction de test. Voir également {{jsxref("Array.prototype.every()")}}.</dd>
- <dt>{{jsxref("TypedArray.fill", "BigUint64Array.prototype.fill()")}}</dt>
- <dd>Remplit les éléments d'un tableau avec une certaine valeur pour les éléments compris entre un indice de début et un indice de fin. Voir également {{jsxref("Array.prototype.fill()")}}.</dd>
- <dt>{{jsxref("TypedArray.filter", "BigUint64Array.prototype.filter()")}}</dt>
- <dd>Crée un nouveau tableau dont tous les éléments proviennent de ce tableau et respectent une condition fournie par une fonction de test. Voir également {{jsxref("Array.prototype.filter()")}}.</dd>
- <dt>{{jsxref("TypedArray.find", "BigUint64Array.prototype.find()")}}</dt>
- <dd>Renvoie une valeur trouvée dans le tableau s'il existe un élément du tableau qui satisfait une condition fournie par une fonction de test, s'il n'y a pas de tel élément <code>undefined</code> sera renvoyé. Voir également {{jsxref("Array.prototype.find()")}}.</dd>
- <dt>{{jsxref("TypedArray.findIndex", "BigUint64Array.prototype.findIndex()")}}</dt>
- <dd>Renvoie l'indice d'un élément qui satisfait une condition fournie par une fonction de test, si aucun élément ne remplit la condition -1 sera renvoyé. Voir également {{jsxref("Array.prototype.findIndex()")}}.</dd>
- <dt>{{jsxref("TypedArray.forEach", "BigUint64Array.prototype.forEach()")}}</dt>
- <dd>Appelle une fonction pour chacun des élément du tableau. Voir également {{jsxref("Array.prototype.forEach()")}}.</dd>
- <dt>{{jsxref("TypedArray.includes", "BigUint64Array.prototype.includes()")}}</dt>
- <dd>Détermine si le tableau typé contient un élément donné. Cette méthode renvoie <code>true</code> ou <code>false</code> selon le cas de figure. Voir également {{jsxref("Array.prototype.includes()")}}.</dd>
- <dt>{{jsxref("TypedArray.indexOf", "BigUint64Array.prototype.indexOf()")}}</dt>
- <dd>Renvoie le premier indice (le plus petit) d'un élément du tableau qui est égal à la valeur fournie. Si aucun élément ne correspond, la valeur -1 sera renvoyée. Voir également {{jsxref("Array.prototype.indexOf()")}}.</dd>
- <dt>{{jsxref("TypedArray.join", "BigUint64Array.prototype.join()")}}</dt>
- <dd>Fusionne l'ensemble des éléments du tableau en une chaîne de caractères. Voir également {{jsxref("Array.prototype.join()")}}.</dd>
- <dt>{{jsxref("TypedArray.keys", "BigUint64Array.prototype.keys()")}}</dt>
- <dd>Renvoie un nouvel objet <code>Array Iterator</code> qui contient les clés de chaque indice du tableau. Voir également {{jsxref("Array.prototype.keys()")}}.</dd>
- <dt>{{jsxref("TypedArray.lastIndexOf", "BigUint64Array.prototype.lastIndexOf()")}}</dt>
- <dd>Renvoie le dernier indice (le plus élevé) d'un élément du tableau qui est égal à la valeur fournie. Si aucun élément ne correspond, la valeur -1 sera renvoyée. Voir également {{jsxref("Array.prototype.lastIndexOf()")}}.</dd>
- <dt>{{jsxref("TypedArray.map", "BigUint64Array.prototype.map()")}}</dt>
- <dd>Crée un nouveau tableau dont les éléments sont les images des éléments du tableau courant par une fonction donnée. Voir également {{jsxref("Array.prototype.map()")}}.</dd>
- <dt>{{jsxref("TypedArray.reduce", "BigUint64Array.prototype.reduce()")}}</dt>
- <dd>Applique une fonction sur un accumulateur et chaque élément du tableau (de gauche à droite) afin de réduire le tableau en une seule valeur. Voir également {{jsxref("Array.prototype.reduce()")}}.</dd>
- <dt>{{jsxref("TypedArray.reduceRight", "BigUint64Array.prototype.reduceRight()")}}</dt>
- <dd>Applique une fonction sur un accumulateur et chaque élément du tableau (de droite à gauche) afin de réduire le tableau en une seule valeur. Voir également {{jsxref("Array.prototype.reduceRight()")}}.</dd>
- <dt>{{jsxref("TypedArray.reverse", "BigUint64Array.prototype.reverse()")}}</dt>
- <dd>Inverse l'ordre des éléments d'un tableau. Le premier élément du tableau devient le dernier et le dernier devient le premier (et ainsi de suite). Voir également {{jsxref("Array.prototype.reverse()")}}.</dd>
- <dt>{{jsxref("TypedArray.set", "BigUint64Array.prototype.set()")}}</dt>
- <dd>Enregistre plusieurs valeurs dans le tableau typé à partir de valeurs d'un autre tableau.</dd>
- <dt>{{jsxref("TypedArray.slice", "BigUint64Array.prototype.slice()")}}</dt>
- <dd>Extrait un fragment d'un tableau et renvoie ce fragment. Voir également {{jsxref("Array.prototype.slice()")}}.</dd>
- <dt>{{jsxref("TypedArray.some", "BigUint64Array.prototype.some()")}}</dt>
- <dd>Renvoie <code>true</code> si au moins un des éléments remplit une condition donnée par une fonction de test. Voir également {{jsxref("Array.prototype.some()")}}.</dd>
- <dt>{{jsxref("TypedArray.sort", "BigUint64Array.prototype.sort()")}}</dt>
- <dd>Trie les éléments du tableau et renvoie ce tableau. Voir également {{jsxref("Array.prototype.sort()")}}.</dd>
- <dt>{{jsxref("TypedArray.subarray", "BigUint64Array.prototype.subarray()")}}</dt>
- <dd>Renvoie un nouvel objet <code>BigUint64Array</code> qui est le fragment du tableau courant, entre les indices de début et de fin donnés.</dd>
- <dt>{{jsxref("TypedArray.values", "BigUint64Array.prototype.values()")}}</dt>
- <dd>Renvoie un nouvel objet <code>Array Iterator</code> qui contient les valeurs correspondantes à chaque indice du tableau. Voir également {{jsxref("Array.prototype.values()")}}.</dd>
- <dt>{{jsxref("TypedArray.toLocaleString", "BigUint64Array.prototype.toLocaleString()")}}</dt>
- <dd>Renvoie une chaîne de caractères localisée qui représente le tableau et ses éléments. Voir également {{jsxref("Array.prototype.toLocaleString()")}}.</dd>
- <dt>{{jsxref("TypedArray.toString", "BigUint64Array.prototype.toString()")}}</dt>
- <dd>Renvoie une chaîne de caractère qui représente le tableau et ses éléments. Voir également {{jsxref("Array.prototype.toString()")}}.</dd>
- <dt>{{jsxref("TypedArray.@@iterator", "BigUint64Array.prototype[@@iterator]()")}}</dt>
- <dd>Renvoie un nouvel objet <code>Array Iterator</code> qui contient les valeurs correspondantes à chaque indice du tableau.</dd>
-</dl>
-
-<h2 id="Exemples">Exemples</h2>
-
-<p>Différentes façons de créer un objet <code>BigUint64Array</code> :</p>
-
-<pre class="brush: js">// Construction à partir d'une longueur
+{{JSRef}}
+
+Le tableau typé **`BigUint64Array`** permet de représenter un tableau d'entiers non signés représentés sur 64 bits, où l'ordre des octets correspond à celui de la plateforme utilisée. Si on souhaite contrôler l'ordre des octets utilisé (le « boutisme »), on utilisera un objet {{jsxref("DataView")}} à la place. Les éléments du tableau sont initialisés à `0n`. Une fois que le tableau est construit, on peut manipuler ses différents éléments grâce aux méthodes de l'objet ou grâce à la notation usuelle (avec les crochets).
+
+## Syntaxe
+
+    new BigUint64Array();
+    new BigUint64Array(longueur);
+    new BigUint64Array(tableauTypé);
+    new BigUint64Array(objet);
+    new BigUint64Array(tampon [, décalage [, longueur]]);
+
+Pour plus d'informations sur la syntaxe du constructeur et le rôle des différents paramètres, voir la page _[TypedArray](/fr/docs/Web/JavaScript/Reference/Objets_globaux/TypedArray#Syntaxe)_.
+
+## Propriétés
+
+- {{jsxref("TypedArray.BYTES_PER_ELEMENT", "BigUint64Array.BYTES_PER_ELEMENT")}}
+  - : Cette propriété renvoie un nombre correspondant à la quantité d'octets pour un élément du tableau. Dans le cas d'`BigUint64Array`, ce sera `8`.
+- `BigUint64Array.length`
+  - : La propriété de longueur statique qui vaut 3. Pour connaître le nombre d'élément, voir {{jsxref("TypedArray.prototype.length", "BigUint64Array.prototype.length")}}.
+- {{jsxref("TypedArray.name", "BigUint64Array.name")}}
+  - : Cette propriété renvoie la chaîne de caractères correspondant au nom du constructeur. Pour `BigUint64Array` ce sera : "BigUint64Array".
+- {{jsxref("TypedArray.prototype", "BigUint64Array.prototype")}}
+  - : Le prototype des objets _TypedArray_.
+
+## Méthodes
+
+- {{jsxref("TypedArray.from", "BigUint64Array.from()")}}
+  - : Cette méthode permet de créer un nouveau tableau typé `BigUint64Array` à partir d'un itérable ou d'un objet semblable à un tableau. Voir aussi {{jsxref("Array.from()")}}.
+- {{jsxref("TypedArray.of", "BigUint64Array.of()")}}
+  - : Cette méthode permet de créer un nouvel objet `BigUint64Array` à partir d'un nombre d'arguments variables. Voir aussi {{jsxref("Array.of()")}}.
+
+## Prototype `BigUint64Array`
+
+Tous les objets `BigUint64Array` héritent de {{jsxref("TypedArray.prototype", "%TypedArray%.prototype")}}.
+
+### Propriétés
+
+- `BigUint64Array.prototype.constructor`
+  - : Cette propriété renvoie la fonction qui a créé l'instance du prototype. Par défaut, ce sera le constructeur `BigUint64Array`.
+- {{jsxref("TypedArray.prototype.buffer", "BigUint64Array.prototype.buffer")}} {{readonlyInline}}
+  - : Cette propriété renvoie l'objet {{jsxref("ArrayBuffer")}} référencé par l'objet `BigUint64Array` Elle est déterminée lors de la construction et est accessible uniquement en **lecture seule**.
+- {{jsxref("TypedArray.prototype.byteLength", "BigUint64Array.prototype.byteLength")}} {{readonlyInline}}
+  - : Cette propriété renvoie la longueur, exprimée en octets, de l'objet `BigUint64Array` à partir du début de l'objet {{jsxref("ArrayBuffer")}} correspondant. Elle est déterminée lors de la construction et est accessible uniquement en **lecture seule**.
+- {{jsxref("TypedArray.prototype.byteOffset", "BigUint64Array.prototype.byteOffset")}} {{readonlyInline}}
+  - : Cette propriété renvoie le décalage, en nombre d'octets, entre le début du tableau typé courant et du début du {{jsxref("ArrayBuffer")}} correspondant. Elle est déterminée lors de la construction et est accessible uniquement en **lecture seule**.
+- {{jsxref("TypedArray.prototype.length", "BigUint64Array.prototype.length")}} {{readonlyInline}}
+  - : Cette propriété renvoie le nombre d'éléments contenus dans le tableau `BigUint64Array`. Elle est déterminée lors de la construction et est accessible uniquement en **lecture seule**.
+
+### Méthodes
+
+- {{jsxref("TypedArray.copyWithin", "BigUint64Array.prototype.copyWithin()")}}
+  - : Copie une suite d'éléments d'un tableau dans le tableau. Voir également {{jsxref("Array.prototype.copyWithin()")}}.
+- {{jsxref("TypedArray.entries", "BigUint64Array.prototype.entries()")}}
+  - : Renvoie un nouvel objet `Array Iterator` qui contient les paires clé/valeur pour chaque indice du tableau. Voir également {{jsxref("Array.prototype.entries()")}}.
+- {{jsxref("TypedArray.every", "BigUint64Array.prototype.every()")}}
+  - : Teste si l'ensemble des éléments du tableau remplissent une certaine condition donnée par une fonction de test. Voir également {{jsxref("Array.prototype.every()")}}.
+- {{jsxref("TypedArray.fill", "BigUint64Array.prototype.fill()")}}
+  - : Remplit les éléments d'un tableau avec une certaine valeur pour les éléments compris entre un indice de début et un indice de fin. Voir également {{jsxref("Array.prototype.fill()")}}.
+- {{jsxref("TypedArray.filter", "BigUint64Array.prototype.filter()")}}
+  - : Crée un nouveau tableau dont tous les éléments proviennent de ce tableau et respectent une condition fournie par une fonction de test. Voir également {{jsxref("Array.prototype.filter()")}}.
+- {{jsxref("TypedArray.find", "BigUint64Array.prototype.find()")}}
+  - : Renvoie une valeur trouvée dans le tableau s'il existe un élément du tableau qui satisfait une condition fournie par une fonction de test, s'il n'y a pas de tel élément `undefined` sera renvoyé. Voir également {{jsxref("Array.prototype.find()")}}.
+- {{jsxref("TypedArray.findIndex", "BigUint64Array.prototype.findIndex()")}}
+  - : Renvoie l'indice d'un élément qui satisfait une condition fournie par une fonction de test, si aucun élément ne remplit la condition -1 sera renvoyé. Voir également {{jsxref("Array.prototype.findIndex()")}}.
+- {{jsxref("TypedArray.forEach", "BigUint64Array.prototype.forEach()")}}
+  - : Appelle une fonction pour chacun des élément du tableau. Voir également {{jsxref("Array.prototype.forEach()")}}.
+- {{jsxref("TypedArray.includes", "BigUint64Array.prototype.includes()")}}
+  - : Détermine si le tableau typé contient un élément donné. Cette méthode renvoie `true` ou `false` selon le cas de figure. Voir également {{jsxref("Array.prototype.includes()")}}.
+- {{jsxref("TypedArray.indexOf", "BigUint64Array.prototype.indexOf()")}}
+  - : Renvoie le premier indice (le plus petit) d'un élément du tableau qui est égal à la valeur fournie. Si aucun élément ne correspond, la valeur -1 sera renvoyée. Voir également {{jsxref("Array.prototype.indexOf()")}}.
+- {{jsxref("TypedArray.join", "BigUint64Array.prototype.join()")}}
+  - : Fusionne l'ensemble des éléments du tableau en une chaîne de caractères. Voir également {{jsxref("Array.prototype.join()")}}.
+- {{jsxref("TypedArray.keys", "BigUint64Array.prototype.keys()")}}
+  - : Renvoie un nouvel objet `Array Iterator` qui contient les clés de chaque indice du tableau. Voir également {{jsxref("Array.prototype.keys()")}}.
+- {{jsxref("TypedArray.lastIndexOf", "BigUint64Array.prototype.lastIndexOf()")}}
+  - : Renvoie le dernier indice (le plus élevé) d'un élément du tableau qui est égal à la valeur fournie. Si aucun élément ne correspond, la valeur -1 sera renvoyée. Voir également {{jsxref("Array.prototype.lastIndexOf()")}}.
+- {{jsxref("TypedArray.map", "BigUint64Array.prototype.map()")}}
+  - : Crée un nouveau tableau dont les éléments sont les images des éléments du tableau courant par une fonction donnée. Voir également {{jsxref("Array.prototype.map()")}}.
+- {{jsxref("TypedArray.reduce", "BigUint64Array.prototype.reduce()")}}
+  - : Applique une fonction sur un accumulateur et chaque élément du tableau (de gauche à droite) afin de réduire le tableau en une seule valeur. Voir également {{jsxref("Array.prototype.reduce()")}}.
+- {{jsxref("TypedArray.reduceRight", "BigUint64Array.prototype.reduceRight()")}}
+  - : Applique une fonction sur un accumulateur et chaque élément du tableau (de droite à gauche) afin de réduire le tableau en une seule valeur. Voir également {{jsxref("Array.prototype.reduceRight()")}}.
+- {{jsxref("TypedArray.reverse", "BigUint64Array.prototype.reverse()")}}
+  - : Inverse l'ordre des éléments d'un tableau. Le premier élément du tableau devient le dernier et le dernier devient le premier (et ainsi de suite). Voir également {{jsxref("Array.prototype.reverse()")}}.
+- {{jsxref("TypedArray.set", "BigUint64Array.prototype.set()")}}
+  - : Enregistre plusieurs valeurs dans le tableau typé à partir de valeurs d'un autre tableau.
+- {{jsxref("TypedArray.slice", "BigUint64Array.prototype.slice()")}}
+  - : Extrait un fragment d'un tableau et renvoie ce fragment. Voir également {{jsxref("Array.prototype.slice()")}}.
+- {{jsxref("TypedArray.some", "BigUint64Array.prototype.some()")}}
+  - : Renvoie `true` si au moins un des éléments remplit une condition donnée par une fonction de test. Voir également {{jsxref("Array.prototype.some()")}}.
+- {{jsxref("TypedArray.sort", "BigUint64Array.prototype.sort()")}}
+  - : Trie les éléments du tableau et renvoie ce tableau. Voir également {{jsxref("Array.prototype.sort()")}}.
+- {{jsxref("TypedArray.subarray", "BigUint64Array.prototype.subarray()")}}
+  - : Renvoie un nouvel objet `BigUint64Array` qui est le fragment du tableau courant, entre les indices de début et de fin donnés.
+- {{jsxref("TypedArray.values", "BigUint64Array.prototype.values()")}}
+  - : Renvoie un nouvel objet `Array Iterator` qui contient les valeurs correspondantes à chaque indice du tableau. Voir également {{jsxref("Array.prototype.values()")}}.
+- {{jsxref("TypedArray.toLocaleString", "BigUint64Array.prototype.toLocaleString()")}}
+  - : Renvoie une chaîne de caractères localisée qui représente le tableau et ses éléments. Voir également {{jsxref("Array.prototype.toLocaleString()")}}.
+- {{jsxref("TypedArray.toString", "BigUint64Array.prototype.toString()")}}
+  - : Renvoie une chaîne de caractère qui représente le tableau et ses éléments. Voir également {{jsxref("Array.prototype.toString()")}}.
+- {{jsxref("TypedArray.@@iterator", "BigUint64Array.prototype[@@iterator]()")}}
+  - : Renvoie un nouvel objet `Array Iterator` qui contient les valeurs correspondantes à chaque indice du tableau.
+
+## Exemples
+
+Différentes façons de créer un objet `BigUint64Array` :
+
+```js
+// Construction à partir d'une longueur
 var bigInt64 = new BigUint64Array(2);
 bigInt64[0] = 42n;
 console.log(bigInt64[0]); // 42n
@@ -151,33 +144,20 @@ var z = new BigUint64Array(buffer, 0, 4);
 var iterable = function*(){ yield* [1n, 2n, 3n]; }();
 var BigInt64 = new BigUint64Array(iterable);
 // BigUint64Array[1n, 2n, 3n]
-</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><a href="https://tc39.github.io/proposal-bigint/#sec-typedarrays-and-dataview">Proposition pour <code>BigInt</code></a></td>
-   <td>Proposition de niveau 3</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.BigUint64Array")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li><a href="/fr/docs/Web/JavaScript/Tableaux_typés">Les tableaux typés en JavaScript</a></li>
- <li>{{jsxref("BigUint64Array")}}</li>
- <li>{{jsxref("DataView")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                     | État                    | Commentaires |
+| ------------------------------------------------------------------------------------------------- | ----------------------- | ------------ |
+| [Proposition pour `BigInt`](https://tc39.github.io/proposal-bigint/#sec-typedarrays-and-dataview) | Proposition de niveau 3 |              |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.BigUint64Array")}}
+
+## Voir aussi
+
+- [Les tableaux typés en JavaScript](/fr/docs/Web/JavaScript/Tableaux_typés)
+- {{jsxref("BigUint64Array")}}
+- {{jsxref("DataView")}}
diff --git a/files/fr/web/javascript/reference/global_objects/boolean/index.md b/files/fr/web/javascript/reference/global_objects/boolean/index.md
index abfa0c874d..970556573d 100644
--- a/files/fr/web/javascript/reference/global_objects/boolean/index.md
+++ b/files/fr/web/javascript/reference/global_objects/boolean/index.md
@@ -9,30 +9,29 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Boolean
 original_slug: Web/JavaScript/Reference/Objets_globaux/Boolean
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>L'objet <strong><code>Boolean</code></strong> est un objet permettant de représenter une valeur booléenne.</p>
+L'objet **`Boolean`** est un objet permettant de représenter une valeur booléenne.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">new Boolean([<var>valeur</var>])</pre>
+    new Boolean([valeur])
 
-<h2 id="Paramètres">Paramètres</h2>
+## Paramètres
 
-<dl>
- <dt><code>valeur</code>{{optional_inline}}</dt>
- <dd>Paramètre optionnel, la valeur initiale de l'objet <code>Boolean</code>.</dd>
-</dl>
+- `valeur`{{optional_inline}}
+  - : Paramètre optionnel, la valeur initiale de l'objet `Boolean`.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La valeur passée en premier paramètre est, si nécessaire, convertie en valeur booléenne. Si la valeur est omise ou est <code>0</code>, <code>-0</code>, {{jsxref("null")}}, <code>false</code>, {{jsxref("NaN")}}, {{jsxref("undefined")}} ou une chaine de caractères vide (""), l'objet a un valeur initiale à <code>false</code> (faux). Si l'objet DOM {{domxref("document.all")}} est passé en argument, la valeur initiale sera également <code>false</code>. Toutes les autres valeurs, y compris n'importe quel objet, un tableau vide (<code>[]</code>), ou une chaine de caractères <code>"false"</code>, créént un objet avec une valeur initiale à <code>true</code> (vrai).</p>
+La valeur passée en premier paramètre est, si nécessaire, convertie en valeur booléenne. Si la valeur est omise ou est `0`, `-0`, {{jsxref("null")}}, `false`, {{jsxref("NaN")}}, {{jsxref("undefined")}} ou une chaine de caractères vide (""), l'objet a un valeur initiale à `false` (faux). Si l'objet DOM {{domxref("document.all")}} est passé en argument, la valeur initiale sera également `false`. Toutes les autres valeurs, y compris n'importe quel objet, un tableau vide (`[]`), ou une chaine de caractères `"false"`, créént un objet avec une valeur initiale à `true` (vrai).
 
-<p>Ne pas confondre les valeurs primitives booléennes <code>true</code> et <code>false</code> avec les valeurs <em>true</em> et <em>false</em> d'un objet Booléen.</p>
+Ne pas confondre les valeurs primitives booléennes `true` et `false` avec les valeurs _true_ et _false_ d'un objet Booléen.
 
-<p>Tout objet dont la valeur n'est ni  <code>undefined</code> ni <code>null</code>, incluant un objet Booléen dont la valeur est fausse, évalue à <code>true</code> lorsqu'il est à une instruction conditionnelle. Par exemple, la condition (voir {{jsxref("Instructions/if...else", "if")}}), dans le code suivant, est validée si l'expression est évaluée à <code>true</code> :</p>
+Tout objet dont la valeur n'est ni  `undefined` ni `null`, incluant un objet Booléen dont la valeur est fausse, évalue à `true` lorsqu'il est à une instruction conditionnelle. Par exemple, la condition (voir {{jsxref("Instructions/if...else", "if")}}), dans le code suivant, est validée si l'expression est évaluée à `true` :
 
-<pre class="brush: js">var x = new Boolean("false");
+```js
+var x = new Boolean("false");
 if (x) {
   // . . . le code est exécuté
 }
@@ -41,123 +40,99 @@ var y = new Boolean(false);
 if (y) {
   // ce code est également exécuté
 }
-</pre>
+```
 
-<p>Ce comportement ne s'applique pas aux valeurs primitives booléennes. Par exemple, la condition, dans le code suivant, est évaluée à <code>false</code> :</p>
+Ce comportement ne s'applique pas aux valeurs primitives booléennes. Par exemple, la condition, dans le code suivant, est évaluée à `false` :
 
-<pre class="brush: js">var x = false;
+```js
+var x = false;
 if (x) {
   // . . . le code n'est pas exécuté
 }
-</pre>
+```
 
-<p>Ne pas utiliser un objet <code>Boolean</code> pour convertir une valeur non-booléenne en une valeur booléenne. Utilisez plutot une fonction booléenne pour effectuer cette tâche :</p>
+Ne pas utiliser un objet `Boolean` pour convertir une valeur non-booléenne en une valeur booléenne. Utilisez plutot une fonction booléenne pour effectuer cette tâche :
 
-<pre class="brush: js">var x = Boolean(expression);     // conseillé
+```js
+var x = Boolean(expression);     // conseillé
 var y = new Boolean(expression); // à ne pas utiliser
-</pre>
+```
 
-<p>Si vous spécifiez un objet quelconque, incluant un objet booléen qui a une valeur fausse, le nouvel objet <code>Boolean</code> a une valeur vraie.</p>
+Si vous spécifiez un objet quelconque, incluant un objet booléen qui a une valeur fausse, le nouvel objet `Boolean` a une valeur vraie.
 
-<pre class="brush: js">var myFalse = new Boolean(false);   // valeur initiale à false
+```js
+var myFalse = new Boolean(false);   // valeur initiale à false
 var g = Boolean(myFalse);       // valeur initiale à true
 var myString = new String("Hello"); // un object String
 var s = Boolean(myString);      // valeur initiale à true
-</pre>
+```
 
-<p>Ne pas utiliser un objet Booléen à la place d'une valeur primitive booléenne.</p>
+Ne pas utiliser un objet Booléen à la place d'une valeur primitive booléenne.
 
-<div class="note">
-<p><strong>Note :</strong> Lorsque la propriété historique, non-standard, <code><a href="/fr/docs/Web/API/Document#Properties">document.all</a></code> est utilisée comme argument, le constructeur <code>Boolean</code> renvoie un objet booléen faux. Cette propriété étant non-standard, son utilisation est déconseillée.</p>
-</div>
+> **Note :** Lorsque la propriété historique, non-standard, [`document.all`](/fr/docs/Web/API/Document#Properties) est utilisée comme argument, le constructeur `Boolean` renvoie un objet booléen faux. Cette propriété étant non-standard, son utilisation est déconseillée.
 
-<h2 id="Propriétés">Propriétés</h2>
+## Propriétés
 
-<dl>
- <dt><code>Boolean.length</code></dt>
- <dd>Renvoie 1. Le nombre d'arguments pris en charge par le constructeur.</dd>
- <dt>{{jsxref("Boolean.prototype")}}</dt>
- <dd>Représente le prototype du constructeur <code>Boolean</code>.</dd>
-</dl>
+- `Boolean.length`
+  - : Renvoie 1. Le nombre d'arguments pris en charge par le constructeur.
+- {{jsxref("Boolean.prototype")}}
+  - : Représente le prototype du constructeur `Boolean`.
 
-<h2 id="Méthodes">Méthodes</h2>
+## Méthodes
 
-<p>L'objet global <code>Boolean</code> ne contient pas ses propres méthodes, cependant, il hérite de certaines méthodes à travers la chaine de prototypes.</p>
+L'objet global `Boolean` ne contient pas ses propres méthodes, cependant, il hérite de certaines méthodes à travers la chaine de prototypes.
 
-<h2 id="Instances_de_Boolean">Instances de <code>Boolean</code></h2>
+## Instances de `Boolean`
 
-<p>Toutes les <code>Boolean</code> héritent de {{jsxref("Boolean.prototype")}}. Comme avec tous les constructeurs, l'objet prototype dicte les propriétés et les méthodes héritées par les instances.</p>
+Toutes les `Boolean` héritent de {{jsxref("Boolean.prototype")}}. Comme avec tous les constructeurs, l'objet prototype dicte les propriétés et les méthodes héritées par les instances.
 
-<h3 id="Propriétés_2">Propriétés</h3>
+### Propriétés
 
-<p>{{page('fr/docs/JavaScript/Reference/Objets_globaux/Boolean/prototype','Propri.C3.A9t.C3.A9s')}}</p>
+{{page('fr/docs/JavaScript/Reference/Objets_globaux/Boolean/prototype','Propri.C3.A9t.C3.A9s')}}
 
-<h3 id="Méthodes_2">Méthodes</h3>
+### Méthodes
 
-<p>{{page('fr/docs/JavaScript/Reference/Objets_globaux/Boolean/prototype','M.C3.A9thodes')}}</p>
+{{page('fr/docs/JavaScript/Reference/Objets_globaux/Boolean/prototype','M.C3.A9thodes')}}
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Création_dobjets_Boolean_avec_une_valeur_initiale_à_faux">Création d'objets <code>Boolean</code> avec une valeur initiale à faux</h3>
+### Création d'objets `Boolean` avec une valeur initiale à faux
 
-<pre class="brush: js">var bNoParam = new Boolean();
+```js
+var bNoParam = new Boolean();
 var bZero = new Boolean(0);
 var bNull = new Boolean(null);
 var bEmptyString = new Boolean("");
 var bfalse = new Boolean(false);
-</pre>
+```
 
-<h3 id="Création_dobjets_Boolean_avec_une_valeur_initiale_à_vrai">Création d'objets <code>Boolean</code> avec une valeur initiale à vrai</h3>
+### Création d'objets `Boolean` avec une valeur initiale à vrai
 
-<pre class="brush: js">var btrue = new Boolean(true);
+```js
+var btrue = new Boolean(true);
 var btrueString = new Boolean("true");
 var bfalseString = new Boolean("false");
 var bArrayProto = new Boolean([]);
 var bObjProto = new Boolean({});
 var bSuLin = new Boolean("Su Lin");
-</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.0.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.6', 'Boolean')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-boolean-objects', 'Boolean')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-boolean-objects', 'Boolean')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Boolean")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Boolean.prototype")}}</li>
- <li><a href="/fr/docs/Web/JavaScript/Structures_de_données#Les_valeurs_primitives">Les valeurs primitives en JavaScript</a></li>
- <li>{{Glossary("Boolean","booléen")}}</li>
- <li><a href="https://fr.wikipedia.org/wiki/Bool%C3%A9en">Le type de données booléen (Wikipédia)</a></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.6', 'Boolean')}}                 | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-boolean-objects', 'Boolean')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-boolean-objects', 'Boolean')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Boolean")}}
+
+## Voir aussi
+
+- {{jsxref("Boolean.prototype")}}
+- [Les valeurs primitives en JavaScript](/fr/docs/Web/JavaScript/Structures_de_données#Les_valeurs_primitives)
+- {{Glossary("Boolean","booléen")}}
+- [Le type de données booléen (Wikipédia)](https://fr.wikipedia.org/wiki/Bool%C3%A9en)
diff --git a/files/fr/web/javascript/reference/global_objects/boolean/tosource/index.md b/files/fr/web/javascript/reference/global_objects/boolean/tosource/index.md
index c194c56ae6..df7e12c637 100644
--- a/files/fr/web/javascript/reference/global_objects/boolean/tosource/index.md
+++ b/files/fr/web/javascript/reference/global_objects/boolean/tosource/index.md
@@ -11,46 +11,43 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Boolean/toSource
 original_slug: Web/JavaScript/Reference/Objets_globaux/Boolean/toSource
 ---
-<div>{{JSRef}} {{Non-standard_header}}</div>
+{{JSRef}} {{Non-standard_header}}
 
-<p>La méthode <code><strong>toSource()</strong></code> renvoie une chaine de caractères représentant le code source de l'objet.</p>
+La méthode **`toSource()`** renvoie une chaine de caractères représentant le code source de l'objet.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>booleanObj</var>.toSource()
-Boolean.toSource()</pre>
+    booleanObj.toSource()
+    Boolean.toSource()
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une chaîne de caractères représentant le code source de l'objet.</p>
+Une chaîne de caractères représentant le code source de l'objet.
 
-<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("Boolean")}} object, <code>toSource</code> renvoie la chaîne de caractères suivantes qui indique que le code source n'est pas disponible :
+- Pour l'objet natif {{jsxref("Boolean")}} object, `toSource` renvoie la chaîne de caractères suivantes qui indique que le code source n'est pas disponible :
 
-  <pre class="brush: js">function Boolean() {
-    [native code]
-}
-</pre>
- </li>
- <li>Pour les instances de {{jsxref("Boolean")}}, <code>toSource</code> renvoie une chaîne explicitant le code source de l'objet.</li>
-</ul>
+  ```js
+    function Boolean() {
+        [native code]
+    }
+    ```
 
-<p>Cette méthode est généralement utilisée de façon interne par le moteur JavaScript et n'est pas appelée explicitement dans des scripts.</p>
+- Pour les instances de {{jsxref("Boolean")}}, `toSource` renvoie une chaîne explicitant le code source de l'objet.
 
-<h2 id="Spécifications">Spécifications</h2>
+Cette méthode est généralement utilisée de façon interne par le moteur JavaScript et n'est pas appelée explicitement dans des scripts.
 
-<p>Ne fait partie d'aucun standard. Implémentée avec JavaScript 1.3.</p>
+## Spécifications
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+Ne fait partie d'aucun standard. Implémentée avec JavaScript 1.3.
 
-<p>{{Compat("javascript.builtins.Boolean.toSource")}}</p>
+## Compatibilité des navigateurs
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+{{Compat("javascript.builtins.Boolean.toSource")}}
 
-<ul>
- <li>{{jsxref("Object.prototype.toSource()")}} {{non-standard_inline}}</li>
-</ul>
+## Voir aussi
+
+- {{jsxref("Object.prototype.toSource()")}} {{non-standard_inline}}
diff --git a/files/fr/web/javascript/reference/global_objects/boolean/tostring/index.md b/files/fr/web/javascript/reference/global_objects/boolean/tostring/index.md
index aedf9e0b00..d3c00ab270 100644
--- a/files/fr/web/javascript/reference/global_objects/boolean/tostring/index.md
+++ b/files/fr/web/javascript/reference/global_objects/boolean/tostring/index.md
@@ -10,76 +10,52 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Boolean/toString
 original_slug: Web/JavaScript/Reference/Objets_globaux/Boolean/toString
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>toString()</strong></code> renvoie une chaine de caractères correspondant à l'objet <code>Boolean</code> courant.</p>
+La méthode **`toString()`** renvoie une chaine de caractères correspondant à l'objet `Boolean` courant.
 
-<div>{{EmbedInteractiveExample("pages/js/boolean-tostring.html")}}</div>
+{{EmbedInteractiveExample("pages/js/boolean-tostring.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>bool</var>.toString()</pre>
+    bool.toString()
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une chaîne de caractères qui représente l'objet {{jsxref("Boolean")}}.</p>
+Une chaîne de caractères qui représente l'objet {{jsxref("Boolean")}}.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>L'objet {{jsxref("Boolean")}} surcharge la méthode <code>toString()</code> de l'objet {{jsxref("Object")}} ; il n'hérite pas de la méthode {{jsxref("Object.prototype.toString()")}}. Pour les objets de type <code>Boolean</code>, la méthode <code>toString()</code> renvoie une chaine de caractère representative de l'objet.</p>
+L'objet {{jsxref("Boolean")}} surcharge la méthode `toString()` de l'objet {{jsxref("Object")}} ; il n'hérite pas de la méthode {{jsxref("Object.prototype.toString()")}}. Pour les objets de type `Boolean`, la méthode `toString()` renvoie une chaine de caractère representative de l'objet.
 
-<p>La méthode <code>toString()</code> est automatiquement appelée quand le <code>Boolean</code> doit être representé comme une texte ou lorsque qu'il est concaténé avec une chaine de caractères.</p>
+La méthode `toString()` est automatiquement appelée quand le `Boolean` doit être representé comme une texte ou lorsque qu'il est concaténé avec une chaine de caractères.
 
-<p>Pour les objets de type <code>Boolean</code> , la fonction native <code>toString()</code> renvoie la chaine de caractère "<code>true</code>" ou "<code>false</code>" en fonction de la valeur de l'objet.</p>
+Pour les objets de type `Boolean` , la fonction native `toString()` renvoie la chaine de caractère "`true`" ou "`false`" en fonction de la valeur de l'objet.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_toString()">Utiliser <code>toString()</code></h3>
+### Utiliser `toString()`
 
-<p>Dans ce code, <code>flag.toString()</code> renvoie "<code>true</code>" :</p>
+Dans ce code, `flag.toString()` renvoie "`true`" :
 
-<pre class="brush: js">var flag = new Boolean(true);
+```js
+var flag = new Boolean(true);
 var maVar = flag.toString();
-</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. Implémentée avec JavaScript 1.1.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.6.4.2', 'Boolean.prototype.toString')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-boolean.prototype.tostring', 'Boolean.prototype.toString')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-boolean.prototype.tostring', 'Boolean.prototype.toString')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Boolean.toString")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Object.prototype.toString()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                        | Statut                       | Commentaires                                          |
+| -------------------------------------------------------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- |
+| {{SpecName('ES1')}}                                                                                             | {{Spec2('ES1')}}         | Définition initiale. Implémentée avec JavaScript 1.1. |
+| {{SpecName('ES5.1', '#sec-15.6.4.2', 'Boolean.prototype.toString')}}                         | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-boolean.prototype.tostring', 'Boolean.prototype.toString')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-boolean.prototype.tostring', 'Boolean.prototype.toString')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Boolean.toString")}}
+
+## Voir aussi
+
+- {{jsxref("Object.prototype.toString()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/boolean/valueof/index.md b/files/fr/web/javascript/reference/global_objects/boolean/valueof/index.md
index 336b15a0ea..78b325ede5 100644
--- a/files/fr/web/javascript/reference/global_objects/boolean/valueof/index.md
+++ b/files/fr/web/javascript/reference/global_objects/boolean/valueof/index.md
@@ -10,72 +10,48 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Boolean/valueOf
 original_slug: Web/JavaScript/Reference/Objets_globaux/Boolean/valueOf
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>valueOf()</strong></code> renvoie la valeur primitive de l'objet {{jsxref("Boolean")}}.</p>
+La méthode **`valueOf()`** renvoie la valeur primitive de l'objet {{jsxref("Boolean")}}.
 
-<div>{{EmbedInteractiveExample("pages/js/boolean-valueof.html")}}</div>
+{{EmbedInteractiveExample("pages/js/boolean-valueof.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>bool</var>.valueOf()</pre>
+    bool.valueOf()
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>La valeur primitive associée à l'objet {{jsxref("Boolean")}}.</p>
+La valeur primitive associée à l'objet {{jsxref("Boolean")}}.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La méthode <code>valueOf()</code> de {{jsxref("Boolean")}} renvoie la valeur primitive d'un objet <code>Boolean</code>, ou d'un littéral booléen.</p>
+La méthode `valueOf()` de {{jsxref("Boolean")}} renvoie la valeur primitive d'un objet `Boolean`, ou d'un littéral booléen.
 
-<p>Cette méthode est généralement utilisée de façon interne pas le moteur JavaScript et n'est pas utilisée explicitement dans les scripts.</p>
+Cette méthode est généralement utilisée de façon interne pas le moteur JavaScript et n'est pas utilisée explicitement dans les scripts.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_valueOf()">Utiliser <code>valueOf()</code></h3>
+### Utiliser `valueOf()`
 
-<pre class="brush: js">var x = new Boolean();
+```js
+var x = new Boolean();
 var maVar = x.valueOf()      // assigne false à maVar
-</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.6.4.3', 'Boolean.prototype.valueOf')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-boolean.prototype.valueof', 'Boolean.prototype.valueOf')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-boolean.prototype.valueof', 'Boolean.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.Boolean.valueOf")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <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.6.4.3', 'Boolean.prototype.valueOf')}}                             | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-boolean.prototype.valueof', 'Boolean.prototype.valueOf')}}         | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-boolean.prototype.valueof', 'Boolean.prototype.valueOf')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Boolean.valueOf")}}
+
+## Voir aussi
+
+- {{jsxref("Object.prototype.valueOf()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/dataview/buffer/index.md b/files/fr/web/javascript/reference/global_objects/dataview/buffer/index.md
index 5e8b762109..879a678bf9 100644
--- a/files/fr/web/javascript/reference/global_objects/dataview/buffer/index.md
+++ b/files/fr/web/javascript/reference/global_objects/dataview/buffer/index.md
@@ -11,58 +11,42 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/DataView/buffer
 original_slug: Web/JavaScript/Reference/Objets_globaux/DataView/buffer
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>L'accesseur <strong><code>buffer</code></strong> est une propriété représentant l'objet {{jsxref("ArrayBuffer")}} ou {{jsxref("SharedArrayBuffer")}} référencé par la vue <code>DataView</code> lors de sa construction.</p>
+L'accesseur **`buffer`** est une propriété représentant l'objet {{jsxref("ArrayBuffer")}} ou {{jsxref("SharedArrayBuffer")}} référencé par la vue `DataView` lors de sa construction.
 
-<div>{{EmbedInteractiveExample("pages/js/dataview-buffer.html")}}</div>
+{{EmbedInteractiveExample("pages/js/dataview-buffer.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>dataview</var>.buffer</pre>
+    dataview.buffer
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La propriété <code>buffer</code> est un accesseur/mutateur dont le mutateur correspondant vaut <code>undefined</code>, cela signifie qu'il n'est possible que de lire cette propriété. Sa valeur est établie lors de la construction de l'objet <code>DataView</code> et ne peut pas être modifiée.</p>
+La propriété `buffer` est un accesseur/mutateur dont le mutateur correspondant vaut `undefined`, cela signifie qu'il n'est possible que de lire cette propriété. Sa valeur est établie lors de la construction de l'objet `DataView` et ne peut pas être modifiée.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utilisation_de_la_propriété_buffer">Utilisation de la propriété <code>buffer</code></h3>
+### Utilisation de la propriété `buffer`
 
-<pre class="brush:js">var buffer = new ArrayBuffer(8);
+```js
+var buffer = new ArrayBuffer(8);
 var dataview = new DataView(buffer);
 dataview.buffer; // ArrayBuffer { byteLength: 8 }
-</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">Statut</th>
-   <th scope="col">Commentaires</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-get-dataview.prototype.buffer', 'DataView.prototype.buffer')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-get-dataview.prototype.buffer', 'DataView.prototype.buffer')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
+| Spécification                                                                                                            | Statut                       | Commentaires         |
+| ------------------------------------------------------------------------------------------------------------------------ | ---------------------------- | -------------------- |
+| {{SpecName('ES6', '#sec-get-dataview.prototype.buffer', 'DataView.prototype.buffer')}}     | {{Spec2('ES6')}}         | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-get-dataview.prototype.buffer', 'DataView.prototype.buffer')}} | {{Spec2('ESDraft')}} |                      |
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.DataView.buffer")}}</p>
+{{Compat("javascript.builtins.DataView.buffer")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("DataView")}}</li>
- <li>{{jsxref("ArrayBuffer")}}</li>
-</ul>
+- {{jsxref("DataView")}}
+- {{jsxref("ArrayBuffer")}}
diff --git a/files/fr/web/javascript/reference/global_objects/dataview/bytelength/index.md b/files/fr/web/javascript/reference/global_objects/dataview/bytelength/index.md
index 0ee441d0f0..bd25a6f629 100644
--- a/files/fr/web/javascript/reference/global_objects/dataview/bytelength/index.md
+++ b/files/fr/web/javascript/reference/global_objects/dataview/bytelength/index.md
@@ -11,25 +11,26 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/DataView/byteLength
 original_slug: Web/JavaScript/Reference/Objets_globaux/DataView/byteLength
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>L'accesseur <strong><code>byteLength</code></strong> est une propriété représentant la longueur, exprimée en octets, de cette vue depuis le début de l'objet {{jsxref("ArrayBuffer")}} ou {{jsxref("SharedArrayBuffer")}} correspondant.</p>
+L'accesseur **`byteLength`** est une propriété représentant la longueur, exprimée en octets, de cette vue depuis le début de l'objet {{jsxref("ArrayBuffer")}} ou {{jsxref("SharedArrayBuffer")}} correspondant.
 
-<div>{{EmbedInteractiveExample("pages/js/dataview-bytelength.html")}}</div>
+{{EmbedInteractiveExample("pages/js/dataview-bytelength.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>dataview</var>.byteLength</pre>
+    dataview.byteLength
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La propriété <code>byteLength</code> est une propriété accesseur/mutateur dont le mutateur vaut  <code>undefined</code>. Cela signifie que cette propriété est en lecture seule. Cette valeur est déterminée lorsque l'objet <code>DataView</code> est construit et ne peut pas être changée. Si <code>DataView</code> ne définit pas de décalage avec <code>byteOffset</code> ou ne spécifie pas <code>byteLength</code>, ce sera la <code>byteLength</code> de l'objet <code>ArrayBuffer</code> ou <code>SharedArrayBuffer </code>référencé qui sera renvoyée.</p>
+La propriété `byteLength` est une propriété accesseur/mutateur dont le mutateur vaut  `undefined`. Cela signifie que cette propriété est en lecture seule. Cette valeur est déterminée lorsque l'objet `DataView` est construit et ne peut pas être changée. Si `DataView` ne définit pas de décalage avec `byteOffset` ou ne spécifie pas `byteLength`, ce sera la `byteLength` de l'objet `ArrayBuffer` ou `SharedArrayBuffer `référencé qui sera renvoyée.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utilisation_de_la_propriété_byteLength">Utilisation de la propriété <code>byteLength</code></h3>
+### Utilisation de la propriété `byteLength`
 
-<pre class="brush:js">var buffer = new ArrayBuffer(8);
+```js
+var buffer = new ArrayBuffer(8);
 var dataview = new DataView(buffer);
 dataview.byteLength; // 8 (correspond au byteLength du buffer)
 
@@ -38,38 +39,21 @@ dataview2.byteLength; // 5 (correspond à la longueur utilisée pour la définit
 
 var dataview3 = new DataView(buffer, 2);
 dataview3.byteLength; // 6 (en raison du décalage (offset) pour la construction du DataView)
-</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('ES6', '#sec-get-dataview.prototype.bytelength', 'DataView.prototype.byteLength')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-get-dataview.prototype.bytelength', 'DataView.prototype.byteLength')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.DataView.byteLength")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("DataView")}}</li>
- <li>{{jsxref("ArrayBuffer")}}</li>
- <li>{{jsxref("SharedArrayBuffer")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                                        | Statut                       | Commentaires         |
+| ------------------------------------------------------------------------------------------------------------------------------------ | ---------------------------- | -------------------- |
+| {{SpecName('ES6', '#sec-get-dataview.prototype.bytelength', 'DataView.prototype.byteLength')}}         | {{Spec2('ES6')}}         | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-get-dataview.prototype.bytelength', 'DataView.prototype.byteLength')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.DataView.byteLength")}}
+
+## Voir aussi
+
+- {{jsxref("DataView")}}
+- {{jsxref("ArrayBuffer")}}
+- {{jsxref("SharedArrayBuffer")}}
diff --git a/files/fr/web/javascript/reference/global_objects/dataview/byteoffset/index.md b/files/fr/web/javascript/reference/global_objects/dataview/byteoffset/index.md
index fe99429718..ec2f25d33a 100644
--- a/files/fr/web/javascript/reference/global_objects/dataview/byteoffset/index.md
+++ b/files/fr/web/javascript/reference/global_objects/dataview/byteoffset/index.md
@@ -11,62 +11,46 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/DataView/byteOffset
 original_slug: Web/JavaScript/Reference/Objets_globaux/DataView/byteOffset
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La propriété <strong><code>byteOffset</code></strong> est un accesseur représentant le décalage, exprimé en octets, entre la vue et le début de l'objet {{jsxref("ArrayBuffer")}} ou {{jsxref("SharedArrayBuffer")}} correspondant.</p>
+La propriété **`byteOffset`** est un accesseur représentant le décalage, exprimé en octets, entre la vue et le début de l'objet {{jsxref("ArrayBuffer")}} ou {{jsxref("SharedArrayBuffer")}} correspondant.
 
-<div>{{EmbedInteractiveExample("pages/js/dataview-byteoffset.html")}}</div>
+{{EmbedInteractiveExample("pages/js/dataview-byteoffset.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>dataview</var>.byteOffset</pre>
+    dataview.byteOffset
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La propriété <code>byteOffset</code> est un accesseur/mutateur dont la fonction du mutateur vaut  <code>undefined</code>. Cela signifie que la propriété n'est accesssible qu'en lecture seule. La valeur de la propriété est définie lors de la construction de l'objet <code>DataView</code> et ne peut pas être modifiée.</p>
+La propriété `byteOffset` est un accesseur/mutateur dont la fonction du mutateur vaut  `undefined`. Cela signifie que la propriété n'est accesssible qu'en lecture seule. La valeur de la propriété est définie lors de la construction de l'objet `DataView` et ne peut pas être modifiée.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utilisation_de_la_propriété_byteOffset">Utilisation de la propriété <code>byteOffset</code></h3>
+### Utilisation de la propriété `byteOffset`
 
-<pre class="brush:js">var buffer = new ArrayBuffer(8);
+```js
+var buffer = new ArrayBuffer(8);
 var dataview = new DataView(buffer);
 dataview.byteOffset; // 0 (aucun décalage)
 
 var dataview2 = new DataView(buffer, 3);
 dataview2.byteOffset; // 3 (décalage défini lors de la construction de la vue)
-</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('ES6', '#sec-get-dataview.prototype.byteoffset', 'DataView.prototype.byteOffset')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-get-dataview.prototype.byteoffset', 'DataView.prototype.byteOffset')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.DataView.byteOffset")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("DataView")}}</li>
- <li>{{jsxref("ArrayBuffer")}}</li>
- <li>{{jsxref("SharedArrayBuffer")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                                        | Statut                       | Commentaires         |
+| ------------------------------------------------------------------------------------------------------------------------------------ | ---------------------------- | -------------------- |
+| {{SpecName('ES6', '#sec-get-dataview.prototype.byteoffset', 'DataView.prototype.byteOffset')}}         | {{Spec2('ES6')}}         | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-get-dataview.prototype.byteoffset', 'DataView.prototype.byteOffset')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.DataView.byteOffset")}}
+
+## Voir aussi
+
+- {{jsxref("DataView")}}
+- {{jsxref("ArrayBuffer")}}
+- {{jsxref("SharedArrayBuffer")}}
diff --git a/files/fr/web/javascript/reference/global_objects/dataview/getbigint64/index.md b/files/fr/web/javascript/reference/global_objects/dataview/getbigint64/index.md
index db4490ac0d..6bdaade750 100644
--- a/files/fr/web/javascript/reference/global_objects/dataview/getbigint64/index.md
+++ b/files/fr/web/javascript/reference/global_objects/dataview/getbigint64/index.md
@@ -12,74 +12,58 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/DataView/getBigInt64
 original_slug: Web/JavaScript/Reference/Objets_globaux/DataView/getBigInt64
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>getBigInt64()</code></strong> permet de lire un entier signé sur 64 bits (type <em>long long</em> par analogie avec C) à l'octet donné par rapport au début de {{jsxref("DataView")}}.</p>
+La méthode **`getBigInt64()`** permet de lire un entier signé sur 64 bits (type _long long_ par analogie avec C) à l'octet donné par rapport au début de {{jsxref("DataView")}}.
 
-<div>{{EmbedInteractiveExample("pages/js/dataview-getbigint64.html")}}</div>
+{{EmbedInteractiveExample("pages/js/dataview-getbigint64.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>dataview</var>.getBigInt64(positionOctet [, littleEndian])</pre>
+    dataview.getBigInt64(positionOctet [, littleEndian])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>positionOctet</code></dt>
- <dd>La position, exprimée en nombre d'octets depuis le début de la vue, à laquelle lire les données.</dd>
- <dt><code>littleEndian</code></dt>
- <dd>{{optional_inline}} indique si la valeur sur 64 bits est enregistrée dans l'ordre des octets {{Glossary("Endianness", "de poids faible")}}. Si le paramètre vaut <code>false</code> ou <code>undefined</code>, la valeur sera lue dans l'ordre des octets de poids forts.</dd>
-</dl>
+- `positionOctet`
+  - : La position, exprimée en nombre d'octets depuis le début de la vue, à laquelle lire les données.
+- `littleEndian`
+  - : {{optional_inline}} indique si la valeur sur 64 bits est enregistrée dans l'ordre des octets {{Glossary("Endianness", "de poids faible")}}. Si le paramètre vaut `false` ou `undefined`, la valeur sera lue dans l'ordre des octets de poids forts.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une valeur {{jsxref("BigInt")}}</p>
+Une valeur {{jsxref("BigInt")}}
 
-<h3 id="Erreurs_renvoyées">Erreurs renvoyées</h3>
+### Erreurs renvoyées
 
-<dl>
- <dt>{{jsxref("RangeError")}}</dt>
- <dd>Renvoyée si <code>positionOctet</code> est tel qu'il est en dehors de la vue.</dd>
-</dl>
+- {{jsxref("RangeError")}}
+  - : Renvoyée si `positionOctet` est tel qu'il est en dehors de la vue.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Il n'y a pas de contrainte d'alignement, les valeurs codées sur plusieurs octets peuvent être obtenues depuis n'importe quelle position.</p>
+Il n'y a pas de contrainte d'alignement, les valeurs codées sur plusieurs octets peuvent être obtenues depuis n'importe quelle position.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utilisation_de_la_méthode_getBigInt64()">Utilisation de la méthode <code>getBigInt64()</code></h3>
+### Utilisation de la méthode `getBigInt64()`
 
-<pre class="brush:js">var buffer = new ArrayBuffer(8);
+```js
+var buffer = new ArrayBuffer(8);
 var dataview = new DataView(buffer);
 dataview.getBigInt64(0); // 0n
-</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><a href="https://tc39.github.io/proposal-bigint/#sec-dataview.prototype.getbigint64">Proposition pour <code>DataView.prototype.getBigInt64()</code></a></td>
-   <td></td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.DataView.getBigInt64")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("DataView")}}</li>
- <li>{{jsxref("ArrayBuffer")}}</li>
- <li>{{jsxref("BigInt")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                                     | État | Commentaires |
+| --------------------------------------------------------------------------------------------------------------------------------- | ---- | ------------ |
+| [Proposition pour `DataView.prototype.getBigInt64()`](https://tc39.github.io/proposal-bigint/#sec-dataview.prototype.getbigint64) |      |              |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.DataView.getBigInt64")}}
+
+## Voir aussi
+
+- {{jsxref("DataView")}}
+- {{jsxref("ArrayBuffer")}}
+- {{jsxref("BigInt")}}
diff --git a/files/fr/web/javascript/reference/global_objects/dataview/getbiguint64/index.md b/files/fr/web/javascript/reference/global_objects/dataview/getbiguint64/index.md
index b6fcc2c2ab..115e157fc8 100644
--- a/files/fr/web/javascript/reference/global_objects/dataview/getbiguint64/index.md
+++ b/files/fr/web/javascript/reference/global_objects/dataview/getbiguint64/index.md
@@ -12,74 +12,58 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/DataView/getBigUint64
 original_slug: Web/JavaScript/Reference/Objets_globaux/DataView/getBigUint64
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>getBigUint64()</code></strong> permet de lire un entier non signé sur 64 bits (type <em>unsigned long long</em> par analogie avec C) à l'octet donné par rapport au début de {{jsxref("DataView")}}.</p>
+La méthode **`getBigUint64()`** permet de lire un entier non signé sur 64 bits (type _unsigned long long_ par analogie avec C) à l'octet donné par rapport au début de {{jsxref("DataView")}}.
 
-<div>{{EmbedInteractiveExample("pages/js/dataview-getbiguint64.html")}}</div>
+{{EmbedInteractiveExample("pages/js/dataview-getbiguint64.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>dataview</var>.getBigUint64(positionOctet [, littleEndian])</pre>
+    dataview.getBigUint64(positionOctet [, littleEndian])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>positionOctet</code></dt>
- <dd>La position, exprimée en nombre d'octets depuis le début de la vue, à laquelle lire les données.</dd>
- <dt><code>littleEndian</code></dt>
- <dd>{{optional_inline}} indique si la valeur sur 64 bits est enregistrée dans l'ordre des octets {{Glossary("Endianness", "de poids faible")}}. Si le paramètre vaut <code>false</code> ou <code>undefined</code>, la valeur sera lue dans l'ordre des octets de poids forts.</dd>
-</dl>
+- `positionOctet`
+  - : La position, exprimée en nombre d'octets depuis le début de la vue, à laquelle lire les données.
+- `littleEndian`
+  - : {{optional_inline}} indique si la valeur sur 64 bits est enregistrée dans l'ordre des octets {{Glossary("Endianness", "de poids faible")}}. Si le paramètre vaut `false` ou `undefined`, la valeur sera lue dans l'ordre des octets de poids forts.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une valeur {{jsxref("BigInt")}}</p>
+Une valeur {{jsxref("BigInt")}}
 
-<h3 id="Erreurs_renvoyées">Erreurs renvoyées</h3>
+### Erreurs renvoyées
 
-<dl>
- <dt>{{jsxref("RangeError")}}</dt>
- <dd>Renvoyée si <code>positionOctet</code> est tel qu'il est en dehors de la vue.</dd>
-</dl>
+- {{jsxref("RangeError")}}
+  - : Renvoyée si `positionOctet` est tel qu'il est en dehors de la vue.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Il n'y a pas de contrainte d'alignement, les valeurs codées sur plusieurs octets peuvent être obtenues depuis n'importe quelle position.</p>
+Il n'y a pas de contrainte d'alignement, les valeurs codées sur plusieurs octets peuvent être obtenues depuis n'importe quelle position.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utilisation_de_la_méthode_getBigUint64()">Utilisation de la méthode <code>getBigUint64()</code></h3>
+### Utilisation de la méthode `getBigUint64()`
 
-<pre class="brush:js">var buffer = new ArrayBuffer(8);
+```js
+var buffer = new ArrayBuffer(8);
 var dataview = new DataView(buffer);
 dataview.getBigUint64(0); // 0n
-</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><a href="https://tc39.es/proposal-bigint/#sec-dataview.prototype.getbiguint64">Proposition pour <code>DataView.prototype.getBigUint64()</code></a></td>
-   <td></td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.DataView.getBigUint64")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("DataView")}}</li>
- <li>{{jsxref("ArrayBuffer")}}</li>
- <li>{{jsxref("BigInt")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                                | État | Commentaires |
+| ---------------------------------------------------------------------------------------------------------------------------- | ---- | ------------ |
+| [Proposition pour `DataView.prototype.getBigUint64()`](https://tc39.es/proposal-bigint/#sec-dataview.prototype.getbiguint64) |      |              |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.DataView.getBigUint64")}}
+
+## Voir aussi
+
+- {{jsxref("DataView")}}
+- {{jsxref("ArrayBuffer")}}
+- {{jsxref("BigInt")}}
diff --git a/files/fr/web/javascript/reference/global_objects/dataview/getfloat32/index.md b/files/fr/web/javascript/reference/global_objects/dataview/getfloat32/index.md
index 20fb09388e..94e7f06fba 100644
--- a/files/fr/web/javascript/reference/global_objects/dataview/getfloat32/index.md
+++ b/files/fr/web/javascript/reference/global_objects/dataview/getfloat32/index.md
@@ -11,83 +11,59 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/DataView/getFloat32
 original_slug: Web/JavaScript/Reference/Objets_globaux/DataView/getFloat32
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>getFloat32()</code></strong> permet de lire un nombre flottant signé sur 32 bits à l'octet donné par rapport au début de {{jsxref("DataView")}}.</p>
+La méthode **`getFloat32()`** permet de lire un nombre flottant signé sur 32 bits à l'octet donné par rapport au début de {{jsxref("DataView")}}.
 
-<div>{{EmbedInteractiveExample("pages/js/dataview-getfloat32.html")}}</div>
+{{EmbedInteractiveExample("pages/js/dataview-getfloat32.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>dataview</var>.getFloat32(positionOctet [, littleEndian])</pre>
+    dataview.getFloat32(positionOctet [, littleEndian])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>positionOctet</code></dt>
- <dd>La position, exprimée en nombre d'octets depuis le début de la vue, à laquelle lire les données.</dd>
- <dt><code>littleEndian</code></dt>
- <dd>{{optional_inline}} indique si la valeur sur 32 bits est enregistrée dans l'ordre des octets {{Glossary("Endianness", "de poids faible")}}. Si le paramètre vaut <code>false</code> ou <code>undefined</code>, la valeur sera lue dans l'ordre des octets de poids forts.</dd>
-</dl>
+- `positionOctet`
+  - : La position, exprimée en nombre d'octets depuis le début de la vue, à laquelle lire les données.
+- `littleEndian`
+  - : {{optional_inline}} indique si la valeur sur 32 bits est enregistrée dans l'ordre des octets {{Glossary("Endianness", "de poids faible")}}. Si le paramètre vaut `false` ou `undefined`, la valeur sera lue dans l'ordre des octets de poids forts.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un nombre flottant signé, sur 32 bits.</p>
+Un nombre flottant signé, sur 32 bits.
 
-<h3 id="Erreurs_renvoyées">Erreurs renvoyées</h3>
+### Erreurs renvoyées
 
-<dl>
- <dt>{{jsxref("RangeError")}}</dt>
- <dd>Renvoyée si <code>positionOctet</code> est tel qu'il est en dehors de la vue.</dd>
-</dl>
+- {{jsxref("RangeError")}}
+  - : Renvoyée si `positionOctet` est tel qu'il est en dehors de la vue.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Il n'y a pas de contrainte d'alignement, les valeurs codées sur plusieurs octets peuvent être obtenues depuis n'importe quelle position.</p>
+Il n'y a pas de contrainte d'alignement, les valeurs codées sur plusieurs octets peuvent être obtenues depuis n'importe quelle position.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utilisation_de_la_méthode_getFloat32">Utilisation de la méthode <code>getFloat32</code></h3>
+### Utilisation de la méthode `getFloat32`
 
-<pre class="brush:js">var buffer = new ArrayBuffer(8);
+```js
+var buffer = new ArrayBuffer(8);
 var dataview = new DataView(buffer);
 dataview.getFloat32(1); // 0
-</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('Typed Array')}}</td>
-   <td>{{Spec2('Typed Array')}}</td>
-   <td>Remplacée dans ECMAScript 2015.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES2015', '#sec-dataview.prototype.getfloat32', 'DataView.prototype.getFloat32')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale au sein d'un standard ECMA.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-dataview.prototype.getfloat32', 'DataView.prototype.getFloat32')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.DataView.getFloat32")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("DataView")}}</li>
- <li>{{jsxref("ArrayBuffer")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                                | État                             | Commentaires                                    |
+| ---------------------------------------------------------------------------------------------------------------------------- | -------------------------------- | ----------------------------------------------- |
+| {{SpecName('Typed Array')}}                                                                                         | {{Spec2('Typed Array')}} | Remplacée dans ECMAScript 2015.                 |
+| {{SpecName('ES2015', '#sec-dataview.prototype.getfloat32', 'DataView.prototype.getFloat32')}} | {{Spec2('ES2015')}}         | Définition initiale au sein d'un standard ECMA. |
+| {{SpecName('ESDraft', '#sec-dataview.prototype.getfloat32', 'DataView.prototype.getFloat32')}} | {{Spec2('ESDraft')}}     |                                                 |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.DataView.getFloat32")}}
+
+## Voir aussi
+
+- {{jsxref("DataView")}}
+- {{jsxref("ArrayBuffer")}}
diff --git a/files/fr/web/javascript/reference/global_objects/dataview/getfloat64/index.md b/files/fr/web/javascript/reference/global_objects/dataview/getfloat64/index.md
index ba67808c2d..dc7d43000f 100644
--- a/files/fr/web/javascript/reference/global_objects/dataview/getfloat64/index.md
+++ b/files/fr/web/javascript/reference/global_objects/dataview/getfloat64/index.md
@@ -11,83 +11,59 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/DataView/getFloat64
 original_slug: Web/JavaScript/Reference/Objets_globaux/DataView/getFloat64
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>getFloat64()</code></strong> permet de lire un entier signé sur 64 bits (type <em>double</em> par analogie avec C) à l'octet donné par rapport au début de {{jsxref("DataView")}}.</p>
+La méthode **`getFloat64()`** permet de lire un entier signé sur 64 bits (type _double_ par analogie avec C) à l'octet donné par rapport au début de {{jsxref("DataView")}}.
 
-<div>{{EmbedInteractiveExample("pages/js/dataview-getfloat64.html")}}</div>
+{{EmbedInteractiveExample("pages/js/dataview-getfloat64.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>dataview</var>.getFloat64(positionOctet [, littleEndian])</pre>
+    dataview.getFloat64(positionOctet [, littleEndian])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>positionOctet</code></dt>
- <dd>La position, exprimée en nombre d'octets depuis le début de la vue, à laquelle lire les données.</dd>
- <dt><code>littleEndian</code></dt>
- <dd>{{optional_inline}} indique si la valeur sur 64 bits est enregistrée dans l'ordre des octets {{Glossary("Endianness", "de poids faible")}}. Si le paramètre vaut <code>false</code> ou <code>undefined</code>, la valeur sera lue dans l'ordre des octets de poids forts.</dd>
-</dl>
+- `positionOctet`
+  - : La position, exprimée en nombre d'octets depuis le début de la vue, à laquelle lire les données.
+- `littleEndian`
+  - : {{optional_inline}} indique si la valeur sur 64 bits est enregistrée dans l'ordre des octets {{Glossary("Endianness", "de poids faible")}}. Si le paramètre vaut `false` ou `undefined`, la valeur sera lue dans l'ordre des octets de poids forts.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un nombre flottant signé sur 64 bits.</p>
+Un nombre flottant signé sur 64 bits.
 
-<h3 id="Erreurs_renvoyées">Erreurs renvoyées</h3>
+### Erreurs renvoyées
 
-<dl>
- <dt>{{jsxref("RangeError")}}</dt>
- <dd>Renvoyée si <code>positionOctet</code> est tel qu'il est en dehors de la vue.</dd>
-</dl>
+- {{jsxref("RangeError")}}
+  - : Renvoyée si `positionOctet` est tel qu'il est en dehors de la vue.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Il n'y a pas de contrainte d'alignement, les valeurs codées sur plusieurs octets peuvent être obtenues depuis n'importe quelle position.</p>
+Il n'y a pas de contrainte d'alignement, les valeurs codées sur plusieurs octets peuvent être obtenues depuis n'importe quelle position.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utilisation_de_la_méthode_getFloat64">Utilisation de la méthode <code>getFloat64</code></h3>
+### Utilisation de la méthode `getFloat64`
 
-<pre class="brush:js">var buffer = new ArrayBuffer(8);
+```js
+var buffer = new ArrayBuffer(8);
 var dataview = new DataView(buffer);
 dataview.getFloat64(0); // 0
-</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('Typed Array')}}</td>
-   <td>{{Spec2('Typed Array')}}</td>
-   <td>Remplacée dans ECMAScript 2015.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES2015', '#sec-dataview.prototype.getfloat64', 'DataView.prototype.getFloat64')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale au sein d'un standard ECMA.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-dataview.prototype.getfloat64', 'DataView.prototype.getFloat64')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.DataView.getFloat64")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("DataView")}}</li>
- <li>{{jsxref("ArrayBuffer")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                                | État                             | Commentaires                                    |
+| ---------------------------------------------------------------------------------------------------------------------------- | -------------------------------- | ----------------------------------------------- |
+| {{SpecName('Typed Array')}}                                                                                         | {{Spec2('Typed Array')}} | Remplacée dans ECMAScript 2015.                 |
+| {{SpecName('ES2015', '#sec-dataview.prototype.getfloat64', 'DataView.prototype.getFloat64')}} | {{Spec2('ES2015')}}         | Définition initiale au sein d'un standard ECMA. |
+| {{SpecName('ESDraft', '#sec-dataview.prototype.getfloat64', 'DataView.prototype.getFloat64')}} | {{Spec2('ESDraft')}}     |                                                 |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.DataView.getFloat64")}}
+
+## Voir aussi
+
+- {{jsxref("DataView")}}
+- {{jsxref("ArrayBuffer")}}
diff --git a/files/fr/web/javascript/reference/global_objects/dataview/getint16/index.md b/files/fr/web/javascript/reference/global_objects/dataview/getint16/index.md
index 07973e9fa7..0d42b98be8 100644
--- a/files/fr/web/javascript/reference/global_objects/dataview/getint16/index.md
+++ b/files/fr/web/javascript/reference/global_objects/dataview/getint16/index.md
@@ -11,83 +11,59 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/DataView/getInt16
 original_slug: Web/JavaScript/Reference/Objets_globaux/DataView/getInt16
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>getInt16()</code></strong> permet de lire un entier signé sur 16 bits (type <em>short</em> par analogie avec C) à l'octet donné par rapport au début de {{jsxref("DataView")}}.</p>
+La méthode **`getInt16()`** permet de lire un entier signé sur 16 bits (type _short_ par analogie avec C) à l'octet donné par rapport au début de {{jsxref("DataView")}}.
 
-<div>{{EmbedInteractiveExample("pages/js/dataview-getint16.html")}}</div>
+{{EmbedInteractiveExample("pages/js/dataview-getint16.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>dataview</var>.getInt16(positionOctet [, littleEndian])</pre>
+    dataview.getInt16(positionOctet [, littleEndian])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>positionOctet</code></dt>
- <dd>La position, exprimée en nombre d'octets depuis le début de la vue, à laquelle lire les données.</dd>
- <dt><code>littleEndian</code></dt>
- <dd>{{optional_inline}} indique si la valeur sur 16 bits est enregistrée dans l'ordre des octets {{Glossary("Endianness", "de poids faible")}}. Si le paramètre vaut <code>false</code> ou <code>undefined</code>, la valeur sera lue dans l'ordre des octets de poids forts.</dd>
-</dl>
+- `positionOctet`
+  - : La position, exprimée en nombre d'octets depuis le début de la vue, à laquelle lire les données.
+- `littleEndian`
+  - : {{optional_inline}} indique si la valeur sur 16 bits est enregistrée dans l'ordre des octets {{Glossary("Endianness", "de poids faible")}}. Si le paramètre vaut `false` ou `undefined`, la valeur sera lue dans l'ordre des octets de poids forts.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un entier signé sur 16 bits.</p>
+Un entier signé sur 16 bits.
 
-<h3 id="Erreurs_renvoyées">Erreurs renvoyées</h3>
+### Erreurs renvoyées
 
-<dl>
- <dt>{{jsxref("RangeError")}}</dt>
- <dd>Renvoyée si <code>positionOctet</code> est tel qu'il est en dehors de la vue.</dd>
-</dl>
+- {{jsxref("RangeError")}}
+  - : Renvoyée si `positionOctet` est tel qu'il est en dehors de la vue.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Il n'y a pas de contrainte d'alignement, les valeurs codées sur plusieurs octets peuvent être obtenues depuis n'importe quelle position.</p>
+Il n'y a pas de contrainte d'alignement, les valeurs codées sur plusieurs octets peuvent être obtenues depuis n'importe quelle position.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utilisation_de_la_méthode_getInt16">Utilisation de la méthode <code>getInt16</code></h3>
+### Utilisation de la méthode `getInt16`
 
-<pre class="brush:js">var buffer = new ArrayBuffer(8);
+```js
+var buffer = new ArrayBuffer(8);
 var dataview = new DataView(buffer);
 dataview.getInt16(1); // 0
-</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('Typed Array')}}</td>
-   <td>{{Spec2('Typed Array')}}</td>
-   <td>Remplacée dans ECMAScript 2015.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES2015', '#sec-dataview.prototype.getint16', 'DataView.prototype.getInt16')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale au sein d'un standard ECMA.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-dataview.prototype.getint16', 'DataView.prototype.getInt16')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.DataView.getInt16")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("DataView")}}</li>
- <li>{{jsxref("ArrayBuffer")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                            | État                             | Commentaires                                    |
+| ------------------------------------------------------------------------------------------------------------------------ | -------------------------------- | ----------------------------------------------- |
+| {{SpecName('Typed Array')}}                                                                                     | {{Spec2('Typed Array')}} | Remplacée dans ECMAScript 2015.                 |
+| {{SpecName('ES2015', '#sec-dataview.prototype.getint16', 'DataView.prototype.getInt16')}} | {{Spec2('ES2015')}}         | Définition initiale au sein d'un standard ECMA. |
+| {{SpecName('ESDraft', '#sec-dataview.prototype.getint16', 'DataView.prototype.getInt16')}} | {{Spec2('ESDraft')}}     |                                                 |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.DataView.getInt16")}}
+
+## Voir aussi
+
+- {{jsxref("DataView")}}
+- {{jsxref("ArrayBuffer")}}
diff --git a/files/fr/web/javascript/reference/global_objects/dataview/getint32/index.md b/files/fr/web/javascript/reference/global_objects/dataview/getint32/index.md
index 024dea3e3e..c611ff5885 100644
--- a/files/fr/web/javascript/reference/global_objects/dataview/getint32/index.md
+++ b/files/fr/web/javascript/reference/global_objects/dataview/getint32/index.md
@@ -11,83 +11,59 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/DataView/getInt32
 original_slug: Web/JavaScript/Reference/Objets_globaux/DataView/getInt32
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>getInt32()</code></strong> permet de lire un entier signé sur 32 bits (type <em>long</em> par analogie avec C) à l'octet donné par rapport au début de {{jsxref("DataView")}}.</p>
+La méthode **`getInt32()`** permet de lire un entier signé sur 32 bits (type _long_ par analogie avec C) à l'octet donné par rapport au début de {{jsxref("DataView")}}.
 
-<div>{{EmbedInteractiveExample("pages/js/dataview-getint32.html")}}</div>
+{{EmbedInteractiveExample("pages/js/dataview-getint32.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>dataview</var>.getInt32(positionOctet [, littleEndian])</pre>
+    dataview.getInt32(positionOctet [, littleEndian])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>positionOctet</code></dt>
- <dd>La position, exprimée en nombre d'octets depuis le début de la vue, à laquelle lire les données.</dd>
- <dt><code>littleEndian</code></dt>
- <dd>{{optional_inline}} indique si la valeur sur 32 bits est enregistrée dans l'ordre des octets {{Glossary("Endianness", "de poids faible")}}. Si le paramètre vaut <code>false</code> ou <code>undefined</code>, la valeur sera lue dans l'ordre des octets de poids forts.</dd>
-</dl>
+- `positionOctet`
+  - : La position, exprimée en nombre d'octets depuis le début de la vue, à laquelle lire les données.
+- `littleEndian`
+  - : {{optional_inline}} indique si la valeur sur 32 bits est enregistrée dans l'ordre des octets {{Glossary("Endianness", "de poids faible")}}. Si le paramètre vaut `false` ou `undefined`, la valeur sera lue dans l'ordre des octets de poids forts.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un entier signé sur 32 bits.</p>
+Un entier signé sur 32 bits.
 
-<h3 id="Erreurs_renvoyées">Erreurs renvoyées</h3>
+### Erreurs renvoyées
 
-<dl>
- <dt>{{jsxref("RangeError")}}</dt>
- <dd>Renvoyée si <code>positionOctet</code> est tel qu'il est en dehors de la vue.</dd>
-</dl>
+- {{jsxref("RangeError")}}
+  - : Renvoyée si `positionOctet` est tel qu'il est en dehors de la vue.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Il n'y a pas de contrainte d'alignement, les valeurs codées sur plusieurs octets peuvent être obtenues depuis n'importe quelle position.</p>
+Il n'y a pas de contrainte d'alignement, les valeurs codées sur plusieurs octets peuvent être obtenues depuis n'importe quelle position.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utilisation_de_la_méthode_getInt32">Utilisation de la méthode <code>getInt32</code></h3>
+### Utilisation de la méthode `getInt32`
 
-<pre class="brush:js">var buffer = new ArrayBuffer(8);
+```js
+var buffer = new ArrayBuffer(8);
 var dataview = new DataView(buffer);
 dataview.getInt32(1); // 0
-</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('Typed Array')}}</td>
-   <td>{{Spec2('Typed Array')}}</td>
-   <td>Remplacée dans ECMAScript 2015.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES2015', '#sec-dataview.prototype.getint32', 'DataView.prototype.getInt32')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale au sein d'un standard ECMA.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-dataview.prototype.getint32', 'DataView.prototype.getInt32')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.DataView.getInt32")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("DataView")}}</li>
- <li>{{jsxref("ArrayBuffer")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                            | État                             | Commentaires                                    |
+| ------------------------------------------------------------------------------------------------------------------------ | -------------------------------- | ----------------------------------------------- |
+| {{SpecName('Typed Array')}}                                                                                     | {{Spec2('Typed Array')}} | Remplacée dans ECMAScript 2015.                 |
+| {{SpecName('ES2015', '#sec-dataview.prototype.getint32', 'DataView.prototype.getInt32')}} | {{Spec2('ES2015')}}         | Définition initiale au sein d'un standard ECMA. |
+| {{SpecName('ESDraft', '#sec-dataview.prototype.getint32', 'DataView.prototype.getInt32')}} | {{Spec2('ESDraft')}}     |                                                 |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.DataView.getInt32")}}
+
+## Voir aussi
+
+- {{jsxref("DataView")}}
+- {{jsxref("ArrayBuffer")}}
diff --git a/files/fr/web/javascript/reference/global_objects/dataview/getint8/index.md b/files/fr/web/javascript/reference/global_objects/dataview/getint8/index.md
index 7404ee6626..137c728e37 100644
--- a/files/fr/web/javascript/reference/global_objects/dataview/getint8/index.md
+++ b/files/fr/web/javascript/reference/global_objects/dataview/getint8/index.md
@@ -11,81 +11,57 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/DataView/getInt8
 original_slug: Web/JavaScript/Reference/Objets_globaux/DataView/getInt8
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>getInt8()</code></strong> permet de lire un entier signé sur 8 bits à l'octet donné par rapport au début de {{jsxref("DataView")}}.</p>
+La méthode **`getInt8()`** permet de lire un entier signé sur 8 bits à l'octet donné par rapport au début de {{jsxref("DataView")}}.
 
-<div>{{EmbedInteractiveExample("pages/js/dataview-getint8.html")}}</div>
+{{EmbedInteractiveExample("pages/js/dataview-getint8.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>dataview</var>.getInt8(positionOctet)</pre>
+    dataview.getInt8(positionOctet)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>positionOctet</code></dt>
- <dd>La position, exprimée en nombre d'octets depuis le début de la vue, à laquelle lire les données.</dd>
-</dl>
+- `positionOctet`
+  - : La position, exprimée en nombre d'octets depuis le début de la vue, à laquelle lire les données.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un entier signé sur 8 bits.</p>
+Un entier signé sur 8 bits.
 
-<h3 id="Erreurs_renvoyées">Erreurs renvoyées</h3>
+### Erreurs renvoyées
 
-<dl>
- <dt>{{jsxref("RangeError")}}</dt>
- <dd>Renvoyée si <code>positionOctet</code> est tel qu'il est en dehors de la vue.</dd>
-</dl>
+- {{jsxref("RangeError")}}
+  - : Renvoyée si `positionOctet` est tel qu'il est en dehors de la vue.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Il n'y a pas de contrainte d'alignement, les valeurs codées sur plusieurs octets peuvent être obtenues depuis n'importe quelle position.</p>
+Il n'y a pas de contrainte d'alignement, les valeurs codées sur plusieurs octets peuvent être obtenues depuis n'importe quelle position.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utilisation_de_la_méthode_getInt8">Utilisation de la méthode <code>getInt8</code></h3>
+### Utilisation de la méthode `getInt8`
 
-<pre class="brush:js">var buffer = new ArrayBuffer(8);
+```js
+var buffer = new ArrayBuffer(8);
 var dataview = new DataView(buffer);
 dataview.getInt8(1); // 0
-</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('Typed Array')}}</td>
-   <td>{{Spec2('Typed Array')}}</td>
-   <td>Remplacée dans ECMAScript 2015.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES2015', '#sec-dataview.prototype.getint8', 'DataView.prototype.getInt8')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale au sein d'un standard ECMA.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-dataview.prototype.getint8', 'DataView.prototype.getInt8')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.DataView.getInt8")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("DataView")}}</li>
- <li>{{jsxref("ArrayBuffer")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                        | État                             | Commentaires                                    |
+| -------------------------------------------------------------------------------------------------------------------- | -------------------------------- | ----------------------------------------------- |
+| {{SpecName('Typed Array')}}                                                                                 | {{Spec2('Typed Array')}} | Remplacée dans ECMAScript 2015.                 |
+| {{SpecName('ES2015', '#sec-dataview.prototype.getint8', 'DataView.prototype.getInt8')}} | {{Spec2('ES2015')}}         | Définition initiale au sein d'un standard ECMA. |
+| {{SpecName('ESDraft', '#sec-dataview.prototype.getint8', 'DataView.prototype.getInt8')}} | {{Spec2('ESDraft')}}     |                                                 |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.DataView.getInt8")}}
+
+## Voir aussi
+
+- {{jsxref("DataView")}}
+- {{jsxref("ArrayBuffer")}}
diff --git a/files/fr/web/javascript/reference/global_objects/dataview/getuint16/index.md b/files/fr/web/javascript/reference/global_objects/dataview/getuint16/index.md
index 7f2a5c307a..c3da190fe2 100644
--- a/files/fr/web/javascript/reference/global_objects/dataview/getuint16/index.md
+++ b/files/fr/web/javascript/reference/global_objects/dataview/getuint16/index.md
@@ -11,83 +11,59 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/DataView/getUint16
 original_slug: Web/JavaScript/Reference/Objets_globaux/DataView/getUint16
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>getUint16()</code></strong> permet de lire un entier non-signé sur 16 bits (type <em>unsigned short</em> par analogie avec C) à l'octet donné par rapport au début de {{jsxref("DataView")}}.</p>
+La méthode **`getUint16()`** permet de lire un entier non-signé sur 16 bits (type _unsigned short_ par analogie avec C) à l'octet donné par rapport au début de {{jsxref("DataView")}}.
 
-<div>{{EmbedInteractiveExample("pages/js/dataview-getuint16.html")}}</div>
+{{EmbedInteractiveExample("pages/js/dataview-getuint16.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>dataview</var>.getUint16(positionOctet [, littleEndian])</pre>
+    dataview.getUint16(positionOctet [, littleEndian])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>positionOctet</code></dt>
- <dd>La position, exprimée en nombre d'octets depuis le début de la vue, à laquelle lire les données.</dd>
- <dt><code>littleEndian</code></dt>
- <dd>{{optional_inline}} indique si la valeur sur 16 bits est enregistrée dans l'ordre des octets {{Glossary("Endianness", "de poids faible")}}. Si le paramètre vaut <code>false</code> ou <code>undefined</code>, la valeur sera lue dans l'ordre des octets de poids forts.</dd>
-</dl>
+- `positionOctet`
+  - : La position, exprimée en nombre d'octets depuis le début de la vue, à laquelle lire les données.
+- `littleEndian`
+  - : {{optional_inline}} indique si la valeur sur 16 bits est enregistrée dans l'ordre des octets {{Glossary("Endianness", "de poids faible")}}. Si le paramètre vaut `false` ou `undefined`, la valeur sera lue dans l'ordre des octets de poids forts.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un entier sur 16 bits non signé.</p>
+Un entier sur 16 bits non signé.
 
-<h3 id="Erreurs_renvoyées">Erreurs renvoyées</h3>
+### Erreurs renvoyées
 
-<dl>
- <dt>{{jsxref("RangeError")}}</dt>
- <dd>Renvoyée si <code>positionOctet</code> est tel qu'il est en dehors de la vue.</dd>
-</dl>
+- {{jsxref("RangeError")}}
+  - : Renvoyée si `positionOctet` est tel qu'il est en dehors de la vue.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Il n'y a pas de contrainte d'alignement, les valeurs codées sur plusieurs octets peuvent être obtenues depuis n'importe quelle position.</p>
+Il n'y a pas de contrainte d'alignement, les valeurs codées sur plusieurs octets peuvent être obtenues depuis n'importe quelle position.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utilisation_de_la_méthode_getUint16">Utilisation de la méthode <code>getUint16</code></h3>
+### Utilisation de la méthode `getUint16`
 
-<pre class="brush:js">var buffer = new ArrayBuffer(8);
+```js
+var buffer = new ArrayBuffer(8);
 var dataview = new DataView(buffer);
 dataview.getUint16(1); // 0
-</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('Typed Array')}}</td>
-   <td>{{Spec2('Typed Array')}}</td>
-   <td>Remplacée dans ECMAScript 2015.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES2015', '#sec-dataview.prototype.getuint16', 'DataView.prototype.getUint16')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale au sein d'un standard ECMA.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-dataview.prototype.getuint16', 'DataView.prototype.getUint16')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.DataView.getUint16")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("DataView")}}</li>
- <li>{{jsxref("ArrayBuffer")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                                | État                             | Commentaires                                    |
+| ---------------------------------------------------------------------------------------------------------------------------- | -------------------------------- | ----------------------------------------------- |
+| {{SpecName('Typed Array')}}                                                                                         | {{Spec2('Typed Array')}} | Remplacée dans ECMAScript 2015.                 |
+| {{SpecName('ES2015', '#sec-dataview.prototype.getuint16', 'DataView.prototype.getUint16')}}     | {{Spec2('ES2015')}}         | Définition initiale au sein d'un standard ECMA. |
+| {{SpecName('ESDraft', '#sec-dataview.prototype.getuint16', 'DataView.prototype.getUint16')}} | {{Spec2('ESDraft')}}     |                                                 |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.DataView.getUint16")}}
+
+## Voir aussi
+
+- {{jsxref("DataView")}}
+- {{jsxref("ArrayBuffer")}}
diff --git a/files/fr/web/javascript/reference/global_objects/dataview/getuint32/index.md b/files/fr/web/javascript/reference/global_objects/dataview/getuint32/index.md
index d01a4a0f87..d45830129d 100644
--- a/files/fr/web/javascript/reference/global_objects/dataview/getuint32/index.md
+++ b/files/fr/web/javascript/reference/global_objects/dataview/getuint32/index.md
@@ -11,83 +11,59 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/DataView/getUint32
 original_slug: Web/JavaScript/Reference/Objets_globaux/DataView/getUint32
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>getUint32()</code></strong> permet de lire un entier non-signé sur 32 bits (type <em>unsigned long</em> par analogie avec C) à l'octet donné par rapport au début de {{jsxref("DataView")}}.</p>
+La méthode **`getUint32()`** permet de lire un entier non-signé sur 32 bits (type _unsigned long_ par analogie avec C) à l'octet donné par rapport au début de {{jsxref("DataView")}}.
 
-<div>{{EmbedInteractiveExample("pages/js/dataview-getuint32.html")}}</div>
+{{EmbedInteractiveExample("pages/js/dataview-getuint32.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>dataview</var>.getUint32(positionOctet [, littleEndian])</pre>
+    dataview.getUint32(positionOctet [, littleEndian])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>positionOctet</code></dt>
- <dd>La position, exprimée en nombre d'octets depuis le début de la vue, à laquelle lire les données.</dd>
- <dt><code>littleEndian</code></dt>
- <dd>{{optional_inline}} indique si la valeur sur 32 bits est enregistrée dans l'ordre des octets {{Glossary("Endianness", "de poids faible")}}. Si le paramètre vaut <code>false</code> ou <code>undefined</code>, la valeur sera lue dans l'ordre des octets de poids forts.</dd>
-</dl>
+- `positionOctet`
+  - : La position, exprimée en nombre d'octets depuis le début de la vue, à laquelle lire les données.
+- `littleEndian`
+  - : {{optional_inline}} indique si la valeur sur 32 bits est enregistrée dans l'ordre des octets {{Glossary("Endianness", "de poids faible")}}. Si le paramètre vaut `false` ou `undefined`, la valeur sera lue dans l'ordre des octets de poids forts.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un entier sur 32 bits, non-signé.</p>
+Un entier sur 32 bits, non-signé.
 
-<h3 id="Erreurs_renvoyées">Erreurs renvoyées</h3>
+### Erreurs renvoyées
 
-<dl>
- <dt>{{jsxref("RangeError")}}</dt>
- <dd>Renvoyée si <code>positionOctet</code> est tel qu'il est en dehors de la vue.</dd>
-</dl>
+- {{jsxref("RangeError")}}
+  - : Renvoyée si `positionOctet` est tel qu'il est en dehors de la vue.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Il n'y a pas de contrainte d'alignement, les valeurs codées sur plusieurs octets peuvent être obtenues depuis n'importe quelle position.</p>
+Il n'y a pas de contrainte d'alignement, les valeurs codées sur plusieurs octets peuvent être obtenues depuis n'importe quelle position.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utilisation_de_la_méthode_getUint32()">Utilisation de la méthode <code>getUint32()</code></h3>
+### Utilisation de la méthode `getUint32()`
 
-<pre class="brush:js">var buffer = new ArrayBuffer(8);
+```js
+var buffer = new ArrayBuffer(8);
 var dataview = new DataView(buffer);
 dataview.getUint32(1); // 0
-</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('Typed Array')}}</td>
-   <td>{{Spec2('Typed Array')}}</td>
-   <td>Remplacée dans ECMAScript 2015.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES2015', '#sec-dataview.prototype.getuint32', 'DataView.prototype.getUint32')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale au sein d'un standard ECMA.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-dataview.prototype.getuint32', 'DataView.prototype.getUint32')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.DataView.getUint32")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("DataView")}}</li>
- <li>{{jsxref("ArrayBuffer")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                                | État                             | Commentaires                                    |
+| ---------------------------------------------------------------------------------------------------------------------------- | -------------------------------- | ----------------------------------------------- |
+| {{SpecName('Typed Array')}}                                                                                         | {{Spec2('Typed Array')}} | Remplacée dans ECMAScript 2015.                 |
+| {{SpecName('ES2015', '#sec-dataview.prototype.getuint32', 'DataView.prototype.getUint32')}}     | {{Spec2('ES2015')}}         | Définition initiale au sein d'un standard ECMA. |
+| {{SpecName('ESDraft', '#sec-dataview.prototype.getuint32', 'DataView.prototype.getUint32')}} | {{Spec2('ESDraft')}}     |                                                 |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.DataView.getUint32")}}
+
+## Voir aussi
+
+- {{jsxref("DataView")}}
+- {{jsxref("ArrayBuffer")}}
diff --git a/files/fr/web/javascript/reference/global_objects/dataview/getuint8/index.md b/files/fr/web/javascript/reference/global_objects/dataview/getuint8/index.md
index a8c94778c7..b49458a38a 100644
--- a/files/fr/web/javascript/reference/global_objects/dataview/getuint8/index.md
+++ b/files/fr/web/javascript/reference/global_objects/dataview/getuint8/index.md
@@ -11,81 +11,57 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/DataView/getUint8
 original_slug: Web/JavaScript/Reference/Objets_globaux/DataView/getUint8
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>getUint8()</code></strong> permet de lire un entier non-signé sur 8 bits à l'octet donné par rapport au début de la {{jsxref("DataView")}}.</p>
+La méthode **`getUint8()`** permet de lire un entier non-signé sur 8 bits à l'octet donné par rapport au début de la {{jsxref("DataView")}}.
 
-<div>{{EmbedInteractiveExample("pages/js/dataview-getuint8.html")}}</div>
+{{EmbedInteractiveExample("pages/js/dataview-getuint8.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>dataview</var>.getUint8(positionOctet)</pre>
+    dataview.getUint8(positionOctet)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>positionOctet</code></dt>
- <dd>La position, exprimée en nombre d'octets depuis le début de la vue, à laquelle lire les données.</dd>
-</dl>
+- `positionOctet`
+  - : La position, exprimée en nombre d'octets depuis le début de la vue, à laquelle lire les données.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un entier sur 8 bits, non-signé.</p>
+Un entier sur 8 bits, non-signé.
 
-<h3 id="Erreurs_renvoyées">Erreurs renvoyées</h3>
+### Erreurs renvoyées
 
-<dl>
- <dt>{{jsxref("RangeError")}}</dt>
- <dd>Renvoyée si <code>positionOctet</code> est tel qu'il est en dehors de la vue.</dd>
-</dl>
+- {{jsxref("RangeError")}}
+  - : Renvoyée si `positionOctet` est tel qu'il est en dehors de la vue.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Il n'y a pas de contrainte d'alignement, les valeurs codées sur plusieurs octets peuvent être obtenues depuis n'importe quelle position.</p>
+Il n'y a pas de contrainte d'alignement, les valeurs codées sur plusieurs octets peuvent être obtenues depuis n'importe quelle position.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utilisation_de_la_méthode_getUint8">Utilisation de la méthode <code>getUint8</code></h3>
+### Utilisation de la méthode `getUint8`
 
-<pre class="brush:js">var buffer = new ArrayBuffer(8);
+```js
+var buffer = new ArrayBuffer(8);
 var dataview = new DataView(buffer);
 dataview.getUint8(1); // 0
-</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('Typed Array')}}</td>
-   <td>{{Spec2('Typed Array')}}</td>
-   <td>Remplacée dans ECMAScript 2015.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES2015', '#sec-dataview.prototype.getuint8', 'DataView.prototype.getUint8')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale au sein d'un standard ECMA.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-dataview.prototype.getuint8', 'DataView.prototype.getUint8')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.DataView.getUint8")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("DataView")}}</li>
- <li>{{jsxref("ArrayBuffer")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                            | État                             | Commentaires                                    |
+| ------------------------------------------------------------------------------------------------------------------------ | -------------------------------- | ----------------------------------------------- |
+| {{SpecName('Typed Array')}}                                                                                     | {{Spec2('Typed Array')}} | Remplacée dans ECMAScript 2015.                 |
+| {{SpecName('ES2015', '#sec-dataview.prototype.getuint8', 'DataView.prototype.getUint8')}} | {{Spec2('ES2015')}}         | Définition initiale au sein d'un standard ECMA. |
+| {{SpecName('ESDraft', '#sec-dataview.prototype.getuint8', 'DataView.prototype.getUint8')}} | {{Spec2('ESDraft')}}     |                                                 |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.DataView.getUint8")}}
+
+## Voir aussi
+
+- {{jsxref("DataView")}}
+- {{jsxref("ArrayBuffer")}}
diff --git a/files/fr/web/javascript/reference/global_objects/dataview/index.md b/files/fr/web/javascript/reference/global_objects/dataview/index.md
index 41edfcb904..d828888f25 100644
--- a/files/fr/web/javascript/reference/global_objects/dataview/index.md
+++ b/files/fr/web/javascript/reference/global_objects/dataview/index.md
@@ -10,62 +10,60 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/DataView
 original_slug: Web/JavaScript/Reference/Objets_globaux/DataView
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La vue <strong><code>DataView</code></strong> fournit une interface de bas niveau pour lire et écrire des données de différents types numériques dans un {{jsxref("ArrayBuffer")}}, quel que soit le « <a href="https://fr.wikipedia.org/wiki/Endianness">boutisme</a> » de la plate-forme.</p>
+La vue **`DataView`** fournit une interface de bas niveau pour lire et écrire des données de différents types numériques dans un {{jsxref("ArrayBuffer")}}, quel que soit le « [boutisme](https://fr.wikipedia.org/wiki/Endianness) » de la plate-forme.
 
-<div>{{EmbedInteractiveExample("pages/js/dataview-constructor.html")}}</div>
+{{EmbedInteractiveExample("pages/js/dataview-constructor.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">new DataView(buffer [, décalageOctets [, longueurOctets]])</pre>
+    new DataView(buffer [, décalageOctets [, longueurOctets]])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>buffer</code></dt>
- <dd>Un {{jsxref("ArrayBuffer")}} ou {{jsxref("SharedArrayBuffer")}}{{experimental_inline}} existant à utiliser pour la mise en mémoire du nouvel objet <code>DataView</code>.</dd>
- <dt><code>décalageOctets </code>{{optional_inline}}</dt>
- <dd>Le décalage, exprimé en octets, pour trouver le premier octet significatif du buffer à représenter dans la vue. Si ce paramètre n'est pas fourni, la vue commencera au premier octet du buffer.</dd>
- <dt><code>longueurOctets </code>{{optional_inline}}</dt>
- <dd>Le nombre d'éléments dans le tableau d'octets. Si ce paramètre n'est pas fourni, la longueur de la vue correspondra à celle du buffer.</dd>
-</dl>
+- `buffer`
+  - : Un {{jsxref("ArrayBuffer")}} ou {{jsxref("SharedArrayBuffer")}}{{experimental_inline}} existant à utiliser pour la mise en mémoire du nouvel objet `DataView`.
+- `décalageOctets `{{optional_inline}}
+  - : Le décalage, exprimé en octets, pour trouver le premier octet significatif du buffer à représenter dans la vue. Si ce paramètre n'est pas fourni, la vue commencera au premier octet du buffer.
+- `longueurOctets `{{optional_inline}}
+  - : Le nombre d'éléments dans le tableau d'octets. Si ce paramètre n'est pas fourni, la longueur de la vue correspondra à celle du buffer.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un nouvel objet <code>DataView</code> représentant le tampon mémoire (<em>buffer</em>) fourni.</p>
+Un nouvel objet `DataView` représentant le tampon mémoire (_buffer_) fourni.
 
-<p>L'objet ainsi renvoyé peut être vu comme un interpréteur du tampon mémoire. Cet objet sait comment convertir des nombres afin de lire ou d'écrire des valeurs dans le tampon. C'est la vue qui s'occupe de la gestion des entiers, de la conversion des flottants, du boutisme utilisé et des autres détails de représentation binaire.</p>
+L'objet ainsi renvoyé peut être vu comme un interpréteur du tampon mémoire. Cet objet sait comment convertir des nombres afin de lire ou d'écrire des valeurs dans le tampon. C'est la vue qui s'occupe de la gestion des entiers, de la conversion des flottants, du boutisme utilisé et des autres détails de représentation binaire.
 
-<h3 id="Erreurs_renvoyées">Erreurs renvoyées</h3>
+### Erreurs renvoyées
 
-<dl>
- <dt><code>{{jsxref("RangeError")}}</code></dt>
- <dd>Renvoyée si les paramètres <code>décalageOctets</code> et <code>longueurOctets</code> dépassent la fin du buffer fourni.</dd>
-</dl>
+- `{{jsxref("RangeError")}}`
+  - : Renvoyée si les paramètres `décalageOctets` et `longueurOctets` dépassent la fin du buffer fourni.
 
-<p>Ainsi, si la taille du tampon mémoire est de 16 octets, que <code>décalageOctets</code>vaut 8 et que <code>longueurOctets</code> vaut 10, cette exception est levée car la vue résultante dépassera de deux octets la longueur totale du tampon mémoire.</p>
+Ainsi, si la taille du tampon mémoire est de 16 octets, que `décalageOctets`vaut 8 et que `longueurOctets` vaut 10, cette exception est levée car la vue résultante dépassera de deux octets la longueur totale du tampon mémoire.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<h3 id="Le_boutisme_(endianness)">Le boutisme (<em>endianness</em>)</h3>
+### Le boutisme (_endianness_)
 
-<p>En utilisant cet objet, vous pouvez détecter le type d'architecture qui exécute votre script, ce qui peut être utile dans certains cas. Voici un fragment de code pour permettre cette détection. Voir {{Glossary("Endianness")}} pour plus d'informations.</p>
+En utilisant cet objet, vous pouvez détecter le type d'architecture qui exécute votre script, ce qui peut être utile dans certains cas. Voici un fragment de code pour permettre cette détection. Voir {{Glossary("Endianness")}} pour plus d'informations.
 
-<pre class="brush: js">var littleEndian = (function() {
+```js
+var littleEndian = (function() {
   var buffer = new ArrayBuffer(2);
   new DataView(buffer).setInt16(0, 256, true /*littleEndian donc */);
   // Int16Array utilise le boutisme de la plate-forme
   return new Int16Array(buffer)[0] === 256;
 })();
 console.log(littleEndian); // true ou false
-</pre>
+```
 
-<h3 id="Gestion_des_valeurs_entières_sur_64_bits">Gestion des valeurs entières sur 64 bits</h3>
+### Gestion des valeurs entières sur 64 bits
 
-<p>JavaScript manipule les nombres comme des valeurs sur 32 bits. Aussi, le moteur ne prend pas en charge la gestion des entiers sur 64 bits et on ne peut donc pas manipuler de telles valeurs avec <code>DataView</code>. Afin de contourner ce problème, on peut implémenter une méthode <code>getUint64()</code> afin d'otbenir une valeur avec une précision allant jusqu'à {{jsxref("Number.MAX_SAFE_INTEGER")}}, ce qui peut être suffisant dans certains cas.</p>
+JavaScript manipule les nombres comme des valeurs sur 32 bits. Aussi, le moteur ne prend pas en charge la gestion des entiers sur 64 bits et on ne peut donc pas manipuler de telles valeurs avec `DataView`. Afin de contourner ce problème, on peut implémenter une méthode `getUint64()` afin d'otbenir une valeur avec une précision allant jusqu'à {{jsxref("Number.MAX_SAFE_INTEGER")}}, ce qui peut être suffisant dans certains cas.
 
-<pre class="brush: js">function getUint64(dataview, byteOffset, littleEndian) {
+```js
+function getUint64(dataview, byteOffset, littleEndian) {
   // on décompose la valeur 64 sur bits en deux nombres 32 bits
   const gauche = dataview.getUint32(byteOffset, littleEndian);
   const droite = dataview.getUint32(byteOffset + 4, littleEndian);
@@ -76,11 +74,13 @@ console.log(littleEndian); // true ou false
     console.warn(combinaison, " dépasse MAX_SAFE_INTEGER : perte de précision !");
   }
   return combinaison;
-}</pre>
+}
+```
 
-<p>On peut également créer un objet {{jsxref("BigInt")}} si on veut avoir accès à 64 bits :</p>
+On peut également créer un objet {{jsxref("BigInt")}} si on veut avoir accès à 64 bits :
 
-<pre class="brush: js">function getUin64BigInt(dataview, byteOffset, littleEndian) {
+```js
+function getUin64BigInt(dataview, byteOffset, littleEndian) {
   const left = dataview.getUint32(byteOffset, littleEndian);
   const right = dataview.getUint32(byteOffset, littleEndian);
 
@@ -89,75 +89,58 @@ console.log(littleEndian); // true ou false
     left.toString(16) + right.toString(16).padStart(8, '0');
 
   return BigInt(`0x${combined}`);
-}</pre>
+}
+```
 
-<div class="blockIndicator note">
-<p><strong>Note :</strong> Sur le plan des performances, les grands entiers ({{jsxref("BigInt")}} ont une taille variable, aussi leur manipulation sera nécessairement plus lente que celle des nombres stockés sur 32 bits. Ceci étant écrit, les valeurs natives {{jsxref("BigInt")}} seront plus performantes que les implémentations tierces (bibliothèques, etc.).</p>
-</div>
+> **Note :** Sur le plan des performances, les grands entiers ({{jsxref("BigInt")}} ont une taille variable, aussi leur manipulation sera nécessairement plus lente que celle des nombres stockés sur 32 bits. Ceci étant écrit, les valeurs natives {{jsxref("BigInt")}} seront plus performantes que les implémentations tierces (bibliothèques, etc.).
 
-<h2 id="Propriétés">Propriétés</h2>
+## Propriétés
 
-<p>Toutes les instances de <code>DataView</code> héritent de {{jsxref("DataView.prototype")}} qui permet d'ajouter des propriétés à l'ensemble des objets <code>DataView</code>.</p>
+Toutes les instances de `DataView` héritent de {{jsxref("DataView.prototype")}} qui permet d'ajouter des propriétés à l'ensemble des objets `DataView`.
 
-<p>{{page("fr/Web/JavaScript/Reference/Objets_globaux/DataView/prototype","Propriétés")}}</p>
+{{page("fr/Web/JavaScript/Reference/Objets_globaux/DataView/prototype","Propriétés")}}
 
-<h2 id="Méthodes">Méthodes</h2>
+## Méthodes
 
-<p>{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/DataView/prototype','Méthodes')}}</p>
+{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/DataView/prototype','Méthodes')}}
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<pre class="brush: js">var buffer = new ArrayBuffer(16);
+```js
+var buffer = new ArrayBuffer(16);
 var dv = new DataView(buffer, 0);
 
 dv.setInt16(1, 42);
 dv.getInt16(1); //42
-</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('Typed Array')}}</td>
-   <td>{{Spec2('Typed Array')}}</td>
-   <td>Remplacée par ECMAScript 6</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-dataview-constructor', 'DataView')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Définition initiale au sein d'un standard ECMA.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-dataview-constructor', 'DataView')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.DataView")}}</p>
-
-<h3 id="Notes_de_compatibilité">Notes de compatibilité</h3>
-
-<p>A partir de Firefox 40 {{geckoRelease(40)}}, <code>DataView</code> doit êre construit avec l'opérateur {{jsxref("Opérateurs/L_opérateur_new", "new")}}. Si on invoque <code>DataView()</code> sans utiliser <code>new</code>, cela lèvera une exception {{jsxref("TypeError")}}.</p>
-
-<pre class="brush: js example-bad">var dv = DataView(buffer, 0);
-// TypeError: calling a builtin DataView constructor without new is forbidden</pre>
-
-<pre class="brush: js example-good">var dv = new DataView(buffer, 0);</pre>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li><a class="link-https" href="https://github.com/jDataView/jDataView">jDataView</a> : une bibliothèque JavaScrit qui ajoute des prothèses et des extensions à l'API <code>DataView</code> afin de pouvoir la manipuler au travers des différents navigateurs et de Node.js.</li>
- <li>{{jsxref("ArrayBuffer")}}</li>
- <li>{{jsxref("SharedArrayBuffer")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                        | État                             | Commentaires                                    |
+| ------------------------------------------------------------------------------------ | -------------------------------- | ----------------------------------------------- |
+| {{SpecName('Typed Array')}}                                                 | {{Spec2('Typed Array')}} | Remplacée par ECMAScript 6                      |
+| {{SpecName('ES6', '#sec-dataview-constructor', 'DataView')}}     | {{Spec2('ES6')}}             | Définition initiale au sein d'un standard ECMA. |
+| {{SpecName('ESDraft', '#sec-dataview-constructor', 'DataView')}} | {{Spec2('ESDraft')}}     |                                                 |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.DataView")}}
+
+### Notes de compatibilité
+
+A partir de Firefox 40 {{geckoRelease(40)}}, `DataView` doit êre construit avec l'opérateur {{jsxref("Opérateurs/L_opérateur_new", "new")}}. Si on invoque `DataView()` sans utiliser `new`, cela lèvera une exception {{jsxref("TypeError")}}.
+
+```js example-bad
+var dv = DataView(buffer, 0);
+// TypeError: calling a builtin DataView constructor without new is forbidden
+```
+
+```js example-good
+var dv = new DataView(buffer, 0);
+```
+
+## Voir aussi
+
+- [jDataView](https://github.com/jDataView/jDataView) : une bibliothèque JavaScrit qui ajoute des prothèses et des extensions à l'API `DataView` afin de pouvoir la manipuler au travers des différents navigateurs et de Node.js.
+- {{jsxref("ArrayBuffer")}}
+- {{jsxref("SharedArrayBuffer")}}
diff --git a/files/fr/web/javascript/reference/global_objects/dataview/setbigint64/index.md b/files/fr/web/javascript/reference/global_objects/dataview/setbigint64/index.md
index 5db0110c35..8581c06772 100644
--- a/files/fr/web/javascript/reference/global_objects/dataview/setbigint64/index.md
+++ b/files/fr/web/javascript/reference/global_objects/dataview/setbigint64/index.md
@@ -11,71 +11,57 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/DataView/setBigInt64
 original_slug: Web/JavaScript/Reference/Objets_globaux/DataView/setBigInt64
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>setBigInt64()</code></strong> permet d'enregister un entier signé sur 64 bits (type <em>long long</em> par analogie avec C) à l'octet indiqué par rapport au début de la {{jsxref("DataView")}}.</p>
+La méthode **`setBigInt64()`** permet d'enregister un entier signé sur 64 bits (type _long long_ par analogie avec C) à l'octet indiqué par rapport au début de la {{jsxref("DataView")}}.
 
-<div>{{EmbedInteractiveExample("pages/js/dataview-setbigint64.html")}}</div>
+{{EmbedInteractiveExample("pages/js/dataview-setbigint64.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>dataview</var>.setBigInt64(positionOctet, value [, littleEndian])</pre>
+    dataview.setBigInt64(positionOctet, value [, littleEndian])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>positionOctet</code></dt>
- <dd>La position, exprimée en numéro d'octet, à partir du début de la vue à laquelle enregistrer la donnée.</dd>
- <dt><code>valeur</code></dt>
- <dd>La valeur à enregistrer</dd>
- <dt><code>littleEndian</code></dt>
- <dd>{{optional_inline}} Indique si la donnée sur 64 bits est enregistrée {{Glossary("Endianness", "dans l'ordre des octets de poids faibles")}}. Si ce paramètre vaut <code>false</code> ou <code>undefined</code>, l'ordre sera celui des octets de poids forts.</dd>
-</dl>
+- `positionOctet`
+  - : La position, exprimée en numéro d'octet, à partir du début de la vue à laquelle enregistrer la donnée.
+- `valeur`
+  - : La valeur à enregistrer
+- `littleEndian`
+  - : {{optional_inline}} Indique si la donnée sur 64 bits est enregistrée {{Glossary("Endianness", "dans l'ordre des octets de poids faibles")}}. Si ce paramètre vaut `false` ou `undefined`, l'ordre sera celui des octets de poids forts.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>{{jsxref("undefined")}}.</p>
+{{jsxref("undefined")}}.
 
-<h3 id="Erreurs_renvoyées">Erreurs renvoyées</h3>
+### Erreurs renvoyées
 
-<dl>
- <dt>{{jsxref("RangeError")}}</dt>
- <dd>Renvoyée si <code>positionOctet</code> est tel que l'enregistrement sera fait en dehors de la vue.</dd>
-</dl>
+- {{jsxref("RangeError")}}
+  - : Renvoyée si `positionOctet` est tel que l'enregistrement sera fait en dehors de la vue.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utilisation_de_la_méthode_setBigInt64()">Utilisation de la méthode <code>setBigInt64()</code></h3>
+### Utilisation de la méthode `setBigInt64()`
 
-<pre class="brush:js">var buffer = new ArrayBuffer(8);
+```js
+var buffer = new ArrayBuffer(8);
 var dataview = new DataView(buffer);
 dataview.setBigInt64(0, 3n);
 dataview.getInt32(0); // 3n
-</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>
-  </tr>
-  <tr>
-   <td><a href="https://tc39.github.io/proposal-bigint/#sec-dataview.prototype.setbigint64">Proposition pour <code>DataView.prototype.setBigInt64()</code></a></td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.DataView.setBigInt64")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("DataView")}}</li>
- <li>{{jsxref("ArrayBuffer")}}</li>
- <li>{{jsxref("BigInt")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                                     | État |
+| --------------------------------------------------------------------------------------------------------------------------------- | ---- |
+| [Proposition pour `DataView.prototype.setBigInt64()`](https://tc39.github.io/proposal-bigint/#sec-dataview.prototype.setbigint64) |      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.DataView.setBigInt64")}}
+
+## Voir aussi
+
+- {{jsxref("DataView")}}
+- {{jsxref("ArrayBuffer")}}
+- {{jsxref("BigInt")}}
diff --git a/files/fr/web/javascript/reference/global_objects/dataview/setbiguint64/index.md b/files/fr/web/javascript/reference/global_objects/dataview/setbiguint64/index.md
index b13aaff413..a55fe3d40a 100644
--- a/files/fr/web/javascript/reference/global_objects/dataview/setbiguint64/index.md
+++ b/files/fr/web/javascript/reference/global_objects/dataview/setbiguint64/index.md
@@ -12,71 +12,57 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/DataView/setBigUint64
 original_slug: Web/JavaScript/Reference/Objets_globaux/DataView/setBigUint64
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>setBigUint64()</code></strong> permet d'enregister un entier non-signé sur 64 bits (type <em>unsigned long long</em> par analogie avec C) à l'octet indiqué par rapport au début de la {{jsxref("DataView")}}.</p>
+La méthode **`setBigUint64()`** permet d'enregister un entier non-signé sur 64 bits (type _unsigned long long_ par analogie avec C) à l'octet indiqué par rapport au début de la {{jsxref("DataView")}}.
 
-<div>{{EmbedInteractiveExample("pages/js/dataview-setbiguint64.html")}}</div>
+{{EmbedInteractiveExample("pages/js/dataview-setbiguint64.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>dataview</var>.setBigUint64(positionOctet, value [, littleEndian])</pre>
+    dataview.setBigUint64(positionOctet, value [, littleEndian])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>positionOctet</code></dt>
- <dd>La position, exprimée en nombre d'octets, à partir du début de la vue à laquelle enregistrer la donnée.</dd>
- <dt><code>valeur</code></dt>
- <dd>La valeur à enregistrer</dd>
- <dt><code>littleEndian</code></dt>
- <dd>{{optional_inline}} Indique si la donnée sur 64 bits est enregistrée {{Glossary("Endianness", "dans l'ordre des octets de poids faibles")}}. Si ce paramètre vaut <code>false</code> ou <code>undefined</code>, l'ordre sera celui des octets de poids forts.</dd>
-</dl>
+- `positionOctet`
+  - : La position, exprimée en nombre d'octets, à partir du début de la vue à laquelle enregistrer la donnée.
+- `valeur`
+  - : La valeur à enregistrer
+- `littleEndian`
+  - : {{optional_inline}} Indique si la donnée sur 64 bits est enregistrée {{Glossary("Endianness", "dans l'ordre des octets de poids faibles")}}. Si ce paramètre vaut `false` ou `undefined`, l'ordre sera celui des octets de poids forts.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>{{jsxref("undefined")}}.</p>
+{{jsxref("undefined")}}.
 
-<h3 id="Erreurs_renvoyées">Erreurs renvoyées</h3>
+### Erreurs renvoyées
 
-<dl>
- <dt>{{jsxref("RangeError")}}</dt>
- <dd>Renvoyée si <code>positionOctet</code> est tel que l'enregistrement sera fait en dehors de la vue.</dd>
-</dl>
+- {{jsxref("RangeError")}}
+  - : Renvoyée si `positionOctet` est tel que l'enregistrement sera fait en dehors de la vue.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utilisation_de_la_méthode_setBigUint64()">Utilisation de la méthode <code>setBigUint64()</code></h3>
+### Utilisation de la méthode `setBigUint64()`
 
-<pre class="brush:js">var buffer = new ArrayBuffer(8);
+```js
+var buffer = new ArrayBuffer(8);
 var dataview = new DataView(buffer);
 dataview.setBigUint64(0, 3n);
 dataview.getInt32(0); // 3n
-</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>
-  </tr>
-  <tr>
-   <td><a href="https://tc39.github.io/proposal-bigint/#sec-dataview.prototype.setBigUint64">Proposition pour <code>DataView.prototype.setBigUint64()</code></a></td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.DataView.setBigUint64")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("DataView")}}</li>
- <li>{{jsxref("ArrayBuffer")}}</li>
- <li>{{jsxref("BigInt")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                                       | État |
+| ----------------------------------------------------------------------------------------------------------------------------------- | ---- |
+| [Proposition pour `DataView.prototype.setBigUint64()`](https://tc39.github.io/proposal-bigint/#sec-dataview.prototype.setBigUint64) |      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.DataView.setBigUint64")}}
+
+## Voir aussi
+
+- {{jsxref("DataView")}}
+- {{jsxref("ArrayBuffer")}}
+- {{jsxref("BigInt")}}
diff --git a/files/fr/web/javascript/reference/global_objects/dataview/setfloat32/index.md b/files/fr/web/javascript/reference/global_objects/dataview/setfloat32/index.md
index a3862d3e4d..2ab89de9f2 100644
--- a/files/fr/web/javascript/reference/global_objects/dataview/setfloat32/index.md
+++ b/files/fr/web/javascript/reference/global_objects/dataview/setfloat32/index.md
@@ -11,82 +11,58 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/DataView/setFloat32
 original_slug: Web/JavaScript/Reference/Objets_globaux/DataView/setFloat32
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>setFloat32()</code></strong> permet d'enregistrer un nombre flottant signé sur 32 bits (type <em>float</em> par analogie avec C) à l'octet indiqué par rapport au début de la {{jsxref("DataView")}}.</p>
+La méthode **`setFloat32()`** permet d'enregistrer un nombre flottant signé sur 32 bits (type _float_ par analogie avec C) à l'octet indiqué par rapport au début de la {{jsxref("DataView")}}.
 
-<div>{{EmbedInteractiveExample("pages/js/dataview-setfloat32.html")}}</div>
+{{EmbedInteractiveExample("pages/js/dataview-setfloat32.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>dataview</var>.setFloat32(positionOctet, valeur [, littleEndian])</pre>
+    dataview.setFloat32(positionOctet, valeur [, littleEndian])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>positionOctet</code></dt>
- <dd>La position, exprimée en numéro d'octet, à partir du début de la vue à laquelle enregistrer la donnée.</dd>
- <dt><code>valeur</code></dt>
- <dd>La valeur à enregistrer</dd>
- <dt><code>littleEndian</code></dt>
- <dd>{{optional_inline}} Indique si la donnée sur 32 bits est enregistrée {{Glossary("Endianness", "dans l'ordre des octets de poids faibles")}}. Si ce paramètre vaut <code>false</code> ou <code>undefined</code>, l'ordre sera celui des octets de poids forts.</dd>
-</dl>
+- `positionOctet`
+  - : La position, exprimée en numéro d'octet, à partir du début de la vue à laquelle enregistrer la donnée.
+- `valeur`
+  - : La valeur à enregistrer
+- `littleEndian`
+  - : {{optional_inline}} Indique si la donnée sur 32 bits est enregistrée {{Glossary("Endianness", "dans l'ordre des octets de poids faibles")}}. Si ce paramètre vaut `false` ou `undefined`, l'ordre sera celui des octets de poids forts.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>{{jsxref("undefined")}}.</p>
+{{jsxref("undefined")}}.
 
-<h3 id="Erreurs_renvoyées">Erreurs renvoyées</h3>
+### Erreurs renvoyées
 
-<dl>
- <dt>{{jsxref("RangeError")}}</dt>
- <dd>Renvoyée si <code>positionOctet</code> est tel que l'enregistrement sera fait en dehors de la vue.</dd>
-</dl>
+- {{jsxref("RangeError")}}
+  - : Renvoyée si `positionOctet` est tel que l'enregistrement sera fait en dehors de la vue.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utilisation_de_la_méthode_setFloat32">Utilisation de la méthode <code>setFloat32</code></h3>
+### Utilisation de la méthode `setFloat32`
 
-<pre class="brush:js">var buffer = new ArrayBuffer(8);
+```js
+var buffer = new ArrayBuffer(8);
 var dataview = new DataView(buffer);
 dataview.setFloat32(1, 3);
 dataview.getFloat32(1); // 3
-</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('Typed Array')}}</td>
-   <td>{{Spec2('Typed Array')}}</td>
-   <td>Remplacée dans ECMAScript 2015.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES2015', '#sec-dataview.prototype.setfloat32', 'DataView.prototype.setFloat32')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale au sein d'un standard ECMA.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-dataview.prototype.setfloat32', 'DataView.prototype.setFloat32')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.DataView.setFloat32")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("DataView")}}</li>
- <li>{{jsxref("ArrayBuffer")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                                | État                             | Commentaires                                    |
+| ---------------------------------------------------------------------------------------------------------------------------- | -------------------------------- | ----------------------------------------------- |
+| {{SpecName('Typed Array')}}                                                                                         | {{Spec2('Typed Array')}} | Remplacée dans ECMAScript 2015.                 |
+| {{SpecName('ES2015', '#sec-dataview.prototype.setfloat32', 'DataView.prototype.setFloat32')}} | {{Spec2('ES2015')}}         | Définition initiale au sein d'un standard ECMA. |
+| {{SpecName('ESDraft', '#sec-dataview.prototype.setfloat32', 'DataView.prototype.setFloat32')}} | {{Spec2('ESDraft')}}     |                                                 |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.DataView.setFloat32")}}
+
+## Voir aussi
+
+- {{jsxref("DataView")}}
+- {{jsxref("ArrayBuffer")}}
diff --git a/files/fr/web/javascript/reference/global_objects/dataview/setfloat64/index.md b/files/fr/web/javascript/reference/global_objects/dataview/setfloat64/index.md
index 0b1d62773b..c374e3732b 100644
--- a/files/fr/web/javascript/reference/global_objects/dataview/setfloat64/index.md
+++ b/files/fr/web/javascript/reference/global_objects/dataview/setfloat64/index.md
@@ -11,82 +11,58 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/DataView/setFloat64
 original_slug: Web/JavaScript/Reference/Objets_globaux/DataView/setFloat64
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>setFloat64()</code></strong> permet d'enregistrer un nombre flottant signé sur 64 bits (type <em>double</em> par analogie avec C) à l'octet indiqué par rapport au début de la {{jsxref("DataView")}}.</p>
+La méthode **`setFloat64()`** permet d'enregistrer un nombre flottant signé sur 64 bits (type _double_ par analogie avec C) à l'octet indiqué par rapport au début de la {{jsxref("DataView")}}.
 
-<div>{{EmbedInteractiveExample("pages/js/dataview-setfloat64.html")}}</div>
+{{EmbedInteractiveExample("pages/js/dataview-setfloat64.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>dataview</var>.setFloat64(positionOctet, value [, littleEndian])</pre>
+    dataview.setFloat64(positionOctet, value [, littleEndian])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>positionOctet</code></dt>
- <dd>La position, exprimée en numéro d'octet, à partir du début de la vue à laquelle enregistrer la donnée.</dd>
- <dt><code>valeur</code></dt>
- <dd>La valeur à enregistrer</dd>
- <dt><code>littleEndian</code></dt>
- <dd>{{optional_inline}} Indique si la donnée sur 64 bits est enregistrée {{Glossary("Endianness", "dans l'ordre des octets de poids faibles")}}. Si ce paramètre vaut <code>false</code> ou <code>undefined</code>, l'ordre sera celui des octets de poids forts.</dd>
-</dl>
+- `positionOctet`
+  - : La position, exprimée en numéro d'octet, à partir du début de la vue à laquelle enregistrer la donnée.
+- `valeur`
+  - : La valeur à enregistrer
+- `littleEndian`
+  - : {{optional_inline}} Indique si la donnée sur 64 bits est enregistrée {{Glossary("Endianness", "dans l'ordre des octets de poids faibles")}}. Si ce paramètre vaut `false` ou `undefined`, l'ordre sera celui des octets de poids forts.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>{{jsxref("undefined")}}.</p>
+{{jsxref("undefined")}}.
 
-<h3 id="Erreurs_renvoyées">Erreurs renvoyées</h3>
+### Erreurs renvoyées
 
-<dl>
- <dt>{{jsxref("RangeError")}}</dt>
- <dd>Renvoyée si <code>positionOctet</code> est tel que l'enregistrement sera fait en dehors de la vue.</dd>
-</dl>
+- {{jsxref("RangeError")}}
+  - : Renvoyée si `positionOctet` est tel que l'enregistrement sera fait en dehors de la vue.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utilisation_de_la_méthode_setFloat64">Utilisation de la méthode <code>setFloat64</code></h3>
+### Utilisation de la méthode `setFloat64`
 
-<pre class="brush:js">var buffer = new ArrayBuffer(8);
+```js
+var buffer = new ArrayBuffer(8);
 var dataview = new DataView(buffer);
 dataview.setFloat64(0, 3);
 dataview.getFloat64(0); // 3
-</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('Typed Array')}}</td>
-   <td>{{Spec2('Typed Array')}}</td>
-   <td>Remplacée dans ECMAScript 2015.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES2015', '#sec-dataview.prototype.setfloat64', 'DataView.prototype.setFloat64')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale au sein d'un standard ECMA.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-dataview.prototype.setfloat64', 'DataView.prototype.setFloat64')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.DataView.setFloat64")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("DataView")}}</li>
- <li>{{jsxref("ArrayBuffer")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                                | État                             | Commentaires                                    |
+| ---------------------------------------------------------------------------------------------------------------------------- | -------------------------------- | ----------------------------------------------- |
+| {{SpecName('Typed Array')}}                                                                                         | {{Spec2('Typed Array')}} | Remplacée dans ECMAScript 2015.                 |
+| {{SpecName('ES2015', '#sec-dataview.prototype.setfloat64', 'DataView.prototype.setFloat64')}} | {{Spec2('ES2015')}}         | Définition initiale au sein d'un standard ECMA. |
+| {{SpecName('ESDraft', '#sec-dataview.prototype.setfloat64', 'DataView.prototype.setFloat64')}} | {{Spec2('ESDraft')}}     |                                                 |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.DataView.setFloat64")}}
+
+## Voir aussi
+
+- {{jsxref("DataView")}}
+- {{jsxref("ArrayBuffer")}}
diff --git a/files/fr/web/javascript/reference/global_objects/dataview/setint16/index.md b/files/fr/web/javascript/reference/global_objects/dataview/setint16/index.md
index b275f78339..60e26fd516 100644
--- a/files/fr/web/javascript/reference/global_objects/dataview/setint16/index.md
+++ b/files/fr/web/javascript/reference/global_objects/dataview/setint16/index.md
@@ -11,82 +11,58 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/DataView/setInt16
 original_slug: Web/JavaScript/Reference/Objets_globaux/DataView/setInt16
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>setInt16()</code></strong> permet d'enregister un entier signé sur 16 bits (type short par analogie avec C) à l'octet indiqué par rapport au début de la {{jsxref("DataView")}}.</p>
+La méthode **`setInt16()`** permet d'enregister un entier signé sur 16 bits (type short par analogie avec C) à l'octet indiqué par rapport au début de la {{jsxref("DataView")}}.
 
-<div>{{EmbedInteractiveExample("pages/js/dataview-setint16.html")}}</div>
+{{EmbedInteractiveExample("pages/js/dataview-setint16.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>dataview</var>.setInt16(positionOctet, value [, littleEndian])</pre>
+    dataview.setInt16(positionOctet, value [, littleEndian])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>positionOctet</code></dt>
- <dd>La position, exprimée en numéro d'octet, à partir du début de la vue à laquelle enregistrer la donnée.</dd>
- <dt><code>valeur</code></dt>
- <dd>La valeur à enregistrer</dd>
- <dt><code>littleEndian</code></dt>
- <dd>{{optional_inline}} Indique si la donnée sur 16 bits est enregistrée {{Glossary("Endianness", "dans l'ordre des octets de poids faibles")}}. Si ce paramètre vaut <code>false</code> ou <code>undefined</code>, l'ordre sera celui des octets de poids forts.</dd>
-</dl>
+- `positionOctet`
+  - : La position, exprimée en numéro d'octet, à partir du début de la vue à laquelle enregistrer la donnée.
+- `valeur`
+  - : La valeur à enregistrer
+- `littleEndian`
+  - : {{optional_inline}} Indique si la donnée sur 16 bits est enregistrée {{Glossary("Endianness", "dans l'ordre des octets de poids faibles")}}. Si ce paramètre vaut `false` ou `undefined`, l'ordre sera celui des octets de poids forts.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>{{jsxref("undefined")}}.</p>
+{{jsxref("undefined")}}.
 
-<h3 id="Erreurs_renvoyées">Erreurs renvoyées</h3>
+### Erreurs renvoyées
 
-<dl>
- <dt>{{jsxref("RangeError")}}</dt>
- <dd>Renvoyée si <code>positionOctet</code> est tel que l'enregistrement sera fait en dehors de la vue.</dd>
-</dl>
+- {{jsxref("RangeError")}}
+  - : Renvoyée si `positionOctet` est tel que l'enregistrement sera fait en dehors de la vue.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utilisation_de_la_méthode_setInt16">Utilisation de la méthode <code>setInt16</code></h3>
+### Utilisation de la méthode `setInt16`
 
-<pre class="brush:js">var buffer = new ArrayBuffer(8);
+```js
+var buffer = new ArrayBuffer(8);
 var dataview = new DataView(buffer);
 dataview.setInt16(1, 3);
 dataview.getInt16(1); // 3
-</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('Typed Array')}}</td>
-   <td>{{Spec2('Typed Array')}}</td>
-   <td>Remplacée par ECMAScript 2015 (ES6).</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES2015', '#sec-dataview.prototype.setint16', 'DataView.prototype.setInt16')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale au sein d'un standard ECMA.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-dataview.prototype.setint16', 'DataView.prototype.setInt16')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.DataView.setInt16")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("DataView")}}</li>
- <li>{{jsxref("ArrayBuffer")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                            | État                             | Commentaires                                    |
+| ------------------------------------------------------------------------------------------------------------------------ | -------------------------------- | ----------------------------------------------- |
+| {{SpecName('Typed Array')}}                                                                                     | {{Spec2('Typed Array')}} | Remplacée par ECMAScript 2015 (ES6).            |
+| {{SpecName('ES2015', '#sec-dataview.prototype.setint16', 'DataView.prototype.setInt16')}} | {{Spec2('ES2015')}}         | Définition initiale au sein d'un standard ECMA. |
+| {{SpecName('ESDraft', '#sec-dataview.prototype.setint16', 'DataView.prototype.setInt16')}} | {{Spec2('ESDraft')}}     |                                                 |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.DataView.setInt16")}}
+
+## Voir aussi
+
+- {{jsxref("DataView")}}
+- {{jsxref("ArrayBuffer")}}
diff --git a/files/fr/web/javascript/reference/global_objects/dataview/setint32/index.md b/files/fr/web/javascript/reference/global_objects/dataview/setint32/index.md
index 21e51b28dd..65e8802da3 100644
--- a/files/fr/web/javascript/reference/global_objects/dataview/setint32/index.md
+++ b/files/fr/web/javascript/reference/global_objects/dataview/setint32/index.md
@@ -11,82 +11,58 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/DataView/setInt32
 original_slug: Web/JavaScript/Reference/Objets_globaux/DataView/setInt32
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>setInt32()</code></strong> permet d'enregister un entier signé sur 32 bits (type <em>long</em> par analogie avec C) à l'octet indiqué par rapport au début de la {{jsxref("DataView")}}.</p>
+La méthode **`setInt32()`** permet d'enregister un entier signé sur 32 bits (type _long_ par analogie avec C) à l'octet indiqué par rapport au début de la {{jsxref("DataView")}}.
 
-<div>{{EmbedInteractiveExample("pages/js/dataview-setint32.html")}}</div>
+{{EmbedInteractiveExample("pages/js/dataview-setint32.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>dataview</var>.setInt32(positionOctet, value [, littleEndian])</pre>
+    dataview.setInt32(positionOctet, value [, littleEndian])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>positionOctet</code></dt>
- <dd>La position, exprimée en numéro d'octet, à partir du début de la vue à laquelle enregistrer la donnée.</dd>
- <dt><code>valeur</code></dt>
- <dd>La valeur à enregistrer</dd>
- <dt><code>littleEndian</code></dt>
- <dd>{{optional_inline}} Indique si la donnée sur 32 bits est enregistrée {{Glossary("Endianness", "dans l'ordre des octets de poids faibles")}}. Si ce paramètre vaut <code>false</code> ou <code>undefined</code>, l'ordre sera celui des octets de poids forts.</dd>
-</dl>
+- `positionOctet`
+  - : La position, exprimée en numéro d'octet, à partir du début de la vue à laquelle enregistrer la donnée.
+- `valeur`
+  - : La valeur à enregistrer
+- `littleEndian`
+  - : {{optional_inline}} Indique si la donnée sur 32 bits est enregistrée {{Glossary("Endianness", "dans l'ordre des octets de poids faibles")}}. Si ce paramètre vaut `false` ou `undefined`, l'ordre sera celui des octets de poids forts.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>{{jsxref("undefined")}}.</p>
+{{jsxref("undefined")}}.
 
-<h3 id="Erreurs_renvoyées">Erreurs renvoyées</h3>
+### Erreurs renvoyées
 
-<dl>
- <dt>{{jsxref("RangeError")}}</dt>
- <dd>Renvoyée si <code>positionOctet</code> est tel que l'enregistrement sera fait en dehors de la vue.</dd>
-</dl>
+- {{jsxref("RangeError")}}
+  - : Renvoyée si `positionOctet` est tel que l'enregistrement sera fait en dehors de la vue.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utilisation_de_la_méthode_setInt32">Utilisation de la méthode <code>setInt32</code></h3>
+### Utilisation de la méthode `setInt32`
 
-<pre class="brush:js">var buffer = new ArrayBuffer(8);
+```js
+var buffer = new ArrayBuffer(8);
 var dataview = new DataView(buffer);
 dataview.setInt32(1, 3);
 dataview.getInt32(1); // 3
-</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('Typed Array')}}</td>
-   <td>{{Spec2('Typed Array')}}</td>
-   <td>Remplacée par ECMAScript 2015.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES2015', '#sec-dataview.prototype.setint32', 'DataView.prototype.setInt32')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale au sein d'un standard ECMA.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-dataview.prototype.setint32', 'DataView.prototype.setInt32')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.DataView.setInt32")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("DataView")}}</li>
- <li>{{jsxref("ArrayBuffer")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                            | État                             | Commentaires                                    |
+| ------------------------------------------------------------------------------------------------------------------------ | -------------------------------- | ----------------------------------------------- |
+| {{SpecName('Typed Array')}}                                                                                     | {{Spec2('Typed Array')}} | Remplacée par ECMAScript 2015.                  |
+| {{SpecName('ES2015', '#sec-dataview.prototype.setint32', 'DataView.prototype.setInt32')}} | {{Spec2('ES2015')}}         | Définition initiale au sein d'un standard ECMA. |
+| {{SpecName('ESDraft', '#sec-dataview.prototype.setint32', 'DataView.prototype.setInt32')}} | {{Spec2('ESDraft')}}     |                                                 |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.DataView.setInt32")}}
+
+## Voir aussi
+
+- {{jsxref("DataView")}}
+- {{jsxref("ArrayBuffer")}}
diff --git a/files/fr/web/javascript/reference/global_objects/dataview/setint8/index.md b/files/fr/web/javascript/reference/global_objects/dataview/setint8/index.md
index f088ea3247..80f169d855 100644
--- a/files/fr/web/javascript/reference/global_objects/dataview/setint8/index.md
+++ b/files/fr/web/javascript/reference/global_objects/dataview/setint8/index.md
@@ -11,82 +11,56 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/DataView/setInt8
 original_slug: Web/JavaScript/Reference/Objets_globaux/DataView/setInt8
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>setInt8()</code></strong> permet d'enregister un entier signé sur 8 bits à l'octet indiqué par rapport au début de la {{jsxref("DataView")}}.</p>
+La méthode **`setInt8()`** permet d'enregister un entier signé sur 8 bits à l'octet indiqué par rapport au début de la {{jsxref("DataView")}}.
 
-<div>{{EmbedInteractiveExample("pages/js/dataview-setint8.html")}}</div>
+{{EmbedInteractiveExample("pages/js/dataview-setint8.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>dataview</var>.setInt8(positionOctet, valeur)</pre>
+    dataview.setInt8(positionOctet, valeur)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>positionOctet</code></dt>
- <dd>La position, exprimée en numéro d'octet, à partir du début de la vue à laquelle enregistrer la donnée.</dd>
- <dt><code>valeur</code></dt>
- <dd>La valeur à enregistrer.</dd>
-</dl>
+- `positionOctet`
+  - : La position, exprimée en numéro d'octet, à partir du début de la vue à laquelle enregistrer la donnée.
+- `valeur`
+  - : La valeur à enregistrer.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>{{jsxref("undefined")}}.</p>
+{{jsxref("undefined")}}.
 
-<h3 id="Erreurs_renvoyées">Erreurs renvoyées</h3>
+### Erreurs renvoyées
 
-<dl>
- <dt>{{jsxref("RangeError")}}</dt>
- <dd>Renvoyée si <code>positionOctet</code> est tel que l'enregistrement sera fait en dehors de la vue.</dd>
-</dl>
+- {{jsxref("RangeError")}}
+  - : Renvoyée si `positionOctet` est tel que l'enregistrement sera fait en dehors de la vue.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utilisation_de_la_méthode_setInt8">Utilisation de la méthode <code>setInt8</code></h3>
+### Utilisation de la méthode `setInt8`
 
-<pre class="brush:js">var buffer = new ArrayBuffer(8);
+```js
+var buffer = new ArrayBuffer(8);
 var dataview = new DataView(buffer);
 dataview.setInt8(1, 3);
 dataview.getInt8(1); // 3
-</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('Typed Array')}}</td>
-   <td>{{Spec2('Typed Array')}}</td>
-   <td>Remplacée dans ECMAScript 2015.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES2015', '#sec-dataview.prototype.setint8', 'DataView.prototype.setInt8')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale au sein d'un standard ECMA.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-dataview.prototype.setint8', 'DataView.prototype.setInt8')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-
-
-<p>{{Compat("javascript.builtins.DataView.setInt8")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("DataView")}}</li>
- <li>{{jsxref("ArrayBuffer")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                        | État                             | Commentaires                                    |
+| -------------------------------------------------------------------------------------------------------------------- | -------------------------------- | ----------------------------------------------- |
+| {{SpecName('Typed Array')}}                                                                                 | {{Spec2('Typed Array')}} | Remplacée dans ECMAScript 2015.                 |
+| {{SpecName('ES2015', '#sec-dataview.prototype.setint8', 'DataView.prototype.setInt8')}} | {{Spec2('ES2015')}}         | Définition initiale au sein d'un standard ECMA. |
+| {{SpecName('ESDraft', '#sec-dataview.prototype.setint8', 'DataView.prototype.setInt8')}} | {{Spec2('ESDraft')}}     |                                                 |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.DataView.setInt8")}}
+
+## Voir aussi
+
+- {{jsxref("DataView")}}
+- {{jsxref("ArrayBuffer")}}
diff --git a/files/fr/web/javascript/reference/global_objects/dataview/setuint16/index.md b/files/fr/web/javascript/reference/global_objects/dataview/setuint16/index.md
index 45ce24f36d..350929f26d 100644
--- a/files/fr/web/javascript/reference/global_objects/dataview/setuint16/index.md
+++ b/files/fr/web/javascript/reference/global_objects/dataview/setuint16/index.md
@@ -11,82 +11,58 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/DataView/setUint16
 original_slug: Web/JavaScript/Reference/Objets_globaux/DataView/setUint16
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>setUint16()</code></strong> permet d'enregister un entier non-signé sur 16 bits (type <em>unsigned short</em> par analogie avec C) à l'octet indiqué par rapport au début de la {{jsxref("DataView")}}.</p>
+La méthode **`setUint16()`** permet d'enregister un entier non-signé sur 16 bits (type _unsigned short_ par analogie avec C) à l'octet indiqué par rapport au début de la {{jsxref("DataView")}}.
 
-<div>{{EmbedInteractiveExample("pages/js/dataview-setuint16.html")}}</div>
+{{EmbedInteractiveExample("pages/js/dataview-setuint16.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>dataview</var>.setUint16(positionOctet, valeur [, littleEndian])</pre>
+    dataview.setUint16(positionOctet, valeur [, littleEndian])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>positionOctet</code></dt>
- <dd>La position, exprimée en numéro d'octet, à partir du début de la vue à laquelle enregistrer la donnée.</dd>
- <dt><code>valeur</code></dt>
- <dd>La valeur à enregistrer</dd>
- <dt><code>littleEndian</code></dt>
- <dd>{{optional_inline}} Indique si la donnée sur 32 bits est enregistrée {{Glossary("Endianness", "dans l'ordre des octets de poids faibles")}}. Si ce paramètre vaut <code>false</code> ou <code>undefined</code>, l'ordre sera celui des octets de poids forts.</dd>
-</dl>
+- `positionOctet`
+  - : La position, exprimée en numéro d'octet, à partir du début de la vue à laquelle enregistrer la donnée.
+- `valeur`
+  - : La valeur à enregistrer
+- `littleEndian`
+  - : {{optional_inline}} Indique si la donnée sur 32 bits est enregistrée {{Glossary("Endianness", "dans l'ordre des octets de poids faibles")}}. Si ce paramètre vaut `false` ou `undefined`, l'ordre sera celui des octets de poids forts.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>{{jsxref("undefined")}}.</p>
+{{jsxref("undefined")}}.
 
-<h3 id="Erreurs_renvoyées">Erreurs renvoyées</h3>
+### Erreurs renvoyées
 
-<dl>
- <dt>{{jsxref("RangeError")}}</dt>
- <dd>Renvoyée si <code>positionOctet</code> est tel que l'enregistrement sera fait en dehors de la vue.</dd>
-</dl>
+- {{jsxref("RangeError")}}
+  - : Renvoyée si `positionOctet` est tel que l'enregistrement sera fait en dehors de la vue.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utilisation_de_la_méthode_setUint1">Utilisation de la méthode <code>setUint1</code></h3>
+### Utilisation de la méthode `setUint1`
 
-<pre class="brush:js">var buffer = new ArrayBuffer(8);
+```js
+var buffer = new ArrayBuffer(8);
 var dataview = new DataView(buffer);
 dataview.setUint16(1, 3);
 dataview.getUint16(1); // 3
-</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('Typed Array')}}</td>
-   <td>{{Spec2('Typed Array')}}</td>
-   <td>Remplacée dans ECMAScript 2015.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES2015', '#sec-dataview.prototype.setuint16', 'DataView.prototype.setUint16')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale au sein d'un standard ECMA.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-dataview.prototype.setuint16', 'DataView.prototype.setUint16')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.DataView.setUint16")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("DataView")}}</li>
- <li>{{jsxref("ArrayBuffer")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                                | État                             | Commentaires                                    |
+| ---------------------------------------------------------------------------------------------------------------------------- | -------------------------------- | ----------------------------------------------- |
+| {{SpecName('Typed Array')}}                                                                                         | {{Spec2('Typed Array')}} | Remplacée dans ECMAScript 2015.                 |
+| {{SpecName('ES2015', '#sec-dataview.prototype.setuint16', 'DataView.prototype.setUint16')}}     | {{Spec2('ES2015')}}         | Définition initiale au sein d'un standard ECMA. |
+| {{SpecName('ESDraft', '#sec-dataview.prototype.setuint16', 'DataView.prototype.setUint16')}} | {{Spec2('ESDraft')}}     |                                                 |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.DataView.setUint16")}}
+
+## Voir aussi
+
+- {{jsxref("DataView")}}
+- {{jsxref("ArrayBuffer")}}
diff --git a/files/fr/web/javascript/reference/global_objects/dataview/setuint32/index.md b/files/fr/web/javascript/reference/global_objects/dataview/setuint32/index.md
index 7c0dc85072..15dc13fe04 100644
--- a/files/fr/web/javascript/reference/global_objects/dataview/setuint32/index.md
+++ b/files/fr/web/javascript/reference/global_objects/dataview/setuint32/index.md
@@ -11,82 +11,58 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/DataView/setUint32
 original_slug: Web/JavaScript/Reference/Objets_globaux/DataView/setUint32
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>setUint32()</code></strong> permet d'enregister un entier non-signé sur 32 bits (type <em>unsigned long</em> par analogie avec C) à l'octet indiqué par rapport au début de la {{jsxref("DataView")}}.</p>
+La méthode **`setUint32()`** permet d'enregister un entier non-signé sur 32 bits (type _unsigned long_ par analogie avec C) à l'octet indiqué par rapport au début de la {{jsxref("DataView")}}.
 
-<div>{{EmbedInteractiveExample("pages/js/dataview-setuint32.html")}}</div>
+{{EmbedInteractiveExample("pages/js/dataview-setuint32.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>dataview</var>.setUint32(positionOctet, valeur [, littleEndian])</pre>
+    dataview.setUint32(positionOctet, valeur [, littleEndian])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>positionOctet</code></dt>
- <dd>La position, exprimée en numéro d'octet, à partir du début de la vue à laquelle enregistrer la donnée.</dd>
- <dt><code>valeur</code></dt>
- <dd>La valeur à enregistrer</dd>
- <dt><code>littleEndian</code></dt>
- <dd>{{optional_inline}} Indique si la donnée sur 32 bits est enregistrée {{Glossary("Endianness", "dans l'ordre des octets de poids faibles")}}. Si ce paramètre vaut <code>false</code> ou <code>undefined</code>, l'ordre sera celui des octets de poids forts.</dd>
-</dl>
+- `positionOctet`
+  - : La position, exprimée en numéro d'octet, à partir du début de la vue à laquelle enregistrer la donnée.
+- `valeur`
+  - : La valeur à enregistrer
+- `littleEndian`
+  - : {{optional_inline}} Indique si la donnée sur 32 bits est enregistrée {{Glossary("Endianness", "dans l'ordre des octets de poids faibles")}}. Si ce paramètre vaut `false` ou `undefined`, l'ordre sera celui des octets de poids forts.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>{{jsxref("undefined")}}.</p>
+{{jsxref("undefined")}}.
 
-<h3 id="Erreurs_renvoyées">Erreurs renvoyées</h3>
+### Erreurs renvoyées
 
-<dl>
- <dt>{{jsxref("RangeError")}}</dt>
- <dd>Renvoyée si <code>positionOctet</code> est tel que l'enregistrement sera fait en dehors de la vue.</dd>
-</dl>
+- {{jsxref("RangeError")}}
+  - : Renvoyée si `positionOctet` est tel que l'enregistrement sera fait en dehors de la vue.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utilisation_de_la_méthode_setUint32">Utilisation de la méthode <code>setUint32</code></h3>
+### Utilisation de la méthode `setUint32`
 
-<pre class="brush:js">var buffer = new ArrayBuffer(8);
+```js
+var buffer = new ArrayBuffer(8);
 var dataview = new DataView(buffer);
 dataview.setUint32(1, 3);
 dataview.getUint32(1); // 3
-</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('Typed Array')}}</td>
-   <td>{{Spec2('Typed Array')}}</td>
-   <td>Remplacée dans ECMAScript 2015 (ES6).</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES2015', '#sec-dataview.prototype.setuint32', 'DataView.prototype.setUint32')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale au sein d'un standard ECMA.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-dataview.prototype.setuint32', 'DataView.prototype.setUint32')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.DataView.setUint32")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("DataView")}}</li>
- <li>{{jsxref("ArrayBuffer")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                                | État                             | Commentaires                                    |
+| ---------------------------------------------------------------------------------------------------------------------------- | -------------------------------- | ----------------------------------------------- |
+| {{SpecName('Typed Array')}}                                                                                         | {{Spec2('Typed Array')}} | Remplacée dans ECMAScript 2015 (ES6).           |
+| {{SpecName('ES2015', '#sec-dataview.prototype.setuint32', 'DataView.prototype.setUint32')}}     | {{Spec2('ES2015')}}         | Définition initiale au sein d'un standard ECMA. |
+| {{SpecName('ESDraft', '#sec-dataview.prototype.setuint32', 'DataView.prototype.setUint32')}} | {{Spec2('ESDraft')}}     |                                                 |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.DataView.setUint32")}}
+
+## Voir aussi
+
+- {{jsxref("DataView")}}
+- {{jsxref("ArrayBuffer")}}
diff --git a/files/fr/web/javascript/reference/global_objects/dataview/setuint8/index.md b/files/fr/web/javascript/reference/global_objects/dataview/setuint8/index.md
index f53c1a78ce..45c7db8f89 100644
--- a/files/fr/web/javascript/reference/global_objects/dataview/setuint8/index.md
+++ b/files/fr/web/javascript/reference/global_objects/dataview/setuint8/index.md
@@ -11,80 +11,56 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/DataView/setUint8
 original_slug: Web/JavaScript/Reference/Objets_globaux/DataView/setUint8
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>setUint8()</code></strong> permet d'enregister un entier non-signé sur 8 bits à l'octet indiqué par rapport au début de la {{jsxref("DataView")}}.</p>
+La méthode **`setUint8()`** permet d'enregister un entier non-signé sur 8 bits à l'octet indiqué par rapport au début de la {{jsxref("DataView")}}.
 
-<div>{{EmbedInteractiveExample("pages/js/dataview-setuint8.html")}}</div>
+{{EmbedInteractiveExample("pages/js/dataview-setuint8.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>dataview</var>.setUint8(positionOctet, valeur)</pre>
+    dataview.setUint8(positionOctet, valeur)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>positionOctet</code></dt>
- <dd>La position, exprimée en numéro d'octet, à partir du début de la vue à laquelle enregistrer la donnée.</dd>
- <dt><code>valeur</code></dt>
- <dd>La valeur à enregistrer.</dd>
-</dl>
+- `positionOctet`
+  - : La position, exprimée en numéro d'octet, à partir du début de la vue à laquelle enregistrer la donnée.
+- `valeur`
+  - : La valeur à enregistrer.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>{{jsxref("undefined")}}.</p>
+{{jsxref("undefined")}}.
 
-<h3 id="Erreurs_renvoyées">Erreurs renvoyées</h3>
+### Erreurs renvoyées
 
-<dl>
- <dt>{{jsxref("RangeError")}}</dt>
- <dd>Renvoyée si <code>positionOctet</code> est tel que l'enregistrement sera fait en dehors de la vue.</dd>
-</dl>
+- {{jsxref("RangeError")}}
+  - : Renvoyée si `positionOctet` est tel que l'enregistrement sera fait en dehors de la vue.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utilisation_de_la_méthode_setUint8">Utilisation de la méthode <code>setUint8</code></h3>
+### Utilisation de la méthode `setUint8`
 
-<pre class="brush:js">var buffer = new ArrayBuffer(8);
+```js
+var buffer = new ArrayBuffer(8);
 var dataview = new DataView(buffer);
 dataview.setUint8(1, 3);
 dataview.getUint8(1); // 3
-</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('Typed Array')}}</td>
-   <td>{{Spec2('Typed Array')}}</td>
-   <td>Remplacée dans ECMAScript 2015.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES2015', '#sec-dataview.prototype.setuint8', 'DataView.prototype.setUint8')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale au sein d'un standard ECMA.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-dataview.prototype.setuint8', 'DataView.prototype.setUint8')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.DataView.setUint8")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("DataView")}}</li>
- <li>{{jsxref("ArrayBuffer")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                            | État                             | Commentaires                                    |
+| ------------------------------------------------------------------------------------------------------------------------ | -------------------------------- | ----------------------------------------------- |
+| {{SpecName('Typed Array')}}                                                                                     | {{Spec2('Typed Array')}} | Remplacée dans ECMAScript 2015.                 |
+| {{SpecName('ES2015', '#sec-dataview.prototype.setuint8', 'DataView.prototype.setUint8')}} | {{Spec2('ES2015')}}         | Définition initiale au sein d'un standard ECMA. |
+| {{SpecName('ESDraft', '#sec-dataview.prototype.setuint8', 'DataView.prototype.setUint8')}} | {{Spec2('ESDraft')}}     |                                                 |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.DataView.setUint8")}}
+
+## Voir aussi
+
+- {{jsxref("DataView")}}
+- {{jsxref("ArrayBuffer")}}
diff --git a/files/fr/web/javascript/reference/global_objects/date/@@toprimitive/index.md b/files/fr/web/javascript/reference/global_objects/date/@@toprimitive/index.md
index ee85093529..574dd32262 100644
--- a/files/fr/web/javascript/reference/global_objects/date/@@toprimitive/index.md
+++ b/files/fr/web/javascript/reference/global_objects/date/@@toprimitive/index.md
@@ -10,57 +10,39 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Date/@@toPrimitive
 original_slug: Web/JavaScript/Reference/Objets_globaux/Date/@@toPrimitive
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>[@@toPrimitive]()</strong></code> permet de convertir un objet <code>Date</code> en une valeur primitive.</p>
+La méthode **`[@@toPrimitive]()`** permet de convertir un objet `Date` en une valeur primitive.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>Date()[Symbol.toPrimitive](hint);
-</var></pre>
+    Date()[Symbol.toPrimitive](hint);
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>La valeur primitive de l'objet {{jsxref("Date")}}. Selon la valeur de l'argument, la méthode peut renvoyer une chaîne de caractères ou un nombre.</p>
+La valeur primitive de l'objet {{jsxref("Date")}}. Selon la valeur de l'argument, la méthode peut renvoyer une chaîne de caractères ou un nombre.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La méthode <code>[@@toPrimitive]()</code> de {{jsxref("Date")}} renvoie une valeur primitive qui est un nombre ou une chaîne de caractère.</p>
+La méthode `[@@toPrimitive]()` de {{jsxref("Date")}} renvoie une valeur primitive qui est un nombre ou une chaîne de caractère.
 
-<p>Si le paramètre <code>hint</code> vaut <code>"string"</code> ou <code>"default"</code>, <code>[@@toPrimitive]()</code> tentera d'appeler la méthode {{jsxref("Object.prototype.toString()", "toString")}}, si la propriété <code>toString()</code> n'existe pas, elle tentera alors d'appeler la méthode {{jsxref("Object.prototype.valueOf()", "valueOf")}}, si cette dernière n'existe pas non plus, <code>[@@toPrimitive]()</code> lèvera une exception {{jsxref("TypeError")}}.</p>
+Si le paramètre `hint` vaut `"string"` ou `"default"`, `[@@toPrimitive]()` tentera d'appeler la méthode {{jsxref("Object.prototype.toString()", "toString")}}, si la propriété `toString()` n'existe pas, elle tentera alors d'appeler la méthode {{jsxref("Object.prototype.valueOf()", "valueOf")}}, si cette dernière n'existe pas non plus, `[@@toPrimitive]()` lèvera une exception {{jsxref("TypeError")}}.
 
-<p>Si le paramètre <code>hint</code> vaut <code>"number"</code>, <code>[@@toPrimitive]()</code> tentera d'abord un appel à <code>valueOf()</code> puis ensuite un appel à <code>toString()</code>.</p>
+Si le paramètre `hint` vaut `"number"`, `[@@toPrimitive]()` tentera d'abord un appel à `valueOf()` puis ensuite un appel à `toString()`.
 
-<p>Le moteur JavaScript appelle la méthode <code>[@@toPrimitive]()</code> afin de convertir un objet en une valeur primitive. Il est rarement nécessaire d'appeler <code>[@@toPrimitive]()</code> explicitement dans son propre code, le moteur JavaScript l'utilisera automatiquement lorsqu'il détectera un objet là où une valeur primitive est attendue.</p>
+Le moteur JavaScript appelle la méthode `[@@toPrimitive]()` afin de convertir un objet en une valeur primitive. Il est rarement nécessaire d'appeler `[@@toPrimitive]()` explicitement dans son propre code, le moteur JavaScript l'utilisera automatiquement lorsqu'il détectera un objet là où une valeur primitive est attendue.
 
-<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-date.prototype-@@toprimitive', 'Date.prototype.@@toPrimitive')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-date.prototype-@@toprimitive', 'Date.prototype.@@toPrimitive')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
+| Spécification                                                                                                                | État                         | Commentaires         |
+| ---------------------------------------------------------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ES6', '#sec-date.prototype-@@toprimitive', 'Date.prototype.@@toPrimitive')}}         | {{Spec2('ES6')}}         | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-date.prototype-@@toprimitive', 'Date.prototype.@@toPrimitive')}} | {{Spec2('ESDraft')}} |                      |
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.Date.@@toPrimitive")}}</p>
+{{Compat("javascript.builtins.Date.@@toPrimitive")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("Symbol.toPrimitive")}}</li>
-</ul>
+- {{jsxref("Symbol.toPrimitive")}}
diff --git a/files/fr/web/javascript/reference/global_objects/date/getdate/index.md b/files/fr/web/javascript/reference/global_objects/date/getdate/index.md
index 7c87be827c..934bca97de 100644
--- a/files/fr/web/javascript/reference/global_objects/date/getdate/index.md
+++ b/files/fr/web/javascript/reference/global_objects/date/getdate/index.md
@@ -10,76 +10,52 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Date/getDate
 original_slug: Web/JavaScript/Reference/Objets_globaux/Date/getDate
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>getDate()</strong></code> retourne le jour du mois pour la date spécifiée d'après l'heure locale.</p>
+La méthode **`getDate()`** retourne le jour du mois pour la date spécifiée d'après l'heure locale.
 
-<div>{{EmbedInteractiveExample("pages/js/date-getdate.html")}}</div>
+{{EmbedInteractiveExample("pages/js/date-getdate.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">dateObj.getDate()</pre>
+    dateObj.getDate()
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<p>Aucun.</p>
+Aucun.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un entier entre 1 et 31 correspondant au jour du mois de la date indiquée selon l'heure locale.</p>
+Un entier entre 1 et 31 correspondant au jour du mois de la date indiquée selon l'heure locale.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_getDate()">Utiliser <code>getDate()</code></h3>
+### Utiliser `getDate()`
 
-<p>La seconde instruction ci-dessous affecte la valeur 25 à la variable <code>jour</code>, d'après la valeur de l'objet {{jsxref("Date")}} <code>Noel95</code>.</p>
+La seconde instruction ci-dessous affecte la valeur 25 à la variable `jour`, d'après la valeur de l'objet {{jsxref("Date")}} `Noel95`.
 
-<pre class="brush: js">var Noel95 = new Date("December 25, 1995 23:15:00");
+```js
+var Noel95 = new Date("December 25, 1995 23:15:00");
 var jour = Noel95.getDate();
 
 console.log(jour); // 25
-</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-date.prototype.getdate', 'Date.prototype.getDate')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-date.prototype.getdate', 'Date.prototype.getDate')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.9.5.14', 'Date.prototype.getDate')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES1')}}</td>
-   <td>{{Spec2('ES1')}}</td>
-   <td>Définition initiale. Implémentée avec JavaScript 1.1.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Date.getDate")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Date.prototype.getUTCDate()")}}</li>
- <li>{{jsxref("Date.prototype.getUTCDay()")}}</li>
- <li>{{jsxref("Date.prototype.setDate()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                | État                         | Commentaires                                          |
+| ------------------------------------------------------------------------------------------------------------ | ---------------------------- | ----------------------------------------------------- |
+| {{SpecName('ESDraft', '#sec-date.prototype.getdate', 'Date.prototype.getDate')}} | {{Spec2('ESDraft')}} |                                                       |
+| {{SpecName('ES6', '#sec-date.prototype.getdate', 'Date.prototype.getDate')}}         | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ES5.1', '#sec-15.9.5.14', 'Date.prototype.getDate')}}                     | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES1')}}                                                                                     | {{Spec2('ES1')}}         | Définition initiale. Implémentée avec JavaScript 1.1. |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Date.getDate")}}
+
+## Voir aussi
+
+- {{jsxref("Date.prototype.getUTCDate()")}}
+- {{jsxref("Date.prototype.getUTCDay()")}}
+- {{jsxref("Date.prototype.setDate()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/date/getday/index.md b/files/fr/web/javascript/reference/global_objects/date/getday/index.md
index 0c4c3d23be..343fc41fcc 100644
--- a/files/fr/web/javascript/reference/global_objects/date/getday/index.md
+++ b/files/fr/web/javascript/reference/global_objects/date/getday/index.md
@@ -10,83 +10,58 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Date/getDay
 original_slug: Web/JavaScript/Reference/Objets_globaux/Date/getDay
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>getDay()</code></strong> renvoie le jour de la semaine pour la date spécifiée selon l'heure locale (0 correspondant à dimanche). Pour obtenir le jour du mois, on utilisera {{jsxref("Date.prototype.getDate()")}}.</p>
+La méthode **`getDay()`** renvoie le jour de la semaine pour la date spécifiée selon l'heure locale (0 correspondant à dimanche). Pour obtenir le jour du mois, on utilisera {{jsxref("Date.prototype.getDate()")}}.
 
-<div>{{EmbedInteractiveExample("pages/js/date-getday.html")}}</div>
+{{EmbedInteractiveExample("pages/js/date-getday.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>dateObj</var>.getDay()</pre>
+    dateObj.getDay()
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un entier correspondant au jour de la semaine (0 correspondant à dimanche, 1 à lundi, 2 à mardi et ainsi de suite) de la date indiquée selon l'heure locale.</p>
+Un entier correspondant au jour de la semaine (0 correspondant à dimanche, 1 à lundi, 2 à mardi et ainsi de suite) de la date indiquée selon l'heure locale.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_getDay()">Utiliser <code>getDay()</code></h3>
+### Utiliser `getDay()`
 
-<p>La seconde instruction ci-dessous assigne la valeur 1 à <code>jourSemaine</code>, selon la valeur de l'objet <code>Date</code> <code>noel95</code>. Le 25 décembre 1995 est un lundi.</p>
+La seconde instruction ci-dessous assigne la valeur 1 à `jourSemaine`, selon la valeur de l'objet `Date` `noel95`. Le 25 décembre 1995 est un lundi.
 
-<pre class="brush: js">var noel95 = new Date("December 25, 1995 23:15:00");
+```js
+var noel95 = new Date("December 25, 1995 23:15:00");
 var jourSemaine = noel95.getDay();
 
 console.log(jourSemaine); //1
-</pre>
-
-<div class="blockIndicator note">
-<p><strong>Note :</strong> Si besoin, on pourra obtenir le nom complet du jour (<code>"lundi"</code> par exemple) en utilisant la méthode {{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}} avec un paramètre <code>options</code>. Ce faisant, il est plus simple d'internationaliser un site ou une application :</p>
-
-<pre class="brush: js">var options = { weekday: 'long'};
-console.log(new Intl.DateTimeFormat('en-US', options).format(Xmas95));
-// Monday
-console.log(new Intl.DateTimeFormat('de-DE', options).format(Xmas95));
-// Montag
-</pre>
-</div>
-
-<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-date.prototype.getday', 'Date.prototype.getDay')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-date.prototype.getday', 'Date.prototype.getDay')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.9.5.16', 'Date.prototype.getDay')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES1')}}</td>
-   <td>{{Spec2('ES1')}}</td>
-   <td>Définition initiale. Implémentée avec JavaScript 1.0.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Date.getDay")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Date.prototype.getUTCDate()")}}</li>
- <li>{{jsxref("Date.prototype.getUTCDay()")}}</li>
- <li>{{jsxref("Date.prototype.setDate()")}}</li>
-</ul>
+```
+
+> **Note :** Si besoin, on pourra obtenir le nom complet du jour (`"lundi"` par exemple) en utilisant la méthode {{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}} avec un paramètre `options`. Ce faisant, il est plus simple d'internationaliser un site ou une application :
+>
+> ```js
+> var options = { weekday: 'long'};
+> console.log(new Intl.DateTimeFormat('en-US', options).format(Xmas95));
+> // Monday
+> console.log(new Intl.DateTimeFormat('de-DE', options).format(Xmas95));
+> // Montag
+> ```
+
+## Spécifications
+
+| Spécification                                                                                            | État                         | Commentaires                                          |
+| -------------------------------------------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- |
+| {{SpecName('ESDraft', '#sec-date.prototype.getday', 'Date.prototype.getDay')}} | {{Spec2('ESDraft')}} |                                                       |
+| {{SpecName('ES6', '#sec-date.prototype.getday', 'Date.prototype.getDay')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ES5.1', '#sec-15.9.5.16', 'Date.prototype.getDay')}}                     | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES1')}}                                                                                 | {{Spec2('ES1')}}         | Définition initiale. Implémentée avec JavaScript 1.0. |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Date.getDay")}}
+
+## Voir aussi
+
+- {{jsxref("Date.prototype.getUTCDate()")}}
+- {{jsxref("Date.prototype.getUTCDay()")}}
+- {{jsxref("Date.prototype.setDate()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/date/getfullyear/index.md b/files/fr/web/javascript/reference/global_objects/date/getfullyear/index.md
index 16d862b7e3..d3cf612ee7 100644
--- a/files/fr/web/javascript/reference/global_objects/date/getfullyear/index.md
+++ b/files/fr/web/javascript/reference/global_objects/date/getfullyear/index.md
@@ -10,72 +10,48 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Date/getFullYear
 original_slug: Web/JavaScript/Reference/Objets_globaux/Date/getFullYear
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>getFullYear()</strong></code> renvoie l'année de la date renseignée d'après l'heure locale.</p>
+La méthode **`getFullYear()`** renvoie l'année de la date renseignée d'après l'heure locale.
 
-<p>Cette méthode doit être utilisée à la place de {{jsxref("Date.prototype.getYear()", "getYear()")}}.</p>
+Cette méthode doit être utilisée à la place de {{jsxref("Date.prototype.getYear()", "getYear()")}}.
 
-<div>{{EmbedInteractiveExample("pages/js/date-getfullyear.html")}}</div>
+{{EmbedInteractiveExample("pages/js/date-getfullyear.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">dateObj.getFullYear()</pre>
+    dateObj.getFullYear()
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un entier correspondant à l'année de la date selon l'heure locale.</p>
+Un entier correspondant à l'année de la date selon l'heure locale.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_getFullYear()">Utiliser <code>getFullYear()</code></h3>
+### Utiliser `getFullYear()`
 
-<p>L'exemple qui suit assigne la valeur à quatre chiffres de l'année courante à la variable <code>année</code>.</p>
+L'exemple qui suit assigne la valeur à quatre chiffres de l'année courante à la variable `année`.
 
-<pre class="brush: js">var aujd = new Date();
+```js
+var aujd = new Date();
 var année = aujd.getFullYear();
-</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.3.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.9.5.10', 'Date.prototype.getFullYear')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-date.prototype.getfullyear', 'Date.prototype.getFullYear')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-date.prototype.getfullyear', 'Date.prototype.getFullYear')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Date.getFullYear")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Date.prototype.getUTCFullYear()")}}</li>
- <li>{{jsxref("Date.prototype.setFullYear()")}}</li>
- <li>{{jsxref("Date.prototype.getYear()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                        | État                         | Commentaires                                          |
+| -------------------------------------------------------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- |
+| {{SpecName('ES1')}}                                                                                             | {{Spec2('ES1')}}         | Définition initiale. Implémentée avec JavaScript 1.3. |
+| {{SpecName('ES5.1', '#sec-15.9.5.10', 'Date.prototype.getFullYear')}}                         | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-date.prototype.getfullyear', 'Date.prototype.getFullYear')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-date.prototype.getfullyear', 'Date.prototype.getFullYear')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Date.getFullYear")}}
+
+## Voir aussi
+
+- {{jsxref("Date.prototype.getUTCFullYear()")}}
+- {{jsxref("Date.prototype.setFullYear()")}}
+- {{jsxref("Date.prototype.getYear()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/date/gethours/index.md b/files/fr/web/javascript/reference/global_objects/date/gethours/index.md
index b0a5765a38..502652786f 100644
--- a/files/fr/web/javascript/reference/global_objects/date/gethours/index.md
+++ b/files/fr/web/javascript/reference/global_objects/date/gethours/index.md
@@ -10,71 +10,47 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Date/getHours
 original_slug: Web/JavaScript/Reference/Objets_globaux/Date/getHours
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>getHours()</strong></code> renvoie l'heure pour la date renseignée, d'après l'heure locale.</p>
+La méthode **`getHours()`** renvoie l'heure pour la date renseignée, d'après l'heure locale.
 
-<div>{{EmbedInteractiveExample("pages/js/date-gethours.html")}}</div>
+{{EmbedInteractiveExample("pages/js/date-gethours.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>dateObj</var>.getHours()</pre>
+    dateObj.getHours()
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un entier, compris entre 0 et 23 qui indique l'heure de la date indiquée selon l'heure locale.</p>
+Un entier, compris entre 0 et 23 qui indique l'heure de la date indiquée selon l'heure locale.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_getHours()">Utiliser <code>getHours()</code></h3>
+### Utiliser `getHours()`
 
-<p>La seconde instruction ci-dessous assigne la valeur 23 à la variable <code>heure</code>, selon la valeur de l'objet {{jsxref("Date")}} <code>noel95</code>.</p>
+La seconde instruction ci-dessous assigne la valeur 23 à la variable `heure`, selon la valeur de l'objet {{jsxref("Date")}} `noel95`.
 
-<pre class="brush: js">var noel95 = new Date("December 25, 1995 23:15:00");
+```js
+var noel95 = new Date("December 25, 1995 23:15:00");
 var heure = noel95.getHours();
 
 console.log(heure); //23
-</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.0.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.9.5.18', 'Date.prototype.getHours')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-date.prototype.gethours', 'Date.prototype.getHours')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-date.prototype.gethours', 'Date.prototype.getHours')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Date.getHours")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Date.prototype.getUTCHours()")}}</li>
- <li>{{jsxref("Date.prototype.setHours()")}}</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.9.5.18', 'Date.prototype.getHours')}}                     | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-date.prototype.gethours', 'Date.prototype.getHours')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-date.prototype.gethours', 'Date.prototype.getHours')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Date.getHours")}}
+
+## Voir aussi
+
+- {{jsxref("Date.prototype.getUTCHours()")}}
+- {{jsxref("Date.prototype.setHours()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/date/getmilliseconds/index.md b/files/fr/web/javascript/reference/global_objects/date/getmilliseconds/index.md
index d2befc401d..5476fccef0 100644
--- a/files/fr/web/javascript/reference/global_objects/date/getmilliseconds/index.md
+++ b/files/fr/web/javascript/reference/global_objects/date/getmilliseconds/index.md
@@ -10,69 +10,45 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Date/getMilliseconds
 original_slug: Web/JavaScript/Reference/Objets_globaux/Date/getMilliseconds
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>getMilliseconds()</strong></code> renvoie les millièmes de secondes de la date renseignée d'après l'heure locale.</p>
+La méthode **`getMilliseconds()`** renvoie les millièmes de secondes de la date renseignée d'après l'heure locale.
 
-<div>{{EmbedInteractiveExample("pages/js/date-getmilliseconds.html")}}</div>
+{{EmbedInteractiveExample("pages/js/date-getmilliseconds.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>dateObj</var>.getMilliseconds()</pre>
+    dateObj.getMilliseconds()
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un nombre entre 0 et 999 indiquant le nombre de millisecondes pour la date indiquée, selon l'heure locale.</p>
+Un nombre entre 0 et 999 indiquant le nombre de millisecondes pour la date indiquée, selon l'heure locale.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_getMilliseconds()">Utiliser <code>getMilliseconds()</code></h3>
+### Utiliser `getMilliseconds()`
 
-<p>L'exemple suivant assigne la partie des millièmes de secondes de l'heure courante à la variable <code>ms</code>.</p>
+L'exemple suivant assigne la partie des millièmes de secondes de l'heure courante à la variable `ms`.
 
-<pre class="brush: js">var aujd = new Date();
+```js
+var aujd = new Date();
 var ms = aujd.getMilliseconds();
-</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.3.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.9.5.24', 'Date.prototype.getMilliseconds')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-date.prototype.getmilliseconds', 'Date.prototype.getMilliseconds')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-date.prototype.getmilliseconds', 'Date.prototype.getMilliseconds')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Date.getMilliseconds")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Date.prototype.getUTCMilliseconds()")}}</li>
- <li>{{jsxref("Date.prototype.setMilliseconds()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                                    | État                         | Commentaires                                          |
+| -------------------------------------------------------------------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- |
+| {{SpecName('ES1')}}                                                                                                         | {{Spec2('ES1')}}         | Définition initiale. Implémentée avec JavaScript 1.3. |
+| {{SpecName('ES5.1', '#sec-15.9.5.24', 'Date.prototype.getMilliseconds')}}                                 | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-date.prototype.getmilliseconds', 'Date.prototype.getMilliseconds')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-date.prototype.getmilliseconds', 'Date.prototype.getMilliseconds')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Date.getMilliseconds")}}
+
+## Voir aussi
+
+- {{jsxref("Date.prototype.getUTCMilliseconds()")}}
+- {{jsxref("Date.prototype.setMilliseconds()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/date/getminutes/index.md b/files/fr/web/javascript/reference/global_objects/date/getminutes/index.md
index 5a866eef11..f7a9657f90 100644
--- a/files/fr/web/javascript/reference/global_objects/date/getminutes/index.md
+++ b/files/fr/web/javascript/reference/global_objects/date/getminutes/index.md
@@ -10,71 +10,47 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Date/getMinutes
 original_slug: Web/JavaScript/Reference/Objets_globaux/Date/getMinutes
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>getMinutes()</code></strong> renvoie les minutes pour la date renseignée d'après l'heure locale.</p>
+La méthode **`getMinutes()`** renvoie les minutes pour la date renseignée d'après l'heure locale.
 
-<div>{{EmbedInteractiveExample("pages/js/date-getminutes.html")}}</div>
+{{EmbedInteractiveExample("pages/js/date-getminutes.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>dateObj</var>.getMinutes()</pre>
+    dateObj.getMinutes()
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>La valeur renvoyée par <code>getMinutes</code> est un entier entre 0 et 59 représentant le nombre de minutes pour la date indiquée, selon l'heure locale.</p>
+La valeur renvoyée par `getMinutes` est un entier entre 0 et 59 représentant le nombre de minutes pour la date indiquée, selon l'heure locale.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_getMinutes()">Utiliser <code>getMinutes()</code></h3>
+### Utiliser `getMinutes()`
 
-<p>La seconde instruction ci-dessous assigne la valeur 15 à la variable <code>minutes</code>, selon la valeur de l'objet {{jsxref("Date")}} <code>noel95</code>.</p>
+La seconde instruction ci-dessous assigne la valeur 15 à la variable `minutes`, selon la valeur de l'objet {{jsxref("Date")}} `noel95`.
 
-<pre class="brush: js">var noel95 = new Date("December 25, 1995 23:15:00");
+```js
+var noel95 = new Date("December 25, 1995 23:15:00");
 var minutes = noel95.getMinutes();
 
 console.log(minutes); //15
-</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.0.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.9.5.20', 'Date.prototype.getMinutes')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-date.prototype.getminutes', 'Date.prototype.getMinutes')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-date.prototype.getminutes', 'Date.prototype.getMinutes')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Date.getMinutes")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Date.prototype.getUTCMinutes()")}}</li>
- <li>{{jsxref("Date.prototype.setMinutes()")}}</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.9.5.20', 'Date.prototype.getMinutes')}}                         | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-date.prototype.getminutes', 'Date.prototype.getMinutes')}}         | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-date.prototype.getminutes', 'Date.prototype.getMinutes')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Date.getMinutes")}}
+
+## Voir aussi
+
+- {{jsxref("Date.prototype.getUTCMinutes()")}}
+- {{jsxref("Date.prototype.setMinutes()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/date/getmonth/index.md b/files/fr/web/javascript/reference/global_objects/date/getmonth/index.md
index e51d1ccb64..2f3cdd1c3f 100644
--- a/files/fr/web/javascript/reference/global_objects/date/getmonth/index.md
+++ b/files/fr/web/javascript/reference/global_objects/date/getmonth/index.md
@@ -10,82 +10,57 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Date/getMonth
 original_slug: Web/JavaScript/Reference/Objets_globaux/Date/getMonth
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>getMonth()</strong></code> retourne le mois de la date renseignée d'après l'heure locale. La numérotation démarre à 0 (c'est-à-dire que 0 correspond au premier mois de l'année).</p>
+La méthode **`getMonth()`** retourne le mois de la date renseignée d'après l'heure locale. La numérotation démarre à 0 (c'est-à-dire que 0 correspond au premier mois de l'année).
 
-<div>{{EmbedInteractiveExample("pages/js/date-getmonth.html")}}</div>
+{{EmbedInteractiveExample("pages/js/date-getmonth.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><em>dateObj.g</em>etMonth()</pre>
+    dateObj.getMonth()
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un entier entre 0 et 11 selon le mois de la date indiquée et d'après l'heure locale (0 correspond à janvier, 1 à février, et ainsi de suite).</p>
+Un entier entre 0 et 11 selon le mois de la date indiquée et d'après l'heure locale (0 correspond à janvier, 1 à février, et ainsi de suite).
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_getMonth()">Utiliser <code>getMonth()</code></h3>
+### Utiliser `getMonth()`
 
-<p>La seconde instruction ci-dessous assigne la valeur 11 à la variable <code>mois</code>, d'après la valeur de l'objet {{jsxref("Date")}} <code>noel95</code>.</p>
+La seconde instruction ci-dessous assigne la valeur 11 à la variable `mois`, d'après la valeur de l'objet {{jsxref("Date")}} `noel95`.
 
-<pre class="brush: js">var noel95 = new Date("December 25, 1995 23:15:00");
+```js
+var noel95 = new Date("December 25, 1995 23:15:00");
 var mois = noel95.getMonth();
 
 console.log(mois); //11
-</pre>
-
-<div class="blockIndicator note">
-<p><strong>Note :</strong> Si besoin, on pourra récupérer le nom complet du mois (<code>"Janvier"</code> par exemple) en utilisant <code><a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/DateTimeFormat">Intl.DateTimeFormat()</a></code> avec un paramètre <code>options</code>. En utilisant cette méthode, il est plus simple d'internationaliser le site ou l'application :</p>
-
-<pre class="brush: js">var options = { month: 'long'};
-console.log(new Intl.DateTimeFormat('en-US', options).format(noel95));
-// December
-console.log(new Intl.DateTimeFormat('de-DE', options).format(noel95));
-// Dezember
-</pre>
-</div>
-
-<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.0.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.9.5.12', 'Date.prototype.getMonth')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-date.prototype.getmonth', 'Date.prototype.getMonth')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-date.prototype.getmonth', 'Date.prototype.getMonth')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Date.getMonth")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Date.prototype.getUTCMonth()")}}</li>
- <li>{{jsxref("Date.prototype.setMonth()")}}</li>
-</ul>
+```
+
+> **Note :** Si besoin, on pourra récupérer le nom complet du mois (`"Janvier"` par exemple) en utilisant [`Intl.DateTimeFormat()`](/fr/docs/Web/JavaScript/Reference/Objets_globaux/DateTimeFormat) avec un paramètre `options`. En utilisant cette méthode, il est plus simple d'internationaliser le site ou l'application :
+>
+> ```js
+> var options = { month: 'long'};
+> console.log(new Intl.DateTimeFormat('en-US', options).format(noel95));
+> // December
+> console.log(new Intl.DateTimeFormat('de-DE', options).format(noel95));
+> // Dezember
+> ```
+
+## 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.9.5.12', 'Date.prototype.getMonth')}}                     | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-date.prototype.getmonth', 'Date.prototype.getMonth')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-date.prototype.getmonth', 'Date.prototype.getMonth')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Date.getMonth")}}
+
+## Voir aussi
+
+- {{jsxref("Date.prototype.getUTCMonth()")}}
+- {{jsxref("Date.prototype.setMonth()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/date/getseconds/index.md b/files/fr/web/javascript/reference/global_objects/date/getseconds/index.md
index 32c91e493c..ddbd49d19a 100644
--- a/files/fr/web/javascript/reference/global_objects/date/getseconds/index.md
+++ b/files/fr/web/javascript/reference/global_objects/date/getseconds/index.md
@@ -10,71 +10,47 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Date/getSeconds
 original_slug: Web/JavaScript/Reference/Objets_globaux/Date/getSeconds
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>getSeconds()</code></strong> renvoie les secondes pour la date renseignée d'après l'heure locale.</p>
+La méthode **`getSeconds()`** renvoie les secondes pour la date renseignée d'après l'heure locale.
 
-<div>{{EmbedInteractiveExample("pages/js/date-getseconds.html")}}</div>
+{{EmbedInteractiveExample("pages/js/date-getseconds.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">dateObj.getSeconds()</pre>
+    dateObj.getSeconds()
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>La valeur renvoyée par <code>getSeconds()</code> est un entier entre 0 et 59 correspondant au nombre de secondes pour la date donnée selon l'heure locale.</p>
+La valeur renvoyée par `getSeconds()` est un entier entre 0 et 59 correspondant au nombre de secondes pour la date donnée selon l'heure locale.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_getSeconds()">Utiliser <code>getSeconds()</code></h3>
+### Utiliser `getSeconds()`
 
-<p>La seconde instruction ci-dessous assigne la valeur 30 à la variable <code>secondes</code>, selon la valeur de l'objet {{jsxref("Date")}} <code>noel95</code>.</p>
+La seconde instruction ci-dessous assigne la valeur 30 à la variable `secondes`, selon la valeur de l'objet {{jsxref("Date")}} `noel95`.
 
-<pre class="brush: js">var noel95 = new Date("December 25, 1995 23:15:30");
+```js
+var noel95 = new Date("December 25, 1995 23:15:30");
 var secondes = noel95.getSeconds();
 
 console.log(secondes); //30
-</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.0.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.9.5.22', 'Date.prototype.getSeconds')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-date.prototype.getseconds', 'Date.prototype.getSeconds')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-date.prototype.getseconds', 'Date.prototype.getSeconds')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Date.getSeconds")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Date.prototype.getUTCSeconds()")}}</li>
- <li>{{jsxref("Date.prototype.setSeconds()")}}</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.9.5.22', 'Date.prototype.getSeconds')}}                         | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-date.prototype.getseconds', 'Date.prototype.getSeconds')}}         | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-date.prototype.getseconds', 'Date.prototype.getSeconds')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Date.getSeconds")}}
+
+## Voir aussi
+
+- {{jsxref("Date.prototype.getUTCSeconds()")}}
+- {{jsxref("Date.prototype.setSeconds()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/date/gettime/index.md b/files/fr/web/javascript/reference/global_objects/date/gettime/index.md
index 86ceaedccd..9c2ac28bca 100644
--- a/files/fr/web/javascript/reference/global_objects/date/gettime/index.md
+++ b/files/fr/web/javascript/reference/global_objects/date/gettime/index.md
@@ -10,53 +10,56 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Date/getTime
 original_slug: Web/JavaScript/Reference/Objets_globaux/Date/getTime
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>getTime()</code></strong> renvoie la valeur numérique correspondant au temps pour la date renseignée, d'après le temps universel (c'est-à-dire relative à UTC, une mesure donnée par <code>getTime()</code> sera indépendante du fuseau horaire sur lequel on se trouve). Cette valeur numérique est le nombre de millisecondes écoulées depuis le premier janvier 1970 à minuit UTC.</p>
+La méthode **`getTime()`** renvoie la valeur numérique correspondant au temps pour la date renseignée, d'après le temps universel (c'est-à-dire relative à UTC, une mesure donnée par `getTime()` sera indépendante du fuseau horaire sur lequel on se trouve). Cette valeur numérique est le nombre de millisecondes écoulées depuis le premier janvier 1970 à minuit UTC.
 
-<p>Vous pouvez utiliser cette méthode pour vous affecter une date et un temps à une autre instance de <code>Date</code>. Cette méthode est fonctionnellement équivalente à la méthode {{jsxref("Date.valueof", "valueOf()")}}.</p>
+Vous pouvez utiliser cette méthode pour vous affecter une date et un temps à une autre instance de `Date`. Cette méthode est fonctionnellement équivalente à la méthode {{jsxref("Date.valueof", "valueOf()")}}.
 
-<div>{{EmbedInteractiveExample("pages/js/date-gettime.html")}}</div>
+{{EmbedInteractiveExample("pages/js/date-gettime.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">dateObj.getTime()</pre>
+    dateObj.getTime()
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>La valeur renvoyée par la méthode <code>getTime()</code> est le nombre de millièmes de secondes entre le 1 janvier 1970 à 00:00:00 UTC et la date indiquée.</p>
+La valeur renvoyée par la méthode `getTime()` est le nombre de millièmes de secondes entre le 1 janvier 1970 à 00:00:00 UTC et la date indiquée.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_getTime()">Utiliser <code>getTime()</code></h3>
+### Utiliser `getTime()`
 
-<p>L'exemple qui suit assigne la valeur de <code>anniversaire</code> à <code>copie</code> :</p>
+L'exemple qui suit assigne la valeur de `anniversaire` à `copie` :
 
-<pre class="brush: js">var anniversaire = new Date(1994 , 11, 10); // 10 décembre 1994
+```js
+var anniversaire = new Date(1994 , 11, 10); // 10 décembre 1994
 var copie = new Date();
 copie.setTime(anniversaire.getTime());
-</pre>
+```
 
-<h3 id="Mesurer_un_temps_d'exécution">Mesurer un temps d'exécution</h3>
+### Mesurer un temps d'exécution
 
-<p>Effectuer une soustration entre deux appels à <code>getTime()</code> donne la durée écoulée entre ces appels. On peut donc utiliser cette méthode afin de connaître la durée d'exécution de certaines opérations (voir également la méthode {{jsxref("Date.now()")}} qui peut permettre d'éviter d'instancier des objets intermédiaires).</p>
+Effectuer une soustration entre deux appels à `getTime()` donne la durée écoulée entre ces appels. On peut donc utiliser cette méthode afin de connaître la durée d'exécution de certaines opérations (voir également la méthode {{jsxref("Date.now()")}} qui peut permettre d'éviter d'instancier des objets intermédiaires).
 
-<pre class="brush: js">var fin, début;
+```js
+var fin, début;
 
 début = new Date();
-for (var i = 0; i &lt; 1000; i++) {
+for (var i = 0; i < 1000; i++) {
   Math.sqrt(i);
 }
 fin = new Date();
 
 console.log('Durée de cette opération : ' + (fin.getTime() - début.getTime()) + ' msec');
-</pre>
+```
 
-<h2 id="Précision_temporelle_réduite">Précision temporelle réduite</h2>
+## Précision temporelle réduite
 
-<p>Afin de protéger contre les attaques de minutage et d'identification, la précision de <code>new Date().getTime()</code> peut être arrondie en fonction des paramètres du navigateur. Pour Firefox, la préférence <code>privacy.reduceTimerPrecision</code> est activée par défaut et vaut, par défaut 20µs pour Firefox 59 et 2ms pour Firefox 60.</p>
+Afin de protéger contre les attaques de minutage et d'identification, la précision de `new Date().getTime()` peut être arrondie en fonction des paramètres du navigateur. Pour Firefox, la préférence `privacy.reduceTimerPrecision` est activée par défaut et vaut, par défaut 20µs pour Firefox 59 et 2ms pour Firefox 60.
 
-<pre class="brush: js">// Précision temporelle réduite (2ms) pour Firefox 60
+```js
+// Précision temporelle réduite (2ms) pour Firefox 60
 new Date().getTime();
 // 1519211809934
 // 1519211810362
@@ -70,50 +73,25 @@ new Date().getTime();
 // 1519129858900
 // 1519129864400
 // ...
-</pre>
-
-<p>Pour Firefox, il est également possible d'activer <code>privacy.resistFingerprinting</code> auquel cas la précision sera 100ms ou la valeur de <code>privacy.resistFingerprinting.reduceTimerPrecision.microseconds</code> selon laquelle est plus grande.</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.0.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.9.5.9', 'Date.prototype.getTime')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-date.prototype.gettime', 'Date.prototype.getTime')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-date.prototype.gettime', 'Date.prototype.getTime')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Date.getTime")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Date.prototype.setTime()")}}</li>
- <li>{{jsxref("Date.prototype.valueOf()")}}</li>
- <li>{{jsxref("Date.prototype.now()")}}</li>
-</ul>
+```
+
+Pour Firefox, il est également possible d'activer `privacy.resistFingerprinting` auquel cas la précision sera 100ms ou la valeur de `privacy.resistFingerprinting.reduceTimerPrecision.microseconds` selon laquelle est plus grande.
+
+## 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.9.5.9', 'Date.prototype.getTime')}}                         | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-date.prototype.gettime', 'Date.prototype.getTime')}}         | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-date.prototype.gettime', 'Date.prototype.getTime')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Date.getTime")}}
+
+## Voir aussi
+
+- {{jsxref("Date.prototype.setTime()")}}
+- {{jsxref("Date.prototype.valueOf()")}}
+- {{jsxref("Date.prototype.now()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/date/gettimezoneoffset/index.md b/files/fr/web/javascript/reference/global_objects/date/gettimezoneoffset/index.md
index a4a46512c1..a313ba77c9 100644
--- a/files/fr/web/javascript/reference/global_objects/date/gettimezoneoffset/index.md
+++ b/files/fr/web/javascript/reference/global_objects/date/gettimezoneoffset/index.md
@@ -10,27 +10,28 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Date/getTimezoneOffset
 original_slug: Web/JavaScript/Reference/Objets_globaux/Date/getTimezoneOffset
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>getTimezoneOffset()</strong></code> retourne la différence en minutes entre le fuseau horaire UTC, et celui de l'heure locale.</p>
+La méthode **`getTimezoneOffset()`** retourne la différence en minutes entre le fuseau horaire UTC, et celui de l'heure locale.
 
-<div>{{EmbedInteractiveExample("pages/js/date-gettimezoneoffset.html")}}</div>
+{{EmbedInteractiveExample("pages/js/date-gettimezoneoffset.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">dateObj.getTimezoneOffset()</pre>
+    dateObj.getTimezoneOffset()
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>La valeur retournée est la différence, exprimée en minutes, entre les fuseaux horaires UTC et celui de l'heure locale. Cette différence est positive si le fuseau horaire local est en retard par rapport à UTC, et négative s'il est en avance.</p>
+La valeur retournée est la différence, exprimée en minutes, entre les fuseaux horaires UTC et celui de l'heure locale. Cette différence est positive si le fuseau horaire local est en retard par rapport à UTC, et négative s'il est en avance.
 
-<p>Par exemple, si votre fuseau horaire est UTC+10 (Australian Eastern Standard Time, Vladivostok, Chamorro), la valeur retournée sera -600. L'heure d'été (DST pour <em>daylight saving time</em> en anglais) empêche cette valeur d'être une constante.</p>
+Par exemple, si votre fuseau horaire est UTC+10 (Australian Eastern Standard Time, Vladivostok, Chamorro), la valeur retournée sera -600. L'heure d'été (DST pour _daylight saving time_ en anglais) empêche cette valeur d'être une constante.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_getTimezoneOffset()">Utiliser <code>getTimezoneOffset()</code></h3>
+### Utiliser `getTimezoneOffset()`
 
-<pre class="brush:js">var x = new Date();
+```js
+var x = new Date();
 var differenceFuseauxEnHeures = x.getTimezoneOffset() / 60;
 // -2
 
@@ -40,40 +41,17 @@ var differenceFuseauxEnHeures = x.getTimezoneOffset() / 60;
 // avec 4 (et pas 5)
 var travail = new Date(2017, 4, 1);
 var decalage = travail.getTimezoneOffset() / 60;
-</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('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.9.5.26', 'Date.prototype.getTimezoneOffset')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-date.prototype.gettimezoneoffset', 'Date.prototype.getTimezoneOffset')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-date.prototype.gettimezoneoffset', 'Date.prototype.getTimezoneOffset')}}</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.9.5.26', 'Date.prototype.getTimezoneOffset')}}                                 | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-date.prototype.gettimezoneoffset', 'Date.prototype.getTimezoneOffset')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-date.prototype.gettimezoneoffset', 'Date.prototype.getTimezoneOffset')}} | {{Spec2('ESDraft')}} |                                                       |
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.Date.getTimezoneOffset")}}</p>
+{{Compat("javascript.builtins.Date.getTimezoneOffset")}}
diff --git a/files/fr/web/javascript/reference/global_objects/date/getutcdate/index.md b/files/fr/web/javascript/reference/global_objects/date/getutcdate/index.md
index 0d4fa90f29..5f062ea4fb 100644
--- a/files/fr/web/javascript/reference/global_objects/date/getutcdate/index.md
+++ b/files/fr/web/javascript/reference/global_objects/date/getutcdate/index.md
@@ -10,70 +10,46 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCDate
 original_slug: Web/JavaScript/Reference/Objets_globaux/Date/getUTCDate
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>getUTCDate()</code></strong> renvoie le jour du mois pour la date renseignée d'après UTC.</p>
+La méthode **`getUTCDate()`** renvoie le jour du mois pour la date renseignée d'après UTC.
 
-<div>{{EmbedInteractiveExample("pages/js/date-getutcdate.html")}}</div>
+{{EmbedInteractiveExample("pages/js/date-getutcdate.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>dateObj</var>.getUTCDate()</pre>
+    dateObj.getUTCDate()
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>La valeur renseignée par <code>getUTCDate()</code> est un entier entre 1 et 31 pour le jour du mois de la date indiquée selon le temps universel.</p>
+La valeur renseignée par `getUTCDate()` est un entier entre 1 et 31 pour le jour du mois de la date indiquée selon le temps universel.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_getUTCDate()">Utiliser <code>getUTCDate()</code></h3>
+### Utiliser `getUTCDate()`
 
-<p>L'exemple suivant assigne le jour du mois pour la date actuelle, à la variable <code>jour</code>.</p>
+L'exemple suivant assigne le jour du mois pour la date actuelle, à la variable `jour`.
 
-<pre class="brush:js">var aujourdhui = new Date();
+```js
+var aujourdhui = new Date();
 var jour = aujourdhui.getUTCDate();
-</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.3.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.9.5.15', 'Date.prototype.getUTCDate')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-date.prototype.getutcdate', 'Date.prototype.getUTCDate')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-date.prototype.getutcdate', 'Date.prototype.getUTCDate')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Date.getUTCDate")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Date.prototype.getDate()")}}</li>
- <li>{{jsxref("Date.prototype.getUTCDay()")}}</li>
- <li>{{jsxref("Date.prototype.setUTCDate()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                        | État                         | Commentaires                                          |
+| -------------------------------------------------------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- |
+| {{SpecName('ES1')}}                                                                                             | {{Spec2('ES1')}}         | Définition initiale. Implémentée avec JavaScript 1.3. |
+| {{SpecName('ES5.1', '#sec-15.9.5.15', 'Date.prototype.getUTCDate')}}                         | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-date.prototype.getutcdate', 'Date.prototype.getUTCDate')}}         | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-date.prototype.getutcdate', 'Date.prototype.getUTCDate')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Date.getUTCDate")}}
+
+## Voir aussi
+
+- {{jsxref("Date.prototype.getDate()")}}
+- {{jsxref("Date.prototype.getUTCDay()")}}
+- {{jsxref("Date.prototype.setUTCDate()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/date/getutcday/index.md b/files/fr/web/javascript/reference/global_objects/date/getutcday/index.md
index db8134b5ce..6fe7f094b9 100644
--- a/files/fr/web/javascript/reference/global_objects/date/getutcday/index.md
+++ b/files/fr/web/javascript/reference/global_objects/date/getutcday/index.md
@@ -10,70 +10,46 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCDay
 original_slug: Web/JavaScript/Reference/Objets_globaux/Date/getUTCDay
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>getUTCDay()</code></strong> renvoie le jour de la semaine pour la date renseignée d'après UTC. La numérotation commence à 0, et dimanche est considéré comme le premier jour de la semaine.</p>
+La méthode **`getUTCDay()`** renvoie le jour de la semaine pour la date renseignée d'après UTC. La numérotation commence à 0, et dimanche est considéré comme le premier jour de la semaine.
 
-<div>{{EmbedInteractiveExample("pages/js/date-getutcday.html")}}</div>
+{{EmbedInteractiveExample("pages/js/date-getutcday.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">dateObj.getUTCDay()</pre>
+    dateObj.getUTCDay()
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>La valeur renvoyée par <code>getUTCDay()</code> est un entier correspondant au jour de la semaine de la date indiquée selon le temps universel (0 pour dimanche, 1 pour lundi, 2 pour mardi, et ainsi de suite).</p>
+La valeur renvoyée par `getUTCDay()` est un entier correspondant au jour de la semaine de la date indiquée selon le temps universel (0 pour dimanche, 1 pour lundi, 2 pour mardi, et ainsi de suite).
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_getUTCDay()">Utiliser <code>getUTCDay()</code></h3>
+### Utiliser `getUTCDay()`
 
-<p>L'exemple suivant assigne le jour de la semaine de la date actuelle à la variable <code>jourSemaine</code>.</p>
+L'exemple suivant assigne le jour de la semaine de la date actuelle à la variable `jourSemaine`.
 
-<pre class="brush: js">var aujourdhui = new Date()
+```js
+var aujourdhui = new Date()
 var jourSemaine = aujourdhui.getUTCDay()
-</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.3.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.9.5.17', 'Date.prototype.getUTCDay')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-date.prototype.getutcday', 'Date.prototype.getUTCDay')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-date.prototype.getutcday', 'Date.prototype.getUTCDay')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Date.getUTCDay")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Date.prototype.getUTCDate()")}}</li>
- <li>{{jsxref("Date.prototype.getDay()")}}</li>
- <li>{{jsxref("Date.prototype.setUTCDate()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                    | État                         | Commentaires                                          |
+| ---------------------------------------------------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- |
+| {{SpecName('ES1')}}                                                                                         | {{Spec2('ES1')}}         | Définition initiale. Implémentée avec JavaScript 1.3. |
+| {{SpecName('ES5.1', '#sec-15.9.5.17', 'Date.prototype.getUTCDay')}}                         | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-date.prototype.getutcday', 'Date.prototype.getUTCDay')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-date.prototype.getutcday', 'Date.prototype.getUTCDay')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Date.getUTCDay")}}
+
+## Voir aussi
+
+- {{jsxref("Date.prototype.getUTCDate()")}}
+- {{jsxref("Date.prototype.getDay()")}}
+- {{jsxref("Date.prototype.setUTCDate()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/date/getutcfullyear/index.md b/files/fr/web/javascript/reference/global_objects/date/getutcfullyear/index.md
index c2c81cc8ab..a481accedf 100644
--- a/files/fr/web/javascript/reference/global_objects/date/getutcfullyear/index.md
+++ b/files/fr/web/javascript/reference/global_objects/date/getutcfullyear/index.md
@@ -10,68 +10,45 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCFullYear
 original_slug: Web/JavaScript/Reference/Objets_globaux/Date/getUTCFullYear
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>getUTCFullYear()</strong></code> renvoie l'année de la date renseignée, d'après UTC.</p>
+La méthode **`getUTCFullYear()`** renvoie l'année de la date renseignée, d'après UTC.
 
-<div>{{EmbedInteractiveExample("pages/js/date-getutcfullyear.html")}}</div>
+{{EmbedInteractiveExample("pages/js/date-getutcfullyear.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">dateObj.getUTCFullYear()</pre>
+    dateObj.getUTCFullYear()
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>La valeur renvoyée par <code>getUTCFullYear</code><code>()</code> est un nombre correspondant à l'année de la date indiquée selon le temps universel. Pour les dates entre les années 1000 et 9999, <code>getUTCFullYear</code><code>()</code> renvoie un nombre à quatre chiffres, par exemple 1995.</p>
+La valeur renvoyée par ` getUTCFullYear``() ` est un nombre correspondant à l'année de la date indiquée selon le temps universel. Pour les dates entre les années 1000 et 9999, ` getUTCFullYear``() ` renvoie un nombre à quatre chiffres, par exemple 1995.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_getUTCFullYear()">Utiliser <code>getUTCFullYear()</code></h3>
+### Utiliser `getUTCFullYear()`
 
-<p>L'exemple suivant assigne une valeur à 4 chiffres, l'année courante, à la variable <code>annee</code>.</p>
+L'exemple suivant assigne une valeur à 4 chiffres, l'année courante, à la variable `annee`.
 
-<pre class="brush:js">var aujourdhui = new Date();
-var annee = aujourdhui.getUTCFullYear();</pre>
+```js
+var aujourdhui = new Date();
+var annee = aujourdhui.getUTCFullYear();
+```
 
-<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.3.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.9.5.11', 'Date.prototype.getUTCFullYear')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-date.prototype.getutcfullyear', 'Date.prototype.getUTCFullYear')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-date.prototype.getutcfullyear', 'Date.prototype.getUTCFullYear')}}</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.3. |
+| {{SpecName('ES5.1', '#sec-15.9.5.11', 'Date.prototype.getUTCFullYear')}}                             | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-date.prototype.getutcfullyear', 'Date.prototype.getUTCFullYear')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-date.prototype.getutcfullyear', 'Date.prototype.getUTCFullYear')}} | {{Spec2('ESDraft')}} |                                                       |
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.Date.getUTCFullYear")}}</p>
+{{Compat("javascript.builtins.Date.getUTCFullYear")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("Date.prototype.getFullYear()")}}</li>
- <li>{{jsxref("Date.prototype.setFullYear()")}}</li>
-</ul>
+- {{jsxref("Date.prototype.getFullYear()")}}
+- {{jsxref("Date.prototype.setFullYear()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/date/getutchours/index.md b/files/fr/web/javascript/reference/global_objects/date/getutchours/index.md
index 225b1d3721..186c88055b 100644
--- a/files/fr/web/javascript/reference/global_objects/date/getutchours/index.md
+++ b/files/fr/web/javascript/reference/global_objects/date/getutchours/index.md
@@ -10,69 +10,45 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCHours
 original_slug: Web/JavaScript/Reference/Objets_globaux/Date/getUTCHours
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>getUTCHours()</code></strong> renvoie les heures de la date renseignée, d'après UTC.</p>
+La méthode **`getUTCHours()`** renvoie les heures de la date renseignée, d'après UTC.
 
-<div>{{EmbedInteractiveExample("pages/js/date-getutchours.html")}}</div>
+{{EmbedInteractiveExample("pages/js/date-getutchours.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">dateObj.getUTCHours()</pre>
+    dateObj.getUTCHours()
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un entier entre 0 et 23 correspondant à l'heure de la date indiquée selon le temps universel.</p>
+Un entier entre 0 et 23 correspondant à l'heure de la date indiquée selon le temps universel.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_getUTCHours()">Utiliser <code>getUTCHours()</code></h3>
+### Utiliser `getUTCHours()`
 
-<p>L'exemple suivant assigne les heures de la date actuelle à la variable <code>heures</code>.</p>
+L'exemple suivant assigne les heures de la date actuelle à la variable `heures`.
 
-<pre class="brush: js">var aujourdhui = new Date();
+```js
+var aujourdhui = new Date();
 var heures = aujourdhui.getUTCHours();
-</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.3.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.9.5.19', 'Date.prototype.getUTCHours')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-date.prototype.getutchours', 'Date.prototype.getUTCHours')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-date.prototype.getutchours', 'Date.prototype.getUTCHours')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Date.getUTCHours")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Date.prototype.getHours()")}}</li>
- <li>{{jsxref("Date.prototype.setUTCHours()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                        | État                         | Commentaires                                          |
+| -------------------------------------------------------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- |
+| {{SpecName('ES1')}}                                                                                             | {{Spec2('ES1')}}         | Définition initiale. Implémentée avec JavaScript 1.3. |
+| {{SpecName('ES5.1', '#sec-15.9.5.19', 'Date.prototype.getUTCHours')}}                         | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-date.prototype.getutchours', 'Date.prototype.getUTCHours')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-date.prototype.getutchours', 'Date.prototype.getUTCHours')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Date.getUTCHours")}}
+
+## Voir aussi
+
+- {{jsxref("Date.prototype.getHours()")}}
+- {{jsxref("Date.prototype.setUTCHours()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/date/getutcmilliseconds/index.md b/files/fr/web/javascript/reference/global_objects/date/getutcmilliseconds/index.md
index 898edb560b..ba7b30ec9c 100644
--- a/files/fr/web/javascript/reference/global_objects/date/getutcmilliseconds/index.md
+++ b/files/fr/web/javascript/reference/global_objects/date/getutcmilliseconds/index.md
@@ -10,73 +10,47 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCMilliseconds
 original_slug: Web/JavaScript/Reference/Objets_globaux/Date/getUTCMilliseconds
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>getUTCMilliseconds()</code></strong> renvoie les millièmes de secondes pour la date renseignée selon UTC.</p>
+La méthode **`getUTCMilliseconds()`** renvoie les millièmes de secondes pour la date renseignée selon UTC.
 
-<div>{{EmbedInteractiveExample("pages/js/date-getutcmilliseconds.html")}}</div>
+{{EmbedInteractiveExample("pages/js/date-getutcmilliseconds.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">dateObj.getUTCMilliseconds()</pre>
+    dateObj.getUTCMilliseconds()
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un entier entre 0 et 999 correspondant au nombre de millisecondes pour la date indiquée, selon le temps universel.</p>
+Un entier entre 0 et 999 correspondant au nombre de millisecondes pour la date indiquée, selon le temps universel.
 
-<div class="blockIndicator note">
-<p><strong>Note :</strong> Le résultat de cette méthode n'est pas le temps "Epoch". Si on veut obtenir le nombre de millisecondes depuis le premier janvier 1970, on utilisera la méthode {{jsxref("Date.prototype.getTime()")}}.</p>
-</div>
+> **Note :** Le résultat de cette méthode n'est pas le temps "Epoch". Si on veut obtenir le nombre de millisecondes depuis le premier janvier 1970, on utilisera la méthode {{jsxref("Date.prototype.getTime()")}}.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_getUTCMilliseconds()">Utiliser <code>getUTCMilliseconds()</code></h3>
+### Utiliser `getUTCMilliseconds()`
 
-<p>L'exemple suivant assigne les millièmes de secondes pour la date actuelle à la variable <code>ms</code>.</p>
+L'exemple suivant assigne les millièmes de secondes pour la date actuelle à la variable `ms`.
 
-<pre class="brush: js">var aujourdhui = new Date();
+```js
+var aujourdhui = new Date();
 var ms = aujourdhui.getUTCMilliseconds();
-</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.3.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.9.5.25', 'Date.prototype.getUTCMilliseconds')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-date.prototype.getutcmilliseconds', 'Date.prototype.getUTCMilliseconds')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-date.prototype.getutcmilliseconds', 'Date.prototype.getUTCMilliseconds')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Date.getUTCMilliseconds")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Date.prototype.getMilliseconds()")}}</li>
- <li>{{jsxref("Date.prototype.setUTCMilliseconds()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                                            | État                         | Commentaires                                          |
+| ---------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- |
+| {{SpecName('ES1')}}                                                                                                                 | {{Spec2('ES1')}}         | Définition initiale. Implémentée avec JavaScript 1.3. |
+| {{SpecName('ES5.1', '#sec-15.9.5.25', 'Date.prototype.getUTCMilliseconds')}}                                     | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-date.prototype.getutcmilliseconds', 'Date.prototype.getUTCMilliseconds')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-date.prototype.getutcmilliseconds', 'Date.prototype.getUTCMilliseconds')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Date.getUTCMilliseconds")}}
+
+## Voir aussi
+
+- {{jsxref("Date.prototype.getMilliseconds()")}}
+- {{jsxref("Date.prototype.setUTCMilliseconds()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/date/getutcminutes/index.md b/files/fr/web/javascript/reference/global_objects/date/getutcminutes/index.md
index 53b7aec489..5cda61f0a0 100644
--- a/files/fr/web/javascript/reference/global_objects/date/getutcminutes/index.md
+++ b/files/fr/web/javascript/reference/global_objects/date/getutcminutes/index.md
@@ -10,69 +10,45 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCMinutes
 original_slug: Web/JavaScript/Reference/Objets_globaux/Date/getUTCMinutes
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>getUTCMinutes()</code></strong> renvoie les minutes de la date renseignée, d'après UTC.</p>
+La méthode **`getUTCMinutes()`** renvoie les minutes de la date renseignée, d'après UTC.
 
-<div>{{EmbedInteractiveExample("pages/js/date-getutcminutes.html")}}</div>
+{{EmbedInteractiveExample("pages/js/date-getutcminutes.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">dateObj.getUTCMinutes()</pre>
+    dateObj.getUTCMinutes()
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un entier entre 0 et 59 correspondant au nombre de minutes pour la date indiquée selon le temps universel.</p>
+Un entier entre 0 et 59 correspondant au nombre de minutes pour la date indiquée selon le temps universel.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_getUTCMinutes">Utiliser <code>getUTCMinutes</code></h3>
+### Utiliser `getUTCMinutes`
 
-<p>L'exemple suivant assigne les minutes de la date actuelle à la variable <code>minutes</code>.</p>
+L'exemple suivant assigne les minutes de la date actuelle à la variable `minutes`.
 
-<pre class="brush: js">var aujourdhui = new Date();
+```js
+var aujourdhui = new Date();
 var minutes = aujourdhui.getUTCMinutes();
-</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.3.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.9.5.21', 'Date.prototype.getUTCMinutes')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-date.prototype.getutcminutes', 'Date.prototype.getUTCMinutes')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-date.prototype.getutcminutes', 'Date.prototype.getUTCMinutes')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Date.getUTCMinutes")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Date.prototype.getMinutes()")}}</li>
- <li>{{jsxref("Date.prototype.setUTCMinutes()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                                | État                         | Commentaires                                          |
+| ---------------------------------------------------------------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- |
+| {{SpecName('ES1')}}                                                                                                     | {{Spec2('ES1')}}         | Définition initiale. Implémentée avec JavaScript 1.3. |
+| {{SpecName('ES5.1', '#sec-15.9.5.21', 'Date.prototype.getUTCMinutes')}}                             | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-date.prototype.getutcminutes', 'Date.prototype.getUTCMinutes')}}         | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-date.prototype.getutcminutes', 'Date.prototype.getUTCMinutes')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Date.getUTCMinutes")}}
+
+## Voir aussi
+
+- {{jsxref("Date.prototype.getMinutes()")}}
+- {{jsxref("Date.prototype.setUTCMinutes()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/date/getutcmonth/index.md b/files/fr/web/javascript/reference/global_objects/date/getutcmonth/index.md
index 5f8ce36dca..562f934ba4 100644
--- a/files/fr/web/javascript/reference/global_objects/date/getutcmonth/index.md
+++ b/files/fr/web/javascript/reference/global_objects/date/getutcmonth/index.md
@@ -10,69 +10,45 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCMonth
 original_slug: Web/JavaScript/Reference/Objets_globaux/Date/getUTCMonth
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>getUTCMonth()</code></strong> renvoie le mois de la date renseignée, d'après UTC. La numérotation des mois commence à 0 pour le premier mois de l'année.</p>
+La méthode **`getUTCMonth()`** renvoie le mois de la date renseignée, d'après UTC. La numérotation des mois commence à 0 pour le premier mois de l'année.
 
-<div>{{EmbedInteractiveExample("pages/js/date-getutcmonth.html")}}</div>
+{{EmbedInteractiveExample("pages/js/date-getutcmonth.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">dateObj.getUTCMonth()</pre>
+    dateObj.getUTCMonth()
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un entier entre 0 et 11 correspondant au mois dans l'année de la date indiquée selon le temps universel (0 pour janvier, 1 pour février, 2 pour mars, et ainsi de suite…).</p>
+Un entier entre 0 et 11 correspondant au mois dans l'année de la date indiquée selon le temps universel (0 pour janvier, 1 pour février, 2 pour mars, et ainsi de suite…).
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_getUTCMonth()">Utiliser <code>getUTCMonth()</code></h3>
+### Utiliser `getUTCMonth()`
 
-<p>L'exemple suivant assigne le mois de la date actuelle à la variable <code>mois</code>.</p>
+L'exemple suivant assigne le mois de la date actuelle à la variable `mois`.
 
-<pre class="brush: js">var aujourdhui = new Date();
+```js
+var aujourdhui = new Date();
 var mois = aujourdhui.getUTCMonth();
-</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.3.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.9.5.13', 'Date.prototype.getUTCMonth')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-date.prototype.getutcmonth', 'Date.prototype.getUTCMonth')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-date.prototype.getutcmonth', 'Date.prototype.getUTCMonth')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Date.getUTCMonth")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Date.prototype.getMonth()")}}</li>
- <li>{{jsxref("Date.prototype.setUTCMonth()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                        | État                         | Commentaires                                          |
+| -------------------------------------------------------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- |
+| {{SpecName('ES1')}}                                                                                             | {{Spec2('ES1')}}         | Définition initiale. Implémentée avec JavaScript 1.3. |
+| {{SpecName('ES5.1', '#sec-15.9.5.13', 'Date.prototype.getUTCMonth')}}                         | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-date.prototype.getutcmonth', 'Date.prototype.getUTCMonth')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-date.prototype.getutcmonth', 'Date.prototype.getUTCMonth')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Date.getUTCMonth")}}
+
+## Voir aussi
+
+- {{jsxref("Date.prototype.getMonth()")}}
+- {{jsxref("Date.prototype.setUTCMonth()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/date/getutcseconds/index.md b/files/fr/web/javascript/reference/global_objects/date/getutcseconds/index.md
index 8f65ada277..10b092970d 100644
--- a/files/fr/web/javascript/reference/global_objects/date/getutcseconds/index.md
+++ b/files/fr/web/javascript/reference/global_objects/date/getutcseconds/index.md
@@ -10,69 +10,45 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCSeconds
 original_slug: Web/JavaScript/Reference/Objets_globaux/Date/getUTCSeconds
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>getUTCSeconds()</code></strong> renvoie les secondes de la date renseignée, d'après UTC.</p>
+La méthode **`getUTCSeconds()`** renvoie les secondes de la date renseignée, d'après UTC.
 
-<div>{{EmbedInteractiveExample("pages/js/date-getutcseconds.html")}}</div>
+{{EmbedInteractiveExample("pages/js/date-getutcseconds.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">dateObj.getUTCSeconds()</pre>
+    dateObj.getUTCSeconds()
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un entier entre 0 et 59 correspondant au nombre de secondes écoulées pour la date indiquée selon le temps universel.</p>
+Un entier entre 0 et 59 correspondant au nombre de secondes écoulées pour la date indiquée selon le temps universel.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_getUTCSeconds()">Utiliser <code>getUTCSeconds()</code></h3>
+### Utiliser `getUTCSeconds()`
 
-<p>L'exemple suivant assigne les secondes de la date actuelle à la variable <code>secondes</code>.</p>
+L'exemple suivant assigne les secondes de la date actuelle à la variable `secondes`.
 
-<pre class="brush: js">var aujourdhui = new Date();
+```js
+var aujourdhui = new Date();
 var secondes = aujourdhui.getUTCSeconds();
-</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.3.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.9.5.23', 'Date.prototype.getUTCSeconds')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-date.prototype.getutcseconds', 'Date.prototype.getUTCSeconds')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-date.prototype.getutcseconds', 'Date.prototype.getUTCSeconds')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Date.getUTCSeconds")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Date.prototype.getSeconds()")}}</li>
- <li>{{jsxref("Date.prototype.setUTCSeconds()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                                | État                         | Commentaires                                          |
+| ---------------------------------------------------------------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- |
+| {{SpecName('ES1')}}                                                                                                     | {{Spec2('ES1')}}         | Définition initiale. Implémentée avec JavaScript 1.3. |
+| {{SpecName('ES5.1', '#sec-15.9.5.23', 'Date.prototype.getUTCSeconds')}}                             | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-date.prototype.getutcseconds', 'Date.prototype.getUTCSeconds')}}         | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-date.prototype.getutcseconds', 'Date.prototype.getUTCSeconds')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Date.getUTCSeconds")}}
+
+## Voir aussi
+
+- {{jsxref("Date.prototype.getSeconds()")}}
+- {{jsxref("Date.prototype.setUTCSeconds()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/date/getyear/index.md b/files/fr/web/javascript/reference/global_objects/date/getyear/index.md
index 438c7107cd..30f96ed639 100644
--- a/files/fr/web/javascript/reference/global_objects/date/getyear/index.md
+++ b/files/fr/web/javascript/reference/global_objects/date/getyear/index.md
@@ -11,116 +11,91 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Date/getYear
 original_slug: Web/JavaScript/Reference/Objets_globaux/Date/getYear
 ---
-<div>{{JSRef}} {{Deprecated_header}}</div>
+{{JSRef}} {{Deprecated_header}}
 
-<p>La méthode <strong><code>getYear()</code></strong> renvoie l'année de la date renseignée, d'après l'heure locale. Parce que <code>getYear()</code> ne renvoie pas l'année complète (« bug de l'an 2000 »), cette méthode n'est plus utilisée et doit être remplacée par {{jsxref("Date.getFullYear", "getFullYear")}}.</p>
+La méthode **`getYear()`** renvoie l'année de la date renseignée, d'après l'heure locale. Parce que `getYear()` ne renvoie pas l'année complète (« bug de l'an 2000 »), cette méthode n'est plus utilisée et doit être remplacée par {{jsxref("Date.getFullYear", "getFullYear")}}.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">dateObj.getYear()</pre>
+    dateObj.getYear()
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un nombre représentant l'année de la date indiquée, selon l'heure locale, auquel on a soustrait 1900.</p>
+Un nombre représentant l'année de la date indiquée, selon l'heure locale, auquel on a soustrait 1900.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La méthode <code>getYear()</code> renvoie l'année moins 1900 ; par conséquent :</p>
+La méthode `getYear()` renvoie l'année moins 1900 ; par conséquent :
 
-<ul>
- <li>Pour les années supérieures ou égales à 2000, la valeur renvoyée par <code>getYear()</code> est supérieure ou égale à 100. Par exemple, si l'année est 2026, <code>getYear()</code> renvoie 126.</li>
- <li>Pour les années entre 1900 et 1999 incluses, la valeur renvoyée par <code>getYear()</code> est comprise entre 0 et 99. Par exemple, si l'année est 1976, <code>getYear()</code> renvoie 76.</li>
- <li>Pour les années inférieures à 1900, la valeur renvoyée par <code>getYear()</code> est négative. Par exemple, si l'année est 1800, <code>getYear()</code> renvoie -100.</li>
-</ul>
+- Pour les années supérieures ou égales à 2000, la valeur renvoyée par `getYear()` est supérieure ou égale à 100. Par exemple, si l'année est 2026, `getYear()` renvoie 126.
+- Pour les années entre 1900 et 1999 incluses, la valeur renvoyée par `getYear()` est comprise entre 0 et 99. Par exemple, si l'année est 1976, `getYear()` renvoie 76.
+- Pour les années inférieures à 1900, la valeur renvoyée par `getYear()` est négative. Par exemple, si l'année est 1800, `getYear()` renvoie -100.
 
-<p>Pour prendre en compte les années avant et après 2000, il vaut mieux utiliser {{jsxref("Date.getFullYear", "getFullYear()")}} au lieu de <code>getYear</code> afin que l'année soit spécifiée en entier.</p>
+Pour prendre en compte les années avant et après 2000, il vaut mieux utiliser {{jsxref("Date.getFullYear", "getFullYear()")}} au lieu de `getYear` afin que l'année soit spécifiée en entier.
 
-<h2 id="Rétrocompatibilité">Rétrocompatibilité</h2>
+## Rétrocompatibilité
 
-<h3 id="Comportement_dans_JavaScript_1.2_et_versions_antérieures">Comportement dans JavaScript 1.2 et versions antérieures</h3>
+### Comportement dans JavaScript 1.2 et versions antérieures
 
-<p>La méthode <code>getYear()</code> renvoyait soit une année en deux chiffres, soit une année en quatre chiffres :</p>
+La méthode `getYear()` renvoyait soit une année en deux chiffres, soit une année en quatre chiffres :
 
-<ul>
- <li>Pour les années entre 1900 et 1999 incluses, la valeur renvoyée par <code>getYear()</code> était l'année moins 1900. Par exemple, si l'année était 1976, la valeur renvoyée était 76.</li>
- <li>Pour les années inférieures à 1900 ou supérieures à 1999, la valeur renvoyée par <code>getYear</code> était l'année en quatre chiffres. Par exemple, si l'année était 1856, la valeur renvoyée était 1856. Si l'année était 2026, la valeur renvoyée était 2026.</li>
-</ul>
+- Pour les années entre 1900 et 1999 incluses, la valeur renvoyée par `getYear()` était l'année moins 1900. Par exemple, si l'année était 1976, la valeur renvoyée était 76.
+- Pour les années inférieures à 1900 ou supérieures à 1999, la valeur renvoyée par `getYear` était l'année en quatre chiffres. Par exemple, si l'année était 1856, la valeur renvoyée était 1856. Si l'année était 2026, la valeur renvoyée était 2026.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Années_entre_1900_et_1999">Années entre 1900 et 1999</h3>
+### Années entre 1900 et 1999
 
-<p>La seconde instruction assigne la valeur 95 à la variable <code>annee</code>.</p>
+La seconde instruction assigne la valeur 95 à la variable `annee`.
 
-<pre class="brush: js">var noel = new Date("December 25, 1995 23:15:00");
+```js
+var noel = new Date("December 25, 1995 23:15:00");
 var annee = noel.getYear(); // renvoie 95
-</pre>
+```
 
-<h3 id="Années_après_1999">Années après 1999</h3>
+### Années après 1999
 
-<p>La seconde instruction assigne la valeur 100 à la variable <code>annee</code>.</p>
+La seconde instruction assigne la valeur 100 à la variable `annee`.
 
-<pre class="brush: js">var noel = new Date("December 25, 2000 23:15:00");
+```js
+var noel = new Date("December 25, 2000 23:15:00");
 var annee = noel.getYear(); // renvoie 100
-</pre>
+```
 
-<h3 id="Années_avant_1900">Années avant 1900</h3>
+### Années avant 1900
 
-<p>La seconde instruction assigne la valeur -100 à la variable <code>annee</code>.</p>
+La seconde instruction assigne la valeur -100 à la variable `annee`.
 
-<pre class="brush: js">var noel = new Date("December 25, 1800 23:15:00");
+```js
+var noel = new Date("December 25, 1800 23:15:00");
 var annee = noel.getYear(); // renvoie -100
-</pre>
+```
 
-<h3 id="Définition_et_lecture_d'une_année_entre_1900_et_1999">Définition et lecture d'une année entre 1900 et 1999</h3>
+### Définition et lecture d'une année entre 1900 et 1999
 
-<p>La troisième instruction assigne la valeur 95 à la variable <code>annee</code>, représentant l'année 1995.</p>
+La troisième instruction assigne la valeur 95 à la variable `annee`, représentant l'année 1995.
 
-<pre class="brush: js">var noel = new Date("December 25, 1800 23:15:00");
+```js
+var noel = new Date("December 25, 1800 23:15:00");
 var noel.setYear(95);
 var annee = noel.getYear(); // renvoie 95
-</pre>
-
-<h2 id="Specifications">Specifications</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.3.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-B.2.4', 'Date.prototype.getYear')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td>Défini dans l'annexe informative sur la compatibilité.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-date.prototype.getyear', 'Date.prototype.getYear')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Défini dans l'annexe normative sur les fonctionnalités additionnelles des navigateurs web.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-date.prototype.getyear', 'Date.prototype.getYear')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Date.getYear")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Date.prototype.getFullYear()")}}</li>
- <li>{{jsxref("Date.prototype.getUTCFullYear()")}}</li>
- <li>{{jsxref("Date.prototype.setYear()")}}</li>
-</ul>
+```
+
+## Specifications
+
+| Spécification                                                                                                | État                         | Commentaires                                                                               |
+| ------------------------------------------------------------------------------------------------------------ | ---------------------------- | ------------------------------------------------------------------------------------------ |
+| {{SpecName('ES1')}}                                                                                     | {{Spec2('ES1')}}         | Définition initiale. Implémentée avec JavaScript 1.3.                                      |
+| {{SpecName('ES5.1', '#sec-B.2.4', 'Date.prototype.getYear')}}                             | {{Spec2('ES5.1')}}     | Défini dans l'annexe informative sur la compatibilité.                                     |
+| {{SpecName('ES6', '#sec-date.prototype.getyear', 'Date.prototype.getYear')}}         | {{Spec2('ES6')}}         | Défini dans l'annexe normative sur les fonctionnalités additionnelles des navigateurs web. |
+| {{SpecName('ESDraft', '#sec-date.prototype.getyear', 'Date.prototype.getYear')}} | {{Spec2('ESDraft')}} |                                                                                            |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Date.getYear")}}
+
+## Voir aussi
+
+- {{jsxref("Date.prototype.getFullYear()")}}
+- {{jsxref("Date.prototype.getUTCFullYear()")}}
+- {{jsxref("Date.prototype.setYear()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/date/index.md b/files/fr/web/javascript/reference/global_objects/date/index.md
index d2ea76a64e..d5ed46eb1a 100644
--- a/files/fr/web/javascript/reference/global_objects/date/index.md
+++ b/files/fr/web/javascript/reference/global_objects/date/index.md
@@ -8,205 +8,201 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Date
 original_slug: Web/JavaScript/Reference/Objets_globaux/Date
 ---
-<div>{{JSRef}}</div>
-
-<p>Les objets JavaScript <strong><code>Date</code></strong> représentent un instant donné sur l'axe du temps dans un format indépendant de la plateforme utilisée. Les objets <code>Date</code> contiennent un nombre (<code>Number</code>) qui représente le nombre de millisecondes écoulées depuis le premier janvier 1970 sur l'échelle <a href="https://fr.wikipedia.org/wiki/Temps_universel_coordonn%C3%A9">UTC</a>.</p>
-
-<div class="note"><p><strong>Note :</strong> TC39 travaille actuellement sur <a href="https://tc39.es/proposal-temporal/docs/index.html">Temporal</a>, une nouvelle API pour la gestion des dates, heures et données temporelles.<br>
- Pour en savoir plus, consultez le <a href="https://blogs.igalia.com/compilers/2020/06/23/dates-and-times-in-javascript/">blog d'Igalia</a> et n'hésitez pas à répondre <a href="https://forms.gle/iL9iZg7Y9LvH41Nv8">au sondage</a>. Les retours concrets de développeurs web sont importants pour affiner cette API. Attention, elle n'est pas encore prête à être utilisée en production !</p>
-</div>
-
-<h2 id="Description">Description</h2>
-
-<h3 id="Lepoch_ECMAScript">L'epoch ECMAScript</h3>
-
-<p>D'un point de vue technique, une date JavaScript correspond au nombre de millisecondes écoulées depuis le premier janvier 1970, minuit UTC. Cette date et cette heure sont les mêmes que <strong>l'<a href="https://fr.wikipedia.org/wiki/Epoch">epoch</a> UNIX</strong>, qui est l'instant de référence principalement utilisé pour manipuler les dates/heures dans les systèmes informatiques.</p>
-
-<div class="note"><p><strong>Note :</strong> Bien que les valeurs temporelles des objets dates soient relatives à UTC, certaines des méthodes simples pour obtenir les composantes d'une date/heure fonctionnent relativement au fuseau horaire du système.</p></div>
-
-<p>On notera également que la représentation maximale d'un objet <code>Date</code> n'est pas la même que le plus grand entier représentable en JavaScript (<code>Number.MAX_SAFE_INTEGER</code> vaut 9,007,199,254,740,991). En effet, ECMA-262 définit un maximum de ±100 000 000 (cent millions) jours relatifs au premier janvier 1970 UTC (ce qui correspond au 20 avril 271 821 avant notre ètre d'une part et au 13 septembre 275 760 de notre ère) pouvant être représentés par un objet <code>Date</code> standard (soit un intervalle de ±8 640 000 000 000 000 millisecondes).</p>
-
-<h3 id="Les_formats_de_date_et_les_conversions_entre_les_fuseaux_horaires">Les formats de date et les conversions entre les fuseaux horaires</h3>
-
-<p>Il existe différentes méthodes pour obtenir une date sous différents formats ou effectuer une conversion entre différents fuseaux. On distingue notamment les fonctions qui manipulent les dates relativement au temps universal coordonné (UTC). Le temps local est celui utilisé par l'appareil de l'utilisateur.</p>
-
-<p>Ainsi, on dispose de méthodes permettant d'obtenir ou de définir les différentes composantes d'une date selon le temps local (ex. {{jsxref("Date.getDay", "getDay()")}}, {{jsxref("Date.setHours", "setHours()")}}) et de méthodes équivalentes pour la manipulation en UTC (ex. {{jsxref("Date.getUTCDay()", "getUTCDay()")}} et {{jsxref("Date.setUTCHours", "setUTCHours()")}} respectivement).</p>
-
-<h2 id="Constructeur">Constructeur</h2>
-
-<dl>
- <dt>{{jsxref("Date/Date", "Date()")}}</dt>
- <dd>Cette fonction permet de créer un nouvel objet <code>Date</code>.</dd>
-</dl>
-
-<h2 id="Méthodes_statiques">Méthodes statiques</h2>
-
-<dl>
- <dt>{{jsxref("Date.now()")}}</dt>
- <dd>Renvoie la valeur numérique correspondant au moment présent sous la forme du nombre de millisecondes écoulées depuis le premier janvier 1970 00:00:00 UTC (les secondes intercalaires (<em>leap seconds</em>) sont ignorées).</dd>
- <dt>{{jsxref("Date.parse()")}}</dt>
- <dd>Analyse la représentation textuelle d'une date et renvoie le nombre de millisecondes écoulées entre cette date et le premier janvier 1970, 00:00:00 UTC (les secondes intercalaires (<em>leap seconds</em>) sont ignorées).
- <div class="note">
- <p><strong>Note :</strong> L'analyse de chaînes de caractères à l'aide de <code>Date.parse</code> est fortement déconseillée en raison des incohérences qui existent entre les navigateurs.</p>
- </div>
- </dd>
- <dt>{{jsxref("Date.UTC()")}}</dt>
- <dd>Accepte les mêmes paramètres que la forme longue du constructeur (c'est-à-dire entre 2 et 7) et renvoie le nombre de millisecondes entre cette date et le premier janvier 1970, 00:00:00 UTC (les secondes intercalaires (<em>leap seconds</em>) sont ignorées).</dd>
-</dl>
-
-<h2 id="Méthodes_des_instances">Méthodes des instances</h2>
-
-<dl>
- <dt>{{jsxref("Date.prototype.getDate()")}}</dt>
- <dd>Renvoie le jour du mois (entre <code>1</code> et <code>31</code>) pour la date donnée, selon le temps local.</dd>
- <dt>{{jsxref("Date.prototype.getDay()")}}</dt>
- <dd>Renvoie le jour de la semaine (entre <code>0</code> et <code>6</code>) pour la date donnée, selon le temps local.</dd>
- <dt>{{jsxref("Date.prototype.getFullYear()")}}</dt>
- <dd>Renvoie l'année (sans chiffre implicite, <code>1999</code> sera renvoyé et pas <code>99</code> par exemple) pour la date donnée, selon le temps local.</dd>
- <dt>{{jsxref("Date.prototype.getHours()")}}</dt>
- <dd>Renvoie l'heure (entre <code>0</code> et <code>23</code>) pour la date donnée, selon le temps local.</dd>
- <dt>{{jsxref("Date.prototype.getMilliseconds()")}}</dt>
- <dd>Renvoie les millisecondes (entre <code>0</code> et <code>999</code>) pour la date donnée, selon le temps local.</dd>
- <dt>{{jsxref("Date.prototype.getMinutes()")}}</dt>
- <dd>Renvoie les minutes (entre <code>0</code> et <code>59</code>) pour la date donnée, selon le temps local.</dd>
- <dt>{{jsxref("Date.prototype.getMonth()")}}</dt>
- <dd>Renvoie le mois (entre <code>0</code> et <code>11</code>) pour la date donnée, selon le temps local.</dd>
- <dt>{{jsxref("Date.prototype.getSeconds()")}}</dt>
- <dd>Renvoie les secondes (entre <code>0</code> et <code>59</code>) pour la date donnée, selon le temps local.</dd>
- <dt>{{jsxref("Date.prototype.getTime()")}}</dt>
- <dd>Renvoie la valeur numérique de la date donnée, exprimée en nombre de millisecondes écoulées depuis le premier janvier 1970, 00:00:00 UTC (pour les temps antérieurs, ce sont des valeurs négatives qui seront renvoyées).</dd>
- <dt>{{jsxref("Date.prototype.getTimezoneOffset()")}}</dt>
- <dd>Renvoie le décalage horaire, exprimé en minutes, pour la locale courante.</dd>
- <dt>{{jsxref("Date.prototype.getUTCDate()")}}</dt>
- <dd>Renvoie le jour du mois (entre <code>1</code> et <code>31</code>) pour la date donnée, selon le temps universel.</dd>
- <dt>{{jsxref("Date.prototype.getUTCDay()")}}</dt>
- <dd>Renvoie le jour de la semaine (entre <code>0</code> et <code>6</code>) pour la date donnée, selon le temps universel.</dd>
- <dt>{{jsxref("Date.prototype.getUTCFullYear()")}}</dt>
- <dd>Renvoie l'année (sans chiffre implicite, <code>1999</code> sera renvoyé plutôt que <code>99</code>) pour la date donnée, selon le temps universel.</dd>
- <dt>{{jsxref("Date.prototype.getUTCHours()")}}</dt>
- <dd>Renvoie l'heure (entre <code>0</code> et <code>23</code>) pour la date donnée, selon le temps universel.</dd>
- <dt>{{jsxref("Date.prototype.getUTCMilliseconds()")}}</dt>
- <dd>Renvoie les millisecondes (entre <code>0</code> et <code>999</code>) pour la date donnée, selon le temps universel.</dd>
- <dt>{{jsxref("Date.prototype.getUTCMinutes()")}}</dt>
- <dd>Renvoie les minutes (entre <code>0</code> et <code>59</code>) pour la date donnée, selon le temps universel.</dd>
- <dt>{{jsxref("Date.prototype.getUTCMonth()")}}</dt>
- <dd>Renvoie le mois (entre <code>0</code> et <code>11</code>) pour la date donnée, selon le temps universel.</dd>
- <dt>{{jsxref("Date.prototype.getUTCSeconds()")}}</dt>
- <dd>Renvoie les secondes (entre <code>0</code> et <code>59</code>) pour la date donnée, selon le temps universel.</dd>
- <dt>{{jsxref("Date.prototype.getYear()")}}</dt>
- <dd>Renvoie l'année (généralement exprimée sur 2 ou 3 chiffres) pour la date donnée selon le temps local. <strong>On utilisera plutôt {{jsxref("Date.prototype.getFullYear()", "getFullYear()")}}</strong>.</dd>
- <dt>{{jsxref("Date.prototype.setDate()")}}</dt>
- <dd>Définit le jour du mois pour la date donnée, selon le temps local.</dd>
- <dt>{{jsxref("Date.prototype.setFullYear()")}}</dt>
- <dd>Définit l'année (sans chiffre implicite, on utilisera <code>1999</code> et pas <code>99</code>) pour la date donnée, selon le temps local.</dd>
- <dt>{{jsxref("Date.prototype.setHours()")}}</dt>
- <dd>Définit les heures pour la date donnée, selon le temps local.</dd>
- <dt>{{jsxref("Date.prototype.setMilliseconds()")}}</dt>
- <dd>Définit les millisecondes pour la date donnée, selon le temps local.</dd>
- <dt>{{jsxref("Date.prototype.setMinutes()")}}</dt>
- <dd>Définit les minutes pour la date donnée, selon le temps local.</dd>
- <dt>{{jsxref("Date.prototype.setMonth()")}}</dt>
- <dd>Définit le mois pour la date donnée, selon le temps local.</dd>
- <dt>{{jsxref("Date.prototype.setSeconds()")}}</dt>
- <dd>Définit les secondes pour la date donnée, selon le temps local.</dd>
- <dt>{{jsxref("Date.prototype.setTime()")}}</dt>
- <dd>Définit le nombre de millisecondes écoulées depuis le premier janvier 1970, 00:00:00 UTC et la date donnée. On utilisera des nombres négatifs pour les moments antérieurs à cette date.</dd>
- <dt>{{jsxref("Date.prototype.setUTCDate()")}}</dt>
- <dd>Définit le jour du mois pour la date donnée selon le temps universel.</dd>
- <dt>{{jsxref("Date.prototype.setUTCFullYear()")}}</dt>
- <dd>Définit l'année (exprimée sans chiffres implicites, ex. <code>1999</code> et pas <code>99</code>) pour la date donnée selon le temps universel.</dd>
- <dt>{{jsxref("Date.prototype.setUTCHours()")}}</dt>
- <dd>Définit l'heure pour la date donnée selon le temps universel.</dd>
- <dt>{{jsxref("Date.prototype.setUTCMilliseconds()")}}</dt>
- <dd>Définit les millisecondes pour la date donnée selon le temps universel.</dd>
- <dt>{{jsxref("Date.prototype.setUTCMinutes()")}}</dt>
- <dd>Définit les minutes pour la date donnée selon le temps universel.</dd>
- <dt>{{jsxref("Date.prototype.setUTCMonth()")}}</dt>
- <dd>Définit le mois pour la date donnée selon le temps universel.</dd>
- <dt>{{jsxref("Date.prototype.setUTCSeconds()")}}</dt>
- <dd>Définit les secondes pour la date donnée selon le temps universel.</dd>
- <dt>{{jsxref("Date.prototype.setYear()")}}</dt>
- <dd>Définit l'année (avec 2 à 3 chiffres) pour la date courante selon le temps local. <strong>On privilégiera la méthode {{jsxref("Date.prototype.setFullYear()", "setFullYear()")}} à la place.</strong></dd>
- <dt>{{jsxref("Date.prototype.toDateString()")}}</dt>
- <dd>Renvoie la partie "date" (jour, mois, année) de l'objet {{jsxref("Date")}} en une chaîne de caractères compréhensible par un humain (anglophone) (ex. <code>'Thu Apr 12 2018'</code>).</dd>
- <dt>{{jsxref("Date.prototype.toISOString()")}}</dt>
- <dd>Convertit une date en une chaîne de caractères selon le format ISO 8601 Étendu.</dd>
- <dt>{{jsxref("Date.prototype.toJSON()")}}</dt>
- <dd>Renvoie une chaîne de caractères représentant l'objet {{jsxref("Date")}} avec {{jsxref("Date.prototype.toISOString()", "toISOString()")}}. Cette méthode est utilisée par {{jsxref("JSON.stringify()")}}.</dd>
- <dt>{{jsxref("Date.prototype.toGMTString()")}}</dt>
- <dd>Renvoie une chaîne de caractères représentant l'objet {{jsxref("Date")}} d'après le fuseau GMT (UTC). <strong>On utilisera plutôt {{jsxref("Date.prototype.toUTCString()", "toUTCString()")}}</strong>.</dd>
- <dt>{{jsxref("Date.prototype.toLocaleDateString()")}}</dt>
- <dd>Renvoie une chaîne de caractères représentant les jours / mois / années de la date courante avec une représentation propre à la locale courante (déduite des paramètres systèmes utilisés).</dd>
- <dt>{{jsxref("Date.prototype.toLocaleFormat()")}}</dt>
- <dd>Convertit la date courante en une chaîne de caractères avec un format décrit en paramètre via une chaîne de caractères.</dd>
- <dt>{{jsxref("Date.prototype.toLocaleString()")}}</dt>
- <dd>Renvoie une chaîne de caractères représentant la date sous le forme de la locale courante. Cette méthode surcharge la méthode {{jsxref("Object.prototype.toLocaleString()")}}.</dd>
- <dt>{{jsxref("Date.prototype.toLocaleTimeString()")}}</dt>
- <dd>Renvoie une chaîne de caractères représentant les heures / minutes / secondes de la date courante avec une représentation propre à la locale courante (déduite des paramètres systèmes utilisés).</dd>
- <dt>{{jsxref("Date.prototype.toString()")}}</dt>
- <dd>Renvoie une chaîne de caractères représentant l'objet {{jsxref("Date")}} courant. Cette méthode surcharge la méthode {{jsxref("Object.prototype.toString()")}}.</dd>
- <dt>{{jsxref("Date.prototype.toTimeString()")}}</dt>
- <dd>Renvoie l'heure (avec les minutes et les secondes) d'une date sous la forme d'une chaîne de caractères compréhensible par un humain.</dd>
- <dt>{{jsxref("Date.prototype.toUTCString()")}}</dt>
- <dd>Convertit une date en chaîne de caractère en utilisant le temps universel comme référentiel.</dd>
- <dt>{{jsxref("Date.prototype.valueOf()")}}</dt>
- <dd>Renvoie la valeur primitive d'un objet {{jsxref("Date")}}. Cette méthode surcharge la méthode {{jsxref("Object.prototype.valueOf()")}}.</dd>
-</dl>
-
-<h2 id="Exemples">Exemples</h2>
-
-<h3 id="Différentes_façons_de_créer_un_objet_Date">Différentes façons de créer un objet <code>Date</code></h3>
-
-<p>Les exemples qui suivent illustrent différentes méthodes permettant de créer des dates JavaScript :</p>
-
-<div class="note">
-<p><strong>Note :</strong> L'analyse de chaîne de caractères représentant des dates avec le constructeur <code>Date</code>  (ou <code>Date.parse</code> qui est équivalent) est fortement déconseillée en raison des différences de comportement existant entre les navigateurs.</p>
-</div>
-
-<pre class="brush: js notranslate">let aujourdhui = new Date()
+{{JSRef}}
+
+Les objets JavaScript **`Date`** représentent un instant donné sur l'axe du temps dans un format indépendant de la plateforme utilisée. Les objets `Date` contiennent un nombre (`Number`) qui représente le nombre de millisecondes écoulées depuis le premier janvier 1970 sur l'échelle [UTC](https://fr.wikipedia.org/wiki/Temps_universel_coordonn%C3%A9).
+
+> **Note :** TC39 travaille actuellement sur [Temporal](https://tc39.es/proposal-temporal/docs/index.html), une nouvelle API pour la gestion des dates, heures et données temporelles.
+> Pour en savoir plus, consultez le [blog d'Igalia](https://blogs.igalia.com/compilers/2020/06/23/dates-and-times-in-javascript/) et n'hésitez pas à répondre [au sondage](https://forms.gle/iL9iZg7Y9LvH41Nv8). Les retours concrets de développeurs web sont importants pour affiner cette API. Attention, elle n'est pas encore prête à être utilisée en production !
+
+## Description
+
+### L'epoch ECMAScript
+
+D'un point de vue technique, une date JavaScript correspond au nombre de millisecondes écoulées depuis le premier janvier 1970, minuit UTC. Cette date et cette heure sont les mêmes que **l'[epoch](https://fr.wikipedia.org/wiki/Epoch) UNIX**, qui est l'instant de référence principalement utilisé pour manipuler les dates/heures dans les systèmes informatiques.
+
+> **Note :** Bien que les valeurs temporelles des objets dates soient relatives à UTC, certaines des méthodes simples pour obtenir les composantes d'une date/heure fonctionnent relativement au fuseau horaire du système.
+
+On notera également que la représentation maximale d'un objet `Date` n'est pas la même que le plus grand entier représentable en JavaScript (`Number.MAX_SAFE_INTEGER` vaut 9,007,199,254,740,991). En effet, ECMA-262 définit un maximum de ±100 000 000 (cent millions) jours relatifs au premier janvier 1970 UTC (ce qui correspond au 20 avril 271 821 avant notre ètre d'une part et au 13 septembre 275 760 de notre ère) pouvant être représentés par un objet `Date` standard (soit un intervalle de ±8 640 000 000 000 000 millisecondes).
+
+### Les formats de date et les conversions entre les fuseaux horaires
+
+Il existe différentes méthodes pour obtenir une date sous différents formats ou effectuer une conversion entre différents fuseaux. On distingue notamment les fonctions qui manipulent les dates relativement au temps universal coordonné (UTC). Le temps local est celui utilisé par l'appareil de l'utilisateur.
+
+Ainsi, on dispose de méthodes permettant d'obtenir ou de définir les différentes composantes d'une date selon le temps local (ex. {{jsxref("Date.getDay", "getDay()")}}, {{jsxref("Date.setHours", "setHours()")}}) et de méthodes équivalentes pour la manipulation en UTC (ex. {{jsxref("Date.getUTCDay()", "getUTCDay()")}} et {{jsxref("Date.setUTCHours", "setUTCHours()")}} respectivement).
+
+## Constructeur
+
+- {{jsxref("Date/Date", "Date()")}}
+  - : Cette fonction permet de créer un nouvel objet `Date`.
+
+## Méthodes statiques
+
+- {{jsxref("Date.now()")}}
+  - : Renvoie la valeur numérique correspondant au moment présent sous la forme du nombre de millisecondes écoulées depuis le premier janvier 1970 00:00:00 UTC (les secondes intercalaires (_leap seconds_) sont ignorées).
+- {{jsxref("Date.parse()")}}
+
+  - : Analyse la représentation textuelle d'une date et renvoie le nombre de millisecondes écoulées entre cette date et le premier janvier 1970, 00:00:00 UTC (les secondes intercalaires (_leap seconds_) sont ignorées).
+
+    > **Note :** L'analyse de chaînes de caractères à l'aide de `Date.parse` est fortement déconseillée en raison des incohérences qui existent entre les navigateurs.
+
+- {{jsxref("Date.UTC()")}}
+  - : Accepte les mêmes paramètres que la forme longue du constructeur (c'est-à-dire entre 2 et 7) et renvoie le nombre de millisecondes entre cette date et le premier janvier 1970, 00:00:00 UTC (les secondes intercalaires (_leap seconds_) sont ignorées).
+
+## Méthodes des instances
+
+- {{jsxref("Date.prototype.getDate()")}}
+  - : Renvoie le jour du mois (entre `1` et `31`) pour la date donnée, selon le temps local.
+- {{jsxref("Date.prototype.getDay()")}}
+  - : Renvoie le jour de la semaine (entre `0` et `6`) pour la date donnée, selon le temps local.
+- {{jsxref("Date.prototype.getFullYear()")}}
+  - : Renvoie l'année (sans chiffre implicite, `1999` sera renvoyé et pas `99` par exemple) pour la date donnée, selon le temps local.
+- {{jsxref("Date.prototype.getHours()")}}
+  - : Renvoie l'heure (entre `0` et `23`) pour la date donnée, selon le temps local.
+- {{jsxref("Date.prototype.getMilliseconds()")}}
+  - : Renvoie les millisecondes (entre `0` et `999`) pour la date donnée, selon le temps local.
+- {{jsxref("Date.prototype.getMinutes()")}}
+  - : Renvoie les minutes (entre `0` et `59`) pour la date donnée, selon le temps local.
+- {{jsxref("Date.prototype.getMonth()")}}
+  - : Renvoie le mois (entre `0` et `11`) pour la date donnée, selon le temps local.
+- {{jsxref("Date.prototype.getSeconds()")}}
+  - : Renvoie les secondes (entre `0` et `59`) pour la date donnée, selon le temps local.
+- {{jsxref("Date.prototype.getTime()")}}
+  - : Renvoie la valeur numérique de la date donnée, exprimée en nombre de millisecondes écoulées depuis le premier janvier 1970, 00:00:00 UTC (pour les temps antérieurs, ce sont des valeurs négatives qui seront renvoyées).
+- {{jsxref("Date.prototype.getTimezoneOffset()")}}
+  - : Renvoie le décalage horaire, exprimé en minutes, pour la locale courante.
+- {{jsxref("Date.prototype.getUTCDate()")}}
+  - : Renvoie le jour du mois (entre `1` et `31`) pour la date donnée, selon le temps universel.
+- {{jsxref("Date.prototype.getUTCDay()")}}
+  - : Renvoie le jour de la semaine (entre `0` et `6`) pour la date donnée, selon le temps universel.
+- {{jsxref("Date.prototype.getUTCFullYear()")}}
+  - : Renvoie l'année (sans chiffre implicite, `1999` sera renvoyé plutôt que `99`) pour la date donnée, selon le temps universel.
+- {{jsxref("Date.prototype.getUTCHours()")}}
+  - : Renvoie l'heure (entre `0` et `23`) pour la date donnée, selon le temps universel.
+- {{jsxref("Date.prototype.getUTCMilliseconds()")}}
+  - : Renvoie les millisecondes (entre `0` et `999`) pour la date donnée, selon le temps universel.
+- {{jsxref("Date.prototype.getUTCMinutes()")}}
+  - : Renvoie les minutes (entre `0` et `59`) pour la date donnée, selon le temps universel.
+- {{jsxref("Date.prototype.getUTCMonth()")}}
+  - : Renvoie le mois (entre `0` et `11`) pour la date donnée, selon le temps universel.
+- {{jsxref("Date.prototype.getUTCSeconds()")}}
+  - : Renvoie les secondes (entre `0` et `59`) pour la date donnée, selon le temps universel.
+- {{jsxref("Date.prototype.getYear()")}}
+  - : Renvoie l'année (généralement exprimée sur 2 ou 3 chiffres) pour la date donnée selon le temps local. **On utilisera plutôt {{jsxref("Date.prototype.getFullYear()", "getFullYear()")}}**.
+- {{jsxref("Date.prototype.setDate()")}}
+  - : Définit le jour du mois pour la date donnée, selon le temps local.
+- {{jsxref("Date.prototype.setFullYear()")}}
+  - : Définit l'année (sans chiffre implicite, on utilisera `1999` et pas `99`) pour la date donnée, selon le temps local.
+- {{jsxref("Date.prototype.setHours()")}}
+  - : Définit les heures pour la date donnée, selon le temps local.
+- {{jsxref("Date.prototype.setMilliseconds()")}}
+  - : Définit les millisecondes pour la date donnée, selon le temps local.
+- {{jsxref("Date.prototype.setMinutes()")}}
+  - : Définit les minutes pour la date donnée, selon le temps local.
+- {{jsxref("Date.prototype.setMonth()")}}
+  - : Définit le mois pour la date donnée, selon le temps local.
+- {{jsxref("Date.prototype.setSeconds()")}}
+  - : Définit les secondes pour la date donnée, selon le temps local.
+- {{jsxref("Date.prototype.setTime()")}}
+  - : Définit le nombre de millisecondes écoulées depuis le premier janvier 1970, 00:00:00 UTC et la date donnée. On utilisera des nombres négatifs pour les moments antérieurs à cette date.
+- {{jsxref("Date.prototype.setUTCDate()")}}
+  - : Définit le jour du mois pour la date donnée selon le temps universel.
+- {{jsxref("Date.prototype.setUTCFullYear()")}}
+  - : Définit l'année (exprimée sans chiffres implicites, ex. `1999` et pas `99`) pour la date donnée selon le temps universel.
+- {{jsxref("Date.prototype.setUTCHours()")}}
+  - : Définit l'heure pour la date donnée selon le temps universel.
+- {{jsxref("Date.prototype.setUTCMilliseconds()")}}
+  - : Définit les millisecondes pour la date donnée selon le temps universel.
+- {{jsxref("Date.prototype.setUTCMinutes()")}}
+  - : Définit les minutes pour la date donnée selon le temps universel.
+- {{jsxref("Date.prototype.setUTCMonth()")}}
+  - : Définit le mois pour la date donnée selon le temps universel.
+- {{jsxref("Date.prototype.setUTCSeconds()")}}
+  - : Définit les secondes pour la date donnée selon le temps universel.
+- {{jsxref("Date.prototype.setYear()")}}
+  - : Définit l'année (avec 2 à 3 chiffres) pour la date courante selon le temps local. **On privilégiera la méthode {{jsxref("Date.prototype.setFullYear()", "setFullYear()")}} à la place.**
+- {{jsxref("Date.prototype.toDateString()")}}
+  - : Renvoie la partie "date" (jour, mois, année) de l'objet {{jsxref("Date")}} en une chaîne de caractères compréhensible par un humain (anglophone) (ex. `'Thu Apr 12 2018'`).
+- {{jsxref("Date.prototype.toISOString()")}}
+  - : Convertit une date en une chaîne de caractères selon le format ISO 8601 Étendu.
+- {{jsxref("Date.prototype.toJSON()")}}
+  - : Renvoie une chaîne de caractères représentant l'objet {{jsxref("Date")}} avec {{jsxref("Date.prototype.toISOString()", "toISOString()")}}. Cette méthode est utilisée par {{jsxref("JSON.stringify()")}}.
+- {{jsxref("Date.prototype.toGMTString()")}}
+  - : Renvoie une chaîne de caractères représentant l'objet {{jsxref("Date")}} d'après le fuseau GMT (UTC). **On utilisera plutôt {{jsxref("Date.prototype.toUTCString()", "toUTCString()")}}**.
+- {{jsxref("Date.prototype.toLocaleDateString()")}}
+  - : Renvoie une chaîne de caractères représentant les jours / mois / années de la date courante avec une représentation propre à la locale courante (déduite des paramètres systèmes utilisés).
+- {{jsxref("Date.prototype.toLocaleFormat()")}}
+  - : Convertit la date courante en une chaîne de caractères avec un format décrit en paramètre via une chaîne de caractères.
+- {{jsxref("Date.prototype.toLocaleString()")}}
+  - : Renvoie une chaîne de caractères représentant la date sous le forme de la locale courante. Cette méthode surcharge la méthode {{jsxref("Object.prototype.toLocaleString()")}}.
+- {{jsxref("Date.prototype.toLocaleTimeString()")}}
+  - : Renvoie une chaîne de caractères représentant les heures / minutes / secondes de la date courante avec une représentation propre à la locale courante (déduite des paramètres systèmes utilisés).
+- {{jsxref("Date.prototype.toString()")}}
+  - : Renvoie une chaîne de caractères représentant l'objet {{jsxref("Date")}} courant. Cette méthode surcharge la méthode {{jsxref("Object.prototype.toString()")}}.
+- {{jsxref("Date.prototype.toTimeString()")}}
+  - : Renvoie l'heure (avec les minutes et les secondes) d'une date sous la forme d'une chaîne de caractères compréhensible par un humain.
+- {{jsxref("Date.prototype.toUTCString()")}}
+  - : Convertit une date en chaîne de caractère en utilisant le temps universel comme référentiel.
+- {{jsxref("Date.prototype.valueOf()")}}
+  - : Renvoie la valeur primitive d'un objet {{jsxref("Date")}}. Cette méthode surcharge la méthode {{jsxref("Object.prototype.valueOf()")}}.
+
+## Exemples
+
+### Différentes façons de créer un objet `Date`
+
+Les exemples qui suivent illustrent différentes méthodes permettant de créer des dates JavaScript :
+
+> **Note :** L'analyse de chaîne de caractères représentant des dates avec le constructeur `Date`  (ou `Date.parse` qui est équivalent) est fortement déconseillée en raison des différences de comportement existant entre les navigateurs.
+
+```js
+let aujourdhui = new Date()
 let anniversaire = new Date('September 22, 2018 15:00:00')
 let anniversaire = new Date('2018-09-22T15:00:00')
 let anniversaire = new Date(2018, 8, 22)            // the month is 0-indexed
 let anniversaire = new Date(2018, 8, 22, 15, 0, 0)
-</pre>
+```
 
-<h3 id="Les_années_sur_deux_chiffres_correspondent_à_la_période_1900_–_1999">Les années sur deux chiffres correspondent à la période 1900 – 1999</h3>
+### Les années sur deux chiffres correspondent à la période 1900 – 1999
 
-<p>Afin de créer et de manipuler des dates sur les années <code>0</code> à <code>99</code> de notre ère, on doit utiliser les méthodes {{jsxref("Date.prototype.setFullYear()")}} and {{jsxref("Date.prototype.getFullYear()")}}.</p>
+Afin de créer et de manipuler des dates sur les années `0` à `99` de notre ère, on doit utiliser les méthodes {{jsxref("Date.prototype.setFullYear()")}} and {{jsxref("Date.prototype.getFullYear()")}}.
 
-<pre class="brush: js notranslate">let date = new Date(98, 1)  // Sun Feb 01 1998 00:00:00 GMT+0000 (GMT)
+```js
+let date = new Date(98, 1)  // Sun Feb 01 1998 00:00:00 GMT+0000 (GMT)
 
 // Méthode dépréciée, 98 correspond également ici à 1998
 date.setYear(98)            // Sun Feb 01 1998 00:00:00 GMT+0000 (GMT)
 
 date.setFullYear(98)        // Sat Feb 01 0098 00:00:00 GMT+0000 (BST)
-</pre>
+```
 
-<h3 id="Calculer_le_temps_écoulé">Calculer le temps écoulé</h3>
+### Calculer le temps écoulé
 
-<p>Dans les exemples suivants, on illustre comment calculer le temps écoulé entre deux dates JavaScript en millisecondes.</p>
+Dans les exemples suivants, on illustre comment calculer le temps écoulé entre deux dates JavaScript en millisecondes.
 
-<p>En raison de durées différentes pour les jours (heure d'été / heure d'hiver), les mois et les années, il faudra faire attention et étudier le sujet avant d'exprimer des durées en unités supérieures à des heures / minutes / secondes.</p>
+En raison de durées différentes pour les jours (heure d'été / heure d'hiver), les mois et les années, il faudra faire attention et étudier le sujet avant d'exprimer des durées en unités supérieures à des heures / minutes / secondes.
 
-<pre class="brush: js notranslate">// Utiliser des objets Date
+```js
+// Utiliser des objets Date
 let debut = Date.now()
 
 // Ici, l'évènement dont on veut mesurer la durée :
 faireQuelqueChosePendantLongtemps()
 let fin = Date.now()
 let duree = fin - debut // La durée écoulée, en millisecondes
-</pre>
+```
 
-<pre class="brush: js notranslate">// En utilisant les méthodes natives
+```js
+// En utilisant les méthodes natives
 let debut = new Date()
 
 // Ici, l'évènement dont on veut mesurer la durée :
 faireQuelqueChosePendantLongtemps()
 let fin = new Date()
 let duree = fin.getTime() - debut.getTime() // La durée écoulée, en millisecondes
-</pre>
+```
 
-<pre class="brush: js notranslate">// Pour tester le temps d'exécution d'une fonction
+```js
+// Pour tester le temps d'exécution d'une fonction
 function afficheDureeEcoulee(fTest) {
   let debut = Date.now(),
       valRetour = fTest(),
@@ -217,40 +213,28 @@ function afficheDureeEcoulee(fTest) {
 }
 
 let valeurDeRetour = afficheDureeEcoulee(maFonctionATester)
-</pre>
+```
 
-<div class="note">
-<p><strong>Note :</strong> Pour les navigateurs qui prennent en charge l'{{domxref("Window.performance", "API Web Performance", "", 1)}}, la méthode {{domxref("Performance.now()")}} peut fournir un outil de mesure des durées écoulées plus fiable et précis que {{jsxref("Date.now()")}}.</p>
-</div>
+> **Note :** Pour les navigateurs qui prennent en charge l'{{domxref("Window.performance", "API Web Performance", "", 1)}}, la méthode {{domxref("Performance.now()")}} peut fournir un outil de mesure des durées écoulées plus fiable et précis que {{jsxref("Date.now()")}}.
 
-<h3 id="Obtenir_le_nombre_de_secondes_écoulées_depuis_lepoch_ECMAScript">Obtenir le nombre de secondes écoulées depuis l'epoch ECMAScript</h3>
+### Obtenir le nombre de secondes écoulées depuis l'epoch ECMAScript
 
-<pre class="brush: js notranslate">let secondes = Math.floor(Date.now() / 1000)
-</pre>
+```js
+let secondes = Math.floor(Date.now() / 1000)
+```
 
-<p>Dans ce cas, on renvoie un entier et c'est pour ça qu'on utilise {{jsxref("Math.floor()")}}. Par ailleurs, on n'utilise pas {{jsxref("Math.round()")}} afin d'avoir le nombre de secondes effectivement écoulées.</p>
+Dans ce cas, on renvoie un entier et c'est pour ça qu'on utilise {{jsxref("Math.floor()")}}. Par ailleurs, on n'utilise pas {{jsxref("Math.round()")}} afin d'avoir le nombre de secondes effectivement écoulées.
 
-<h2 id="Spécifications">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-date-objects', 'Date')}}</td>
-  </tr>
- </tbody>
-</table>
+| Spécification                                                        |
+| -------------------------------------------------------------------- |
+| {{SpecName('ESDraft', '#sec-date-objects', 'Date')}} |
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.Date", 3)}}</p>
+{{Compat("javascript.builtins.Date", 3)}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>Le constructeur {{jsxref("Date/Date", "Date()")}}</li>
-</ul>
+- Le constructeur {{jsxref("Date/Date", "Date()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/date/now/index.md b/files/fr/web/javascript/reference/global_objects/date/now/index.md
index 271fbf39bb..27cfc90da5 100644
--- a/files/fr/web/javascript/reference/global_objects/date/now/index.md
+++ b/files/fr/web/javascript/reference/global_objects/date/now/index.md
@@ -10,43 +10,44 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Date/now
 original_slug: Web/JavaScript/Reference/Objets_globaux/Date/now
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>Date.now()</code></strong> renvoie le nombre de millisecondes écoulées depuis le 1er Janvier 1970 00:00:00 UTC.</p>
+La méthode **`Date.now()`** renvoie le nombre de millisecondes écoulées depuis le 1er Janvier 1970 00:00:00 UTC.
 
-<div>{{EmbedInteractiveExample("pages/js/date-now.html")}}</div>
+{{EmbedInteractiveExample("pages/js/date-now.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">var tempsEnMs = Date.now();
-</pre>
+    var tempsEnMs = Date.now();
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Le nombre de millisecondes écoulées depuis le premier janvier 1970 à minuit UTC.</p>
+Le nombre de millisecondes écoulées depuis le premier janvier 1970 à minuit UTC.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La méthode <code>now()</code> renvoie le nombre de millisecondes écoulées depuis le 1er janvier 1970 00:00:00 UTC sous forme d'un {{jsxref("Number")}} (nombre).</p>
+La méthode `now()` renvoie le nombre de millisecondes écoulées depuis le 1er janvier 1970 00:00:00 UTC sous forme d'un {{jsxref("Number")}} (nombre).
 
-<p><code>now()</code> étant une méthode statique de {{jsxref("Date")}}, on utilisera toujours la forme <code>Date.now()</code>.</p>
+`now()` étant une méthode statique de {{jsxref("Date")}}, on utilisera toujours la forme `Date.now()`.
 
-<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é standardisée dans la 5e édition d'ECMA-262. Les moteurs JavaScript ne la supportant pas peuvent l'émuler de la façon suivante :</p>
+Cette méthode a été standardisée dans la 5e édition d'ECMA-262. Les moteurs JavaScript ne la supportant pas peuvent l'émuler de la façon suivante :
 
-<pre class="brush: js">if (!Date.now) {
+```js
+if (!Date.now) {
   Date.now = function now() {
     return new Date().getTime();
   };
 }
-</pre>
+```
 
-<h2 id="Précision_temporelle_réduite">Précision temporelle réduite</h2>
+## Précision temporelle réduite
 
-<p>Afin de protéger contre les attaques de minutage et d'identification, la précision de <code>new Date.now()</code> peut être arrondie en fonction des paramètres du navigateur. Pour Firefox, la préférence <code>privacy.reduceTimerPrecision</code> est activée par défaut et vaut, par défaut 20ms pour Firefox 59 et 2ms pour Firefox 60.</p>
+Afin de protéger contre les attaques de minutage et d'identification, la précision de `new Date.now()` peut être arrondie en fonction des paramètres du navigateur. Pour Firefox, la préférence `privacy.reduceTimerPrecision` est activée par défaut et vaut, par défaut 20ms pour Firefox 59 et 2ms pour Firefox 60.
 
-<pre class="brush: js">// Précision temporelle réduite (2ms) pour Firefox 60
+```js
+// Précision temporelle réduite (2ms) pour Firefox 60
 new Date().getTime();
 // 1519211809934
 // 1519211810362
@@ -60,44 +61,23 @@ new Date().getTime();
 // 1519129858900
 // 1519129864400
 // ...
-</pre>
-
-<p>Pour Firefox, il est également possible d'activer <code>privacy.resistFingerprinting</code> auquel cas la précision sera 100ms ou la valeur de <code>privacy.resistFingerprinting.reduceTimerPrecision.microseconds</code> selon laquelle est plus grande.</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('ES5.1', '#sec-15.9.4.4', 'Date.now')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td>Définition initiale. Implémentée avec JavaScript 1.5.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-date.now', 'Date.now')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-date.now', 'Date.now')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Date.now")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{domxref("window.performance.now")}} - renvoie des timestamps (horodatages) avec une précision supérieure à la milliseconde pour mesurer la performance des pages web.</li>
- <li>{{domxref("console.time")}} / {{domxref("console.timeEnd")}}</li>
-</ul>
+```
+
+Pour Firefox, il est également possible d'activer `privacy.resistFingerprinting` auquel cas la précision sera 100ms ou la valeur de `privacy.resistFingerprinting.reduceTimerPrecision.microseconds` selon laquelle est plus grande.
+
+## Spécifications
+
+| Spécification                                                        | État                         | Commentaires                                          |
+| -------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- |
+| {{SpecName('ES5.1', '#sec-15.9.4.4', 'Date.now')}} | {{Spec2('ES5.1')}}     | Définition initiale. Implémentée avec JavaScript 1.5. |
+| {{SpecName('ES6', '#sec-date.now', 'Date.now')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-date.now', 'Date.now')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Date.now")}}
+
+## Voir aussi
+
+- {{domxref("window.performance.now")}} - renvoie des timestamps (horodatages) avec une précision supérieure à la milliseconde pour mesurer la performance des pages web.
+- {{domxref("console.time")}} / {{domxref("console.timeEnd")}}
diff --git a/files/fr/web/javascript/reference/global_objects/date/parse/index.md b/files/fr/web/javascript/reference/global_objects/date/parse/index.md
index 86226b698a..5aebdfbe75 100644
--- a/files/fr/web/javascript/reference/global_objects/date/parse/index.md
+++ b/files/fr/web/javascript/reference/global_objects/date/parse/index.md
@@ -9,187 +9,169 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Date/parse
 original_slug: Web/JavaScript/Reference/Objets_globaux/Date/parse
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>Date.parse()</code></strong><strong> </strong>analyse la représentation textuelle d'une date, et renvoie le nombre de millisecondes depuis le 1er janvier 1970, 00:00:00 UTC jusqu'à cette date ou <code>NaN</code> si la chaîne n'est pas reconnue ou décrit une date invalide (par exemple 2015-02-31).</p>
+La méthode **`Date.parse()`\*\*** \*\*analyse la représentation textuelle d'une date, et renvoie le nombre de millisecondes depuis le 1er janvier 1970, 00:00:00 UTC jusqu'à cette date ou `NaN` si la chaîne n'est pas reconnue ou décrit une date invalide (par exemple 2015-02-31).
 
-<div class="note">
-<p><strong>Note :</strong> Pour les anciennes implémentations (avant ES5), le résultat de <code>Date.</code><code>parse</code> variait d'une implémentation à l'autre. Attention donc à la compatibilité avec ces anciennes versions.</p>
-</div>
+> **Note :** Pour les anciennes implémentations (avant ES5), le résultat de ` Date.``parse ` variait d'une implémentation à l'autre. Attention donc à la compatibilité avec ces anciennes versions.
 
-<div>{{EmbedInteractiveExample("pages/js/date-parse.html")}}</div>
+{{EmbedInteractiveExample("pages/js/date-parse.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<p>Appel direct :</p>
+Appel direct :
 
-<pre class="syntaxbox notranslate">Date.parse(dateString)</pre>
+    Date.parse(dateString)
 
-<p>Appel implicite :</p>
+Appel implicite :
 
-<pre class="syntaxbox notranslate">new Date(<var>dateString</var>)</pre>
+    new Date(dateString)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>dateString</code></dt>
- <dd>Une chaine de caractères représentant une date dans une version simplifiéee d'ISO 8601 (d'autres formats peuvent être utilisés mais les résultats ne sont pas garantis).</dd>
-</dl>
+- `dateString`
+  - : Une chaine de caractères représentant une date dans une version simplifiéee d'ISO 8601 (d'autres formats peuvent être utilisés mais les résultats ne sont pas garantis).
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un nombre correspondant au nombre de millisecondes écoulées entre le premier janvier 1970 à minuit UTC et la date indiquée en argument sous la forme d'une chaîne de caractères. Si l'argument ne permet pas de décrire une date valide, c'est {{jsxref("NaN")}} qui sera renvoyé.</p>
+Un nombre correspondant au nombre de millisecondes écoulées entre le premier janvier 1970 à minuit UTC et la date indiquée en argument sous la forme d'une chaîne de caractères. Si l'argument ne permet pas de décrire une date valide, c'est {{jsxref("NaN")}} qui sera renvoyé.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La méthode <code>parse</code> prend en argument une chaine de caractères contenant une date en paramètre (comme "<code>Dec 25, 1995</code>") et renvoie le nombre de millièmes de secondes depuis le 1er janvier 1970, 00:00:00 UTC. Cette fonction est utile pour définir des valeurs de dates à partir de représentations textuelles, par exemple en conjonction avec la méthode {{jsxref("Objets_globaux/Date/setTime", "setTime()")}} et l'objet {{jsxref("Objets_globaux/Date", "Date")}}.</p>
+La méthode `parse` prend en argument une chaine de caractères contenant une date en paramètre (comme "`Dec 25, 1995`") et renvoie le nombre de millièmes de secondes depuis le 1er janvier 1970, 00:00:00 UTC. Cette fonction est utile pour définir des valeurs de dates à partir de représentations textuelles, par exemple en conjonction avec la méthode {{jsxref("Objets_globaux/Date/setTime", "setTime()")}} et l'objet {{jsxref("Objets_globaux/Date", "Date")}}.
 
-<h3 id="Format_de_la_chaîne_de_caractères">Format de la chaîne de caractères</h3>
+### Format de la chaîne de caractères
 
-<p>À partir d'une chaine de caractères représentant une date, <code>parse</code> renvoie une valeur de temps. La syntaxe acceptée est un format simplifié de la norme ISO 8601. On pourra par exemple utiliser <code>"2011-10-10"</code> (date uniquement), <code>"2011-10-10T14:48:00"</code> (date et heure) ou <code>"2011-10-10T14:48:00.000+09:00"</code> (date, heure, millisecondes et fuseau horaire).</p>
+À partir d'une chaine de caractères représentant une date, `parse` renvoie une valeur de temps. La syntaxe acceptée est un format simplifié de la norme ISO 8601. On pourra par exemple utiliser `"2011-10-10"` (date uniquement), `"2011-10-10T14:48:00"` (date et heure) ou `"2011-10-10T14:48:00.000+09:00"` (date, heure, millisecondes et fuseau horaire).
 
-<p>Si aucun fuseau horaire n'est spécifié, les chaînes représentant uniquement des dates seront considérées comme UTC et les dates / heures seront considérées comme locales.</p>
+Si aucun fuseau horaire n'est spécifié, les chaînes représentant uniquement des dates seront considérées comme UTC et les dates / heures seront considérées comme locales.
 
-<p>Lorsque des indicateurs de fuseau horaire sont utilisés, la valeur renvoyée correspondra toujours au nombre de millisecondes écoulées entre l'argument et le premier janvier 1970 à minuit UTC.</p>
+Lorsque des indicateurs de fuseau horaire sont utilisés, la valeur renvoyée correspondra toujours au nombre de millisecondes écoulées entre l'argument et le premier janvier 1970 à minuit UTC.
 
-<p><code>parse()</code> est une méthode statique de {{jsxref("Date")}} et on invoquera ainsi <code>Date.parse()</code> plutôt que <code>parse()</code> sur une instance d'un objet <code>Date</code>.</p>
+`parse()` est une méthode statique de {{jsxref("Date")}} et on invoquera ainsi `Date.parse()` plutôt que `parse()` sur une instance d'un objet `Date`.
 
-<h3 id="Différences_entre_les_fuseaux_horaires_supposés">Différences entre les fuseaux horaires supposés</h3>
+### Différences entre les fuseaux horaires supposés
 
-<p>Avec une chaîne comme <code>"March 7, 2014"</code>, <code>parse()</code> supposera un fuseau horaire local, avec une chaîne au format ISO comme <code>"2014-03-07"</code>, la méthode supposera un fuseau horaire UTC en ES5 et un fuseau horaire local pour ECMAScript 2015. Ainsi les objets {{jsxref("Date")}} construits avec ces chaînes représenteront des instants différents, sauf si le fuseau horaire local du système utilisé correspond à UTC. Cela signifie que deux dates représentées de façon textuelles semblables peuvent donner des dates différentes (ce comportement doit être corrigé avec ECMAScript 6 afin que les deux dates soient traitées de façon locale).</p>
+Avec une chaîne comme `"March 7, 2014"`, `parse()` supposera un fuseau horaire local, avec une chaîne au format ISO comme `"2014-03-07"`, la méthode supposera un fuseau horaire UTC en ES5 et un fuseau horaire local pour ECMAScript 2015. Ainsi les objets {{jsxref("Date")}} construits avec ces chaînes représenteront des instants différents, sauf si le fuseau horaire local du système utilisé correspond à UTC. Cela signifie que deux dates représentées de façon textuelles semblables peuvent donner des dates différentes (ce comportement doit être corrigé avec ECMAScript 6 afin que les deux dates soient traitées de façon locale).
 
-<h3 id="Traitement_laissé_libre_à_limplémentation">Traitement laissé libre à l'implémentation</h3>
+### Traitement laissé libre à l'implémentation
 
-<p>Le standard ECMAScript dicte que si la chaîne utilisée n'est pas conforme au format standard, alors la fonction peut utiliser une heuristique et/ou un algorithme d'analyse de texte propre à l'implémentation. Les chaînes impossibles à décoder et/ou qui contiennent des éléments non-conformes aux formats ISO doivent renvoyer {{jsxref("NaN")}} lors de l'appel à <code>Date.parse()</code>.</p>
+Le standard ECMAScript dicte que si la chaîne utilisée n'est pas conforme au format standard, alors la fonction peut utiliser une heuristique et/ou un algorithme d'analyse de texte propre à l'implémentation. Les chaînes impossibles à décoder et/ou qui contiennent des éléments non-conformes aux formats ISO doivent renvoyer {{jsxref("NaN")}} lors de l'appel à `Date.parse()`.
 
-<p>Cependant, les valeurs invalides qui ne sont pas reconnues dans un format ISO pris en charge par ECMA-262 peuvent ou non engendrer la valeur {{jsxref("NaN")}} selon le navigateur et les valeurs utilisées. Par exemple :</p>
+Cependant, les valeurs invalides qui ne sont pas reconnues dans un format ISO pris en charge par ECMA-262 peuvent ou non engendrer la valeur {{jsxref("NaN")}} selon le navigateur et les valeurs utilisées. Par exemple :
 
-<pre class="brush: js notranslate">// Chaîne non ISO avec des valeurs invalides
-new Date('23/25/2014');</pre>
+```js
+// Chaîne non ISO avec des valeurs invalides
+new Date('23/25/2014');
+```
 
-<p>sera traitée comme la date locale du 25 novembre 2015 avec Firefox 30 et comme invalide avec Safari 7. Cependant, si la chaîne est reconnue dans un format ISO mais contient des valeurs invalides, la méthode renverra {{jsxref("NaN")}} pour tous les navigateurs conformes à ES5 (ou aux versions ultérieures) :</p>
+sera traitée comme la date locale du 25 novembre 2015 avec Firefox 30 et comme invalide avec Safari 7. Cependant, si la chaîne est reconnue dans un format ISO mais contient des valeurs invalides, la méthode renverra {{jsxref("NaN")}} pour tous les navigateurs conformes à ES5 (ou aux versions ultérieures) :
 
-<pre class="brush: js notranslate">// Chaîne ISO avec des valeurs invalides new
+```js
+// Chaîne ISO avec des valeurs invalides new
 Date('2014-25-23').toISOString();
-// renvoie "RangeError: invalid date" pour les navigateurs ES5</pre>
+// renvoie "RangeError: invalid date" pour les navigateurs ES5
+```
 
-<p>L'implémentation spécifique de SpiderMonkey peut être trouvée dans le fichier <a href="https://dxr.mozilla.org/mozilla-central/source/js/src/jsdate.cpp?rev=64553c483cd1#889"><code>jsdate.cpp</code></a>. La chaîne <code>"10 06 2014"</code> est un exemple de chaîne non ISO, utiliser parse() sur cette chaîne entraînera le moteur JavaScript à utiliser son implémentation de recours. Voir ce <a href="https://bugzilla.mozilla.org/show_bug.cgi?id=1023155#c6">bug</a> pour une explication rapide de la façon dont est faite l'analyse de la chaîne.</p>
+L'implémentation spécifique de SpiderMonkey peut être trouvée dans le fichier [`jsdate.cpp`](https://dxr.mozilla.org/mozilla-central/source/js/src/jsdate.cpp?rev=64553c483cd1#889). La chaîne `"10 06 2014"` est un exemple de chaîne non ISO, utiliser parse() sur cette chaîne entraînera le moteur JavaScript à utiliser son implémentation de recours. Voir ce [bug](https://bugzilla.mozilla.org/show_bug.cgi?id=1023155#c6) pour une explication rapide de la façon dont est faite l'analyse de la chaîne.
 
-<pre class="brush: js notranslate">new Date('10 06 2014');</pre>
+```js
+new Date('10 06 2014');
+```
 
-<p>sera traitée comme la date locale du 6 octobre 2014 et non comme le 10 juin 2014. D'autres exemples :</p>
+sera traitée comme la date locale du 6 octobre 2014 et non comme le 10 juin 2014. D'autres exemples :
 
-<pre class="brush: js notranslate">new Date('toto-truc 2014').toString();
+```js
+new Date('toto-truc 2014').toString();
 // renvoie : "Invalid Date"
 Date.parse('toto-truc 2014');
-// renvoie : NaN</pre>
+// renvoie : NaN
+```
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_Date.parse">Utiliser <code>Date.parse()</code></h3>
+### Utiliser `Date.parse()`
 
-<p>Les appels suivants renvoient tous <code>1546300800000</code>. Dans le premier appel, on indique uniquement la date (et donc le fuseau UTC implicite). Les chaînes qui suivent utilisent une indication de fuseau horaire selon la norme ISO (<code>Z</code> et <code>+00:00</code>)</p>
+Les appels suivants renvoient tous `1546300800000`. Dans le premier appel, on indique uniquement la date (et donc le fuseau UTC implicite). Les chaînes qui suivent utilisent une indication de fuseau horaire selon la norme ISO (`Z` et `+00:00`)
 
-<pre class="brush: js notranslate">Date.parse("2019-01-01")
+```js
+Date.parse("2019-01-01")
 Date.parse("2019-01-01T00:00:00.000Z")
 Date.parse("2019-01-01T00:00:00.000+00:00")
-</pre>
+```
 
-<p>L'appel suivant, qui ne précise pas le fuseau horaire, fournira le nombre de millisecondes écoulées entre le premier janvier 1970 minuit UTC et le premier janvier 2019 à minuit selon l'heure locale du système utilisé.</p>
+L'appel suivant, qui ne précise pas le fuseau horaire, fournira le nombre de millisecondes écoulées entre le premier janvier 1970 minuit UTC et le premier janvier 2019 à minuit selon l'heure locale du système utilisé.
 
-<pre class="brush: js notranslate">Date.parse("2019-01-01T00:00:00")
-</pre>
+```js
+Date.parse("2019-01-01T00:00:00")
+```
 
-<h3 id="Chaînes_de_caractères_non-standard">Chaînes de caractères non-standard</h3>
+### Chaînes de caractères non-standard
 
-<div class="blockIndicator note">
-<p><strong>Note :</strong> Cette section contient des exemples qui reposent sur des comportements spécifiques aux implémentations et on peut donc avoir des incohérences entre les moteurs utilisés.</p>
-</div>
+> **Note :** Cette section contient des exemples qui reposent sur des comportements spécifiques aux implémentations et on peut donc avoir des incohérences entre les moteurs utilisés.
 
-<p>Si <code>IPOdate</code> est un objet {{jsxref("Date")}}, on peut définir sa valeur au 9 août 1995 (heure locale), de la façon suivante :</p>
+Si `IPOdate` est un objet {{jsxref("Date")}}, on peut définir sa valeur au 9 août 1995 (heure locale), de la façon suivante :
 
-<pre class="brush: js notranslate">IPOdate.setTime(Date.parse('Aug 9, 1995'));
-</pre>
+```js
+IPOdate.setTime(Date.parse('Aug 9, 1995'));
+```
 
-<p>Voici un autre exemple avec une chaîne qui ne suit pas le format standard.</p>
+Voici un autre exemple avec une chaîne qui ne suit pas le format standard.
 
-<pre class="brush: js notranslate">Date.parse('Aug 9, 1995');
-</pre>
+```js
+Date.parse('Aug 9, 1995');
+```
 
-<p>Cette méthode renverra <code>807937200000</code> pour le fuseau horaire GMT-0300 et d'autres valeurs pour d'autres fuseaux car la chaîne n'indique pas le fuseau horaire et ne respecte pas le format ISO (le fuseau considéré par défaut est donc le fuseau local).</p>
+Cette méthode renverra `807937200000` pour le fuseau horaire GMT-0300 et d'autres valeurs pour d'autres fuseaux car la chaîne n'indique pas le fuseau horaire et ne respecte pas le format ISO (le fuseau considéré par défaut est donc le fuseau local).
 
-<pre class="brush: js notranslate">Date.parse('Wed, 09 Aug 1995 00:00:00 GMT');
-</pre>
+```js
+Date.parse('Wed, 09 Aug 1995 00:00:00 GMT');
+```
 
-<p>Renvoie <code>807926400000</code> quel que soit le fuseau local car on indique GMT.</p>
+Renvoie `807926400000` quel que soit le fuseau local car on indique GMT.
 
-<pre class="brush: js notranslate">Date.parse('Wed, 09 Aug 1995 00:00:00');
-</pre>
+```js
+Date.parse('Wed, 09 Aug 1995 00:00:00');
+```
 
-<p>Renvoie <code>807937200000</code> dans le fuseau GMT-0300 et d'autres valeurs pour d'autres fuseaux car aucune indication de fuseau n'est fournie et que la chaîne n'est pas au format ISO, elle est donc traitée comme un temps local.</p>
+Renvoie `807937200000` dans le fuseau GMT-0300 et d'autres valeurs pour d'autres fuseaux car aucune indication de fuseau n'est fournie et que la chaîne n'est pas au format ISO, elle est donc traitée comme un temps local.
 
-<pre class="brush: js notranslate">Date.parse('Thu, 01 Jan 1970 00:00:00 GMT');
-</pre>
+```js
+Date.parse('Thu, 01 Jan 1970 00:00:00 GMT');
+```
 
-<p>Renvoie <code>0</code> quel que soit le fuseau local car l'indicateur GMT est fourni.</p>
+Renvoie `0` quel que soit le fuseau local car l'indicateur GMT est fourni.
 
-<pre class="brush: js notranslate">Date.parse('Thu, 01 Jan 1970 00:00:00');
-</pre>
+```js
+Date.parse('Thu, 01 Jan 1970 00:00:00');
+```
 
-<p>Renvoie <code>14400000</code> pour le fuseau GMT-0400 et d'autres valeurs dans d'autres fuseaux car aucune indication de fuseau n'est fournie et la chaîne n'est pas au format ISO, elle est donc traitée comme un temps local.</p>
+Renvoie `14400000` pour le fuseau GMT-0400 et d'autres valeurs dans d'autres fuseaux car aucune indication de fuseau n'est fournie et la chaîne n'est pas au format ISO, elle est donc traitée comme un temps local.
 
-<pre class="brush: js notranslate">Date.parse('Thu, 01 Jan 1970 00:00:00 GMT-0400');
-</pre>
+```js
+Date.parse('Thu, 01 Jan 1970 00:00:00 GMT-0400');
+```
 
-<p>Renvoie <code>14400000</code> quel que soit le fuseau car l'indicateur GMT est fourni.</p>
+Renvoie `14400000` quel que soit le fuseau car l'indicateur GMT est fourni.
 
-<h2 id="Spécifications">Spécifications</h2>
+## Spécifications
 
-<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.9.4.2', 'Date.parse')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td>Ajout du format ISO 8601 simplifié.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-date.parse', 'Date.parse')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-date.parse', 'Date.parse')}}</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.9.4.2', 'Date.parse')}}         | {{Spec2('ES5.1')}}     | Ajout du format ISO 8601 simplifié.                   |
+| {{SpecName('ES6', '#sec-date.parse', 'Date.parse')}}         | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-date.parse', 'Date.parse')}} | {{Spec2('ESDraft')}} |                                                       |
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.Date.parse")}}</p>
+{{Compat("javascript.builtins.Date.parse")}}
 
-<h2 id="Notes_de_compatibilité">Notes de compatibilité</h2>
+## Notes de compatibilité
 
-<ul>
- <li>À partir de Firefox 49 ({{geckoRelease(49)}}, l'interprétation des années exprimées sur deux chiffres est alignée avec Google Chrome (et non plus avec Internet Explorer). Désormais, les années exprimées sur deux chiffres et strictement inférieures à 50 seront considérées comme des années du XXIe siècle. Ainsi, <code>04/16/17</code> correspondait avant au 16 avril 1917 et correspond désormais au 16 avril 2017. Cela évite des problèmes d'interopérabilité et d'ambiguïté et cette méthode est recommandée par le format ISO 8601 (cf. {{bug(1265136)}}).</li>
- <li>Google Chrome acceptera une chaîne de caractères avec un nombre pour le paramètre <code>dateString</code>. Ainsi, si on exécute <code>!!Date.parse("42")</code> dans Firefox, on obtiendra <code>false</code> tandis que que Google Chrome donnera <code>true</code> car <code>"42"</code> sera interprété comme la date du premier janvier 2042.</li>
-</ul>
+- À partir de Firefox 49 ({{geckoRelease(49)}}, l'interprétation des années exprimées sur deux chiffres est alignée avec Google Chrome (et non plus avec Internet Explorer). Désormais, les années exprimées sur deux chiffres et strictement inférieures à 50 seront considérées comme des années du XXIe siècle. Ainsi, `04/16/17` correspondait avant au 16 avril 1917 et correspond désormais au 16 avril 2017. Cela évite des problèmes d'interopérabilité et d'ambiguïté et cette méthode est recommandée par le format ISO 8601 (cf. {{bug(1265136)}}).
+- Google Chrome acceptera une chaîne de caractères avec un nombre pour le paramètre `dateString`. Ainsi, si on exécute `!!Date.parse("42")` dans Firefox, on obtiendra `false` tandis que que Google Chrome donnera `true` car `"42"` sera interprété comme la date du premier janvier 2042.
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("Date.UTC()")}}</li>
-</ul>
+- {{jsxref("Date.UTC()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/date/setdate/index.md b/files/fr/web/javascript/reference/global_objects/date/setdate/index.md
index 7091ece853..01ebb5094c 100644
--- a/files/fr/web/javascript/reference/global_objects/date/setdate/index.md
+++ b/files/fr/web/javascript/reference/global_objects/date/setdate/index.md
@@ -10,86 +10,61 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Date/setDate
 original_slug: Web/JavaScript/Reference/Objets_globaux/Date/setDate
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>setDate()</strong></code> définit le jour du mois (relatif au début du mois courant) pour une date donnée.</p>
+La méthode **`setDate()`** définit le jour du mois (relatif au début du mois courant) pour une date donnée.
 
-<div>{{EmbedInteractiveExample("pages/js/date-setdate.html")}}</div>
+{{EmbedInteractiveExample("pages/js/date-setdate.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>dateObj</var>.setDate(valeurJour)</pre>
+    dateObj.setDate(valeurJour)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>valeurJour</code></dt>
- <dd>Un entier représentant le jour du mois.</dd>
-</dl>
+- `valeurJour`
+  - : Un entier représentant le jour du mois.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Le nombre de millisecondes écoulées entre le premier janvier 1970 00:00:00 UTC et la date résultante (l'objet {{jsxref("Date")}} est également modifié).</p>
+Le nombre de millisecondes écoulées entre le premier janvier 1970 00:00:00 UTC et la date résultante (l'objet {{jsxref("Date")}} est également modifié).
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Si la <code>valeurJour</code> est en dehors des limites du mois courant, <code>setDate()</code> mettra à jour l'objet<code> </code>{{jsxref("Date")}} en conséquence.</p>
+Si la `valeurJour` est en dehors des limites du mois courant, `setDate()` mettra à jour l'objet` `{{jsxref("Date")}} en conséquence.
 
-<p>Par exemple, si 0 est fourni pour <code>valeurJour</code>, la date sera défini sur le dernier jour du mois précédent.</p>
+Par exemple, si 0 est fourni pour `valeurJour`, la date sera défini sur le dernier jour du mois précédent.
 
-<p>Si on fournit un nombre négatif, la date sera déterminée à rebours à partir du dernier jour du mois précédent. Ainsi, avec -1, on obtiendrait la veille du dernier jour du mois précédent.</p>
+Si on fournit un nombre négatif, la date sera déterminée à rebours à partir du dernier jour du mois précédent. Ainsi, avec -1, on obtiendrait la veille du dernier jour du mois précédent.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_setDate()">Utiliser <code>setDate()</code></h3>
+### Utiliser `setDate()`
 
-<pre class="brush:js">var theBigDay = new Date(1962, 6, 7); // 1962-07-06T23:00:00.000Z
+```js
+var theBigDay = new Date(1962, 6, 7); // 1962-07-06T23:00:00.000Z
 theBigDay.setDate(24);   // 1962-07-23T23:00:00.000Z
 theBigDay.setDate(32);   // 1962-07-31T23:00:00.000Z
 theBigDay.setDate(22);   // 1962-08-21T23:00:00.000Z
 theBigDay.setDate(0);    // 1962-07-30T23:00:00.000Z
 theBigDay.setDate(98);   // 1962-10-05T23:00:00.000Z
-theBigDay.setDate(-50);  // 1962-08-10T23:00:00.000Z</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.0.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.9.5.36', 'Date.prototype.setDate')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-date.prototype.setdate', 'Date.prototype.setDate')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-date.prototype.setdate', 'Date.prototype.setDate')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Date.setDate")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Date.prototype.getDate()")}}</li>
- <li>{{jsxref("Date.prototype.setUTCDate()")}}</li>
-</ul>
+theBigDay.setDate(-50);  // 1962-08-10T23:00:00.000Z
+```
+
+## 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.9.5.36', 'Date.prototype.setDate')}}                     | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-date.prototype.setdate', 'Date.prototype.setDate')}}         | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-date.prototype.setdate', 'Date.prototype.setDate')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Date.setDate")}}
+
+## Voir aussi
+
+- {{jsxref("Date.prototype.getDate()")}}
+- {{jsxref("Date.prototype.setUTCDate()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/date/setfullyear/index.md b/files/fr/web/javascript/reference/global_objects/date/setfullyear/index.md
index 5c08f44347..c5ce1547e4 100644
--- a/files/fr/web/javascript/reference/global_objects/date/setfullyear/index.md
+++ b/files/fr/web/javascript/reference/global_objects/date/setfullyear/index.md
@@ -10,85 +10,59 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Date/setFullYear
 original_slug: Web/JavaScript/Reference/Objets_globaux/Date/setFullYear
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>setFullYear()</strong></code> définit l'année complête pour une date, d'après l'heure locale.</p>
+La méthode **`setFullYear()`** définit l'année complête pour une date, d'après l'heure locale.
 
-<div>{{EmbedInteractiveExample("pages/js/date-setfullyear.html")}}</div>
+{{EmbedInteractiveExample("pages/js/date-setfullyear.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>dateObj</var>.setFullYear(valeurAnnée[, valeurMois[, valeurJour]])</pre>
+    dateObj.setFullYear(valeurAnnée[, valeurMois[, valeurJour]])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>valeurAnnée</code></dt>
- <dd>Un entier indiquant la valeur numérique de l'année, par exemple, 1995.</dd>
- <dt><code>valeurMois</code></dt>
- <dd>Paramètre optionnel qui représente un entier entre 0 et 11, représentant les mois de janvier à décembre.</dd>
- <dt><code>valeurJour</code></dt>
- <dd>Paramètre optionnel qui représente un entier entre 1 et 31 représentant le jour du mois. Si vous indiquez une <code>valeurJour</code>, vous devez aussi indiquer <code>valeurMois</code>.</dd>
-</dl>
+- `valeurAnnée`
+  - : Un entier indiquant la valeur numérique de l'année, par exemple, 1995.
+- `valeurMois`
+  - : Paramètre optionnel qui représente un entier entre 0 et 11, représentant les mois de janvier à décembre.
+- `valeurJour`
+  - : Paramètre optionnel qui représente un entier entre 1 et 31 représentant le jour du mois. Si vous indiquez une `valeurJour`, vous devez aussi indiquer `valeurMois`.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Le nombre de millisecondes écoulées entre le premier janvier 1970 à minuit UTC et la date mise à jour.</p>
+Le nombre de millisecondes écoulées entre le premier janvier 1970 à minuit UTC et la date mise à jour.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Si vous n'indiquez pas les paramètres <code>valeurMois</code> et <code>valeurJour</code>. Les valeurs renvoyées par les méthodes {{jsxref("Date.prototype.getMonth()", "getMonth()")}} et {{jsxref("Date.prototype.getDate()", "getDate()")}} seront utilisées.</p>
+Si vous n'indiquez pas les paramètres `valeurMois` et `valeurJour`. Les valeurs renvoyées par les méthodes {{jsxref("Date.prototype.getMonth()", "getMonth()")}} et {{jsxref("Date.prototype.getDate()", "getDate()")}} seront utilisées.
 
-<p>Si un des paramètres que vous indiquez est en dehors des limites attendues, <code>setFullYear()</code> tentera de mettre à jour la date en conséquence. Pa exemple, si vous indiquez 15 pour <code>valeurMois</code>, l'année sera incrémenté de 1 (année + 1), et 3 sera utilisé pour le mois.</p>
+Si un des paramètres que vous indiquez est en dehors des limites attendues, `setFullYear()` tentera de mettre à jour la date en conséquence. Pa exemple, si vous indiquez 15 pour `valeurMois`, l'année sera incrémenté de 1 (année + 1), et 3 sera utilisé pour le mois.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_setFullYear()">Utiliser <code>setFullYear()</code></h3>
+### Utiliser `setFullYear()`
 
-<pre class="brush:js">var leGrandJour = new Date();
+```js
+var leGrandJour = new Date();
 leGrandJour.setFullYear(1997);
-</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. Implémentée avec JavaScript 1.3.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.9.5.40', 'Date.prototype.setFullYear')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-date.prototype.setfullyear', 'Date.prototype.setFullYear')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-date.prototype.setfullyear', 'Date.prototype.setFullYear')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Date.setFullYear")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Date.prototype.getUTCFullYear()")}}</li>
- <li>{{jsxref("Date.prototype.setUTCFullYear()")}}</li>
- <li>{{jsxref("Date.prototype.setYear()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                        | Statut                       | Commentaires                                          |
+| -------------------------------------------------------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- |
+| {{SpecName('ES1')}}                                                                                             | {{Spec2('ES1')}}         | Définition initiale. Implémentée avec JavaScript 1.3. |
+| {{SpecName('ES5.1', '#sec-15.9.5.40', 'Date.prototype.setFullYear')}}                         | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-date.prototype.setfullyear', 'Date.prototype.setFullYear')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-date.prototype.setfullyear', 'Date.prototype.setFullYear')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Date.setFullYear")}}
+
+## Voir aussi
+
+- {{jsxref("Date.prototype.getUTCFullYear()")}}
+- {{jsxref("Date.prototype.setUTCFullYear()")}}
+- {{jsxref("Date.prototype.setYear()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/date/sethours/index.md b/files/fr/web/javascript/reference/global_objects/date/sethours/index.md
index a2823e19d0..0571dbdf8b 100644
--- a/files/fr/web/javascript/reference/global_objects/date/sethours/index.md
+++ b/files/fr/web/javascript/reference/global_objects/date/sethours/index.md
@@ -10,91 +10,64 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Date/setHours
 original_slug: Web/JavaScript/Reference/Objets_globaux/Date/setHours
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>setHours()</strong></code> définit les heures pour une date donnée, selon l'heure locale, et renvoie le nombre de millièmes de secondes écoulées entre le 1er janvier 1970 00:00:00 UTC et la nouvelle date mise à jour.</p>
+La méthode **`setHours()`** définit les heures pour une date donnée, selon l'heure locale, et renvoie le nombre de millièmes de secondes écoulées entre le 1er janvier 1970 00:00:00 UTC et la nouvelle date mise à jour.
 
-<div>{{EmbedInteractiveExample("pages/js/date-sethours.html")}}</div>
+{{EmbedInteractiveExample("pages/js/date-sethours.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">dateObj.setHours(valeurHeures[, valeurMinutes[, valeurSecondes[, valeurMs]]])
-</pre>
+    dateObj.setHours(valeurHeures[, valeurMinutes[, valeurSecondes[, valeurMs]]])
 
-<h3 id="Versions_antérieures_à_JavaScript_1.3">Versions antérieures à JavaScript 1.3</h3>
+### Versions antérieures à JavaScript 1.3
 
-<pre class="syntaxbox">dateObj.setHours(valeurHeures)</pre>
+    dateObj.setHours(valeurHeures)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>valeurHeures</code></dt>
- <dd>Un entier normalement compris entre 0 et 23, représentant l'heure. Si la valeur est supérieure à 23, la valeur de l'heure sera incrémentée d'autant d'heures supplémentaires.</dd>
- <dt><code>valeurMinutes</code></dt>
- <dd>Paramètre optionnel, un entier normalement compris entre 0 et 59, représentant les minutes. Si la valeur est supérieure à 59, la valeur de l'heure sera incrémentée d'autant de minutes supplémentaires.</dd>
- <dt><code>valeurSecondes</code></dt>
- <dd>Paramètre optionnel, un entier normalement compris entre 0 et 59, représentant les secondes. Si vous indiquez le paramètre <code>valeurSecondes</code>, vous devez aussi renseigner <code>valeurMinutes</code>. Si la valeur est supérieure à 59, l'heure sera incrémentée d'autant de secondes supplémentaires.</dd>
- <dt><code>valeurMs</code></dt>
- <dd>Paramètre optionnel, un entier normalement compris entre 0 et 999, représentant les millièmes de secondes. Si vous indiquez <code>valeurMs</code>, vous devez aussi renseigner <code>valeurMinutes</code> et <code>valeurSecondes</code>. Si la valeur fournie est supérieure à 999, l'heure sera incrémentée d'autant de millisecondes supplémentaires.</dd>
-</dl>
+- `valeurHeures`
+  - : Un entier normalement compris entre 0 et 23, représentant l'heure. Si la valeur est supérieure à 23, la valeur de l'heure sera incrémentée d'autant d'heures supplémentaires.
+- `valeurMinutes`
+  - : Paramètre optionnel, un entier normalement compris entre 0 et 59, représentant les minutes. Si la valeur est supérieure à 59, la valeur de l'heure sera incrémentée d'autant de minutes supplémentaires.
+- `valeurSecondes`
+  - : Paramètre optionnel, un entier normalement compris entre 0 et 59, représentant les secondes. Si vous indiquez le paramètre `valeurSecondes`, vous devez aussi renseigner `valeurMinutes`. Si la valeur est supérieure à 59, l'heure sera incrémentée d'autant de secondes supplémentaires.
+- `valeurMs`
+  - : Paramètre optionnel, un entier normalement compris entre 0 et 999, représentant les millièmes de secondes. Si vous indiquez `valeurMs`, vous devez aussi renseigner `valeurMinutes` et `valeurSecondes`. Si la valeur fournie est supérieure à 999, l'heure sera incrémentée d'autant de millisecondes supplémentaires.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Le nombre de millisecondes écoulées entre le premier janvier 1970 à minuit, UTC et la date mise à jour.</p>
+Le nombre de millisecondes écoulées entre le premier janvier 1970 à minuit, UTC et la date mise à jour.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Si vous ne renseignez pas <code>valeurMinutes</code>, <code>valeurSecondes</code> et <code>valeurMs</code>, les valeurs renvoyées par les méthodes {{jsxref("Date.getMinutes", "getMinutes()")}}, {{jsxref("Date.getSeconds", "getSeconds()")}}, et {{jsxref("Date.getMilliseconds", "getMilliseconds()")}} seront utilisées.</p>
+Si vous ne renseignez pas `valeurMinutes`, `valeurSecondes` et `valeurMs`, les valeurs renvoyées par les méthodes {{jsxref("Date.getMinutes", "getMinutes()")}}, {{jsxref("Date.getSeconds", "getSeconds()")}}, et {{jsxref("Date.getMilliseconds", "getMilliseconds()")}} seront utilisées.
 
-<p>Si un des paramètres que vous renseignez est en dehors des limites attendues, <code>setHours()</code> tentera de mettre à jour la date en conséquence. Par exemple, si vous utilisez 100 pour <code>valeurSecondes</code>, les minutes seront incrémentées de 1 (min + 1), et 40 sera utilisé pour les secondes.</p>
+Si un des paramètres que vous renseignez est en dehors des limites attendues, `setHours()` tentera de mettre à jour la date en conséquence. Par exemple, si vous utilisez 100 pour `valeurSecondes`, les minutes seront incrémentées de 1 (min + 1), et 40 sera utilisé pour les secondes.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_setHours()">Utiliser <code>setHours()</code></h3>
+### Utiliser `setHours()`
 
-<pre class="brush:js">var leGrandJour = new Date();
+```js
+var leGrandJour = new Date();
 leGrandJour.setHours(7);
-</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.0</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.9.5.34', 'Date.prototype.setHours')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-date.prototype.sethours', 'Date.prototype.setHours')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-date.prototype.sethours', 'Date.prototype.setHours')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Date.setHours")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Date.prototype.getHours()")}}</li>
- <li>{{jsxref("Date.prototype.setUTCHours()")}}</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.9.5.34', 'Date.prototype.setHours')}}                     | {{Spec2('ES5.1')}}     |                                                      |
+| {{SpecName('ES6', '#sec-date.prototype.sethours', 'Date.prototype.setHours')}}     | {{Spec2('ES6')}}         |                                                      |
+| {{SpecName('ESDraft', '#sec-date.prototype.sethours', 'Date.prototype.setHours')}} | {{Spec2('ESDraft')}} |                                                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Date.setHours")}}
+
+## Voir aussi
+
+- {{jsxref("Date.prototype.getHours()")}}
+- {{jsxref("Date.prototype.setUTCHours()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/date/setmilliseconds/index.md b/files/fr/web/javascript/reference/global_objects/date/setmilliseconds/index.md
index 472eb7e43e..e6ab186569 100644
--- a/files/fr/web/javascript/reference/global_objects/date/setmilliseconds/index.md
+++ b/files/fr/web/javascript/reference/global_objects/date/setmilliseconds/index.md
@@ -10,78 +10,52 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Date/setMilliseconds
 original_slug: Web/JavaScript/Reference/Objets_globaux/Date/setMilliseconds
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>setMilliseconds()</strong></code> définit les millièmes de secondes pour la date, selon l'heure locale.</p>
+La méthode **`setMilliseconds()`** définit les millièmes de secondes pour la date, selon l'heure locale.
 
-<div>{{EmbedInteractiveExample("pages/js/date-setmilliseconds.html")}}</div>
+{{EmbedInteractiveExample("pages/js/date-setmilliseconds.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>dateObj</var>.setMilliseconds(valeurMs)</pre>
+    dateObj.setMilliseconds(valeurMs)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>valeurMs</code></dt>
- <dd>Un entier entre 0 et 999, représentant les millièmes de secondes.</dd>
-</dl>
+- `valeurMs`
+  - : Un entier entre 0 et 999, représentant les millièmes de secondes.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Le nombre de millisecondes écoulées entre le premier janvier 1970 minuit, UTC et la date mise à jour.</p>
+Le nombre de millisecondes écoulées entre le premier janvier 1970 minuit, UTC et la date mise à jour.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Si vous indiquez un nombre en dehors des limites attendues, la date sera mise à jour en conséquence. Par exemple, si vous indiquez 1005, le nombre des secondes sera incrémenté de 1, et 5 sera utilisé pour les millièmes de secondes.</p>
+Si vous indiquez un nombre en dehors des limites attendues, la date sera mise à jour en conséquence. Par exemple, si vous indiquez 1005, le nombre des secondes sera incrémenté de 1, et 5 sera utilisé pour les millièmes de secondes.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_setMilliseconds()">Utiliser <code>setMilliseconds()</code></h3>
+### Utiliser `setMilliseconds()`
 
-<pre class="brush:js">var leGrandJour = new Date();
+```js
+var leGrandJour = new Date();
 leGrandJour.setMilliseconds(100);
-</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.3.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.9.5.28', 'Date.prototype.setMilliseconds')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-date.prototype.setmilliseconds', 'Date.prototype.setMilliseconds')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-date.prototype.setmilliseconds', 'Date.prototype.setMilliseconds')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Date.setMilliseconds")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Date.prototype.getMilliseconds()")}}</li>
- <li>{{jsxref("Date.prototype.setUTCMilliseconds()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                                    | État                         | Commentaires                                          |
+| -------------------------------------------------------------------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- |
+| {{SpecName('ES1')}}                                                                                                         | {{Spec2('ES1')}}         | Définition initiale. Implémentée avec JavaScript 1.3. |
+| {{SpecName('ES5.1', '#sec-15.9.5.28', 'Date.prototype.setMilliseconds')}}                                 | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-date.prototype.setmilliseconds', 'Date.prototype.setMilliseconds')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-date.prototype.setmilliseconds', 'Date.prototype.setMilliseconds')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Date.setMilliseconds")}}
+
+## Voir aussi
+
+- {{jsxref("Date.prototype.getMilliseconds()")}}
+- {{jsxref("Date.prototype.setUTCMilliseconds()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/date/setminutes/index.md b/files/fr/web/javascript/reference/global_objects/date/setminutes/index.md
index dfed490684..894474edac 100644
--- a/files/fr/web/javascript/reference/global_objects/date/setminutes/index.md
+++ b/files/fr/web/javascript/reference/global_objects/date/setminutes/index.md
@@ -10,88 +10,62 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Date/setMinutes
 original_slug: Web/JavaScript/Reference/Objets_globaux/Date/setMinutes
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>setMinutes()</strong></code> définit les minutes pour la date donnée, selon l'heure locale.</p>
+La méthode **`setMinutes()`** définit les minutes pour la date donnée, selon l'heure locale.
 
-<div>{{EmbedInteractiveExample("pages/js/date-setminutes.html")}}</div>
+{{EmbedInteractiveExample("pages/js/date-setminutes.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>dateObj</var>.setMinutes(valeurMinutes[, valeurSecondes[, valeurMs]])</pre>
+    dateObj.setMinutes(valeurMinutes[, valeurSecondes[, valeurMs]])
 
-<h3 id="Versions_antérieures_à_JavaScript_1.3">Versions antérieures à JavaScript 1.3</h3>
+### Versions antérieures à JavaScript 1.3
 
-<pre class="syntaxbox"><var>dateObj</var>.setMinutes(valeurMinutes)</pre>
+    dateObj.setMinutes(valeurMinutes)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>valeurMinutes</code></dt>
- <dd>Un entier entre 0 et 59, représentant les minutes.</dd>
- <dt><code>valeurSecondes</code></dt>
- <dd>Paramètre optionnel, un entier entre 0 et 59, représentant les secondes. Si <code>valeurSecondes</code> est utilisé, il faut également utiliser <code>valeurMinutes</code>.</dd>
- <dt><code>valeurMs</code></dt>
- <dd>Paramètre optionel, un nombre entre 0 et 999, représentant les millièmes de secondes. Si <code>valeurMs</code> est utilisé, il faut également utiliser <code>valeurMinutes</code> et <code>valeurSecondes</code>.</dd>
-</dl>
+- `valeurMinutes`
+  - : Un entier entre 0 et 59, représentant les minutes.
+- `valeurSecondes`
+  - : Paramètre optionnel, un entier entre 0 et 59, représentant les secondes. Si `valeurSecondes` est utilisé, il faut également utiliser `valeurMinutes`.
+- `valeurMs`
+  - : Paramètre optionel, un nombre entre 0 et 999, représentant les millièmes de secondes. Si `valeurMs` est utilisé, il faut également utiliser `valeurMinutes` et `valeurSecondes`.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Le nombre de millisecondes écoulées entre le premier janvier 1970 minuit, UTC et la date mise à jour.</p>
+Le nombre de millisecondes écoulées entre le premier janvier 1970 minuit, UTC et la date mise à jour.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Si <code>valeurSecondes</code> et <code>valeurMs</code> ne sont pas indiquées, les valeurs renvoyées par les méthodes {{jsxref("Date.getSeconds", "getSeconds()")}} et {{jsxref("Date.getMilliseconds", "getMilliseconds()")}} seront utilisées.</p>
+Si `valeurSecondes` et `valeurMs` ne sont pas indiquées, les valeurs renvoyées par les méthodes {{jsxref("Date.getSeconds", "getSeconds()")}} et {{jsxref("Date.getMilliseconds", "getMilliseconds()")}} seront utilisées.
 
-<p>Si un paramètre est en dehors des limites attendues, <code>setMinutes()</code> tentera de mettre à jour la date en conséquence. Par exemple, si on utilise la valeur 100 pour <code>valeurSecondes</code>, les minutes (<code>valeurMinutes</code>) seront incrémentées de 1 (<code>valeurMinutes</code> + 1), et 40 sera utilisé pour les secondes.</p>
+Si un paramètre est en dehors des limites attendues, `setMinutes()` tentera de mettre à jour la date en conséquence. Par exemple, si on utilise la valeur 100 pour `valeurSecondes`, les minutes (`valeurMinutes`) seront incrémentées de 1 (`valeurMinutes` + 1), et 40 sera utilisé pour les secondes.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_setMinutes()">Utiliser <code>setMinutes()</code></h3>
+### Utiliser `setMinutes()`
 
-<pre class="brush: js">var leGrandJour = new Date();
+```js
+var leGrandJour = new Date();
 leGrandJour.setMinutes(45);
-</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.0.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.9.5.32', 'Date.prototype.setMinutes')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-date.prototype.setminutes', 'Date.prototype.setMinutes')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-date.prototype.setminutes', 'Date.prototype.setMinutes')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Date.setMinutes")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Date.prototype.getMinutes()")}}</li>
- <li>{{jsxref("Date.prototype.setUTCMinutes()")}}</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.9.5.32', 'Date.prototype.setMinutes')}}                         | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-date.prototype.setminutes', 'Date.prototype.setMinutes')}}         | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-date.prototype.setminutes', 'Date.prototype.setMinutes')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Date.setMinutes")}}
+
+## Voir aussi
+
+- {{jsxref("Date.prototype.getMinutes()")}}
+- {{jsxref("Date.prototype.setUTCMinutes()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/date/setmonth/index.md b/files/fr/web/javascript/reference/global_objects/date/setmonth/index.md
index 08e81440aa..adaccb768d 100644
--- a/files/fr/web/javascript/reference/global_objects/date/setmonth/index.md
+++ b/files/fr/web/javascript/reference/global_objects/date/setmonth/index.md
@@ -10,95 +10,69 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Date/setMonth
 original_slug: Web/JavaScript/Reference/Objets_globaux/Date/setMonth
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>setMonth()</strong></code> définit le mois de la date, selon l'heure locale et l'année courante de l'objet {{jsxref("Date")}}</p>
+La méthode **`setMonth()`** définit le mois de la date, selon l'heure locale et l'année courante de l'objet {{jsxref("Date")}}
 
-<div>{{EmbedInteractiveExample("pages/js/date-setmonth.html")}}</div>
+{{EmbedInteractiveExample("pages/js/date-setmonth.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>dateObj</var>.setMonth(valeurMois[, valeurJour])</pre>
+    dateObj.setMonth(valeurMois[, valeurJour])
 
-<h3 id="Versions_antérieures_à_JavaScript_1.3">Versions antérieures à JavaScript 1.3</h3>
+### Versions antérieures à JavaScript 1.3
 
-<pre class="syntaxbox"><var>dateObj</var>.setMonth(valeurMois)</pre>
+    dateObj.setMonth(valeurMois)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>valeurMois</code></dt>
- <dd>Un entier entre 0 et 11 (représentant les mois de janvier à décembre).</dd>
- <dt><code>valeurJour</code></dt>
- <dd>Paramètre optionnel, un entier entre 1 et 31, représentant le jour du mois.</dd>
-</dl>
+- `valeurMois`
+  - : Un entier entre 0 et 11 (représentant les mois de janvier à décembre).
+- `valeurJour`
+  - : Paramètre optionnel, un entier entre 1 et 31, représentant le jour du mois.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Le nombre de millisecondes écoulées entre le premier janvier 1970 minuit, UTC et la date mise à jour.</p>
+Le nombre de millisecondes écoulées entre le premier janvier 1970 minuit, UTC et la date mise à jour.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Si le paramètre <code>valeurJour</code> n'est pas utilisé, la valeur renvoyée par la méthode {{jsxref("Date.getDate", "getDate()")}} sera utilisée.</p>
+Si le paramètre `valeurJour` n'est pas utilisé, la valeur renvoyée par la méthode {{jsxref("Date.getDate", "getDate()")}} sera utilisée.
 
-<p>Si un paramètre que vous renseignez n'est pas dans les limites attendues, <code>setMonth()</code> tentera de mettre à jour la date en conséquence. Par exemple, si la valeur 15 est utilisée pour <code>valeurMois</code>, l'année sera incrémenté de 1 (année + 1), et 3 sera utilisé pour le mois.</p>
+Si un paramètre que vous renseignez n'est pas dans les limites attendues, `setMonth()` tentera de mettre à jour la date en conséquence. Par exemple, si la valeur 15 est utilisée pour `valeurMois`, l'année sera incrémenté de 1 (année + 1), et 3 sera utilisé pour le mois.
 
-<div class="note">
-<p><strong>Note :</strong> Attention aux jours du mois lorsqu'on utilise <code>setMonth()</code>. En effet, <code>setMonth()</code> cherchera à aboutir à une date correcte et on peut avoir des surprises pour les transitions entre les mois. Ainsi, en 2016 (où février a eu 29 jours), on aura le cas suivant :</p>
+> **Note :** Attention aux jours du mois lorsqu'on utilise `setMonth()`. En effet, `setMonth()` cherchera à aboutir à une date correcte et on peut avoir des surprises pour les transitions entre les mois. Ainsi, en 2016 (où février a eu 29 jours), on aura le cas suivant :
+>
+> ```js
+> var finDuMois = new Date(2016, 7, 31); // le 31 août 2016
+> finDuMois.setMonth(1);
+>
+> console.log(finDuMois.toLocaleString()); // 02/03/2016 à 00:00:00
+> ```
 
-<pre class="brush: js">var finDuMois = new Date(2016, 7, 31); // le 31 août 2016
-finDuMois.setMonth(1);
+## Exemples
 
-console.log(finDuMois.toLocaleString()); // 02/03/2016 à 00:00:00</pre>
-</div>
+### Utiliser `setMonth()`
 
-<h2 id="Exemples">Exemples</h2>
+```js
+var leGrandJour = new Date();
+leGrandJour.setMonth(6);
+```
 
-<h3 id="Utiliser_setMonth()">Utiliser <code>setMonth()</code></h3>
+## Spécifications
 
-<pre class="brush: js">var leGrandJour = new Date();
-leGrandJour.setMonth(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. Implémentée avec JavaScript 1.0.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.9.5.38', 'Date.prototype.setMonth')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-date.prototype.setmonth', 'Date.prototype.setMonth')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-date.prototype.setmonth', 'Date.prototype.setMonth')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Date.setMonth")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Date.prototype.getMonth()")}}</li>
- <li>{{jsxref("Date.prototype.setUTCMonth()")}}</li>
-</ul>
+| Spécification                                                                                                | État                         | Commentaires                                          |
+| ------------------------------------------------------------------------------------------------------------ | ---------------------------- | ----------------------------------------------------- |
+| {{SpecName('ES1')}}                                                                                     | {{Spec2('ES1')}}         | Définition initiale. Implémentée avec JavaScript 1.0. |
+| {{SpecName('ES5.1', '#sec-15.9.5.38', 'Date.prototype.setMonth')}}                     | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-date.prototype.setmonth', 'Date.prototype.setMonth')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-date.prototype.setmonth', 'Date.prototype.setMonth')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Date.setMonth")}}
+
+## Voir aussi
+
+- {{jsxref("Date.prototype.getMonth()")}}
+- {{jsxref("Date.prototype.setUTCMonth()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/date/setseconds/index.md b/files/fr/web/javascript/reference/global_objects/date/setseconds/index.md
index b979885ed8..b6db54ba85 100644
--- a/files/fr/web/javascript/reference/global_objects/date/setseconds/index.md
+++ b/files/fr/web/javascript/reference/global_objects/date/setseconds/index.md
@@ -10,86 +10,60 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Date/setSeconds
 original_slug: Web/JavaScript/Reference/Objets_globaux/Date/setSeconds
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>setSeconds()</strong></code> définit les secondes pour la date, selon l'heure locale.</p>
+La méthode **`setSeconds()`** définit les secondes pour la date, selon l'heure locale.
 
-<div>{{EmbedInteractiveExample("pages/js/date-setseconds.html")}}</div>
+{{EmbedInteractiveExample("pages/js/date-setseconds.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>dateObj</var>.setSeconds(valeurSecondes[, valeurMs])</pre>
+    dateObj.setSeconds(valeurSecondes[, valeurMs])
 
-<h3 id="Versions_antérieures_à_JavaScript_1.3">Versions antérieures à JavaScript 1.3</h3>
+### Versions antérieures à JavaScript 1.3
 
-<pre class="syntaxbox"><var>dateObj</var>.setSeconds(valeurSecondes)</pre>
+    dateObj.setSeconds(valeurSecondes)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>valeurSecondes</code></dt>
- <dd>Un entier entre 0 et 59.</dd>
- <dt><code>valeurMs</code></dt>
- <dd>Paramètre optionnel, un nombre entre 0 et 999, représentant les millièmes de secondes.</dd>
-</dl>
+- `valeurSecondes`
+  - : Un entier entre 0 et 59.
+- `valeurMs`
+  - : Paramètre optionnel, un nombre entre 0 et 999, représentant les millièmes de secondes.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Le nombre de millisecondes écoulées entre le premier janvier 1970 minuit, UTC et la date mise à jour.</p>
+Le nombre de millisecondes écoulées entre le premier janvier 1970 minuit, UTC et la date mise à jour.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Si le paramètre <code>valeurMs</code> n'est pas utilisé, la valeur renvoyée par la méthode {{jsxref("Date.getMilliseconds", "getMilliseconds()")}} sera utilisée.</p>
+Si le paramètre `valeurMs` n'est pas utilisé, la valeur renvoyée par la méthode {{jsxref("Date.getMilliseconds", "getMilliseconds()")}} sera utilisée.
 
-<p>Si un paramètre utilisé est en dehors des limites attendues, <code>setSeconds()</code> tentera de mettre à jour la date en conséquence. Par exemple, si on utilise la valeur 100 pour <code>valeurSecondes</code>, les minutes de la date seront incrémentées de 1, et 40 sera utilisé pour les secondes.</p>
+Si un paramètre utilisé est en dehors des limites attendues, `setSeconds()` tentera de mettre à jour la date en conséquence. Par exemple, si on utilise la valeur 100 pour `valeurSecondes`, les minutes de la date seront incrémentées de 1, et 40 sera utilisé pour les secondes.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_setSeconds()">Utiliser <code>setSeconds()</code></h3>
+### Utiliser `setSeconds()`
 
-<pre class="brush:js">var leGrandJour = new Date();
+```js
+var leGrandJour = new Date();
 leGrandJour.setSeconds(30)
-</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.0.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.9.5.30', 'Date.prototype.setSeconds')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-date.prototype.setseconds', 'Date.prototype.setSeconds')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-date.prototype.setseconds', 'Date.prototype.setSeconds')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Date.setSeconds")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Date.prototype.getSeconds()")}}</li>
- <li>{{jsxref("Date.prototype.setUTCSeconds()")}}</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.9.5.30', 'Date.prototype.setSeconds')}}                         | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-date.prototype.setseconds', 'Date.prototype.setSeconds')}}         | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-date.prototype.setseconds', 'Date.prototype.setSeconds')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Date.setSeconds")}}
+
+## Voir aussi
+
+- {{jsxref("Date.prototype.getSeconds()")}}
+- {{jsxref("Date.prototype.setUTCSeconds()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/date/settime/index.md b/files/fr/web/javascript/reference/global_objects/date/settime/index.md
index 4318c595b4..01c26769a9 100644
--- a/files/fr/web/javascript/reference/global_objects/date/settime/index.md
+++ b/files/fr/web/javascript/reference/global_objects/date/settime/index.md
@@ -10,79 +10,53 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Date/setTime
 original_slug: Web/JavaScript/Reference/Objets_globaux/Date/setTime
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>setTime()</strong></code> met l'objet {{jsxref("Date")}} à jour par rapport au nombre de millisecondes depuis le 1 janvier 1970, 00:00:00 UTC.</p>
+La méthode **`setTime()`** met l'objet {{jsxref("Date")}} à jour par rapport au nombre de millisecondes depuis le 1 janvier 1970, 00:00:00 UTC.
 
-<div>{{EmbedInteractiveExample("pages/js/date-settime.html")}}</div>
+{{EmbedInteractiveExample("pages/js/date-settime.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>dateObj</var>.setTime(valeurTemps)</pre>
+    dateObj.setTime(valeurTemps)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>valeurTemps</code></dt>
- <dd>Un entier représentant le nombre de millisecondes depuis le 1 janvier 1970, 00:00:00 UTC.</dd>
-</dl>
+- `valeurTemps`
+  - : Un entier représentant le nombre de millisecondes depuis le 1 janvier 1970, 00:00:00 UTC.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Le nombre de millisecondes écoulées entre le premier janvier 1970 à minuit, UTC et la date mise à jour (ce qui correspond à la valeur de l'argument).</p>
+Le nombre de millisecondes écoulées entre le premier janvier 1970 à minuit, UTC et la date mise à jour (ce qui correspond à la valeur de l'argument).
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La méthode <code>setTime()</code> est utilisée afin d'assigner une date à un autre objet {{jsxref("Date")}}.</p>
+La méthode `setTime()` est utilisée afin d'assigner une date à un autre objet {{jsxref("Date")}}.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_setTime()">Utiliser <code>setTime()</code></h3>
+### Utiliser `setTime()`
 
-<pre class="brush: js">var leGrandJour = new Date("July 1, 1999");
+```js
+var leGrandJour = new Date("July 1, 1999");
 var pareilQueGrandJour = new Date();
 pareilQueGrandJour.setTime(leGrandJour.getTime());
-</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.0.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.9.5.27', 'Date.prototype.setTime')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-date.prototype.settime', 'Date.prototype.setTime')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-date.prototype.settime', 'Date.prototype.setTime')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Date.setTime")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Date.prototype.getTime()")}}</li>
- <li>{{jsxref("Date.prototype.setUTCHours()")}}</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.9.5.27', 'Date.prototype.setTime')}}                     | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-date.prototype.settime', 'Date.prototype.setTime')}}         | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-date.prototype.settime', 'Date.prototype.setTime')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Date.setTime")}}
+
+## Voir aussi
+
+- {{jsxref("Date.prototype.getTime()")}}
+- {{jsxref("Date.prototype.setUTCHours()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/date/setutcdate/index.md b/files/fr/web/javascript/reference/global_objects/date/setutcdate/index.md
index 98de0005b5..b2b6aa67a4 100644
--- a/files/fr/web/javascript/reference/global_objects/date/setutcdate/index.md
+++ b/files/fr/web/javascript/reference/global_objects/date/setutcdate/index.md
@@ -10,78 +10,52 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Date/setUTCDate
 original_slug: Web/JavaScript/Reference/Objets_globaux/Date/setUTCDate
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>setUTCDate()</strong></code> définit le jour du mois pour la date, selon UTC.</p>
+La méthode **`setUTCDate()`** définit le jour du mois pour la date, selon UTC.
 
-<div>{{EmbedInteractiveExample("pages/js/date-setutcdate.html")}}</div>
+{{EmbedInteractiveExample("pages/js/date-setutcdate.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>dateObj</var>.setUTCDate(valeurJour)</pre>
+    dateObj.setUTCDate(valeurJour)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>valeurJour</code></dt>
- <dd>Un entier de 1 à 31, représentant un jour dans le mois.</dd>
-</dl>
+- `valeurJour`
+  - : Un entier de 1 à 31, représentant un jour dans le mois.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Le nombre de millisecondes écoulées entre le premier janvier 1970 minuit, UTC et la date mise à jour.</p>
+Le nombre de millisecondes écoulées entre le premier janvier 1970 minuit, UTC et la date mise à jour.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Si le paramètre renseigné est en dehors des limites attendues, <code>setUTCDate()</code> tentera de mettre à jour la date en conséquence. Par exemple, si on utilise la valeur 40 pour <code>valeurJour</code>, et que le mois de la date est juin, le jour sera changé en 10 et le mois passera à juillet.</p>
+Si le paramètre renseigné est en dehors des limites attendues, `setUTCDate()` tentera de mettre à jour la date en conséquence. Par exemple, si on utilise la valeur 40 pour `valeurJour`, et que le mois de la date est juin, le jour sera changé en 10 et le mois passera à juillet.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_setUTCDate()">Utiliser <code>setUTCDate()</code></h3>
+### Utiliser `setUTCDate()`
 
-<pre class="brush: js">var leGrandJour = new Date();
+```js
+var leGrandJour = new Date();
 leGrandJour.setUTCDate(20);
-</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.3.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.9.5.37', 'Date.prototype.setUTCDate')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-date.prototype.setutcdate', 'Date.prototype.setUTCDate')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-date.prototype.setutcdate', 'Date.prototype.setUTCDate')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Date.setUTCDate")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Date.prototype.getUTCDate()")}}</li>
- <li>{{jsxref("Date.prototype.setDate()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                        | État                         | Commentaires                                          |
+| -------------------------------------------------------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- |
+| {{SpecName('ES1')}}                                                                                             | {{Spec2('ES1')}}         | Définition initiale. Implémentée avec JavaScript 1.3. |
+| {{SpecName('ES5.1', '#sec-15.9.5.37', 'Date.prototype.setUTCDate')}}                         | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-date.prototype.setutcdate', 'Date.prototype.setUTCDate')}}         | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-date.prototype.setutcdate', 'Date.prototype.setUTCDate')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Date.setUTCDate")}}
+
+## Voir aussi
+
+- {{jsxref("Date.prototype.getUTCDate()")}}
+- {{jsxref("Date.prototype.setDate()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/date/setutcfullyear/index.md b/files/fr/web/javascript/reference/global_objects/date/setutcfullyear/index.md
index beeedfb099..4490cf9d6a 100644
--- a/files/fr/web/javascript/reference/global_objects/date/setutcfullyear/index.md
+++ b/files/fr/web/javascript/reference/global_objects/date/setutcfullyear/index.md
@@ -10,84 +10,58 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Date/setUTCFullYear
 original_slug: Web/JavaScript/Reference/Objets_globaux/Date/setUTCFullYear
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>setUTCFullYear()</strong></code> définit l'année complête pour la date, selon UTC.</p>
+La méthode **`setUTCFullYear()`** définit l'année complête pour la date, selon UTC.
 
-<div>{{EmbedInteractiveExample("pages/js/date-setutcfullyear.html")}}</div>
+{{EmbedInteractiveExample("pages/js/date-setutcfullyear.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>dateObj</var>.setUTCFullYear(valeurAnnée[, valeurMois[, valeurJour]])</pre>
+    dateObj.setUTCFullYear(valeurAnnée[, valeurMois[, valeurJour]])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>valeurAnnée</code></dt>
- <dd>Un entier indiquant la valeur numérique d'une année, par exemple, 1995.</dd>
- <dt><code>valeurMois</code></dt>
- <dd>Paramètre optionnel, un entier entre 0 et 11 représentant les mois de janvier à décembre.</dd>
- <dt><code>valeurJour</code></dt>
- <dd>Paramètre optionnel, un entier entre 1 et 31 représentant le jour du mois. Si le paramètre <code>valeurJour</code> est utilisé, il est également nécessaire d'indiquer <code>valeurMois</code>.</dd>
-</dl>
+- `valeurAnnée`
+  - : Un entier indiquant la valeur numérique d'une année, par exemple, 1995.
+- `valeurMois`
+  - : Paramètre optionnel, un entier entre 0 et 11 représentant les mois de janvier à décembre.
+- `valeurJour`
+  - : Paramètre optionnel, un entier entre 1 et 31 représentant le jour du mois. Si le paramètre `valeurJour` est utilisé, il est également nécessaire d'indiquer `valeurMois`.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Le nombre de millisecondes écoulées entre le premier janvier 1970 minuit, UTC et la date mise à jour.</p>
+Le nombre de millisecondes écoulées entre le premier janvier 1970 minuit, UTC et la date mise à jour.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Si les paramètres <code>valeurMois</code> et <code>valeurJour</code> ne sont pas utilisés, les valeurs renvoyées par les méthodes {{jsxref("Objets_globaux/Date/getUTCMonth", "getUTCMonth()")}} et {{jsxref("Objets_globaux/Date/getUTCDate", "getUTCDate()")}} seront utilisées.</p>
+Si les paramètres `valeurMois` et `valeurJour` ne sont pas utilisés, les valeurs renvoyées par les méthodes {{jsxref("Objets_globaux/Date/getUTCMonth", "getUTCMonth()")}} et {{jsxref("Objets_globaux/Date/getUTCDate", "getUTCDate()")}} seront utilisées.
 
-<p>Si un des paramètres indiqué est en dehors des limites attendues, <code>setUTCFullYear()</code> tentera de mettre à jour la date en conséquence. Ainsi si on utilise la valeur 15 pour <code>valeurMois</code>, l'année sera incrémentée de 1 (année + 1), et 3 sera utilisé pour le mois.</p>
+Si un des paramètres indiqué est en dehors des limites attendues, `setUTCFullYear()` tentera de mettre à jour la date en conséquence. Ainsi si on utilise la valeur 15 pour `valeurMois`, l'année sera incrémentée de 1 (année + 1), et 3 sera utilisé pour le mois.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_setUTCFullYear()">Utiliser <code>setUTCFullYear()</code></h3>
+### Utiliser `setUTCFullYear()`
 
-<pre class="brush: js">var leGrandJour = new Date();
+```js
+var leGrandJour = new Date();
 leGrandJour.setUTCFullYear(1997);
-</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.3.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.9.5.41', 'Date.prototype.setUTCFullYear')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-date.prototype.setutcfullyear', 'Date.prototype.setUTCFullYear')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-date.prototype.setutcfullyear', 'Date.prototype.setUTCFullYear')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Date.setUTCFullYear")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Date.prototype.getUTCFullYear()")}}</li>
- <li>{{jsxref("Date.prototype.setFullYear()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                                | État                         | Commentaires                                          |
+| ---------------------------------------------------------------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- |
+| {{SpecName('ES1')}}                                                                                                     | {{Spec2('ES1')}}         | Définition initiale. Implémentée avec JavaScript 1.3. |
+| {{SpecName('ES5.1', '#sec-15.9.5.41', 'Date.prototype.setUTCFullYear')}}                             | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-date.prototype.setutcfullyear', 'Date.prototype.setUTCFullYear')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-date.prototype.setutcfullyear', 'Date.prototype.setUTCFullYear')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Date.setUTCFullYear")}}
+
+## Voir aussi
+
+- {{jsxref("Date.prototype.getUTCFullYear()")}}
+- {{jsxref("Date.prototype.setFullYear()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/date/setutchours/index.md b/files/fr/web/javascript/reference/global_objects/date/setutchours/index.md
index 038f330691..775990f78e 100644
--- a/files/fr/web/javascript/reference/global_objects/date/setutchours/index.md
+++ b/files/fr/web/javascript/reference/global_objects/date/setutchours/index.md
@@ -10,86 +10,60 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Date/setUTCHours
 original_slug: Web/JavaScript/Reference/Objets_globaux/Date/setUTCHours
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>setUTCHours()</strong></code> définit les heures pour la date, selon UTC, et renvoie le nombre de millièmes de secondes écoulées entre le 1er janvier 1970 00:00:00 UTC et cette nouvelle date.</p>
+La méthode **`setUTCHours()`** définit les heures pour la date, selon UTC, et renvoie le nombre de millièmes de secondes écoulées entre le 1er janvier 1970 00:00:00 UTC et cette nouvelle date.
 
-<div>{{EmbedInteractiveExample("pages/js/date-setutchours.html")}}</div>
+{{EmbedInteractiveExample("pages/js/date-setutchours.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>dateObj</var>.setUTCHours(valeurHeures[, valeurMinutes[, valeurSecondes[, valeurMs]]])</pre>
+    dateObj.setUTCHours(valeurHeures[, valeurMinutes[, valeurSecondes[, valeurMs]]])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>valeurHeures</code></dt>
- <dd>Un entier entre 0 et 23, représentant l'heure.</dd>
- <dt><code>valeurMinutes</code></dt>
- <dd>Paramètre optionnel, un entier entre 0 et 59, représentant les minutes.</dd>
- <dt><code>valeurSecondes</code></dt>
- <dd>Paramètre optionnel, un entier entre 0 et 59, représentant les secondes. Si le paramètre <code>valeurSecondes</code> est utilisé, le paramètre <code>valeurMinutes</code> devra également être renseigné.</dd>
- <dt><code>valeurMs</code></dt>
- <dd>Paramètre optionnel, un entier entre 0 et 999, représentant les millièmes de secondes. Si le paramètre <code>valeurMs</code> est utilisé, les paramètres <code>valeurMinutes</code> et <code>valeurSecondes</code> devront également être renseignés.</dd>
-</dl>
+- `valeurHeures`
+  - : Un entier entre 0 et 23, représentant l'heure.
+- `valeurMinutes`
+  - : Paramètre optionnel, un entier entre 0 et 59, représentant les minutes.
+- `valeurSecondes`
+  - : Paramètre optionnel, un entier entre 0 et 59, représentant les secondes. Si le paramètre `valeurSecondes` est utilisé, le paramètre `valeurMinutes` devra également être renseigné.
+- `valeurMs`
+  - : Paramètre optionnel, un entier entre 0 et 999, représentant les millièmes de secondes. Si le paramètre `valeurMs` est utilisé, les paramètres `valeurMinutes` et `valeurSecondes` devront également être renseignés.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Le nombre de millisecondes écoulées entre le premier janvier 1970 minuit, UTC et la date mise à jour.</p>
+Le nombre de millisecondes écoulées entre le premier janvier 1970 minuit, UTC et la date mise à jour.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Si les paramètres <code>valeurMinutes</code>, <code>valeurSecondes</code> et <code>valeurMs</code> ne sont pas renseignés, les valeurs renvoyées par les méthodes {{jsxref("Date.prototype.getUTCMinutes", "getUTCMinutes()")}}, {{jsxref("Date.prototype.getUTCSeconds", "getUTCSeconds()")}}, et {{jsxref("Date.prototype.getUTCMilliseconds", "getUTCMilliseconds()")}} seront utilisées.</p>
+Si les paramètres `valeurMinutes`, `valeurSecondes` et `valeurMs` ne sont pas renseignés, les valeurs renvoyées par les méthodes {{jsxref("Date.prototype.getUTCMinutes", "getUTCMinutes()")}}, {{jsxref("Date.prototype.getUTCSeconds", "getUTCSeconds()")}}, et {{jsxref("Date.prototype.getUTCMilliseconds", "getUTCMilliseconds()")}} seront utilisées.
 
-<p>Si un des paramètres renseignés est en dehors des limites attendues, <code>setUTCHours()</code> tentera de mettre à jour la date en conséquence. Par exemple, si on utilise la valeur 100 pour <code>valeurSecondes</code>, les minutes seront incrémentées de 1 (min + 1), et 40 sera utilisé pour les secondes.</p>
+Si un des paramètres renseignés est en dehors des limites attendues, `setUTCHours()` tentera de mettre à jour la date en conséquence. Par exemple, si on utilise la valeur 100 pour `valeurSecondes`, les minutes seront incrémentées de 1 (min + 1), et 40 sera utilisé pour les secondes.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_setUTCHours()">Utiliser <code>setUTCHours()</code></h3>
+### Utiliser `setUTCHours()`
 
-<pre class="brush: js">var leGrandJour = new Date();
+```js
+var leGrandJour = new Date();
 leGrandJour.setUTCHours(8);
-</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.3.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.9.5.35', 'Date.prototype.setUTCHours')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-date.prototype.setutchours', 'Date.prototype.setUTCHours')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-date.prototype.setutchours', 'Date.prototype.setUTCHours')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Date.setUTCHours")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Date.prototype.getUTCHours()")}}</li>
- <li>{{jsxref("Date.prototype.setHours()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                        | État                         | Commentaires                                          |
+| -------------------------------------------------------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- |
+| {{SpecName('ES1')}}                                                                                             | {{Spec2('ES1')}}         | Définition initiale. Implémentée avec JavaScript 1.3. |
+| {{SpecName('ES5.1', '#sec-15.9.5.35', 'Date.prototype.setUTCHours')}}                         | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-date.prototype.setutchours', 'Date.prototype.setUTCHours')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-date.prototype.setutchours', 'Date.prototype.setUTCHours')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Date.setUTCHours")}}
+
+## Voir aussi
+
+- {{jsxref("Date.prototype.getUTCHours()")}}
+- {{jsxref("Date.prototype.setHours()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/date/setutcmilliseconds/index.md b/files/fr/web/javascript/reference/global_objects/date/setutcmilliseconds/index.md
index 4e6b3e26f1..7e7e0a4e3d 100644
--- a/files/fr/web/javascript/reference/global_objects/date/setutcmilliseconds/index.md
+++ b/files/fr/web/javascript/reference/global_objects/date/setutcmilliseconds/index.md
@@ -10,78 +10,52 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Date/setUTCMilliseconds
 original_slug: Web/JavaScript/Reference/Objets_globaux/Date/setUTCMilliseconds
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>setUTCMilliseconds()</strong></code> définit les millièmes de secondes pour la date, selon UTC.</p>
+La méthode **`setUTCMilliseconds()`** définit les millièmes de secondes pour la date, selon UTC.
 
-<div>{{EmbedInteractiveExample("pages/js/date-setutcmilliseconds.html")}}</div>
+{{EmbedInteractiveExample("pages/js/date-setutcmilliseconds.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>dateObj</var>.setUTCMilliseconds(valeurMs) </pre>
+    dateObj.setUTCMilliseconds(valeurMs)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>valeurMs</code></dt>
- <dd>Un entier entre 0 et 999, représentant les millièmes de secondes.</dd>
-</dl>
+- `valeurMs`
+  - : Un entier entre 0 et 999, représentant les millièmes de secondes.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Le nombre de millisecondes écoulées entre le premier janvier 1970 minuit, UTC et la date mise à jour.</p>
+Le nombre de millisecondes écoulées entre le premier janvier 1970 minuit, UTC et la date mise à jour.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Si le paramètre indiqué est en dehors des limites attendues, la date sera mise à jour en conséquence. Par exemple, si on utilise la valeur 1005, le nombre des secondes sera incrémenté de 1, et 5 sera utilisé pour les millièmes de secondes.</p>
+Si le paramètre indiqué est en dehors des limites attendues, la date sera mise à jour en conséquence. Par exemple, si on utilise la valeur 1005, le nombre des secondes sera incrémenté de 1, et 5 sera utilisé pour les millièmes de secondes.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_setUTCMilliseconds()">Utiliser <code>setUTCMilliseconds()</code></h3>
+### Utiliser `setUTCMilliseconds()`
 
-<pre class="brush: js">var leGrandJour = new Date();
+```js
+var leGrandJour = new Date();
 leGrandJour.setUTCMilliseconds(500);
-</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.3.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.9.5.29', 'Date.prototype.setUTCMilliseconds')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-date.prototype.setutcmilliseconds', 'Date.prototype.setUTCMilliseconds')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-date.prototype.setutcmilliseconds', 'Date.prototype.setUTCMilliseconds')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Date.setUTCMilliseconds")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Date.prototype.getUTCMilliseconds()")}}</li>
- <li>{{jsxref("Date.prototype.setMilliseconds()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                                            | État                         | Commentaires                                          |
+| ---------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- |
+| {{SpecName('ES1')}}                                                                                                                 | {{Spec2('ES1')}}         | Définition initiale. Implémentée avec JavaScript 1.3. |
+| {{SpecName('ES5.1', '#sec-15.9.5.29', 'Date.prototype.setUTCMilliseconds')}}                                     | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-date.prototype.setutcmilliseconds', 'Date.prototype.setUTCMilliseconds')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-date.prototype.setutcmilliseconds', 'Date.prototype.setUTCMilliseconds')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Date.setUTCMilliseconds")}}
+
+## Voir aussi
+
+- {{jsxref("Date.prototype.getUTCMilliseconds()")}}
+- {{jsxref("Date.prototype.setMilliseconds()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/date/setutcminutes/index.md b/files/fr/web/javascript/reference/global_objects/date/setutcminutes/index.md
index 5e57b4e761..ebf0a4ead5 100644
--- a/files/fr/web/javascript/reference/global_objects/date/setutcminutes/index.md
+++ b/files/fr/web/javascript/reference/global_objects/date/setutcminutes/index.md
@@ -10,84 +10,58 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Date/setUTCMinutes
 original_slug: Web/JavaScript/Reference/Objets_globaux/Date/setUTCMinutes
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>setUTCMinutes()</strong></code> définit les minutes pour la date, selon UTC.</p>
+La méthode **`setUTCMinutes()`** définit les minutes pour la date, selon UTC.
 
-<div>{{EmbedInteractiveExample("pages/js/date-setutcminutes.html")}}</div>
+{{EmbedInteractiveExample("pages/js/date-setutcminutes.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>dateObj</var>.setUTCMinutes(valeurMinutes[, valeurSecondes[, valeurMs]]) </pre>
+    dateObj.setUTCMinutes(valeurMinutes[, valeurSecondes[, valeurMs]])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>valeurMinutes</code></dt>
- <dd>Un entier entre 0 et 59, représentant les minutes.</dd>
- <dt><code>valeurSecondes</code></dt>
- <dd>Paramètre optionnel, un entier entre 0 et 59, représentant les secondes. Si ce paramètre est utilisé, il faut également utiliser <code>valeurMinutes</code>.</dd>
- <dt><code>valeurMs</code></dt>
- <dd>Paramètre optionnel, un nombre entre 0 et 999, représentant les millièmes de secondes. Si ce paramètre est utilisé, il faut aussi indiquer <code>valeurMinutes</code> et <code>valeurSecondes</code>.</dd>
-</dl>
+- `valeurMinutes`
+  - : Un entier entre 0 et 59, représentant les minutes.
+- `valeurSecondes`
+  - : Paramètre optionnel, un entier entre 0 et 59, représentant les secondes. Si ce paramètre est utilisé, il faut également utiliser `valeurMinutes`.
+- `valeurMs`
+  - : Paramètre optionnel, un nombre entre 0 et 999, représentant les millièmes de secondes. Si ce paramètre est utilisé, il faut aussi indiquer `valeurMinutes` et `valeurSecondes`.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Le nombre de millisecondes écoulées entre le premier janvier 1970 minuit, UTC et la date mise à jour.</p>
+Le nombre de millisecondes écoulées entre le premier janvier 1970 minuit, UTC et la date mise à jour.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Si les paramètres <code>valeurSecondes</code> et <code>valeurMs</code> ne sont pas utilisés, les valeurs renvoyées par les méthodes {{jsxref("Date.prototype.getUTCSeconds", "getUTCSeconds()")}} et {{jsxref("Date.prototype.getUTCMilliseconds", "getUTCMilliseconds()")}} seront utilisées.</p>
+Si les paramètres `valeurSecondes` et `valeurMs` ne sont pas utilisés, les valeurs renvoyées par les méthodes {{jsxref("Date.prototype.getUTCSeconds", "getUTCSeconds()")}} et {{jsxref("Date.prototype.getUTCMilliseconds", "getUTCMilliseconds()")}} seront utilisées.
 
-<p>Si un paramètre est en dehors des limites attendues, <code>setUTCMinutes()</code> tentera de mettre à jour la date en conséquence. Par exemple, si on utilise 100 pour <code>valeurSecondes</code>, les minutes (<code>valeurMinutes</code>) seront incrémentées de 1 (<code>valeurMinutes</code> + 1), et 40 sera utilisé pour les secondes.</p>
+Si un paramètre est en dehors des limites attendues, `setUTCMinutes()` tentera de mettre à jour la date en conséquence. Par exemple, si on utilise 100 pour `valeurSecondes`, les minutes (`valeurMinutes`) seront incrémentées de 1 (`valeurMinutes` + 1), et 40 sera utilisé pour les secondes.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_setUTCMinutes()">Utiliser <code>setUTCMinutes()</code></h3>
+### Utiliser `setUTCMinutes()`
 
-<pre class="brush: js">var leGrandJour = new Date();
+```js
+var leGrandJour = new Date();
 leGrandJour.setUTCMinutes(43);
-</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.3.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.9.5.33', 'Date.prototype.setUTCMinutes')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-date.prototype.setutcminutes', 'Date.prototype.setUTCMinutes')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-date.prototype.setutcminutes', 'Date.prototype.setUTCMinutes')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Date.setUTCMinutes")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Date.prototype.getUTCMinutes()")}}</li>
- <li>{{jsxref("Date.prototype.setMinutes()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                                | État                         | Commentaires                                          |
+| ---------------------------------------------------------------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- |
+| {{SpecName('ES1')}}                                                                                                     | {{Spec2('ES1')}}         | Définition initiale. Implémentée avec JavaScript 1.3. |
+| {{SpecName('ES5.1', '#sec-15.9.5.33', 'Date.prototype.setUTCMinutes')}}                             | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-date.prototype.setutcminutes', 'Date.prototype.setUTCMinutes')}}         | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-date.prototype.setutcminutes', 'Date.prototype.setUTCMinutes')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Date.setUTCMinutes")}}
+
+## Voir aussi
+
+- {{jsxref("Date.prototype.getUTCMinutes()")}}
+- {{jsxref("Date.prototype.setMinutes()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/date/setutcmonth/index.md b/files/fr/web/javascript/reference/global_objects/date/setutcmonth/index.md
index 7fff322429..580acfb674 100644
--- a/files/fr/web/javascript/reference/global_objects/date/setutcmonth/index.md
+++ b/files/fr/web/javascript/reference/global_objects/date/setutcmonth/index.md
@@ -10,82 +10,56 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Date/setUTCMonth
 original_slug: Web/JavaScript/Reference/Objets_globaux/Date/setUTCMonth
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>setUTCMonth()</strong></code> définit le mois de la date, selon UTC.</p>
+La méthode **`setUTCMonth()`** définit le mois de la date, selon UTC.
 
-<div>{{EmbedInteractiveExample("pages/js/date-setutcmonth.html")}}</div>
+{{EmbedInteractiveExample("pages/js/date-setutcmonth.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>dateObj</var>.setUTCMonth(valeurMois[, valeurJour]) </pre>
+    dateObj.setUTCMonth(valeurMois[, valeurJour])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>valeurMois</code></dt>
- <dd>Un entier entre 0 et 11, représentant les mois de Janvier à Décembre.</dd>
- <dt><code>valeurJour</code></dt>
- <dd>Paramètre optionnel, un entier entre 1 et 31, représentant le jour du mois.</dd>
-</dl>
+- `valeurMois`
+  - : Un entier entre 0 et 11, représentant les mois de Janvier à Décembre.
+- `valeurJour`
+  - : Paramètre optionnel, un entier entre 1 et 31, représentant le jour du mois.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Le nombre de millisecondes écoulées entre le premier janvier 1970 minuit, UTC et la date mise à jour.</p>
+Le nombre de millisecondes écoulées entre le premier janvier 1970 minuit, UTC et la date mise à jour.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Si le paramètre <code>valeurJour</code> n'est pas utilisé, la valeur renvoyée par la méthode {{jsxref("Date.prototype.getUTCDate", "getUTCDate()")}} sera utilisée.</p>
+Si le paramètre `valeurJour` n'est pas utilisé, la valeur renvoyée par la méthode {{jsxref("Date.prototype.getUTCDate", "getUTCDate()")}} sera utilisée.
 
-<p>Si un paramètre renseigné n'est pas dans l'intervalle attendues, <code>setUTCMonth()</code> tentera de mettre à jour la date en conséquence. Par exemple, si on utilise 15 pour <code>valeurMois</code>, l'année sera incrémentée de 1 (année + 1), et 3 sera utilisé pour le mois.</p>
+Si un paramètre renseigné n'est pas dans l'intervalle attendues, `setUTCMonth()` tentera de mettre à jour la date en conséquence. Par exemple, si on utilise 15 pour `valeurMois`, l'année sera incrémentée de 1 (année + 1), et 3 sera utilisé pour le mois.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_setUTCMonth()">Utiliser <code>setUTCMonth()</code></h3>
+### Utiliser `setUTCMonth()`
 
-<pre class="brush: js">var leGrandJour = new Date();
+```js
+var leGrandJour = new Date();
 leGrandJour.setUTCMonth(11);
-</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.3.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.9.5.39', 'Date.prototype.setUTCMonth')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-date.prototype.setutcmonth', 'Date.prototype.setUTCMonth')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-date.prototype.setutcmonth', 'Date.prototype.setUTCMonth')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Date.setUTCMonth")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Date.prototype.getUTCMonth()")}}</li>
- <li>{{jsxref("Date.prototype.setMonth()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                        | État                         | Commentaires                                          |
+| -------------------------------------------------------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- |
+| {{SpecName('ES1')}}                                                                                             | {{Spec2('ES1')}}         | Définition initiale. Implémentée avec JavaScript 1.3. |
+| {{SpecName('ES5.1', '#sec-15.9.5.39', 'Date.prototype.setUTCMonth')}}                         | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-date.prototype.setutcmonth', 'Date.prototype.setUTCMonth')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-date.prototype.setutcmonth', 'Date.prototype.setUTCMonth')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Date.setUTCMonth")}}
+
+## Voir aussi
+
+- {{jsxref("Date.prototype.getUTCMonth()")}}
+- {{jsxref("Date.prototype.setMonth()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/date/setutcseconds/index.md b/files/fr/web/javascript/reference/global_objects/date/setutcseconds/index.md
index 38bbc89cad..ffb683924a 100644
--- a/files/fr/web/javascript/reference/global_objects/date/setutcseconds/index.md
+++ b/files/fr/web/javascript/reference/global_objects/date/setutcseconds/index.md
@@ -10,82 +10,56 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Date/setUTCSeconds
 original_slug: Web/JavaScript/Reference/Objets_globaux/Date/setUTCSeconds
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>setUTCSeconds()</strong></code> définit les secondes pour la date, selon UTC.</p>
+La méthode **`setUTCSeconds()`** définit les secondes pour la date, selon UTC.
 
-<div>{{EmbedInteractiveExample("pages/js/date-setutcseconds.html")}}</div>
+{{EmbedInteractiveExample("pages/js/date-setutcseconds.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>dateObj</var>.setUTCSeconds(valeurSecondes[, valeurMs]) </pre>
+    dateObj.setUTCSeconds(valeurSecondes[, valeurMs])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>valeurSecondes</code></dt>
- <dd>Un entier entre 0 et 59.</dd>
- <dt><code>valeurMs</code></dt>
- <dd>Paramètre optionnel, un nombre entre 0 et 999, représentant les millièmes de secondes.</dd>
-</dl>
+- `valeurSecondes`
+  - : Un entier entre 0 et 59.
+- `valeurMs`
+  - : Paramètre optionnel, un nombre entre 0 et 999, représentant les millièmes de secondes.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Le nombre de millisecondes écoulées entre le premier janvier 1970 minuit, UTC et la date mise à jour.</p>
+Le nombre de millisecondes écoulées entre le premier janvier 1970 minuit, UTC et la date mise à jour.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Si le paramètre <code>valeurMs</code> n'est pas utilisée, la valeur renvoyée par la méthode {{jsxref("Date.prototype.getUTCMilliseconds", "getUTCMilliseconds()")}} sera utilisée.</p>
+Si le paramètre `valeurMs` n'est pas utilisée, la valeur renvoyée par la méthode {{jsxref("Date.prototype.getUTCMilliseconds", "getUTCMilliseconds()")}} sera utilisée.
 
-<p>Si un paramètre renseigné est en dehors de l'intervalle attendu, <code>setUTCSeconds()</code> tentera de mettre à jour la date en conséquence. Par exemple, si on utilise 100 pour <code>valeurSecondes</code>, les minutes de la date seront incrémentées de 1, et 40 sera utilisé pour les secondes.</p>
+Si un paramètre renseigné est en dehors de l'intervalle attendu, `setUTCSeconds()` tentera de mettre à jour la date en conséquence. Par exemple, si on utilise 100 pour `valeurSecondes`, les minutes de la date seront incrémentées de 1, et 40 sera utilisé pour les secondes.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_setUTCSeconds()">Utiliser <code>setUTCSeconds()</code></h3>
+### Utiliser `setUTCSeconds()`
 
-<pre class="brush: js">var leGrandJour = new Date();
+```js
+var leGrandJour = new Date();
 leGrandJour.setUTCSeconds(20);
-</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.3.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.9.5.31', 'Date.prototype.setUTCSeconds')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-date.prototype.setutcseconds', 'Date.prototype.setUTCSeconds')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-date.prototype.setutcseconds', 'Date.prototype.setUTCSeconds')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Date.setUTCSeconds")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Date.prototype.getUTCSeconds()")}}</li>
- <li>{{jsxref("Date.prototype.setSeconds()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                                | État                         | Commentaires                                          |
+| ---------------------------------------------------------------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- |
+| {{SpecName('ES1')}}                                                                                                     | {{Spec2('ES1')}}         | Définition initiale. Implémentée avec JavaScript 1.3. |
+| {{SpecName('ES5.1', '#sec-15.9.5.31', 'Date.prototype.setUTCSeconds')}}                             | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-date.prototype.setutcseconds', 'Date.prototype.setUTCSeconds')}}         | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-date.prototype.setutcseconds', 'Date.prototype.setUTCSeconds')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Date.setUTCSeconds")}}
+
+## Voir aussi
+
+- {{jsxref("Date.prototype.getUTCSeconds()")}}
+- {{jsxref("Date.prototype.setSeconds()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/date/setyear/index.md b/files/fr/web/javascript/reference/global_objects/date/setyear/index.md
index 05e61e6700..34756135d3 100644
--- a/files/fr/web/javascript/reference/global_objects/date/setyear/index.md
+++ b/files/fr/web/javascript/reference/global_objects/date/setyear/index.md
@@ -11,83 +11,57 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Date/setYear
 original_slug: Web/JavaScript/Reference/Objets_globaux/Date/setYear
 ---
-<div>{{JSRef}} {{deprecated_header}}</div>
+{{JSRef}} {{deprecated_header}}
 
-<p>La méthode <strong><code>setYear()</code></strong> définit l'année pour pour la date, selon l'heure locale. <code>setYear()</code> ne définissant pas des années complêtes ( « bug de l'an 2000 » ), elle n'est plus utilisée et a été remplacée par la méthode {{jsxref("Date.prototype.setFullYear", "setFullYear")}}.</p>
+La méthode **`setYear()`** définit l'année pour pour la date, selon l'heure locale. `setYear()` ne définissant pas des années complêtes ( « bug de l'an 2000 » ), elle n'est plus utilisée et a été remplacée par la méthode {{jsxref("Date.prototype.setFullYear", "setFullYear")}}.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>dateObj</var>.setYear(valeurAnnée)</pre>
+    dateObj.setYear(valeurAnnée)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>valeurAnnée</code></dt>
- <dd>Un entier.</dd>
-</dl>
+- `valeurAnnée`
+  - : Un entier.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Le nombre de millisecondes écoulées entre le premier janvier 1970 minuit, UTC et la date mise à jour.</p>
+Le nombre de millisecondes écoulées entre le premier janvier 1970 minuit, UTC et la date mise à jour.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Si <code>valeurAnnée</code> est un nombre entre 0 et 99 (inclus), alors l'année de <code>dateObj</code> sera définie à 1900 + <code>valeurAnnée</code>. Sinon, l'année de <code>dateObj</code> sera définie à <code>valeurAnnée</code>.</p>
+Si `valeurAnnée` est un nombre entre 0 et 99 (inclus), alors l'année de `dateObj` sera définie à 1900 + `valeurAnnée`. Sinon, l'année de `dateObj` sera définie à `valeurAnnée`.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_setYear()">Utiliser <code>setYear()</code></h3>
+### Utiliser `setYear()`
 
-<p>Les deux premières instructions définissent l'année 1996. La troisième définit l'année 2000.</p>
+Les deux premières instructions définissent l'année 1996. La troisième définit l'année 2000.
 
-<pre class="brush: js">var leGrandJour = new Date();
+```js
+var leGrandJour = new Date();
 
 leGrandJour.setYear(96);
 leGrandJour.setYear(1996);
 leGrandJour.setYear(2000);
-</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.0.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-B.2.5', 'Date.prototype.setYear')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td>Définie dans l'annexe informative sur la compatibilité.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-date.prototype.setyear', 'Date.prototype.setYear')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Définie dans l'annexe normative sur les fonctionnalités additionnelles des navigateurs web.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-date.prototype.setyear', 'Date.prototype.setYear')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td>Définie dans l'annexe normative 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.Date.setYear")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Date.prototype.getFullYear()")}}</li>
- <li>{{jsxref("Date.prototype.getUTCFullYear()")}}</li>
- <li>{{jsxref("Date.prototype.setFullYear()")}}</li>
- <li>{{jsxref("Date.prototype.setUTCFullYear()")}}</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-B.2.5', 'Date.prototype.setYear')}}                             | {{Spec2('ES5.1')}}     | Définie dans l'annexe informative sur la compatibilité.                                     |
+| {{SpecName('ES6', '#sec-date.prototype.setyear', 'Date.prototype.setYear')}}         | {{Spec2('ES6')}}         | Définie dans l'annexe normative sur les fonctionnalités additionnelles des navigateurs web. |
+| {{SpecName('ESDraft', '#sec-date.prototype.setyear', 'Date.prototype.setYear')}} | {{Spec2('ESDraft')}} | Définie dans l'annexe normative sur les fonctionnalités additionnelles des navigateurs web. |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Date.setYear")}}
+
+## Voir aussi
+
+- {{jsxref("Date.prototype.getFullYear()")}}
+- {{jsxref("Date.prototype.getUTCFullYear()")}}
+- {{jsxref("Date.prototype.setFullYear()")}}
+- {{jsxref("Date.prototype.setUTCFullYear()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/date/todatestring/index.md b/files/fr/web/javascript/reference/global_objects/date/todatestring/index.md
index 0fa5df67f0..50dbe12d4b 100644
--- a/files/fr/web/javascript/reference/global_objects/date/todatestring/index.md
+++ b/files/fr/web/javascript/reference/global_objects/date/todatestring/index.md
@@ -10,82 +10,57 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Date/toDateString
 original_slug: Web/JavaScript/Reference/Objets_globaux/Date/toDateString
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>toDateString()</strong></code> renvoie la date contenue dans un objet {{jsxref("Date")}} sous la forme d'une chaîne de caractères lisible par un humain, en anglais américain et au format suivant :</p>
+La méthode **`toDateString()`** renvoie la date contenue dans un objet {{jsxref("Date")}} sous la forme d'une chaîne de caractères lisible par un humain, en anglais américain et au format suivant :
 
-<ol>
- <li>Les trois premières lettre indiquent le jour</li>
- <li>Les trois lettres suivantes indiquent le mois</li>
- <li>Les deux chiffres suivants indiquent le jour du mois (et sont complétés avec un 0 devant si besoin)</li>
- <li>Les quatre chiffres restants indiquent l'année (si besoin complétées avec des 0 comme préfixe)</li>
-</ol>
+1.  Les trois premières lettre indiquent le jour
+2.  Les trois lettres suivantes indiquent le mois
+3.  Les deux chiffres suivants indiquent le jour du mois (et sont complétés avec un 0 devant si besoin)
+4.  Les quatre chiffres restants indiquent l'année (si besoin complétées avec des 0 comme préfixe)
 
-<div>{{EmbedInteractiveExample("pages/js/date-todatestring.html")}}</div>
+{{EmbedInteractiveExample("pages/js/date-todatestring.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>dateObj</var>.toDateString()</pre>
+    dateObj.toDateString()
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une chaîne de caractères qui représente la date indiquée, dans un format anglais américain.</p>
+Une chaîne de caractères qui représente la date indiquée, dans un format anglais américain.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Les instances de {{jsxref("Date")}} représentent un point précis dans le temps. Appeler {{jsxref("Date.prototype.toString", "toString")}} retournera la date formatée sous une forme lisible par un humain, en anglais américain. Pour le moteur JavaScript <a href="/fr/docs/SpiderMonkey">SpiderMonkey</a>, ceci consiste en : la partie « date » (jour, mois et année) suivie de la partie « heure » (heures, minutes, secondes et fuseau horaire). Il est parfois préférable d'obtenir uniquement la partie « date » ; ceci est possible grâce à la méthode <code>toDateString()</code>.</p>
+Les instances de {{jsxref("Date")}} représentent un point précis dans le temps. Appeler {{jsxref("Date.prototype.toString", "toString")}} retournera la date formatée sous une forme lisible par un humain, en anglais américain. Pour le moteur JavaScript [SpiderMonkey](/fr/docs/SpiderMonkey), ceci consiste en : la partie « date » (jour, mois et année) suivie de la partie « heure » (heures, minutes, secondes et fuseau horaire). Il est parfois préférable d'obtenir uniquement la partie « date » ; ceci est possible grâce à la méthode `toDateString()`.
 
-<p>La méthode <code>toDateString()</code> est particulièrement utile car, pour les moteurs implémentant fidèlement <a href="/fr/docs/JavaScript/Language_Resources">ECMA-262</a>, il peut y avoir certaines différences dans la chaîne de caractères produite par <code>toString()</code> sur les objets <code>Date</code>. Le format dépend de l'implémentation et les techniques simples de découpage de texte peuvent ne pas produire un résultat cohérent à travers les différents moteurs.</p>
+La méthode `toDateString()` est particulièrement utile car, pour les moteurs implémentant fidèlement [ECMA-262](/fr/docs/JavaScript/Language_Resources), il peut y avoir certaines différences dans la chaîne de caractères produite par `toString()` sur les objets `Date`. Le format dépend de l'implémentation et les techniques simples de découpage de texte peuvent ne pas produire un résultat cohérent à travers les différents moteurs.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_simplement_toDateString()">Utiliser simplement <code>toDateString()</code></h3>
+### Utiliser simplement `toDateString()`
 
-<pre class="brush:js">var d = new Date(1993, 6, 28, 14, 39, 7);
+```js
+var d = new Date(1993, 6, 28, 14, 39, 7);
 
 console.log(d.toString());     // écrit Wed Jul 28 1993 14:39:07 GMT-0600 (PDT)
-console.log(d.toDateString()); // écrit Wed Jul 28 1993</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.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.9.5.3', 'Date.prototype.toDateString')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-date.prototype.todatestring', 'Date.prototype.toDateString')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-date.prototype.todatestring', 'Date.prototype.toDateString')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Date.toDateString")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Date.prototype.toLocaleDateString()")}}</li>
- <li>{{jsxref("Date.prototype.toTimeString()")}}</li>
- <li>{{jsxref("Date.prototype.toString()")}}</li>
-</ul>
+console.log(d.toDateString()); // écrit Wed Jul 28 1993
+```
+
+## Spécifications
+
+| Spécification                                                                                                            | État                         | Commentaires         |
+| ------------------------------------------------------------------------------------------------------------------------ | ---------------------------- | -------------------- |
+| {{SpecName('ES3')}}                                                                                                 | {{Spec2('ES3')}}         | Définition initiale. |
+| {{SpecName('ES5.1', '#sec-15.9.5.3', 'Date.prototype.toDateString')}}                             | {{Spec2('ES5.1')}}     |                      |
+| {{SpecName('ES6', '#sec-date.prototype.todatestring', 'Date.prototype.toDateString')}}     | {{Spec2('ES6')}}         |                      |
+| {{SpecName('ESDraft', '#sec-date.prototype.todatestring', 'Date.prototype.toDateString')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Date.toDateString")}}
+
+## Voir aussi
+
+- {{jsxref("Date.prototype.toLocaleDateString()")}}
+- {{jsxref("Date.prototype.toTimeString()")}}
+- {{jsxref("Date.prototype.toString()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/date/togmtstring/index.md b/files/fr/web/javascript/reference/global_objects/date/togmtstring/index.md
index 701cc5c49a..6cabfdde5a 100644
--- a/files/fr/web/javascript/reference/global_objects/date/togmtstring/index.md
+++ b/files/fr/web/javascript/reference/global_objects/date/togmtstring/index.md
@@ -11,74 +11,48 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Date/toGMTString
 original_slug: Web/JavaScript/Reference/Objets_globaux/Date/toGMTString
 ---
-<div>{{JSRef}} {{deprecated_header}}</div>
+{{JSRef}} {{deprecated_header}}
 
-<p>La méthode <code><strong>toGMTString()</strong></code> convertit une date en une chaîne de caractères, en utilisant les conventions Internet pour GMT. Le format exact de la valeur renvoyée par <code>toGMTString()</code> varie en fonction de la plateforme et du navigateur web. En général, le texte produit est formaté pour être lisible par un humain.</p>
+La méthode **`toGMTString()`** convertit une date en une chaîne de caractères, en utilisant les conventions Internet pour GMT. Le format exact de la valeur renvoyée par `toGMTString()` varie en fonction de la plateforme et du navigateur web. En général, le texte produit est formaté pour être lisible par un humain.
 
-<div class="note">
-<p><strong>Note :</strong> <code>toGMTString()</code> est obsolète et ne doit plus être utilisé. Il existe encore uniquementpour des questions de compatibilité. La méthode {{jsxref("Date.prototype.toUTCString", "toUTCString()")}} doit être utilisée à la place.</p>
-</div>
+> **Note :** `toGMTString()` est obsolète et ne doit plus être utilisé. Il existe encore uniquementpour des questions de compatibilité. La méthode {{jsxref("Date.prototype.toUTCString", "toUTCString()")}} doit être utilisée à la place.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>dateObj</var>.toGMTString()</pre>
+    dateObj.toGMTString()
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une chaîne de caractères représentant la date indiquée selon la convention internet pour GMT (<em>Greenwich Mean Time</em>).</p>
+Une chaîne de caractères représentant la date indiquée selon la convention internet pour GMT (_Greenwich Mean Time_).
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_toGMTString()">Utiliser <code>toGMTString()</code></h3>
+### Utiliser `toGMTString()`
 
-<p>Dans cet exemple, la méthode <code>toGMTString()</code> convertit la date vers GMT (UTC) en utilisant la différence avec le fuseau horaire du système d'exploitation. Elle renvoie une chaîne de caractères similaire à celle de l'exemple. La forme exacte de cette chaîne de caractères dépend de la plateforme.</p>
+Dans cet exemple, la méthode `toGMTString()` convertit la date vers GMT (UTC) en utilisant la différence avec le fuseau horaire du système d'exploitation. Elle renvoie une chaîne de caractères similaire à celle de l'exemple. La forme exacte de cette chaîne de caractères dépend de la plateforme.
 
-<pre class="brush: js">var aujourdhui = new Date();
+```js
+var aujourdhui = new Date();
 var str = aujourdhui.toGMTString();  // Obsolète ! Utilisez toUTCString()
 
 console.log(str);               // Mon, 18 Dec 1995 17:28:35 GMT
-</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 et déjà déclarée comme dépréciée. Implémentée avec JavaScript 1.0.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-B.2.6', 'Date.prototype.toGMTString')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td>Définie dans l'annexe informative sur la compatibilité.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-date.prototype.togmtstring', 'Date.prototype.toGMTString')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Définie dans l'annexe normative sur les fonctionnalités additionnelles des navigateurs web.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-date.prototype.togmtstring', 'Date.prototype.toGMTString')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td>Définie dans l'annexe normative 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.Date.toGMTString")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Date.prototype.toLocaleDateString()")}}</li>
- <li>{{jsxref("Date.prototype.toTimeString()")}}</li>
- <li>{{jsxref("Date.prototype.toUTCString()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                        | État                         | Commentaires                                                                                |
+| -------------------------------------------------------------------------------------------------------------------- | ---------------------------- | ------------------------------------------------------------------------------------------- |
+| {{SpecName('ES1')}}                                                                                             | {{Spec2('ES1')}}         | Définition initiale et déjà déclarée comme dépréciée. Implémentée avec JavaScript 1.0.      |
+| {{SpecName('ES5.1', '#sec-B.2.6', 'Date.prototype.toGMTString')}}                             | {{Spec2('ES5.1')}}     | Définie dans l'annexe informative sur la compatibilité.                                     |
+| {{SpecName('ES6', '#sec-date.prototype.togmtstring', 'Date.prototype.toGMTString')}}     | {{Spec2('ES6')}}         | Définie dans l'annexe normative sur les fonctionnalités additionnelles des navigateurs web. |
+| {{SpecName('ESDraft', '#sec-date.prototype.togmtstring', 'Date.prototype.toGMTString')}} | {{Spec2('ESDraft')}} | Définie dans l'annexe normative sur les fonctionnalités additionnelles des navigateurs web. |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Date.toGMTString")}}
+
+## Voir aussi
+
+- {{jsxref("Date.prototype.toLocaleDateString()")}}
+- {{jsxref("Date.prototype.toTimeString()")}}
+- {{jsxref("Date.prototype.toUTCString()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/date/toisostring/index.md b/files/fr/web/javascript/reference/global_objects/date/toisostring/index.md
index 102c8dfb19..04e1ce306e 100644
--- a/files/fr/web/javascript/reference/global_objects/date/toisostring/index.md
+++ b/files/fr/web/javascript/reference/global_objects/date/toisostring/index.md
@@ -11,40 +11,42 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Date/toISOString
 original_slug: Web/JavaScript/Reference/Objets_globaux/Date/toISOString
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>toISOString()</strong></code> renvoie une chaîne de caractères au format ISO (<a href="http://en.wikipedia.org/wiki/ISO_8601">ISO 8601 Extended Format</a>), qui peut être décrite de cette façon : <code><strong>YYYY-MM-DDTHH:mm:ss.sssZ</strong></code> (toujours longue de 24 caractères) ou de cette façon <strong><code>±YYYYYY-MM-DDTHH:mm:ss.sssZ</code></strong> (27 caractères). Le fuseau horaire est toujours UTC, comme l'indique le suffixe « Z » (pour zéro décalage avec UTC).</p>
+La méthode **`toISOString()`** renvoie une chaîne de caractères au format ISO ([ISO 8601 Extended Format](http://en.wikipedia.org/wiki/ISO_8601)), qui peut être décrite de cette façon : **`YYYY-MM-DDTHH:mm:ss.sssZ`** (toujours longue de 24 caractères) ou de cette façon **`±YYYYYY-MM-DDTHH:mm:ss.sssZ`** (27 caractères). Le fuseau horaire est toujours UTC, comme l'indique le suffixe « Z » (pour zéro décalage avec UTC).
 
-<div>{{EmbedInteractiveExample("pages/js/date-toisostring.html")}}</div>
+{{EmbedInteractiveExample("pages/js/date-toisostring.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>dateObj</var>.toISOString()</pre>
+    dateObj.toISOString()
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une chaîne de caractères représentant la date indiquée au format <a href="https://fr.wikipedia.org/wiki/ISO_8601">ISO 8601</a> selon le temps universel.</p>
+Une chaîne de caractères représentant la date indiquée au format [ISO 8601](https://fr.wikipedia.org/wiki/ISO_8601) selon le temps universel.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_toISOString()">Utiliser <code>toISOString()</code></h3>
+### Utiliser `toISOString()`
 
-<pre class="brush: js">var aujourdhui = new Date("05 October 2011 14:48 UTC");
+```js
+var aujourdhui = new Date("05 October 2011 14:48 UTC");
 
 console.log(aujourdhui.toISOString()); // Renvoie "2011-10-05T14:48:00.000Z"
-</pre>
+```
 
-<p>L'exemple ci-dessus analyse une chaîne de caractères non-standard, qui peut donc être incorrectement intérprété par des navigateurs n'utilisant pas Gecko.</p>
+L'exemple ci-dessus analyse une chaîne de caractères non-standard, qui peut donc être incorrectement intérprété par des navigateurs n'utilisant pas Gecko.
 
-<h2 id="Prothèse_d'émulation_(polyfill)">Prothèse d'émulation (<em>polyfill</em>)</h2>
+## Prothèse d'émulation (_polyfill_)
 
-<p>Cette méthode fut standardisée avec la cinquième édition d'ECMAScript. Afin d'utiliser cette méthode avec les moteurs qui n'en disposent pas nativement, on pourra utiliser ce fragment de code :</p>
+Cette méthode fut standardisée avec la cinquième édition d'ECMAScript. Afin d'utiliser cette méthode avec les moteurs qui n'en disposent pas nativement, on pourra utiliser ce fragment de code :
 
-<pre class="brush:js">if ( !Date.prototype.toISOString ) {
+```js
+if ( !Date.prototype.toISOString ) {
   ( function() {
 
     function pad(number) {
-      if ( number &lt; 10 ) {
+      if ( number < 10 ) {
         return '0' + number;
       }
       return number;
@@ -62,43 +64,23 @@ console.log(aujourdhui.toISOString()); // Renvoie "2011-10-05T14:48:00.000Z"
     };
 
   }() );
-}</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.9.5.43', 'Date.prototype.toISOString')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td>Définition initiale. Implémentée avec JavaScript 1.8.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-date.prototype.toisostring', 'Date.prototype.toISOString')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-date.prototype.toisostring', 'Date.prototype.toISOString')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Date.toISOString")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Date.prototype.toLocaleDateString()")}}</li>
- <li>{{jsxref("Date.prototype.toTimeString()")}}</li>
- <li>{{jsxref("Date.prototype.toUTCString()")}}</li>
-</ul>
+}
+```
+
+## Spécifications
+
+| Spécification                                                                                                        | État                         | Commentaires                                          |
+| -------------------------------------------------------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- |
+| {{SpecName('ES5.1', '#sec-15.9.5.43', 'Date.prototype.toISOString')}}                         | {{Spec2('ES5.1')}}     | Définition initiale. Implémentée avec JavaScript 1.8. |
+| {{SpecName('ES6', '#sec-date.prototype.toisostring', 'Date.prototype.toISOString')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-date.prototype.toisostring', 'Date.prototype.toISOString')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Date.toISOString")}}
+
+## Voir aussi
+
+- {{jsxref("Date.prototype.toLocaleDateString()")}}
+- {{jsxref("Date.prototype.toTimeString()")}}
+- {{jsxref("Date.prototype.toUTCString()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/date/tojson/index.md b/files/fr/web/javascript/reference/global_objects/date/tojson/index.md
index c05c5d8d13..7909061c35 100644
--- a/files/fr/web/javascript/reference/global_objects/date/tojson/index.md
+++ b/files/fr/web/javascript/reference/global_objects/date/tojson/index.md
@@ -10,69 +10,49 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Date/toJSON
 original_slug: Web/JavaScript/Reference/Objets_globaux/Date/toJSON
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>toJSON()</strong></code> renvoie une chaîne représentant l'objet {{jsxref("Date")}} sous forme {{Glossary("JSON")}}</p>
+La méthode **`toJSON()`** renvoie une chaîne représentant l'objet {{jsxref("Date")}} sous forme {{Glossary("JSON")}}
 
-<div>{{EmbedInteractiveExample("pages/js/date-tojson.html")}}</div>
+{{EmbedInteractiveExample("pages/js/date-tojson.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>dateObj</var>.toJSON()</pre>
+    dateObj.toJSON()
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une chaîne de caractères représentant la date indiquée.</p>
+Une chaîne de caractères représentant la date indiquée.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Les instances de {{jsxref("Date")}} identifient un instant précis dans le temps. Appeler <code>toJSON()</code> renvoie une chaîne de caractères formatée en JSON (en utilisant {{jsxref("Date.prototype.toISOString", "toISOString()")}}), représentant la valeur de l'objet <code>Date</code>. Cette méthode est généralement utilisée, par défaut, pour sérialiser les objets <code>Date</code> lors d'une sérialisation au format JSON.</p>
+Les instances de {{jsxref("Date")}} identifient un instant précis dans le temps. Appeler `toJSON()` renvoie une chaîne de caractères formatée en JSON (en utilisant {{jsxref("Date.prototype.toISOString", "toISOString()")}}), représentant la valeur de l'objet `Date`. Cette méthode est généralement utilisée, par défaut, pour sérialiser les objets `Date` lors d'une sérialisation au format JSON.
 
-<h2 id="Exemple">Exemple</h2>
+## Exemple
 
-<h3 id="Utiliser_toJSON()">Utiliser <code>toJSON()</code></h3>
+### Utiliser `toJSON()`
 
-<pre class="brush:js">var jsonDate = (new Date()).toJSON();
+```js
+var jsonDate = (new Date()).toJSON();
 var retourVersDate = new Date(jsonDate);
 
 console.log(jsonDate); //2015-10-26T07:46:36.611Z
-</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.9.5.44', 'Date.prototype.toJSON')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td>Définition initiale. Implémentée avec JavaScript 1.8.5.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-date.prototype.tojson', 'Date.prototype.toJSON')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-date.prototype.tojson', 'Date.prototype.toJSON')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Date.toJSON")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Date.prototype.toLocaleDateString()")}}</li>
- <li>{{jsxref("Date.prototype.toTimeString()")}}</li>
- <li>{{jsxref("Date.prototype.toUTCString()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                            | État                         | Commentaires                                            |
+| -------------------------------------------------------------------------------------------------------- | ---------------------------- | ------------------------------------------------------- |
+| {{SpecName('ES5.1', '#sec-15.9.5.44', 'Date.prototype.toJSON')}}                     | {{Spec2('ES5.1')}}     | Définition initiale. Implémentée avec JavaScript 1.8.5. |
+| {{SpecName('ES6', '#sec-date.prototype.tojson', 'Date.prototype.toJSON')}}     | {{Spec2('ES6')}}         |                                                         |
+| {{SpecName('ESDraft', '#sec-date.prototype.tojson', 'Date.prototype.toJSON')}} | {{Spec2('ESDraft')}} |                                                         |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Date.toJSON")}}
+
+## Voir aussi
+
+- {{jsxref("Date.prototype.toLocaleDateString()")}}
+- {{jsxref("Date.prototype.toTimeString()")}}
+- {{jsxref("Date.prototype.toUTCString()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/date/tolocaledatestring/index.md b/files/fr/web/javascript/reference/global_objects/date/tolocaledatestring/index.md
index e773e49be3..3d0c471682 100644
--- a/files/fr/web/javascript/reference/global_objects/date/tolocaledatestring/index.md
+++ b/files/fr/web/javascript/reference/global_objects/date/tolocaledatestring/index.md
@@ -12,47 +12,50 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Date/toLocaleDateString
 original_slug: Web/JavaScript/Reference/Objets_globaux/Date/toLocaleDateString
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>toLocaleDateString()</strong></code> renvoie une chaine de caractères correspondant à la date (le fragment de l'objet qui correspond à la date : jour, mois, année) exprimée selon une locale. Les arguments <code>locales</code> et <code>options</code> permettent aux applications de définir le langage utilisé pour les conventions de format et permettent de personnaliser le comportement de la fonction. Les anciennes implémentations ignorent ces arguments, la locale utilisée et le format de la chaine dépendent uniquement de l'implémentation.</p>
+La méthode **`toLocaleDateString()`** renvoie une chaine de caractères correspondant à la date (le fragment de l'objet qui correspond à la date : jour, mois, année) exprimée selon une locale. Les arguments `locales` et `options` permettent aux applications de définir le langage utilisé pour les conventions de format et permettent de personnaliser le comportement de la fonction. Les anciennes implémentations ignorent ces arguments, la locale utilisée et le format de la chaine dépendent uniquement de l'implémentation.
 
-<div>{{EmbedInteractiveExample("pages/js/date-tolocaledatestring.html")}}</div>
+{{EmbedInteractiveExample("pages/js/date-tolocaledatestring.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>dateObj</var>.toLocaleDateString([locales [, options]])</pre>
+    dateObj.toLocaleDateString([locales [, options]])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<p>Voir le tableau de <a href="#compat">compatibilité des navigateurs</a> afin de déterminer quels navigateurs respectent les arguments <code>locales</code> et <code>options</code> ainsi que l'exemple <a href="#check">Vérifier le support des arguments locales et options</a> qui permet de détecter cette fonctionnalité.</p>
+Voir le tableau de [compatibilité des navigateurs](#compat) afin de déterminer quels navigateurs respectent les arguments `locales` et `options` ainsi que l'exemple [Vérifier le support des arguments locales et options](#check) qui permet de détecter cette fonctionnalité.
 
-<p>{{page('fr/docs/JavaScript/Reference/Objets_globaux/DateTimeFormat','Paramètres')}}</p>
+{{page('fr/docs/JavaScript/Reference/Objets_globaux/DateTimeFormat','Paramètres')}}
 
-<p>La valeur par défaut de chacun des composants de la date vaut {{jsxref("undefined")}}, si les propriétés <code>weekday</code>, <code>year</code>, <code>month</code>, <code>day</code> sont toutes <code>undefined</code>, on suppose alors que <code>year</code>, <code>month</code>, et <code>day</code> sont « numériques ».</p>
+La valeur par défaut de chacun des composants de la date vaut {{jsxref("undefined")}}, si les propriétés `weekday`, `year`, `month`, `day` sont toutes `undefined`, on suppose alors que `year`, `month`, et `day` sont « numériques ».
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une chaîne de caractères qui représente le jour de la date indiquée selon des options de locales.</p>
+Une chaîne de caractères qui représente le jour de la date indiquée selon des options de locales.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_toLocaleDateString()">Utiliser <code>toLocaleDateString()</code></h3>
+### Utiliser `toLocaleDateString()`
 
-<p>Voici un usage simple qui ne définit pas de locale : une chaine de caractères dans une locale et avec des options par défaut est renvoyée.</p>
+Voici un usage simple qui ne définit pas de locale : une chaine de caractères dans une locale et avec des options par défaut est renvoyée.
 
-<pre class="brush:js">var date = new Date(Date.UTC(2012, 11, 12, 3, 0, 0));
+```js
+var date = new Date(Date.UTC(2012, 11, 12, 3, 0, 0));
 
 // toLocaleDateString() sans argument, on utilise donc
 // les valeurs par défaut (de l'implémentation)
 // pour la locale, et le fuseau horaire
 date.toLocaleDateString();
-// → "12/12/2012" si exécuté dans une locale fr et le fuseau horaire CEST</pre>
+// → "12/12/2012" si exécuté dans une locale fr et le fuseau horaire CEST
+```
 
-<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 arguments <code>locales</code> et <code>options</code> ne sont pas encore supportés par tous les navigateurs. Afin de vérifier si l'implementation utilisée les supporte, vous pouvez utiliser le pré-requis suivant : les locales incorrectes sont rejetées avec une exception<code> RangeError</code> :</p>
+Les arguments `locales` et `options` ne sont pas encore supportés par tous les navigateurs. Afin de vérifier si l'implementation utilisée les supporte, vous pouvez utiliser le pré-requis suivant : les locales incorrectes sont rejetées avec une exception` RangeError` :
 
-<pre class="brush: js">function toLocaleDateStringSupportsLocales() {
+```js
+function toLocaleDateStringSupportsLocales() {
     try {
         new Date().toLocaleDateString("i");
     } catch (e) {
@@ -60,13 +63,14 @@ date.toLocaleDateString();
     }
     return false;
 }
-</pre>
+```
 
-<h3 id="Utiliser_l'argument_locales">Utiliser l'argument <code>locales</code></h3>
+### Utiliser l'argument `locales`
 
-<p>Cet exemple montre quelques variations dues aux formats de dates localisés. Afin d'obtenir le langage utilisé au sein de l'interface utilisateur de votre application, vérifiez de bien fournir ce langage (et éventuellement des locales de recours) en utilisant l'argument <code>locales</code> :</p>
+Cet exemple montre quelques variations dues aux formats de dates localisés. Afin d'obtenir le langage utilisé au sein de l'interface utilisateur de votre application, vérifiez de bien fournir ce langage (et éventuellement des locales de recours) en utilisant l'argument `locales` :
 
-<pre class="brush: js">var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0));
+```js
+var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0));
 
 // les formats qui suivent se basent sur le
 // fuseau horaire CEST
@@ -85,7 +89,7 @@ alert(date.toLocaleDateString("ko-KR"));
 
 // l'arabe, dans la plupart des pays arabophones, utilise les chiffres arabes
 alert(date.toLocaleDateString("ar-EG"));
-// → "<span dir="rtl">٢٠‏/١٢‏/٢٠١٢</span>"
+// → "٢٠‏/١٢‏/٢٠١٢"
 
 // en ce qui concerne le japonais, les applications peuvent
 // souhaiter utiliser le calendrier japonais
@@ -97,13 +101,14 @@ alert(date.toLocaleDateString("ja-JP-u-ca-japanese"));
 // il est possible de fournir un langage de recours (ici l'indonésien)
 alert(date.toLocaleDateString(["ban", "id"]));
 // → "20/12/2012"
-</pre>
+```
 
-<h3 id="Utiliser_l'argument_options">Utiliser l'argument <code>options</code></h3>
+### Utiliser l'argument `options`
 
-<p>Les résultats fournis par <code>toLocaleDateString()</code> peuvent être personnalisés grâce à l'argument <code>options</code> :</p>
+Les résultats fournis par `toLocaleDateString()` peuvent être personnalisés grâce à l'argument `options` :
 
-<pre class="brush: js">var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0));
+```js
+var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0));
 
 // fournir le jour de la semaine avec une date longe
 var options = {weekday: "long", year: "numeric", month: "long", day: "numeric"};
@@ -116,68 +121,31 @@ options.timeZone = "UTC";
 options.timeZoneName = "short";
 alert(date.toLocaleDateString("en-US", options));
 // → "Thursday, December 20, 2012, GMT"
-</pre>
-
-<h2 id="Performance">Performance</h2>
-
-<p>Lorsque des grands nombres ou de grandes dates sont formatés, il est préférable de créer un objet {{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}} et d'utiliser la fonction fournie par sa propriété {{jsxref("DateTimeFormat.prototype.format", "format")}}.</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.0.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', 'sec-15.9.5.6', 'Date.prototype.toLocaleDateString')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-date.prototype.tolocaledatestring', 'Date.prototype.toLocaleDateString')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-date.prototype.tolocaledatestring', 'Date.prototype.toLocaleDateString')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES Int 1.0', '#sec-13.3.2', 'Date.prototype.toLocaleDateString')}}</td>
-   <td>{{Spec2('ES Int 1.0')}}</td>
-   <td>Définition des arguments <code>locales</code> et <code>options</code>.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES Int 2.0', '#sec-13.3.2', 'Date.prototype.toLocaleDateString')}}</td>
-   <td>{{Spec2('ES Int 2.0')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES Int Draft', '#sec-Date.prototype.toLocaleDateString', 'Date.prototype.toLocaleDateString')}}</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.Date.toLocaleDateString")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}}</li>
- <li>{{jsxref("Date.prototype.toLocaleString()")}}</li>
- <li>{{jsxref("Date.prototype.toLocaleTimeString()")}}</li>
- <li>{{jsxref("Date.prototype.toString()")}}</li>
-</ul>
+```
+
+## Performance
+
+Lorsque des grands nombres ou de grandes dates sont formatés, il est préférable de créer un objet {{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}} et d'utiliser la fonction fournie par sa propriété {{jsxref("DateTimeFormat.prototype.format", "format")}}.
+
+## Spécifications
+
+| Spécification                                                                                                                                    | État                             | Commentaires                                          |
+| ------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------- | ----------------------------------------------------- |
+| {{SpecName('ES3')}}                                                                                                                         | {{Spec2('ES3')}}             | Définition initiale. Implémentée avec JavaScript 1.0. |
+| {{SpecName('ES5.1', 'sec-15.9.5.6', 'Date.prototype.toLocaleDateString')}}                                             | {{Spec2('ES5.1')}}         |                                                       |
+| {{SpecName('ES6', '#sec-date.prototype.tolocaledatestring', 'Date.prototype.toLocaleDateString')}}             | {{Spec2('ES6')}}             |                                                       |
+| {{SpecName('ESDraft', '#sec-date.prototype.tolocaledatestring', 'Date.prototype.toLocaleDateString')}}         | {{Spec2('ESDraft')}}     |                                                       |
+| {{SpecName('ES Int 1.0', '#sec-13.3.2', 'Date.prototype.toLocaleDateString')}}                                         | {{Spec2('ES Int 1.0')}} | Définition des arguments `locales` et `options`.      |
+| {{SpecName('ES Int 2.0', '#sec-13.3.2', 'Date.prototype.toLocaleDateString')}}                                         | {{Spec2('ES Int 2.0')}} |                                                       |
+| {{SpecName('ES Int Draft', '#sec-Date.prototype.toLocaleDateString', 'Date.prototype.toLocaleDateString')}} | {{Spec2('ES Int Draft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Date.toLocaleDateString")}}
+
+## Voir aussi
+
+- {{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}}
+- {{jsxref("Date.prototype.toLocaleString()")}}
+- {{jsxref("Date.prototype.toLocaleTimeString()")}}
+- {{jsxref("Date.prototype.toString()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/date/tolocalestring/index.md b/files/fr/web/javascript/reference/global_objects/date/tolocalestring/index.md
index 8eebb47913..22c2f30587 100644
--- a/files/fr/web/javascript/reference/global_objects/date/tolocalestring/index.md
+++ b/files/fr/web/javascript/reference/global_objects/date/tolocalestring/index.md
@@ -12,47 +12,50 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Date/toLocaleString
 original_slug: Web/JavaScript/Reference/Objets_globaux/Date/toLocaleString
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>toLocaleString()</strong></code> renvoie une chaine de caractères représentant la date selon une locale. Les arguments <code>locales</code> et <code>options</code> permettent aux applications de définir le langage à utiliser pour les conventions de format et permettent de personnaliser le comportement de la fonction. Les anciennes implémentations ignorent ces arguments, la locale utilisée et le format de la chaine dépendent uniquement de l'implémentation.</p>
+La méthode **`toLocaleString()`** renvoie une chaine de caractères représentant la date selon une locale. Les arguments `locales` et `options` permettent aux applications de définir le langage à utiliser pour les conventions de format et permettent de personnaliser le comportement de la fonction. Les anciennes implémentations ignorent ces arguments, la locale utilisée et le format de la chaine dépendent uniquement de l'implémentation.
 
-<div>{{EmbedInteractiveExample("pages/js/date-tolocalestring.html")}}</div>
+{{EmbedInteractiveExample("pages/js/date-tolocalestring.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>dateObj.toLocaleString([locales [, options]])</var></pre>
+    dateObj.toLocaleString([locales [, options]])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<p>Voir le tableau de <a href="#compat" title="#Compatibilit.C3.A9_des_navigateurs">compatibilité des navigateurs</a> afin de déterminer quels navigateurs respectent les arguments <code>locales</code> et <code>options</code> ainsi que l'exemple <a href="#check">Vérifier le support des arguments <code>locales</code> et <code>options</code></a> qui permet de détecter cette fonctionnalité.</p>
+Voir le tableau de [compatibilité des navigateurs](#compat "#Compatibilit.C3.A9_des_navigateurs") afin de déterminer quels navigateurs respectent les arguments `locales` et `options` ainsi que l'exemple [Vérifier le support des arguments `locales` et `options`](#check) qui permet de détecter cette fonctionnalité.
 
-<p>{{page('fr/docs/Web/JavaScript/Reference/Objets_globaux/DateTimeFormat','Paramètres')}}</p>
+{{page('fr/docs/Web/JavaScript/Reference/Objets_globaux/DateTimeFormat','Paramètres')}}
 
-<p>La valeur par défaut de chacun des composants de la date-heure vaut {{jsxref("undefined")}}, mais si les propriétés <code>weekday</code>, <code>year</code>, <code>month</code>, <code>day</code>, <code>hour</code>, <code>minute</code>, <code>second</code> sont toutes {{jsxref("undefined")}},  alors  <code>weekday</code>, <code>year</code>, <code>month</code>, <code>day</code>, <code>hour</code>, <code>minute</code> et <code>second</code> sont supposés être "numeric".</p>
+La valeur par défaut de chacun des composants de la date-heure vaut {{jsxref("undefined")}}, mais si les propriétés `weekday`, `year`, `month`, `day`, `hour`, `minute`, `second` sont toutes {{jsxref("undefined")}},  alors  `weekday`, `year`, `month`, `day`, `hour`, `minute` et `second` sont supposés être "numeric".
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une chaîne de caractères représentant la date indiquée selon des conventions de locales spécifiques.</p>
+Une chaîne de caractères représentant la date indiquée selon des conventions de locales spécifiques.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_toLocaleString()">Utiliser <code>toLocaleString()</code></h3>
+### Utiliser `toLocaleString()`
 
-<p>Voici un usage simple qui ne définit pas de locale : une chaine de caractères dans une locale et avec des options par défaut est renvoyée.</p>
+Voici un usage simple qui ne définit pas de locale : une chaine de caractères dans une locale et avec des options par défaut est renvoyée.
 
-<pre class="brush:js">var date = new Date(Date.UTC(2014, 11, 21, 3, 0, 0));
+```js
+var date = new Date(Date.UTC(2014, 11, 21, 3, 0, 0));
 
 // toLocaleString() sans argument, on utilise donc
 // les valeurs par défaut (de l'implémentation)
 // pour la locale, et le fuseau horaire
 date.toLocaleString();
-// → "21/12/2014 04:00:00" si exécuté dans une locale fr et le fuseau horaire CEST</pre>
+// → "21/12/2014 04:00:00" si exécuté dans une locale fr et le fuseau horaire CEST
+```
 
-<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 arguments <code>locales</code> et <code>options</code> ne sont pas encore supportés par tous les navigateurs. Afin de vérifier si l'implementation utilisée les supporte, vous pouvez utiliser le pré-requis suivant : les locales incorrectes sont rejetées avec une exception {{jsxref("RangeError")}} :</p>
+Les arguments `locales` et `options` ne sont pas encore supportés par tous les navigateurs. Afin de vérifier si l'implementation utilisée les supporte, vous pouvez utiliser le pré-requis suivant : les locales incorrectes sont rejetées avec une exception {{jsxref("RangeError")}} :
 
-<pre class="brush: js">function toLocaleStringSupportsLocales() {
+```js
+function toLocaleStringSupportsLocales() {
     try {
         new Date().toLocaleString("i");
     } catch (e) {
@@ -60,13 +63,14 @@ date.toLocaleString();
     }
     return false;
 }
-</pre>
+```
 
-<h3 id="Utiliser_locales">Utiliser <code>locales</code></h3>
+### Utiliser `locales`
 
-<p>Cet exemple montre quelques variations dues aux formats de dates localisés. Afin d'obtenir le langage utilisé au sein de l'interface utilisateur de votre application, vérifiez de bien fournir ce langage (et éventuellement des locales de recours) en utilisant l'argument <code>locales</code> :</p>
+Cet exemple montre quelques variations dues aux formats de dates localisés. Afin d'obtenir le langage utilisé au sein de l'interface utilisateur de votre application, vérifiez de bien fournir ce langage (et éventuellement des locales de recours) en utilisant l'argument `locales` :
 
-<pre class="brush: js">var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0));
+```js
+var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0));
 
 // les formats qui suivent se basent sur le
 // fuseau horaire CEST
@@ -97,13 +101,14 @@ console.log(date.toLocaleString("ja-JP-u-ca-japanese"));
 // il est possible de fournir un langage de recours (ici l'indonésien)
 console.log(date.toLocaleString(["ban", "id"]));
 // → "20/12/2012 04.00.00"
-</pre>
+```
 
-<h3 id="Utiliser_options">Utiliser <code>options</code></h3>
+### Utiliser `options`
 
-<p>Les résultats fournis par <code>toLocaleString()</code> peuvent être personnalisés grâce à l'argument <code>options</code> :</p>
+Les résultats fournis par `toLocaleString()` peuvent être personnalisés grâce à l'argument `options` :
 
-<pre class="brush: js">var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0));
+```js
+var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0));
 
 // obtenir le jour de la semaine avec une date longue
 var options = {weekday: "long", year: "numeric", month: "long", day: "numeric"};
@@ -119,83 +124,45 @@ console.log(date.toLocaleString("en-US", options));
 // parfois, même les USA ont besoin d'avoir une heure sur 24h
 console.log(date.toLocaleString("en-US", {hour12: false}));
 // → "12/19/2012, 19:00:00"
-</pre>
+```
 
-<h3 id="Comparaison_des_dates_formatées_et_des_valeurs_statiques">Comparaison des dates formatées et des valeurs statiques</h3>
+### Comparaison des dates formatées et des valeurs statiques
 
-<p>La plupart du temps, le format renvoyé par <code>toLocaleString()</code> est cohérent. Toutefois, cela peut évoluer à l'avenir et n'est pas garanti pour l'ensemble des langues (de telles variations sont souhaitables et permises par la spécification). Ainsi, IE et Edge ajoutent des caractères de contrôle bidirectionnels autour des dates afin que le texte produit ait une directionalité cohérente avec le texte avec lequel elles seront concaténées.</p>
+La plupart du temps, le format renvoyé par `toLocaleString()` est cohérent. Toutefois, cela peut évoluer à l'avenir et n'est pas garanti pour l'ensemble des langues (de telles variations sont souhaitables et permises par la spécification). Ainsi, IE et Edge ajoutent des caractères de contrôle bidirectionnels autour des dates afin que le texte produit ait une directionalité cohérente avec le texte avec lequel elles seront concaténées.
 
-<p>Aussi, mieux vaut ne pas comparer un résultat fourni par <code>format()</code> avec une valeur statique :</p>
+Aussi, mieux vaut ne pas comparer un résultat fourni par `format()` avec une valeur statique :
 
-<pre class="brush: js; example-bad">"1.1.2019, 01:00:00" === new Date("2019-01-01T00:00:00.000000Z").toLocaleString();
+```js example-bad
+"1.1.2019, 01:00:00" === new Date("2019-01-01T00:00:00.000000Z").toLocaleString();
 // true pour Firefox et les autres
 // false pour IE et Edge
-</pre>
-
-<div class="blockIndicator note">
-<p><strong>Note :</strong> Voir aussi ce fil <a href="https://stackoverflow.com/questions/25574963/ies-tolocalestring-has-strange-characters-in-results">StackOverflow</a> pour plus de détails et d'exemples.</p>
-</div>
-
-<h2 id="Performance">Performance</h2>
-
-<p>Quand vous formatez d'importants volumes de dates, il est préférable de créer un objet {{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}} et d'utiliser la fonction fournie via la propriété {{jsxref("DateTimeFormat.prototype.format", "format")}}.</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.0.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.9.5.5', 'Date.prototype.toLocaleString')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-date.prototype.tolocalestring', 'Date.prototype.toLocaleString')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-date.prototype.tolocalestring', 'Date.prototype.toLocaleString')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES Int 1.0', '#sec-13.3.1', 'Date.prototype.toLocaleString')}}</td>
-   <td>{{Spec2('ES Int 1.0')}}</td>
-   <td>Définition des arguments <code>locales</code> et <code>options</code>.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES Int 2.0', '#sec-13.3.1', 'Date.prototype.toLocaleString')}}</td>
-   <td>{{Spec2('ES Int 2.0')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES Int Draft', '#sec-Date.prototype.toLocaleString', 'Date.prototype.toLocaleString')}}</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.Date.toLocaleString")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}}</li>
- <li>{{jsxref("Date.prototype.toLocaleDateString()")}}</li>
- <li>{{jsxref("Date.prototype.toLocaleTimeString()")}}</li>
- <li>{{jsxref("Date.prototype.toString()")}}</li>
-</ul>
+```
+
+> **Note :** Voir aussi ce fil [StackOverflow](https://stackoverflow.com/questions/25574963/ies-tolocalestring-has-strange-characters-in-results) pour plus de détails et d'exemples.
+
+## Performance
+
+Quand vous formatez d'importants volumes de dates, il est préférable de créer un objet {{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}} et d'utiliser la fonction fournie via la propriété {{jsxref("DateTimeFormat.prototype.format", "format")}}.
+
+## 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.9.5.5', 'Date.prototype.toLocaleString')}}                                     | {{Spec2('ES5.1')}}         |                                                       |
+| {{SpecName('ES6', '#sec-date.prototype.tolocalestring', 'Date.prototype.toLocaleString')}}             | {{Spec2('ES6')}}             |                                                       |
+| {{SpecName('ESDraft', '#sec-date.prototype.tolocalestring', 'Date.prototype.toLocaleString')}}         | {{Spec2('ESDraft')}}     |                                                       |
+| {{SpecName('ES Int 1.0', '#sec-13.3.1', 'Date.prototype.toLocaleString')}}                                 | {{Spec2('ES Int 1.0')}} | Définition des arguments `locales` et `options`.      |
+| {{SpecName('ES Int 2.0', '#sec-13.3.1', 'Date.prototype.toLocaleString')}}                                 | {{Spec2('ES Int 2.0')}} |                                                       |
+| {{SpecName('ES Int Draft', '#sec-Date.prototype.toLocaleString', 'Date.prototype.toLocaleString')}} | {{Spec2('ES Int Draft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Date.toLocaleString")}}
+
+## Voir aussi
+
+- {{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}}
+- {{jsxref("Date.prototype.toLocaleDateString()")}}
+- {{jsxref("Date.prototype.toLocaleTimeString()")}}
+- {{jsxref("Date.prototype.toString()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/date/tolocaletimestring/index.md b/files/fr/web/javascript/reference/global_objects/date/tolocaletimestring/index.md
index 28764c098c..b6e4af66c9 100644
--- a/files/fr/web/javascript/reference/global_objects/date/tolocaletimestring/index.md
+++ b/files/fr/web/javascript/reference/global_objects/date/tolocaletimestring/index.md
@@ -12,47 +12,50 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Date/toLocaleTimeString
 original_slug: Web/JavaScript/Reference/Objets_globaux/Date/toLocaleTimeString
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>toLocaleTimeString()</strong></code> renvoie une chaine de caractères correspondant à l'heure dans la date, exprimée selon une locale. Les arguments <code>locales</code> et <code>options</code> permettent aux applications de définir le langage utilisé pour les conventions de format et permettent de personnaliser le comportement de la fonction. Les anciennes implémentations ignorent ces arguments, la locale utilisée et le format de la chaine dépendent uniquement de l'implémentation.</p>
+La méthode **`toLocaleTimeString()`** renvoie une chaine de caractères correspondant à l'heure dans la date, exprimée selon une locale. Les arguments `locales` et `options` permettent aux applications de définir le langage utilisé pour les conventions de format et permettent de personnaliser le comportement de la fonction. Les anciennes implémentations ignorent ces arguments, la locale utilisée et le format de la chaine dépendent uniquement de l'implémentation.
 
-<div>{{EmbedInteractiveExample("pages/js/date-tolocaletimestring.html")}}</div>
+{{EmbedInteractiveExample("pages/js/date-tolocaletimestring.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>dateObj</var>.toLocaleTimeString([locales [, options]])</pre>
+    dateObj.toLocaleTimeString([locales [, options]])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<p>Voir le tableau de <a href="#compat" title="#Compatibilit.C3.A9_des_navigateurs">compatibilité des navigateurs</a> afin de déterminer quels navigateurs respectent les arguments <code>locales</code> et <code>options</code> ainsi que l'exemple <a href="#check">Vérifier le support des arguments <code>locales</code> et <code>options</code></a> qui permet de détecter cette fonctionnalité.</p>
+Voir le tableau de [compatibilité des navigateurs](#compat "#Compatibilit.C3.A9_des_navigateurs") afin de déterminer quels navigateurs respectent les arguments `locales` et `options` ainsi que l'exemple [Vérifier le support des arguments `locales` et `options`](#check) qui permet de détecter cette fonctionnalité.
 
-<p>{{page('fr/docs/Web/JavaScript/Reference/Objets_globaux/DateTimeFormat','Param.C3.A8tres')}}</p>
+{{page('fr/docs/Web/JavaScript/Reference/Objets_globaux/DateTimeFormat','Param.C3.A8tres')}}
 
-<p>La valeur par défaut de chacun des composants de la date vaut {{jsxref("undefined")}}, si les propriétés <code>hour</code>, <code>minute</code>, <code>second</code> sont toutes <code>undefined</code>, on suppose alors que <code>hour</code>, <code>minute</code>, et <code>second</code> sont "numeric".</p>
+La valeur par défaut de chacun des composants de la date vaut {{jsxref("undefined")}}, si les propriétés `hour`, `minute`, `second` sont toutes `undefined`, on suppose alors que `hour`, `minute`, et `second` sont "numeric".
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une chaîne de caractères qui représente l'heure de la date indiquée selon des conventions de locales spécifiques.</p>
+Une chaîne de caractères qui représente l'heure de la date indiquée selon des conventions de locales spécifiques.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_toLocaleTimeString()">Utiliser <code>toLocaleTimeString()</code></h3>
+### Utiliser `toLocaleTimeString()`
 
-<p>Voici un usage simple qui ne définit pas de locale : une chaine de caractères dans une locale et avec des options par défaut est renvoyée.</p>
+Voici un usage simple qui ne définit pas de locale : une chaine de caractères dans une locale et avec des options par défaut est renvoyée.
 
-<pre class="brush:js">var date = new Date(Date.UTC(2012, 11, 12, 3, 0, 0));
+```js
+var date = new Date(Date.UTC(2012, 11, 12, 3, 0, 0));
 
 // toLocaleTimeString() sans argument, on utilise donc
 // les valeurs par défaut (de l'implémentation)
 // pour la locale, et le fuseau horaire
 console.log(date.toLocaleTimeString());
-// → "04:00:00" si exécuté dans une locale fr et le fuseau horaire CEST</pre>
+// → "04:00:00" si exécuté dans une locale fr et le fuseau horaire CEST
+```
 
-<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 arguments <code>locales</code> et <code>options</code> ne sont pas encore supportés par tous les navigateurs. Afin de vérifier si l'implementation utilisée les supporte, vous pouvez utiliser le pré-requis suivant : les locales incorrectes sont rejetées avec une exception<code> RangeError</code> :</p>
+Les arguments `locales` et `options` ne sont pas encore supportés par tous les navigateurs. Afin de vérifier si l'implementation utilisée les supporte, vous pouvez utiliser le pré-requis suivant : les locales incorrectes sont rejetées avec une exception` RangeError` :
 
-<pre class="brush: js">function toLocaleTimeStringSupportsLocales() {
+```js
+function toLocaleTimeStringSupportsLocales() {
     try {
         new Date().toLocaleTimeString("i");
     } catch (e) {
@@ -60,13 +63,14 @@ console.log(date.toLocaleTimeString());
     }
     return false;
 }
-</pre>
+```
 
-<h3 id="Utiliser_locales">Utiliser <code>locales</code></h3>
+### Utiliser `locales`
 
-<p>Cet exemple montre quelques variations dues aux formats de dates localisés. Afin d'obtenir le langage utilisé au sein de l'interface utilisateur de votre application, vérifiez de bien fournir ce langage (et éventuellement des locales de recours) en utilisant l'argument <code>locales</code> :</p>
+Cet exemple montre quelques variations dues aux formats de dates localisés. Afin d'obtenir le langage utilisé au sein de l'interface utilisateur de votre application, vérifiez de bien fournir ce langage (et éventuellement des locales de recours) en utilisant l'argument `locales` :
 
-<pre class="brush: js">var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0));
+```js
+var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0));
 
 // les formats qui suivent se basent sur le
 // fuseau horaire CEST
@@ -91,13 +95,14 @@ console.log(date.toLocaleTimeString("ar-EG"));
 // il est possible de fournir un langage de recours (ici l'indonésien)
 console.log(date.toLocaleTimeString(["ban", "id"]));
 // → "4.00.00"
-</pre>
+```
 
-<h3 id="Utiliser_options">Utiliser <code>options</code></h3>
+### Utiliser `options`
 
-<p>Les résultats fournis par <code>toLocaleTimeString()</code> peuvent être personnalisés grâce à l'argument <code>options</code> :</p>
+Les résultats fournis par `toLocaleTimeString()` peuvent être personnalisés grâce à l'argument `options` :
 
-<pre class="brush: js">var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0));
+```js
+var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0));
 
 // une application peut vouloir utiliser UTC et le montrer
 var options = {timeZone: "UTC", timeZoneName: "short"};
@@ -107,69 +112,32 @@ console.log(date.toLocaleTimeString("en-US", options));
 // parfois, même les USA ont besoin du format sur 24h
 console.log(date.toLocaleTimeString("en-US", {hour12: false}));
 // → "19:00:00"
-</pre>
-
-<h2 id="Performance">Performance</h2>
-
-<p>Pour formater de nombreuses dates, il est préférable de créer un objet {{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}} et d'utiliser la fonction fournie par sa propriété {{jsxref("DateTimeFormat.prototype.format", "format")}}.</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.0.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.9.5.7', 'Date.prototype.toLocaleTimeString')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-date.prototype.tolocalestring', 'Date.prototype.toLocaleTimeString')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-date.prototype.tolocalestring', 'Date.prototype.toLocaleTimeString')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES Int 1.0', '#sec-13.3.3', 'Date.prototype.toLocaleTimeString')}}</td>
-   <td>{{Spec2('ES Int 1.0')}}</td>
-   <td>Définition des arguments <code>locales</code> et <code>options</code>.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES Int 2.0', '#sec-13.3.3', 'Date.prototype.toLocaleTimeString')}}</td>
-   <td>{{Spec2('ES Int 2.0')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES Int Draft', '#sec-Date.prototype.toLocaleTimeString', 'Date.prototype.toLocaleTimeString')}}</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.Date.toLocaleTimeString")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}}</li>
- <li>{{jsxref("Date.prototype.toLocaleDateString()")}}</li>
- <li>{{jsxref("Date.prototype.toLocaleString()")}}</li>
- <li>{{jsxref("Date.prototype.toTimeString()")}}</li>
- <li>{{jsxref("Date.prototype.toString()")}}</li>
-</ul>
+```
+
+## Performance
+
+Pour formater de nombreuses dates, il est préférable de créer un objet {{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}} et d'utiliser la fonction fournie par sa propriété {{jsxref("DateTimeFormat.prototype.format", "format")}}.
+
+## Spécifications
+
+| Spécification                                                                                                                                    | État                             | Commentaires                                          |
+| ------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------- | ----------------------------------------------------- |
+| {{SpecName('ES3')}}                                                                                                                         | {{Spec2('ES3')}}             | Définition initiale. Implémentée avec JavaScript 1.0. |
+| {{SpecName('ES5.1', '#sec-15.9.5.7', 'Date.prototype.toLocaleTimeString')}}                                             | {{Spec2('ES5.1')}}         |                                                       |
+| {{SpecName('ES6', '#sec-date.prototype.tolocalestring', 'Date.prototype.toLocaleTimeString')}}                     | {{Spec2('ES6')}}             |                                                       |
+| {{SpecName('ESDraft', '#sec-date.prototype.tolocalestring', 'Date.prototype.toLocaleTimeString')}}             | {{Spec2('ESDraft')}}     |                                                       |
+| {{SpecName('ES Int 1.0', '#sec-13.3.3', 'Date.prototype.toLocaleTimeString')}}                                         | {{Spec2('ES Int 1.0')}} | Définition des arguments `locales` et `options`.      |
+| {{SpecName('ES Int 2.0', '#sec-13.3.3', 'Date.prototype.toLocaleTimeString')}}                                         | {{Spec2('ES Int 2.0')}} |                                                       |
+| {{SpecName('ES Int Draft', '#sec-Date.prototype.toLocaleTimeString', 'Date.prototype.toLocaleTimeString')}} | {{Spec2('ES Int Draft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Date.toLocaleTimeString")}}
+
+## Voir aussi
+
+- {{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}}
+- {{jsxref("Date.prototype.toLocaleDateString()")}}
+- {{jsxref("Date.prototype.toLocaleString()")}}
+- {{jsxref("Date.prototype.toTimeString()")}}
+- {{jsxref("Date.prototype.toString()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/date/tosource/index.md b/files/fr/web/javascript/reference/global_objects/date/tosource/index.md
index 93d004781e..0564beedc8 100644
--- a/files/fr/web/javascript/reference/global_objects/date/tosource/index.md
+++ b/files/fr/web/javascript/reference/global_objects/date/tosource/index.md
@@ -10,47 +10,43 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Date/toSource
 original_slug: Web/JavaScript/Reference/Objets_globaux/Date/toSource
 ---
-<div>{{JSRef}} {{Non-standard_header}}</div>
+{{JSRef}} {{Non-standard_header}}
 
-<p>La méthode <code><strong>toSource()</strong></code> renvoie une chaîne de caractères représentant le code source de l'objet.</p>
+La méthode **`toSource()`** renvoie une chaîne de caractères représentant le code source de l'objet.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>dateObj</var>.toSource()
-Date.toSource()</pre>
+    dateObj.toSource()
+    Date.toSource()
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une chaîne de caractères représentant le code source de l'objet date indiqué.</p>
+Une chaîne de caractères représentant le code source de l'objet date indiqué.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La méthode <code>toSource()</code> renvoie les valeur suivantes :</p>
+La méthode `toSource()` renvoie les valeur suivantes :
 
-<ul>
- <li>Pour l'objet natif {{jsxref("Date")}}, <code>toSource()</code> renvoie la chaîne de caractères suivante, indiquant que le code source n'est pas disponible :</li>
-</ul>
+- Pour l'objet natif {{jsxref("Date")}}, `toSource()` renvoie la chaîne de caractères suivante, indiquant que le code source n'est pas disponible :
 
-<pre class="brush: js">function Date() {
+```js
+function Date() {
     [native code]
-}</pre>
+}
+```
 
-<ul>
- <li>Pour les instances de {{jsxref("Date")}}, <code>toSource()</code> renvoie une chaîne de caractères représentant le code source.</li>
-</ul>
+- Pour les instances de {{jsxref("Date")}}, `toSource()` renvoie une chaîne de caractères représentant le code source.
 
-<p>Cette méthode est habituellement appelée en interne par le moteur JavaScript et non explicitement dans le code d'un script.</p>
+Cette méthode est habituellement appelée en interne par le moteur JavaScript et non explicitement dans le code d'un script.
 
-<h2 id="Spécifications">Spécifications</h2>
+## Spécifications
 
-<p>Ne fait partie d'aucune spécification. Implémentée dans JavaScript 1.3.</p>
+Ne fait partie d'aucune spécification. Implémentée dans JavaScript 1.3.
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.Date.toSource")}}</p>
+{{Compat("javascript.builtins.Date.toSource")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("Object.prototype.toSource()")}}</li>
-</ul>
+- {{jsxref("Object.prototype.toSource()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/date/tostring/index.md b/files/fr/web/javascript/reference/global_objects/date/tostring/index.md
index b548fb5d0c..f25b125d01 100644
--- a/files/fr/web/javascript/reference/global_objects/date/tostring/index.md
+++ b/files/fr/web/javascript/reference/global_objects/date/tostring/index.md
@@ -10,123 +10,90 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Date/toString
 original_slug: Web/JavaScript/Reference/Objets_globaux/Date/toString
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>toString()</strong></code> renvoie une chaîne de caractères représentant l'objet {{jsxref("Date")}}.</p>
+La méthode **`toString()`** renvoie une chaîne de caractères représentant l'objet {{jsxref("Date")}}.
 
-<div>{{EmbedInteractiveExample("pages/js/date-tostring.html")}}</div>
+{{EmbedInteractiveExample("pages/js/date-tostring.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>dateObj</var>.toString()</pre>
+    dateObj.toString()
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une chaîne de caractères représentant la date indiquée.</p>
+Une chaîne de caractères représentant la date indiquée.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>L'objet {{jsxref("Date")}} remplace la méthode <code>toString()</code> de l'objet {{jsxref("Object")}} ; il n'hérite pas de {{jsxref("Object.prototype.toString()")}}. Pour les objets {{jsxref("Date")}}, la méthode <code>toString()</code> renvoie une représentation textuelle de l'objet.</p>
+L'objet {{jsxref("Date")}} remplace la méthode `toString()` de l'objet {{jsxref("Object")}} ; il n'hérite pas de {{jsxref("Object.prototype.toString()")}}. Pour les objets {{jsxref("Date")}}, la méthode `toString()` renvoie une représentation textuelle de l'objet.
 
-<p>La méthode <code>toString()</code> renvoie toujours une chaîne de caractères représentant une date en anglais américain. Ce format a été standardisé avec ES2018 et peut être décrit de la façon suivante :</p>
+La méthode `toString()` renvoie toujours une chaîne de caractères représentant une date en anglais américain. Ce format a été standardisé avec ES2018 et peut être décrit de la façon suivante :
 
-<ul>
- <li>Le jour de la semaine avec les trois premières lettres du jour en anglais (ex. « Sat »)</li>
- <li>Un espace</li>
- <li>Le mois avec les trois premières lettres du mois en anglais (ex. « Sep »)</li>
- <li>Un espace</li>
- <li>La date du jour dans le mois sur deux chiffres (ex. « 01 »)</li>
- <li>Un espace</li>
- <li>L'année sur 4 chiffres (ex. « 2018 »)</li>
- <li>Un espace</li>
- <li>L'heure sur deux chiffres (ex. « 14 »)</li>
- <li>Un deux-points (:)</li>
- <li>Les minutes sur deux chiffres (ex. « 53 »)</li>
- <li>Un deux-points (:)</li>
- <li>Les secondes sur deux chiffres (ex. « 26 »)</li>
- <li>Un espace</li>
- <li>La chaîne de caractères « GMT »</li>
- <li>Le signe du décalage horaire par rapport à GMT :
-  <ul>
-   <li>La chaîne "+" pour les décalages positifs (0 ou plus)</li>
-   <li>La chaîne "-" pour les décalages strictement négatifs</li>
-  </ul>
- </li>
- <li>L'heure de décalage sur deux chiffres</li>
- <li>Les minutes de décalage sur deux chiffres</li>
- <li>Et, éventuellement, le nom du fuseau horaire avec
-  <ul>
-   <li>Un espace</li>
-   <li>Une parenthèse ouvrante (« ( »)</li>
-   <li>Une chaîne de caractères, pouvant varier selon l'implémentation, qui désigne le fuseau horaire. Ce peut être une abréviation ou un nom complet.</li>
-   <li>Une parenthèse fermante (« ) »)</li>
-  </ul>
- </li>
-</ul>
+- Le jour de la semaine avec les trois premières lettres du jour en anglais (ex. « Sat »)
+- Un espace
+- Le mois avec les trois premières lettres du mois en anglais (ex. « Sep »)
+- Un espace
+- La date du jour dans le mois sur deux chiffres (ex. « 01 »)
+- Un espace
+- L'année sur 4 chiffres (ex. « 2018 »)
+- Un espace
+- L'heure sur deux chiffres (ex. « 14 »)
+- Un deux-points (:)
+- Les minutes sur deux chiffres (ex. « 53 »)
+- Un deux-points (:)
+- Les secondes sur deux chiffres (ex. « 26 »)
+- Un espace
+- La chaîne de caractères « GMT »
+- Le signe du décalage horaire par rapport à GMT :
 
-<p>Avant ES2018, le format de la chaîne de caractères renvoyé pouvait varier selon l'implémentation.</p>
+  - La chaîne "+" pour les décalages positifs (0 ou plus)
+  - La chaîne "-" pour les décalages strictement négatifs
 
-<p>JavaScript appelle la méthode <code>toString()</code> automatiquement quand une date doit être representée sous forme d'un texte ou quand une date est référencée lors d'une concatenation de chaînes de caractères.</p>
+- L'heure de décalage sur deux chiffres
+- Les minutes de décalage sur deux chiffres
+- Et, éventuellement, le nom du fuseau horaire avec
 
-<p><code>toString()</code> est une méthode générique. Si <code>this</code> n'est pas une instance de {{jsxref("Date")}}, elle renverra "Invalid Date".</p>
+  - Un espace
+  - Une parenthèse ouvrante (« ( »)
+  - Une chaîne de caractères, pouvant varier selon l'implémentation, qui désigne le fuseau horaire. Ce peut être une abréviation ou un nom complet.
+  - Une parenthèse fermante (« ) »)
 
-<h2 id="Exemples">Exemples</h2>
+Avant ES2018, le format de la chaîne de caractères renvoyé pouvait varier selon l'implémentation.
 
-<h3 id="Utiliser_toString()">Utiliser <code>toString()</code></h3>
+JavaScript appelle la méthode `toString()` automatiquement quand une date doit être representée sous forme d'un texte ou quand une date est référencée lors d'une concatenation de chaînes de caractères.
 
-<p>L'exemple suivant assigne la valeur de <code>toString()</code> de l'objet <code>Date</code> à <code>maVar</code> :</p>
+`toString()` est une méthode générique. Si `this` n'est pas une instance de {{jsxref("Date")}}, elle renverra "Invalid Date".
 
-<pre class="brush:js">var x = new Date();
+## Exemples
+
+### Utiliser `toString()`
+
+L'exemple suivant assigne la valeur de `toString()` de l'objet `Date` à `maVar` :
+
+```js
+var x = new Date();
 var maVar = x.toString(); // assigne une valeur à maVar similaire à :
 // Mon Sep 28 1998 14:36:22 GMT-0700 (PDT)
-</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.0.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.9.5.2', 'Date.prototype.toLocaleTimeString')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-date.prototype.tostring', 'Date.prototype.toString')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES2018', '#sec-date.prototype.tostring', 'Date.prototype.toString')}}</td>
-   <td>{{Spec2('ES2018')}}</td>
-   <td>Standardisation du format produit par <code>Date.prototype.toString()</code></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-date.prototype.tostring', 'Date.prototype.toString')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Date.toString")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Object.prototype.toString()")}}</li>
- <li>{{jsxref("Date.prototype.toDateString()")}}</li>
- <li>{{jsxref("Date.prototype.toLocaleString()")}}</li>
- <li>{{jsxref("Date.prototype.toTimeString()")}}</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.9.5.2', 'Date.prototype.toLocaleTimeString')}}         | {{Spec2('ES5.1')}}     |                                                                   |
+| {{SpecName('ES6', '#sec-date.prototype.tostring', 'Date.prototype.toString')}}     | {{Spec2('ES6')}}         |                                                                   |
+| {{SpecName('ES2018', '#sec-date.prototype.tostring', 'Date.prototype.toString')}} | {{Spec2('ES2018')}}     | Standardisation du format produit par `Date.prototype.toString()` |
+| {{SpecName('ESDraft', '#sec-date.prototype.tostring', 'Date.prototype.toString')}} | {{Spec2('ESDraft')}} |                                                                   |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Date.toString")}}
+
+## Voir aussi
+
+- {{jsxref("Object.prototype.toString()")}}
+- {{jsxref("Date.prototype.toDateString()")}}
+- {{jsxref("Date.prototype.toLocaleString()")}}
+- {{jsxref("Date.prototype.toTimeString()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/date/totimestring/index.md b/files/fr/web/javascript/reference/global_objects/date/totimestring/index.md
index 8931f46e60..cabaa9ae84 100644
--- a/files/fr/web/javascript/reference/global_objects/date/totimestring/index.md
+++ b/files/fr/web/javascript/reference/global_objects/date/totimestring/index.md
@@ -10,76 +10,52 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Date/toTimeString
 original_slug: Web/JavaScript/Reference/Objets_globaux/Date/toTimeString
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>toTimeString()</strong></code>renvoie la partie « heure » de l'objet <code>Date</code> dans un format lisible par un humain, en anglais américain.</p>
+La méthode **`toTimeString()`**renvoie la partie « heure » de l'objet `Date` dans un format lisible par un humain, en anglais américain.
 
-<div>{{EmbedInteractiveExample("pages/js/date-totimestring.html")}}</div>
+{{EmbedInteractiveExample("pages/js/date-totimestring.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>dateObj</var>.toTimeString()</pre>
+    dateObj.toTimeString()
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une chaîne de caractères qui représente l'heure de la date indiquée dans un format anglais américain.</p>
+Une chaîne de caractères qui représente l'heure de la date indiquée dans un format anglais américain.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Une instance de {{jsxref("Date")}} représente un instant précis dans le temps. Appeler {{jsxref("Date.toString", "toString()")}} renverra la date formatée de façon à être lisible par un humain, en anglais américain. Pour le moteur JavaScript <a href="/fr/docs/SpiderMonkey">SpiderMonkey</a>, ceci consiste en la partie « date » (jour, mois, année) suivie de la partie « heure » (heures, minutes, secondes, et fuseau horaire). Parfois, il est préférable d'obtenir seulement la partie « heure » ; c'est ce que renvoie la méthode <code>toTimeString().</code></p>
+Une instance de {{jsxref("Date")}} représente un instant précis dans le temps. Appeler {{jsxref("Date.toString", "toString()")}} renverra la date formatée de façon à être lisible par un humain, en anglais américain. Pour le moteur JavaScript [SpiderMonkey](/fr/docs/SpiderMonkey), ceci consiste en la partie « date » (jour, mois, année) suivie de la partie « heure » (heures, minutes, secondes, et fuseau horaire). Parfois, il est préférable d'obtenir seulement la partie « heure » ; c'est ce que renvoie la méthode `toTimeString().`
 
-<p>La méthode <code>toTimeString()</code> est particulièrement utile parce que les moteurs implémentant <a href="/fr/docs/JavaScript/Language_Resources">ECMA-262</a> peuvent obtenir des résultats différents avec la méthode {{jsxref("Date.prototype.toString()", "toString()")}} (en effet, le format dépend de l'implémentation). Ceci peut empêcher les manipulations de textes simples d'avoir des résultats cohérents au sein des différents moteurs/navigateurs.</p>
+La méthode `toTimeString()` est particulièrement utile parce que les moteurs implémentant [ECMA-262](/fr/docs/JavaScript/Language_Resources) peuvent obtenir des résultats différents avec la méthode {{jsxref("Date.prototype.toString()", "toString()")}} (en effet, le format dépend de l'implémentation). Ceci peut empêcher les manipulations de textes simples d'avoir des résultats cohérents au sein des différents moteurs/navigateurs.
 
-<h2 id="Exemple">Exemple</h2>
+## Exemple
 
-<h3 id="Utiliser_toTimeString()">Utiliser <code>toTimeString()</code></h3>
+### Utiliser `toTimeString()`
 
-<pre class="brush:js">var d = new Date(1993, 6, 28, 14, 39, 7);
+```js
+var d = new Date(1993, 6, 28, 14, 39, 7);
 
 console.log(d.toString());     // Wed Jul 28 1993 14:39:07 GMT-0600 (PDT)
 console.log(d.toTimeString()); // 14:39:07 GMT-0600 (PDT)
-</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.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.9.5.4', 'Date.prototype.toTimeString')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-date.prototype.totimestring', 'Date.prototype.toTimeString')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-date.prototype.totimestring', 'Date.prototype.toTimeString')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Date.toTimeString")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Date.prototype.toLocaleTimeString()")}}</li>
- <li>{{jsxref("Date.prototype.toDateString()")}}</li>
- <li>{{jsxref("Date.prototype.toString()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                            | État                         | Commentaires         |
+| ------------------------------------------------------------------------------------------------------------------------ | ---------------------------- | -------------------- |
+| {{SpecName('ES3')}}                                                                                                 | {{Spec2('ES3')}}         | Définition initiale. |
+| {{SpecName('ES5.1', '#sec-15.9.5.4', 'Date.prototype.toTimeString')}}                             | {{Spec2('ES5.1')}}     |                      |
+| {{SpecName('ES6', '#sec-date.prototype.totimestring', 'Date.prototype.toTimeString')}}     | {{Spec2('ES6')}}         |                      |
+| {{SpecName('ESDraft', '#sec-date.prototype.totimestring', 'Date.prototype.toTimeString')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Date.toTimeString")}}
+
+## Voir aussi
+
+- {{jsxref("Date.prototype.toLocaleTimeString()")}}
+- {{jsxref("Date.prototype.toDateString()")}}
+- {{jsxref("Date.prototype.toString()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/date/toutcstring/index.md b/files/fr/web/javascript/reference/global_objects/date/toutcstring/index.md
index fb08c111a8..b7db523967 100644
--- a/files/fr/web/javascript/reference/global_objects/date/toutcstring/index.md
+++ b/files/fr/web/javascript/reference/global_objects/date/toutcstring/index.md
@@ -10,80 +10,52 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Date/toUTCString
 original_slug: Web/JavaScript/Reference/Objets_globaux/Date/toUTCString
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>toUTCString()</strong></code> convertit une date en une chaîne de caractères, selon le fuseau horaire UTC.</p>
+La méthode **`toUTCString()`** convertit une date en une chaîne de caractères, selon le fuseau horaire UTC.
 
-<div>{{EmbedInteractiveExample("pages/js/date-toutcstring.html")}}</div>
+{{EmbedInteractiveExample("pages/js/date-toutcstring.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>dateObj</var>.toUTCString()</pre>
+    dateObj.toUTCString()
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une chaîne de caractères représentant la date indiquée selon le fuseau horaire UTC.</p>
+Une chaîne de caractères représentant la date indiquée selon le fuseau horaire UTC.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La valeur renvoyée par <code>toUTCString()</code> est un texte au même format que celui renvoyé {{jsxref("Date.prototype.toString()")}} mais sans décalage de fuseau horaire (en UTC).</p>
+La valeur renvoyée par `toUTCString()` est un texte au même format que celui renvoyé {{jsxref("Date.prototype.toString()")}} mais sans décalage de fuseau horaire (en UTC).
 
-<p>Avant ECMAScript 2018, le format de la valeur renvoyée pouvait varier selon les plateformes. La valeur la plus couramment renvoyée était une date formatée selon la RFC 1123, qui est une version mise à jour de la RFC 822.</p>
+Avant ECMAScript 2018, le format de la valeur renvoyée pouvait varier selon les plateformes. La valeur la plus couramment renvoyée était une date formatée selon la RFC 1123, qui est une version mise à jour de la RFC 822.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_toUTCString()">Utiliser <code>toUTCString()</code></h3>
+### Utiliser `toUTCString()`
 
-<pre class="brush: js">var aujourdhui = new Date();
+```js
+var aujourdhui = new Date();
 var UTCstring = aujourdhui.toUTCString();
 // Mon, 03 Jul 2006 21:44:38 GMT
-</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.3. Le format dépend de l'implémentation.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.9.5.42', 'Date.prototype.toUTCString')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-date.prototype.toutcstring', 'Date.prototype.toUTCString')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES2018', '#sec-date.prototype.toutcstring', 'Date.prototype.toUTCString')}}</td>
-   <td>{{Spec2('ES2018')}}</td>
-   <td>Première standardisation du format</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-date.prototype.toutcstring', 'Date.prototype.toUTCString')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Date.toUTCString")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Date.prototype.toLocaleString()")}}</li>
- <li>{{jsxref("Date.prototype.toDateString()")}}</li>
- <li>{{jsxref("Date.prototype.toISOString()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                        | État                         | Commentaires                                                                                |
+| -------------------------------------------------------------------------------------------------------------------- | ---------------------------- | ------------------------------------------------------------------------------------------- |
+| {{SpecName('ES1')}}                                                                                             | {{Spec2('ES1')}}         | Définition initiale. Implémentée avec JavaScript 1.3. Le format dépend de l'implémentation. |
+| {{SpecName('ES5.1', '#sec-15.9.5.42', 'Date.prototype.toUTCString')}}                         | {{Spec2('ES5.1')}}     |                                                                                             |
+| {{SpecName('ES6', '#sec-date.prototype.toutcstring', 'Date.prototype.toUTCString')}}     | {{Spec2('ES6')}}         |                                                                                             |
+| {{SpecName('ES2018', '#sec-date.prototype.toutcstring', 'Date.prototype.toUTCString')}} | {{Spec2('ES2018')}}     | Première standardisation du format                                                          |
+| {{SpecName('ESDraft', '#sec-date.prototype.toutcstring', 'Date.prototype.toUTCString')}} | {{Spec2('ESDraft')}} |                                                                                             |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Date.toUTCString")}}
+
+## Voir aussi
+
+- {{jsxref("Date.prototype.toLocaleString()")}}
+- {{jsxref("Date.prototype.toDateString()")}}
+- {{jsxref("Date.prototype.toISOString()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/date/utc/index.md b/files/fr/web/javascript/reference/global_objects/date/utc/index.md
index 8caed69035..6dbf12f938 100644
--- a/files/fr/web/javascript/reference/global_objects/date/utc/index.md
+++ b/files/fr/web/javascript/reference/global_objects/date/utc/index.md
@@ -9,126 +9,99 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Date/UTC
 original_slug: Web/JavaScript/Reference/Objets_globaux/Date/UTC
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>Date.UTC()</code></strong> accepte des paramètres similaires à ceux du constructeur {{jsxref("Date")}} et renvoie le nombre de millièmes de seconde depuis le 1er janvier 1970, 00:00:00, temps universel. Autrement dit, elle renvoie la date en UTC.</p>
+La méthode **`Date.UTC()`** accepte des paramètres similaires à ceux du constructeur {{jsxref("Date")}} et renvoie le nombre de millièmes de seconde depuis le 1er janvier 1970, 00:00:00, temps universel. Autrement dit, elle renvoie la date en UTC.
 
-<div>{{EmbedInteractiveExample("pages/js/date-utc.html")}}</div>
+{{EmbedInteractiveExample("pages/js/date-utc.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">Date.UTC(<em>année</em>[,<em>mois</em>[,<em>jour</em>[,<em>heures</em>[,<em>minutes</em>[,<em>secondes</em>[,<em>ms</em>]]]]]])</pre>
+    Date.UTC(année[,mois[,jour[,heures[,minutes[,secondes[,ms]]]]]])
 
-<h2 id="Paramètres">Paramètres</h2>
+## Paramètres
 
-<dl>
- <dt><code>année</code></dt>
- <dd>Une année sur deux chiffres pour une année après 1900 (ex. 98 pour 1998) ou bien une année sur quatre chiffres (2018).</dd>
- <dt><code>mois</code>{{optional_inline}}</dt>
- <dd>
- <p>Un entier entre 0 (janvier) et 11 (décembre) représentant le mois.</p>
+- `année`
+  - : Une année sur deux chiffres pour une année après 1900 (ex. 98 pour 1998) ou bien une année sur quatre chiffres (2018).
+- `mois`{{optional_inline}}
 
- <div class="note"><p><strong>Note :</strong> Cet argument est optionnel depuis ECMAScript 2017.</p></div>
- </dd>
- <dt><code>jour</code>{{optional_inline}}</dt>
- <dd>Un entier entre 1 et 31 représentant le jour du mois. La valeur par défaut vaut 1.</dd>
- <dt><code>heures</code>{{optional_inline}}</dt>
- <dd>Paramètre optionnel, un entier entre 0 et 23 représentant les heures. La valeur par défaut vaut 0.</dd>
- <dt><code>minutes</code>{{optional_inline}}</dt>
- <dd>Paramètre optionnel, un entier entre 0 et 59 représentant les minutes. La valeur par défaut vaut 0.</dd>
- <dt><code>secondes</code>{{optional_inline}}</dt>
- <dd>Paramètre optionnel, un entier entre 0 et 59 représentant les secondes. La valeur par défaut vaut 0.</dd>
- <dt><code>ms</code>{{optional_inline}}</dt>
- <dd>Paramètre optionnel, un entier entre 0 et 999 représentant les millièmes de seconde. La valeur par défaut vaut 0.</dd>
-</dl>
+  - : Un entier entre 0 (janvier) et 11 (décembre) représentant le mois.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+    > **Note :** Cet argument est optionnel depuis ECMAScript 2017.
 
-<p>Un nombre représentant le nombre de millisecondes écoulées entre la date indiquée et le premier janvier 1970 à minuit UTC.</p>
+- `jour`{{optional_inline}}
+  - : Un entier entre 1 et 31 représentant le jour du mois. La valeur par défaut vaut 1.
+- `heures`{{optional_inline}}
+  - : Paramètre optionnel, un entier entre 0 et 23 représentant les heures. La valeur par défaut vaut 0.
+- `minutes`{{optional_inline}}
+  - : Paramètre optionnel, un entier entre 0 et 59 représentant les minutes. La valeur par défaut vaut 0.
+- `secondes`{{optional_inline}}
+  - : Paramètre optionnel, un entier entre 0 et 59 représentant les secondes. La valeur par défaut vaut 0.
+- `ms`{{optional_inline}}
+  - : Paramètre optionnel, un entier entre 0 et 999 représentant les millièmes de seconde. La valeur par défaut vaut 0.
 
-<h2 id="Description">Description</h2>
+### Valeur de retour
 
-<p>La méthode <code>UTC</code> prend des paramètres de date et d'heure séparés par des virgules et renvoie le nombre de millièmes de seconde entre le 1er janvier 1970, 00:00:00, temps universel et la date et l'heure spécifiées.</p>
+Un nombre représentant le nombre de millisecondes écoulées entre la date indiquée et le premier janvier 1970 à minuit UTC.
 
-<p>Il faut spécifier l'année entière pour le premier paramètre ; par exemple 1998. Si l'année spécifiée est entre 0 et 99, la méthode la convertira en une année du XXe siècle (1900 + année) ; par exemple si vous indiquez 95, l'année 1995 sera utilisée.</p>
+## Description
 
-<p>La méthode <code>UTC</code> diffère du constructeur {{jsxref("Date")}} pour deux raisons :</p>
+La méthode `UTC` prend des paramètres de date et d'heure séparés par des virgules et renvoie le nombre de millièmes de seconde entre le 1er janvier 1970, 00:00:00, temps universel et la date et l'heure spécifiées.
 
-<ul>
- <li><code>Date.UTC</code> utilise le temps universel plutôt que l'heure locale.</li>
- <li><code>Date.UTC</code> renvoie une valeur temporelle sous la forme d'un nombre plutôt que de créer un objet <code>Date</code>.</li>
-</ul>
+Il faut spécifier l'année entière pour le premier paramètre ; par exemple 1998. Si l'année spécifiée est entre 0 et 99, la méthode la convertira en une année du XXe siècle (1900 + année) ; par exemple si vous indiquez 95, l'année 1995 sera utilisée.
 
-<p>Si un paramètre spécifié est en dehors des limites attendues, la méthode <code>UTC</code> met à jour les autres paramètres pour s'adapter à ce nombre. Par exemple, si vous utilisez 15 pour le mois, l'année sera incrémentée d'une unité (année + 1), et la valeur 3 (avril) sera utilisée pour le mois.</p>
+La méthode `UTC` diffère du constructeur {{jsxref("Date")}} pour deux raisons :
 
-<p>Comme <code>UTC</code> est une méthode statique de <code>Date</code>, on l'utilise toujours sous la forme <code>Date.UTC()</code> plutôt que comme une méthode d'un objet <code>Date</code> que vous auriez créé.</p>
+- `Date.UTC` utilise le temps universel plutôt que l'heure locale.
+- `Date.UTC` renvoie une valeur temporelle sous la forme d'un nombre plutôt que de créer un objet `Date`.
 
-<h2 id="Exemples">Exemples</h2>
+Si un paramètre spécifié est en dehors des limites attendues, la méthode `UTC` met à jour les autres paramètres pour s'adapter à ce nombre. Par exemple, si vous utilisez 15 pour le mois, l'année sera incrémentée d'une unité (année + 1), et la valeur 3 (avril) sera utilisée pour le mois.
 
-<h3 id="Utiliser_Date.UTC()">Utiliser <code>Date.UTC()</code></h3>
+Comme `UTC` est une méthode statique de `Date`, on l'utilise toujours sous la forme `Date.UTC()` plutôt que comme une méthode d'un objet `Date` que vous auriez créé.
 
-<p>L'instruction qui suit crée un objet <code>Date</code> en utilisant l'heure UTC plutôt que l'heure locale :</p>
+## Exemples
 
-<pre class="brush: js">var utcDate = new Date(Date.UTC(96, 11, 1, 0, 0, 0));
-</pre>
+### Utiliser `Date.UTC()`
 
-<h2 id="Spécifications">Spécifications</h2>
+L'instruction qui suit crée un objet `Date` en utilisant l'heure UTC plutôt que l'heure locale :
 
-<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-date.utc', 'Date.UTC')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td>Le paramètre pour le mois est devenu optionnel avec ES2017.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-date.utc', 'Date.UTC')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.9.4.3', 'Date.UTC')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES1')}}</td>
-   <td>{{Spec2('ES1')}}</td>
-   <td>Définition initiale. Implémentée avec JavaScript 1.0.</td>
-  </tr>
- </tbody>
-</table>
+```js
+var utcDate = new Date(Date.UTC(96, 11, 1, 0, 0, 0));
+```
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Spécifications
 
-<p>{{Compat("javascript.builtins.Date.UTC")}}</p>
+| Spécification                                                        | État                         | Commentaires                                                |
+| -------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------------- |
+| {{SpecName('ESDraft', '#sec-date.utc', 'Date.UTC')}} | {{Spec2('ESDraft')}} | Le paramètre pour le mois est devenu optionnel avec ES2017. |
+| {{SpecName('ES6', '#sec-date.utc', 'Date.UTC')}}     | {{Spec2('ES6')}}         |                                                             |
+| {{SpecName('ES5.1', '#sec-15.9.4.3', 'Date.UTC')}} | {{Spec2('ES5.1')}}     |                                                             |
+| {{SpecName('ES1')}}                                             | {{Spec2('ES1')}}         | Définition initiale. Implémentée avec JavaScript 1.0.       |
 
-<h2 id="Notes_de_compatibilité">Notes de compatibilité</h2>
+## Compatibilité des navigateurs
 
-<h3 id="Utiliser_Date.UTC_avec_moins_de_deux_arguments">Utiliser <code>Date.UTC</code> avec moins de deux arguments</h3>
+{{Compat("javascript.builtins.Date.UTC")}}
 
-<p>Lorsqu'on fournit moins de deux arguments à <code>Date.UTC</code>, {{jsxref("NaN")}} sera renvoyé. Ce comportement a été spécifié dans ECMAScript 2017 et les moteurs qui n'obéissaient pas à cette règle on été mis à jour (cf. {{bug(1050755)}}, <a href="https://github.com/tc39/ecma262/pull/642">ecma-262 #642</a>).</p>
+## Notes de compatibilité
 
-<pre class="brush: js">Date.UTC();
+### Utiliser `Date.UTC` avec moins de deux arguments
+
+Lorsqu'on fournit moins de deux arguments à `Date.UTC`, {{jsxref("NaN")}} sera renvoyé. Ce comportement a été spécifié dans ECMAScript 2017 et les moteurs qui n'obéissaient pas à cette règle on été mis à jour (cf. {{bug(1050755)}}, [ecma-262 #642](https://github.com/tc39/ecma262/pull/642)).
+
+```js
+Date.UTC();
 Date.UTC(1);
 
 // Safari: NaN
 // Chrome/Opera/V8: NaN
 
-// Firefox &lt;54: non-NaN
+// Firefox <54: non-NaN
 // Firefox 54+: NaN
 
 // IE: non-NaN
 // Edge: NaN
-</pre>
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("Date.parse()")}}</li>
-</ul>
+- {{jsxref("Date.parse()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/date/valueof/index.md b/files/fr/web/javascript/reference/global_objects/date/valueof/index.md
index fb835f4c3b..684d275338 100644
--- a/files/fr/web/javascript/reference/global_objects/date/valueof/index.md
+++ b/files/fr/web/javascript/reference/global_objects/date/valueof/index.md
@@ -10,75 +10,51 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Date/valueOf
 original_slug: Web/JavaScript/Reference/Objets_globaux/Date/valueOF
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>valueOf()</code></strong> renvoie la valeur primitive d'un objet {{jsxref("Date")}}.</p>
+La méthode **`valueOf()`** renvoie la valeur primitive d'un objet {{jsxref("Date")}}.
 
-<div>{{EmbedInteractiveExample("pages/js/date-valueof.html")}}</div>
+{{EmbedInteractiveExample("pages/js/date-valueof.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>date</var>.valueOf()</pre>
+    date.valueOf()
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Le nombre de millisecondes écoulées entre le premier janvier 1970, minuit UTC et la date indiquée.</p>
+Le nombre de millisecondes écoulées entre le premier janvier 1970, minuit UTC et la date indiquée.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La méthode <code>valueOf()</code> renvoie la valeur primitive d'un objet <code>Date</code> sous forme d'un nombre. Ce nombre correspond au nombre de millisecondes écoulées depuis le 1 janvier 1970 00h00 GMT.</p>
+La méthode `valueOf()` renvoie la valeur primitive d'un objet `Date` sous forme d'un nombre. Ce nombre correspond au nombre de millisecondes écoulées depuis le 1 janvier 1970 00h00 GMT.
 
-<p>D'un point de vue fonctionnel, cette méthode est équivalente à {{jsxref("Date.prototype.getTime()")}}.</p>
+D'un point de vue fonctionnel, cette méthode est équivalente à {{jsxref("Date.prototype.getTime()")}}.
 
-<p>Cette méthode est souvent appelée en interne par le moteur JavaScript et n'est pas utilisée de façon explicite dans des scripts.</p>
+Cette méthode est souvent appelée en interne par le moteur JavaScript et n'est pas utilisée de façon explicite dans des scripts.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_valueOf()">Utiliser <code>valueOf()</code></h3>
+### Utiliser `valueOf()`
 
-<pre class="brush:js">var x = new Date(56, 6, 17);
+```js
+var x = new Date(56, 6, 17);
 var maVar = x.valueOf();      // maVar vaut -424713600000
-</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.9.5.8', 'Date.prototype.valueOf')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-date.prototype.valueof', 'Date.prototype.valueOf')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-date.prototype.valueof', 'Date.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.Date.valueOf")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Object.prototype.valueOf()")}}</li>
- <li>{{jsxref("Date.prototype.getTime()")}}</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.9.5.8', 'Date.prototype.valueOf')}}                         | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-date.prototype.valueof', 'Date.prototype.valueOf')}}         | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-date.prototype.valueof', 'Date.prototype.valueOf')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Date.valueOf")}}
+
+## Voir aussi
+
+- {{jsxref("Object.prototype.valueOf()")}}
+- {{jsxref("Date.prototype.getTime()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/decodeuri/index.md b/files/fr/web/javascript/reference/global_objects/decodeuri/index.md
index 07d7dd5a71..818de77595 100644
--- a/files/fr/web/javascript/reference/global_objects/decodeuri/index.md
+++ b/files/fr/web/javascript/reference/global_objects/decodeuri/index.md
@@ -7,94 +7,69 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/decodeURI
 original_slug: Web/JavaScript/Reference/Objets_globaux/decodeURI
 ---
-<div>{{jsSidebar("Objects")}}</div>
+{{jsSidebar("Objects")}}
 
-<p>La méthode <code><strong>decodeURI()</strong></code> permet de décoder un Uniform Resource Identifier (URI) créé par la méthode {{jsxref("encodeURI","encodeURI()")}} ou une méthode similaire.</p>
+La méthode **`decodeURI()`** permet de décoder un Uniform Resource Identifier (URI) créé par la méthode {{jsxref("encodeURI","encodeURI()")}} ou une méthode similaire.
 
-<div>{{EmbedInteractiveExample("pages/js/globalprops-decodeuri.html")}}</div>
+{{EmbedInteractiveExample("pages/js/globalprops-decodeuri.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">decodeURI(<var>encodedURI</var>)</pre>
+    decodeURI(encodedURI)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>encodedURI</code></dt>
- <dd>Un URI complet, encodé.</dd>
-</dl>
+- `encodedURI`
+  - : Un URI complet, encodé.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une nouvelle chaîne de caractères dont certains caractères ont été décodés à partir de l'URI encodée passée en argument.</p>
+Une nouvelle chaîne de caractères dont certains caractères ont été décodés à partir de l'URI encodée passée en argument.
 
-<h3 id="Exceptions">Exceptions</h3>
+### Exceptions
 
-<p>Cette méthode lève une exception {{jsxref("URIError")}} ("<em>malformed URI sequence"</em>) lorsque la chaîne passée en argument contient des séquences de caractères invalides.</p>
+Cette méthode lève une exception {{jsxref("URIError")}} ("_malformed URI sequence"_) lorsque la chaîne passée en argument contient des séquences de caractères invalides.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Cette méthode remplace chaque séquence d'échappement présente dans l'URI encodée avec le caractère correspondant. Les séquences d'échappement qui n'auraient pas pu être introduites par {{jsxref("encodeURI", "encodeURI()")}} ne seront pas décodées. Le caractère « <code>#</code> » n'est pas décodé au sein des séquences d'échappement.</p>
+Cette méthode remplace chaque séquence d'échappement présente dans l'URI encodée avec le caractère correspondant. Les séquences d'échappement qui n'auraient pas pu être introduites par {{jsxref("encodeURI", "encodeURI()")}} ne seront pas décodées. Le caractère « `#` » n'est pas décodé au sein des séquences d'échappement.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Décoder_une_URL_cyrillique">Décoder une URL cyrillique</h3>
+### Décoder une URL cyrillique
 
-<pre class="brush: js">decodeURI("https://developer.mozilla.org/ru/docs/JavaScript_%D1%88%D0%B5%D0%BB%D0%BB%D1%8B");
+```js
+decodeURI("https://developer.mozilla.org/ru/docs/JavaScript_%D1%88%D0%B5%D0%BB%D0%BB%D1%8B");
 // "https://developer.mozilla.org/ru/docs/JavaScript_шеллы"
-</pre>
+```
 
-<h3 id="Gérer_les_exceptions">Gérer les exceptions</h3>
+### Gérer les exceptions
 
-<pre class="brush: js">try {
+```js
+try {
   var a = decodeURI('%E0%A4%A');
 } catch(e) {
   console.error(e);
 }
 
 // Cela produira "URIError: malformed URI sequence"
-</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.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.1.3.1', 'decodeURI')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-decodeuri-encodeduri', 'decodeURI')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-decodeuri-encodeduri', 'decodeURI')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.decodeURI")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("decodeURIComponent","decodeURIComponent()")}}</li>
- <li>{{jsxref("encodeURI","encodeURI()")}}</li>
- <li>{{jsxref("encodeURIComponent","encodeURIComponent()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                            | État                         | Commentaires         |
+| ---------------------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ES3')}}                                                                 | {{Spec2('ES3')}}         | Définition initiale. |
+| {{SpecName('ES5.1', '#sec-15.1.3.1', 'decodeURI')}}                     | {{Spec2('ES5.1')}}     |                      |
+| {{SpecName('ES6', '#sec-decodeuri-encodeduri', 'decodeURI')}}         | {{Spec2('ES6')}}         |                      |
+| {{SpecName('ESDraft', '#sec-decodeuri-encodeduri', 'decodeURI')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.decodeURI")}}
+
+## Voir aussi
+
+- {{jsxref("decodeURIComponent","decodeURIComponent()")}}
+- {{jsxref("encodeURI","encodeURI()")}}
+- {{jsxref("encodeURIComponent","encodeURIComponent()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/decodeuricomponent/index.md b/files/fr/web/javascript/reference/global_objects/decodeuricomponent/index.md
index af978f1b90..e825bcbbc0 100644
--- a/files/fr/web/javascript/reference/global_objects/decodeuricomponent/index.md
+++ b/files/fr/web/javascript/reference/global_objects/decodeuricomponent/index.md
@@ -7,83 +7,57 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/decodeURIComponent
 original_slug: Web/JavaScript/Reference/Objets_globaux/decodeURIComponent
 ---
-<div>{{jsSidebar("Objects")}}</div>
+{{jsSidebar("Objects")}}
 
-<p>La fonction <code><strong>decodeURIComponent()</strong></code> permet de décoder un composant d'un Uniform Resource Identifier (URI) précédemment créé par {{jsxref("encodeURIComponent")}} ou par une méthode similaire.</p>
+La fonction **`decodeURIComponent()`** permet de décoder un composant d'un Uniform Resource Identifier (URI) précédemment créé par {{jsxref("encodeURIComponent")}} ou par une méthode similaire.
 
-<div>{{EmbedInteractiveExample("pages/js/globalprops-decodeuricomponent.html")}}</div>
+{{EmbedInteractiveExample("pages/js/globalprops-decodeuricomponent.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">decodeURIComponent(<var>encodedURI</var>)</pre>
+    decodeURIComponent(encodedURI)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>encodedURI</code></dt>
- <dd>Un composant d'URI qui est encodé.</dd>
-</dl>
+- `encodedURI`
+  - : Un composant d'URI qui est encodé.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une nouvelle chaîne de caractères qui représente la version décodée du composant d'URI encodé passé en argument.</p>
+Une nouvelle chaîne de caractères qui représente la version décodée du composant d'URI encodé passé en argument.
 
-<h3 id="Exceptions_levées">Exceptions levées</h3>
+### Exceptions levées
 
-<p>Cette méthode lève une exception {{jsxref("URIError")}} ("<em>malformed URI sequence</em>") lorsqu'elle est utilisée de façon incorrecte.</p>
+Cette méthode lève une exception {{jsxref("URIError")}} ("_malformed URI sequence_") lorsqu'elle est utilisée de façon incorrecte.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Cette méthode remplace chaque séquence d'échappement du composant d'URI encodé par le caractère que la séquence représente.</p>
+Cette méthode remplace chaque séquence d'échappement du composant d'URI encodé par le caractère que la séquence représente.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Décoder_un_composant_d'URL_encodé">Décoder un composant d'URL encodé</h3>
+### Décoder un composant d'URL encodé
 
-<pre class="brush: js">decodeURIComponent("JavaScript_%D1%88%D0%B5%D0%BB%D0%BB%D1%8B");
+```js
+decodeURIComponent("JavaScript_%D1%88%D0%B5%D0%BB%D0%BB%D1%8B");
 // "JavaScript_шеллы"
-</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.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.1.3.2', 'decodeURIComponent')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-decodeuricomponent-encodeduricomponent', 'decodeURIComponent')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-decodeuricomponent-encodeduricomponent', 'decodeURIComponent')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.decodeURIComponent")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("decodeURI")}}</li>
- <li>{{jsxref("encodeURI")}}</li>
- <li>{{jsxref("encodeURIComponent")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                                | État                         | Commentaires         |
+| ---------------------------------------------------------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ES3')}}                                                                                                     | {{Spec2('ES3')}}         | Définition initiale. |
+| {{SpecName('ES5.1', '#sec-15.1.3.2', 'decodeURIComponent')}}                                             | {{Spec2('ES5.1')}}     |                      |
+| {{SpecName('ES6', '#sec-decodeuricomponent-encodeduricomponent', 'decodeURIComponent')}}         | {{Spec2('ES6')}}         |                      |
+| {{SpecName('ESDraft', '#sec-decodeuricomponent-encodeduricomponent', 'decodeURIComponent')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.decodeURIComponent")}}
+
+## Voir aussi
+
+- {{jsxref("decodeURI")}}
+- {{jsxref("encodeURI")}}
+- {{jsxref("encodeURIComponent")}}
diff --git a/files/fr/web/javascript/reference/global_objects/encodeuri/index.md b/files/fr/web/javascript/reference/global_objects/encodeuri/index.md
index 1020c28623..02eade980e 100644
--- a/files/fr/web/javascript/reference/global_objects/encodeuri/index.md
+++ b/files/fr/web/javascript/reference/global_objects/encodeuri/index.md
@@ -8,53 +8,51 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/encodeURI
 original_slug: Web/JavaScript/Reference/Objets_globaux/encodeURI
 ---
-<div>{{jsSidebar("Objects")}}</div>
+{{jsSidebar("Objects")}}
 
-<p>La fonction <code><strong>encodeURI()</strong></code> encode un Uniform Resource Identifier (URI) en remplaçant chaque exemplaire de certains caractères par une, deux, trois ou quatre séquences d'échappement représentant le caractère encodé en UTF-8 (les quatre séquences d'échappement ne seront utilisées que si le caractère est composé de deux caractères « <em>surrogate</em> »).</p>
+La fonction **`encodeURI()`** encode un Uniform Resource Identifier (URI) en remplaçant chaque exemplaire de certains caractères par une, deux, trois ou quatre séquences d'échappement représentant le caractère encodé en UTF-8 (les quatre séquences d'échappement ne seront utilisées que si le caractère est composé de deux caractères « _surrogate_ »).
 
-<div>{{EmbedInteractiveExample("pages/js/globalprops-encodeuri.html")}}</div>
+{{EmbedInteractiveExample("pages/js/globalprops-encodeuri.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">encodeURI(<var>URI</var>)</pre>
+    encodeURI(URI)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>URI</code></dt>
- <dd>Un Uniform Resource Identifier complet.</dd>
-</dl>
+- `URI`
+  - : Un Uniform Resource Identifier complet.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une nouvelle chaîne de caractères représentant un URI, encodé, à partir de la chaîne de caractères passée en argument.</p>
+Une nouvelle chaîne de caractères représentant un URI, encodé, à partir de la chaîne de caractères passée en argument.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p><code>encodeURI()</code> échappe tous les caractères sauf ceux-ci :</p>
+`encodeURI()` échappe tous les caractères sauf ceux-ci :
 
-<pre>A-Z a-z 0-9 ; , / ? : @ &amp; = + $ - _ . ! ~ * ' ( ) #
-</pre>
+    A-Z a-z 0-9 ; , / ? : @ & = + $ - _ . ! ~ * ' ( ) #
 
-<p><code>encodeURI()</code> est différente de {{jsxref("encodeURIComponent")}}. Par exemple :</p>
+`encodeURI()` est différente de {{jsxref("encodeURIComponent")}}. Par exemple :
 
-<pre class="brush: js">var set1 = ";,/?:@&amp;=+$#";  // Caractères réservés
+```js
+var set1 = ";,/?:@&=+$#";  // Caractères réservés
 var set2 = "-_.!~*'()";   // Caractères non-réservés
 var set3 = "ABC abc 123"; // Caractères alphanumériques et espace
 
-console.log(encodeURI(set1)); // ;,/?:@&amp;=+$#
+console.log(encodeURI(set1)); // ;,/?:@&=+$#
 console.log(encodeURI(set2)); // -_.!~*'()
 console.log(encodeURI(set3)); // ABC%20abc%20123 (l'espace est encodé en %20)
 
 console.log(encodeURIComponent(set1)); // %3B%2C%2F%3F%3A%40%26%3D%2B%24%23
 console.log(encodeURIComponent(set2)); // -_.!~*'()
 console.log(encodeURIComponent(set3)); // ABC%20abc%20123 (l'espace est encodé en %20)
+```
 
-</pre>
+Une exception {{jsxref("URIError")}} sera levée si on tente d'encoder un caractère *surrogate* (demi-codet) qui ne fait pas partie d'une paire :
 
-<p>Une exception {{jsxref("URIError")}} sera levée si on tente d'encoder un caractère <em>surrogate</em> (demi-codet) qui ne fait pas partie d'une paire :</p>
-
-<pre class="brush: js">// On a une paire de codets <em>surrogate</em>
+```js
+// On a une paire de codets surrogate
 console.log(encodeURI('\uD800\uDFFF'));
 
 // Ici, seul le caractère "haut"
@@ -64,58 +62,33 @@ console.log(encodeURI('\uD800'));
 // Ici, seul le caractère "bas"
 // ce qui déclenche une "URIError: malformed URI sequence"
 console.log(encodeURI('\uDFFF'));
-</pre>
+```
 
-<p><code>encodeURI()</code> ne permet pas de former des requêtes HTTP GET ou POST (par exemple avec {{domxref("XMLHTTPRequest")}}) car "&amp;", "+" et "=" ne sont pas encodés et sont traités comme des caractères spéciaux (toutefois, la méthode. {{jsxref("encodeURIComponent")}} pourra être utilisée pour encoder ces caractères).</p>
+`encodeURI()` ne permet pas de former des requêtes HTTP GET ou POST (par exemple avec {{domxref("XMLHTTPRequest")}}) car "&", "+" et "=" ne sont pas encodés et sont traités comme des caractères spéciaux (toutefois, la méthode. {{jsxref("encodeURIComponent")}} pourra être utilisée pour encoder ces caractères).
 
-<p>Si on souhaite suivre la <a href="http://tools.ietf.org/html/rfc3986">RFC3986</a> qui concerne les URL et qui rend les crochets réservés (pour IPv6) (il ne faut donc plus encoder ces caractères lorsqu'ils font partie d'une URL (notamment pour la partie représentant l'hôte), on pourra utiliser le fragment de code suivant :</p>
+Si on souhaite suivre la [RFC3986](http://tools.ietf.org/html/rfc3986) qui concerne les URL et qui rend les crochets réservés (pour IPv6) (il ne faut donc plus encoder ces caractères lorsqu'ils font partie d'une URL (notamment pour la partie représentant l'hôte), on pourra utiliser le fragment de code suivant :
 
-<pre class="brush: js">function fixedEncodeURI(str) {
+```js
+function fixedEncodeURI(str) {
   return encodeURI(str).replace(/%5B/g, '[').replace(/%5D/g, ']');
-}</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-encodeuri-uri', 'encodeURI')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-encodeuri-uri', 'encodeURI')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.1.3.3', 'encodeURI')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES3')}}</td>
-   <td>{{Spec2('ES3')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.encodeURI")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("decodeURI", "decodeURI()")}}</li>
- <li>{{jsxref("encodeURIComponent", "encodeURIComponent()")}}</li>
- <li>{{jsxref("decodeURIComponent", "decodeURIComponent()")}}</li>
-</ul>
+}
+```
+
+## Spécifications
+
+| Spécification                                                                | État                         | Commentaires         |
+| ---------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ESDraft', '#sec-encodeuri-uri', 'encodeURI')}} | {{Spec2('ESDraft')}} |                      |
+| {{SpecName('ES6', '#sec-encodeuri-uri', 'encodeURI')}}     | {{Spec2('ES6')}}         |                      |
+| {{SpecName('ES5.1', '#sec-15.1.3.3', 'encodeURI')}}         | {{Spec2('ES5.1')}}     |                      |
+| {{SpecName('ES3')}}                                                     | {{Spec2('ES3')}}         | Définition initiale. |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.encodeURI")}}
+
+## Voir aussi
+
+- {{jsxref("decodeURI", "decodeURI()")}}
+- {{jsxref("encodeURIComponent", "encodeURIComponent()")}}
+- {{jsxref("decodeURIComponent", "decodeURIComponent()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/encodeuricomponent/index.md b/files/fr/web/javascript/reference/global_objects/encodeuricomponent/index.md
index c3deeef114..fdb9bdb700 100644
--- a/files/fr/web/javascript/reference/global_objects/encodeuricomponent/index.md
+++ b/files/fr/web/javascript/reference/global_objects/encodeuricomponent/index.md
@@ -8,39 +8,38 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/encodeURIComponent
 original_slug: Web/JavaScript/Reference/Objets_globaux/encodeURIComponent
 ---
-<div>{{jsSidebar("Objects")}}</div>
+{{jsSidebar("Objects")}}
 
-<p>La fonction <code><strong>encodeURIComponent()</strong></code> permet d'encoder un composant d'un Uniform Resource Identifier (URI) en remplaçant chaque exemplaire de certains caractères par une, deux, trois ou quatres séquences d'échappement UTF-8 correspondantes (quatre séquences seront utilisées uniquement lorsque les caractères à encoder sont composés de deux caractères « <em>surrogate</em> »).</p>
+La fonction **`encodeURIComponent()`** permet d'encoder un composant d'un Uniform Resource Identifier (URI) en remplaçant chaque exemplaire de certains caractères par une, deux, trois ou quatres séquences d'échappement UTF-8 correspondantes (quatre séquences seront utilisées uniquement lorsque les caractères à encoder sont composés de deux caractères « _surrogate_ »).
 
-<div>{{EmbedInteractiveExample("pages/js/globalprops-encodeuricomponent.html")}}</div>
+{{EmbedInteractiveExample("pages/js/globalprops-encodeuricomponent.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">encodeURIComponent(<var>str</var>);</pre>
+    encodeURIComponent(str);
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>str</code></dt>
- <dd>Une chaîne de caractères qui correspond à un composant d'URI.</dd>
-</dl>
+- `str`
+  - : Une chaîne de caractères qui correspond à un composant d'URI.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une nouvelle chaîne de caractères qui représente un composant d'URI obtenu en encodant la chaîne passée en argument.</p>
+Une nouvelle chaîne de caractères qui représente un composant d'URI obtenu en encodant la chaîne passée en argument.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p><code>encodeURIComponent()</code> échappe tous les caractères sauf : les lettres de l'alphabet latin, les chiffres (arabes) et <code>- _ . ! ~ * ' ( )</code></p>
+`encodeURIComponent()` échappe tous les caractères sauf : les lettres de l'alphabet latin, les chiffres (arabes) et `- _ . ! ~ * ' ( )`
 
-<p>La méthode <code>encodeURIComponent()</code> diffère de la méthode <code>encodeURI()</code> par rapport aux caractères qui sont encodés :</p>
+La méthode `encodeURIComponent()` diffère de la méthode `encodeURI()` par rapport aux caractères qui sont encodés :
 
-<pre class="brush: js">var set1 = ";,/?:@&amp;=+$";  // Caractères réservés
+```js
+var set1 = ";,/?:@&=+$";  // Caractères réservés
 var set2 = "-_.!~*'()";   // Caractères non-réservés
 var set3 = "#";           // Croisillon
 var set4 = "ABC abc 123"; // Caractères alphanumériques et espace
 
-console.log(encodeURI(set1)); // ;,/?:@&amp;=+$
+console.log(encodeURI(set1)); // ;,/?:@&=+$
 console.log(encodeURI(set2)); // -_.!~*'()
 console.log(encodeURI(set3)); // #
 console.log(encodeURI(set4)); // ABC%20abc%20123 (l'espace est encodé en %20)
@@ -49,12 +48,12 @@ console.log(encodeURIComponent(set1)); // %3B%2C%2F%3F%3A%40%26%3D%2B%24
 console.log(encodeURIComponent(set2)); // -_.!~*'()
 console.log(encodeURIComponent(set3)); // #
 console.log(encodeURIComponent(set4)); // ABC%20abc%20123 (l'espace est encodé en %20)
+```
 
-</pre>
+Une exception {{jsxref("URIError")}} sera levée lorsqu'on utilise cette fonction sur un unique demi-codet qui est censé faire partie d'une paire de demi-codets :
 
-<p>Une exception {{jsxref("URIError")}} sera levée lorsqu'on utilise cette fonction sur un unique demi-codet qui est censé faire partie d'une paire de demi-codets :</p>
-
-<pre class="brush: js">// la paire de demi-codets : OK
+```js
+// la paire de demi-codets : OK
 console.log(encodeURIComponent('\uD800\uDFFF'));
 
 // seul le demi-codet supérieur : "URIError: malformed URI sequence"
@@ -62,26 +61,28 @@ console.log(encodeURIComponent('\uD800'));
 
 // seul le demi-codet inférieur : "URIError: malformed URI sequence"
 console.log(encodeURIComponent('\uDFFF'));
-</pre>
+```
 
-<p>Afin d'éviter des requêtes inattendues vers le serveur, il est conseillé d'utiliser la fonction <code>encodeURIComponent()</code> pour n'importe quel paramètre qui aurait été saisi par l'utilisateur et qui ferait partie d'un URI. Ainsi, si un utilisateur peut saisir "<code>Thym &amp;access=admin</code>" dans une variable <code>commentaire</code> et qu'on n'utilise pas <code>encodeURIComponent()</code>, on obtiendra la chaîne <code>commentaire=Thym%20&amp;access=admin</code>. On voit ici que l'esperluette (&amp;) et le signe égal forment une nouvelle paire clé/valeur. Au lieu d'avoir une clé POST <code>commentaire</code> égale à "<code>Thym &amp;access=admin</code>", on aura deux clés POST, l'une égale à "<code>Thym </code>" et une seconde (<code>access</code>) égale à <code>admin</code>.</p>
+Afin d'éviter des requêtes inattendues vers le serveur, il est conseillé d'utiliser la fonction `encodeURIComponent()` pour n'importe quel paramètre qui aurait été saisi par l'utilisateur et qui ferait partie d'un URI. Ainsi, si un utilisateur peut saisir "`Thym &access=admin`" dans une variable `commentaire` et qu'on n'utilise pas `encodeURIComponent()`, on obtiendra la chaîne `commentaire=Thym%20&access=admin`. On voit ici que l'esperluette (&) et le signe égal forment une nouvelle paire clé/valeur. Au lieu d'avoir une clé POST `commentaire` égale à "`Thym &access=admin`", on aura deux clés POST, l'une égale à "`Thym `" et une seconde (`access`) égale à `admin`.
 
-<p>Pour <a href="https://www.whatwg.org/specs/web-apps/current-work/multipage/association-of-controls-and-forms.html#application/x-www-form-urlencoded-encoding-algorithm"><code>application/x-www-form-urlencoded</code></a>, les espaces sont remplacés par un '+', aussi, dans ce cas, on pourra ajouter un remplacement supplémentaire après <code>encodeURIComponent()</code> pour remplacer "%20" par "+".</p>
+Pour [`application/x-www-form-urlencoded`](https://www.whatwg.org/specs/web-apps/current-work/multipage/association-of-controls-and-forms.html#application/x-www-form-urlencoded-encoding-algorithm), les espaces sont remplacés par un '+', aussi, dans ce cas, on pourra ajouter un remplacement supplémentaire après `encodeURIComponent()` pour remplacer "%20" par "+".
 
-<p>Pour utiliser une fonction qui respecte la <a class="external" href="https://tools.ietf.org/html/rfc3986">RFC 3986</a>, plus stricte (qui réserve les caractères !, ', (, ), et * même si ces caractères n'ont pas d'usage normalisé), on pourra utiliser la fonction suivante :</p>
+Pour utiliser une fonction qui respecte la [RFC 3986](https://tools.ietf.org/html/rfc3986), plus stricte (qui réserve les caractères !, ', (, ), et \* même si ces caractères n'ont pas d'usage normalisé), on pourra utiliser la fonction suivante :
 
-<pre class="brush: js">function fixedEncodeURIComponent (str) {
+```js
+function fixedEncodeURIComponent (str) {
   return encodeURIComponent(str).replace(/[!'()*]/g, function(c) {
     return '%' + c.charCodeAt(0).toString(16);
   });
 }
-</pre>
+```
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<p>Dans l'exemple qui suit, on utilise une méthode spéciale pour l'encodage afin d'utiliser les paramètres d'en-tête de réponse <code>Content-Disposition</code> et <code>Link</code> (pour, par exemple, représenter des noms de fichiers en UTF-8) :</p>
+Dans l'exemple qui suit, on utilise une méthode spéciale pour l'encodage afin d'utiliser les paramètres d'en-tête de réponse `Content-Disposition` et `Link` (pour, par exemple, représenter des noms de fichiers en UTF-8) :
 
-<pre class="brush: js">var nomFichier = 'mon fichier(2).txt';
+```js
+var nomFichier = 'mon fichier(2).txt';
 var header = "Content-Disposition: attachment; filename*=UTF-8''"
              + encodeRFC5987ValueChars(nomFichier);
 
@@ -105,56 +106,31 @@ function encodeRFC5987ValueChars2(str) {
   return encodeURIComponent(str).
     // Bien que la RFC 3986 réserve "!", RFC 5987 ne réserve pas ce caractère,
     // il n'est donc pas nécessaire l'échapper
-    replace(/['()*]/g, c =&gt; '%' + c.charCodeAt(0).toString(16)). // i.e., %27 %28 %29 %2a
+    replace(/['()*]/g, c => '%' + c.charCodeAt(0).toString(16)). // i.e., %27 %28 %29 %2a
     // on notera que l'encodage valide pour "*" est %2A et qui faut donc appeler toUpperCase()
     // pour encoder exactement.
 
     // Selon la RFC 5987 ce qui suit n'est pas nécessairement requis
     // on peut donc bénéficier d'un peu plus de lisibilité : |`^
-    replace(/%(7C|60|5E)/g, (str, hex) =&gt; String.fromCharCode(parseInt(hex, 16)));
+    replace(/%(7C|60|5E)/g, (str, hex) => String.fromCharCode(parseInt(hex, 16)));
 }
-</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.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.1.3.4', 'encodeURIComponent')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-encodeuricomponent-uricomponent', 'encodeURIComponent')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-encodeuricomponent-uricomponent', 'encodeURIComponent')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.encodeURIComponent")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("decodeURI")}}</li>
- <li>{{jsxref("encodeURI")}}</li>
- <li>{{jsxref("decodeURIComponent")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                    | État                         | Commentaires         |
+| ---------------------------------------------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ES3')}}                                                                                         | {{Spec2('ES3')}}         | Définition initiale. |
+| {{SpecName('ES5.1', '#sec-15.1.3.4', 'encodeURIComponent')}}                                 | {{Spec2('ES5.1')}}     |                      |
+| {{SpecName('ES6', '#sec-encodeuricomponent-uricomponent', 'encodeURIComponent')}}     | {{Spec2('ES6')}}         |                      |
+| {{SpecName('ESDraft', '#sec-encodeuricomponent-uricomponent', 'encodeURIComponent')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.encodeURIComponent")}}
+
+## Voir aussi
+
+- {{jsxref("decodeURI")}}
+- {{jsxref("encodeURI")}}
+- {{jsxref("decodeURIComponent")}}
diff --git a/files/fr/web/javascript/reference/global_objects/error/columnnumber/index.md b/files/fr/web/javascript/reference/global_objects/error/columnnumber/index.md
index b507d0b41f..2af2806a79 100644
--- a/files/fr/web/javascript/reference/global_objects/error/columnnumber/index.md
+++ b/files/fr/web/javascript/reference/global_objects/error/columnnumber/index.md
@@ -10,31 +10,30 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Error/columnNumber
 original_slug: Web/JavaScript/Reference/Objets_globaux/Error/columnNumber
 ---
-<div>{{JSRef}} {{non-standard_header}}</div>
+{{JSRef}} {{non-standard_header}}
 
-<p>La propriété <code><strong>columnNumber</strong></code> contient le numéro de la colonne, dans la ligne du fichier qui a déclenché l'erreur.</p>
+La propriété **`columnNumber`** contient le numéro de la colonne, dans la ligne du fichier qui a déclenché l'erreur.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_de_columnNumber">Utiliser de <code>columnNumber</code></h3>
+### Utiliser de `columnNumber`
 
-<pre class="brush: js">var e = new Error("Ne peut pas lire la donnée");
+```js
+var e = new Error("Ne peut pas lire la donnée");
 throw e;
 console.log(e.columnNumber) // 0
-</pre>
+```
 
-<h2 id="Spécifications">Spécifications</h2>
+## Spécifications
 
-<p>Ne fait partie d'aucune spécification. Non standard.</p>
+Ne fait partie d'aucune spécification. Non standard.
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.Error.columnNumber")}}</p>
+{{Compat("javascript.builtins.Error.columnNumber")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("Error.prototype.stack")}} {{non-standard_inline}}</li>
- <li>{{jsxref("Error.prototype.lineNumber")}} {{non-standard_inline}}</li>
- <li>{{jsxref("Error.prototype.fileName")}} {{non-standard_inline}}</li>
-</ul>
+- {{jsxref("Error.prototype.stack")}} {{non-standard_inline}}
+- {{jsxref("Error.prototype.lineNumber")}} {{non-standard_inline}}
+- {{jsxref("Error.prototype.fileName")}} {{non-standard_inline}}
diff --git a/files/fr/web/javascript/reference/global_objects/error/filename/index.md b/files/fr/web/javascript/reference/global_objects/error/filename/index.md
index 2a2cda2422..ca5fbf3e64 100644
--- a/files/fr/web/javascript/reference/global_objects/error/filename/index.md
+++ b/files/fr/web/javascript/reference/global_objects/error/filename/index.md
@@ -11,35 +11,34 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Error/fileName
 original_slug: Web/JavaScript/Reference/Objets_globaux/Error/fileName
 ---
-<div>{{JSRef}} {{non-standard_header}}</div>
+{{JSRef}} {{non-standard_header}}
 
-<p>La propriété <code><strong>fileName</strong></code> contient le chemin vers le fichier qui a déclenché l'erreur.</p>
+La propriété **`fileName`** contient le chemin vers le fichier qui a déclenché l'erreur.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Cette propriété non-standard contient le chemin vers le fichier qui a déclenché cette erreur. Si elle est appelée depuis un débugger (les outils de développement de Firefox par exemple), "debugger eval code" sera renvoyé.</p>
+Cette propriété non-standard contient le chemin vers le fichier qui a déclenché cette erreur. Si elle est appelée depuis un débugger (les outils de développement de Firefox par exemple), "debugger eval code" sera renvoyé.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_fileName">Utiliser <code>fileName</code></h3>
+### Utiliser `fileName`
 
-<pre class="brush: js">var e = new Error("Ne peut pas lire la donnée");
+```js
+var e = new Error("Ne peut pas lire la donnée");
 throw e;
 // e.fileName peut ressembler à "file:///C:/exemple.html"
-</pre>
+```
 
-<h2 id="Spécifications">Spécifications</h2>
+## Spécifications
 
-<p>Ne fait partie d'aucune spécification. Non standard.</p>
+Ne fait partie d'aucune spécification. Non standard.
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.Error.fileName")}}</p>
+{{Compat("javascript.builtins.Error.fileName")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("Error.prototype.stack")}} {{non-standard_inline}}</li>
- <li>{{jsxref("Error.prototype.columnNumber")}} {{non-standard_inline}}</li>
- <li>{{jsxref("Error.prototype.lineNumber")}} {{non-standard_inline}}</li>
-</ul>
+- {{jsxref("Error.prototype.stack")}} {{non-standard_inline}}
+- {{jsxref("Error.prototype.columnNumber")}} {{non-standard_inline}}
+- {{jsxref("Error.prototype.lineNumber")}} {{non-standard_inline}}
diff --git a/files/fr/web/javascript/reference/global_objects/error/index.md b/files/fr/web/javascript/reference/global_objects/error/index.md
index 5675ff256a..037520b23f 100644
--- a/files/fr/web/javascript/reference/global_objects/error/index.md
+++ b/files/fr/web/javascript/reference/global_objects/error/index.md
@@ -8,105 +8,103 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Error
 original_slug: Web/JavaScript/Reference/Objets_globaux/Error
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>Le constructeur <strong><code>Error</code></strong> crée un objet d'erreur. Des instances d'objets <code>Error</code> sont déclenchées lorsque des erreurs d'exécution surviennent. L'objet <code>Error</code> peut aussi être utilisé comme objet de base pour des exceptions définies par l'utilisateur. Voir ci-dessous pour les types d'erreur natifs standard.</p>
+Le constructeur **`Error`** crée un objet d'erreur. Des instances d'objets `Error` sont déclenchées lorsque des erreurs d'exécution surviennent. L'objet `Error` peut aussi être utilisé comme objet de base pour des exceptions définies par l'utilisateur. Voir ci-dessous pour les types d'erreur natifs standard.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox notranslate">new Error([<var>message</var>[, <var>fileName</var>[, <var>lineNumber</var>]]])</pre>
+    new Error([message[, fileName[, lineNumber]]])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>message</code> {{optional_inline}}</dt>
- <dd>Description de l'erreur sous une forme lisible par un humain.</dd>
- <dt><code>fileName</code> {{optional_inline}}{{Non-standard_inline}}</dt>
- <dd>Argument qui sera utilisé pour la valeur de la propriété <code>fileName</code> dans l'objet <code>Error</code> créé. Par défaut, ce sera le nom du fichier contenant le code qui a appelé le constructeur <code>Error()</code>.</dd>
- <dt><code>lineNumber</code> {{optional_inline}}{{Non-standard_inline}}</dt>
- <dd>Argument qui sera utilisé pour la valeur de la propriété <code>lineNumber</code> dans l'objet <code>Error</code> créé. Par défaut, ce sera le numéro de la ligne contenant l'invocation du constructeur <code>Error()</code>.</dd>
-</dl>
+- `message` {{optional_inline}}
+  - : Description de l'erreur sous une forme lisible par un humain.
+- `fileName` {{optional_inline}}{{Non-standard_inline}}
+  - : Argument qui sera utilisé pour la valeur de la propriété `fileName` dans l'objet `Error` créé. Par défaut, ce sera le nom du fichier contenant le code qui a appelé le constructeur `Error()`.
+- `lineNumber` {{optional_inline}}{{Non-standard_inline}}
+  - : Argument qui sera utilisé pour la valeur de la propriété `lineNumber` dans l'objet `Error` créé. Par défaut, ce sera le numéro de la ligne contenant l'invocation du constructeur `Error()`.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Les erreurs d'exécution ont pour résultat la création et le déclenchement d'objets <code>Error</code>.</p>
+Les erreurs d'exécution ont pour résultat la création et le déclenchement d'objets `Error`.
 
-<p>Cette page documente l'utilisation de l'objet <code>Error</code> lui-même et son utilisation comme fonction constructeur. Pour une liste des propriétés et des méthodes héritées par les instances d'<code>Error</code>,  voir {{jsxref("Error.prototype")}}.</p>
+Cette page documente l'utilisation de l'objet `Error` lui-même et son utilisation comme fonction constructeur. Pour une liste des propriétés et des méthodes héritées par les instances d'`Error`,  voir {{jsxref("Error.prototype")}}.
 
-<h3 id="Utilisation_de_Error_comme_fonction">Utilisation de <code>Error</code> comme fonction</h3>
+### Utilisation de `Error` comme fonction
 
-<p>Lorsqu'<code>Error</code> est utilisée comme fonction sans utiliser l'opérateur {{jsxref("Opérateurs/L_opérateur_new", "new")}}, cet appel renverra un objet <code>Error</code>. Aussi, un simple appel à <code>Error</code> produira le même résultat qu'une invocation avec <code>new</code>.</p>
+Lorsqu'`Error` est utilisée comme fonction sans utiliser l'opérateur {{jsxref("Opérateurs/L_opérateur_new", "new")}}, cet appel renverra un objet `Error`. Aussi, un simple appel à `Error` produira le même résultat qu'une invocation avec `new`.
 
-<pre class="brush: js notranslate">// Cette instruction :
+```js
+// Cette instruction :
 const x = Error("J'ai été créée sans new");
 
 // Aura le même effet que
-const y = new Error("J'ai été créée avec new");</pre>
+const y = new Error("J'ai été créée avec new");
+```
 
-<h3 id="Types_derreur">Types d'erreur</h3>
+### Types d'erreur
 
-<p>En plus du constructeur <code>Error</code> générique, il existe sept autres constructeurs d'erreur de base en JavaScript. Pour les exceptions côté client, voir <a href="/fr/docs/Web/JavaScript/Guide/Contr%C3%B4le_du_flux_Gestion_des_erreurs">Contrôle du flux d'instructions et gestion des erreurs</a>.</p>
+En plus du constructeur `Error` générique, il existe sept autres constructeurs d'erreur de base en JavaScript. Pour les exceptions côté client, voir [Contrôle du flux d'instructions et gestion des erreurs](/fr/docs/Web/JavaScript/Guide/Contr%C3%B4le_du_flux_Gestion_des_erreurs).
 
-<dl>
- <dt>{{jsxref("EvalError")}}</dt>
- <dd>Crée une instance représentant une erreur se produisant en relation avec la fonction globale {{jsxref("eval","eval()")}}.</dd>
- <dt>{{jsxref("RangeError")}}</dt>
- <dd>Crée une instance représentant une erreur se produisant quand une variable numérique ou un paramètre est en dehors de sa plage de validité.</dd>
- <dt>{{jsxref("ReferenceError")}}</dt>
- <dd>Crée une instance représentant une erreur se produisant lors du déréférencement d'une référence invalide.</dd>
- <dt>{{jsxref("SyntaxError")}}</dt>
- <dd>Crée une instance représentant une erreur de syntaxe se produisant lors d'une analyse de code dans {{jsxref("eval", "eval()")}}.</dd>
- <dt>{{jsxref("TypeError")}}</dt>
- <dd>Crée une instance représentant une erreur se produisant quand une variable ou un paramètre n'est pas d'un type valide.</dd>
- <dt>{{jsxref("URIError")}}</dt>
- <dd>Crée une instance représentant une erreur se produisant quand des paramètres invalides sont passés à {{jsxref("encodeURI", "encodeURI()")}} ou à {{jsxref("decodeURI", "decodeURI()")}}.</dd>
- <dt>{{JSxRef("AggregateError")}}</dt>
- <dd>Crée une instance représentant différentes erreurs agrégées en une seule lorsque plusieurs erreurs sont rapportées par une opération, par exemple avec {{JSxRef("Promise.any()")}}.</dd>
- <dt>{{jsxref("InternalError")}} {{non-standard_inline}}</dt>
- <dd>Crée une instance représentant une erreur se produisant quand une erreur interne dans le moteur JavaScript est déclenchée. Par ex., "too much recursion".</dd>
-</dl>
+- {{jsxref("EvalError")}}
+  - : Crée une instance représentant une erreur se produisant en relation avec la fonction globale {{jsxref("eval","eval()")}}.
+- {{jsxref("RangeError")}}
+  - : Crée une instance représentant une erreur se produisant quand une variable numérique ou un paramètre est en dehors de sa plage de validité.
+- {{jsxref("ReferenceError")}}
+  - : Crée une instance représentant une erreur se produisant lors du déréférencement d'une référence invalide.
+- {{jsxref("SyntaxError")}}
+  - : Crée une instance représentant une erreur de syntaxe se produisant lors d'une analyse de code dans {{jsxref("eval", "eval()")}}.
+- {{jsxref("TypeError")}}
+  - : Crée une instance représentant une erreur se produisant quand une variable ou un paramètre n'est pas d'un type valide.
+- {{jsxref("URIError")}}
+  - : Crée une instance représentant une erreur se produisant quand des paramètres invalides sont passés à {{jsxref("encodeURI", "encodeURI()")}} ou à {{jsxref("decodeURI", "decodeURI()")}}.
+- {{JSxRef("AggregateError")}}
+  - : Crée une instance représentant différentes erreurs agrégées en une seule lorsque plusieurs erreurs sont rapportées par une opération, par exemple avec {{JSxRef("Promise.any()")}}.
+- {{jsxref("InternalError")}} {{non-standard_inline}}
+  - : Crée une instance représentant une erreur se produisant quand une erreur interne dans le moteur JavaScript est déclenchée. Par ex., "too much recursion".
 
-<h2 id="Propriétés">Propriétés</h2>
+## Propriétés
 
-<dl>
- <dt>{{jsxref("Error.prototype")}}</dt>
- <dd>Permet l'ajout de propriétés aux instances <code>Error</code>.</dd>
-</dl>
+- {{jsxref("Error.prototype")}}
+  - : Permet l'ajout de propriétés aux instances `Error`.
 
-<h2 id="Méthodes">Méthodes</h2>
+## Méthodes
 
-<p>L'objet global <code>Error</code> ne contient pas de méthodes en propre, toutefois, il hérite de certaines méthodes via la chaine de prototype.</p>
+L'objet global `Error` ne contient pas de méthodes en propre, toutefois, il hérite de certaines méthodes via la chaine de prototype.
 
-<h2 id="Instances_dError">Instances d'<code>Error</code></h2>
+## Instances d'`Error`
 
-<div>{{page('fr/docs/JavaScript/Reference/Objets_globaux/Error/prototype', 'Description')}}</div>
+{{page('fr/docs/JavaScript/Reference/Objets_globaux/Error/prototype', 'Description')}}
 
-<h3 id="Propriétés_2">Propriétés</h3>
+### Propriétés
 
-<p>{{page('fr/docs/JavaScript/Reference/Objets_globaux/Error/prototype', 'Propriétés')}}</p>
+{{page('fr/docs/JavaScript/Reference/Objets_globaux/Error/prototype', 'Propriétés')}}
 
-<h3 id="Méthodes_2">Méthodes</h3>
+### Méthodes
 
-<p>{{page('fr/docs/JavaScript/Reference/Objets_globaux/Error/prototype', 'Méthodes')}}</p>
+{{page('fr/docs/JavaScript/Reference/Objets_globaux/Error/prototype', 'Méthodes')}}
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Déclenchement_dune_erreur_générique">Déclenchement d'une erreur générique</h3>
+### Déclenchement d'une erreur générique
 
-<p>Vous créez habituellement un objet <code>Error</code> dans l'intention de le déclencher en utilisant le mot-clé {{jsxref("Instructions/throw", "throw")}}. Vous pouvez gérer l'erreur en utilisant la construction {{jsxref("Instructions/try...catch", "try...catch")}} :</p>
+Vous créez habituellement un objet `Error` dans l'intention de le déclencher en utilisant le mot-clé {{jsxref("Instructions/throw", "throw")}}. Vous pouvez gérer l'erreur en utilisant la construction {{jsxref("Instructions/try...catch", "try...catch")}} :
 
-<pre class="brush: js notranslate">try {
+```js
+try {
     throw new Error("Ouups !");
 } catch (e) {
     console.log(e.name + ": " + e.message);
 }
-</pre>
+```
 
-<h3 id="Gestion_dune_erreur_spécifique">Gestion d'une erreur spécifique</h3>
+### Gestion d'une erreur spécifique
 
-<p>Vous pouvez choisir de ne gérer que des types d'erreur particuliers en testant le type de l'erreur via la propriété {{jsxref("Object.prototype.constructor", "constructor")}} de l'erreur ou, si vous écrivez pour des interpréteurs JavaScript modernes, le mot-clé {{jsxref("Opérateurs/instanceof", "instanceof")}} :</p>
+Vous pouvez choisir de ne gérer que des types d'erreur particuliers en testant le type de l'erreur via la propriété {{jsxref("Object.prototype.constructor", "constructor")}} de l'erreur ou, si vous écrivez pour des interpréteurs JavaScript modernes, le mot-clé {{jsxref("Opérateurs/instanceof", "instanceof")}} :
 
-<pre class="brush: js notranslate">try {
+```js
+try {
     machin.truc();
 } catch (e) {
     if (e instanceof EvalError) {
@@ -116,23 +114,20 @@ const y = new Error("J'ai été créée avec new");</pre>
     }
     // ... etc
 }
-</pre>
+```
 
-<h3 id="Types_derreur_personnalisés">Types d'erreur personnalisés</h3>
+### Types d'erreur personnalisés
 
-<p>Vous pouvez vouloir définir vos propres types d'erreur dérivants d'<code>Error</code> pour pouvoir écrire <code>throw new MonErreur()</code> et utiliser <code>instanceof MonErreur</code> afin de vérifier le type d'erreur dans le gestionnaire d'exceptions. Cela a pour résultat un code de gestion d'erreur plus propre et plus cohérent. Voir <a href="http://stackoverflow.com/questions/1382107/whats-a-good-way-to-extend-error-in-javascript"><em>What's a good way to extend Error in JavaScript?</em></a> sur StackOverflow pour une discussion en profondeur.</p>
+Vous pouvez vouloir définir vos propres types d'erreur dérivants d'`Error` pour pouvoir écrire `throw new MonErreur()` et utiliser `instanceof MonErreur` afin de vérifier le type d'erreur dans le gestionnaire d'exceptions. Cela a pour résultat un code de gestion d'erreur plus propre et plus cohérent. Voir [_What's a good way to extend Error in JavaScript?_](http://stackoverflow.com/questions/1382107/whats-a-good-way-to-extend-error-in-javascript) sur StackOverflow pour une discussion en profondeur.
 
-<h4 id="Classes_derreur_personnalisées_avec_ECMAScript_2015_ES6">Classes d'erreur personnalisées avec ECMAScript 2015 / ES6</h4>
+#### Classes d'erreur personnalisées avec ECMAScript 2015 / ES6
 
-<div class="warning">
-<p><strong>Attention :</strong> Babel, dans les versions antérieures à Babel 7, ainsi que d'autres transpileurs ne géreront pas correctement le code suivant sans <a href="https://github.com/loganfsmyth/babel-plugin-transform-builtin-extend">configuration supplémentaire</a>. Les versions de Babel antérieures à la version 7 peuvent uniquement gérer les classes d'erreur personnalisées lorsque celles-ci sont créées avec <code><a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object/defineProperty">Object.defineProperty()</a></code>.</p>
-</div>
+> **Attention :** Babel, dans les versions antérieures à Babel 7, ainsi que d'autres transpileurs ne géreront pas correctement le code suivant sans [configuration supplémentaire](https://github.com/loganfsmyth/babel-plugin-transform-builtin-extend). Les versions de Babel antérieures à la version 7 peuvent uniquement gérer les classes d'erreur personnalisées lorsque celles-ci sont créées avec [`Object.defineProperty()`](/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object/defineProperty).
 
-<div class="note">
-<p><strong>Note :</strong> Certains navigateurs incluent le constructeur <code>CustomError</code> (Erreur Personnalisée) dans la pile d'appels lors de l'utilisation de classes ES6.</p>
-</div>
+> **Note :** Certains navigateurs incluent le constructeur `CustomError` (Erreur Personnalisée) dans la pile d'appels lors de l'utilisation de classes ES6.
 
-<pre class="brush: js notranslate">class CustomError extends Error {
+```js
+class CustomError extends Error {
   constructor(machin = 'truc', ...params) {
     // Passer les arguments restants (incluant ceux spécifiques au vendeur) au constructeur parent
     super(...params);
@@ -155,15 +150,15 @@ try {
   console.log(e.machin);  // bidule
   console.log(e.message); // messageBidule
   console.log(e.stack);   // stacktrace
-}</pre>
+}
+```
 
-<h4 id="Objet_derreur_personnalisé_ES5">Objet d'erreur personnalisé ES5</h4>
+#### Objet d'erreur personnalisé ES5
 
-<div class="warning">
-<p><strong>Attention :</strong> Tous les navigateurs incluent le constructeur <code>CustomError</code> dans la pile  d'appel lorsqu'une déclaration prototypale est utilisée.</p>
-</div>
+> **Attention :** Tous les navigateurs incluent le constructeur `CustomError` dans la pile  d'appel lorsqu'une déclaration prototypale est utilisée.
 
-<pre class="brush: js notranslate">function CustomError(machin, message, nomFichier, numeroLigne) {
+```js
+function CustomError(machin, message, nomFichier, numeroLigne) {
   var instance = new Error(message, nomFichier, numeroLigne);
   instance.name = 'CustomError';
   instance.machin = machin;
@@ -197,50 +192,24 @@ try {
   console.log(e.toto);       // bidule
   console.log(e.message);    // messageBidule
   console.log(e.lineNumber); // 29
-}</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-error-objects', 'Error')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES2015', '#sec-error-objects', 'Error')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.11', 'Error')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES1')}}</td>
-   <td>{{Spec2('ES1')}}</td>
-   <td>Définition initiale. Implémentée avec JavaScript 1.1.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Error")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Error.prototype")}}</li>
- <li>{{jsxref("Instructions/throw", "throw")}}</li>
- <li>{{jsxref("Instructions/try...catch", "try...catch")}}</li>
-</ul>
+}
+```
+
+## Spécifications
+
+| Spécification                                                            | État                         | Commentaires                                          |
+| ------------------------------------------------------------------------ | ---------------------------- | ----------------------------------------------------- |
+| {{SpecName('ESDraft', '#sec-error-objects', 'Error')}} | {{Spec2('ESDraft')}} |                                                       |
+| {{SpecName('ES2015', '#sec-error-objects', 'Error')}} | {{Spec2('ES2015')}}     |                                                       |
+| {{SpecName('ES5.1', '#sec-15.11', 'Error')}}             | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES1')}}                                                 | {{Spec2('ES1')}}         | Définition initiale. Implémentée avec JavaScript 1.1. |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Error")}}
+
+## Voir aussi
+
+- {{jsxref("Error.prototype")}}
+- {{jsxref("Instructions/throw", "throw")}}
+- {{jsxref("Instructions/try...catch", "try...catch")}}
diff --git a/files/fr/web/javascript/reference/global_objects/error/linenumber/index.md b/files/fr/web/javascript/reference/global_objects/error/linenumber/index.md
index d82a788e79..b2a2a1ff5a 100644
--- a/files/fr/web/javascript/reference/global_objects/error/linenumber/index.md
+++ b/files/fr/web/javascript/reference/global_objects/error/linenumber/index.md
@@ -11,42 +11,40 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Error/lineNumber
 original_slug: Web/JavaScript/Reference/Objets_globaux/Error/lineNumber
 ---
-<div>{{JSRef}} {{non-standard_header}}</div>
+{{JSRef}} {{non-standard_header}}
 
-<p>La propriété <code><strong>lineNumber</strong></code> contient le numéro de la ligne qui a déclenché l'erreur dans le fichier.</p>
+La propriété **`lineNumber`** contient le numéro de la ligne qui a déclenché l'erreur dans le fichier.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_lineNumber">Utiliser <code>lineNumber</code></h3>
+### Utiliser `lineNumber`
 
-<pre class="brush: js">var e = new Error("Ne peut pas lire la donnée");
+```js
+var e = new Error("Ne peut pas lire la donnée");
 throw e;
-console.log(e.lineNumber) // 2</pre>
+console.log(e.lineNumber) // 2
+```
 
-<h3 id="Alternative_en_utilisant_l'événement_error">Alternative en utilisant l'événement <code>error</code></h3>
+### Alternative en utilisant l'événement `error`
 
-<pre class="brush: js">window.addEventListener("error", function (e) {
+```js
+window.addEventListener("error", function (e) {
  console.log(e.lineNumber); //5
 });
 var e = new Error('Ne peut pas lire la donnée');
-throw e;</pre>
-
-<h2 id="Spécifications">Spécifications</h2>
-
-<p>Ne fait partie d'aucune spécification. Non standard.</p>
+throw e;
+```
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Spécifications
 
-<div>
+Ne fait partie d'aucune spécification. Non standard.
 
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.Error.lineNumber")}}</p>
-</div>
+{{Compat("javascript.builtins.Error.lineNumber")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("Error.prototype.stack")}} {{non-standard_inline}}</li>
- <li>{{jsxref("Error.prototype.columnNumber")}} {{non-standard_inline}}</li>
- <li>{{jsxref("Error.prototype.fileName")}} {{non-standard_inline}}</li>
-</ul>
+- {{jsxref("Error.prototype.stack")}} {{non-standard_inline}}
+- {{jsxref("Error.prototype.columnNumber")}} {{non-standard_inline}}
+- {{jsxref("Error.prototype.fileName")}} {{non-standard_inline}}
diff --git a/files/fr/web/javascript/reference/global_objects/error/message/index.md b/files/fr/web/javascript/reference/global_objects/error/message/index.md
index 7ea12bb648..47c745abbe 100644
--- a/files/fr/web/javascript/reference/global_objects/error/message/index.md
+++ b/files/fr/web/javascript/reference/global_objects/error/message/index.md
@@ -10,64 +10,40 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Error/message
 original_slug: Web/JavaScript/Reference/Objets_globaux/Error/message
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La propriété <code><strong>message</strong></code> est une description de l'erreur, écrite pour être lue par un humain.</p>
+La propriété **`message`** est une description de l'erreur, écrite pour être lue par un humain.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La propriété contient une brève description de l'erreur si elle est accessible, ou si elle a été définie. <a href="/fr/docs/SpiderMonkey">SpiderMonkey</a> utilise intensivement la propriété <code>message</code> pour les erreurs d'exécution. La propriété <code>message</code>, combinée à la propriété {{jsxref("Error.name", "name")}}, est utilisée par la méthode {{jsxref("Error.prototype.toString()")}} pour créer une représentation de l'erreur sous la forme d'une chaine de caractères.</p>
+La propriété contient une brève description de l'erreur si elle est accessible, ou si elle a été définie. [SpiderMonkey](/fr/docs/SpiderMonkey) utilise intensivement la propriété `message` pour les erreurs d'exécution. La propriété `message`, combinée à la propriété {{jsxref("Error.name", "name")}}, est utilisée par la méthode {{jsxref("Error.prototype.toString()")}} pour créer une représentation de l'erreur sous la forme d'une chaine de caractères.
 
-<p>Par défaut, la propriété <code>message</code> est une chaine de caractères vide, mais ce comportement peut être remplacé pour une instance, en renseignant un message comme premier argument du constructeur {{jsxref("Error")}}.</p>
+Par défaut, la propriété `message` est une chaine de caractères vide, mais ce comportement peut être remplacé pour une instance, en renseignant un message comme premier argument du constructeur {{jsxref("Error")}}.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Déclencher_une_erreur_personnalisée">Déclencher une erreur personnalisée</h3>
+### Déclencher une erreur personnalisée
 
-<pre class="brush: js">var e = new Error("Impossible de lire la donnée");
+```js
+var e = new Error("Impossible de lire la donnée");
 // e.message est "Impossible de lire la donnée"
 throw e;
-</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">Statut</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.11.4.3', 'Error.prototype.message')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-error.prototype.message', 'Error.prototype.message')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-error.prototype.message', 'Error.prototype.message')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
+| Spécification                                                                                                | Statut                       | Commentaires         |
+| ------------------------------------------------------------------------------------------------------------ | ---------------------------- | -------------------- |
+| {{SpecName('ES1')}}                                                                                     | {{Spec2('ES1')}}         | Définition initiale. |
+| {{SpecName('ES5.1', '#sec-15.11.4.3', 'Error.prototype.message')}}                     | {{Spec2('ES5.1')}}     |                      |
+| {{SpecName('ES6', '#sec-error.prototype.message', 'Error.prototype.message')}}     | {{Spec2('ES6')}}         |                      |
+| {{SpecName('ESDraft', '#sec-error.prototype.message', 'Error.prototype.message')}} | {{Spec2('ESDraft')}} |                      |
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.Error.message")}}</p>
+{{Compat("javascript.builtins.Error.message")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("Error.prototype.name")}}</li>
- <li>{{jsxref("Error.prototype.toString()")}}</li>
-</ul>
+- {{jsxref("Error.prototype.name")}}
+- {{jsxref("Error.prototype.toString()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/error/name/index.md b/files/fr/web/javascript/reference/global_objects/error/name/index.md
index 7463cb7eff..9ef6dbf87e 100644
--- a/files/fr/web/javascript/reference/global_objects/error/name/index.md
+++ b/files/fr/web/javascript/reference/global_objects/error/name/index.md
@@ -10,64 +10,40 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Error/name
 original_slug: Web/JavaScript/Reference/Objets_globaux/Error/name
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La propriété <code><strong>name</strong></code> est une chaîne de caractères représentant le nom du type d'erreur. La valeur initiale est "Error".</p>
+La propriété **`name`** est une chaîne de caractères représentant le nom du type d'erreur. La valeur initiale est "Error".
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Par défaut, les instances d'{{jsxref("Error")}} reçoivent le nom "Error". La propriété <code>name</code>, associée à la propriété {{jsxref("Error.message", "message")}}, est utilisée par la méthode {{jsxref("Error.prototype.toString()")}} pour créer une représentation de l'erreur sous la forme d'une chaine de caractères.</p>
+Par défaut, les instances d'{{jsxref("Error")}} reçoivent le nom "Error". La propriété `name`, associée à la propriété {{jsxref("Error.message", "message")}}, est utilisée par la méthode {{jsxref("Error.prototype.toString()")}} pour créer une représentation de l'erreur sous la forme d'une chaine de caractères.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Déclencher_une_erreur_personnalisée">Déclencher une erreur personnalisée</h3>
+### Déclencher une erreur personnalisée
 
-<pre class="brush:js">var e = new Error("Donnée malformée"); // e.name est "Error"
+```js
+var e = new Error("Donnée malformée"); // e.name est "Error"
 
 e.name = "ParseError";
 throw e;
 // e.toString() renverra "ParseError: Donnée malformée"
-</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">Statut</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.11.4.2', 'Error.prototype.name')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-error.prototype.name', 'Error.prototype.name')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-error.prototype.name', 'Error.prototype.name')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
+| Spécification                                                                                        | Statut                       | Commentaires         |
+| ---------------------------------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ES1')}}                                                                             | {{Spec2('ES1')}}         | Définition initiale. |
+| {{SpecName('ES5.1', '#sec-15.11.4.2', 'Error.prototype.name')}}                 | {{Spec2('ES5.1')}}     |                      |
+| {{SpecName('ES6', '#sec-error.prototype.name', 'Error.prototype.name')}}     | {{Spec2('ES6')}}         |                      |
+| {{SpecName('ESDraft', '#sec-error.prototype.name', 'Error.prototype.name')}} | {{Spec2('ESDraft')}} |                      |
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.Error.name")}}</p>
+{{Compat("javascript.builtins.Error.name")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("Error.prototype.message")}}</li>
- <li>{{jsxref("Error.prototype.toString()")}}</li>
-</ul>
+- {{jsxref("Error.prototype.message")}}
+- {{jsxref("Error.prototype.toString()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/error/stack/index.md b/files/fr/web/javascript/reference/global_objects/error/stack/index.md
index 133dfa454e..94bc830aeb 100644
--- a/files/fr/web/javascript/reference/global_objects/error/stack/index.md
+++ b/files/fr/web/javascript/reference/global_objects/error/stack/index.md
@@ -11,29 +11,30 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Error/Stack
 original_slug: Web/JavaScript/Reference/Objets_globaux/Error/Stack
 ---
-<div>{{JSRef}} {{non-standard_header}}</div>
+{{JSRef}} {{non-standard_header}}
 
-<p>La propriété non-standard <code><strong>stack</strong></code> des objets {{jsxref("Error")}} fournit une trace des fonctions qui ont été appelées, dans quel ordre, depuis quelle ligne de quel fichier, et avec quels arguments. La chaine de pile remonte des appels les plus récents jusqu'aux plus anciens, ramenant à l'appel original de la portée globale.</p>
+La propriété non-standard **`stack`** des objets {{jsxref("Error")}} fournit une trace des fonctions qui ont été appelées, dans quel ordre, depuis quelle ligne de quel fichier, et avec quels arguments. La chaine de pile remonte des appels les plus récents jusqu'aux plus anciens, ramenant à l'appel original de la portée globale.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Chaque étape sera séparée par une nouvelle ligne, la première partie de la ligne étant le nom de la fonction (si ce n'est pas un appel depuis la portée globale), suivi du signe arobase (@), de l'emplacement du fichier (sauf quand la fonction est le constructeur d'erreur lorsque l'erreur est déclenchée), de deux-points, et, s'il y a un emplacement de fichier, du numéro de ligne. (Notez que l'objet {{jsxref("Error")}} possède aussi les propriétés <code>fileName</code>, <code>lineNumber</code> et <code>columnNumber</code> pour leur récupération à partir de l'erreur déclenchée (mais seulement l'erreur, et pas sa trace)).</p>
+Chaque étape sera séparée par une nouvelle ligne, la première partie de la ligne étant le nom de la fonction (si ce n'est pas un appel depuis la portée globale), suivi du signe arobase (@), de l'emplacement du fichier (sauf quand la fonction est le constructeur d'erreur lorsque l'erreur est déclenchée), de deux-points, et, s'il y a un emplacement de fichier, du numéro de ligne. (Notez que l'objet {{jsxref("Error")}} possède aussi les propriétés `fileName`, `lineNumber` et `columnNumber` pour leur récupération à partir de l'erreur déclenchée (mais seulement l'erreur, et pas sa trace)).
 
-<p>Notez que ceci est le format utilisé par Firefox. Il n'y a aucun formatage standard. Cependant Safari 6+ et Opera 12- utilisent un format très similaire. Les navigateurs utilisant le moteur JavaScript V8 (tel que Chrome, Opera 15+, Navigateur Android) et IE10+, utilisent un format différent (voir la documentation MSDN <a href="https://web.archive.org/web/20140210004225/http://msdn.microsoft.com/en-us/library/windows/apps/hh699850.aspx">error.stack</a>).</p>
+Notez que ceci est le format utilisé par Firefox. Il n'y a aucun formatage standard. Cependant Safari 6+ et Opera 12- utilisent un format très similaire. Les navigateurs utilisant le moteur JavaScript V8 (tel que Chrome, Opera 15+, Navigateur Android) et IE10+, utilisent un format différent (voir la documentation MSDN [error.stack](https://web.archive.org/web/20140210004225/http://msdn.microsoft.com/en-us/library/windows/apps/hh699850.aspx)).
 
-<p><strong>Valeurs des arguments dans la pile :</strong> avant Firefox 14 ({{bug("744842")}}), le nom d'une fonction étaient suivis par les valeurs des arguments converties en une chaine de caractères entre parenthèses, immédiatement avant le signe arobase (@). Tandis qu'un objet (ou un tableau, etc.) apparaissait sous la forme convertie <code>"[object Object]"</code>, et en tant que tel, ne pouvait pas être réévalué en les objets réels, les valeurs scalaires pouvaient être récupérées (bien qu'il soit plus facile — c'est toujours possible dans Firefox 14 — d'utiliser <code>arguments.callee.caller.arguments</code>, tout comme le nom de la fonction pouvait être récupéré avec <code>arguments.callee.caller.name</code>). <code>"undefined"</code> est listé comme <code>"(void 0)"</code>. Notez que si des arguments chaines de caractères étaient passés avec des valeurs comme <code>"@"</code>, <code>"("</code>, <code>")"</code> (ou si dans les noms de fichier), vous ne pouviez pas vous reposez facilement sur ceux-ci pour découper la ligne en les parties qui la composent. Par conséquent, dans Firefox 14 et ultérieur, ceci est moins un problème.</p>
+**Valeurs des arguments dans la pile :** avant Firefox 14 ({{bug("744842")}}), le nom d'une fonction étaient suivis par les valeurs des arguments converties en une chaine de caractères entre parenthèses, immédiatement avant le signe arobase (@). Tandis qu'un objet (ou un tableau, etc.) apparaissait sous la forme convertie `"[object Object]"`, et en tant que tel, ne pouvait pas être réévalué en les objets réels, les valeurs scalaires pouvaient être récupérées (bien qu'il soit plus facile — c'est toujours possible dans Firefox 14 — d'utiliser `arguments.callee.caller.arguments`, tout comme le nom de la fonction pouvait être récupéré avec `arguments.callee.caller.name`). `"undefined"` est listé comme `"(void 0)"`. Notez que si des arguments chaines de caractères étaient passés avec des valeurs comme `"@"`, `"("`, `")"` (ou si dans les noms de fichier), vous ne pouviez pas vous reposez facilement sur ceux-ci pour découper la ligne en les parties qui la composent. Par conséquent, dans Firefox 14 et ultérieur, ceci est moins un problème.
 
-<p>Les différents navigateurs définissent cette valeur à différents instants. Par exemple, Firefox la définit lors de la création d'un objet {{jsxref("Error")}}, tandis que PhantomJS ne la définit que lors du déclenchement de l'{{jsxref("Error")}}, et la <a href="https://web.archive.org/web/20140210004225/http://msdn.microsoft.com/en-us/library/windows/apps/hh699850.aspx">documentation MSDN</a> semble correspondre à l'implémentation PhantomJS.</p>
+Les différents navigateurs définissent cette valeur à différents instants. Par exemple, Firefox la définit lors de la création d'un objet {{jsxref("Error")}}, tandis que PhantomJS ne la définit que lors du déclenchement de l'{{jsxref("Error")}}, et la [documentation MSDN](https://web.archive.org/web/20140210004225/http://msdn.microsoft.com/en-us/library/windows/apps/hh699850.aspx) semble correspondre à l'implémentation PhantomJS.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<p>Le code HTML suivant démontre l'utilisation de la propriété <code>stack</code>.</p>
+Le code HTML suivant démontre l'utilisation de la propriété `stack`.
 
-<pre class="brush: html">&lt;!DOCTYPE HTML&gt;
-&lt;meta charset="UTF-8"&gt;
-&lt;title&gt;Exemple de Trace de Pile&lt;/title&gt;
-&lt;body&gt;
-    &lt;script&gt;
+```html
+<!DOCTYPE HTML>
+<meta charset="UTF-8">
+<title>Exemple de Trace de Pile</title>
+<body>
+    <script>
         function trace() {
             try {
                 throw new Error('monError');
@@ -49,46 +50,47 @@ original_slug: Web/JavaScript/Reference/Objets_globaux/Error/Stack
             b(3, 4, "\n\n", undefined, {});
         }
         a("premier appel, premierarg");
-    &lt;/script&gt;
-</pre>
+    </script>
+```
 
-<p>En supposant que ce code a été enregistré comme <code>C:\exemple.html</code> sur un système de fichier Windows, il produira un message d'alerte dans une nouvelle fenêtre avec le texte suivant :</p>
+En supposant que ce code a été enregistré comme `C:\exemple.html` sur un système de fichier Windows, il produira un message d'alerte dans une nouvelle fenêtre avec le texte suivant :
 
-<p>À partir de Firefox 30 et ultérieur, ce message contiendra le numéro de colonne  ({{bug(762556)}}) :</p>
+À partir de Firefox 30 et ultérieur, ce message contiendra le numéro de colonne  ({{bug(762556)}}) :
 
-<pre class="brush: html">trace@file:///C:/exemple.html:9:17
+```html
+trace@file:///C:/exemple.html:9:17
 b@file:///C:/exemple.html:16:13
 a@file:///C:/exemple.html:19:13
-@file:///C:/exemple.html:21:9</pre>
+@file:///C:/exemple.html:21:9
+```
 
-<p>De Firefox 14 à Firefox 29 :</p>
+De Firefox 14 à Firefox 29 :
 
-<pre><samp>trace@file:///C:/exemple.html:9
-b@file:///C:/exemple.html:16
-a@file:///C:/exemple.html:19
-@file:///C:/exemple.html:21
-</samp></pre>
+    trace@file:///C:/exemple.html:9
+    b@file:///C:/exemple.html:16
+    a@file:///C:/exemple.html:19
+    @file:///C:/exemple.html:21
 
-<p>Firefox 13 et antérieur aurait produit à la place le texte suivant :</p>
+Firefox 13 et antérieur aurait produit à la place le texte suivant :
 
-<pre><samp>Error("monError")@:0
-trace()@file:///C:/exemple.html:9
-b(3,4,"\n\n",(void 0),[object Object])@file:///C:/exemple.html:16
-a("premier appel, premierarg")@file:///C:/exemple.html:19
-@file:///C:/exemple.html:21
-</samp></pre>
+    Error("monError")@:0
+    trace()@file:///C:/exemple.html:9
+    b(3,4,"\n\n",(void 0),[object Object])@file:///C:/exemple.html:16
+    a("premier appel, premierarg")@file:///C:/exemple.html:19
+    @file:///C:/exemple.html:21
 
-<h3 id="Pile_d'un_code_evalué">Pile d'un code evalué</h3>
+### Pile d'un code evalué
 
-<p>À partir de Firefox 30 {{geckoRelease("30")}}, la pile d'erreur du code dans les appels à <code>Function()</code> et <code>eval()</code> produit désormais des piles avec des informations plus détaillées sur les numéros de lignes et de colonnes dans ces appels. Les appels de fonction sont indiqués par <code>"&gt; Function"</code> et les appels d'<code>eval</code> par <code>"&gt; eval"</code>. Voir {{bug("332176")}}.</p>
+À partir de Firefox 30 {{geckoRelease("30")}}, la pile d'erreur du code dans les appels à `Function()` et `eval()` produit désormais des piles avec des informations plus détaillées sur les numéros de lignes et de colonnes dans ces appels. Les appels de fonction sont indiqués par `"> Function"` et les appels d'`eval` par `"> eval"`. Voir {{bug("332176")}}.
 
-<pre class="brush: js">try {
+```js
+try {
   new Function('throw new Error()')();
 } catch (e) {
   console.log(e.stack);
 }
 
-// anonymous@file:///C:/exemple.html line 7 &gt; Function:1:1
+// anonymous@file:///C:/exemple.html line 7 > Function:1:1
 // @file:///C:/exemple.html:7:6
 
 try {
@@ -97,25 +99,24 @@ try {
   console.log(x.stack);
 }
 
-// @file:///C:/exemple.html line 7 &gt; eval line 1 &gt; eval:1:1
-// @file:///C:/exemple.html line 7 &gt; eval:1:1
-// @file:///C:/exemple.html:7:6</pre>
+// @file:///C:/exemple.html line 7 > eval line 1 > eval:1:1
+// @file:///C:/exemple.html line 7 > eval:1:1
+// @file:///C:/exemple.html:7:6
+```
 
-<p>Vous pouvez aussi utiliser la directive <code>//# sourceURL</code> pour nommer une source eval. Voir aussi <a href="https://developer.mozilla.org/fr-FR/docs/Tools/Debugger/How_to/Debug_eval_sources">Déboguer des sources évaluées</a> dans les docs <a href="https://developer.mozilla.org/fr-FR/docs/Tools/Debugger">Débogueur</a>, ainsi que ce <a href="http://fitzgeraldnick.com/weblog/59/">blog post</a>.</p>
+Vous pouvez aussi utiliser la directive `//# sourceURL` pour nommer une source eval. Voir aussi [Déboguer des sources évaluées](https://developer.mozilla.org/fr-FR/docs/Tools/Debugger/How_to/Debug_eval_sources) dans les docs [Débogueur](https://developer.mozilla.org/fr-FR/docs/Tools/Debugger), ainsi que ce [blog post](http://fitzgeraldnick.com/weblog/59/).
 
-<h2 id="Spécifications">Spécifications</h2>
+## Spécifications
 
-<p>Ne fait partie d'aucune spécification. Non-standard.</p>
+Ne fait partie d'aucune spécification. Non-standard.
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.Error.stack")}}</p>
+{{Compat("javascript.builtins.Error.stack")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li><a href="/fr-FR/docs/Components.stack">Components.stack</a></li>
- <li>Projets externes : <a class="link-https" href="https://github.com/csnover/TraceKit/">TraceKit</a> et <a class="link-https" href="https://github.com/eriwen/javascript-stacktrace">javascript-stacktrace</a></li>
- <li>MSDN : docs <a href="https://web.archive.org/web/20140210004225/http://msdn.microsoft.com/en-us/library/windows/apps/hh699850.aspx">error.stack</a></li>
- <li><a href="https://github.com/v8/v8/wiki/Stack%20Trace%20API">Overview of the V8 JavaScript stack trace API</a></li>
-</ul>
+- [Components.stack](/fr-FR/docs/Components.stack)
+- Projets externes : [TraceKit](https://github.com/csnover/TraceKit/) et [javascript-stacktrace](https://github.com/eriwen/javascript-stacktrace)
+- MSDN : docs [error.stack](https://web.archive.org/web/20140210004225/http://msdn.microsoft.com/en-us/library/windows/apps/hh699850.aspx)
+- [Overview of the V8 JavaScript stack trace API](https://github.com/v8/v8/wiki/Stack%20Trace%20API)
diff --git a/files/fr/web/javascript/reference/global_objects/error/tosource/index.md b/files/fr/web/javascript/reference/global_objects/error/tosource/index.md
index 5c84fe9b75..9876514034 100644
--- a/files/fr/web/javascript/reference/global_objects/error/tosource/index.md
+++ b/files/fr/web/javascript/reference/global_objects/error/tosource/index.md
@@ -11,42 +11,42 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Error/toSource
 original_slug: Web/JavaScript/Reference/Objets_globaux/Error/toSource
 ---
-<div>{{JSRef}} {{non-standard_header}}</div>
+{{JSRef}} {{non-standard_header}}
 
-<p>La méthode <code><strong>toSource()</strong></code> renvoie le code source qui peut générer la même erreur.</p>
+La méthode **`toSource()`** renvoie le code source qui peut générer la même erreur.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><em>e</em>.toSource()</pre>
+    e.toSource()
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une chaîne de caractères qui contient le code source de l'erreur.</p>
+Une chaîne de caractères qui contient le code source de l'erreur.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Appeler la méthode <code>toSource()</code> d'une instance {{jsxref("Error")}} (<a href="/fr/docs/JavaScript/Reference/Objets_globaux/Error#Error_types">Erreurs natives</a> incluses) renverra le code source de l'erreur. Cette chaine de caractères peut être évaluée afin de créer un objet similaire. La chaine de caractères contenant le code source suit la structure du constructeur <code>Error</code>. Par exemple :</p>
+Appeler la méthode `toSource()` d'une instance {{jsxref("Error")}} ([Erreurs natives](/fr/docs/JavaScript/Reference/Objets_globaux/Error#Error_types) incluses) renverra le code source de l'erreur. Cette chaine de caractères peut être évaluée afin de créer un objet similaire. La chaine de caractères contenant le code source suit la structure du constructeur `Error`. Par exemple :
 
-<pre class="brush: js">(new name(message ,fileName, lineNumber))</pre>
+```js
+(new name(message ,fileName, lineNumber))
+```
 
-<p>où ces attributs correspondent aux propriétés respectives de l'instance <code>Error</code>.</p>
+où ces attributs correspondent aux propriétés respectives de l'instance `Error`.
 
-<div class="note"><p><strong>Note :</strong> Les propriétés utilisées par la méthode <code>toSource()</code> dans la création de cette chaine de caractères sont mutables et peuvent ne pas refléter correctement la fonction utilisée pour créer une instance d'erreur ou le nom du fichier ou la ligne à laquelle s'est produite l'erreur originale.</p></div>
+> **Note :** Les propriétés utilisées par la méthode `toSource()` dans la création de cette chaine de caractères sont mutables et peuvent ne pas refléter correctement la fonction utilisée pour créer une instance d'erreur ou le nom du fichier ou la ligne à laquelle s'est produite l'erreur originale.
 
-<h2 id="Spécifications">Spécifications</h2>
+## Spécifications
 
-<p>Ne fait partie d'aucun standard. Implémentée dans JavaScript 1.3.</p>
+Ne fait partie d'aucun standard. Implémentée dans JavaScript 1.3.
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.Error.toSource")}}</p>
+{{Compat("javascript.builtins.Error.toSource")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("Error.prototype.fileName")}} {{non-standard_inline}}</li>
- <li>{{jsxref("Error.prototype.lineNumber")}} {{non-standard_inline}}</li>
- <li>{{jsxref("Error.prototype.message")}}</li>
- <li>{{jsxref("Error.prototype.name")}}</li>
- <li>{{jsxref("Object.prototype.toSource()")}} {{non-standard_inline}}</li>
-</ul>
+- {{jsxref("Error.prototype.fileName")}} {{non-standard_inline}}
+- {{jsxref("Error.prototype.lineNumber")}} {{non-standard_inline}}
+- {{jsxref("Error.prototype.message")}}
+- {{jsxref("Error.prototype.name")}}
+- {{jsxref("Object.prototype.toSource()")}} {{non-standard_inline}}
diff --git a/files/fr/web/javascript/reference/global_objects/error/tostring/index.md b/files/fr/web/javascript/reference/global_objects/error/tostring/index.md
index cd67175fff..97119fcb6e 100644
--- a/files/fr/web/javascript/reference/global_objects/error/tostring/index.md
+++ b/files/fr/web/javascript/reference/global_objects/error/tostring/index.md
@@ -10,23 +10,24 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Error/toString
 original_slug: Web/JavaScript/Reference/Objets_globaux/Error/toString
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>toString()</strong></code> renvoie une représentation de l'objet {{jsxref("Error")}} sous la forme d'une chaine de caractères.</p>
+La méthode **`toString()`** renvoie une représentation de l'objet {{jsxref("Error")}} sous la forme d'une chaine de caractères.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>e</var>.toString()</pre>
+    e.toString()
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une chaîne de caractères représentant l'objet {{jsxref("Error")}}.</p>
+Une chaîne de caractères représentant l'objet {{jsxref("Error")}}.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>L'objet {{jsxref("Error")}} surcharge la méthode {{jsxref("Object.prototype.toString()")}} héritée par tous les objets. Sa sémantique est la suivante (en partant du principe que {{jsxref("Object")}} et {{jsxref("String")}} ont leurs valeurs originales) :</p>
+L'objet {{jsxref("Error")}} surcharge la méthode {{jsxref("Object.prototype.toString()")}} héritée par tous les objets. Sa sémantique est la suivante (en partant du principe que {{jsxref("Object")}} et {{jsxref("String")}} ont leurs valeurs originales) :
 
-<pre class="brush:js">Error.prototype.toString = function () {
+```js
+Error.prototype.toString = function () {
   "use strict";
 
   var obj = Object(this);
@@ -46,11 +47,12 @@ original_slug: Web/JavaScript/Reference/Objets_globaux/Error/toString
 
   return name + ": " + msg;
 };
-</pre>
+```
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<pre class="brush:js">var e = new Error("Erreur fatale");
+```js
+var e = new Error("Erreur fatale");
 console.log(e.toString()); // "Error: Erreur fatale"
 
 e.name = undefined;
@@ -64,46 +66,21 @@ console.log(e.toString()); // ""
 
 e.name = "salut";
 console.log(e.toString()); // "salut"
-</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.11.4.4', 'Error.prototype.toString')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-error.prototype.tostring', 'Error.prototype.toString')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-error.prototype.tostring', 'Error.prototype.toString')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Error.toString")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Error.prototype.toSource()")}} {{non-standard_inline}}</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.11.4.4', 'Error.prototype.toString')}}                         | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-error.prototype.tostring', 'Error.prototype.toString')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-error.prototype.tostring', 'Error.prototype.toString')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Error.toString")}}
+
+## Voir aussi
+
+- {{jsxref("Error.prototype.toSource()")}} {{non-standard_inline}}
diff --git a/files/fr/web/javascript/reference/global_objects/escape/index.md b/files/fr/web/javascript/reference/global_objects/escape/index.md
index e1b23297b0..f3222c3d56 100644
--- a/files/fr/web/javascript/reference/global_objects/escape/index.md
+++ b/files/fr/web/javascript/reference/global_objects/escape/index.md
@@ -7,90 +7,62 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/escape
 original_slug: Web/JavaScript/Reference/Objets_globaux/escape
 ---
-<div>{{jsSidebar("Objects")}}</div>
+{{jsSidebar("Objects")}}
 
-<div class="warning"><p><strong>Attention :</strong> Bien que <code>escape(…)</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 commence par :
+> **Attention :** Bien que `escape(…)` 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 commence par :
+>
+> > … L'ensemble des fonctionnalités et comportements définis dans cette annexe possède une ou plusieurs caractéristiques indésirables. En l'absence d'une utilisation historique, ces fonctionnalités seraient retirés de la spécification. …
+> > … Les développeurs ne devraient pas utiliser ces fonctionnalités et comportements ou présupposer qu'elles existent lors de l'écriture de nouveau code ECMAScript. …
 
-<blockquote>… L'ensemble des fonctionnalités et comportements définis dans cette annexe possède une ou plusieurs caractéristiques indésirables. En l'absence d'une utilisation historique, ces fonctionnalités seraient retirés de la spécification. …<br>
-… Les développeurs ne devraient pas utiliser ces fonctionnalités et comportements ou présupposer qu'elles existent lors de l'écriture de nouveau code ECMAScript. …</blockquote></p>
-</div>
+La fonction **`escape()`** permet de renvoyer une nouvelle chaîne de caractères dont certains caractères ont été remplacés par leur séquence d'échappement hexadécimale. Cette méthode est obsolète et il est donc conseillé d'utiliser {{jsxref("encodeURI")}} ou {{jsxref("encodeURIComponent")}} à la place.
 
-<p>La fonction <code><strong>escape()</strong></code> permet de renvoyer une nouvelle chaîne de caractères dont certains caractères ont été remplacés par leur séquence d'échappement hexadécimale. Cette méthode est obsolète et il est donc conseillé d'utiliser {{jsxref("encodeURI")}} ou {{jsxref("encodeURIComponent")}} à la place.</p>
+> **Note :** Cette fonction pouvait être utilisée pour l'encodage de fragment de requêtes d'URL. Si on souhaite remplacer des caractères par leur séquence d'échappement correcte (avec `%20` par exemple), on pourra utiliser [`decodeURIComponent`](/fr/docs/Web/JavaScript/Reference/Objets_globaux/decodeURIComponent).
 
-<div class="blockIndicator note">
-<p><strong>Note :</strong> Cette fonction pouvait être utilisée pour l'encodage de fragment de requêtes d'URL. Si on souhaite remplacer des caractères par leur séquence d'échappement correcte (avec <code>%20</code> par exemple), on pourra utiliser <code><a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/decodeURIComponent">decodeURIComponent</a></code>.</p>
-</div>
+## Syntaxe
 
-<h2 id="Syntaxe">Syntaxe</h2>
+    escape(str)
 
-<pre class="syntaxbox">escape(<var>str</var>)</pre>
+### Paramètres
 
-<h3 id="Paramètres">Paramètres</h3>
+- `str`
+  - : Une chaîne de caractères à encoder.
 
-<dl>
- <dt><code>str</code></dt>
- <dd>Une chaîne de caractères à encoder.</dd>
-</dl>
+### Valeur de retour
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+Une nouvelle chaîne de caractères dont certains caractères ont été échappés.
 
-<p>Une nouvelle chaîne de caractères dont certains caractères ont été échappés.</p>
+## Description
 
-<h2 id="Description">Description</h2>
+La fonction `escape` est une propriété de l'_objet global_. Les caractères spéciaux, sauf @\*\_+-./, seront encodés.
 
-<p>La fonction <code>escape</code> est une propriété de l'<em>objet global</em>. Les caractères spéciaux, sauf @*_+-./, seront encodés.</p>
+La forme hexadécimale des caractères dont la valeur du codet est inférieure à 0xFF sera représentée sur deux chiffres : %xx. Pour les caractères avec un code supérieur, quatre chiffres seront utilisés avec le format suivant %**u**xxxx.
 
-<p>La forme hexadécimale des caractères dont la valeur du codet est inférieure à 0xFF sera représentée sur deux chiffres : %xx. Pour les caractères avec un code supérieur, quatre chiffres seront utilisés avec le format suivant %<strong>u</strong>xxxx.</p>
+## Exemples
 
-<h2 id="Exemples">Exemples</h2>
-
-<pre class="brush: js">escape("abc123");     // "abc123"
+```js
+escape("abc123");     // "abc123"
 escape("äöü");        // "%E4%F6%FC"
 escape("ć");          // "%u0107"
 
 // caractères spéciaux
-escape("@*_+-./");    // "@*_+-./"</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-B.2.1', 'escape')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td>Définie dans l'annexe B (informative) sur la compatibilité.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-escape-string', 'escape')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Définie dans l'annexe B (normative) pour les fonctionnalités additionnelles d'ECMAScript pour les navigateurs Web.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-escape-string', 'escape')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td>Définie dans l'annexe B (normative) pour les fonctionnalités additionnelles d'ECMAScript pour les navigateurs Web.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.escape")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("encodeURI")}}</li>
- <li>{{jsxref("encodeURIComponent")}}</li>
- <li>{{jsxref("unescape")}}</li>
-</ul>
+escape("@*_+-./");    // "@*_+-./"
+```
+
+## Spécifications
+
+| Spécification                                                            | État                         | Commentaires                                                                                                       |
+| ------------------------------------------------------------------------ | ---------------------------- | ------------------------------------------------------------------------------------------------------------------ |
+| {{SpecName('ES1')}}                                                 | {{Spec2('ES1')}}         | Définition initiale.                                                                                               |
+| {{SpecName('ES5.1', '#sec-B.2.1', 'escape')}}             | {{Spec2('ES5.1')}}     | Définie dans l'annexe B (informative) sur la compatibilité.                                                        |
+| {{SpecName('ES6', '#sec-escape-string', 'escape')}}     | {{Spec2('ES6')}}         | Définie dans l'annexe B (normative) pour les fonctionnalités additionnelles d'ECMAScript pour les navigateurs Web. |
+| {{SpecName('ESDraft', '#sec-escape-string', 'escape')}} | {{Spec2('ESDraft')}} | Définie dans l'annexe B (normative) pour les fonctionnalités additionnelles d'ECMAScript pour les navigateurs Web. |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.escape")}}
+
+## Voir aussi
+
+- {{jsxref("encodeURI")}}
+- {{jsxref("encodeURIComponent")}}
+- {{jsxref("unescape")}}
diff --git a/files/fr/web/javascript/reference/global_objects/eval/index.md b/files/fr/web/javascript/reference/global_objects/eval/index.md
index d52bd140e3..e28f94f20e 100644
--- a/files/fr/web/javascript/reference/global_objects/eval/index.md
+++ b/files/fr/web/javascript/reference/global_objects/eval/index.md
@@ -10,96 +10,99 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/eval
 original_slug: Web/JavaScript/Reference/Objets_globaux/eval
 ---
-<div>{{jsSidebar("Objects")}}</div>
+{{jsSidebar("Objects")}}
 
-<p>La fonction <code><strong>eval()</strong></code> permet d'évaluer du code JavaScript représenté sous forme d'une chaîne de caractères.</p>
+La fonction **`eval()`** permet d'évaluer du code JavaScript représenté sous forme d'une chaîne de caractères.
 
-<div class="warning">
-<p><strong>Attention :</strong> L'exécution de JavaScript à partir d'une chaîne de caractères constitue un risque de sécurité énorme. Il est beaucoup trop facile pour un mauvais acteur d'exécuter du code arbitraire lorsque vous utilisez <code>eval()</code>. Voir la section <a href="#Nutiliser_eval_quen_dernier_recours_!">N'utilisez eval() qu'en dernier recours !</a> ci-dessous.</p>
-</div>
+> **Attention :** L'exécution de JavaScript à partir d'une chaîne de caractères constitue un risque de sécurité énorme. Il est beaucoup trop facile pour un mauvais acteur d'exécuter du code arbitraire lorsque vous utilisez `eval()`. Voir la section [N'utilisez eval() qu'en dernier recours !](#Nutiliser_eval_quen_dernier_recours_!) ci-dessous.
 
-<div>{{EmbedInteractiveExample("pages/js/globalprops-eval.html")}}</div>
+{{EmbedInteractiveExample("pages/js/globalprops-eval.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre>eval(<var>str</var>)</pre>
+    eval(str)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>str</code></dt>
- <dd>Une chaîne de caractères qui représente une expression JavaScript ou une instruction ou une suite d'instructions JavaScript. L'expression utilisée peut contenir des variables et des propriétés d'objets existants.</dd>
-</dl>
+- `str`
+  - : Une chaîne de caractères qui représente une expression JavaScript ou une instruction ou une suite d'instructions JavaScript. L'expression utilisée peut contenir des variables et des propriétés d'objets existants.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>La valeur de terminaison du code fourni en argument. Si la valeur de terminaison est vide, c'est la valeur {{jsxref("undefined")}} qui est renvoyée.</p>
+La valeur de terminaison du code fourni en argument. Si la valeur de terminaison est vide, c'est la valeur {{jsxref("undefined")}} qui est renvoyée.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p><code>eval()</code> est une fonction rattachée à l'objet global.</p>
+`eval()` est une fonction rattachée à l'objet global.
 
-<p><code>eval()</code> prend en compte un argument qui est une chaîne de caractères. Si cette chaîne représente une expression, <code>eval()</code> évaluera l'expression. Si l'argument utilisé représente une ou plusieurs instructions JavaScript, <code>eval()</code> évaluera les instructions. <code>eval()</code> ne doit pas être utilisé pour évaluer une expression arithmétique. En effet, JavaScript évalue automatiquement les expressions arithmétiques.</p>
+`eval()` prend en compte un argument qui est une chaîne de caractères. Si cette chaîne représente une expression, `eval()` évaluera l'expression. Si l'argument utilisé représente une ou plusieurs instructions JavaScript, `eval()` évaluera les instructions. `eval()` ne doit pas être utilisé pour évaluer une expression arithmétique. En effet, JavaScript évalue automatiquement les expressions arithmétiques.
 
-<p>Si on construit une expression arithmétique sous la forme d'une chaîne de caractères, on peut utiliser <code>eval()</code> pour évaluer cette expression par la suite. Ainsi, si on a une variable <code>x</code>, on peut préparer une expression à utiliser plus tard en construisant la chaîne "<code>3 * x + 2</code>" par exemple. Au moment où on souhaite procéder à l'évaluation, on appellera <code>eval()</code> avec cette chaîne de caractères.</p>
+Si on construit une expression arithmétique sous la forme d'une chaîne de caractères, on peut utiliser `eval()` pour évaluer cette expression par la suite. Ainsi, si on a une variable `x`, on peut préparer une expression à utiliser plus tard en construisant la chaîne "`3 * x + 2`" par exemple. Au moment où on souhaite procéder à l'évaluation, on appellera `eval()` avec cette chaîne de caractères.
 
-<p>Si l'argument passé à <code>eval()</code> n'est pas une chaîne de caractères, <code>eval()</code> renverra l'argument inchangé. Dans l'exemple qui suit, on utilise le constructeur <code>String</code>, <code>eval()</code> renvoie donc un objet <code>String</code> au lieu d'évaluer la chaîne de caractères correspondante.</p>
+Si l'argument passé à `eval()` n'est pas une chaîne de caractères, `eval()` renverra l'argument inchangé. Dans l'exemple qui suit, on utilise le constructeur `String`, `eval()` renvoie donc un objet `String` au lieu d'évaluer la chaîne de caractères correspondante.
 
-<pre class="brush:js">eval(new String("2 + 2")); // renvoie un objet String contenant "2 + 2"
+```js
+eval(new String("2 + 2")); // renvoie un objet String contenant "2 + 2"
 eval("2 + 2");             // renvoie 4
-</pre>
+```
 
-<p>Ce comportement peut être résolu de façon générique en utilisant la méthode <code>toString()</code>.</p>
+Ce comportement peut être résolu de façon générique en utilisant la méthode `toString()`.
 
-<pre class="brush:js">var expression = new String("2 + 2");
+```js
+var expression = new String("2 + 2");
 eval(expression.toString());
-</pre>
+```
 
-<p>Si la fonction  <code>eval</code> est utilisée de manière indirecte, en l'invoquant par une référence autre que <code>eval</code>, cela fonctionnera avec une portée globale plutôt que locale (d'après ECMASCript 5). Par exemple, les déclarations de fonctions vont créer des fonctions globales et le code en cours d'évaluation n'aura pas accès aux variables locales déclarées avec la même portée que là où la fonction <code>eval</code> est appelée.</p>
+Si la fonction  `eval` est utilisée de manière indirecte, en l'invoquant par une référence autre que `eval`, cela fonctionnera avec une portée globale plutôt que locale (d'après ECMASCript 5). Par exemple, les déclarations de fonctions vont créer des fonctions globales et le code en cours d'évaluation n'aura pas accès aux variables locales déclarées avec la même portée que là où la fonction `eval` est appelée.
 
-<pre class="brush: js">function test() {
+```js
+function test() {
   var x = 2, y = 4;
   console.log(eval("x + y"));  // Appel direct, portée locale, résultat de 6
   var geval = eval;
   console.log(geval("x + y")); // Appel indirect, portée globale, lance une exception ReferenceError car `x` n'est pas défini
   (0, eval)('x + y'); // un autre exemple d'appel indirect.
-}</pre>
+}
+```
 
-<h2 id="Nutiliser_eval_quen_dernier_recours_!">N'utiliser <code>eval()</code> qu'en dernier recours !</h2>
+## N'utiliser `eval()` qu'en dernier recours !
 
-<p><code>eval()</code> est une fonction dangereuse qui exécute le code passé en argument avec les privilèges de l'environnement appelant. Si <code>eval()</code> est utilisée avec une chaîne construite de façon mal intentionnée, cela pourra entraîner l'exécution d'un code malveillant sur la machine de l'utilisateur avec les permissions données au site ou au module complémentaire. À un niveau encore plus critique, du code tiers pourrait ainsi consulter la portée dans laquelle <code>eval()</code> a été invoquée. Cela peut permettre des attaques qui n'auraient pas été rendues possible en utilisant un objet {{jsxref("Function")}}.</p>
+`eval()` est une fonction dangereuse qui exécute le code passé en argument avec les privilèges de l'environnement appelant. Si `eval()` est utilisée avec une chaîne construite de façon mal intentionnée, cela pourra entraîner l'exécution d'un code malveillant sur la machine de l'utilisateur avec les permissions données au site ou au module complémentaire. À un niveau encore plus critique, du code tiers pourrait ainsi consulter la portée dans laquelle `eval()` a été invoquée. Cela peut permettre des attaques qui n'auraient pas été rendues possible en utilisant un objet {{jsxref("Function")}}.
 
-<p><code>eval()</code> est également plus lente que les méthodes alternatives. En effet, l'évaluation nécessite de faire appel à l'interpréteur JavaScript alors que de nombreuses structures sont optimisées par les moteurs JavaScript modernes.</p>
+`eval()` est également plus lente que les méthodes alternatives. En effet, l'évaluation nécessite de faire appel à l'interpréteur JavaScript alors que de nombreuses structures sont optimisées par les moteurs JavaScript modernes.
 
-<p>Dans de nombreux cas, il existe des alternatives plus sûres et plus performantes à <code>eval()</code>.</p>
+Dans de nombreux cas, il existe des alternatives plus sûres et plus performantes à `eval()`.
 
-<p>De plus, les moteurs JavaScript modernes convertissent le code JavaScript en code machine. Les notions relatives aux noms des variables sont donc transformées. Utiliser <code>eval()</code> force le navigateur à enregistrer puis à rechercher parmi les noms existants afin de retrouver les variables. Si besoin, on peut utiliser le constructeur <code><a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Function">Function</a></code> :</p>
+De plus, les moteurs JavaScript modernes convertissent le code JavaScript en code machine. Les notions relatives aux noms des variables sont donc transformées. Utiliser `eval()` force le navigateur à enregistrer puis à rechercher parmi les noms existants afin de retrouver les variables. Si besoin, on peut utiliser le constructeur [`Function`](/fr/docs/Web/JavaScript/Reference/Objets_globaux/Function) :
 
-<p>Avec <code>eval()</code> :</p>
+Avec `eval()` :
 
-<pre class="brush:js">function looseJsonParse(obj){
+```js
+function looseJsonParse(obj){
     return eval("(" + obj + ")");
 }
 console.log(looseJsonParse(
    "{a:(4-1), b:function(){}, c:new Date()}"
 ))
-</pre>
+```
 
-<p>Avec <code>Function</code> :</p>
+Avec `Function` :
 
-<pre class="brush:js">function looseJsonParse(obj){
+```js
+function looseJsonParse(obj){
     return Function('"use strict";return (' + obj + ')')();
 }
 console.log(looseJsonParse(
    "{a:(4-1), b:function(){}, c:new Date()}"
 ))
-</pre>
+```
 
-<p>Dans le premier cas, l'évaluation de <code>c: new Date()</code> sera beaucoup plus lente car <code>Date</code> peut faire référence à une variable déclarée avant. Dans le second cas, la fonction est évaluée dans la portée globale et le moteur peut donc utiliser {{jsxref("Date")}} directement.</p>
+Dans le premier cas, l'évaluation de `c: new Date()` sera beaucoup plus lente car `Date` peut faire référence à une variable déclarée avant. Dans le second cas, la fonction est évaluée dans la portée globale et le moteur peut donc utiliser {{jsxref("Date")}} directement.
 
-<p>Autrement dit, dans le premier cas, on aurait pu avoir un code comme :</p>
+Autrement dit, dans le premier cas, on aurait pu avoir un code comme :
 
-<pre class="brush:js">function Date(n){
+```js
+function Date(n){
     return ["Monday","Tuesday","Wednesday","Thursaday","Friday","Saturday","Sunday"][n%7 || 0];
 }
 function looseJsonParse(obj){
@@ -108,13 +111,14 @@ function looseJsonParse(obj){
 console.log(looseJsonParse(
    "{a:(4-1), b:function(){}, c:new Date()}"
 ))
-</pre>
+```
 
-<p>Auquel cas, le navigateur doit effectuer une recherche coûteuse afin de vérifier s'il y a des variables locales <code>Date</code>.</p>
+Auquel cas, le navigateur doit effectuer une recherche coûteuse afin de vérifier s'il y a des variables locales `Date`.
 
-<p>Pour obtenir un résultat identique, on peut tout à fait se passer d'<code>eval()</code> :</p>
+Pour obtenir un résultat identique, on peut tout à fait se passer d'`eval()` :
 
-<pre class="brush:js">function Date(n){
+```js
+function Date(n){
     return ["Monday","Tuesday","Wednesday","Thursaday","Friday","Saturday","Sunday"][n%7 || 0];
 }
 function runCodeWithDateFunction(obj){
@@ -125,88 +129,95 @@ function runCodeWithDateFunction(obj){
 console.log(runCodeWithDateFunction(
    "function(Date){ return Date(5) }"
 ))
-</pre>
+```
 
-<p>1. Le code passé à <code>runCodeWithDateFunction</code> peut être minifié.</p>
+1\. Le code passé à `runCodeWithDateFunction` peut être minifié.
 
-<p>2. Le surcoût lié à un appel de fonction est léger</p>
+2\. Le surcoût lié à un appel de fonction est léger
 
-<p>3. <code>Function()</code> permet d'utiliser  <code>"use strict";</code> (qui peut également aider à améliorer les performances).</p>
+3\. `Function()` permet d'utiliser  `"use strict";` (qui peut également aider à améliorer les performances).
 
-<p>Enfin, pour la plupart des cas, on doit pouvoir éviter de passer par</p>
+Enfin, pour la plupart des cas, on doit pouvoir éviter de passer par
 
-<p><code>eval()</code> ou <code>Function()</code> !</p>
+`eval()` ou `Function()` !
 
-<h3 id="Accéder_aux_propriétés_dun_objet">Accéder aux propriétés d'un objet</h3>
+### Accéder aux propriétés d'un objet
 
-<p><code>eval()</code> ne doit pas être utilisée pour convertir des noms de propriétés en propriétés. Par exemple, lorsqu'on ne sait pas quelle propriété va être consultée avant l'exécution, on pourrait utiliser :</p>
+`eval()` ne doit pas être utilisée pour convertir des noms de propriétés en propriétés. Par exemple, lorsqu'on ne sait pas quelle propriété va être consultée avant l'exécution, on pourrait utiliser :
 
-<pre class="brush:js">var obj = { a: 20, b: 30 };
+```js
+var obj = { a: 20, b: 30 };
 var nomPropriété = getNomProp();  //une méthode qui renvoie "a" ou "b"
 
 eval( "var résultat = obj." + nomPropriété );
-</pre>
+```
 
-<p>Cependant, <code>eval()</code> n'est pas du tout nécessaire. Il est beaucoup plus simple, plus sécurisé, plus rapide, d'utiliser les <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_membres">accesseurs de propriétés</a> :</p>
+Cependant, `eval()` n'est pas du tout nécessaire. Il est beaucoup plus simple, plus sécurisé, plus rapide, d'utiliser les [accesseurs de propriétés](/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_membres) :
 
-<pre class="brush:js">var obj = { a: 20, b: 30 };
+```js
+var obj = { a: 20, b: 30 };
 var nomPropriété = getNomProp();  // une méthode qui renvoie  "a" or "b"
 var résultat = obj[nomPropriété]; //  obj[ "a" ] correspond à obj.a
-</pre>
+```
 
-<h3 id="Utiliser_des_fonctions_au_lieu_de_morceaux_de_code">Utiliser des fonctions au lieu de morceaux de code</h3>
+### Utiliser des fonctions au lieu de morceaux de code
 
-<p>Les fonctions JavaScript sont des <a class="external" href="https://en.wikipedia.org/wiki/First-class_function">citoyens de premier rang du langage</a>, cela signifie que les fonctions peuvent être passées comme arguments aux autres API, qu'elles peuvent être stockées dans des variables, dans des propriétés d'objets, etc. De nombreuses API pour le DOM fonctionnent en prenant en argument des fonctions :</p>
+Les fonctions JavaScript sont des [citoyens de premier rang du langage](https://en.wikipedia.org/wiki/First-class_function), cela signifie que les fonctions peuvent être passées comme arguments aux autres API, qu'elles peuvent être stockées dans des variables, dans des propriétés d'objets, etc. De nombreuses API pour le DOM fonctionnent en prenant en argument des fonctions :
 
-<pre class="brush: js">// au lieu de setTimeout(" ... ", 1000) on utilisera :
+```js
+// au lieu de setTimeout(" ... ", 1000) on utilisera :
 setTimeout(function() { ... }, 1000);
 
 // au lieu de elt.setAttribute("onclick", "...") on utilisera :
-elt.addEventListener("click", function() { ... } , false); </pre>
+elt.addEventListener("click", function() { ... } , false); 
+```
 
-<p><a href="/fr/docs/Web/JavaScript/Guide/Closures">Les fermetures (<em>closures</em>)</a> sont utiles lorsqu'on souhaite obtenir des fonctions paramétrées sans avoir à concaténer des chaînes de caractères.</p>
+[Les fermetures (_closures_)](/fr/docs/Web/JavaScript/Guide/Closures) sont utiles lorsqu'on souhaite obtenir des fonctions paramétrées sans avoir à concaténer des chaînes de caractères.
 
-<h3 id="Convertir_des_chaînes_JSON_en_objets_JavaScript_parsing">Convertir des chaînes JSON en objets JavaScript (<em>parsing</em>)</h3>
+### Convertir des chaînes JSON en objets JavaScript (_parsing_)
 
-<p>Si la chaîne utilisée avec <code>eval()</code> contient des données (par exemple, un tableau : <code>"[1, 2, 3]"</code>) et non du code, il est conseillé d'utiliser du {{Glossary("JSON")}}, qui permet de représenter un sous-ensemble des données représentables en JavaScript.</p>
+Si la chaîne utilisée avec `eval()` contient des données (par exemple, un tableau : `"[1, 2, 3]"`) et non du code, il est conseillé d'utiliser du {{Glossary("JSON")}}, qui permet de représenter un sous-ensemble des données représentables en JavaScript.
 
-<p>On notera que la syntaxe JSON est limitée relativement à la syntaxe JavaScript. De nombreux littéraux JavaScript ne pourront être parsés en JSON (par exemple, les virgules à la fin des instructions ne seront pas autorisées et les noms de propriétés devront être compris entre simples quotes). Il est souvent préférable d'utiliser un outil de sérialisation JSON pour que les chaînes générées puissent être analysée en JSON.</p>
+On notera que la syntaxe JSON est limitée relativement à la syntaxe JavaScript. De nombreux littéraux JavaScript ne pourront être parsés en JSON (par exemple, les virgules à la fin des instructions ne seront pas autorisées et les noms de propriétés devront être compris entre simples quotes). Il est souvent préférable d'utiliser un outil de sérialisation JSON pour que les chaînes générées puissent être analysée en JSON.
 
-<h3 id="Transmettre_des_données_et_non_du_code">Transmettre des données et non du code</h3>
+### Transmettre des données et non du code
 
-<p>Si on a par exemple une extension conçue pour parcourir le code d'une page web, on pourra transmettre des données <a href="/fr/docs/XPath">XPath</a> au lieu d'un code JavaScript.</p>
+Si on a par exemple une extension conçue pour parcourir le code d'une page web, on pourra transmettre des données [XPath](/fr/docs/XPath) au lieu d'un code JavaScript.
 
-<h3 id="Exécuter_du_code_avec_des_privilèges_restreints">Exécuter du code avec des privilèges restreints</h3>
+### Exécuter du code avec des privilèges restreints
 
-<p>S'il faut nécessairement exécuter du code, il faut le faire avec des privilèges restreints. Cela s'applique généralement aux modules complémentaires ou aux applications XUL. Pour cela, on pourra utiliser <a href="/fr/docs/Components.utils.evalInSandbox">Components.utils.evalInSandbox</a>.</p>
+S'il faut nécessairement exécuter du code, il faut le faire avec des privilèges restreints. Cela s'applique généralement aux modules complémentaires ou aux applications XUL. Pour cela, on pourra utiliser [Components.utils.evalInSandbox](/fr/docs/Components.utils.evalInSandbox).
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_eval">Utiliser <code>eval()</code></h3>
+### Utiliser `eval()`
 
-<p>Dans le code suivant, les deux instructions passées à <code>eval()</code> sous la forme d'une chaîne renvoient 42. La première évaluation porte sur la chaîne "<code>x + y + 1</code>" ; la seconde évaluation porte sur la chaîne de caractères "<code>42</code>".</p>
+Dans le code suivant, les deux instructions passées à `eval()` sous la forme d'une chaîne renvoient 42. La première évaluation porte sur la chaîne "`x + y + 1`" ; la seconde évaluation porte sur la chaîne de caractères "`42`".
 
-<pre class="brush:js">var x = 2;
+```js
+var x = 2;
 var y = 39;
 var z = "42";
 eval("x + y + 1"); // renvoie 42
 eval(z);           // renvoie 42
-</pre>
+```
 
-<h3 id="Utiliser_eval_pour_une_chaîne_dinstructions">Utiliser <code>eval()</code> pour une chaîne d'instructions</h3>
+### Utiliser `eval()` pour une chaîne d'instructions
 
-<p>Dans l'exemple qui suit, <code>eval()</code> est utilisée pour évaluer la chaîne de caractères <code>str</code>. Cette chaîne contient plusieurs instructions JavaScript qui affichent un message dans la console et qui affectent la valeur 42 à la variable <code>z</code> si <code>x</code> vaut cinq et 0 sinon. Lorsque la seconde instruction est exécutée, <code>eval()</code> entraînera l'exécution des instructions, les instructions seront évaluées et la valeur de <code>z</code> sera donc renvoyée.</p>
+Dans l'exemple qui suit, `eval()` est utilisée pour évaluer la chaîne de caractères `str`. Cette chaîne contient plusieurs instructions JavaScript qui affichent un message dans la console et qui affectent la valeur 42 à la variable `z` si `x` vaut cinq et 0 sinon. Lorsque la seconde instruction est exécutée, `eval()` entraînera l'exécution des instructions, les instructions seront évaluées et la valeur de `z` sera donc renvoyée.
 
-<pre class="brush:js">var x = 5;
+```js
+var x = 5;
 var str = "if (x == 5) {console.log('z vaut 42'); z = 42;} else z = 0; ";
 console.log("z vaut "+eval(str));
-</pre>
+```
 
-<h3 id="Le_résultat_deval_est_celui_de_la_dernière_expression">Le résultat d'<code>eval()</code> est celui de la dernière expression</h3>
+### Le résultat d'`eval()` est celui de la dernière expression
 
-<p><code>eval()</code> renvoie la valeur de la dernière expression évaluée :</p>
+`eval()` renvoie la valeur de la dernière expression évaluée :
 
-<pre class="brush:js">var str = "if ( a ) { 1+1; } else { 1+2; }";
+```js
+var str = "if ( a ) { 1+1; } else { 1+2; }";
 var a = true;
 var b = eval(str);  // renvoie 2
 
@@ -215,64 +226,39 @@ console.log("b vaut : " + b);
 a = false;
 b = eval(str);      // renvoie 3
 
-console.log("b vaut : " + b);</pre>
+console.log("b vaut : " + b);
+```
 
-<h3 id="eval_et_les_fonctions"><code>eval()</code> et les fonctions</h3>
+### `eval()` et les fonctions
 
-<p>Pour qu'une fonction soit restituée lors de l'évaluation, il est nécessaire d'encadrer l'expression contenue dans la chaîne de caractères avec des parenthèses :</p>
+Pour qu'une fonction soit restituée lors de l'évaluation, il est nécessaire d'encadrer l'expression contenue dans la chaîne de caractères avec des parenthèses :
 
-<pre class="brush:js">var fctStr1 = "function a() {}"
+```js
+var fctStr1 = "function a() {}"
 var fctStr2 = "(function a() {})"
 var fct1 = eval(fctStr1)  // renvoie undefined
 var fct2 = eval(fctStr2)  // renvoie une function
-</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.1.2.1', 'eval')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-eval-x', 'eval')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-eval-x', 'eval')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.eval")}}</p>
-
-<h2 id="Notes_spécifiques_à_Firefox">Notes spécifiques à Firefox</h2>
-
-<ul>
- <li>Historiquement, <code>eval()</code> utilisait un deuxième argument qui définissait l'objet qui était le contexte pour lequel effectuer l'évaluation. Cet argument était non-standard et a été retiré de SpiderMonkey avec Firefox 4 (cf. {{bug(531675)}}).</li>
-</ul>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Objets_globaux/uneval", "uneval()")}}</li>
- <li>{{jsxref("Opérateurs/Opérateurs_de_membres","Les accesseurs de propriétés","",1)}}</li>
- <li><a href="/fr/Add-ons/WebExtensions/Content_scripts#Using_eval()_in_content_scripts">Utiliser <code>eval()</code> dans les scripts de contenu dans les WebExtensions</a></li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                | État                         | Commentaires         |
+| ------------------------------------------------------------ | ---------------------------- | -------------------- |
+| {{SpecName('ES1')}}                                     | {{Spec2('ES1')}}         | Définition initiale. |
+| {{SpecName('ES5.1', '#sec-15.1.2.1', 'eval')}} | {{Spec2('ES5.1')}}     |                      |
+| {{SpecName('ES6', '#sec-eval-x', 'eval')}}     | {{Spec2('ES6')}}         |                      |
+| {{SpecName('ESDraft', '#sec-eval-x', 'eval')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.eval")}}
+
+## Notes spécifiques à Firefox
+
+- Historiquement, `eval()` utilisait un deuxième argument qui définissait l'objet qui était le contexte pour lequel effectuer l'évaluation. Cet argument était non-standard et a été retiré de SpiderMonkey avec Firefox 4 (cf. {{bug(531675)}}).
+
+## Voir aussi
+
+- {{jsxref("Objets_globaux/uneval", "uneval()")}}
+- {{jsxref("Opérateurs/Opérateurs_de_membres","Les accesseurs de propriétés","",1)}}
+- [Utiliser `eval()` dans les scripts de contenu dans les WebExtensions](</fr/Add-ons/WebExtensions/Content_scripts#Using_eval()_in_content_scripts>)
diff --git a/files/fr/web/javascript/reference/global_objects/evalerror/index.md b/files/fr/web/javascript/reference/global_objects/evalerror/index.md
index 402a26e026..7000c66f7c 100644
--- a/files/fr/web/javascript/reference/global_objects/evalerror/index.md
+++ b/files/fr/web/javascript/reference/global_objects/evalerror/index.md
@@ -9,53 +9,50 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/EvalError
 original_slug: Web/JavaScript/Reference/Objets_globaux/EvalError
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>L'objet <strong><code>EvalError</code></strong> indique une erreur concernant la fonction globale {{jsxref("Objets_globaux/eval","eval()")}}. Cette exception n'est plus levée par JavaScript mais l'objet <code>EvalError</code> est conservé pour des raisons de compatibilité.</p>
+L'objet **`EvalError`** indique une erreur concernant la fonction globale {{jsxref("Objets_globaux/eval","eval()")}}. Cette exception n'est plus levée par JavaScript mais l'objet `EvalError` est conservé pour des raisons de compatibilité.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">new EvalError([<var>message</var>[, nomFichier[, numeroLigne]]])</pre>
+    new EvalError([message[, nomFichier[, numeroLigne]]])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>message</code></dt>
- <dd>Paramètre optionnel, une description compréhensible de l'erreur</dd>
- <dt><code>nomFichier</code> {{Non-standard_inline}}</dt>
- <dd>Paramètre optionnel, le nom du fichier qui contient le code à l'origine de l'exception</dd>
- <dt><code>numeroLigne</code> {{Non-standard_inline}}</dt>
- <dd>Paramètre optionnel, le numéro de la ligne du code qui a entrainé l'exception</dd>
-</dl>
+- `message`
+  - : Paramètre optionnel, une description compréhensible de l'erreur
+- `nomFichier` {{Non-standard_inline}}
+  - : Paramètre optionnel, le nom du fichier qui contient le code à l'origine de l'exception
+- `numeroLigne` {{Non-standard_inline}}
+  - : Paramètre optionnel, le numéro de la ligne du code qui a entrainé l'exception
 
-<h2 id="Propriétés">Propriétés</h2>
+## Propriétés
 
-<dl>
- <dt>{{jsxref("EvalError.prototype")}}</dt>
- <dd>Cette propriété permet l'addition de propriétés à un objet <code>EvalError</code>.</dd>
-</dl>
+- {{jsxref("EvalError.prototype")}}
+  - : Cette propriété permet l'addition de propriétés à un objet `EvalError`.
 
-<h2 id="Méthodes">Méthodes</h2>
+## Méthodes
 
-<p>L'objet global <code>EvalError</code> ne contient pas de méthodes propres. En revanche, il hérite de certaines méthodes via sa chaîne de prototypes.</p>
+L'objet global `EvalError` ne contient pas de méthodes propres. En revanche, il hérite de certaines méthodes via sa chaîne de prototypes.
 
-<h2 id="Instances_de_EvalError">Instances de <code>EvalError</code></h2>
+## Instances de `EvalError`
 
-<h3 id="Propriétés_2">Propriétés</h3>
+### Propriétés
 
-<div>{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/EvalError/prototype','Properties')}}</div>
+{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/EvalError/prototype','Properties')}}
 
-<h3 id="Méthodes_2">Méthodes</h3>
+### Méthodes
 
-<div>{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/EvalError/prototype','Methods')}}</div>
+{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/EvalError/prototype','Methods')}}
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<p><code>EvalError</code> n'est pas utilisée par la spécification ECMAScript actuelle et ne sera donc pas levée lors de l'exécution. Cependant, l'objet reste disponible à des fins de compatibilité avec les versions antérieures de la spécification.</p>
+`EvalError` n'est pas utilisée par la spécification ECMAScript actuelle et ne sera donc pas levée lors de l'exécution. Cependant, l'objet reste disponible à des fins de compatibilité avec les versions antérieures de la spécification.
 
-<h3 id="Créer_une_exception_EvalError">Créer une exception <code>EvalError</code></h3>
+### Créer une exception `EvalError`
 
-<pre class="brush: js">try {
+```js
+try {
   throw new EvalError("Coucou", "unFichier.js", 10);
 } catch (e) {
   console.log(e instanceof EvalError); // true
@@ -65,51 +62,24 @@ original_slug: Web/JavaScript/Reference/Objets_globaux/EvalError
   console.log(e.lineNumber);           // 10
   console.log(e.columnNumber);         // 0
   console.log(e.stack);                // "@Scratchpad/2:2:9\n"
-}</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('ES3')}}</td>
-   <td>{{Spec2('ES3')}}</td>
-   <td>Définition initiale</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.11.6.1', 'EvalError')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td>Non utilisé dans cette spécificaition. Présent à des fins de rétrocompatibilité.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-native-error-types-used-in-this-standard-evalerror', 'EvalError')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Non utilisé dans cette spécificaition. Présent à des fins de rétrocompatibilité.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-native-error-types-used-in-this-standard-evalerror', 'EvalError')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<div>
-
-<p>{{Compat("javascript.builtins.EvalError")}}</p>
-</div>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Error")}}</li>
- <li>{{jsxref("EvalError.prototype")}}</li>
- <li>{{jsxref("Objets_globaux/eval", "eval()")}}</li>
-</ul>
+}
+```
+
+## Spécifications
+
+| Spécification                                                                                                                    | Statut                       | Commentaires                                                                     |
+| -------------------------------------------------------------------------------------------------------------------------------- | ---------------------------- | -------------------------------------------------------------------------------- |
+| {{SpecName('ES3')}}                                                                                                         | {{Spec2('ES3')}}         | Définition initiale                                                              |
+| {{SpecName('ES5.1', '#sec-15.11.6.1', 'EvalError')}}                                                             | {{Spec2('ES5.1')}}     | Non utilisé dans cette spécificaition. Présent à des fins de rétrocompatibilité. |
+| {{SpecName('ES6', '#sec-native-error-types-used-in-this-standard-evalerror', 'EvalError')}}         | {{Spec2('ES6')}}         | Non utilisé dans cette spécificaition. Présent à des fins de rétrocompatibilité. |
+| {{SpecName('ESDraft', '#sec-native-error-types-used-in-this-standard-evalerror', 'EvalError')}} | {{Spec2('ESDraft')}} |                                                                                  |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.EvalError")}}
+
+## Voir aussi
+
+- {{jsxref("Error")}}
+- {{jsxref("EvalError.prototype")}}
+- {{jsxref("Objets_globaux/eval", "eval()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/float32array/index.md b/files/fr/web/javascript/reference/global_objects/float32array/index.md
index a6e52bb590..0e20735fef 100644
--- a/files/fr/web/javascript/reference/global_objects/float32array/index.md
+++ b/files/fr/web/javascript/reference/global_objects/float32array/index.md
@@ -10,125 +10,118 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Float32Array
 original_slug: Web/JavaScript/Reference/Objets_globaux/Float32Array
 ---
-<div>{{JSRef}}</div>
-
-<p>Le tableau typé <strong><code>Float32Array</code></strong> représente un tableau de nombres flottants représentés sur 32 bits (ce qui correspond au type C <code>float</code>), l'ordre des octets utilisés étant celui de la plate-forme. Si on souhaite maîtriser le boutisme (<em>endianness</em>) utilisé, on pourra utiliser une {{jsxref("DataView")}}. Les éléments du tableau sont initialisés à <code>0</code>. Une fois que le tableau est établi, on peut référencer des éléments dans le tableau en utilisant les méthodes de l'objet ou la syntaxe usuelle des crochets.</p>
-
-<h2 id="Syntaxe">Syntaxe</h2>
-
-<pre class="syntaxbox">new Float32Array(); // Apparu avec ES2017
-new Float32Array(longueur);
-new Float32Array(tableauTypé);
-new Float32Array(objet);
-new Float32Array(buffer [, décalageOctets [, longueur]]);</pre>
-
-<p>Pour plus d'informations sur la syntaxe de ce constructeur et les paramètres utilisés, voir la page {{jsxref("Objets_globaux/TypedArray","TypedArray","#Syntaxe")}}.</p>
-
-<h2 id="Propriétés">Propriétés</h2>
-
-<dl>
- <dt>{{jsxref("TypedArray.BYTES_PER_ELEMENT", "Float32Array.BYTES_PER_ELEMENT")}}</dt>
- <dd>Renvoie le nombre d'octets par élément. <code>4</code> dans le cas de <code>Float32Array</code>.</dd>
- <dt>Float32Array.length</dt>
- <dd>Une propriété de longueur statique qui vaut 3. Pour connaître le nombre d'élément, voir {{jsxref("TypedArray.prototype.length", "Float32Array.prototype.length")}}.</dd>
- <dt>{{jsxref("TypedArray.name", "Float32Array.name")}}</dt>
- <dd>Renvoie la chaîne de caractères correspondant au nom du constructeur, dans le cas de <code>Float32Array</code>, ce sera : "Float32Array".</dd>
- <dt>{{jsxref("TypedArray.prototype", "Float32Array.prototype")}}</dt>
- <dd>Le prototype des objets <em>TypedArray</em>.</dd>
-</dl>
-
-<h2 id="Méthodes">Méthodes</h2>
-
-<dl>
- <dt>{{jsxref("TypedArray.from", "Float32Array.from()")}}</dt>
- <dd>Crée un nouvel objet <code>Float32Array</code> à partir d'un objet semblable à un tableau ou d'un objet itérable. Voir également la page {{jsxref("Array.from()")}}.</dd>
- <dt>{{jsxref("TypedArray.of", "Float32Array.of()")}}</dt>
- <dd>Crée un nouvel objet <code>Float32Array</code> à partir d'un nombre variable d'arguments. Voir également la page {{jsxref("Array.of()")}}.</dd>
-</dl>
-
-<h2 id="Prototype_Float32Array">Prototype <code>Float32Array</code></h2>
-
-<p>Chacun des objets <code>Float32Array</code> hérite de {{jsxref("TypedArray.prototype", "%TypedArray%.prototype")}}.</p>
-
-<h3 id="Propriétés_2">Propriétés</h3>
-
-<dl>
- <dt><code>Float32Array.prototype.constructor</code></dt>
- <dd>Renvoie la fonction qui a crée le prototype de l'instance. Par défaut, ce sera le constructeur <code>Float32Array</code>.</dd>
- <dt>{{jsxref("TypedArray.prototype.buffer", "Float32Array.prototype.buffer")}} {{readonlyInline}}</dt>
- <dd>Renvoie l'objet {{jsxref("ArrayBuffer")}} référencé par l'objet <code>Float32Array</code>. Cette propriété est fixée lors de la construction et n'est donc disponible qu'en <strong>lecture seule</strong>.</dd>
- <dt>{{jsxref("TypedArray.prototype.byteLength", "Float32Array.prototype.byteLength")}} {{readonlyInline}}</dt>
- <dd>Renvoie la longueur, exprimée en octets, de l'objet <code>Float32Array</code> à partir du début de l'{{jsxref("ArrayBuffer")}} correspondant. Cette propriété est fixée lors de la construction et n'est donc disponible qu'en <strong>lecture seule</strong>.</dd>
- <dt>{{jsxref("TypedArray.prototype.byteOffset", "Float32Array.prototype.byteOffset")}} {{readonlyInline}}</dt>
- <dd>Renvoie le décalage, exprimé en octets, de l'objet <code>Float32Array</code> par rapport au début de l'{{jsxref("ArrayBuffer")}} correspondant. Cette propriété est fixée lors de la construction et n'est donc disponible qu'en <strong>lecture seule</strong>.</dd>
- <dt>{{jsxref("TypedArray.prototype.length", "Float32Array.prototype.length")}} {{readonlyInline}}</dt>
- <dd>Renvoie le nombre d'éléments contenus dans l'objet <code>Float32Array</code>. Cette propriété est fixée lors de la construction et n'est donc disponible qu'en <strong>lecture seule</strong>.</dd>
-</dl>
-
-<h3 id="Méthodes_2">Méthodes</h3>
-
-<dl>
- <dt>{{jsxref("TypedArray.copyWithin", "Float32Array.prototype.copyWithin()")}}</dt>
- <dd>Copie une suite d'éléments d'un tableau dans le tableau. Voir également {{jsxref("Array.prototype.copyWithin()")}}.</dd>
- <dt>{{jsxref("TypedArray.entries", "Float32Array.prototype.entries()")}}</dt>
- <dd>Renvoie un nouvel objet <code>Array Iterator</code> qui contient les paires clé/valeur pour chaque indice du tableau. Voir également {{jsxref("Array.prototype.entries()")}}.</dd>
- <dt>{{jsxref("TypedArray.every", "Float32Array.prototype.every()")}}</dt>
- <dd>Teste si l'ensemble des éléments du tableau remplissent une certaine condition donnée par une fonction de test. Voir également {{jsxref("Array.prototype.every()")}}.</dd>
- <dt>{{jsxref("TypedArray.fill", "Float32Array.prototype.fill()")}}</dt>
- <dd>Remplit les éléments d'un tableau avec une certaine valeur pour les éléments compris entre un indice de début et un indice de fin. Voir également {{jsxref("Array.prototype.fill()")}}.</dd>
- <dt>{{jsxref("TypedArray.filter", "Float32Array.prototype.filter()")}}</dt>
- <dd>Crée un nouveau tableau dont tous les éléments proviennent de ce tableau et respectent une condition fournie par une fonction de test. Voir également {{jsxref("Array.prototype.filter()")}}.</dd>
- <dt>{{jsxref("TypedArray.find", "Float32Array.prototype.find()")}}</dt>
- <dd>Renvoie une valeur trouvée dans le tableau s'il existe un élément du tableau qui satisfait une condition fournie par une fonction de test, s'il n'y a pas de tel élément <code>undefined</code> sera renvoyé. Voir également {{jsxref("Array.prototype.find()")}}.</dd>
- <dt>{{jsxref("TypedArray.findIndex", "Float32Array.prototype.findIndex()")}}</dt>
- <dd>Renvoie l'indice d'un élément qui satisfait une condition fournie par une fonction de test, si aucun élément ne remplit la condition -1 sera renvoyé. Voir également {{jsxref("Array.prototype.findIndex()")}}.</dd>
- <dt>{{jsxref("TypedArray.forEach", "Float32Array.prototype.forEach()")}}</dt>
- <dd>Appelle une fonction pour chacun des élément du tableau. Voir également {{jsxref("Array.prototype.forEach()")}}.</dd>
- <dt>{{jsxref("TypedArray.includes", "Float32Array.prototype.includes()")}}</dt>
- <dd>Détermine si le tableau typé contient un élément donné. Cette méthode renvoie <code>true</code> ou <code>false</code> selon le cas de figure. Voir également {{jsxref("Array.prototype.includes()")}}.</dd>
- <dt>{{jsxref("TypedArray.indexOf", "Float32Array.prototype.indexOf()")}}</dt>
- <dd>Renvoie le premier indice (le plus petit) d'un élément du tableau qui est égal à la valeur fournie. Si aucun élément ne correspond, la valeur -1 sera renvoyée. Voir également {{jsxref("Array.prototype.indexOf()")}}.</dd>
- <dt>{{jsxref("TypedArray.join", "Float32Array.prototype.join()")}}</dt>
- <dd>Fusionne l'ensemble des éléments du tableau en une chaîne de caractères. Voir également {{jsxref("Array.prototype.join()")}}.</dd>
- <dt>{{jsxref("TypedArray.keys", "Float32Array.prototype.keys()")}}</dt>
- <dd>Renvoie un nouvel objet <code>Array Iterator</code> qui contient les clés de chaque indice du tableau. Voir également {{jsxref("Array.prototype.keys()")}}.</dd>
- <dt>{{jsxref("TypedArray.lastIndexOf", "Float32Array.prototype.lastIndexOf()")}}</dt>
- <dd>Renvoie le dernier indice (le plus élevé) d'un élément du tableau qui est égal à la valeur fournie. Si aucun élément ne correspond, la valeur -1 sera renvoyée. Voir également {{jsxref("Array.prototype.lastIndexOf()")}}.</dd>
- <dt>{{jsxref("TypedArray.map", "Float32Array.prototype.map()")}}</dt>
- <dd>Crée un nouveau tableau dont les éléments sont les images des éléments du tableau courant par une fonction donnée. Voir également {{jsxref("Array.prototype.map()")}}.</dd>
- <dt>{{jsxref("TypedArray.move", "Float32Array.prototype.move()")}} {{non-standard_inline}} {{unimplemented_inline}}</dt>
- <dd>Ancienne version, non-standard, de {{jsxref("TypedArray.copyWithin", "Float32Array.prototype.copyWithin()")}}.</dd>
- <dt>{{jsxref("TypedArray.reduce", "Float32Array.prototype.reduce()")}}</dt>
- <dd>Applique une fonction sur un accumulateur et chaque élément du tableau (de gauche à droite) afin de réduire le tableau en une seule valeur. Voir également {{jsxref("Array.prototype.reduce()")}}.</dd>
- <dt>{{jsxref("TypedArray.reduceRight", "Float32Array.prototype.reduceRight()")}}</dt>
- <dd>Applique une fonction sur un accumulateur et chaque élément du tableau (de droite à gauche) afin de réduire le tableau en une seule valeur. Voir également {{jsxref("Array.prototype.reduceRight()")}}.</dd>
- <dt>{{jsxref("TypedArray.reverse", "Float32Array.prototype.reverse()")}}</dt>
- <dd>Inverse l'ordre des éléments d'un tableau. Le premier élément du tableau devient le dernier et le dernier devient le premier (et ainsi de suite). Voir également {{jsxref("Array.prototype.reverse()")}}.</dd>
- <dt>{{jsxref("TypedArray.set", "Float32Array.prototype.set()")}}</dt>
- <dd>Enregistre plusieurs valeurs dans le tableau typé à partir de valeurs d'un autre tableau.</dd>
- <dt>{{jsxref("TypedArray.slice", "Float32Array.prototype.slice()")}}</dt>
- <dd>Extrait un fragment d'un tableau et renvoie ce fragment. Voir également {{jsxref("Array.prototype.slice()")}}.</dd>
- <dt>{{jsxref("TypedArray.some", "Float32Array.prototype.some()")}}</dt>
- <dd>Renvoie <code>true</code> si au moins un des éléments remplit une condition donnée par une fonction de test. Voir également {{jsxref("Array.prototype.some()")}}.</dd>
- <dt>{{jsxref("TypedArray.sort", "Float32Array.prototype.sort()")}}</dt>
- <dd>Trie les éléments du tableau et renvoie ce tableau. Voir également {{jsxref("Array.prototype.sort()")}}.</dd>
- <dt>{{jsxref("TypedArray.subarray", "Float32Array.prototype.subarray()")}}</dt>
- <dd>Renvoie un nouvel objet <code>Float32Array</code> qui est le fragment du tableau courant, entre les indices de début et de fin donnés.</dd>
- <dt>{{jsxref("TypedArray.values", "Float32Array.prototype.values()")}}</dt>
- <dd>Renvoie un nouvel objet <code>Array Iterator</code> qui contient les valeurs correspondantes à chaque indice du tableau. Voir également {{jsxref("Array.prototype.values()")}}.</dd>
- <dt>{{jsxref("TypedArray.toLocaleString", "Float32Array.prototype.toLocaleString()")}}</dt>
- <dd>Renvoie une chaîne de caractères localisée qui représente le tableau et ses éléments. Voir également {{jsxref("Array.prototype.toLocaleString()")}}.</dd>
- <dt>{{jsxref("TypedArray.toString", "Float32Array.prototype.toString()")}}</dt>
- <dd>Renvoie une chaîne de caractère qui représente le tableau et ses éléments. Voir également {{jsxref("Array.prototype.toString()")}}.</dd>
- <dt>{{jsxref("TypedArray.@@iterator", "Float32Array.prototype[@@iterator]()")}}</dt>
- <dd>Renvoie un nouvel objet <code>Array Iterator</code> qui contient les valeurs correspondantes à chaque indice du tableau.</dd>
-</dl>
-
-<h2 id="Exemples">Exemples</h2>
-
-<p>Différentes façons de créer un objet <code>Float32Array</code> :</p>
-
-<pre class="brush: js">// Construction à partir d'une longueur
+{{JSRef}}
+
+Le tableau typé **`Float32Array`** représente un tableau de nombres flottants représentés sur 32 bits (ce qui correspond au type C `float`), l'ordre des octets utilisés étant celui de la plate-forme. Si on souhaite maîtriser le boutisme (_endianness_) utilisé, on pourra utiliser une {{jsxref("DataView")}}. Les éléments du tableau sont initialisés à `0`. Une fois que le tableau est établi, on peut référencer des éléments dans le tableau en utilisant les méthodes de l'objet ou la syntaxe usuelle des crochets.
+
+## Syntaxe
+
+    new Float32Array(); // Apparu avec ES2017
+    new Float32Array(longueur);
+    new Float32Array(tableauTypé);
+    new Float32Array(objet);
+    new Float32Array(buffer [, décalageOctets [, longueur]]);
+
+Pour plus d'informations sur la syntaxe de ce constructeur et les paramètres utilisés, voir la page {{jsxref("Objets_globaux/TypedArray","TypedArray","#Syntaxe")}}.
+
+## Propriétés
+
+- {{jsxref("TypedArray.BYTES_PER_ELEMENT", "Float32Array.BYTES_PER_ELEMENT")}}
+  - : Renvoie le nombre d'octets par élément. `4` dans le cas de `Float32Array`.
+- Float32Array.length
+  - : Une propriété de longueur statique qui vaut 3. Pour connaître le nombre d'élément, voir {{jsxref("TypedArray.prototype.length", "Float32Array.prototype.length")}}.
+- {{jsxref("TypedArray.name", "Float32Array.name")}}
+  - : Renvoie la chaîne de caractères correspondant au nom du constructeur, dans le cas de `Float32Array`, ce sera : "Float32Array".
+- {{jsxref("TypedArray.prototype", "Float32Array.prototype")}}
+  - : Le prototype des objets _TypedArray_.
+
+## Méthodes
+
+- {{jsxref("TypedArray.from", "Float32Array.from()")}}
+  - : Crée un nouvel objet `Float32Array` à partir d'un objet semblable à un tableau ou d'un objet itérable. Voir également la page {{jsxref("Array.from()")}}.
+- {{jsxref("TypedArray.of", "Float32Array.of()")}}
+  - : Crée un nouvel objet `Float32Array` à partir d'un nombre variable d'arguments. Voir également la page {{jsxref("Array.of()")}}.
+
+## Prototype `Float32Array`
+
+Chacun des objets `Float32Array` hérite de {{jsxref("TypedArray.prototype", "%TypedArray%.prototype")}}.
+
+### Propriétés
+
+- `Float32Array.prototype.constructor`
+  - : Renvoie la fonction qui a crée le prototype de l'instance. Par défaut, ce sera le constructeur `Float32Array`.
+- {{jsxref("TypedArray.prototype.buffer", "Float32Array.prototype.buffer")}} {{readonlyInline}}
+  - : Renvoie l'objet {{jsxref("ArrayBuffer")}} référencé par l'objet `Float32Array`. Cette propriété est fixée lors de la construction et n'est donc disponible qu'en **lecture seule**.
+- {{jsxref("TypedArray.prototype.byteLength", "Float32Array.prototype.byteLength")}} {{readonlyInline}}
+  - : Renvoie la longueur, exprimée en octets, de l'objet `Float32Array` à partir du début de l'{{jsxref("ArrayBuffer")}} correspondant. Cette propriété est fixée lors de la construction et n'est donc disponible qu'en **lecture seule**.
+- {{jsxref("TypedArray.prototype.byteOffset", "Float32Array.prototype.byteOffset")}} {{readonlyInline}}
+  - : Renvoie le décalage, exprimé en octets, de l'objet `Float32Array` par rapport au début de l'{{jsxref("ArrayBuffer")}} correspondant. Cette propriété est fixée lors de la construction et n'est donc disponible qu'en **lecture seule**.
+- {{jsxref("TypedArray.prototype.length", "Float32Array.prototype.length")}} {{readonlyInline}}
+  - : Renvoie le nombre d'éléments contenus dans l'objet `Float32Array`. Cette propriété est fixée lors de la construction et n'est donc disponible qu'en **lecture seule**.
+
+### Méthodes
+
+- {{jsxref("TypedArray.copyWithin", "Float32Array.prototype.copyWithin()")}}
+  - : Copie une suite d'éléments d'un tableau dans le tableau. Voir également {{jsxref("Array.prototype.copyWithin()")}}.
+- {{jsxref("TypedArray.entries", "Float32Array.prototype.entries()")}}
+  - : Renvoie un nouvel objet `Array Iterator` qui contient les paires clé/valeur pour chaque indice du tableau. Voir également {{jsxref("Array.prototype.entries()")}}.
+- {{jsxref("TypedArray.every", "Float32Array.prototype.every()")}}
+  - : Teste si l'ensemble des éléments du tableau remplissent une certaine condition donnée par une fonction de test. Voir également {{jsxref("Array.prototype.every()")}}.
+- {{jsxref("TypedArray.fill", "Float32Array.prototype.fill()")}}
+  - : Remplit les éléments d'un tableau avec une certaine valeur pour les éléments compris entre un indice de début et un indice de fin. Voir également {{jsxref("Array.prototype.fill()")}}.
+- {{jsxref("TypedArray.filter", "Float32Array.prototype.filter()")}}
+  - : Crée un nouveau tableau dont tous les éléments proviennent de ce tableau et respectent une condition fournie par une fonction de test. Voir également {{jsxref("Array.prototype.filter()")}}.
+- {{jsxref("TypedArray.find", "Float32Array.prototype.find()")}}
+  - : Renvoie une valeur trouvée dans le tableau s'il existe un élément du tableau qui satisfait une condition fournie par une fonction de test, s'il n'y a pas de tel élément `undefined` sera renvoyé. Voir également {{jsxref("Array.prototype.find()")}}.
+- {{jsxref("TypedArray.findIndex", "Float32Array.prototype.findIndex()")}}
+  - : Renvoie l'indice d'un élément qui satisfait une condition fournie par une fonction de test, si aucun élément ne remplit la condition -1 sera renvoyé. Voir également {{jsxref("Array.prototype.findIndex()")}}.
+- {{jsxref("TypedArray.forEach", "Float32Array.prototype.forEach()")}}
+  - : Appelle une fonction pour chacun des élément du tableau. Voir également {{jsxref("Array.prototype.forEach()")}}.
+- {{jsxref("TypedArray.includes", "Float32Array.prototype.includes()")}}
+  - : Détermine si le tableau typé contient un élément donné. Cette méthode renvoie `true` ou `false` selon le cas de figure. Voir également {{jsxref("Array.prototype.includes()")}}.
+- {{jsxref("TypedArray.indexOf", "Float32Array.prototype.indexOf()")}}
+  - : Renvoie le premier indice (le plus petit) d'un élément du tableau qui est égal à la valeur fournie. Si aucun élément ne correspond, la valeur -1 sera renvoyée. Voir également {{jsxref("Array.prototype.indexOf()")}}.
+- {{jsxref("TypedArray.join", "Float32Array.prototype.join()")}}
+  - : Fusionne l'ensemble des éléments du tableau en une chaîne de caractères. Voir également {{jsxref("Array.prototype.join()")}}.
+- {{jsxref("TypedArray.keys", "Float32Array.prototype.keys()")}}
+  - : Renvoie un nouvel objet `Array Iterator` qui contient les clés de chaque indice du tableau. Voir également {{jsxref("Array.prototype.keys()")}}.
+- {{jsxref("TypedArray.lastIndexOf", "Float32Array.prototype.lastIndexOf()")}}
+  - : Renvoie le dernier indice (le plus élevé) d'un élément du tableau qui est égal à la valeur fournie. Si aucun élément ne correspond, la valeur -1 sera renvoyée. Voir également {{jsxref("Array.prototype.lastIndexOf()")}}.
+- {{jsxref("TypedArray.map", "Float32Array.prototype.map()")}}
+  - : Crée un nouveau tableau dont les éléments sont les images des éléments du tableau courant par une fonction donnée. Voir également {{jsxref("Array.prototype.map()")}}.
+- {{jsxref("TypedArray.move", "Float32Array.prototype.move()")}} {{non-standard_inline}} {{unimplemented_inline}}
+  - : Ancienne version, non-standard, de {{jsxref("TypedArray.copyWithin", "Float32Array.prototype.copyWithin()")}}.
+- {{jsxref("TypedArray.reduce", "Float32Array.prototype.reduce()")}}
+  - : Applique une fonction sur un accumulateur et chaque élément du tableau (de gauche à droite) afin de réduire le tableau en une seule valeur. Voir également {{jsxref("Array.prototype.reduce()")}}.
+- {{jsxref("TypedArray.reduceRight", "Float32Array.prototype.reduceRight()")}}
+  - : Applique une fonction sur un accumulateur et chaque élément du tableau (de droite à gauche) afin de réduire le tableau en une seule valeur. Voir également {{jsxref("Array.prototype.reduceRight()")}}.
+- {{jsxref("TypedArray.reverse", "Float32Array.prototype.reverse()")}}
+  - : Inverse l'ordre des éléments d'un tableau. Le premier élément du tableau devient le dernier et le dernier devient le premier (et ainsi de suite). Voir également {{jsxref("Array.prototype.reverse()")}}.
+- {{jsxref("TypedArray.set", "Float32Array.prototype.set()")}}
+  - : Enregistre plusieurs valeurs dans le tableau typé à partir de valeurs d'un autre tableau.
+- {{jsxref("TypedArray.slice", "Float32Array.prototype.slice()")}}
+  - : Extrait un fragment d'un tableau et renvoie ce fragment. Voir également {{jsxref("Array.prototype.slice()")}}.
+- {{jsxref("TypedArray.some", "Float32Array.prototype.some()")}}
+  - : Renvoie `true` si au moins un des éléments remplit une condition donnée par une fonction de test. Voir également {{jsxref("Array.prototype.some()")}}.
+- {{jsxref("TypedArray.sort", "Float32Array.prototype.sort()")}}
+  - : Trie les éléments du tableau et renvoie ce tableau. Voir également {{jsxref("Array.prototype.sort()")}}.
+- {{jsxref("TypedArray.subarray", "Float32Array.prototype.subarray()")}}
+  - : Renvoie un nouvel objet `Float32Array` qui est le fragment du tableau courant, entre les indices de début et de fin donnés.
+- {{jsxref("TypedArray.values", "Float32Array.prototype.values()")}}
+  - : Renvoie un nouvel objet `Array Iterator` qui contient les valeurs correspondantes à chaque indice du tableau. Voir également {{jsxref("Array.prototype.values()")}}.
+- {{jsxref("TypedArray.toLocaleString", "Float32Array.prototype.toLocaleString()")}}
+  - : Renvoie une chaîne de caractères localisée qui représente le tableau et ses éléments. Voir également {{jsxref("Array.prototype.toLocaleString()")}}.
+- {{jsxref("TypedArray.toString", "Float32Array.prototype.toString()")}}
+  - : Renvoie une chaîne de caractère qui représente le tableau et ses éléments. Voir également {{jsxref("Array.prototype.toString()")}}.
+- {{jsxref("TypedArray.@@iterator", "Float32Array.prototype[@@iterator]()")}}
+  - : Renvoie un nouvel objet `Array Iterator` qui contient les valeurs correspondantes à chaque indice du tableau.
+
+## Exemples
+
+Différentes façons de créer un objet `Float32Array` :
+
+```js
+// Construction à partir d'une longueur
 var float32 = new Float32Array(2);
 float32[0] = 42;
 console.log(float32[0]); // 42
@@ -152,53 +145,36 @@ var z = new Float32Array(buffer, 0, 4);
 var iterable = function*(){ yield* [1,2,3]; }();
 var float32 = new Float32Array(iterable);
 // Float32Array[1, 2, 3]
-</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('Typed Array')}}</td>
-   <td>{Spec2('Typed Array')}}</td>
-   <td>Remplacée par ECMAScript 2015.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#table-49', 'TypedArray constructors')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Défintion initiale au sein d'un standard ECMA. <code>new</code> est obligatoire.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#table-49', 'TypedArray constructors')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td>ECMAScript 2017 a modifié le constructeur afin que celui-ci utilise l'opération interne <code>ToIndex</code> et puisse être utilisé sans argument.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Float32Array")}}</p>
-
-<h2 id="Notes_de_compatibilité">Notes de compatibilité</h2>
-
-<p>À partir d'ECMAScript 2015 (ES6), <code>Float32Array</code> doit être utilisée avec {{jsxref("Opérateurs/L_opérateur_new", "new")}}. Appeler un constructeur <code>Float32Array</code> comme une fonction, sans <code>new</code>, provoquera une exception {{jsxref("TypeError")}}.</p>
-
-<pre class="brush: js example-bad">var dv = Float32Array([1, 2, 3]);
+```
+
+## Spécifications
+
+| Spécification                                                                        | État                         | Commentaires                                                                                                                            |
+| ------------------------------------------------------------------------------------ | ---------------------------- | --------------------------------------------------------------------------------------------------------------------------------------- |
+| {{SpecName('Typed Array')}}                                                 | {Spec2('Typed Array')}}      | Remplacée par ECMAScript 2015.                                                                                                          |
+| {{SpecName('ES6', '#table-49', 'TypedArray constructors')}}     | {{Spec2('ES6')}}         | Défintion initiale au sein d'un standard ECMA. `new` est obligatoire.                                                                   |
+| {{SpecName('ESDraft', '#table-49', 'TypedArray constructors')}} | {{Spec2('ESDraft')}} | ECMAScript 2017 a modifié le constructeur afin que celui-ci utilise l'opération interne `ToIndex` et puisse être utilisé sans argument. |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Float32Array")}}
+
+## Notes de compatibilité
+
+À partir d'ECMAScript 2015 (ES6), `Float32Array` doit être utilisée avec {{jsxref("Opérateurs/L_opérateur_new", "new")}}. Appeler un constructeur `Float32Array` comme une fonction, sans `new`, provoquera une exception {{jsxref("TypeError")}}.
+
+```js example-bad
+var dv = Float32Array([1, 2, 3]);
 // TypeError: calling a builtin Float32Array constructor
-// without new is forbidden</pre>
+// without new is forbidden
+```
 
-<pre class="brush: js example-good">var dv = new Float32Array([1, 2, 3]);</pre>
+```js example-good
+var dv = new Float32Array([1, 2, 3]);
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li><a href="/fr/docs/Web/JavaScript/Tableaux_typés">Les tableaux typés en JavaScript</a></li>
- <li>{{jsxref("ArrayBuffer")}}</li>
- <li>{{jsxref("DataView")}}</li>
-</ul>
+- [Les tableaux typés en JavaScript](/fr/docs/Web/JavaScript/Tableaux_typés)
+- {{jsxref("ArrayBuffer")}}
+- {{jsxref("DataView")}}
diff --git a/files/fr/web/javascript/reference/global_objects/float64array/index.md b/files/fr/web/javascript/reference/global_objects/float64array/index.md
index 9865674fff..daace3e093 100644
--- a/files/fr/web/javascript/reference/global_objects/float64array/index.md
+++ b/files/fr/web/javascript/reference/global_objects/float64array/index.md
@@ -10,125 +10,118 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Float64Array
 original_slug: Web/JavaScript/Reference/Objets_globaux/Float64Array
 ---
-<div>{{JSRef}}</div>
-
-<p>Le constructeur <strong><code>Floa64Array</code></strong> permet de représenter un tableau typé dont les éléments sont des nombres flottants représentés sur 64 bits (ce qui correspond à la représentation du type <code>double</code> en C) dans l'ordre des octets utilisé par la plate-forme. Si on souhaite maîtriser le boutisme (<em>endianness</em>), on pourra utiliser un objet {{jsxref("DataView")}} à la place. Les éléments du tableau sont initialisés à <code>0</code>. Une fois construit, il est possible de faire référence aux éléments du tableau en utilisant les méthodes de l'objet ou la syntaxe usuelle pour l'accès aux éléments du tableau (les crochets).</p>
-
-<h2 id="Syntaxe">Syntaxe</h2>
-
-<pre class="syntaxbox">new Float64Array(); // apparu avec ES2017
-new Float64Array(longueur);
-new Float64Array(tableauTypé);
-new Float64Array(objet);
-new Float64Array(buffer [, positionOctet [, longueur]]);</pre>
-
-<p>Pour plus d'informations sur la syntaxe du constructeur et ses paramètres, voir <em><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray#Syntaxe">TypedArray</a></em>.</p>
-
-<h2 id="Propriétés">Propriétés</h2>
-
-<dl>
- <dt>{{jsxref("TypedArray.BYTES_PER_ELEMENT", "Float64Array.BYTES_PER_ELEMENT")}}</dt>
- <dd>Renvoie un nombre traduisant la taille de l'élément en octets, <code>8</code> dans le cas d'un <code>Float64Array</code>.</dd>
- <dt>Float64Array.length</dt>
- <dd>Une propriété de longueur statique qui vaut 3. Pour connaître le nombre d'éléments, voir {{jsxref("TypedArray.prototype.length", "Float64Array.prototype.length")}}.</dd>
- <dt>{{jsxref("TypedArray.name", "Float64Array.name")}}</dt>
- <dd>Renvoie la chaîne de caractère correspondant au nom du constructeur, dans le cas de <code>Float64Array</code>, ce sera : "Float64Array".</dd>
- <dt>{{jsxref("TypedArray.prototype", "Float64Array.prototype")}}</dt>
- <dd>Prototype pour les objets <em>TypedArray</em>.</dd>
-</dl>
-
-<h2 id="Méthodes">Méthodes</h2>
-
-<dl>
- <dt>{{jsxref("TypedArray.from", "Float64Array.from()")}}</dt>
- <dd>Crée un nouvel objet <code>Float64Array</code> à partir d'un objet semblable à un tableau ou d'un objet itérable. Voir aussi {{jsxref("Array.from()")}}.</dd>
- <dt>{{jsxref("TypedArray.of", "Float64Array.of()")}}</dt>
- <dd>Crée un nouvel objet <code>Float64Array</code> à partir d'un nombre variable d'arguments. Voir aussi {{jsxref("Array.of()")}}.</dd>
-</dl>
-
-<h2 id="Prototype_de_Float64Array">Prototype de <code>Float64Array</code></h2>
-
-<p>Tous les objets <code>Float64Array</code> héritent de {{jsxref("TypedArray.prototype", "Float64Array.prototype")}}.</p>
-
-<h3 id="Propriétés_2">Propriétés</h3>
-
-<dl>
- <dt><code>Float64Array.prototype.constructor</code></dt>
- <dd>Renvoie la fonction qui a créé le prototype de l'instance. Par défaut, ce sera le constructeur natif <code>Float64Array</code>.</dd>
- <dt>{{jsxref("TypedArray.prototype.buffer", "Float64Array.prototype.buffer")}} {{readonlyInline}}</dt>
- <dd>Renvoie l'{{jsxref("ArrayBuffer")}} référencé par l'objet <code>Float64Array</code>. Cette valeur est fixée lors de la construction de l'objet et n'est accessible qu'<strong>en lecture seule</strong>.</dd>
- <dt>{{jsxref("TypedArray.prototype.byteLength", "Float64Array.prototype.byteLength")}} {{readonlyInline}}</dt>
- <dd>Renvoie la longueur, exprimée en octets, de l'objet <code>Float64Array</code> depuis le début de son {{jsxref("ArrayBuffer")}}. Cette valeur est fixée lors de la construction de l'objet et n'est accessible qu'<strong>en lecture seule</strong>.</dd>
- <dt>{{jsxref("TypedArray.prototype.byteOffset", "Float64Array.prototype.byteOffset")}} {{readonlyInline}}</dt>
- <dd>Renvoie le décalage, exprimé en octets, entre l'objet <code>Float64Array</code> et le début de son {{jsxref("ArrayBuffer")}}. Cette valeur est fixée lors de la construction de l'objet et n'est accessible qu'<strong>en lecture seule</strong>.</dd>
- <dt>{{jsxref("TypedArray.prototype.length", "Float64Array.prototype.length")}} {{readonlyInline}}</dt>
- <dd>Renvoie le nombre d'éléments contenus dans l'objet <code>Float64Array</code>. Cette valeur est fixée lors de la construction de l'objet et n'est accessible qu'<strong>en lecture seule</strong>.</dd>
-</dl>
-
-<h3 id="Méthodes_2">Méthodes</h3>
-
-<dl>
- <dt>{{jsxref("TypedArray.copyWithin", "Float64Array.prototype.copyWithin()")}}</dt>
- <dd>Copie une suite d'éléments d'un tableau dans le tableau. Voir également {{jsxref("Array.prototype.copyWithin()")}}.</dd>
- <dt>{{jsxref("TypedArray.entries", "Float64Array.prototype.entries()")}}</dt>
- <dd>Renvoie un nouvel objet <code>Array Iterator</code> qui contient les paires clé/valeur pour chaque indice du tableau. Voir également {{jsxref("Array.prototype.entries()")}}.</dd>
- <dt>{{jsxref("TypedArray.every", "Float64Array.prototype.every()")}}</dt>
- <dd>Teste si l'ensemble des éléments du tableau remplissent une certaine condition donnée par une fonction de test. Voir également {{jsxref("Array.prototype.every()")}}.</dd>
- <dt>{{jsxref("TypedArray.fill", "Float64Array.prototype.fill()")}}</dt>
- <dd>Remplit les éléments d'un tableau avec une certaine valeur pour les éléments compris entre un indice de début et un indice de fin. Voir également {{jsxref("Array.prototype.fill()")}}.</dd>
- <dt>{{jsxref("TypedArray.filter", "Float64Array.prototype.filter()")}}</dt>
- <dd>Crée un nouveau tableau dont tous les éléments proviennent de ce tableau et respectent une condition fournie par une fonction de test. Voir également {{jsxref("Array.prototype.filter()")}}.</dd>
- <dt>{{jsxref("TypedArray.find", "Float64Array.prototype.find()")}}</dt>
- <dd>Renvoie une valeur trouvée dans le tableau s'il existe un élément du tableau qui satisfait une condition fournie par une fonction de test, s'il n'y a pas de tel élément <code>undefined</code> sera renvoyé. Voir également {{jsxref("Array.prototype.find()")}}.</dd>
- <dt>{{jsxref("TypedArray.findIndex", "Float64Array.prototype.findIndex()")}}</dt>
- <dd>Renvoie l'indice d'un élément qui satisfait une condition fournie par une fonction de test, si aucun élément ne remplit la condition -1 sera renvoyé. Voir également {{jsxref("Array.prototype.findIndex()")}}.</dd>
- <dt>{{jsxref("TypedArray.forEach", "Float64Array.prototype.forEach()")}}</dt>
- <dd>Appelle une fonction pour chacun des élément du tableau. Voir également {{jsxref("Array.prototype.forEach()")}}.</dd>
- <dt>{{jsxref("TypedArray.includes", "Float64Array.prototype.includes()")}}</dt>
- <dd>Détermine si le tableau typé contient un élément donné. Cette méthode renvoie <code>true</code> ou <code>false</code> selon le cas de figure. Voir également {{jsxref("Array.prototype.includes()")}}.</dd>
- <dt>{{jsxref("TypedArray.indexOf", "Float64Array.prototype.indexOf()")}}</dt>
- <dd>Renvoie le premier indice (le plus petit) d'un élément du tableau qui est égal à la valeur fournie. Si aucun élément ne correspond, la valeur -1 sera renvoyée. Voir également {{jsxref("Array.prototype.indexOf()")}}.</dd>
- <dt>{{jsxref("TypedArray.join", "Float64Array.prototype.join()")}}</dt>
- <dd>Fusionne l'ensemble des éléments du tableau en une chaîne de caractères. Voir également {{jsxref("Array.prototype.join()")}}.</dd>
- <dt>{{jsxref("TypedArray.keys", "Float64Array.prototype.keys()")}}</dt>
- <dd>Renvoie un nouvel objet <code>Array Iterator</code> qui contient les clés de chaque indice du tableau. Voir également {{jsxref("Array.prototype.keys()")}}.</dd>
- <dt>{{jsxref("TypedArray.lastIndexOf", "Float64Array.prototype.lastIndexOf()")}}</dt>
- <dd>Renvoie le dernier indice (le plus élevé) d'un élément du tableau qui est égal à la valeur fournie. Si aucun élément ne correspond, la valeur -1 sera renvoyée. Voir également {{jsxref("Array.prototype.lastIndexOf()")}}.</dd>
- <dt>{{jsxref("TypedArray.map", "Float64Array.prototype.map()")}}</dt>
- <dd>Crée un nouveau tableau dont les éléments sont les images des éléments du tableau courant par une fonction donnée. Voir également {{jsxref("Array.prototype.map()")}}.</dd>
- <dt>{{jsxref("TypedArray.move", "Float64Array.prototype.move()")}} {{non-standard_inline}} {{unimplemented_inline}}</dt>
- <dd>Ancienne version, non-standard, de {{jsxref("TypedArray.copyWithin", "Float64Array.prototype.copyWithin()")}}.</dd>
- <dt>{{jsxref("TypedArray.reduce", "Float64Array.prototype.reduce()")}}</dt>
- <dd>Applique une fonction sur un accumulateur et chaque élément du tableau (de gauche à droite) afin de réduire le tableau en une seule valeur. Voir également {{jsxref("Array.prototype.reduce()")}}.</dd>
- <dt>{{jsxref("TypedArray.reduceRight", "Float64Array.prototype.reduceRight()")}}</dt>
- <dd>Applique une fonction sur un accumulateur et chaque élément du tableau (de droite à gauche) afin de réduire le tableau en une seule valeur. Voir également {{jsxref("Array.prototype.reduceRight()")}}.</dd>
- <dt>{{jsxref("TypedArray.reverse", "Float64Array.prototype.reverse()")}}</dt>
- <dd>Inverse l'ordre des éléments d'un tableau. Le premier élément du tableau devient le dernier et le dernier devient le premier (et ainsi de suite). Voir également {{jsxref("Array.prototype.reverse()")}}.</dd>
- <dt>{{jsxref("TypedArray.set", "Float64Array.prototype.set()")}}</dt>
- <dd>Enregistre plusieurs valeurs dans le tableau typé à partir de valeurs d'un autre tableau.</dd>
- <dt>{{jsxref("TypedArray.slice", "Float64Array.prototype.slice()")}}</dt>
- <dd>Extrait un fragment d'un tableau et renvoie ce fragment. Voir également {{jsxref("Array.prototype.slice()")}}.</dd>
- <dt>{{jsxref("TypedArray.some", "Float64Array.prototype.some()")}}</dt>
- <dd>Renvoie <code>true</code> si au moins un des éléments remplit une condition donnée par une fonction de test. Voir également {{jsxref("Array.prototype.some()")}}.</dd>
- <dt>{{jsxref("TypedArray.sort", "Float64Array.prototype.sort()")}}</dt>
- <dd>Trie les éléments du tableau et renvoie ce tableau. Voir également {{jsxref("Array.prototype.sort()")}}.</dd>
- <dt>{{jsxref("TypedArray.subarray", "Float64Array.prototype.subarray()")}}</dt>
- <dd>Renvoie un nouvel objet <code>Float64Array</code> qui est le fragment du tableau courant, entre les indices de début et de fin donnés.</dd>
- <dt>{{jsxref("TypedArray.values", "Float64Array.prototype.values()")}}</dt>
- <dd>Renvoie un nouvel objet <code>Array Iterator</code> qui contient les valeurs correspondantes à chaque indice du tableau. Voir également {{jsxref("Array.prototype.values()")}}.</dd>
- <dt>{{jsxref("TypedArray.toLocaleString", "Float64Array.prototype.toLocaleString()")}}</dt>
- <dd>Renvoie une chaîne de caractères localisée qui représente le tableau et ses éléments. Voir également {{jsxref("Array.prototype.toLocaleString()")}}.</dd>
- <dt>{{jsxref("TypedArray.toString", "Float64Array.prototype.toString()")}}</dt>
- <dd>Renvoie une chaîne de caractère qui représente le tableau et ses éléments. Voir également {{jsxref("Array.prototype.toString()")}}.</dd>
- <dt>{{jsxref("TypedArray.@@iterator", "Float64Array.prototype[@@iterator]()")}}</dt>
- <dd>Renvoie un nouvel objet <code>Array Iterator</code> qui contient les valeurs correspondantes à chaque indice du tableau.</dd>
-</dl>
-
-<h2 id="Exemples">Exemples</h2>
-
-<p>Différentes façons de créer un objet <code>Float64Array</code> :</p>
-
-<pre class="brush: js">// Construction avec une longueur de tableau
+{{JSRef}}
+
+Le constructeur **`Floa64Array`** permet de représenter un tableau typé dont les éléments sont des nombres flottants représentés sur 64 bits (ce qui correspond à la représentation du type `double` en C) dans l'ordre des octets utilisé par la plate-forme. Si on souhaite maîtriser le boutisme (_endianness_), on pourra utiliser un objet {{jsxref("DataView")}} à la place. Les éléments du tableau sont initialisés à `0`. Une fois construit, il est possible de faire référence aux éléments du tableau en utilisant les méthodes de l'objet ou la syntaxe usuelle pour l'accès aux éléments du tableau (les crochets).
+
+## Syntaxe
+
+    new Float64Array(); // apparu avec ES2017
+    new Float64Array(longueur);
+    new Float64Array(tableauTypé);
+    new Float64Array(objet);
+    new Float64Array(buffer [, positionOctet [, longueur]]);
+
+Pour plus d'informations sur la syntaxe du constructeur et ses paramètres, voir _[TypedArray](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray#Syntaxe)_.
+
+## Propriétés
+
+- {{jsxref("TypedArray.BYTES_PER_ELEMENT", "Float64Array.BYTES_PER_ELEMENT")}}
+  - : Renvoie un nombre traduisant la taille de l'élément en octets, `8` dans le cas d'un `Float64Array`.
+- Float64Array.length
+  - : Une propriété de longueur statique qui vaut 3. Pour connaître le nombre d'éléments, voir {{jsxref("TypedArray.prototype.length", "Float64Array.prototype.length")}}.
+- {{jsxref("TypedArray.name", "Float64Array.name")}}
+  - : Renvoie la chaîne de caractère correspondant au nom du constructeur, dans le cas de `Float64Array`, ce sera : "Float64Array".
+- {{jsxref("TypedArray.prototype", "Float64Array.prototype")}}
+  - : Prototype pour les objets _TypedArray_.
+
+## Méthodes
+
+- {{jsxref("TypedArray.from", "Float64Array.from()")}}
+  - : Crée un nouvel objet `Float64Array` à partir d'un objet semblable à un tableau ou d'un objet itérable. Voir aussi {{jsxref("Array.from()")}}.
+- {{jsxref("TypedArray.of", "Float64Array.of()")}}
+  - : Crée un nouvel objet `Float64Array` à partir d'un nombre variable d'arguments. Voir aussi {{jsxref("Array.of()")}}.
+
+## Prototype de `Float64Array`
+
+Tous les objets `Float64Array` héritent de {{jsxref("TypedArray.prototype", "Float64Array.prototype")}}.
+
+### Propriétés
+
+- `Float64Array.prototype.constructor`
+  - : Renvoie la fonction qui a créé le prototype de l'instance. Par défaut, ce sera le constructeur natif `Float64Array`.
+- {{jsxref("TypedArray.prototype.buffer", "Float64Array.prototype.buffer")}} {{readonlyInline}}
+  - : Renvoie l'{{jsxref("ArrayBuffer")}} référencé par l'objet `Float64Array`. Cette valeur est fixée lors de la construction de l'objet et n'est accessible qu'**en lecture seule**.
+- {{jsxref("TypedArray.prototype.byteLength", "Float64Array.prototype.byteLength")}} {{readonlyInline}}
+  - : Renvoie la longueur, exprimée en octets, de l'objet `Float64Array` depuis le début de son {{jsxref("ArrayBuffer")}}. Cette valeur est fixée lors de la construction de l'objet et n'est accessible qu'**en lecture seule**.
+- {{jsxref("TypedArray.prototype.byteOffset", "Float64Array.prototype.byteOffset")}} {{readonlyInline}}
+  - : Renvoie le décalage, exprimé en octets, entre l'objet `Float64Array` et le début de son {{jsxref("ArrayBuffer")}}. Cette valeur est fixée lors de la construction de l'objet et n'est accessible qu'**en lecture seule**.
+- {{jsxref("TypedArray.prototype.length", "Float64Array.prototype.length")}} {{readonlyInline}}
+  - : Renvoie le nombre d'éléments contenus dans l'objet `Float64Array`. Cette valeur est fixée lors de la construction de l'objet et n'est accessible qu'**en lecture seule**.
+
+### Méthodes
+
+- {{jsxref("TypedArray.copyWithin", "Float64Array.prototype.copyWithin()")}}
+  - : Copie une suite d'éléments d'un tableau dans le tableau. Voir également {{jsxref("Array.prototype.copyWithin()")}}.
+- {{jsxref("TypedArray.entries", "Float64Array.prototype.entries()")}}
+  - : Renvoie un nouvel objet `Array Iterator` qui contient les paires clé/valeur pour chaque indice du tableau. Voir également {{jsxref("Array.prototype.entries()")}}.
+- {{jsxref("TypedArray.every", "Float64Array.prototype.every()")}}
+  - : Teste si l'ensemble des éléments du tableau remplissent une certaine condition donnée par une fonction de test. Voir également {{jsxref("Array.prototype.every()")}}.
+- {{jsxref("TypedArray.fill", "Float64Array.prototype.fill()")}}
+  - : Remplit les éléments d'un tableau avec une certaine valeur pour les éléments compris entre un indice de début et un indice de fin. Voir également {{jsxref("Array.prototype.fill()")}}.
+- {{jsxref("TypedArray.filter", "Float64Array.prototype.filter()")}}
+  - : Crée un nouveau tableau dont tous les éléments proviennent de ce tableau et respectent une condition fournie par une fonction de test. Voir également {{jsxref("Array.prototype.filter()")}}.
+- {{jsxref("TypedArray.find", "Float64Array.prototype.find()")}}
+  - : Renvoie une valeur trouvée dans le tableau s'il existe un élément du tableau qui satisfait une condition fournie par une fonction de test, s'il n'y a pas de tel élément `undefined` sera renvoyé. Voir également {{jsxref("Array.prototype.find()")}}.
+- {{jsxref("TypedArray.findIndex", "Float64Array.prototype.findIndex()")}}
+  - : Renvoie l'indice d'un élément qui satisfait une condition fournie par une fonction de test, si aucun élément ne remplit la condition -1 sera renvoyé. Voir également {{jsxref("Array.prototype.findIndex()")}}.
+- {{jsxref("TypedArray.forEach", "Float64Array.prototype.forEach()")}}
+  - : Appelle une fonction pour chacun des élément du tableau. Voir également {{jsxref("Array.prototype.forEach()")}}.
+- {{jsxref("TypedArray.includes", "Float64Array.prototype.includes()")}}
+  - : Détermine si le tableau typé contient un élément donné. Cette méthode renvoie `true` ou `false` selon le cas de figure. Voir également {{jsxref("Array.prototype.includes()")}}.
+- {{jsxref("TypedArray.indexOf", "Float64Array.prototype.indexOf()")}}
+  - : Renvoie le premier indice (le plus petit) d'un élément du tableau qui est égal à la valeur fournie. Si aucun élément ne correspond, la valeur -1 sera renvoyée. Voir également {{jsxref("Array.prototype.indexOf()")}}.
+- {{jsxref("TypedArray.join", "Float64Array.prototype.join()")}}
+  - : Fusionne l'ensemble des éléments du tableau en une chaîne de caractères. Voir également {{jsxref("Array.prototype.join()")}}.
+- {{jsxref("TypedArray.keys", "Float64Array.prototype.keys()")}}
+  - : Renvoie un nouvel objet `Array Iterator` qui contient les clés de chaque indice du tableau. Voir également {{jsxref("Array.prototype.keys()")}}.
+- {{jsxref("TypedArray.lastIndexOf", "Float64Array.prototype.lastIndexOf()")}}
+  - : Renvoie le dernier indice (le plus élevé) d'un élément du tableau qui est égal à la valeur fournie. Si aucun élément ne correspond, la valeur -1 sera renvoyée. Voir également {{jsxref("Array.prototype.lastIndexOf()")}}.
+- {{jsxref("TypedArray.map", "Float64Array.prototype.map()")}}
+  - : Crée un nouveau tableau dont les éléments sont les images des éléments du tableau courant par une fonction donnée. Voir également {{jsxref("Array.prototype.map()")}}.
+- {{jsxref("TypedArray.move", "Float64Array.prototype.move()")}} {{non-standard_inline}} {{unimplemented_inline}}
+  - : Ancienne version, non-standard, de {{jsxref("TypedArray.copyWithin", "Float64Array.prototype.copyWithin()")}}.
+- {{jsxref("TypedArray.reduce", "Float64Array.prototype.reduce()")}}
+  - : Applique une fonction sur un accumulateur et chaque élément du tableau (de gauche à droite) afin de réduire le tableau en une seule valeur. Voir également {{jsxref("Array.prototype.reduce()")}}.
+- {{jsxref("TypedArray.reduceRight", "Float64Array.prototype.reduceRight()")}}
+  - : Applique une fonction sur un accumulateur et chaque élément du tableau (de droite à gauche) afin de réduire le tableau en une seule valeur. Voir également {{jsxref("Array.prototype.reduceRight()")}}.
+- {{jsxref("TypedArray.reverse", "Float64Array.prototype.reverse()")}}
+  - : Inverse l'ordre des éléments d'un tableau. Le premier élément du tableau devient le dernier et le dernier devient le premier (et ainsi de suite). Voir également {{jsxref("Array.prototype.reverse()")}}.
+- {{jsxref("TypedArray.set", "Float64Array.prototype.set()")}}
+  - : Enregistre plusieurs valeurs dans le tableau typé à partir de valeurs d'un autre tableau.
+- {{jsxref("TypedArray.slice", "Float64Array.prototype.slice()")}}
+  - : Extrait un fragment d'un tableau et renvoie ce fragment. Voir également {{jsxref("Array.prototype.slice()")}}.
+- {{jsxref("TypedArray.some", "Float64Array.prototype.some()")}}
+  - : Renvoie `true` si au moins un des éléments remplit une condition donnée par une fonction de test. Voir également {{jsxref("Array.prototype.some()")}}.
+- {{jsxref("TypedArray.sort", "Float64Array.prototype.sort()")}}
+  - : Trie les éléments du tableau et renvoie ce tableau. Voir également {{jsxref("Array.prototype.sort()")}}.
+- {{jsxref("TypedArray.subarray", "Float64Array.prototype.subarray()")}}
+  - : Renvoie un nouvel objet `Float64Array` qui est le fragment du tableau courant, entre les indices de début et de fin donnés.
+- {{jsxref("TypedArray.values", "Float64Array.prototype.values()")}}
+  - : Renvoie un nouvel objet `Array Iterator` qui contient les valeurs correspondantes à chaque indice du tableau. Voir également {{jsxref("Array.prototype.values()")}}.
+- {{jsxref("TypedArray.toLocaleString", "Float64Array.prototype.toLocaleString()")}}
+  - : Renvoie une chaîne de caractères localisée qui représente le tableau et ses éléments. Voir également {{jsxref("Array.prototype.toLocaleString()")}}.
+- {{jsxref("TypedArray.toString", "Float64Array.prototype.toString()")}}
+  - : Renvoie une chaîne de caractère qui représente le tableau et ses éléments. Voir également {{jsxref("Array.prototype.toString()")}}.
+- {{jsxref("TypedArray.@@iterator", "Float64Array.prototype[@@iterator]()")}}
+  - : Renvoie un nouvel objet `Array Iterator` qui contient les valeurs correspondantes à chaque indice du tableau.
+
+## Exemples
+
+Différentes façons de créer un objet `Float64Array` :
+
+```js
+// Construction avec une longueur de tableau
 var float64 = new Float64Array(2);
 float64[0] = 42;
 console.log(float64[0]); // 42
@@ -152,52 +145,35 @@ var z = new Float64Array(buffer, 0, 4);
 var iterable = function*(){ yield* [1,2,3]; }();
 var float64 = new Float64Array(iterable);
 // Float64Array[1, 2, 3]
-</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('Typed Array')}}</td>
-   <td>{{Spec2('Typed Array')}}</td>
-   <td>Remplacée dans ECMAScript 2015.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES2015', '#table-49', 'TypedArray constructors')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Première définition au sein d'un standard ECMAScript. <code>new</code> est nécessaire pour utiliser le constructeur.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#table-49', 'TypedArray constructors')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td>ECMAScript 2017 a modifié le constructeur afin qu'il utilise l'opération interne <code>ToIndex</code> ce qui permet de l'utiliser sans argument.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Float64Array")}}</p>
-
-<h2 id="Notes_de_compatibilité">Notes de compatibilité</h2>
-
-<p>À partir d'ECMAScript 2015 (ES6), les constructeurs <code>TypedArray</code> doivent être utilisés avec {{jsxref("Opérateurs/L_opérateur_new", "new")}}. Appeler un constructeur <code>TypedArray</code> comme une fonction, sans <code>new</code>, provoquera une exception {{jsxref("TypeError")}}.</p>
-
-<pre class="brush: js example-bad">var dv = Float64Array([1, 2, 3]);
-// TypeError: calling a builtin Float64Array constructor without new is forbidden</pre>
-
-<pre class="brush: js example-good">var dv = new Float64Array([1, 2, 3]);</pre>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li><a href="/fr/docs/Web/JavaScript/Tableaux_typés">Les tableaux typés en JavaScript</a></li>
- <li>{{jsxref("ArrayBuffer")}}</li>
- <li>{{jsxref("DataView")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                        | État                             | Commentaires                                                                                                                          |
+| ------------------------------------------------------------------------------------ | -------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------- |
+| {{SpecName('Typed Array')}}                                                 | {{Spec2('Typed Array')}} | Remplacée dans ECMAScript 2015.                                                                                                       |
+| {{SpecName('ES2015', '#table-49', 'TypedArray constructors')}} | {{Spec2('ES2015')}}         | Première définition au sein d'un standard ECMAScript. `new` est nécessaire pour utiliser le constructeur.                             |
+| {{SpecName('ESDraft', '#table-49', 'TypedArray constructors')}} | {{Spec2('ESDraft')}}     | ECMAScript 2017 a modifié le constructeur afin qu'il utilise l'opération interne `ToIndex` ce qui permet de l'utiliser sans argument. |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Float64Array")}}
+
+## Notes de compatibilité
+
+À partir d'ECMAScript 2015 (ES6), les constructeurs `TypedArray` doivent être utilisés avec {{jsxref("Opérateurs/L_opérateur_new", "new")}}. Appeler un constructeur `TypedArray` comme une fonction, sans `new`, provoquera une exception {{jsxref("TypeError")}}.
+
+```js example-bad
+var dv = Float64Array([1, 2, 3]);
+// TypeError: calling a builtin Float64Array constructor without new is forbidden
+```
+
+```js example-good
+var dv = new Float64Array([1, 2, 3]);
+```
+
+## Voir aussi
+
+- [Les tableaux typés en JavaScript](/fr/docs/Web/JavaScript/Tableaux_typés)
+- {{jsxref("ArrayBuffer")}}
+- {{jsxref("DataView")}}
diff --git a/files/fr/web/javascript/reference/global_objects/function/apply/index.md b/files/fr/web/javascript/reference/global_objects/function/apply/index.md
index a8dcbf5fab..f4e6698445 100644
--- a/files/fr/web/javascript/reference/global_objects/function/apply/index.md
+++ b/files/fr/web/javascript/reference/global_objects/function/apply/index.md
@@ -9,76 +9,74 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Function/apply
 original_slug: Web/JavaScript/Reference/Objets_globaux/Function/apply
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>apply()</strong></code> appelle une fonction en lui passant une valeur <code>this</code> et des <code>arguments</code> sous forme d'un tableau (ou d'un objet <a href="/fr/docs/Web/JavaScript/Guide/Objets_élémentaires_JavaScript#Manipuler_des_objets_semblables_aux_tableaux">semblable à un tableau</a>).</p>
+La méthode **`apply()`** appelle une fonction en lui passant une valeur `this` et des `arguments` sous forme d'un tableau (ou d'un objet [semblable à un tableau](/fr/docs/Web/JavaScript/Guide/Objets_élémentaires_JavaScript#Manipuler_des_objets_semblables_aux_tableaux)).
 
-<div class="note"><p><strong>Note :</strong> Bien que la syntaxe de cette fonction ressemble à celle de {{jsxref("Function.call", "call()")}}, elle est différente car <code>call()</code> accepte <strong>une liste d'arguments</strong>, tandis que <code>apply()</code> accepte un <strong>tableau d'arguments</strong>.</p></div>
+> **Note :** Bien que la syntaxe de cette fonction ressemble à celle de {{jsxref("Function.call", "call()")}}, elle est différente car `call()` accepte **une liste d'arguments**, tandis que `apply()` accepte un **tableau d'arguments**.
 
-<div class="note"><p><strong>Note :</strong> Quand on utilise {{jsxref("undefined")}} ou {{jsxref("null")}} comme premier argument pour cette fonction, on peut obtenir un résultat similaire avec la <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Syntaxe_décomposition">syntaxe de décomposition</a>.</p></div>
+> **Note :** Quand on utilise {{jsxref("undefined")}} ou {{jsxref("null")}} comme premier argument pour cette fonction, on peut obtenir un résultat similaire avec la [syntaxe de décomposition](/fr/docs/Web/JavaScript/Reference/Opérateurs/Syntaxe_décomposition).
 
-<div>{{EmbedInteractiveExample("pages/js/function-apply.html")}}</div>
+{{EmbedInteractiveExample("pages/js/function-apply.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>fun</var>.apply(<var>thisArg, </var>[<var>argsArray</var>])</pre>
+    fun.apply(thisArg, [argsArray])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>thisArg</code></dt>
- <dd>La valeur de <code>this</code> fournie pour l'appel à la fonction <em><code>fun</code></em>. On notera que, sous certaines conditions, <code>this</code> peut ne pas être la valeur exacte vue par la méthode : si la méthode est une fonction utilisée en mode {{jsxref("Strict_mode", "mode non-strict", "", 1)}}, {{jsxref("null")}} et {{jsxref("undefined")}} seront remplacées par l'objet global, et les valeurs primitives seront encapsulées. Cet argument n'est pas optionnel.</dd>
- <dt><code>argsArray</code></dt>
- <dd>Un objet semblable à un tableau qui définit les arguments avec lesquel <em><code>fun</code></em> devrait être appelée, ou {{jsxref("null")}} ou {{jsxref("undefined")}} si aucun argument n'est passé à la fonction. Avec ECMAScript 5, ces arguments peuvent être représentés par un objet semblable un tableau. Voir ci-après pour plus d'informations sur <a href="#compat">la compatibilité des navigateurs</a>.</dd>
-</dl>
+- `thisArg`
+  - : La valeur de `this` fournie pour l'appel à la fonction _`fun`_. On notera que, sous certaines conditions, `this` peut ne pas être la valeur exacte vue par la méthode : si la méthode est une fonction utilisée en mode {{jsxref("Strict_mode", "mode non-strict", "", 1)}}, {{jsxref("null")}} et {{jsxref("undefined")}} seront remplacées par l'objet global, et les valeurs primitives seront encapsulées. Cet argument n'est pas optionnel.
+- `argsArray`
+  - : Un objet semblable à un tableau qui définit les arguments avec lesquel _`fun`_ devrait être appelée, ou {{jsxref("null")}} ou {{jsxref("undefined")}} si aucun argument n'est passé à la fonction. Avec ECMAScript 5, ces arguments peuvent être représentés par un objet semblable un tableau. Voir ci-après pour plus d'informations sur [la compatibilité des navigateurs](#compat).
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Le résultat obtenu en appelant la fonction avec la valeur <code>this</code> indiquée et les arguments fournis.</p>
+Le résultat obtenu en appelant la fonction avec la valeur `this` indiquée et les arguments fournis.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Il est possible d'utiliser un objet <code>this</code> différent lors de l'appel à une fonction existante. <code>this</code> fait référence à l'objet courant, l'objet appelant. Avec <code>apply</code>, on peut écrire une méthode une seule fois et en hériter dans un autre objet, sans avoir à la réécrire dans le nouvel objet.</p>
+Il est possible d'utiliser un objet `this` différent lors de l'appel à une fonction existante. `this` fait référence à l'objet courant, l'objet appelant. Avec `apply`, on peut écrire une méthode une seule fois et en hériter dans un autre objet, sans avoir à la réécrire dans le nouvel objet.
 
-<p><code>apply</code> est similaire à {{jsxref("Function.call", "call()")}}, hormis pour le type d'arguments supporté. Il est possible d'utiliser un tableau à la place d'un ensemble de paramètres. Avec <code>apply</code>, il est également possible d'utiliser un littéral de tableau, par exemple, <code><em>fun</em>.apply(this, ['manger', 'bananes'])</code>, ou un objet {{jsxref("Array")}}, par exemple, <code><em>fun</em>.apply(this, new Array('manger', 'bananes'))</code>.</p>
+`apply` est similaire à {{jsxref("Function.call", "call()")}}, hormis pour le type d'arguments supporté. Il est possible d'utiliser un tableau à la place d'un ensemble de paramètres. Avec `apply`, il est également possible d'utiliser un littéral de tableau, par exemple, `fun.apply(this, ['manger', 'bananes'])`, ou un objet {{jsxref("Array")}}, par exemple, `fun.apply(this, new Array('manger', 'bananes'))`.
 
-<p>On peut aussi passer {{jsxref("Fonctions/arguments", "arguments ")}} en tant que paramètre <code>argsArray</code>. <code>arguments</code> étant une variable locale à la fonction. Celle-ci peut également être utilisée pour tous les arguments non spécifiés de l'objet appelé. Ainsi, il n'est pas nécessaire de connaître les arguments de l'objet appelé lors d'un appel à la méthode <code>apply</code>. <code>arguments</code> peut être utilisé pour passer tous les arguments à l'objet appelé. L'objet appelé gèrera alors la manipulation des arguments.</p>
+On peut aussi passer {{jsxref("Fonctions/arguments", "arguments ")}} en tant que paramètre `argsArray`. `arguments` étant une variable locale à la fonction. Celle-ci peut également être utilisée pour tous les arguments non spécifiés de l'objet appelé. Ainsi, il n'est pas nécessaire de connaître les arguments de l'objet appelé lors d'un appel à la méthode `apply`. `arguments` peut être utilisé pour passer tous les arguments à l'objet appelé. L'objet appelé gèrera alors la manipulation des arguments.
 
-<p>Depuis la cinquième édition d'ECMAScript, il est possible d'utiliser des objet semblables à des tableaux à la place. En pratique tout objet possédant une propriété <code>length</code> et une propriété entière comprise entre <code>[0..length[</code> est un objet semblable à un tableau. On peut ainsi, par exemple, utiliser un objet {{domxref("NodeList")}} ou un objet quelconque comme <code>{'length': 2, '0': 'manger', '1': 'bananes'}</code>.</p>
+Depuis la cinquième édition d'ECMAScript, il est possible d'utiliser des objet semblables à des tableaux à la place. En pratique tout objet possédant une propriété `length` et une propriété entière comprise entre `[0..length[` est un objet semblable à un tableau. On peut ainsi, par exemple, utiliser un objet {{domxref("NodeList")}} ou un objet quelconque comme `{'length': 2, '0': 'manger', '1': 'bananes'}`.
 
-<div class="note">
-<p><strong>Note :</strong> Beaucoup de navigateurs, y compris Chrome 14 et Internet Explorer 9 n'acceptent pas encore un objet semblable à un tableau, ils déclencheront un exception.</p>
-</div>
+> **Note :** Beaucoup de navigateurs, y compris Chrome 14 et Internet Explorer 9 n'acceptent pas encore un objet semblable à un tableau, ils déclencheront un exception.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_apply_pour_chaîner_des_constructeurs">Utiliser <code>apply</code> pour chaîner des constructeurs</h3>
+### Utiliser `apply` pour chaîner des constructeurs
 
-<p>Il est possible d'utiliser <code>apply</code> afin de chaîner les {{jsxref("Opérateurs/L_opérateur_new", "constructeurs","",1)}} d'un objet, de façon sembable au chaînage utilisé en java. Dans l'exemple suivant, on crée une {{jsxref("Function")}} globale appelée <code>construct</code>, qui permet d'utiliser un objet de type <code>Array</code> associé à un constructeur au lieu d'une liste d'arguments.</p>
+Il est possible d'utiliser `apply` afin de chaîner les {{jsxref("Opérateurs/L_opérateur_new", "constructeurs","",1)}} d'un objet, de façon sembable au chaînage utilisé en java. Dans l'exemple suivant, on crée une {{jsxref("Function")}} globale appelée `construct`, qui permet d'utiliser un objet de type `Array` associé à un constructeur au lieu d'une liste d'arguments.
 
-<pre class="brush: js">Function.prototype.construct = function (aArgs) {
+```js
+Function.prototype.construct = function (aArgs) {
   var nouvelObjet = Object.create(this.prototype);
   this.apply(nouvelObjet, aArgs);
   return nouvelObjet;
 };
-</pre>
-
-<div class="note">
-<p><strong>Note :</strong> La méthode {{jsxref("Object.create()")}} utilisée ci-avant est relativement nouvelle. Pour une autre méthode qui utilise les <code>closure</code>, on pourra utiliser :</p>
-
-<pre class="brush: js">Function.prototype.construct = function(aArgs) {
-  var fConstructeur = this, fNouveauConstructeur = function() {
-    fConstructeur.apply(this, aArgs);
-  };
-  fNouveauConstructeur.prototype = fConstructeur.prototype;
-  return new fNouveauConstructeur();
-};</pre>
-</div>
-
-<p>Exemple d'utilisation :</p>
-
-<pre class="brush: js">function MonConstructeur () {
-    for (var nProp = 0; nProp &lt; arguments.length; nProp++) {
+```
+
+> **Note :** La méthode {{jsxref("Object.create()")}} utilisée ci-avant est relativement nouvelle. Pour une autre méthode qui utilise les `closure`, on pourra utiliser :
+>
+> ```js
+> Function.prototype.construct = function(aArgs) {
+>   var fConstructeur = this, fNouveauConstructeur = function() {
+>     fConstructeur.apply(this, aArgs);
+>   };
+>   fNouveauConstructeur.prototype = fConstructeur.prototype;
+>   return new fNouveauConstructeur();
+> };
+> ```
+
+Exemple d'utilisation :
+
+```js
+function MonConstructeur () {
+    for (var nProp = 0; nProp < arguments.length; nProp++) {
         this["propriété" + nProp] = arguments[nProp];
     }
 }
@@ -89,38 +87,39 @@ var monInstance = MonConstructeur.construct(monTableau);
 console.log(monInstance.propriété1); // "Coucou monde !"
 console.log(monInstance instanceof MonConstructeur); // "true"
 console.log(monInstance.constructor); // "MonConstructeur"
-</pre>
-
-<div class="note">
-<p><strong>Note :</strong> On pourrait également utiliser {{jsxref("Object/__proto__", "Object.__proto__")}}</p>
-
-<pre class="brush: js">Function.prototype.construct = function (aArgs) {
-  var oNew = {};
-  oNew.__proto__ = this.prototype;
-  this.apply(oNew, aArgs);
-  return oNew;
-};
-</pre>
-
-<p>ou encore le constructeur {{jsxref("Function")}} :</p>
-
-<pre class="brush: js">Function.prototype.construct = function (aArgs) {
-  var fNewConstr = new Function("");
-  fNewConstr.prototype = this.prototype;
-  var oNew = new fNewConstr();
-  this.apply(oNew, aArgs);
-  return oNew;
-};
-</pre>
-</div>
-
-<div class="note"><p><strong>Note :</strong> Attention, cette méthode non-native <code>Function.construct</code> ne fonctionnera pas avec certains contructeurs natifs (tels que {{jsxref("Date", "Date")}}). Dans ce cas précis, on peut utiliser la méthode {{jsxref("Function.bind")}} (pour exemple, si on prend le tableau suivant <code>[2012, 11, 4]</code> utilisé sur le constructeur de l'objet <code>Date</code> : on peut écrire ceci : <code>new (Function.prototype.bind.apply(Date, [null].concat([2012, 11, 4])))()</code> – cependant cela reste une pratique à éviter si possible et à ne pas utiliser en dans un environnement de production).</p></div>
-
-<h3 id="Utiliser_apply_et_des_fonctions_natives">Utiliser <code>apply</code> et des fonctions natives</h3>
-
-<p>Un usage singulier de <code>apply</code> permet d'appeler des fonctions natives pour réaliser par exemple des tâches qui autrement auraient nécessité une boucle sur toutes les valeurs d'un tableau. Pour illustrer ce concept, on prend l'exemple de <code>Math.max</code>/<code>Math.min</code> qui permettent d'extraire la valeur maximum/minimale de notre tableau.</p>
-
-<pre class="brush: js">/* min/max tableau de nombres */
+```
+
+> **Note :** On pourrait également utiliser {{jsxref("Object/__proto__", "Object.__proto__")}}
+>
+> ```js
+> Function.prototype.construct = function (aArgs) {
+>   var oNew = {};
+>   oNew.__proto__ = this.prototype;
+>   this.apply(oNew, aArgs);
+>   return oNew;
+> };
+> ```
+>
+> ou encore le constructeur {{jsxref("Function")}} :
+>
+> ```js
+> Function.prototype.construct = function (aArgs) {
+>   var fNewConstr = new Function("");
+>   fNewConstr.prototype = this.prototype;
+>   var oNew = new fNewConstr();
+>   this.apply(oNew, aArgs);
+>   return oNew;
+> };
+> ```
+
+> **Note :** Attention, cette méthode non-native `Function.construct` ne fonctionnera pas avec certains contructeurs natifs (tels que {{jsxref("Date", "Date")}}). Dans ce cas précis, on peut utiliser la méthode {{jsxref("Function.bind")}} (pour exemple, si on prend le tableau suivant `[2012, 11, 4]` utilisé sur le constructeur de l'objet `Date` : on peut écrire ceci : `new (Function.prototype.bind.apply(Date, [null].concat([2012, 11, 4])))()` – cependant cela reste une pratique à éviter si possible et à ne pas utiliser en dans un environnement de production).
+
+### Utiliser `apply` et des fonctions natives
+
+Un usage singulier de `apply` permet d'appeler des fonctions natives pour réaliser par exemple des tâches qui autrement auraient nécessité une boucle sur toutes les valeurs d'un tableau. Pour illustrer ce concept, on prend l'exemple de `Math.max`/`Math.min` qui permettent d'extraire la valeur maximum/minimale de notre tableau.
+
+```js
+/* min/max tableau de nombres */
 var nombres = [5, 6, 2, 3, 7];
 
 /* usage de Math.min/Math.max et de la méthode apply */
@@ -133,20 +132,22 @@ var min = Math.min.apply(null, nombres);
 /* vs. algorithme trivial avec une boucle */
 max = -Infinity, min = +Infinity;
 
-for (var i = 0; i &lt; nombres.length; i++) {
-  if (nombres[i] &gt; max)
+for (var i = 0; i < nombres.length; i++) {
+  if (nombres[i] > max)
     max = nombres[i];
-  if (nombres[i] &lt; min)
+  if (nombres[i] < min)
     min = nombres[i];
-}</pre>
+}
+```
 
-<p>Note : l'utilisation de <code>apply</code> peut provoquer l'atteinte du seuil limite du nombres d'arguments supporté par le moteur Javascript. Les conséquences de cette utilisation abusive (on évoque plus de 10000 arguments) peuvent varier selon les moteurs Javascript (JavaScript contient une limite en dur de <a class="link-https" href="https://bugs.webkit.org/show_bug.cgi?id=80797">65536</a>), car une liberté subsiste quant à l'implémentation du moteur. Des moteurs lèveront une exception si le seuil est atteint. Il est donc préférable d'apporter une attention toute particulière au nombre d'arguments passés. (Illustrerons ce cas dans l'exemple suivant avec un moteur factice capable de ne gérer que 4 arguments au maximum (les limites natives sont, bien sûr, plus élevées), et reprenons les arguments de l'exemple précédent <code>5, 6, 2, 3</code> passés à la méthode <code>apply</code> plutôt que notre tableau entier.) Imaginons que notre tableau soit progressivement peuplé de milliers d'éléments, une stratégie spécifique devra être appliquée, par exemple en appliquant la méthode apply sur des portions du tableau:</p>
+Note : l'utilisation de `apply` peut provoquer l'atteinte du seuil limite du nombres d'arguments supporté par le moteur Javascript. Les conséquences de cette utilisation abusive (on évoque plus de 10000 arguments) peuvent varier selon les moteurs Javascript (JavaScript contient une limite en dur de [65536](https://bugs.webkit.org/show_bug.cgi?id=80797)), car une liberté subsiste quant à l'implémentation du moteur. Des moteurs lèveront une exception si le seuil est atteint. Il est donc préférable d'apporter une attention toute particulière au nombre d'arguments passés. (Illustrerons ce cas dans l'exemple suivant avec un moteur factice capable de ne gérer que 4 arguments au maximum (les limites natives sont, bien sûr, plus élevées), et reprenons les arguments de l'exemple précédent `5, 6, 2, 3` passés à la méthode `apply` plutôt que notre tableau entier.) Imaginons que notre tableau soit progressivement peuplé de milliers d'éléments, une stratégie spécifique devra être appliquée, par exemple en appliquant la méthode apply sur des portions du tableau:
 
-<pre class="brush: js">function minimumDuTableau(tab) {
+```js
+function minimumDuTableau(tab) {
   var min = Infinity;
   var QUANTUM = 32768;
 
-  for (var i = 0, longueur = tab.length; i &lt; len; i += QUANTUM) {
+  for (var i = 0, longueur = tab.length; i < len; i += QUANTUM) {
     var submin = Math.min.apply(null,
                                 tab.slice(i, Math.min(i + QUANTUM, longueur)));
     min = Math.min(submin, min);
@@ -156,53 +157,26 @@ for (var i = 0; i &lt; nombres.length; i++) {
 }
 
 var min = minimumDuTableau([5, 6, 2, 3, 7]);
-</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('ES3')}}</td>
-   <td>{{Spec2('ES3')}}</td>
-   <td>Définition initiale. Implémentée avec JavaScript 1.3.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.3.4.3', 'Function.prototype.apply')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-function.prototype.apply', 'Function.prototype.apply')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-function.prototype.apply', 'Function.prototype.apply')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Function.apply")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>L'objet {{jsxref("Fonctions/arguments", "arguments")}}</li>
- <li>{{jsxref("Function.prototype.bind()")}}</li>
- <li>{{jsxref("Function.prototype.call()")}}</li>
- <li>{{jsxref("Fonctions", "Les fonctions et portées de fonctions", "", 1)}}</li>
- <li>{{jsxref("Reflect.apply()")}}</li>
- <li><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Syntaxe_décomposition">La syntaxe de décomposition permettant d'exploser un tableau</a></li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                    | État                         | Commentaires                                          |
+| ---------------------------------------------------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- |
+| {{SpecName('ES3')}}                                                                                         | {{Spec2('ES3')}}         | Définition initiale. Implémentée avec JavaScript 1.3. |
+| {{SpecName('ES5.1', '#sec-15.3.4.3', 'Function.prototype.apply')}}                         | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-function.prototype.apply', 'Function.prototype.apply')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-function.prototype.apply', 'Function.prototype.apply')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Function.apply")}}
+
+## Voir aussi
+
+- L'objet {{jsxref("Fonctions/arguments", "arguments")}}
+- {{jsxref("Function.prototype.bind()")}}
+- {{jsxref("Function.prototype.call()")}}
+- {{jsxref("Fonctions", "Les fonctions et portées de fonctions", "", 1)}}
+- {{jsxref("Reflect.apply()")}}
+- [La syntaxe de décomposition permettant d'exploser un tableau](/fr/docs/Web/JavaScript/Reference/Opérateurs/Syntaxe_décomposition)
diff --git a/files/fr/web/javascript/reference/global_objects/function/arguments/index.md b/files/fr/web/javascript/reference/global_objects/function/arguments/index.md
index 6723204679..a8272388ce 100644
--- a/files/fr/web/javascript/reference/global_objects/function/arguments/index.md
+++ b/files/fr/web/javascript/reference/global_objects/function/arguments/index.md
@@ -11,25 +11,26 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Function/arguments
 original_slug: Web/JavaScript/Reference/Objets_globaux/Function/arguments
 ---
-<div>{{JSRef}} {{Deprecated_header}}</div>
+{{JSRef}} {{Deprecated_header}}
 
-<p>La propriété <code><strong>function.arguments</strong></code> fait référence à un objet dont la structure est semblable à celle d'un tableau dont les éléments correspondent aux arguments passés à une fonction. En lieu et place, il faut désormais utiliser {{jsxref("Fonctions/arguments", "arguments")}}. Cette propriété est interdite en mode stricte à cause de <a href="https://www.ecma-international.org/ecma-262/6.0/#sec-addrestrictedfunctionproperties">l'optimisation de la queue des appels (<em>tail call optimization</em>)</a>.</p>
+La propriété **`function.arguments`** fait référence à un objet dont la structure est semblable à celle d'un tableau dont les éléments correspondent aux arguments passés à une fonction. En lieu et place, il faut désormais utiliser {{jsxref("Fonctions/arguments", "arguments")}}. Cette propriété est interdite en mode stricte à cause de [l'optimisation de la queue des appels (_tail call optimization_)](https://www.ecma-international.org/ecma-262/6.0/#sec-addrestrictedfunctionproperties).
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La syntaxe <code><em>function</em>.arguments</code> est obsolète.  La méthode recommandée pour accéder à l'objet {{jsxref("Fonctions/arguments", "arguments")}} disponible au sein des fonctions est simplement de faire référence à la variable {{jsxref("Fonctions/arguments", "arguments")}}.</p>
+La syntaxe `function.arguments` est obsolète.  La méthode recommandée pour accéder à l'objet {{jsxref("Fonctions/arguments", "arguments")}} disponible au sein des fonctions est simplement de faire référence à la variable {{jsxref("Fonctions/arguments", "arguments")}}.
 
-<p>Si on utilise la récursivité (autrement dit si une fonction <code>f</code> apparaît plusieurs fois dans la pile d'appels ou encore qu'une fonction <code>f</code> s'appelle elle-même), la valeur de <code>f.arguments</code> représentera les arguments correspondant à l'appel le plus « récent » de la fonction.</p>
+Si on utilise la récursivité (autrement dit si une fonction `f` apparaît plusieurs fois dans la pile d'appels ou encore qu'une fonction `f` s'appelle elle-même), la valeur de `f.arguments` représentera les arguments correspondant à l'appel le plus « récent » de la fonction.
 
-<p>La valeur de la propriété <code>arguments</code> est normalement <code>null</code> si la fonction n'est pas « en cours » (au sens où elle aurait été appelée et qu'elle n'ait pas fini son exécution).</p>
+La valeur de la propriété `arguments` est normalement `null` si la fonction n'est pas « en cours » (au sens où elle aurait été appelée et qu'elle n'ait pas fini son exécution).
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<pre class="brush:js">function f(n) { g(n-1); }
+```js
+function f(n) { g(n-1); }
 
 function g(n) {
   console.log("avant : " + g.arguments[0]);
-  if(n&gt;0) f(n);
+  if(n>0) f(n);
   console.log("après : " + g.arguments[0]);
 }
 
@@ -44,47 +45,22 @@ console.log("fonction terminée : " + g.arguments);
 // après : 0
 // après : 1
 // fonction terminée : null
-</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. Implémentée avec JavaScript 1.0. Dépréciée pour être remplacée par {{jsxref("Fonctions/arguments", "arguments")}} décrit par ES3.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-10.6', 'arguments object')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td>Objet {{jsxref("Fonctions/arguments", "arguments")}}</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-arguments-object', 'arguments object')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Objet {{jsxref("Fonctions/arguments", "arguments")}}</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-arguments-object', 'arguments object')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td>Objet {{jsxref("Fonctions/arguments", "arguments")}}</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Function.arguments")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>L'objet {{jsxref("Fonctions/arguments", "arguments")}}</li>
- <li>{{jsxref("Fonctions", "Les fonctions et les portées de fonctions", "", 1)}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                | Statut                       | Commentaires                                                                                                                                                         |
+| -------------------------------------------------------------------------------------------- | ---------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| {{SpecName('ES1')}}                                                                     | {{Spec2('ES1')}}         | Définition initiale. Implémentée avec JavaScript 1.0. Dépréciée pour être remplacée par {{jsxref("Fonctions/arguments", "arguments")}} décrit par ES3. |
+| {{SpecName('ES5.1', '#sec-10.6', 'arguments object')}}                     | {{Spec2('ES5.1')}}     | Objet {{jsxref("Fonctions/arguments", "arguments")}}                                                                                                   |
+| {{SpecName('ES6', '#sec-arguments-object', 'arguments object')}}         | {{Spec2('ES6')}}         | Objet {{jsxref("Fonctions/arguments", "arguments")}}                                                                                                   |
+| {{SpecName('ESDraft', '#sec-arguments-object', 'arguments object')}} | {{Spec2('ESDraft')}} | Objet {{jsxref("Fonctions/arguments", "arguments")}}                                                                                                   |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Function.arguments")}}
+
+## Voir aussi
+
+- L'objet {{jsxref("Fonctions/arguments", "arguments")}}
+- {{jsxref("Fonctions", "Les fonctions et les portées de fonctions", "", 1)}}
diff --git a/files/fr/web/javascript/reference/global_objects/function/bind/index.md b/files/fr/web/javascript/reference/global_objects/function/bind/index.md
index 747fa29f94..a2484ba8da 100644
--- a/files/fr/web/javascript/reference/global_objects/function/bind/index.md
+++ b/files/fr/web/javascript/reference/global_objects/function/bind/index.md
@@ -12,59 +12,56 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Function/bind
 original_slug: Web/JavaScript/Reference/Objets_globaux/Function/bind
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>bind()</strong></code> crée une nouvelle fonction qui, lorsqu'elle est appelée, a pour contexte <code><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_this">this</a></code> la valeur passée en paramètre et éventuellement une suite d'arguments qui précéderont ceux fournis à l'appel de la fonction créée.</p>
+La méthode **`bind()`** crée une nouvelle fonction qui, lorsqu'elle est appelée, a pour contexte [`this`](/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_this) la valeur passée en paramètre et éventuellement une suite d'arguments qui précéderont ceux fournis à l'appel de la fonction créée.
 
-<div>{{EmbedInteractiveExample("pages/js/function-bind.html", "taller")}}</div>
+{{EmbedInteractiveExample("pages/js/function-bind.html", "taller")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">let boundFunc = <var>fun</var>c.bind(<var>thisArg</var>[, <var>arg1</var>[, <var>arg2</var>[, ...]]])</pre>
+    let boundFunc = func.bind(thisArg[, arg1[, arg2[, ...]]])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>thisArg</code></dt>
- <dd>La valeur que l'on doit passer est le paramètre <code>this</code> de la fonction cible <em><code>func</code></em> quand la fonction est appelée. La valeur est ignorée si la fonction liée est construite en utilisant l'opérateur {{jsxref("Opérateurs/L_opérateur_new", "new")}}. Lorsque vous utilisez <code>bind</code> pour créer une fonction (fournie comme un rappel) dans un <code>setTimeout</code>, toute valeur primitive passée comme <code>thisArg</code> est convertie en objet. Si aucun argument n'est fourni dans <code>bind</code>, le <code>this</code> de cette fonction est traité comme le <code>thisArg</code> de la nouvelle fonction.</dd>
- <dt><code>arg1, arg2, ...</code> {{optional_inline}}</dt>
- <dd>Arguments à faire précéder aux arguments fournis à la fonction liée lors de l'invocation de <em><code>func</code></em>.</dd>
-</dl>
+- `thisArg`
+  - : La valeur que l'on doit passer est le paramètre `this` de la fonction cible _`func`_ quand la fonction est appelée. La valeur est ignorée si la fonction liée est construite en utilisant l'opérateur {{jsxref("Opérateurs/L_opérateur_new", "new")}}. Lorsque vous utilisez `bind` pour créer une fonction (fournie comme un rappel) dans un `setTimeout`, toute valeur primitive passée comme `thisArg` est convertie en objet. Si aucun argument n'est fourni dans `bind`, le `this` de cette fonction est traité comme le `thisArg` de la nouvelle fonction.
+- `arg1, arg2, ...` {{optional_inline}}
+  - : Arguments à faire précéder aux arguments fournis à la fonction liée lors de l'invocation de _`func`_.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une copie de la fonction fournie avec la valeur <code>this</code> indiquée et les arguments initiaux fournis.</p>
+Une copie de la fonction fournie avec la valeur `this` indiquée et les arguments initiaux fournis.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La fonction <code>bind()</code> crée une nouvelle <strong>fonction liée</strong>, qui est un <em>objet de fonction exotique</em> (un terme de l'ECMAScript 2015) qui enveloppe l'objet de fonction original. L'appel de la fonction liée entraîne généralement l'exécution de sa fonction enveloppée.</p>
+La fonction `bind()` crée une nouvelle **fonction liée**, qui est un _objet de fonction exotique_ (un terme de l'ECMAScript 2015) qui enveloppe l'objet de fonction original. L'appel de la fonction liée entraîne généralement l'exécution de sa fonction enveloppée.
 
-<p>Une fonction liée possède les propriétés internes suivantes :</p>
+Une fonction liée possède les propriétés internes suivantes :
 
-<dl>
- <dt><strong><code>[[BoundTargetFunction]]</code> </strong></dt>
- <dd>L'objet de fonction enveloppé</dd>
- <dt><code><strong>[[BoundThis]]</strong></code></dt>
- <dd>La valeur qui est toujours transmise est la valeur <code>this</code> lors de l'appel de la fonction enveloppée.</dd>
- <dt><code><strong>[[BoundArguments]]</strong></code></dt>
- <dd>Une liste de valeurs dont les éléments sont utilisés comme premiers arguments pour tout appel à la fonction enveloppée.</dd>
- <dt><code><strong>[[Call]]</strong></code></dt>
- <dd>Exécute le code associé à cet objet. Invoqué par une expression d'appel de fonction. Les arguments de la méthode interne sont constitués d'une valeur <code>this</code> et d'une liste contenant les arguments passés à la fonction par une expression d'appel.</dd>
-</dl>
+- **`[[BoundTargetFunction]]`**
+  - : L'objet de fonction enveloppé
+- **`[[BoundThis]]`**
+  - : La valeur qui est toujours transmise est la valeur `this` lors de l'appel de la fonction enveloppée.
+- **`[[BoundArguments]]`**
+  - : Une liste de valeurs dont les éléments sont utilisés comme premiers arguments pour tout appel à la fonction enveloppée.
+- **`[[Call]]`**
+  - : Exécute le code associé à cet objet. Invoqué par une expression d'appel de fonction. Les arguments de la méthode interne sont constitués d'une valeur `this` et d'une liste contenant les arguments passés à la fonction par une expression d'appel.
 
-<p>Lorsqu'une fonction liée est appelée, elle appelle la méthode interne <code>[[Call]]</code> dans <code>[[BoundTargetFunction]]</code>, avec les arguments suivants <code>Call(<var>boundThis</var>, ...<var>args</var>)</code>. <var>Là où </var><code><var>boundThis</var></code> est <code>[[BoundThis]]</code>, <code><var>args</var></code> est <code>[[BoundArguments]]</code>, suivi des arguments passés par l'appel de fonction.</p>
+Lorsqu'une fonction liée est appelée, elle appelle la méthode interne `[[Call]]` dans `[[BoundTargetFunction]]`, avec les arguments suivants `Call(boundThis, ...args)`. _Là où _`boundThis` est `[[BoundThis]]`, `args` est `[[BoundArguments]]`, suivi des arguments passés par l'appel de fonction.
 
-<p>Une fonction liée peut également être construite à l'aide de l'opérateur {{jsxref("Opérateurs/L_opérateur_new", "new")}}. Ce faisant, on agit comme si la fonction cible avait été construite. La valeur fournie <code>this</code> est ignorée, tandis que des arguments préparés sont fournis à la fonction émulée.</p>
+Une fonction liée peut également être construite à l'aide de l'opérateur {{jsxref("Opérateurs/L_opérateur_new", "new")}}. Ce faisant, on agit comme si la fonction cible avait été construite. La valeur fournie `this` est ignorée, tandis que des arguments préparés sont fournis à la fonction émulée.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Créer_une_fonction_liée">Créer une fonction liée</h3>
+### Créer une fonction liée
 
-<p>La façon la plus simple d'utiliser <code>bind()</code>est de faire une fonction qui, peu importe la façon dont elle est appellée, le sera avec une certaine valeur <code>this</code> donnée.</p>
+La façon la plus simple d'utiliser `bind()`est de faire une fonction qui, peu importe la façon dont elle est appellée, le sera avec une certaine valeur `this` donnée.
 
-<p>Une erreur courante lorsqu'on débute en JavaScript est d'extraire une méthode d'un objet, puis plus tard d'appeler cette méthode depuis un objet et de s'attendre à utiliser l'objet original en tant que valeur de <code>this</code> (par exemple en utilisant cette méthode dans un <em>callback</em>). Sans précaution, cependant, l'objet original est perdu. Créer une fonction liée depuis la méthode, en utilisant l'objet original, résout simplement le problème :</p>
+Une erreur courante lorsqu'on débute en JavaScript est d'extraire une méthode d'un objet, puis plus tard d'appeler cette méthode depuis un objet et de s'attendre à utiliser l'objet original en tant que valeur de `this` (par exemple en utilisant cette méthode dans un _callback_). Sans précaution, cependant, l'objet original est perdu. Créer une fonction liée depuis la méthode, en utilisant l'objet original, résout simplement le problème :
 
-<pre class="brush: js">this.x = 9; // en dehors de tout contexte,
+```js
+this.x = 9; // en dehors de tout contexte,
             // pour un navigateur, this est
             // l'objet window
 var module = {
@@ -81,13 +78,14 @@ getX(); // 9, car ici, this fait référence à l'objet global
 // tant que 'this'
 var boundGetX = getX.bind(module);
 boundGetX(); // 81
-</pre>
+```
 
-<h3 id="Fonctions_partiellement_appliquées">Fonctions partiellement appliquées</h3>
+### Fonctions partiellement appliquées
 
-<p>Dans l'exemple suivant, on utilise <code>bind()</code> afin de créer une fonction avec des arguments initiaux prédéfinis. Ces arguments, s'il y en a, suivent le <code>this</code> fourni et sont ensuite insérés au début des arguments passés à la fonction cible, suivis par les arguments passés à la fonction liée au moment où celle-ci est appelée.</p>
+Dans l'exemple suivant, on utilise `bind()` afin de créer une fonction avec des arguments initiaux prédéfinis. Ces arguments, s'il y en a, suivent le `this` fourni et sont ensuite insérés au début des arguments passés à la fonction cible, suivis par les arguments passés à la fonction liée au moment où celle-ci est appelée.
 
-<pre class="brush: js">function list() {
+```js
+function list() {
   return Array.prototype.slice.call(arguments);
 }
 
@@ -107,13 +105,14 @@ function sommeArguments(arg1, arg2){
 var ajouter37 = sommeArguments.bind(null, 37);
 
 var resultat = ajouter37(5); // 37 + 5 = 42
-</pre>
+```
 
-<h3 id="Utiliser_bind_avec_setTimeout">Utiliser <code>bind</code> avec <code>setTimeout</code></h3>
+### Utiliser `bind` avec `setTimeout`
 
-<p>Par défaut à l'intérieur de {{domxref("window.setTimeout()")}}, le mot-clé <code>this</code> sera attribué à l'objet {{domxref("window")}} (ou l'objet <code>global</code>). Lorsqu'on travaille avec des méthodes de classe utilisant <code>this</code> qui se réfère à l'instance, on peut lier <code>this</code> de façon explicite afin d'être certain de manipuler l'instance.</p>
+Par défaut à l'intérieur de {{domxref("window.setTimeout()")}}, le mot-clé `this` sera attribué à l'objet {{domxref("window")}} (ou l'objet `global`). Lorsqu'on travaille avec des méthodes de classe utilisant `this` qui se réfère à l'instance, on peut lier `this` de façon explicite afin d'être certain de manipuler l'instance.
 
-<pre class="brush: js">function Fleur() {
+```js
+function Fleur() {
   this.nbPétales = Math.floor( Math.random() * 12 ) + 1;
 }
 
@@ -130,17 +129,16 @@ Fleur.prototype.declare = function() {
 var fleur = new Fleur();
 fleur.floraison();
 // Après environ 1 seconde, on déclenche la méthode declare
-</pre>
+```
 
-<h3 id="Les_fonctions_liées_utilisées_en_tant_que_constructeurs">Les fonctions liées utilisées en tant que constructeurs</h3>
+### Les fonctions liées utilisées en tant que constructeurs
 
-<div class="warning">
-<p><strong>Attention :</strong> Cette section illustre des capacités marginales et des cas aux limites concernant l'usage de la méthode bind(). Les méthodes montrées ci-après ne sont pas les façons les plus propres de faire les choses et ne devraient pas être utilisées en production.</p>
-</div>
+> **Attention :** Cette section illustre des capacités marginales et des cas aux limites concernant l'usage de la méthode bind(). Les méthodes montrées ci-après ne sont pas les façons les plus propres de faire les choses et ne devraient pas être utilisées en production.
 
-<p>Les fonctions liées sont automatiquement disponibles à l'usage pour toutes les instances initialisées avec l'opérateur {{jsxref("Opérateurs/L_opérateur_new", "new")}} sur la fonction cible. Quand une fonction liée est utilisée pour construire une valeur, le <code>this</code> fourni est ignoré. Cependant, les arguments fournis sont toujours préremplis lors de l'appel au constructeur :</p>
+Les fonctions liées sont automatiquement disponibles à l'usage pour toutes les instances initialisées avec l'opérateur {{jsxref("Opérateurs/L_opérateur_new", "new")}} sur la fonction cible. Quand une fonction liée est utilisée pour construire une valeur, le `this` fourni est ignoré. Cependant, les arguments fournis sont toujours préremplis lors de l'appel au constructeur :
 
-<pre class="brush: js">function Point(x, y) {
+```js
+function Point(x, y) {
   this.x = x;
   this.y = y;
 }
@@ -165,11 +163,12 @@ axisPoint.toString(); //  "0,5"
 axisPoint instanceof Point; // true
 axisPoint instanceof YAxisPoint; // true
 new Point(17, 42) instanceof YAxisPoint; // false
-</pre>
+```
 
-<p>On notera qu'il n'y a rien à faire de particulier pour pouvoir utiliser {{jsxref("Opérateurs/L_opérateur_new", "new")}} sur votre fonction liée. Le corollaire est qu'il n'y a rien à faire de plus pour créer une fonction liée qui soit appelée sans préfixe, même s'il est préférable d'appeler une fonction liée uniquement avec le mot-clé {{jsxref("Opérateurs/L_opérateur_new", "new")}}.</p>
+On notera qu'il n'y a rien à faire de particulier pour pouvoir utiliser {{jsxref("Opérateurs/L_opérateur_new", "new")}} sur votre fonction liée. Le corollaire est qu'il n'y a rien à faire de plus pour créer une fonction liée qui soit appelée sans préfixe, même s'il est préférable d'appeler une fonction liée uniquement avec le mot-clé {{jsxref("Opérateurs/L_opérateur_new", "new")}}.
 
-<pre class="brush: js">// Cet exemple fonctionne dans votre console JavaScript
+```js
+// Cet exemple fonctionne dans votre console JavaScript
 // ...(sous réserve d'avoir utilisé le code précédent)
 
 // Peut toujours être appelé comme une fonction normale
@@ -177,71 +176,50 @@ new Point(17, 42) instanceof YAxisPoint; // false
 YAxisPoint(13);
 
 emptyObj.x + "," + emptyObj.y; // "0,13"
-</pre>
+```
 
-<p>Si on souhaite supporter le cas où la fonction liée  d'une fonction liée en utilisant seulement <code>new</code>, ou juste en l'appellant, la fonction cible doit outrepasser cette restriction.</p>
+Si on souhaite supporter le cas où la fonction liée  d'une fonction liée en utilisant seulement `new`, ou juste en l'appellant, la fonction cible doit outrepasser cette restriction.
 
-<h3 id="Créer_des_raccourcis">Créer des raccourcis</h3>
+### Créer des raccourcis
 
-<div>
-<p><code>bind()</code> est également utile dans les cas où on souhaite créer un raccourci vers une fonction qui requiert un <code>this</code> ayant une certaine valeur.</p>
+`bind()` est également utile dans les cas où on souhaite créer un raccourci vers une fonction qui requiert un `this` ayant une certaine valeur.
 
-<p>Si, par exemple, on considère la fonction {{jsxref("Array.prototype.slice")}} et qu'on souhaite l'utiliser pour convertir un objet semblable à un tableau en un objet <code>array</code>, on peut créer un raccourci de cette façon :</p>
+Si, par exemple, on considère la fonction {{jsxref("Array.prototype.slice")}} et qu'on souhaite l'utiliser pour convertir un objet semblable à un tableau en un objet `array`, on peut créer un raccourci de cette façon :
 
-<pre class="brush: js">var slice = Array.prototype.slice;
+```js
+var slice = Array.prototype.slice;
 
 // ... un peu plus loin
 
-slice.apply(arguments);</pre>
+slice.apply(arguments);
+```
 
-<p>Avec <code>bind()</code>, il est possible de simplifier cela. Dans l'exemple qui suit <code>slice</code> est une fonction liée à la fonction {{jsxref("Function.prototype.apply()", "apply()")}} de <code>Function.prototype</code>, et <code>this</code> défini en tant que fonction {{jsxref("Array.prototype.slice()", "slice()")}} de {{jsxref("Array.prototype")}}. Cela signifie que les appels à la méthode <code>apply()</code> peuvent être éliminés :</p>
+Avec `bind()`, il est possible de simplifier cela. Dans l'exemple qui suit `slice` est une fonction liée à la fonction {{jsxref("Function.prototype.apply()", "apply()")}} de `Function.prototype`, et `this` défini en tant que fonction {{jsxref("Array.prototype.slice()", "slice()")}} de {{jsxref("Array.prototype")}}. Cela signifie que les appels à la méthode `apply()` peuvent être éliminés :
 
-<pre class="brush: js">// pareil que "slice" dans l'exemple précédent
+```js
+// pareil que "slice" dans l'exemple précédent
 var unboundSlice = Array.prototype.slice;
 var slice = Function.prototype.apply.bind(unboundSlice);
 
 // ...
 
 slice(arguments);
-</pre>
-</div>
-
-<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.3.4.5', 'Function.prototype.bind')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td>Définition initiale.<br>
-    Implémentée avec JavaScript 1.8.5</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES2015', '#sec-function.prototype.apply', 'Function.prototype.bind')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-function.prototype.bind', 'Function.prototype.bind')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Function.bind")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Function.prototype.apply()")}}</li>
- <li>{{jsxref("Function.prototype.call()")}}</li>
- <li>{{jsxref("Fonctions", "Fonctions et portées de fonctions", "", 1)}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                | État                         | Commentaires                                           |
+| ------------------------------------------------------------------------------------------------------------ | ---------------------------- | ------------------------------------------------------ |
+| {{SpecName('ES5.1', '#sec-15.3.4.5', 'Function.prototype.bind')}}                     | {{Spec2('ES5.1')}}     | Définition initiale. Implémentée avec JavaScript 1.8.5 |
+| {{SpecName('ES2015', '#sec-function.prototype.apply', 'Function.prototype.bind')}} | {{Spec2('ES2015')}}     |                                                        |
+| {{SpecName('ESDraft', '#sec-function.prototype.bind', 'Function.prototype.bind')}} | {{Spec2('ESDraft')}} |                                                        |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Function.bind")}}
+
+## Voir aussi
+
+- {{jsxref("Function.prototype.apply()")}}
+- {{jsxref("Function.prototype.call()")}}
+- {{jsxref("Fonctions", "Fonctions et portées de fonctions", "", 1)}}
diff --git a/files/fr/web/javascript/reference/global_objects/function/call/index.md b/files/fr/web/javascript/reference/global_objects/function/call/index.md
index 5cc70709d0..5226e7b387 100644
--- a/files/fr/web/javascript/reference/global_objects/function/call/index.md
+++ b/files/fr/web/javascript/reference/global_objects/function/call/index.md
@@ -9,44 +9,43 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Function/call
 original_slug: Web/JavaScript/Reference/Objets_globaux/Function/call
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>call()</strong></code> réalise un appel à une fonction avec une valeur <code>this</code> donnée et des arguments fournis individuellement.</p>
+La méthode **`call()`** réalise un appel à une fonction avec une valeur `this` donnée et des arguments fournis individuellement.
 
-<div class="note"><p><strong>Note :</strong> Bien que la syntaxe de cette fonction ressemble à celle de {{jsxref("Function.apply", "apply()")}}, la différence fondamentale réside dans le fait que <code>call()</code> accepte <strong>une liste d'arguments</strong>, tandis que la méthode <code>apply()</code> accepte <strong>un unique tableau d'arguments</strong>.</p></div>
+> **Note :** Bien que la syntaxe de cette fonction ressemble à celle de {{jsxref("Function.apply", "apply()")}}, la différence fondamentale réside dans le fait que `call()` accepte **une liste d'arguments**, tandis que la méthode `apply()` accepte **un unique tableau d'arguments**.
 
-<div>{{EmbedInteractiveExample("pages/js/function-call.html")}}</div>
+{{EmbedInteractiveExample("pages/js/function-call.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>fun</var>.call(<var>thisArg</var>[, <var>arg1</var>[, <var>arg2</var>[, ...]]])</pre>
+    fun.call(thisArg[, arg1[, arg2[, ...]]])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>thisArg</code></dt>
- <dd>La valeur <code>this</code> fournie pour l'appel de la fonction <em><code>fun</code></em>. La valeur peut être différente de celle normalement perçue par la méthode : si la méthode est une fonction utilisée dans un code en {{jsxref("Fonctions/Strict_mode", "mode non-strict", "", 1)}}, {{jsxref("null")}} and {{jsxref("undefined")}} seront remplacés par l'objet global et les valeurs primitives seront encapsulées en objets.</dd>
- <dt><code>arg1, arg2, ...</code></dt>
- <dd>Les arguments pour la fonction.</dd>
-</dl>
+- `thisArg`
+  - : La valeur `this` fournie pour l'appel de la fonction _`fun`_. La valeur peut être différente de celle normalement perçue par la méthode : si la méthode est une fonction utilisée dans un code en {{jsxref("Fonctions/Strict_mode", "mode non-strict", "", 1)}}, {{jsxref("null")}} and {{jsxref("undefined")}} seront remplacés par l'objet global et les valeurs primitives seront encapsulées en objets.
+- `arg1, arg2, ...`
+  - : Les arguments pour la fonction.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Le résultat de l'appel de la fonction invoquée avec la valeur <code>this</code> indiquée et les arguments fournis.</p>
+Le résultat de l'appel de la fonction invoquée avec la valeur `this` indiquée et les arguments fournis.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La méthode <code>call()</code> permet d'appeler une fonction rattachée à un objet donné sur un autre objet.</p>
+La méthode `call()` permet d'appeler une fonction rattachée à un objet donné sur un autre objet.
 
-<p>Il est possible d'affecter un objet <code>this</code> différent lors de l'appel à une fonction existante. En général, <code>this</code> fait référence à l'objet courant, celui sur lequel est appelée la méthode. Avec <code>call</code>, on peut écrire une méthode une seule fois et ensuite en hériter dans un autre objet, sans avoir à réécrire cette méthode pour ce nouvel objet.</p>
+Il est possible d'affecter un objet `this` différent lors de l'appel à une fonction existante. En général, `this` fait référence à l'objet courant, celui sur lequel est appelée la méthode. Avec `call`, on peut écrire une méthode une seule fois et ensuite en hériter dans un autre objet, sans avoir à réécrire cette méthode pour ce nouvel objet.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_call()_pour_chaîner_le_constructeur_d'un_objet.">Utiliser <code>call()</code> pour chaîner le constructeur d'un objet.</h3>
+### Utiliser `call()` pour chaîner le constructeur d'un objet.
 
-<p>Il est possible d'utiliser <code>call</code> pour chaîner le constructeur d'un objet, de façon similaire à Java. Dans l'exemple suivant, le constructeur de l'objet <code>Product</code> est défini avec deux paramètres, <code>name</code> et <code>price</code>. Deux autres fonctions, <code>Food</code> et <code>Toy</code> invoquent <code>Product</code> en passant <code>this,</code> <code>name</code> et <code>price</code>. <code>Product</code> initialise les propriétés <code>name</code> et <code>price</code>, tandis que les fonctions spécialisées définissent la propriété <code>category</code>.</p>
+Il est possible d'utiliser `call` pour chaîner le constructeur d'un objet, de façon similaire à Java. Dans l'exemple suivant, le constructeur de l'objet `Product` est défini avec deux paramètres, `name` et `price`. Deux autres fonctions, `Food` et `Toy` invoquent `Product` en passant `this,` `name` et `price`. `Product` initialise les propriétés `name` et `price`, tandis que les fonctions spécialisées définissent la propriété `category`.
 
-<pre class="brush: js">function Product(name, price) {
+```js
+function Product(name, price) {
   this.name = name;
   this.price = price;
 }
@@ -63,18 +62,19 @@ function Toy(name, price) {
 
 var cheese = new Food('feta', 5);
 var fun = new Toy('robot', 40);
-</pre>
+```
 
-<h3 id="Utiliser_call()_pour_invoquer_une_fonction_anonyme">Utiliser <code>call()</code> pour invoquer une fonction anonyme</h3>
+### Utiliser `call()` pour invoquer une fonction anonyme
 
-<p>Dans cet exemple (purement inventé), on crée une fonction anonyme et on utilise <code>call</code> pour l'invoquer sur chaque objet d'un tableau. Le principal but de cette fonction anonyme est d'ajouter une fonction <code>print</code> sur chaque élément qui permet d'afficher l'index de l'objet. Le passage de l'objet en tant que valeur <code>this</code> n'était pas nécessaire, mais il permet d'expliquer le sujet.</p>
+Dans cet exemple (purement inventé), on crée une fonction anonyme et on utilise `call` pour l'invoquer sur chaque objet d'un tableau. Le principal but de cette fonction anonyme est d'ajouter une fonction `print` sur chaque élément qui permet d'afficher l'index de l'objet. Le passage de l'objet en tant que valeur `this` n'était pas nécessaire, mais il permet d'expliquer le sujet.
 
-<pre class="brush: js">var animaux = [
+```js
+var animaux = [
   {espece: 'Lion', nom: 'Roi'},
   {espece: 'Éléphant', nom: 'Dumbo'}
 ];
 
-for (var i = 0; i &lt; animaux.length; i++) {
+for (var i = 0; i < animaux.length; i++) {
   (function (i) {
     this.print = function () {
       console.log('#' + i  + ' ' + this.espece + ' : ' + this.nom);
@@ -82,13 +82,14 @@ for (var i = 0; i &lt; animaux.length; i++) {
     this.print();
   }).call(animaux[i], i);
 }
-</pre>
+```
 
-<h3 id="Utiliser_call()_pour_appeler_une_fonction_avec_un_objet_pour_this">Utiliser <code>call()</code> pour appeler une fonction avec un objet pour <code>this</code></h3>
+### Utiliser `call()` pour appeler une fonction avec un objet pour `this`
 
-<p>Dans l'exemple qui suit, on utilise la méthode <code>call()</code> sur la fonction <code>saluer()</code> afin de l'appliquer à l'objet <code>personne1</code> :</p>
+Dans l'exemple qui suit, on utilise la méthode `call()` sur la fonction `saluer()` afin de l'appliquer à l'objet `personne1` :
 
-<pre class="brush: js">function saluer() {
+```js
+function saluer() {
   var reponse = [this.nom, "est un", this.role, "."].join(" ");
   console.log(reponse);
 }
@@ -99,76 +100,51 @@ var personne1 = {
 };
 
 saluer.call(personne1); // Sénèque est un philosophe.
-</pre>
+```
 
-<h3 id="Utiliser_call()_pour_appeler_une_fonction_sans_indiquer_de_premier_argument">Utiliser <code>call()</code> pour appeler une fonction sans indiquer de premier argument</h3>
+### Utiliser `call()` pour appeler une fonction sans indiquer de premier argument
 
-<p>Dans l'exemple qui suit, on appelle la fonction <code>afficher()</code> sans lui passer d'argument. C'est donc l'objet global qui est utilisé comme contexte :</p>
-
-<pre class="brush: js">var prenom = 'Archibald';
-
-function afficher() {
-  console.log('prenom vaut ' + this.prenom);
-}
-
-afficher.call(); // prenom est Archibald</pre>
-
-<div class="note">
-<p><strong>Note :</strong> La valeur de <code>this</code> sera {{jsxref("undefined")}} en mode strict.</p>
-
-<pre class="brush: js">'use strict';
+Dans l'exemple qui suit, on appelle la fonction `afficher()` sans lui passer d'argument. C'est donc l'objet global qui est utilisé comme contexte :
 
+```js
 var prenom = 'Archibald';
 
 function afficher() {
   console.log('prenom vaut ' + this.prenom);
 }
 
-afficher.call(); // Cannot read the property prenom' of undefined</pre>
-</div>
-
-<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('ES3')}}</td>
-   <td>{{Spec2('ES3')}}</td>
-   <td>Définition initiale. Implémentée avec JavaScript 1.3.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.3.4.4', 'Function.prototype.call')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-function.prototype.call', 'Function.prototype.call')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-function.prototype.call', 'Function.prototype.call')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Function.call")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Function.prototype.bind()")}}</li>
- <li>{{jsxref("Function.prototype.apply()")}}</li>
- <li><a href="/fr/docs/Web/JavaScript/Introduction_à_JavaScript_orienté_objet">Introduction à JavaScript orienté objet</a></li>
-</ul>
+afficher.call(); // prenom est Archibald
+```
+
+> **Note :** La valeur de `this` sera {{jsxref("undefined")}} en mode strict.
+>
+> ```js
+> 'use strict';
+>
+> var prenom = 'Archibald';
+>
+> function afficher() {
+>   console.log('prenom vaut ' + this.prenom);
+> }
+>
+> afficher.call(); // Cannot read the property prenom' of undefined
+> ```
+
+## Spécifications
+
+| Spécification                                                                                                | État                         | Commentaires                                          |
+| ------------------------------------------------------------------------------------------------------------ | ---------------------------- | ----------------------------------------------------- |
+| {{SpecName('ES3')}}                                                                                     | {{Spec2('ES3')}}         | Définition initiale. Implémentée avec JavaScript 1.3. |
+| {{SpecName('ES5.1', '#sec-15.3.4.4', 'Function.prototype.call')}}                     | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-function.prototype.call', 'Function.prototype.call')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-function.prototype.call', 'Function.prototype.call')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Function.call")}}
+
+## Voir aussi
+
+- {{jsxref("Function.prototype.bind()")}}
+- {{jsxref("Function.prototype.apply()")}}
+- [Introduction à JavaScript orienté objet](/fr/docs/Web/JavaScript/Introduction_à_JavaScript_orienté_objet)
diff --git a/files/fr/web/javascript/reference/global_objects/function/caller/index.md b/files/fr/web/javascript/reference/global_objects/function/caller/index.md
index 92f4a60f1a..c7736a0831 100644
--- a/files/fr/web/javascript/reference/global_objects/function/caller/index.md
+++ b/files/fr/web/javascript/reference/global_objects/function/caller/index.md
@@ -9,74 +9,73 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Function/caller
 original_slug: Web/JavaScript/Reference/Objets_globaux/Function/caller
 ---
-<div>{{JSRef}} {{non-standard_header}}</div>
+{{JSRef}} {{non-standard_header}}
 
-<p>La propriété <code><strong>function.caller</strong></code> renvoie la fonction qui a appelé la fonction donnée. Cette propriété est interdite en mode strict.</p>
+La propriété **`function.caller`** renvoie la fonction qui a appelé la fonction donnée. Cette propriété est interdite en mode strict.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Si la fonction <code>f</code> a été invoquée par du code situé au plus haut niveau, la valeur de <code>f.caller</code> sera {{jsxref("null")}}, sinon, ce sera la fonction qui a appelé <code>f</code>.</p>
+Si la fonction `f` a été invoquée par du code situé au plus haut niveau, la valeur de `f.caller` sera {{jsxref("null")}}, sinon, ce sera la fonction qui a appelé `f`.
 
-<p>Cette propriété remplace la propriété obsolète {{jsxref("Fonctions/arguments/caller", "arguments.caller")}} de l'objet {{jsxref("Fonctions/arguments", "arguments")}}.</p>
+Cette propriété remplace la propriété obsolète {{jsxref("Fonctions/arguments/caller", "arguments.caller")}} de l'objet {{jsxref("Fonctions/arguments", "arguments")}}.
 
-<p>La propriété spéciale <code>__caller__</code> qui renvoyait l'objet qui dans lequel était fait l'appel a été supprimée pour des raisons de sécurités.</p>
+La propriété spéciale `__caller__` qui renvoyait l'objet qui dans lequel était fait l'appel a été supprimée pour des raisons de sécurités.
 
-<h3 id="Notes">Notes</h3>
+### Notes
 
-<p>Dans une fonction récursive, cette propriété ne peut pas être utilisée pour reconstituer la pile d'appels (<em>call stack</em>). Par exemple, si on a :</p>
+Dans une fonction récursive, cette propriété ne peut pas être utilisée pour reconstituer la pile d'appels (_call stack_). Par exemple, si on a :
 
-<pre class="brush: js">function f(n) { g(n - 1); }
-function g(n) { if (n &gt; 0) { f(n); } else { stop(); } }
+```js
+function f(n) { g(n - 1); }
+function g(n) { if (n > 0) { f(n); } else { stop(); } }
 f(2);
-</pre>
+```
 
-<p>Au moment où <code>stop()</code> est appelé, la pile sera :</p>
+Au moment où `stop()` est appelé, la pile sera :
 
-<pre class="eval">f(2) -&gt; g(1) -&gt; f(1) -&gt; g(0) -&gt; stop()
-</pre>
+    f(2) -> g(1) -> f(1) -> g(0) -> stop()
 
-<p>Et ceci est vrai :</p>
+Et ceci est vrai :
 
-<pre class="eval">stop.caller === g &amp;&amp; f.caller === g &amp;&amp; g.caller === f
-</pre>
+    stop.caller === g && f.caller === g && g.caller === f
 
-<p>Donc si on essaie d'obtenir la pile de cette façon :</p>
+Donc si on essaie d'obtenir la pile de cette façon :
 
-<pre class="brush: js">var f = stop;
+```js
+var f = stop;
 var stack = 'Stack trace:';
 while (f) {
   stack += '\n' + f.name;
   f = f.caller;
 }
-</pre>
+```
 
-<p>la boucle ne s'arrêterait jamais.</p>
+la boucle ne s'arrêterait jamais.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Vérifier_la_valeur_de_la_propriété_caller">Vérifier la valeur de la propriété <code>caller</code></h3>
+### Vérifier la valeur de la propriété `caller`
 
-<p>Dans l'exemple suivant, on verifie la propriété <code>caller</code> de la fonction.</p>
+Dans l'exemple suivant, on verifie la propriété `caller` de la fonction.
 
-<pre class="brush: js">function maFonction() {
+```js
+function maFonction() {
   if (maFonction.caller == null) {
     return 'Fonction appelée au plus haut niveau !';
   } else {
     return 'Fonction appelée par ' + maFonction.caller;
   }
 }
-</pre>
+```
 
-<h2 id="Spécifications">Spécifications</h2>
+## Spécifications
 
-<p>Ne fait partie d'aucune spécification. Implémentée avec JavaScript 1.5.</p>
+Ne fait partie d'aucune spécification. Implémentée avec JavaScript 1.5.
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.Function.caller")}}</p>
+{{Compat("javascript.builtins.Function.caller")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>Le bug d'implémentation pour SpiderMonkey {{bug(65683)}}</li>
-</ul>
+- Le bug d'implémentation pour SpiderMonkey {{bug(65683)}}
diff --git a/files/fr/web/javascript/reference/global_objects/function/displayname/index.md b/files/fr/web/javascript/reference/global_objects/function/displayname/index.md
index 41224d8f33..374722f47c 100644
--- a/files/fr/web/javascript/reference/global_objects/function/displayname/index.md
+++ b/files/fr/web/javascript/reference/global_objects/function/displayname/index.md
@@ -10,15 +10,16 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Function/displayName
 original_slug: Web/JavaScript/Reference/Objets_globaux/Function/displayName
 ---
-<div>{{JSRef}} {{Non-standard_header}}</div>
+{{JSRef}} {{Non-standard_header}}
 
-<p>La propriété <code><strong>function.displayName</strong></code> renvoie le nom affiché de la fonction.</p>
+La propriété **`function.displayName`** renvoie le nom affiché de la fonction.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Lorsque la propriété <code>displayName</code> est définie, elle renvoie le nom affiché de la fonction :</p>
+Lorsque la propriété `displayName` est définie, elle renvoie le nom affiché de la fonction :
 
-<pre class="brush:js">function faireTruc() { }
+```js
+function faireTruc() { }
 
 console.log(faireTruc.displayName); // "undefined"
 
@@ -27,11 +28,12 @@ var logMessage = function(contenu) { console.log(contenu) };
 logMessage.displayName = 'Afficher les messages dans le journal';
 
 console.log(logMessage.displayName); // "Afficher les messages dans le journal"
-</pre>
+```
 
-<p>Il est possible de définir une fonction avec un nom d'affichage grâce à une {{jsxref("Fonctions", "expression de fonctions","",1)}}:</p>
+Il est possible de définir une fonction avec un nom d'affichage grâce à une {{jsxref("Fonctions", "expression de fonctions","",1)}}:
 
-<pre class="brush:js">var objet = {
+```js
+var objet = {
   uneMéthode: function () {}
 };
 
@@ -42,11 +44,12 @@ console.log(objet.uneMéthode.displayName);
 
 try { uneMéthode } catch(e) { console.log(e); }
 // ReferenceError: uneMéthode is not defined
-</pre>
+```
 
-<p>La propriété <code>displayName</code> peut être changée dynamiquement :</p>
+La propriété `displayName` peut être changée dynamiquement :
 
-<pre class="brush:js">var objet = {
+```js
+var objet = {
   // anonyme
   uneMéthode: function(valeur) {
     this.displayName = "uneMéthode (" + valeur + ")";
@@ -57,24 +60,25 @@ console.log(objet.uneMéthode.displayName); // "undefined"
 
 objet.uneMéthode("123")
 console.log(objet.uneMéthode.displayName); // "uneMéthode (123)"
-</pre>
+```
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<p>On souhaite généralement utiliser cette propriété dans les consoles et profileurs plutôt que {{jsxref("Function.name", "func.name")}}</p>
+On souhaite généralement utiliser cette propriété dans les consoles et profileurs plutôt que {{jsxref("Function.name", "func.name")}}
 
-<p>Le code suivant devrait afficher quelque chose comme "function Ma Fonction()":</p>
+Le code suivant devrait afficher quelque chose comme "function Ma Fonction()":
 
-<pre class="brush:js">var a = function () { };
+```js
+var a = function () { };
 a.displayName = 'Ma Fonction';
 
 a;
-</pre>
+```
 
-<h2 id="Spécifications">Spécifications</h2>
+## Spécifications
 
-<p>N'appartient à aucune spécification.</p>
+N'appartient à aucune spécification.
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.Function.displayName")}}</p>
+{{Compat("javascript.builtins.Function.displayName")}}
diff --git a/files/fr/web/javascript/reference/global_objects/function/index.md b/files/fr/web/javascript/reference/global_objects/function/index.md
index cbac58bc3c..4db2a14baa 100644
--- a/files/fr/web/javascript/reference/global_objects/function/index.md
+++ b/files/fr/web/javascript/reference/global_objects/function/index.md
@@ -9,60 +9,59 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Function
 original_slug: Web/JavaScript/Reference/Objets_globaux/Function
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>Le constructeur <code><strong>Function</strong></code> crée un nouvel <em>objet</em> <code>Function</code>. En JavaScript, chaque fonction est un objet <code>Function</code>.</p>
+Le constructeur **`Function`** crée un nouvel _objet_ `Function`. En JavaScript, chaque fonction est un objet `Function`.
 
-<p>Appeler ce constructeur permet de créer des fonctions dynamiquement mais cette méthode souffre de défauts équivalents à {{jsxref("eval")}} en termes de sécurité et de performance. Toutefois, à la différence d'<code>eval</code>, le constructeur <code>Function</code> permet d'exécuter du code dans la portée globale.</p>
+Appeler ce constructeur permet de créer des fonctions dynamiquement mais cette méthode souffre de défauts équivalents à {{jsxref("eval")}} en termes de sécurité et de performance. Toutefois, à la différence d'`eval`, le constructeur `Function` permet d'exécuter du code dans la portée globale.
 
-<div>{{EmbedInteractiveExample("pages/js/function-constructor.html")}}</div>
+{{EmbedInteractiveExample("pages/js/function-constructor.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">new Function ([<var>arg1</var>[, <var>arg2</var>[, ...<var>argN</var>]],] corpsFonction)</pre>
+    new Function ([arg1[, arg2[, ...argN]],] corpsFonction)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>arg1, arg2, ... argN</code></dt>
- <dd>Les noms utilisés par la fonction pour les arguments formellement déclarés. Chacun doit être une chaîne de caractères correspondant à un identifiant JavaScript valide (ou une liste de telles chaînes séparées par des virgules). Par exemple : "<code>x</code>", "<code>uneValeur</code>", ou "<code>a,b</code>".</dd>
- <dt><code>corpsFonction</code></dt>
- <dd>Une chaîne de caractères qui contient les instructions JavaScript définissant la fonction.</dd>
-</dl>
+- `arg1, arg2, ... argN`
+  - : Les noms utilisés par la fonction pour les arguments formellement déclarés. Chacun doit être une chaîne de caractères correspondant à un identifiant JavaScript valide (ou une liste de telles chaînes séparées par des virgules). Par exemple : "`x`", "`uneValeur`", ou "`a,b`".
+- `corpsFonction`
+  - : Une chaîne de caractères qui contient les instructions JavaScript définissant la fonction.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Les objets <code>Function</code> créés avec le constructeur <code>Function</code> sont analysés quand la fonction est créée. Ceci est moins efficace que de déclarer une fonction grâce à une {{jsxref("Opérateurs/L_opérateur_function","expression de fonction","",1)}} ou à une instruction {{jsxref("Instructions/function","function")}} car celles crées de cette façon sont analysées avec le reste du code.</p>
+Les objets `Function` créés avec le constructeur `Function` sont analysés quand la fonction est créée. Ceci est moins efficace que de déclarer une fonction grâce à une {{jsxref("Opérateurs/L_opérateur_function","expression de fonction","",1)}} ou à une instruction {{jsxref("Instructions/function","function")}} car celles crées de cette façon sont analysées avec le reste du code.
 
-<p>Tous les arguments passés à la fonction seront traités avec les noms des identifiants des paramètres de la fonction à créer, dans le même ordre dans lequel ils ont été passés. Si un argument n'est pas passé, la valeur du paramètre dans la fonction sera {{jsxref("undefined")}}.</p>
+Tous les arguments passés à la fonction seront traités avec les noms des identifiants des paramètres de la fonction à créer, dans le même ordre dans lequel ils ont été passés. Si un argument n'est pas passé, la valeur du paramètre dans la fonction sera {{jsxref("undefined")}}.
 
-<p>Appeler le constructeur <code>Function</code> comme une fonction (c'est-à-dire sans utiliser l'opérateur {{jsxref("Opérateurs/L_opérateur_new","new")}}) a le même effet que quand il est appelé comme constructeur.</p>
+Appeler le constructeur `Function` comme une fonction (c'est-à-dire sans utiliser l'opérateur {{jsxref("Opérateurs/L_opérateur_new","new")}}) a le même effet que quand il est appelé comme constructeur.
 
-<h2 id="Propriétés_et_méthodes_de_Function">Propriétés et méthodes de <code>Function</code></h2>
+## Propriétés et méthodes de `Function`
 
-<p>L'objet global <code>Function</code> ne possède pas de méthodes ou de propriétés propres. Cependant, il est lui-même une fonction et hérite de certaines méthodes et propriétés depuis {{jsxref("Function.prototype")}} grâce à la chaîne de prototype.</p>
+L'objet global `Function` ne possède pas de méthodes ou de propriétés propres. Cependant, il est lui-même une fonction et hérite de certaines méthodes et propriétés depuis {{jsxref("Function.prototype")}} grâce à la chaîne de prototype.
 
-<h2 id="Le_prototype_de_Function">Le prototype de <code>Function</code></h2>
+## Le prototype de `Function`
 
-<h3 id="Propriétés">Propriétés</h3>
+### Propriétés
 
-<div>{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/Function/prototype', 'Propri.C3.A9t.C3.A9s')}}</div>
+{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/Function/prototype', 'Propri.C3.A9t.C3.A9s')}}
 
-<h3 id="Méthodes">Méthodes</h3>
+### Méthodes
 
-<div>{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/Function/prototype', 'M.C3.A9thodes')}}</div>
+{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/Function/prototype', 'M.C3.A9thodes')}}
 
-<h2 id="Les_instances_de_Function">Les instances de <code>Function</code></h2>
+## Les instances de `Function`
 
-<p>Les instances de <code>Function</code> héritent des méthodes et propriétés de {{jsxref("Function.prototype")}}. Comme pour les autres constructeurs, il est possible de modifier le prototype du constructeur afin d'apporter des modifications à toutes les instances de <code>Function</code>.</p>
+Les instances de `Function` héritent des méthodes et propriétés de {{jsxref("Function.prototype")}}. Comme pour les autres constructeurs, il est possible de modifier le prototype du constructeur afin d'apporter des modifications à toutes les instances de `Function`.
 
-<h2 id="Exemple">Exemple</h2>
+## Exemple
 
-<h3 id="Définir_des_arguments_avec_le_constructeur_Function">Définir des arguments avec le constructeur <code>Function</code></h3>
+### Définir des arguments avec le constructeur `Function`
 
-<p>Le code suivant permet de créer un objet <code>Function</code> qui utilise deux arguments :</p>
+Le code suivant permet de créer un objet `Function` qui utilise deux arguments :
 
-<pre class="brush: js">// Cet exemple peut être lancé dans votre console JavaScript
+```js
+// Cet exemple peut être lancé dans votre console JavaScript
 
 // On crée un fonction qui prend deux arguments
 // et qui en renvoie la somme
@@ -70,16 +69,17 @@ var ajoute = new Function('a', 'b', 'return a + b');
 
 // On appelle la fonction
 ajoute(2, 6);
-// &gt; 8
-</pre>
+// > 8
+```
 
-<p>Les arguments "<code>a</code>" et "<code>b</code>" sont les noms des arguments formellement déclarés utilisés dans le corps de la fonction : "<code>return a + b</code>".</p>
+Les arguments "`a`" et "`b`" sont les noms des arguments formellement déclarés utilisés dans le corps de la fonction : "`return a + b`".
 
-<h3 id="Différence_entre_le_constructeur_Function_et_les_déclarations_de_fonction">Différence entre le constructeur <code>Function</code> et les déclarations de fonction</h3>
+### Différence entre le constructeur `Function` et les déclarations de fonction
 
-<p>Les fonctions créées avec le constructeur {{jsxref("Function()")}} ne créent pas de fermetures liées au contexte de leur création. Ainsi, lorsqu'elles sont exécutées, elles ne peuvent accéder qu'aux variables globales et à leurs propres valeurs locales. Elles ne peuvent pas accéder aux variables de la portée dans laquelle le constructeur <code>Function</code> a été invoqué. Le comportement est différent de celui qu'on obtient avec {{jsxref("eval")}} avec du code contenant une expression de fonction.</p>
+Les fonctions créées avec le constructeur {{jsxref("Function()")}} ne créent pas de fermetures liées au contexte de leur création. Ainsi, lorsqu'elles sont exécutées, elles ne peuvent accéder qu'aux variables globales et à leurs propres valeurs locales. Elles ne peuvent pas accéder aux variables de la portée dans laquelle le constructeur `Function` a été invoqué. Le comportement est différent de celui qu'on obtient avec {{jsxref("eval")}} avec du code contenant une expression de fonction.
 
-<pre class="brush: js">var x = 10;
+```js
+var x = 10;
 
 function créerFonction1() {
   var x = 20;
@@ -97,54 +97,30 @@ function créerFonction2() {
 var f1 = créerFonction1();
 console.log(f1());          // 10
 var f2 = créerFonction2();
-console.log(f2());          // 20</pre>
-
-<p>Bien que ce code fonctionne dans un navigateur web, l'appel à <code>f1()</code> provoquera une {{jsxref("ReferenceError")}} dans Node.js car <code>x</code> ne sera pas trouvé. En effet, pour Node, la portée de plus haut niveau n'est pas la portée globale et <code>x</code> est ici local à la fonction.</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.0.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.3', 'Function')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-function-objects', 'Function')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-function-objects', 'Function')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Function")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Fonctions", "Les fonctions","",1)}}</li>
- <li>L'instruction {{jsxref("Instructions/function", "function")}}</li>
- <li>L'expression {{jsxref("Opérateurs/L_opérateur_function", "function")}}</li>
- <li>L'instruction {{jsxref("Instructions/function*", "function*")}}</li>
- <li>L'expression {{jsxref("Opérateurs/function*", "function*")}}</li>
- <li>{{jsxref("AsyncFunction")}}</li>
- <li>{{jsxref("GeneratorFunction")}}</li>
-</ul>
+console.log(f2());          // 20
+```
+
+Bien que ce code fonctionne dans un navigateur web, l'appel à `f1()` provoquera une {{jsxref("ReferenceError")}} dans Node.js car `x` ne sera pas trouvé. En effet, pour Node, la portée de plus haut niveau n'est pas la portée globale et `x` est ici local à la fonction.
+
+## 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.3', 'Function')}}                     | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-function-objects', 'Function')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-function-objects', 'Function')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Function")}}
+
+## Voir aussi
+
+- {{jsxref("Fonctions", "Les fonctions","",1)}}
+- L'instruction {{jsxref("Instructions/function", "function")}}
+- L'expression {{jsxref("Opérateurs/L_opérateur_function", "function")}}
+- L'instruction {{jsxref("Instructions/function*", "function*")}}
+- L'expression {{jsxref("Opérateurs/function*", "function*")}}
+- {{jsxref("AsyncFunction")}}
+- {{jsxref("GeneratorFunction")}}
diff --git a/files/fr/web/javascript/reference/global_objects/function/length/index.md b/files/fr/web/javascript/reference/global_objects/function/length/index.md
index 7493f7d759..359031b990 100644
--- a/files/fr/web/javascript/reference/global_objects/function/length/index.md
+++ b/files/fr/web/javascript/reference/global_objects/function/length/index.md
@@ -9,31 +9,28 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Function/length
 original_slug: Web/JavaScript/Reference/Objets_globaux/Function/length
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La propriété <code><strong>length</strong></code> définit le nombre de paramètres attendus par la fonction.</p>
+La propriété **`length`** définit le nombre de paramètres attendus par la fonction.
 
-<div>{{EmbedInteractiveExample("pages/js/function-length.html")}}</div>
+{{EmbedInteractiveExample("pages/js/function-length.html")}}{{js_property_attributes(0,0,1)}}
 
+## Description
 
+`length` est une propriété des fonctions qui indique le nombre d'arguments attendus par la fonction (ce qui correspond au nombre d'arguments formellement déclarés). Cette quantité n'inclue pas les {{jsxref("Fonctions/paramètres_du_reste", "paramètres du reste", "", 1)}} et ne compte que les paramètres situés avant le premier paramètre avec une valeur par défaut. Cette propriété est différente de {{jsxref("Fonctions/arguments/length", "arguments.length")}} qui est locale à la fonction et qui décrit le nombre d'arguments réellement passés à la fonction.
 
-<div>{{js_property_attributes(0,0,1)}}</div>
+### Propriété du constructeur `Function`
 
-<h2 id="Description">Description</h2>
+Le constructeur {{jsxref("Function")}} est lui-même un objet {{jsxref("Function")}}. Sa propriété` length` vaut 1. Les attributs de cette propriété sont : Écrivable : `false`, Énumérable : `false`, Configurable : `true`.
 
-<p><code>length</code> est une propriété des fonctions qui indique le nombre d'arguments attendus par la fonction (ce qui correspond au nombre d'arguments formellement déclarés). Cette quantité n'inclue pas les {{jsxref("Fonctions/paramètres_du_reste", "paramètres du reste", "", 1)}} et ne compte que les paramètres situés avant le premier paramètre avec une valeur par défaut. Cette propriété est différente de {{jsxref("Fonctions/arguments/length", "arguments.length")}} qui est locale à la fonction et qui décrit le nombre d'arguments réellement passés à la fonction.</p>
+### Propriété du prototype de `Function`
 
-<h3 id="Propriété_du_constructeur_Function">Propriété du constructeur <code>Function</code></h3>
+La propriété `length` du prototype de {{jsxref("Function")}} vaut 0.
 
-<p>Le constructeur {{jsxref("Function")}} est lui-même un objet {{jsxref("Function")}}. Sa propriété<code> length</code> vaut 1. Les attributs de cette propriété sont : Écrivable : <code>false</code>, Énumérable : <code>false</code>, Configurable : <code>true</code>.</p>
+## Exemples
 
-<h3 id="Propriété_du_prototype_de_Function">Propriété du prototype de <code>Function</code></h3>
-
-<p>La propriété <code>length</code> du prototype de {{jsxref("Function")}} vaut 0.</p>
-
-<h2 id="Exemples">Exemples</h2>
-
-<pre class="brush: js">console.log(Function.length); /* 1 */
+```js
+console.log(Function.length); /* 1 */
 
 console.log((function()        {}).length); /* 0 */
 console.log((function(a)       {}).length); /* 1 */
@@ -43,46 +40,21 @@ console.log((function(...args) {}).length);
 console.log((function(a, b = 1, c) {}).length);
 // 1, seuls les paramètres avant les valeurs par
 // défaut sont comptés
-</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.3.5.1', 'Function.length')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-function-instances-length', 'Function.length')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>L'attribut <code>configurable</code> de cette propriété vaut <code>true</code> désormais.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-function-instances-length', 'Function.length')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Function.length")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Function", "Function")}}</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.3.5.1', 'Function.length')}}                         | {{Spec2('ES5.1')}}     |                                                                     |
+| {{SpecName('ES6', '#sec-function-instances-length', 'Function.length')}}     | {{Spec2('ES6')}}         | L'attribut `configurable` de cette propriété vaut `true` désormais. |
+| {{SpecName('ESDraft', '#sec-function-instances-length', 'Function.length')}} | {{Spec2('ESDraft')}} |                                                                     |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Function.length")}}
+
+## Voir aussi
+
+- {{jsxref("Function", "Function")}}
diff --git a/files/fr/web/javascript/reference/global_objects/function/name/index.md b/files/fr/web/javascript/reference/global_objects/function/name/index.md
index 0f8df52d94..2d1fe90437 100644
--- a/files/fr/web/javascript/reference/global_objects/function/name/index.md
+++ b/files/fr/web/javascript/reference/global_objects/function/name/index.md
@@ -10,133 +10,142 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Function/name
 original_slug: Web/JavaScript/Reference/Objets_globaux/Function/name
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La propriété <code><strong>function.name</strong></code> est une propriété en lecture seule qui renvoie le nom de la fonction courante ou <code>"anonymous"</code> si celle-ci a été créée de façon anonyme.</p>
+La propriété **`function.name`** est une propriété en lecture seule qui renvoie le nom de la fonction courante ou `"anonymous"` si celle-ci a été créée de façon anonyme.
 
-<div>{{EmbedInteractiveExample("pages/js/function-name.html")}}</div>
+{{EmbedInteractiveExample("pages/js/function-name.html")}}{{js_property_attributes(0,0,1)}}
 
+> **Note :** Dans les implémentations non-standards antérieures à ES2015, l'attribut `configurable` valait `false`.
 
+## Exemples
 
-<div>{{js_property_attributes(0,0,1)}}</div>
+### Instruction de fonction
 
-<div class="note">
-<p><strong>Note :</strong> Dans les implémentations non-standards antérieures à ES2015, l'attribut <code>configurable</code> valait <code>false</code>.</p>
-</div>
+La propriété `name` renvoie le nom de la fonction lorsque celle-ci est utilisée dans une instruction de fonction.
 
-<h2 id="Exemples">Exemples</h2>
-
-<h3 id="Instruction_de_fonction">Instruction de fonction</h3>
-
-<p>La propriété <code>name</code> renvoie le nom de la fonction lorsque celle-ci est utilisée dans une instruction de fonction.</p>
-
-<pre class="brush: js">function faireUnTruc() {}
+```js
+function faireUnTruc() {}
 faireUnTruc.name; // "faireUnTruc"
-</pre>
+```
 
-<h3 id="Fonctions_créées_avec_un_constructeur">Fonctions créées avec un constructeur</h3>
+### Fonctions créées avec un constructeur
 
-<p>Lorsqu'on crée une fonction avec <code>new Function(...)</code> ou simplement <code>Function(...)</code>, on crée uniquement des objets dont le nom est "anonymous".</p>
+Lorsqu'on crée une fonction avec `new Function(...)` ou simplement `Function(...)`, on crée uniquement des objets dont le nom est "anonymous".
 
-<pre class="brush: js">(new Function).name; // "anonymous"</pre>
+```js
+(new Function).name; // "anonymous"
+```
 
-<h3 id="Inférence_des_noms_de_fonction">Inférence des noms de fonction</h3>
+### Inférence des noms de fonction
 
-<p>Les variables et les méthodes permettent d'inférer (c'est-à-dire de « deviner ») le nom des fonctions anonymes en fonction de leur position syntaxique (cette fonctionnalité est apparue avec ECMAScript 2015).</p>
+Les variables et les méthodes permettent d'inférer (c'est-à-dire de « deviner ») le nom des fonctions anonymes en fonction de leur position syntaxique (cette fonctionnalité est apparue avec ECMAScript 2015).
 
-<pre class="brush: js">var f = function() {};
+```js
+var f = function() {};
 var objet = {
   uneMéthode: function() {}
 };
 
 console.log(f.name); // "f"
 console.log(objet.uneMéthode.name); // "uneMéthode"
-</pre>
+```
 
-<p>On peut définir une fonction avec un nom grâce à une {{jsxref("Opérateurs/L_opérateur_function", "expression de fonction", "", 1)}}:</p>
+On peut définir une fonction avec un nom grâce à une {{jsxref("Opérateurs/L_opérateur_function", "expression de fonction", "", 1)}}:
 
-<pre class="brush: js">var objet = {
+```js
+var objet = {
   uneMéthode: function objet_maMéthode() {}
 };
 console.log(objet.uneMéthode.name); // logs "objet_maMéthode"
 
 try { objet_maMéthode } catch(e) { console.log(e); }
 // ReferenceError: objet_maMéthode is not defined
-</pre>
+```
 
-<p>On ne peut pas changer le nom d'une fonction, cette propriété est uniquement en lecture :</p>
+On ne peut pas changer le nom d'une fonction, cette propriété est uniquement en lecture :
 
-<pre class="brush: js">var objet = {
+```js
+var objet = {
   // anonyme
   uneMéthode: function() {}
 };
 
 objet.uneMéthode.name = 'uneMéthode';
 console.log(object.uneMéthode.name); // une chaîne vide, uneMéthode est anonyme
-</pre>
+```
 
-<p>Pour modifier le nom, on pourrait cependant utiliser la méthode {{jsxref("Object.defineProperty()")}}.</p>
+Pour modifier le nom, on pourrait cependant utiliser la méthode {{jsxref("Object.defineProperty()")}}.
 
-<h3 id="Notation_raccourcie_pour_les_méthodes">Notation raccourcie pour les méthodes</h3>
+### Notation raccourcie pour les méthodes
 
-<pre class="brush: js">var o = {
+```js
+var o = {
   toto(){}
 };
-o.toto.name; // "toto";</pre>
+o.toto.name; // "toto";
+```
 
-<h3 id="Noms_des_fonctions_liées">Noms des fonctions liées</h3>
+### Noms des fonctions liées
 
-<p>{{jsxref("Function.bind()")}} produit une fonction dont le nom sera la chaîne "bound " suivi du nom de la fonction.</p>
+{{jsxref("Function.bind()")}} produit une fonction dont le nom sera la chaîne "bound " suivi du nom de la fonction.
 
-<pre class="brush: js">function toto() {};
+```js
+function toto() {};
 toto.bind({}).name; // "bound toto"
-</pre>
+```
 
-<h3 id="Noms_de_fonction_pour_les_accesseurs_et_les_mutateurs">Noms de fonction pour les accesseurs et les mutateurs</h3>
+### Noms de fonction pour les accesseurs et les mutateurs
 
-<p>Lorsqu'on utilise les propriétés d'accesseur <code><a href="/fr/docs/Web/JavaScript/Reference/Fonctions/get">get</a></code> / <code><a href="/fr/docs/Web/JavaScript/Reference/Fonctions/set">set</a></code>, "get" ou "set" apparaîtra avant le nom de la fonction.</p>
+Lorsqu'on utilise les propriétés d'accesseur [`get`](/fr/docs/Web/JavaScript/Reference/Fonctions/get) / [`set`](/fr/docs/Web/JavaScript/Reference/Fonctions/set), "get" ou "set" apparaîtra avant le nom de la fonction.
 
-<pre class="brush: js">var o = {
+```js
+var o = {
   get toto(){},
   set toto(x){}
 };
 
 var descripteur = Object.getOwnPropertyDescriptor(o, "toto");
 descripteur.get.name; // "get toto"
-descripteur.set.name; // "set toto";</pre>
+descripteur.set.name; // "set toto";
+```
 
-<h3 id="Noms_des_fonctions_utilisées_dans_les_classes">Noms des fonctions utilisées dans les classes</h3>
+### Noms des fonctions utilisées dans les classes
 
-<p>On peut utiliser la notation <code>obj.constructor.name</code> pour vérifier la « classe » d'un objet (attention aux avertissements ci-après) :</p>
+On peut utiliser la notation `obj.constructor.name` pour vérifier la « classe » d'un objet (attention aux avertissements ci-après) :
 
-<pre class="brush: js">function Toto() {}  // Syntaxe ES2015 : class Toto {}
+```js
+function Toto() {}  // Syntaxe ES2015 : class Toto {}
 
 var instanceDeToto = new Toto();
 console.log(instanceDeToto.constructor.name); // affiche "Toto" dans la console
-</pre>
+```
 
-<p><strong>Attention :</strong> l'interpréteur utilisera la propriété native <code>Function.name</code> uniquement si la fonction ne possède pas une propriété en propre intitulée <em>name</em> (cf section <a href="https://www.ecma-international.org/ecma-262/6.0/#sec-setfunctionname">9.2.11 de la spécification ECMAScript2015</a>). Cependant, ES2015 indique que les propriétés définies avec mot-clé <em>static</em> seront des propriétés propres de la fonction constructrice (cf. ECMAScript2015, <a href="https://www.ecma-international.org/ecma-262/6.0/#sec-runtime-semantics-classdefinitionevaluation">14.5.14.21.b</a> + <a href="https://www.ecma-international.org/ecma-262/6.0/#sec-object-initializer-runtime-semantics-propertydefinitionevaluation">12.2.6.9</a>). Ainsi, il n'est plus possible d'obtenir le nom de la classe si celle-ci possède une méthode statique intitulée <code>name()</code> :</p>
+**Attention :** l'interpréteur utilisera la propriété native `Function.name` uniquement si la fonction ne possède pas une propriété en propre intitulée _name_ (cf section [9.2.11 de la spécification ECMAScript2015](https://www.ecma-international.org/ecma-262/6.0/#sec-setfunctionname)). Cependant, ES2015 indique que les propriétés définies avec mot-clé _static_ seront des propriétés propres de la fonction constructrice (cf. ECMAScript2015, [14.5.14.21.b](https://www.ecma-international.org/ecma-262/6.0/#sec-runtime-semantics-classdefinitionevaluation) + [12.2.6.9](https://www.ecma-international.org/ecma-262/6.0/#sec-object-initializer-runtime-semantics-propertydefinitionevaluation)). Ainsi, il n'est plus possible d'obtenir le nom de la classe si celle-ci possède une méthode statique intitulée `name()` :
 
-<pre class="brush: js">class Toto {
+```js
+class Toto {
   constructor() {}
   static name() {}
 }
-</pre>
+```
 
-<p>Avec <code>static name()</code>, <code>Toto.name</code> ne contient plus le nom de la classe mais une référence à l'objet <code>name()</code>. La définition utilisée ci-avant se comporte de façon semblable à ce fragment de code ES5 :</p>
+Avec `static name()`, `Toto.name` ne contient plus le nom de la classe mais une référence à l'objet `name()`. La définition utilisée ci-avant se comporte de façon semblable à ce fragment de code ES5 :
 
-<pre class="brush: js">function Toto() {}
+```js
+function Toto() {}
 Object.defineProperty(Toto, 'name', { writable: true });
 Toto.name = function() {};
-</pre>
+```
 
-<p>Il est donc parfois erroné de penser que <code>Function.name</code> pointe toujours vers le nom de la classe.</p>
+Il est donc parfois erroné de penser que `Function.name` pointe toujours vers le nom de la classe.
 
-<h3 id="Noms_de_fonction_sous_la_forme_de_symboles">Noms de fonction sous la forme de symboles</h3>
+### Noms de fonction sous la forme de symboles
 
-<p>Si un symbole ({{jsxref("Symbol")}}) est utilisé comme nom d'une fonction et que celui-ci dispose d'une description, c'est cette dernière qui sera utilisée comme nom de la méthode, entre crochets :</p>
+Si un symbole ({{jsxref("Symbol")}}) est utilisé comme nom d'une fonction et que celui-ci dispose d'une description, c'est cette dernière qui sera utilisée comme nom de la méthode, entre crochets :
 
-<pre class="brush: js">var sym1 = Symbol("Toto");
+```js
+var sym1 = Symbol("Toto");
 var sym2 = Symbol();
 var o = {
   [sym1]: function(){},
@@ -144,13 +153,15 @@ var o = {
 };
 
 o[sym1].name; // "[Toto]"
-o[sym2].name; // ""</pre>
+o[sym2].name; // ""
+```
 
-<h2 id="Compresseurs_et_outils_de_minification_JavaScript">Compresseurs et outils de minification JavaScript</h2>
+## Compresseurs et outils de minification JavaScript
 
-<p>Attention à l'utilisation de <code>Function.name</code> lorsque le code source est transformé par certains outils. En effet, ceux-ci réduisent généralement la taille d'un programme en compressant les espaces et en modifiant parfois les noms de variables. Ainsi, un fragment de code comme :</p>
+Attention à l'utilisation de `Function.name` lorsque le code source est transformé par certains outils. En effet, ceux-ci réduisent généralement la taille d'un programme en compressant les espaces et en modifiant parfois les noms de variables. Ainsi, un fragment de code comme :
 
-<pre class="brush: js">function Toto() {};
+```js
+function Toto() {};
 var toto = new Toto();
 
 if (Toto.constructor.name === 'Toto') {
@@ -158,43 +169,29 @@ if (Toto.constructor.name === 'Toto') {
 } else {
   console.log('Oups !');
 }
-</pre>
+```
 
-<p>pourrait être compressé en :</p>
+pourrait être compressé en :
 
-<pre class="brush: js">function a() {};
+```js
+function a() {};
 var b = new a();
 if (b.constructor.name === 'Toto') {
   console.log("'toto' est une instance de 'Toto'");
 } else {
   console.log('Oups !');
 }
-</pre>
-
-<p>Dans la version non-compressée, la condition du test est remplie et on affiche <em>'toto' est une instance de 'Toto'</em> dans la console. Mais dans la version compressée, la condition n'est pas vérifiée. Lorsqu'on utilise <code>name</code>, il faut s'assurer que les outils utilisés ne modifient pas le nom des fonctions.</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('ES2015', '#sec-name', 'name')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-function-instances-name', 'name')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Function.name")}}</p>
+```
+
+Dans la version non-compressée, la condition du test est remplie et on affiche _'toto' est une instance de 'Toto'_ dans la console. Mais dans la version compressée, la condition n'est pas vérifiée. Lorsqu'on utilise `name`, il faut s'assurer que les outils utilisés ne modifient pas le nom des fonctions.
+
+## Spécifications
+
+| Spécification                                                                        | État                         | Commentaires         |
+| ------------------------------------------------------------------------------------ | ---------------------------- | -------------------- |
+| {{SpecName('ES2015', '#sec-name', 'name')}}                             | {{Spec2('ES2015')}}     | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-function-instances-name', 'name')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Function.name")}}
diff --git a/files/fr/web/javascript/reference/global_objects/function/tosource/index.md b/files/fr/web/javascript/reference/global_objects/function/tosource/index.md
index cfc1e8f26a..ad358e7be6 100644
--- a/files/fr/web/javascript/reference/global_objects/function/tosource/index.md
+++ b/files/fr/web/javascript/reference/global_objects/function/tosource/index.md
@@ -9,58 +9,55 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Function/toSource
 original_slug: Web/JavaScript/Reference/Objets_globaux/Function/toSource
 ---
-<div>{{JSRef}}{{non-standard_header}}</div>
+{{JSRef}}{{non-standard_header}}
 
-<p>La méthode <code><strong>toSource()</strong></code> renvoie une chaîne de caractères représentant le code source de l'objet.</p>
+La méthode **`toSource()`** renvoie une chaîne de caractères représentant le code source de l'objet.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>function</var>.toSource();
-Function.toSource();
-</pre>
+    function.toSource();
+    Function.toSource();
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une chaîne de caractères représentant le code source de l'objet.</p>
+Une chaîne de caractères représentant le code source de l'objet.
 
-<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("Function")}}, <code>toSource()</code> renvoie la chaîne suivante qui indique que le code source n'est pas disponible :
+- Pour l'objet natif {{jsxref("Function")}}, `toSource()` renvoie la chaîne suivante qui indique que le code source n'est pas disponible :
 
-  <pre class="brush: js">function Function() {
-    [native code]
-}
-</pre>
- </li>
- <li>Pour les fonctions définies dans les scripts, <code>toSource()</code> renverra la chaîne correspondant au code source JavaScript de l'objet.
-  <pre class="brush: js">function coucou() {
-  console.log("Coucou le monde");
-}
+  ```js
+    function Function() {
+        [native code]
+    }
+    ```
 
-coucou.toSource();
-// produira la chaîne de caractères
-// "function coucou() {
-//   console.log(\"Coucou le monde\");
-// }"
-</pre>
- </li>
-</ul>
+- Pour les fonctions définies dans les scripts, `toSource()` renverra la chaîne correspondant au code source JavaScript de l'objet.
 
-<p>De façon générale, cette méthode est utilisée en interne par le moteur JavaScript et n'est pas utilisée dans les scripts tiers. Il est possible d'utiliser cette méthode pour une aide au débogage et pouvoir examiner le contenu d'un objet.</p>
+  ```js
+    function coucou() {
+      console.log("Coucou le monde");
+    }
 
-<h2 id="Spécifications">Spécifications</h2>
+    coucou.toSource();
+    // produira la chaîne de caractères
+    // "function coucou() {
+    //   console.log(\"Coucou le monde\");
+    // }"
+    ```
 
-<p>Ne fait partie d'aucune spécification. Implémentée avec JavaScript 1.3.</p>
+De façon générale, cette méthode est utilisée en interne par le moteur JavaScript et n'est pas utilisée dans les scripts tiers. Il est possible d'utiliser cette méthode pour une aide au débogage et pouvoir examiner le contenu d'un objet.
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Spécifications
 
-<p>{{Compat("javascript.builtins.Function.toSource")}}</p>
+Ne fait partie d'aucune spécification. Implémentée avec JavaScript 1.3.
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Compatibilité des navigateurs
 
-<ul>
- <li>{{jsxref("Object.prototype.toSource()")}}</li>
-</ul>
+{{Compat("javascript.builtins.Function.toSource")}}
+
+## Voir aussi
+
+- {{jsxref("Object.prototype.toSource()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/function/tostring/index.md b/files/fr/web/javascript/reference/global_objects/function/tostring/index.md
index 625eb83203..0eac5c45c6 100644
--- a/files/fr/web/javascript/reference/global_objects/function/tostring/index.md
+++ b/files/fr/web/javascript/reference/global_objects/function/tostring/index.md
@@ -10,86 +10,62 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Function/toString
 original_slug: Web/JavaScript/Reference/Objets_globaux/Function/toString
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>toString()</strong></code> renvoie une chaîne de caractères représentant le code source de la fonction.</p>
+La méthode **`toString()`** renvoie une chaîne de caractères représentant le code source de la fonction.
 
-<div>{{EmbedInteractiveExample("pages/js/function-tostring.html")}}</div>
+{{EmbedInteractiveExample("pages/js/function-tostring.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>function</var>.toString(indentation)</pre>
+    function.toString(indentation)
 
-<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 fonction.</p>
+Une chaîne de caractères qui représente le code source de la fonction.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>L'objet {{jsxref("Function")}} redéfinit la méthode {{jsxref("Object.prototype.toString", "toString")}} de l'objet {{jsxref("Object")}} ; il n'hérite donc pas de {{jsxref("Object.prototype.toString")}}. Pour les objets {{jsxref("Function")}}, la méthode <code>toString</code> renvoie une chaîne de caractères représentant l'objet sous la forme d'une déclaration de fonction. Pour ce faire, <code>toString</code> décompile la fonction pour renvoyer une chaîne qui contient le mot-clé <code>function</code>, la liste des arguments, les accolades et la source correspondant au corps de la fonction.</p>
+L'objet {{jsxref("Function")}} redéfinit la méthode {{jsxref("Object.prototype.toString", "toString")}} de l'objet {{jsxref("Object")}} ; il n'hérite donc pas de {{jsxref("Object.prototype.toString")}}. Pour les objets {{jsxref("Function")}}, la méthode `toString` renvoie une chaîne de caractères représentant l'objet sous la forme d'une déclaration de fonction. Pour ce faire, `toString` décompile la fonction pour renvoyer une chaîne qui contient le mot-clé `function`, la liste des arguments, les accolades et la source correspondant au corps de la fonction.
 
-<p>Le moteur JavaScript appelle la méthode <code>toString</code> automatiquement lorsqu'un objet {{jsxref("Function")}} doit être représenté textuellement (par exemple lorsqu'une fonction doit être concaténée avec une chaîne de caractères).</p>
+Le moteur JavaScript appelle la méthode `toString` automatiquement lorsqu'un objet {{jsxref("Function")}} doit être représenté textuellement (par exemple lorsqu'une fonction doit être concaténée avec une chaîne de caractères).
 
-<p>La méthode <code>toString()</code> lèvera une exception {{jsxref("TypeError")}} (« Function.prototype.toString called on incompatible object ») si la valeur this n'est pas un objet <code>Function</code>.</p>
+La méthode `toString()` lèvera une exception {{jsxref("TypeError")}} (« Function.prototype.toString called on incompatible object ») si la valeur this n'est pas un objet `Function`.
 
-<pre class="example-bad brush: js">Function.prototype.toString.call("toto"); // TypeError
-</pre>
+```js example-bad
+Function.prototype.toString.call("toto"); // TypeError
+```
 
-<p>Si la méthode <code>toString()</code> est appelée sur des fonctions natives qui ne sont pas définies dans le script, <code>toString()</code> renvoie une chaîne de caractères indiquant le caractère natif :</p>
+Si la méthode `toString()` est appelée sur des fonctions natives qui ne sont pas définies dans le script, `toString()` renvoie une chaîne de caractères indiquant le caractère natif :
 
-<pre class="brush: js">Math.abs.toString();
+```js
+Math.abs.toString();
 
 "function abs() {
     [native code]
-}"</pre>
-
-<p>Si la méthode <code>toString()</code> est appelée sur une fonction créée avec le constructeur <code>Function</code>, <code>toString()</code> renverra le code source d'une fonction intitulée <code>anonymous</code> et utilisera les paramètres et le corps de la fonction fournis.</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.1.</td>
-  </tr>
-  <tr>
-   <td><code><a href="https://tc39.github.io/Function-prototype-toString-revision/#sec-introduction">Function.prototype.toString()</a></code></td>
-   <td>Brouillon</td>
-   <td>Standardise la chaîne de caractères utilisée pour les fonctions natives ainsi que la gestion des fins de ligne.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-function.prototype.tostring', 'Function.prototype.toString')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Critères supplémentaires ajoutés sur la représentation de la chaîne.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-function.prototype.tostring', 'Function.prototype.toString')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Function.toString")}}</p>
-
-<h2 id="Notes_spécifiques_à_Firefox">Notes spécifiques à Firefox</h2>
-
-<ul>
- <li>À partir de Firefox 17.0, <code>Function.prototype.toString()</code> a été implémenté en sauvegardant le code source de la fonction. La méthode utilisant la décompilation a été retirée et le paramètre <code>indentation</code> n'est donc plus nécessaire. Pour plus d'informations, voir {{bug("761723")}}.</li>
- <li>À partir de Firefox 38 et jusqu'à Firefox 63, <code>Function.prototype.toString()</code> levait une exception pour les {{jsxref("Proxy")}} (cf. {{bug(1100936)}} et {{bug(1440468)}}).</li>
-</ul>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Object.prototype.toString()")}}</li>
-</ul>
+}"
+```
+
+Si la méthode `toString()` est appelée sur une fonction créée avec le constructeur `Function`, `toString()` renverra le code source d'une fonction intitulée `anonymous` et utilisera les paramètres et le corps de la fonction fournis.
+
+## Spécifications
+
+| Spécification                                                                                                            | État                         | Commentaires                                                                                                    |
+| ------------------------------------------------------------------------------------------------------------------------ | ---------------------------- | --------------------------------------------------------------------------------------------------------------- |
+| {{SpecName('ES1')}}                                                                                                 | {{Spec2('ES1')}}         | Définition initiale. Implémentée avec JavaScript 1.1.                                                           |
+| [`Function.prototype.toString()`](https://tc39.github.io/Function-prototype-toString-revision/#sec-introduction)         | Brouillon                    | Standardise la chaîne de caractères utilisée pour les fonctions natives ainsi que la gestion des fins de ligne. |
+| {{SpecName('ES6', '#sec-function.prototype.tostring', 'Function.prototype.toString')}}     | {{Spec2('ES6')}}         | Critères supplémentaires ajoutés sur la représentation de la chaîne.                                            |
+| {{SpecName('ESDraft', '#sec-function.prototype.tostring', 'Function.prototype.toString')}} | {{Spec2('ESDraft')}} |                                                                                                                 |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Function.toString")}}
+
+## Notes spécifiques à Firefox
+
+- À partir de Firefox 17.0, `Function.prototype.toString()` a été implémenté en sauvegardant le code source de la fonction. La méthode utilisant la décompilation a été retirée et le paramètre `indentation` n'est donc plus nécessaire. Pour plus d'informations, voir {{bug("761723")}}.
+- À partir de Firefox 38 et jusqu'à Firefox 63, `Function.prototype.toString()` levait une exception pour les {{jsxref("Proxy")}} (cf. {{bug(1100936)}} et {{bug(1440468)}}).
+
+## Voir aussi
+
+- {{jsxref("Object.prototype.toString()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/generator/index.md b/files/fr/web/javascript/reference/global_objects/generator/index.md
index 646ecd415a..7540ca763f 100644
--- a/files/fr/web/javascript/reference/global_objects/generator/index.md
+++ b/files/fr/web/javascript/reference/global_objects/generator/index.md
@@ -9,36 +9,35 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Generator
 original_slug: Web/JavaScript/Reference/Objets_globaux/Generator
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>L'objet <code><strong>Generator</strong></code> est renvoyé par une {{jsxref("Instructions/function*","fonction génératrice","",1)}}, c'est à la fois <a href="/fr/docs/Web/JavaScript/Reference/Les_protocoles_iteration#Le_protocole_%C2%AB_it%C3%A9rateur_%C2%BB">un itérateur</a> et <a href="/fr/docs/Web/JavaScript/Reference/Les_protocoles_iteration#Le_protocole_%C2%AB_it%C3%A9rable_%C2%BB">un itérable</a>.</p>
+L'objet **`Generator`** est renvoyé par une {{jsxref("Instructions/function*","fonction génératrice","",1)}}, c'est à la fois [un itérateur](/fr/docs/Web/JavaScript/Reference/Les_protocoles_iteration#Le_protocole_%C2%AB_it%C3%A9rateur_%C2%BB) et [un itérable](/fr/docs/Web/JavaScript/Reference/Les_protocoles_iteration#Le_protocole_%C2%AB_it%C3%A9rable_%C2%BB).
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">function* gen() {
-  yield 1;
-  yield 2;
-  yield 3;
-}
+    function* gen() {
+      yield 1;
+      yield 2;
+      yield 3;
+    }
 
-var g = gen(); // "Generator { }"</pre>
+    var g = gen(); // "Generator { }"
 
-<h2 id="Méthodes">Méthodes</h2>
+## Méthodes
 
-<dl>
- <dt>{{jsxref("Generator.prototype.next()")}}</dt>
- <dd>Renvoie une valeur générée par l'expression {{jsxref("Opérateurs/yield", "yield")}}.</dd>
- <dt>{{jsxref("Generator.prototype.return()")}}</dt>
- <dd>Renvoie la valeur donnée et termine le générateur.</dd>
- <dt>{{jsxref("Generator.prototype.throw()")}}</dt>
- <dd>Lève une exception dans un générateur. Cette opération termine le générateur, sauf si l'exception est interceptée dans le générateur.</dd>
-</dl>
+- {{jsxref("Generator.prototype.next()")}}
+  - : Renvoie une valeur générée par l'expression {{jsxref("Opérateurs/yield", "yield")}}.
+- {{jsxref("Generator.prototype.return()")}}
+  - : Renvoie la valeur donnée et termine le générateur.
+- {{jsxref("Generator.prototype.throw()")}}
+  - : Lève une exception dans un générateur. Cette opération termine le générateur, sauf si l'exception est interceptée dans le générateur.
 
-<h2 id="Exemple">Exemple</h2>
+## Exemple
 
-<h3 id="Un_itérateur_infini">Un itérateur infini</h3>
+### Un itérateur infini
 
-<pre class="brush: js">function* idMaker(){
+```js
+function* idMaker(){
     var index = 0;
     while(true)
         yield index++;
@@ -49,28 +48,28 @@ var gen = idMaker(); // "Generator { }"
 console.log(gen.next().value); // 0
 console.log(gen.next().value); // 1
 console.log(gen.next().value); // 2
-// ...</pre>
+// ...
+```
 
-<h2 id="Générateurs_historiques">Générateurs historiques</h2>
+## Générateurs historiques
 
-<p>Firefox (SpiderMonkey) implémente également une version antérieure pour les générateurs avec <a href="/fr/docs/Web/JavaScript/New_in_JavaScript/1.7">JavaScript 1.7</a>. Pour cette syntaxe, il n'y a pas besoin d'utiliser l'astérisque dans la déclaration de la fonction, il suffit d'utiliser le mot-clé <code>yield</code> dans le corps de la fonction. Les générateurs historiques sont une fonctionnalité dépréciée et seront supprimés à l'avenir ({{bug(1083482)}}), il est fortement déconseillé de les utiliser.</p>
+Firefox (SpiderMonkey) implémente également une version antérieure pour les générateurs avec [JavaScript 1.7](/fr/docs/Web/JavaScript/New_in_JavaScript/1.7). Pour cette syntaxe, il n'y a pas besoin d'utiliser l'astérisque dans la déclaration de la fonction, il suffit d'utiliser le mot-clé `yield` dans le corps de la fonction. Les générateurs historiques sont une fonctionnalité dépréciée et seront supprimés à l'avenir ({{bug(1083482)}}), il est fortement déconseillé de les utiliser.
 
-<h3 id="Méthodes_pour_les_générateurs_historiques">Méthodes pour les générateurs historiques</h3>
+### Méthodes pour les générateurs historiques
 
-<dl>
- <dt><code>Generator.prototype.next() </code>{{non-standard_inline}}</dt>
- <dd>Renvoie une valeur générée par l'expression {{jsxref("Opérateurs/yield", "yield")}}. Cette méthode correspond à <code>next()</code> pour les générateurs ES2015.</dd>
- <dt><code>Generator.prototype.close()</code> {{non-standard_inline}}</dt>
- <dd>Clôture le générateur, tout appel ultérieur à <code>next()</code> renverra une exception {{jsxref("StopIteration")}}. Cela correspond à la méthode <code>return()</code> pour les générateurs ES2015.</dd>
- <dt><code>Generator.prototype.send()</code> {{non-standard_inline}}</dt>
- <dd>Utilisée pour envoyer une valeur à un générateur. La valeur est renvoyée avec une expression {{jsxref("Opérateurs/yield", "yield")}} et renvoie une valeur générée par la prochaine expression {{jsxref("Opérateurs/yield", "yield")}}. <code>send(x)</code> correspond à <code>next(x)</code> pour les générateurs ES2015.</dd>
- <dt><strong><code>Generator.</code></strong><code>prototype.</code><strong><code>throw()</code> </strong> {{non-standard_inline}}</dt>
- <dd>Lève une exception au sein d'un générateur. Cela correspond à la méthode <code>throw()</code> pour les générateurs ES2015.</dd>
-</dl>
+- `Generator.prototype.next() `{{non-standard_inline}}
+  - : Renvoie une valeur générée par l'expression {{jsxref("Opérateurs/yield", "yield")}}. Cette méthode correspond à `next()` pour les générateurs ES2015.
+- `Generator.prototype.close()` {{non-standard_inline}}
+  - : Clôture le générateur, tout appel ultérieur à `next()` renverra une exception {{jsxref("StopIteration")}}. Cela correspond à la méthode `return()` pour les générateurs ES2015.
+- `Generator.prototype.send()` {{non-standard_inline}}
+  - : Utilisée pour envoyer une valeur à un générateur. La valeur est renvoyée avec une expression {{jsxref("Opérateurs/yield", "yield")}} et renvoie une valeur générée par la prochaine expression {{jsxref("Opérateurs/yield", "yield")}}. `send(x)` correspond à `next(x)` pour les générateurs ES2015.
+- **`Generator.`**`prototype.`**`throw()` **{{non-standard_inline}}
+  - : Lève une exception au sein d'un générateur. Cela correspond à la méthode `throw()` pour les générateurs ES2015.
 
-<h3 id="Exemple_utilisant_un_générateur_historique">Exemple utilisant un générateur historique</h3>
+### Exemple utilisant un générateur historique
 
-<pre class="brush: js">function* fibonacci() {
+```js
+function* fibonacci() {
   var a = yield 1;
   yield a * 2;
 }
@@ -81,54 +80,35 @@ console.log(it.next());   // 1
 console.log(it.send(10)); // 20
 console.log(it.close());  // undefined
 console.log(it.next());   // throws StopIteration (le générateur est clôturé)
-</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-generator-objects', 'Generator objects')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-generator-objects', 'Generator objects')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Generator")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<h3 id="Générateurs_historiques_2">Générateurs historiques</h3>
-
-<ul>
- <li>{{jsxref("Instructions/Fonction_génératrice_historique", "Fonction génératrice historique", "", 1)}}</li>
- <li>{{jsxref("Opérateurs/function*", "L'expression d'un générateur historique", "", 1)}}</li>
- <li>{{jsxref("StopIteration")}}</li>
- <li><a href="/fr/docs/Web/JavaScript/Guide/Le_protocole_itérateur_historique">Le protocole itérateur historique</a></li>
-</ul>
-
-<h3 id="Générateurs_ES2015">Générateurs ES2015</h3>
-
-<ul>
- <li>{{jsxref("Fonctions", "Fonctions", "", 1)}}</li>
- <li>{{jsxref("Instructions/function", "function")}}</li>
- <li>L'expression {{jsxref("L_opérateur_function", "function")}}</li>
- <li>{{jsxref("Function")}}</li>
- <li>{{jsxref("Instructions/function*", "function*")}}</li>
- <li>L'expression {{jsxref("Opérateurs/function*", "function*")}}</li>
- <li>{{jsxref("GeneratorFunction")}}</li>
- <li><a href="/fr/docs/Web/JavaScript/Guide/Le_protocole_iterator">Le protocole Iterator</a></li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                | État                         | Commentaires         |
+| -------------------------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ES2015', '#sec-generator-objects', 'Generator objects')}} | {{Spec2('ES2015')}}     | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-generator-objects', 'Generator objects')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Generator")}}
+
+## Voir aussi
+
+### Générateurs historiques
+
+- {{jsxref("Instructions/Fonction_génératrice_historique", "Fonction génératrice historique", "", 1)}}
+- {{jsxref("Opérateurs/function*", "L'expression d'un générateur historique", "", 1)}}
+- {{jsxref("StopIteration")}}
+- [Le protocole itérateur historique](/fr/docs/Web/JavaScript/Guide/Le_protocole_itérateur_historique)
+
+### Générateurs ES2015
+
+- {{jsxref("Fonctions", "Fonctions", "", 1)}}
+- {{jsxref("Instructions/function", "function")}}
+- L'expression {{jsxref("L_opérateur_function", "function")}}
+- {{jsxref("Function")}}
+- {{jsxref("Instructions/function*", "function*")}}
+- L'expression {{jsxref("Opérateurs/function*", "function*")}}
+- {{jsxref("GeneratorFunction")}}
+- [Le protocole Iterator](/fr/docs/Web/JavaScript/Guide/Le_protocole_iterator)
diff --git a/files/fr/web/javascript/reference/global_objects/generator/next/index.md b/files/fr/web/javascript/reference/global_objects/generator/next/index.md
index f88fc2d356..098448211a 100644
--- a/files/fr/web/javascript/reference/global_objects/generator/next/index.md
+++ b/files/fr/web/javascript/reference/global_objects/generator/next/index.md
@@ -11,43 +11,38 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Generator/next
 original_slug: Web/JavaScript/Reference/Objets_globaux/Generator/next
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>next</strong></code><strong><code>()</code></strong> renvoie un objet possédant deux propriétés <code>done</code> et <code>value</code>. Cette méthode peut également recevoir un paramètre pour envoyer une valeur au générateur.</p>
+La méthode **`next`\*\***`()`\*\* renvoie un objet possédant deux propriétés `done` et `value`. Cette méthode peut également recevoir un paramètre pour envoyer une valeur au générateur.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>gen</var>.next(<var>valeur</var>)</pre>
+    gen.next(valeur)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>valeur</code></dt>
- <dd>La valeur à envoyer au générateur. La valeur sera affectée comme résultat d'une expression <code>yield</code>. Autrement dit, lorsque le générateur contient une expression de la forme <code>variable = yield expression</code>, c'est l'argument <code>valeur</code> qui sera affecté à <code>variable</code><em>.</em></dd>
-</dl>
+- `valeur`
+  - : La valeur à envoyer au générateur. La valeur sera affectée comme résultat d'une expression `yield`. Autrement dit, lorsque le générateur contient une expression de la forme `variable = yield expression`, c'est l'argument `valeur` qui sera affecté à `variable`_._
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un {{jsxref("Object")}} possédant deux propriétés :</p>
+Un {{jsxref("Object")}} possédant deux propriétés :
 
-<ul>
- <li><code>done</code> (un booléen)
+- `done` (un booléen)
 
-  <ul>
-   <li>vaut <code>true</code> si l'itérateur a atteint la fin de la série sur laquelle il itère. Dans ce cas, la propriété <code>value</code> définit la valeur de retour pour l'itérateur.</li>
-   <li>vaut <code>false</code> si l'itérateur a pu fournir la prochaine valeur de la série. C'est la valeur par défaut si la propriété <code>done</code> n'est pas définie.</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>
+  - vaut `true` si l'itérateur a atteint la fin de la série sur laquelle il itère. Dans ce cas, la propriété `value` définit la valeur de retour pour l'itérateur.
+  - vaut `false` si l'itérateur a pu fournir la prochaine valeur de la série. C'est la valeur par défaut si la propriété `done` n'est pas définie.
 
-<h2 id="Exemples">Exemples</h2>
+- `value` - n'importe quelle valeur JavaScript renvoyée par l'itérateur. Cette propriété peut être absente lorsque `done` vaut `true`.
 
-<h3 id="Utiliser_next()">Utiliser <code>next()</code></h3>
+## Exemples
 
-<p>L'exemple suivant illustre comment utiliser un générateur simple et les objets renvoyés par la méthode <code>next</code> :</p>
+### Utiliser `next()`
 
-<pre class="brush: js">function* gen() {
+L'exemple suivant illustre comment utiliser un générateur simple et les objets renvoyés par la méthode `next` :
+
+```js
+function* gen() {
   yield 1;
   yield 2;
   yield 3;
@@ -58,13 +53,14 @@ g.next();      // "Object { value: 1, done: false }"
 g.next();      // "Object { value: 2, done: false }"
 g.next();      // "Object { value: 3, done: false }"
 g.next();      // "Object { value: undefined, done: true }"
-</pre>
+```
 
-<h3 id="Envoyer_des_valeurs_à_un_générateur">Envoyer des valeurs à un générateur</h3>
+### Envoyer des valeurs à un générateur
 
-<p>Ici, <code>next</code> est appelé avec une valeur. On notera ici que le premier appel n'affiche rien car le générateur n'a encore rien généré.</p>
+Ici, `next` est appelé avec une valeur. On notera ici que le premier appel n'affiche rien car le générateur n'a encore rien généré.
 
-<pre class="brush: js">function* gen() {
+```js
+function* gen() {
   while(true) {
     var value = yield null;
     console.log(value);
@@ -77,37 +73,20 @@ g.next(1);
 g.next(2);
 // 2
 // "{ value: null, done: 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('ES2015', '#sec-generator.prototype.next', 'Generator.prototype.next')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-generator.prototype.next', 'Generator.prototype.next')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Generator.next")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Instructions/function*","function*")}}</li>
- <li><a href="/fr/docs/Web/JavaScript/Guide/iterateurs_et_generateurs">Les itérateurs et générateurs</a></li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                    | État                         | Commentaires         |
+| ---------------------------------------------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ES2015', '#sec-generator.prototype.next', 'Generator.prototype.next')}} | {{Spec2('ES2015')}}     | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-generator.prototype.next', 'Generator.prototype.next')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Generator.next")}}
+
+## Voir aussi
+
+- {{jsxref("Instructions/function*","function*")}}
+- [Les itérateurs et générateurs](/fr/docs/Web/JavaScript/Guide/iterateurs_et_generateurs)
diff --git a/files/fr/web/javascript/reference/global_objects/generator/return/index.md b/files/fr/web/javascript/reference/global_objects/generator/return/index.md
index 3ddfa7f463..6beafe949c 100644
--- a/files/fr/web/javascript/reference/global_objects/generator/return/index.md
+++ b/files/fr/web/javascript/reference/global_objects/generator/return/index.md
@@ -11,32 +11,31 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Generator/return
 original_slug: Web/JavaScript/Reference/Objets_globaux/Generator/return
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>return</strong></code><strong><code>()</code></strong> renvoie la valeur fournie et termine le générateur.</p>
+La méthode **`return`\*\***`()`\*\* renvoie la valeur fournie et termine le générateur.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>gen</var>.return(<var>valeur</var>)</pre>
+    gen.return(valeur)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>valeur</code></dt>
- <dd>La valeur à renvoyer</dd>
-</dl>
+- `valeur`
+  - : La valeur à renvoyer
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>La valeur fournie comme argument.</p>
+La valeur fournie comme argument.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_return()">Utiliser <code>return()</code></h3>
+### Utiliser `return()`
 
-<p>L'exemple suivant illustre une utilisation simple d'un générateur et de la méthode <code>return()</code>.</p>
+L'exemple suivant illustre une utilisation simple d'un générateur et de la méthode `return()`.
 
-<pre class="brush: js">function* gen() {
+```js
+function* gen() {
   yield 1;
   yield 2;
   yield 3;
@@ -47,55 +46,36 @@ var g = gen();
 g.next();         // { value: 1, done: false }
 g.return("toto"); // { value: "toto", done: true }
 g.next();         // { value: undefined, done: true }
-</pre>
-
-<div class="note">
-<p><strong>Note :</strong> Si <code>done</code> vaut <code>true</code>, <code>return(valeur)</code> renverra la même chose que <code>next()</code> : <code>undefined</code>. Si aucun argument n'est fourni, la propriété <code>value</code> de l'objet renvoyé sera la même qu'avec un appel à <code>.next()</code>. Si un argument est fourni, c'est lui qui sera utilisé comme valeur pour l'attribut <code>value</code> du résultat.</p>
-
-<pre class="brush: js">function* gen() {
-  yield 1;
-  yield 2;
-  yield 3;
-}
-var g = gen();
-console.log(g.next()); // { value: 1; done: false}
-console.log(g.next()); // { value: 2; done: false}
-console.log(g.next()); // { value: 3; done: false}
-console.log(g.next()); // { value: undefined; done: true}
-console.log(g.return()); // { value: undefined; done: true}
-console.log(g.return(1)); // { value: 1; done: true}
-
-</pre>
-</div>
-
-<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-generator.prototype.return', 'Generator.prototype.return')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-generator.prototype.return', 'Generator.prototype.return')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Generator.return")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li><code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/function*">function*</a></code></li>
-</ul>
+```
+
+> **Note :** Si `done` vaut `true`, `return(valeur)` renverra la même chose que `next()` : `undefined`. Si aucun argument n'est fourni, la propriété `value` de l'objet renvoyé sera la même qu'avec un appel à `.next()`. Si un argument est fourni, c'est lui qui sera utilisé comme valeur pour l'attribut `value` du résultat.
+>
+> ```js
+> function* gen() {
+>   yield 1;
+>   yield 2;
+>   yield 3;
+> }
+> var g = gen();
+> console.log(g.next()); // { value: 1; done: false}
+> console.log(g.next()); // { value: 2; done: false}
+> console.log(g.next()); // { value: 3; done: false}
+> console.log(g.next()); // { value: undefined; done: true}
+> console.log(g.return()); // { value: undefined; done: true}
+> console.log(g.return(1)); // { value: 1; done: true}
+> ```
+
+## Spécifications
+
+| Spécification                                                                                                        | État                         | Commentaires         |
+| -------------------------------------------------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ES2015', '#sec-generator.prototype.return', 'Generator.prototype.return')}} | {{Spec2('ES2015')}}     | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-generator.prototype.return', 'Generator.prototype.return')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Generator.return")}}
+
+## Voir aussi
+
+- [`function*`](/fr/docs/Web/JavaScript/Reference/Instructions/function*)
diff --git a/files/fr/web/javascript/reference/global_objects/generator/throw/index.md b/files/fr/web/javascript/reference/global_objects/generator/throw/index.md
index 547c877869..42d63db17b 100644
--- a/files/fr/web/javascript/reference/global_objects/generator/throw/index.md
+++ b/files/fr/web/javascript/reference/global_objects/generator/throw/index.md
@@ -11,43 +11,38 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Generator/throw
 original_slug: Web/JavaScript/Reference/Objets_globaux/Generator/throw
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>throw</strong></code><strong><code>()</code></strong> lève une erreur dans un générateur.</p>
+La méthode **`throw`\*\***`()`\*\* lève une erreur dans un générateur.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>gen</var>.throw(<var>exception</var>)</pre>
+    gen.throw(exception)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>exception</code></dt>
- <dd>L'exception à lever. On préfèrera généralement utiliser un objet qui est une instance d'{{jsxref("Error")}}.</dd>
-</dl>
+- `exception`
+  - : L'exception à lever. On préfèrera généralement utiliser un objet qui est une instance d'{{jsxref("Error")}}.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un {{jsxref("Object")}} avec deux propriétés :</p>
+Un {{jsxref("Object")}} avec deux propriétés :
 
-<ul>
- <li><code>done</code> (un booléen)
+- `done` (un booléen)
 
-  <ul>
-   <li>Qui vaut <code>true</code> lorsque l'itérateur a fini de parcourir la suite. Dans ce cas, <code>value</code> correspondra éventuellement à la valeur de retour de l'itérateur.</li>
-   <li>Qui vaut <code>false</code> si l'itérateur a pu produire la prochaine valeur de la série.</li>
-  </ul>
- </li>
- <li><code>value</code> : une valeur renvoyée par l'itérateur. Lorsque <code>done</code> vaut <code>true</code>, cette valeur peut être absente ou valoir <code>undefined</code>.</li>
-</ul>
+  - Qui vaut `true` lorsque l'itérateur a fini de parcourir la suite. Dans ce cas, `value` correspondra éventuellement à la valeur de retour de l'itérateur.
+  - Qui vaut `false` si l'itérateur a pu produire la prochaine valeur de la série.
 
-<h2 id="Exemples">Exemples</h2>
+- `value` : une valeur renvoyée par l'itérateur. Lorsque `done` vaut `true`, cette valeur peut être absente ou valoir `undefined`.
 
-<h3 id="Utiliser_throw()">Utiliser <code>throw()</code></h3>
+## Exemples
 
-<p>Dans l'exemple suivant, on utilise un générateur simple et on génère une exception grâce à la méthode <code>throw()</code>. Une exception peut être interceptée avec un bloc {{jsxref("Instructions/try...catch","try...catch")}} usuel.</p>
+### Utiliser `throw()`
 
-<pre class="brush: js">function* gen() {
+Dans l'exemple suivant, on utilise un générateur simple et on génère une exception grâce à la méthode `throw()`. Une exception peut être interceptée avec un bloc {{jsxref("Instructions/try...catch","try...catch")}} usuel.
+
+```js
+function* gen() {
   while(true) {
     try {
        yield 42;
@@ -63,36 +58,19 @@ g.next();
 g.throw(new Error("Quelque chose s'est mal passé"));
 // "Erreur interceptée !"
 // { value: 42, done: false }
-</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('ES2015', '#sec-generator.prototype.throw', 'Generator.prototype.throw')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-generator.prototype.throw', 'Generator.prototype.throw')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Generator.throw")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Instructions/function*","function*")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                        | Statut                       | Commentaires         |
+| -------------------------------------------------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ES2015', '#sec-generator.prototype.throw', 'Generator.prototype.throw')}}     | {{Spec2('ES2015')}}     | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-generator.prototype.throw', 'Generator.prototype.throw')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Generator.throw")}}
+
+## Voir aussi
+
+- {{jsxref("Instructions/function*","function*")}}
diff --git a/files/fr/web/javascript/reference/global_objects/generatorfunction/index.md b/files/fr/web/javascript/reference/global_objects/generatorfunction/index.md
index 8f92be2961..f9faec0967 100644
--- a/files/fr/web/javascript/reference/global_objects/generatorfunction/index.md
+++ b/files/fr/web/javascript/reference/global_objects/generatorfunction/index.md
@@ -11,102 +11,81 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/GeneratorFunction
 original_slug: Web/JavaScript/Reference/Objets_globaux/GeneratorFunction
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>Le constructeur <strong><code>GeneratorFunction</code></strong> permet de créer un nouvel objet qui est une {{jsxref("Instructions/function*", "fonction génératrice","",1)}}. En JavaScript, chaque générateur (ou fonction génératrice) est un objet <code>GeneratorFunction</code>.</p>
+Le constructeur **`GeneratorFunction`** permet de créer un nouvel objet qui est une {{jsxref("Instructions/function*", "fonction génératrice","",1)}}. En JavaScript, chaque générateur (ou fonction génératrice) est un objet `GeneratorFunction`.
 
-<p>L'objet <code>GeneratorFunction</code> n'est pas un objet global. Il peut être obtenu en exécutant le code suivant :</p>
+L'objet `GeneratorFunction` n'est pas un objet global. Il peut être obtenu en exécutant le code suivant :
 
-<pre class="brush: js">Object.getPrototypeOf(function*(){}).constructor
-</pre>
+```js
+Object.getPrototypeOf(function*(){}).constructor
+```
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">new GeneratorFunction ([<var>arg1</var>[, <var>arg2</var>[, ...<var>argN</var>]],] corpsFonction)</pre>
+    new GeneratorFunction ([arg1[, arg2[, ...argN]],] corpsFonction)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>arg1, arg2, ... arg<em>N</em></code></dt>
- <dd>Les noms à utiliser pour les arguments formellement déclarés. Chacun doit être une chaîne de caractères correspondant à un identifiant JavaScript valide ou une liste de telles chaînes séparées par des virgules. Par exemple, on peut avoir "<code>x</code>", "<code>maValeur</code>", ou "<code>a,b</code>".</dd>
- <dt><code>corpsFonction</code></dt>
- <dd>Une chaîne qui contient les instructions JavaScript qui composent la définition de la fonction.</dd>
-</dl>
+- `arg1, arg2, ... argN`
+  - : Les noms à utiliser pour les arguments formellement déclarés. Chacun doit être une chaîne de caractères correspondant à un identifiant JavaScript valide ou une liste de telles chaînes séparées par des virgules. Par exemple, on peut avoir "`x`", "`maValeur`", ou "`a,b`".
+- `corpsFonction`
+  - : Une chaîne qui contient les instructions JavaScript qui composent la définition de la fonction.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Les {{jsxref("Instructions/function*", "fonctions génératrices","",1)}} créées avec le constructeur <code>GeneratorFunction</code> sont analysés lorsque la fonction est crée. Cela est moins efficace que de déclarer un générateur avec une expression {{jsxref("Statements/function*", "function*")}} puis de l'appeler car ces fonctions sont analysées avec le reste du code (ce qui permet au moteur JavaScript d'effectuer certaines optimisations).</p>
+Les {{jsxref("Instructions/function*", "fonctions génératrices","",1)}} créées avec le constructeur `GeneratorFunction` sont analysés lorsque la fonction est crée. Cela est moins efficace que de déclarer un générateur avec une expression {{jsxref("Statements/function*", "function*")}} puis de l'appeler car ces fonctions sont analysées avec le reste du code (ce qui permet au moteur JavaScript d'effectuer certaines optimisations).
 
-<p>Tous les arguments passés à la fonction sont traités par la suite avec les noms des identifiants utilisés pour les noms des paramètres lors de la création de la fonction et avec cet ordre là.</p>
+Tous les arguments passés à la fonction sont traités par la suite avec les noms des identifiants utilisés pour les noms des paramètres lors de la création de la fonction et avec cet ordre là.
 
-<div class="note">
-<p><strong>Note :</strong> Les {{jsxref("Instructions/function*", "générateurs","",1)}} créés avec le constructeur <code>GeneratorFunction</code> ne créent pas de fermetures avec leurs contextes de création. Ils sont toujours créés dans la portée globale. Lorsqu'ils sont exécutés, ils n'ont accès qu'à leurs variables locales et aux variables globales et ils n'ont pas accès aux variables de la portée où a eu lieu l'appel à <code>GeneratorFunction</code>. Ce comportement est différent de celui obtenu lorsqu'on appelle {{jsxref("Objets_globaux/eval", "eval")}} avec du code correspondant à une expression de générateur.</p>
-</div>
+> **Note :** Les {{jsxref("Instructions/function*", "générateurs","",1)}} créés avec le constructeur `GeneratorFunction` ne créent pas de fermetures avec leurs contextes de création. Ils sont toujours créés dans la portée globale. Lorsqu'ils sont exécutés, ils n'ont accès qu'à leurs variables locales et aux variables globales et ils n'ont pas accès aux variables de la portée où a eu lieu l'appel à `GeneratorFunction`. Ce comportement est différent de celui obtenu lorsqu'on appelle {{jsxref("Objets_globaux/eval", "eval")}} avec du code correspondant à une expression de générateur.
 
-<p>L'appel du constructeur <code>GeneratorFunction</code> comme fonction (c'est-à-dire sans utiliser l'opérateur <code>new</code>) aura le même effet que si celui-ci est invoqué comme constructeur.</p>
+L'appel du constructeur `GeneratorFunction` comme fonction (c'est-à-dire sans utiliser l'opérateur `new`) aura le même effet que si celui-ci est invoqué comme constructeur.
 
-<h2 id="Propriétés">Propriétés</h2>
+## Propriétés
 
-<dl>
- <dt><code><strong>GeneratorFunction.length</strong></code></dt>
- <dd>La propriété de longueur du constructeur <code>GeneratorFunction</code> qui vaut 1.</dd>
- <dt>{{jsxref("GeneratorFunction.prototype")}}</dt>
- <dd>Le prototype du constructeur qui permet d'ajouter des propriétés à tous les générateurs.</dd>
-</dl>
+- **`GeneratorFunction.length`**
+  - : La propriété de longueur du constructeur `GeneratorFunction` qui vaut 1.
+- {{jsxref("GeneratorFunction.prototype")}}
+  - : Le prototype du constructeur qui permet d'ajouter des propriétés à tous les générateurs.
 
-<h2 id="Le_prototype_de_GeneratorFunction">Le prototype de <code>GeneratorFunction</code></h2>
+## Le prototype de `GeneratorFunction`
 
-<h3 id="Propriétés_2">Propriétés</h3>
+### Propriétés
 
-<div>{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/GeneratorFunction/prototype', 'Properties')}}</div>
+{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/GeneratorFunction/prototype', 'Properties')}}
 
-<h2 id="Les_instances_de_GeneratorFunction">Les instances de <code>GeneratorFunction</code></h2>
+## Les instances de `GeneratorFunction`
 
-<p>Les instances de <code>GeneratorFunction</code> héritent des méthodes et propriétés de {{jsxref("GeneratorFunction.prototype")}}. Comme pour tous les constructeurs, il est possible de modifier le prototype afin d'apporter des modifications à toutes les instances de <code>GeneratorFunction</code>.</p>
+Les instances de `GeneratorFunction` héritent des méthodes et propriétés de {{jsxref("GeneratorFunction.prototype")}}. Comme pour tous les constructeurs, il est possible de modifier le prototype afin d'apporter des modifications à toutes les instances de `GeneratorFunction`.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Créer_un_générateur_en_utilisant_le_constructeur_GeneratorFunction">Créer un générateur en utilisant le constructeur <code>GeneratorFunction</code></h3>
+### Créer un générateur en utilisant le constructeur `GeneratorFunction`
 
-<pre class="brush: js">var GeneratorFunction = Object.getPrototypeOf(function*(){}).constructor
+```js
+var GeneratorFunction = Object.getPrototypeOf(function*(){}).constructor
 var g = new GeneratorFunction("a", "yield a * 2");
 var itérateur = g(10);
 console.log(itérateur.next().value); // 20
-</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('ES2015', '#sec-generatorfunction-objects', 'GeneratorFunction')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-generatorfunction-objects', 'GeneratorFunction')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.GeneratorFunction")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>L'instruction {{jsxref("Instructions/function*", "function*")}}</li>
- <li>L'expression {{jsxref("Opérateurs/function*", "function*")}}</li>
- <li>{{jsxref("Function")}}</li>
- <li>L'instruction {{jsxref("Instructions/function", "function")}}</li>
- <li>L'expression {{jsxref("Opérateurs/L_opérateur_function", "function")}}</li>
- <li>{{jsxref("Fonctions", "Les fonctions et portées de fonctions", "", 1)}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                            | Statut                       | Commentaires         |
+| -------------------------------------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ES2015', '#sec-generatorfunction-objects', 'GeneratorFunction')}} | {{Spec2('ES2015')}}     | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-generatorfunction-objects', 'GeneratorFunction')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.GeneratorFunction")}}
+
+## Voir aussi
+
+- L'instruction {{jsxref("Instructions/function*", "function*")}}
+- L'expression {{jsxref("Opérateurs/function*", "function*")}}
+- {{jsxref("Function")}}
+- L'instruction {{jsxref("Instructions/function", "function")}}
+- L'expression {{jsxref("Opérateurs/L_opérateur_function", "function")}}
+- {{jsxref("Fonctions", "Les fonctions et portées de fonctions", "", 1)}}
diff --git a/files/fr/web/javascript/reference/global_objects/globalthis/index.md b/files/fr/web/javascript/reference/global_objects/globalthis/index.md
index 428d089b96..4a6721b390 100644
--- a/files/fr/web/javascript/reference/global_objects/globalthis/index.md
+++ b/files/fr/web/javascript/reference/global_objects/globalthis/index.md
@@ -8,39 +8,39 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/globalThis
 original_slug: Web/JavaScript/Reference/Objets_globaux/globalThis
 ---
-<div>{{jsSidebar("Objects")}}</div>
+{{jsSidebar("Objects")}}
 
-<p>La propriété globale <code><strong>globalThis</strong></code> renvoie l'objet global de plus haut niveau.</p>
+La propriété globale **`globalThis`** renvoie l'objet global de plus haut niveau.
 
-<div>{{EmbedInteractiveExample("pages/js/globalprops-globalthis.html")}}</div>
+{{EmbedInteractiveExample("pages/js/globalprops-globalthis.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><code>globalThis</code>
-</pre>
+    globalThis
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Par le passé, il était nécessaire d'utiliser différentes syntaxes pour différents environnements afin d'accéder à la portée globale. Sur le Web, on peut utiliser {{domxref("Window.window", "window")}}, {{domxref("Window.self", "self")}} ou {{domxref("Window.frames", "frames")}} ; pour les <a href="/en-US/docs/Web/API/Worker">web workers</a>, seul <code>self</code> peut être employé ; pour Node.js aucun de ces mots-clés ne fonctionne et il faut utiliser <code>global</code>.<br>
- Le mot-clé <code>this</code> pouvait être utilisé à l'intérieur des fonctions en <a href="/fr/docs/Web/JavaScript/Reference/Strict_mode">mode non-strict</a> mais vaudra sinon <code>undefined</code> dans les modules et dans les fonctions utilisant le <a href="/fr/docs/Web/JavaScript/Reference/Strict_mode">mode strict</a>.</p>
+Par le passé, il était nécessaire d'utiliser différentes syntaxes pour différents environnements afin d'accéder à la portée globale. Sur le Web, on peut utiliser {{domxref("Window.window", "window")}}, {{domxref("Window.self", "self")}} ou {{domxref("Window.frames", "frames")}} ; pour les [web workers](/en-US/docs/Web/API/Worker), seul `self` peut être employé ; pour Node.js aucun de ces mots-clés ne fonctionne et il faut utiliser `global`.
+Le mot-clé `this` pouvait être utilisé à l'intérieur des fonctions en [mode non-strict](/fr/docs/Web/JavaScript/Reference/Strict_mode) mais vaudra sinon `undefined` dans les modules et dans les fonctions utilisant le [mode strict](/fr/docs/Web/JavaScript/Reference/Strict_mode).
 
-<p>La propriété <code>globalThis</code> fournit une méthode standard d'accès à l'objet <code>this</code> global, quel que soit l'environnement. Contrairement aux propriétés <code>window</code> et <code>self</code>, ce mot-clé fonctionnera quel que soit le contexte (que celui-ci soit doté de fenêtres ou non). Ainsi, on peut accéder à l'objet global de façon homogène, quel que soit l'environnement dans lequel le code est utilisé.</p>
+La propriété `globalThis` fournit une méthode standard d'accès à l'objet `this` global, quel que soit l'environnement. Contrairement aux propriétés `window` et `self`, ce mot-clé fonctionnera quel que soit le contexte (que celui-ci soit doté de fenêtres ou non). Ainsi, on peut accéder à l'objet global de façon homogène, quel que soit l'environnement dans lequel le code est utilisé.
 
-<p>Pour mieux mémoriser ce nom, on se rappellera que la valeur de <code>this</code> dans la portée globale est <code>globalThis</code>.</p>
+Pour mieux mémoriser ce nom, on se rappellera que la valeur de `this` dans la portée globale est `globalThis`.
 
-<h3 id="Accès_indirect_à_la_variable_globale_dans_un_contexte_web">Accès indirect à la variable globale dans un contexte web</h3>
+### Accès indirect à la variable globale dans un contexte web
 
-<p>Dans la plupart des environnements, <code>globalThis</code> sera une référence directe à l'objet global. Cependant, dans les navigateurs web, avec les principes de sécurité relatifs aux <em>iframes</em> et aux liens entre les fenêtres, <code>globalThis</code> fournira un {{jsxref("Proxy")}} sur l'objet global (auquel on n'aura donc pas accès directement).</p>
+Dans la plupart des environnements, `globalThis` sera une référence directe à l'objet global. Cependant, dans les navigateurs web, avec les principes de sécurité relatifs aux _iframes_ et aux liens entre les fenêtres, `globalThis` fournira un {{jsxref("Proxy")}} sur l'objet global (auquel on n'aura donc pas accès directement).
 
-<h3 id="Nommage">Nommage</h3>
+### Nommage
 
-<p>D'autres noms furent proposés pour cette fonctionnalité (tels que <code>self</code> et <code>global</code>) mais ils furent écartés car ils pouvaient entraîner des problèmes de compatibilité avec du code existant. Pour plus de détails, voir <a href="https://github.com/tc39/proposal-global/blob/master/NAMING.md">le document de la proposition pour le nommage</a>.</p>
+D'autres noms furent proposés pour cette fonctionnalité (tels que `self` et `global`) mais ils furent écartés car ils pouvaient entraîner des problèmes de compatibilité avec du code existant. Pour plus de détails, voir [le document de la proposition pour le nommage](https://github.com/tc39/proposal-global/blob/master/NAMING.md).
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<p>Avant l'introduction de <code>globalThis</code>, la seule façon qui permettait d'obtenir l'objet global de l'environnement de façon homogène était <code>Function('return this')()</code>. Toutefois, cela enfreignait certaines règles <a href="/fr/docs/Web/HTTP/CSP">CSP</a> avec certains réglages et <a href="https://github.com/paulmillr/es6-shim">es6-shim</a>, par exemple, devait utiliser une logique conditionnelle :</p>
+Avant l'introduction de `globalThis`, la seule façon qui permettait d'obtenir l'objet global de l'environnement de façon homogène était `Function('return this')()`. Toutefois, cela enfreignait certaines règles [CSP](/fr/docs/Web/HTTP/CSP) avec certains réglages et [es6-shim](https://github.com/paulmillr/es6-shim), par exemple, devait utiliser une logique conditionnelle :
 
-<pre class="brush: js">var getGlobal = function () {
+```js
+var getGlobal = function () {
   if (typeof self !== 'undefined') { return self; }
   if (typeof window !== 'undefined') { return window; }
   if (typeof global !== 'undefined') { return global; }
@@ -52,33 +52,22 @@ var globals = getGlobal();
 if (typeof globals.setTimeout !== 'function') {
   // pas de setTimeout pour cet environnement
 }
-</pre>
+```
 
-<p>Avec <code>globalThis</code>, il n'est plus nécessaire de parcourir les différents mots-clés des différents environnements :</p>
+Avec `globalThis`, il n'est plus nécessaire de parcourir les différents mots-clés des différents environnements :
 
-<pre class="brush: js">if (typeof globalThis.setTimeout !== 'function') {
+```js
+if (typeof globalThis.setTimeout !== 'function') {
   // pas de setTimeout pour cet environnement
-}</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><a href="https://tc39.github.io/proposal-global/#sec-other-properties-of-the-global-object-global">Proposition pour <code>globalThis</code></a></td>
-   <td>Proposition de niveau 3 (<em>stage 3</em>)</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.globalThis")}}</p>
+}
+```
+
+## Spécifications
+
+| Spécification                                                                                                             | État                                | Commentaires |
+| ------------------------------------------------------------------------------------------------------------------------- | ----------------------------------- | ------------ |
+| [Proposition pour `globalThis`](https://tc39.github.io/proposal-global/#sec-other-properties-of-the-global-object-global) | Proposition de niveau 3 (_stage 3_) |              |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.globalThis")}}
diff --git a/files/fr/web/javascript/reference/global_objects/index.md b/files/fr/web/javascript/reference/global_objects/index.md
index b8eb0beaa1..0c2020b20d 100644
--- a/files/fr/web/javascript/reference/global_objects/index.md
+++ b/files/fr/web/javascript/reference/global_objects/index.md
@@ -8,179 +8,151 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects
 original_slug: Web/JavaScript/Reference/Objets_globaux
 ---
-<div>{{jsSidebar("Objects")}}</div>
-
-<p>Cette partie référence tous les objets natifs standards JavaScript, avec leurs propriétés et méthodes.</p>
-
-<p>Le terme « objets globaux » (ou objets natifs standards) ne doit pas ici être confondu avec l<em>'objet global</em>. Ici, « objets globaux » se réfère aux <em>objets de portée globale</em>. L'objet global lui-même peut être accédé en utilisant {{jsxref("Opérateurs/L_opérateur_this", "this")}} dans la portée globale (uniquement lorsque <a href="/fr/docs/Web/JavaScript/Reference/Strict_mode">le mode strict</a> n'est pas utilisé, sinon, il renvoie {{jsxref("undefined")}}). En réalité, la portée globale <em>consiste des</em> propriétés de l'objet global (avec ses propriétés héritées, s'il en a).</p>
-
-<div class="note">
-<p><strong>Note :</strong> En <a href="/fr/docs/Web/JavaScript/Reference/Strict_mode">mode strict</a>, la portée globale représentée par <code>this</code> sera {{jsxref("undefined")}}.</p>
-</div>
-
-<p>Les autres objets de la portée globale sont <a href="/fr/docs/Web/JavaScript/Guide/Utiliser_les_objets#Cr.C3.A9er_de_nouveaux_objets">créés par les scripts utilisateurs</a> ou fournis par l'application hôte dans laquelle s'exécute JavaScript. Les objets mis à disposition par les navigateurs web sont documentés dans la <a href="/fr/docs/Web/API">référence API</a>. Pour plus d'informations sur la distinction entre le <a href="/fr/docs/Web/API/R%C3%A9f%C3%A9rence_du_DOM_Gecko">DOM</a> et JavaScript, voir <a href="/fr/docs/Web/JavaScript/JavaScript_technologies_overview">l'aperçu des technologies JavaScript</a>.</p>
-
-<h2 id="Objets_globaux_standards_(par_catégorie)">Objets globaux standards (par catégorie)</h2>
-
-<h3 id="Propriétés_-_valeurs">Propriétés - valeurs</h3>
-
-<p>Les propriétés globales renvoient une valeur simple, elles ne possèdent aucune propriété ou méthode :</p>
-
-<ul>
- <li>{{jsxref("Infinity")}}</li>
- <li>{{jsxref("NaN")}}</li>
- <li>{{jsxref("undefined")}}</li>
- <li>le littéral {{jsxref("null")}}</li>
- <li>{{JSxRef("globalThis")}}</li>
-</ul>
-
-<h3 id="Propriétés_-_fonctions">Propriétés - fonctions</h3>
-
-<p>Les fonctions globales, appelées globalement (et non par rapport à un objet), renvoient directement leur résultat à l'objet appelant.</p>
-
-<ul>
- <li>{{jsxref("Objets_globaux/eval", "eval()")}}</li>
- <li>{{jsxref("Objets_globaux/uneval", "uneval()")}} {{non-standard_inline()}}</li>
- <li>{{jsxref("Objets_globaux/isFinite", "isFinite()")}}</li>
- <li>{{jsxref("Objets_globaux/isNaN", "isNaN()")}}</li>
- <li>{{jsxref("Objets_globaux/parseFloat", "parseFloat()")}}</li>
- <li>{{jsxref("Objets_globaux/parseInt", "parseInt()")}}</li>
- <li>{{jsxref("Objets_globaux/decodeURI", "decodeURI()")}}</li>
- <li>{{jsxref("Objets_globaux/decodeURIComponent", "decodeURIComponent()")}}</li>
- <li>{{jsxref("Objets_globaux/encodeURI", "encodeURI()")}}</li>
- <li>{{jsxref("Objets_globaux/encodeURIComponent", "encodeURIComponent()")}}</li>
- <li>{{jsxref("Objets_globaux/escape", "escape()")}} {{deprecated_inline()}}</li>
- <li>{{jsxref("Objets_globaux/unescape", "unescape()")}} {{deprecated_inline()}}</li>
-</ul>
-
-<h3 id="Objets_fondamentaux">Objets fondamentaux</h3>
+{{jsSidebar("Objects")}}
 
-<p>Ces objets sont les objets fondamentaux de JavaScript. Parmi ces objets, on retrouve les objets génériques, les fonctions et les erreurs.</p>
-
-<ul>
- <li>{{jsxref("Object")}}</li>
- <li>{{jsxref("Function")}}</li>
- <li>{{jsxref("Boolean")}}</li>
- <li>{{jsxref("Symbol")}}</li>
- <li>{{jsxref("Error")}}</li>
- <li>{{jsxref("EvalError")}}</li>
- <li>{{jsxref("InternalError")}} {{Non-standard_Inline}}</li>
- <li>{{jsxref("RangeError")}}</li>
- <li>{{jsxref("ReferenceError")}}</li>
- <li>{{jsxref("StopIteration")}}</li>
- <li>{{jsxref("SyntaxError")}}</li>
- <li>{{jsxref("TypeError")}}</li>
- <li>{{jsxref("URIError")}}</li>
-</ul>
-
-<h3 id="Nombres_et_dates">Nombres et dates</h3>
-
-<p>Ces objets permettent de manipuler les nombres, dates et calculs mathématiques.</p>
-
-<ul>
- <li>{{jsxref("Number")}}</li>
- <li>{{JSxRef("BigInt")}}</li>
- <li>{{jsxref("Math")}}</li>
- <li>{{jsxref("Date")}}</li>
-</ul>
-
-<h3 id="Manipulation_de_textes">Manipulation de textes</h3>
-
-<p>Ces objets permettent de manipuler des chaînes de caractères.</p>
-
-<ul>
- <li>{{jsxref("String")}}</li>
- <li>{{jsxref("RegExp")}}</li>
-</ul>
-
-<h3 id="Collections_indexées">Collections indexées</h3>
-
-<p>Ces objets sont des collections ordonnées par un index. Cela inclut les tableaux (typés) et les objets semblables aux tableaux.</p>
-
-<ul>
- <li>{{jsxref("Array")}}</li>
- <li>{{jsxref("Int8Array")}}</li>
- <li>{{jsxref("Uint8Array")}}</li>
- <li>{{jsxref("Uint8ClampedArray")}}</li>
- <li>{{jsxref("Int16Array")}}</li>
- <li>{{jsxref("Uint16Array")}}</li>
- <li>{{jsxref("Int32Array")}}</li>
- <li>{{jsxref("Uint32Array")}}</li>
- <li>{{jsxref("Float32Array")}}</li>
- <li>{{jsxref("Float64Array")}}</li>
- <li>{{jsxref("BigInt64Array")}}</li>
- <li>{{jsxref("BigUint64Array")}}</li>
-</ul>
-
-<h3 id="Collections_avec_clefs">Collections avec clefs</h3>
-
-<p>Ces objets représentent des collections d'objets avec clefs. Ils contiennent des éléments itérables, dans leur ordre d'insertion.</p>
-
-<ul>
- <li>{{jsxref("Map")}}</li>
- <li>{{jsxref("Set")}}</li>
- <li>{{jsxref("WeakMap")}}</li>
- <li>{{jsxref("WeakSet")}}</li>
-</ul>
-
-<h3 id="Données_structurées">Données structurées</h3>
-
-<p>Ces objets permettent de représenter et de manipuler des tampons de données (<em>buffers</em>) et des données utilisant la notation JSON (<strong>J</strong>ava<strong>S</strong>cript <strong>O</strong>bject <strong>N</strong>otation).</p>
-
-<ul>
- <li>{{jsxref("ArrayBuffer")}}</li>
- <li>{{jsxref("SharedArrayBuffer")}} {{experimental_inline}}</li>
- <li>{{jsxref("Atomics")}} {{experimental_inline}}</li>
- <li>{{jsxref("DataView")}}</li>
- <li>{{jsxref("JSON")}}</li>
-</ul>
-
-<h3 id="Objets_de_contrôle_d'abstraction">Objets de contrôle d'abstraction</h3>
-
-<ul>
- <li>{{jsxref("Promise")}}</li>
- <li>{{jsxref("Generator")}}</li>
- <li>{{jsxref("GeneratorFunction")}}</li>
- <li>{{jsxref("AsyncFunction")}}{{experimental_inline}}</li>
-</ul>
-
-<h3 id="Introspection">Introspection</h3>
-
-<ul>
- <li>{{jsxref("Reflect")}}</li>
- <li>{{jsxref("Proxy")}}</li>
-</ul>
-
-<h3 id="Internationalisation">Internationalisation</h3>
-
-<p>Ces objets ont été ajoutés à ECMAScript pour des traitements dépendants de particularités linguistiques. Ils possèdent leur propre spécification.</p>
-
-<ul>
- <li>{{jsxref("Intl")}}</li>
- <li>{{jsxref("Objets_globaux/Collator", "Intl.Collator")}}</li>
- <li>{{jsxref("Objets_globaux/DateTimeFormat", "Intl.DateTimeFormat")}}</li>
- <li>{{JSxRef("Global_Objects/ListFormat", "Intl.ListFormat")}}</li>
- <li>{{jsxref("Objets_globaux/NumberFormat", "Intl.NumberFormat")}}</li>
- <li>{{JSxRef("Global_Objects/PluralRules", "Intl.PluralRules")}}</li>
- <li>{{jsxref("Objets_globaux/RelativeTimeFormat", "Intl.RelativeTimeFormat")}}</li>
- <li>{{jsxref("Objets_globaux/Locale", "Intl.Locale")}}</li>
-</ul>
-
-<h3 id="WebAssembly">WebAssembly</h3>
-
-<ul>
- <li>{{jsxref("WebAssembly")}}</li>
- <li>{{jsxref("WebAssembly.Module")}}</li>
- <li>{{jsxref("WebAssembly.Instance")}}</li>
- <li>{{jsxref("WebAssembly.Memory")}}</li>
- <li>{{jsxref("WebAssembly.Table")}}</li>
- <li>{{jsxref("WebAssembly.CompileError")}}</li>
- <li>{{jsxref("WebAssembly.LinkError")}}</li>
- <li>{{jsxref("WebAssembly.RuntimeError")}}</li>
-</ul>
-
-<h3 id="Autres">Autres</h3>
-
-<ul>
- <li>{{JSxRef("Fonctions/arguments", "arguments")}}</li>
-</ul>
+Cette partie référence tous les objets natifs standards JavaScript, avec leurs propriétés et méthodes.
+
+Le terme « objets globaux » (ou objets natifs standards) ne doit pas ici être confondu avec l*'objet global*. Ici, « objets globaux » se réfère aux _objets de portée globale_. L'objet global lui-même peut être accédé en utilisant {{jsxref("Opérateurs/L_opérateur_this", "this")}} dans la portée globale (uniquement lorsque [le mode strict](/fr/docs/Web/JavaScript/Reference/Strict_mode) n'est pas utilisé, sinon, il renvoie {{jsxref("undefined")}}). En réalité, la portée globale _consiste des_ propriétés de l'objet global (avec ses propriétés héritées, s'il en a).
+
+> **Note :** En [mode strict](/fr/docs/Web/JavaScript/Reference/Strict_mode), la portée globale représentée par `this` sera {{jsxref("undefined")}}.
+
+Les autres objets de la portée globale sont [créés par les scripts utilisateurs](/fr/docs/Web/JavaScript/Guide/Utiliser_les_objets#Cr.C3.A9er_de_nouveaux_objets) ou fournis par l'application hôte dans laquelle s'exécute JavaScript. Les objets mis à disposition par les navigateurs web sont documentés dans la [référence API](/fr/docs/Web/API). Pour plus d'informations sur la distinction entre le [DOM](/fr/docs/Web/API/R%C3%A9f%C3%A9rence_du_DOM_Gecko) et JavaScript, voir [l'aperçu des technologies JavaScript](/fr/docs/Web/JavaScript/JavaScript_technologies_overview).
+
+## Objets globaux standards (par catégorie)
+
+### Propriétés - valeurs
+
+Les propriétés globales renvoient une valeur simple, elles ne possèdent aucune propriété ou méthode :
+
+- {{jsxref("Infinity")}}
+- {{jsxref("NaN")}}
+- {{jsxref("undefined")}}
+- le littéral {{jsxref("null")}}
+- {{JSxRef("globalThis")}}
+
+### Propriétés - fonctions
+
+Les fonctions globales, appelées globalement (et non par rapport à un objet), renvoient directement leur résultat à l'objet appelant.
+
+- {{jsxref("Objets_globaux/eval", "eval()")}}
+- {{jsxref("Objets_globaux/uneval", "uneval()")}} {{non-standard_inline()}}
+- {{jsxref("Objets_globaux/isFinite", "isFinite()")}}
+- {{jsxref("Objets_globaux/isNaN", "isNaN()")}}
+- {{jsxref("Objets_globaux/parseFloat", "parseFloat()")}}
+- {{jsxref("Objets_globaux/parseInt", "parseInt()")}}
+- {{jsxref("Objets_globaux/decodeURI", "decodeURI()")}}
+- {{jsxref("Objets_globaux/decodeURIComponent", "decodeURIComponent()")}}
+- {{jsxref("Objets_globaux/encodeURI", "encodeURI()")}}
+- {{jsxref("Objets_globaux/encodeURIComponent", "encodeURIComponent()")}}
+- {{jsxref("Objets_globaux/escape", "escape()")}} {{deprecated_inline()}}
+- {{jsxref("Objets_globaux/unescape", "unescape()")}} {{deprecated_inline()}}
+
+### Objets fondamentaux
+
+Ces objets sont les objets fondamentaux de JavaScript. Parmi ces objets, on retrouve les objets génériques, les fonctions et les erreurs.
+
+- {{jsxref("Object")}}
+- {{jsxref("Function")}}
+- {{jsxref("Boolean")}}
+- {{jsxref("Symbol")}}
+- {{jsxref("Error")}}
+- {{jsxref("EvalError")}}
+- {{jsxref("InternalError")}} {{Non-standard_Inline}}
+- {{jsxref("RangeError")}}
+- {{jsxref("ReferenceError")}}
+- {{jsxref("StopIteration")}}
+- {{jsxref("SyntaxError")}}
+- {{jsxref("TypeError")}}
+- {{jsxref("URIError")}}
+
+### Nombres et dates
+
+Ces objets permettent de manipuler les nombres, dates et calculs mathématiques.
+
+- {{jsxref("Number")}}
+- {{JSxRef("BigInt")}}
+- {{jsxref("Math")}}
+- {{jsxref("Date")}}
+
+### Manipulation de textes
+
+Ces objets permettent de manipuler des chaînes de caractères.
+
+- {{jsxref("String")}}
+- {{jsxref("RegExp")}}
+
+### Collections indexées
+
+Ces objets sont des collections ordonnées par un index. Cela inclut les tableaux (typés) et les objets semblables aux tableaux.
+
+- {{jsxref("Array")}}
+- {{jsxref("Int8Array")}}
+- {{jsxref("Uint8Array")}}
+- {{jsxref("Uint8ClampedArray")}}
+- {{jsxref("Int16Array")}}
+- {{jsxref("Uint16Array")}}
+- {{jsxref("Int32Array")}}
+- {{jsxref("Uint32Array")}}
+- {{jsxref("Float32Array")}}
+- {{jsxref("Float64Array")}}
+- {{jsxref("BigInt64Array")}}
+- {{jsxref("BigUint64Array")}}
+
+### Collections avec clefs
+
+Ces objets représentent des collections d'objets avec clefs. Ils contiennent des éléments itérables, dans leur ordre d'insertion.
+
+- {{jsxref("Map")}}
+- {{jsxref("Set")}}
+- {{jsxref("WeakMap")}}
+- {{jsxref("WeakSet")}}
+
+### Données structurées
+
+Ces objets permettent de représenter et de manipuler des tampons de données (_buffers_) et des données utilisant la notation JSON (**J**ava**S**cript **O**bject **N**otation).
+
+- {{jsxref("ArrayBuffer")}}
+- {{jsxref("SharedArrayBuffer")}} {{experimental_inline}}
+- {{jsxref("Atomics")}} {{experimental_inline}}
+- {{jsxref("DataView")}}
+- {{jsxref("JSON")}}
+
+### Objets de contrôle d'abstraction
+
+- {{jsxref("Promise")}}
+- {{jsxref("Generator")}}
+- {{jsxref("GeneratorFunction")}}
+- {{jsxref("AsyncFunction")}}{{experimental_inline}}
+
+### Introspection
+
+- {{jsxref("Reflect")}}
+- {{jsxref("Proxy")}}
+
+### Internationalisation
+
+Ces objets ont été ajoutés à ECMAScript pour des traitements dépendants de particularités linguistiques. Ils possèdent leur propre spécification.
+
+- {{jsxref("Intl")}}
+- {{jsxref("Objets_globaux/Collator", "Intl.Collator")}}
+- {{jsxref("Objets_globaux/DateTimeFormat", "Intl.DateTimeFormat")}}
+- {{JSxRef("Global_Objects/ListFormat", "Intl.ListFormat")}}
+- {{jsxref("Objets_globaux/NumberFormat", "Intl.NumberFormat")}}
+- {{JSxRef("Global_Objects/PluralRules", "Intl.PluralRules")}}
+- {{jsxref("Objets_globaux/RelativeTimeFormat", "Intl.RelativeTimeFormat")}}
+- {{jsxref("Objets_globaux/Locale", "Intl.Locale")}}
+
+### WebAssembly
+
+- {{jsxref("WebAssembly")}}
+- {{jsxref("WebAssembly.Module")}}
+- {{jsxref("WebAssembly.Instance")}}
+- {{jsxref("WebAssembly.Memory")}}
+- {{jsxref("WebAssembly.Table")}}
+- {{jsxref("WebAssembly.CompileError")}}
+- {{jsxref("WebAssembly.LinkError")}}
+- {{jsxref("WebAssembly.RuntimeError")}}
+
+### Autres
+
+- {{JSxRef("Fonctions/arguments", "arguments")}}
diff --git a/files/fr/web/javascript/reference/global_objects/infinity/index.md b/files/fr/web/javascript/reference/global_objects/infinity/index.md
index 7188beb806..0be346bb70 100644
--- a/files/fr/web/javascript/reference/global_objects/infinity/index.md
+++ b/files/fr/web/javascript/reference/global_objects/infinity/index.md
@@ -7,74 +7,51 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Infinity
 original_slug: Web/JavaScript/Reference/Objets_globaux/Infinity
 ---
-<div>{{jsSidebar("Objects")}}</div>
+{{jsSidebar("Objects")}}
 
-<p>La propriété globale <strong><code>Infinity</code></strong> est une valeur numérique représentant l'infini.</p>
+La propriété globale **`Infinity`** est une valeur numérique représentant l'infini.
 
-<p>{{js_property_attributes(0,0,0)}}</p>
+{{js_property_attributes(0,0,0)}}
 
-<div>{{EmbedInteractiveExample("pages/js/globalprops-infinity.html")}}</div>
+{{EmbedInteractiveExample("pages/js/globalprops-infinity.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">Infinity</pre>
+    Infinity
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p><code>Infinity</code> est une propriété de <em>l'objet global</em> , c'est-à-dire qu'elle est accessible globalement.</p>
+`Infinity` est une propriété de _l'objet global_ , c'est-à-dire qu'elle est accessible globalement.
 
-<p>La valeur initiale d'<code>Infinity</code> est {{jsxref("Number.POSITIVE_INFINITY")}}. La valeur <code>Infinity</code> (infinité positive) est une valeur plus grande que n'importe quel nombre. Cette valeur se comporte comme l'infini mathématique ; par exemple, tout ce qui est multiplié par <code>Infinity</code> vaut <code>Infinity</code>, et tout ce qui est divisé par <code>Infinity</code> vaut 0.</p>
+La valeur initiale d'`Infinity` est {{jsxref("Number.POSITIVE_INFINITY")}}. La valeur `Infinity` (infinité positive) est une valeur plus grande que n'importe quel nombre. Cette valeur se comporte comme l'infini mathématique ; par exemple, tout ce qui est multiplié par `Infinity` vaut `Infinity`, et tout ce qui est divisé par `Infinity` vaut 0.
 
-<p>D'après la spécification ECMAScript 5, <code>Infinity</code> est en lecture seule.</p>
+D'après la spécification ECMAScript 5, `Infinity` est en lecture seule.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<pre class="brush: js">console.log(Infinity);          // Infinity
+```js
+console.log(Infinity);          // Infinity
 console.log(Infinity + 1);      // Infinity
 console.log(Math.pow(10, 1000)); // Infinity
 console.log(Math.log(0));       // -Infinity
-console.log(1 / Infinity);      // 0</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.3</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.1.1.2', 'Infinity')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-value-properties-of-the-global-object-infinity', 'Infinity')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-value-properties-of-the-global-object-infinity', 'Infinity')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Infinity")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Number.NEGATIVE_INFINITY")}}</li>
- <li>{{jsxref("Number.POSITIVE_INFINITY")}}</li>
- <li>{{jsxref("Number.isFinite")}}</li>
-</ul>
+console.log(1 / Infinity);      // 0
+```
+
+## Spécifications
+
+| Spécification                                                                                                            | État                         | Commentaires                                         |
+| ------------------------------------------------------------------------------------------------------------------------ | ---------------------------- | ---------------------------------------------------- |
+| {{SpecName('ES1')}}                                                                                                 | {{Spec2('ES1')}}         | Définition initiale. Implémentée avec JavaScript 1.3 |
+| {{SpecName('ES5.1', '#sec-15.1.1.2', 'Infinity')}}                                                     | {{Spec2('ES5.1')}}     |                                                      |
+| {{SpecName('ES6', '#sec-value-properties-of-the-global-object-infinity', 'Infinity')}}     | {{Spec2('ES6')}}         |                                                      |
+| {{SpecName('ESDraft', '#sec-value-properties-of-the-global-object-infinity', 'Infinity')}} | {{Spec2('ESDraft')}} |                                                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Infinity")}}
+
+## Voir aussi
+
+- {{jsxref("Number.NEGATIVE_INFINITY")}}
+- {{jsxref("Number.POSITIVE_INFINITY")}}
+- {{jsxref("Number.isFinite")}}
diff --git a/files/fr/web/javascript/reference/global_objects/int16array/index.md b/files/fr/web/javascript/reference/global_objects/int16array/index.md
index c23c5289a6..ecd15ddbf3 100644
--- a/files/fr/web/javascript/reference/global_objects/int16array/index.md
+++ b/files/fr/web/javascript/reference/global_objects/int16array/index.md
@@ -10,125 +10,118 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Int16Array
 original_slug: Web/JavaScript/Reference/Objets_globaux/Int16Array
 ---
-<div>{{JSRef}}</div>
-
-<p>Le tableau typé <strong><code>Int16Array</code></strong> permet de représenter un tableau d'entiers signés (en complément à deux) représentés sur 16 bits et dans l'ordre des octets de la plate-forme. Pour avoir un contrôle sur le boutisme utilisé, il faudra utiliser un objet {{jsxref("DataView")}} à la place. Les éléments du tableau sont initialisés à 0. Une fois le tableau construit, il est possible de faire référence aux éléments en utilisant les méthodes de l'objet ou en utilisant la notation usuelle de parcours d'un tableau (la syntaxe utilisant les crochets).</p>
-
-<h2 id="Syntaxe">Syntaxe</h2>
-
-<pre class="syntaxbox">new Int16Array(); // apparu avec ES2017
-new Int16Array(longueur);
-new Int16Array(tableauTypé);
-new Int16Array(objet);
-new Int16Array(buffer [, positionOctet [, longueur]]);</pre>
-
-<p>Pour plus d'informations sur la syntaxe du constructeur, voir la page sur les <a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/TypedArray#Syntaxe">tableaux typés</a><em> (TypedArray)</em>.</p>
-
-<h2 id="Propriétés">Propriétés</h2>
-
-<dl>
- <dt>{{jsxref("TypedArray.BYTES_PER_ELEMENT", "Int16Array.BYTES_PER_ELEMENT")}}</dt>
- <dd>Renvoie un nombre représentant la taille d'un élément du tableau en termes d'octets. Dans le cas de <code>Int16Array</code>, la propriété vaudra 2.</dd>
- <dt><code>Int16Array.length</code></dt>
- <dd>Une propriété de longueur qui vaut 3. Pour connaître le nombre d'élément, voir {{jsxref("TypedArray.prototype.length", "Int16Array.prototype.length")}}.</dd>
- <dt>{{jsxref("TypedArray.name", "Int16Array.name")}}</dt>
- <dd>Renvoie la chaîne de caractère représentant le nom du constructeur. Dans le cas de <code>Int16Array</code>, la propriété vaudra "Int16Array".</dd>
- <dt>{{jsxref("TypedArray.prototype", "Int16Array.prototype")}}</dt>
- <dd>Prototype pour les objets <em>TypedArray</em>.</dd>
-</dl>
-
-<h2 id="Méthodes">Méthodes</h2>
-
-<dl>
- <dt>{{jsxref("TypedArray.from", "Int16Array.from()")}}</dt>
- <dd>Crée un nouvel objet <code>Int16Array</code> à partir d'un objet semblable à un tableau ou d'un objet itérable. Voir également la page {{jsxref("Array.from()")}}.</dd>
- <dt>{{jsxref("TypedArray.of", "Int16Array.of()")}}</dt>
- <dd>Crée un nouvel objet <code>Int16Array</code> à partir d'un nombre variable d'arguments. Voir également la page {{jsxref("Array.of()")}}.</dd>
-</dl>
-
-<h2 id="Prototype_de_Int16Array">Prototype de <code>Int16Array</code></h2>
-
-<p>Tous les objets <code>Int16Array</code> héritent de {{jsxref("TypedArray.prototype", "%TypedArray%.prototype")}}.</p>
-
-<h3 id="Propriétés_2">Propriétés</h3>
-
-<dl>
- <dt><code>Int16Array.prototype.constructor</code></dt>
- <dd>Renvoie la fonction qui a créé le prototype de l'instance. Par défaut, ce sera le constructeur natif<code> Int16Array</code>.</dd>
- <dt>{{jsxref("TypedArray.prototype.buffer", "Int16Array.prototype.buffer")}} {{readonlyInline}}</dt>
- <dd>Renvoie l'{{jsxref("ArrayBuffer")}} référencée par l'objet <code>Int16Array</code>. Cette propriété est déterminée lors de la construction de l'objet et n'est accessible qu'en <strong>lecture seule</strong>.</dd>
- <dt>{{jsxref("TypedArray.prototype.byteLength", "Int16Array.prototype.byteLength")}} {{readonlyInline}}</dt>
- <dd>Renvoie la longueur, exprimée en octets, de l'objet <code>Int16Array</code> depuis le début de l'{{jsxref("ArrayBuffer")}} correspondant. Cette propriété est déterminée lors de la construction de l'objet et n'est accessible qu'en <strong>lecture seule</strong>.</dd>
- <dt>{{jsxref("TypedArray.prototype.byteOffset", "Int16Array.prototype.byteOffset")}} {{readonlyInline}}</dt>
- <dd>Renvoie le décalage, exprimé en octets, entre l'objet <code>Int16Array</code> et le début de l'{{jsxref("ArrayBuffer")}} correspondant. Cette propriété est déterminée lors de la construction de l'objet et n'est accessible qu'en <strong>lecture seule</strong>.</dd>
- <dt>{{jsxref("TypedArray.prototype.length", "Int16Array.prototype.length")}} {{readonlyInline}}</dt>
- <dd>Renvoie le nombre d'éléments contenus dans l'objet <code>Int16Array</code>. Cette propriété est déterminée lors de la construction de l'objet et n'est accessible qu'en <strong>lecture seule</strong>.</dd>
-</dl>
-
-<h3 id="Méthodes_2">Méthodes</h3>
-
-<dl>
- <dt>{{jsxref("TypedArray.copyWithin", "Int16Array.prototype.copyWithin()")}}</dt>
- <dd>Copie une suite d'éléments d'un tableau dans le tableau. Voir également {{jsxref("Array.prototype.copyWithin()")}}.</dd>
- <dt>{{jsxref("TypedArray.entries", "Int16Array.prototype.entries()")}}</dt>
- <dd>Renvoie un nouvel objet <code>Array Iterator</code> qui contient les paires clé/valeur pour chaque indice du tableau. Voir également {{jsxref("Array.prototype.entries()")}}.</dd>
- <dt>{{jsxref("TypedArray.every", "Int16Array.prototype.every()")}}</dt>
- <dd>Teste si l'ensemble des éléments du tableau remplissent une certaine condition donnée par une fonction de test. Voir également {{jsxref("Array.prototype.every()")}}.</dd>
- <dt>{{jsxref("TypedArray.fill", "Int16Array.prototype.fill()")}}</dt>
- <dd>Remplit les éléments d'un tableau avec une certaine valeur pour les éléments compris entre un indice de début et un indice de fin. Voir également {{jsxref("Array.prototype.fill()")}}.</dd>
- <dt>{{jsxref("TypedArray.filter", "Int16Array.prototype.filter()")}}</dt>
- <dd>Crée un nouveau tableau dont tous les éléments proviennent de ce tableau et respectent une condition fournie par une fonction de test. Voir également {{jsxref("Array.prototype.filter()")}}.</dd>
- <dt>{{jsxref("TypedArray.find", "Int16Array.prototype.find()")}}</dt>
- <dd>Renvoie une valeur trouvée dans le tableau s'il existe un élément du tableau qui satisfait une condition fournie par une fonction de test, s'il n'y a pas de tel élément <code>undefined</code> sera renvoyé. Voir également {{jsxref("Array.prototype.find()")}}.</dd>
- <dt>{{jsxref("TypedArray.findIndex", "Int16Array.prototype.findIndex()")}}</dt>
- <dd>Renvoie l'indice d'un élément qui satisfait une condition fournie par une fonction de test, si aucun élément ne remplit la condition -1 sera renvoyé. Voir également {{jsxref("Array.prototype.findIndex()")}}.</dd>
- <dt>{{jsxref("TypedArray.forEach", "Int16Array.prototype.forEach()")}}</dt>
- <dd>Appelle une fonction pour chacun des élément du tableau. Voir également {{jsxref("Array.prototype.forEach()")}}.</dd>
- <dt>{{jsxref("TypedArray.includes", "Int16Array.prototype.includes()")}}</dt>
- <dd>Détermine si le tableau typé contient un élément donné. Cette méthode renvoie <code>true</code> ou <code>false</code> selon le cas de figure. Voir également {{jsxref("Array.prototype.includes()")}}.</dd>
- <dt>{{jsxref("TypedArray.indexOf", "Int16Array.prototype.indexOf()")}}</dt>
- <dd>Renvoie le premier indice (le plus petit) d'un élément du tableau qui est égal à la valeur fournie. Si aucun élément ne correspond, la valeur -1 sera renvoyée. Voir également {{jsxref("Array.prototype.indexOf()")}}.</dd>
- <dt>{{jsxref("TypedArray.join", "Int16Array.prototype.join()")}}</dt>
- <dd>Fusionne l'ensemble des éléments du tableau en une chaîne de caractères. Voir également {{jsxref("Array.prototype.join()")}}.</dd>
- <dt>{{jsxref("TypedArray.keys", "Int16Array.prototype.keys()")}}</dt>
- <dd>Renvoie un nouvel objet <code>Array Iterator</code> qui contient les clés de chaque indice du tableau. Voir également {{jsxref("Array.prototype.keys()")}}.</dd>
- <dt>{{jsxref("TypedArray.lastIndexOf", "Int16Array.prototype.lastIndexOf()")}}</dt>
- <dd>Renvoie le dernier indice (le plus élevé) d'un élément du tableau qui est égal à la valeur fournie. Si aucun élément ne correspond, la valeur -1 sera renvoyée. Voir également {{jsxref("Array.prototype.lastIndexOf()")}}.</dd>
- <dt>{{jsxref("TypedArray.map", "Int16Array.prototype.map()")}}</dt>
- <dd>Crée un nouveau tableau dont les éléments sont les images des éléments du tableau courant par une fonction donnée. Voir également {{jsxref("Array.prototype.map()")}}.</dd>
- <dt>{{jsxref("TypedArray.move", "Int16Array.prototype.move()")}} {{non-standard_inline}} {{unimplemented_inline}}</dt>
- <dd>Ancienne version, non-standard, de {{jsxref("TypedArray.copyWithin", "Int16Array.prototype.copyWithin()")}}.</dd>
- <dt>{{jsxref("TypedArray.reduce", "Int16Array.prototype.reduce()")}}</dt>
- <dd>Applique une fonction sur un accumulateur et chaque élément du tableau (de gauche à droite) afin de réduire le tableau en une seule valeur. Voir également {{jsxref("Array.prototype.reduce()")}}.</dd>
- <dt>{{jsxref("TypedArray.reduceRight", "Int16Array.prototype.reduceRight()")}}</dt>
- <dd>Applique une fonction sur un accumulateur et chaque élément du tableau (de droite à gauche) afin de réduire le tableau en une seule valeur. Voir également {{jsxref("Array.prototype.reduceRight()")}}.</dd>
- <dt>{{jsxref("TypedArray.reverse", "Int16Array.prototype.reverse()")}}</dt>
- <dd>Inverse l'ordre des éléments d'un tableau. Le premier élément du tableau devient le dernier et le dernier devient le premier (et ainsi de suite). Voir également {{jsxref("Array.prototype.reverse()")}}.</dd>
- <dt>{{jsxref("TypedArray.set", "Int16Array.prototype.set()")}}</dt>
- <dd>Enregistre plusieurs valeurs dans le tableau typé à partir de valeurs d'un autre tableau.</dd>
- <dt>{{jsxref("TypedArray.slice", "Int16Array.prototype.slice()")}}</dt>
- <dd>Extrait un fragment d'un tableau et renvoie ce fragment. Voir également {{jsxref("Array.prototype.slice()")}}.</dd>
- <dt>{{jsxref("TypedArray.some", "Int16Array.prototype.some()")}}</dt>
- <dd>Renvoie <code>true</code> si au moins un des éléments remplit une condition donnée par une fonction de test. Voir également {{jsxref("Array.prototype.some()")}}.</dd>
- <dt>{{jsxref("TypedArray.sort", "Int16Array.prototype.sort()")}}</dt>
- <dd>Trie les éléments du tableau et renvoie ce tableau. Voir également {{jsxref("Array.prototype.sort()")}}.</dd>
- <dt>{{jsxref("TypedArray.subarray", "Int16Array.prototype.subarray()")}}</dt>
- <dd>Renvoie un nouvel objet <code>Int16Array</code> qui est le fragment du tableau courant, entre les indices de début et de fin donnés.</dd>
- <dt>{{jsxref("TypedArray.values", "Int16Array.prototype.values()")}}</dt>
- <dd>Renvoie un nouvel objet <code>Array Iterator</code> qui contient les valeurs correspondantes à chaque indice du tableau. Voir également {{jsxref("Array.prototype.values()")}}.</dd>
- <dt>{{jsxref("TypedArray.toLocaleString", "Int16Array.prototype.toLocaleString()")}}</dt>
- <dd>Renvoie une chaîne de caractères localisée qui représente le tableau et ses éléments. Voir également {{jsxref("Array.prototype.toLocaleString()")}}.</dd>
- <dt>{{jsxref("TypedArray.toString", "Int16Array.prototype.toString()")}}</dt>
- <dd>Renvoie une chaîne de caractère qui représente le tableau et ses éléments. Voir également {{jsxref("Array.prototype.toString()")}}.</dd>
- <dt>{{jsxref("TypedArray.@@iterator", "Int16Array.prototype[@@iterator]()")}}</dt>
- <dd>Renvoie un nouvel objet <code>Array Iterator</code> qui contient les valeurs correspondantes à chaque indice du tableau.</dd>
-</dl>
-
-<h2 id="Exemples">Exemples</h2>
-
-<p>Différentes façons de créer un <code>Int16Array</code> :</p>
-
-<pre class="brush: js">// Construction à partir d'une longueur
+{{JSRef}}
+
+Le tableau typé **`Int16Array`** permet de représenter un tableau d'entiers signés (en complément à deux) représentés sur 16 bits et dans l'ordre des octets de la plate-forme. Pour avoir un contrôle sur le boutisme utilisé, il faudra utiliser un objet {{jsxref("DataView")}} à la place. Les éléments du tableau sont initialisés à 0. Une fois le tableau construit, il est possible de faire référence aux éléments en utilisant les méthodes de l'objet ou en utilisant la notation usuelle de parcours d'un tableau (la syntaxe utilisant les crochets).
+
+## Syntaxe
+
+    new Int16Array(); // apparu avec ES2017
+    new Int16Array(longueur);
+    new Int16Array(tableauTypé);
+    new Int16Array(objet);
+    new Int16Array(buffer [, positionOctet [, longueur]]);
+
+Pour plus d'informations sur la syntaxe du constructeur, voir la page sur les [tableaux typés](/fr/docs/Web/JavaScript/Reference/Objets_globaux/TypedArray#Syntaxe) _(TypedArray)_.
+
+## Propriétés
+
+- {{jsxref("TypedArray.BYTES_PER_ELEMENT", "Int16Array.BYTES_PER_ELEMENT")}}
+  - : Renvoie un nombre représentant la taille d'un élément du tableau en termes d'octets. Dans le cas de `Int16Array`, la propriété vaudra 2.
+- `Int16Array.length`
+  - : Une propriété de longueur qui vaut 3. Pour connaître le nombre d'élément, voir {{jsxref("TypedArray.prototype.length", "Int16Array.prototype.length")}}.
+- {{jsxref("TypedArray.name", "Int16Array.name")}}
+  - : Renvoie la chaîne de caractère représentant le nom du constructeur. Dans le cas de `Int16Array`, la propriété vaudra "Int16Array".
+- {{jsxref("TypedArray.prototype", "Int16Array.prototype")}}
+  - : Prototype pour les objets _TypedArray_.
+
+## Méthodes
+
+- {{jsxref("TypedArray.from", "Int16Array.from()")}}
+  - : Crée un nouvel objet `Int16Array` à partir d'un objet semblable à un tableau ou d'un objet itérable. Voir également la page {{jsxref("Array.from()")}}.
+- {{jsxref("TypedArray.of", "Int16Array.of()")}}
+  - : Crée un nouvel objet `Int16Array` à partir d'un nombre variable d'arguments. Voir également la page {{jsxref("Array.of()")}}.
+
+## Prototype de `Int16Array`
+
+Tous les objets `Int16Array` héritent de {{jsxref("TypedArray.prototype", "%TypedArray%.prototype")}}.
+
+### Propriétés
+
+- `Int16Array.prototype.constructor`
+  - : Renvoie la fonction qui a créé le prototype de l'instance. Par défaut, ce sera le constructeur natif` Int16Array`.
+- {{jsxref("TypedArray.prototype.buffer", "Int16Array.prototype.buffer")}} {{readonlyInline}}
+  - : Renvoie l'{{jsxref("ArrayBuffer")}} référencée par l'objet `Int16Array`. Cette propriété est déterminée lors de la construction de l'objet et n'est accessible qu'en **lecture seule**.
+- {{jsxref("TypedArray.prototype.byteLength", "Int16Array.prototype.byteLength")}} {{readonlyInline}}
+  - : Renvoie la longueur, exprimée en octets, de l'objet `Int16Array` depuis le début de l'{{jsxref("ArrayBuffer")}} correspondant. Cette propriété est déterminée lors de la construction de l'objet et n'est accessible qu'en **lecture seule**.
+- {{jsxref("TypedArray.prototype.byteOffset", "Int16Array.prototype.byteOffset")}} {{readonlyInline}}
+  - : Renvoie le décalage, exprimé en octets, entre l'objet `Int16Array` et le début de l'{{jsxref("ArrayBuffer")}} correspondant. Cette propriété est déterminée lors de la construction de l'objet et n'est accessible qu'en **lecture seule**.
+- {{jsxref("TypedArray.prototype.length", "Int16Array.prototype.length")}} {{readonlyInline}}
+  - : Renvoie le nombre d'éléments contenus dans l'objet `Int16Array`. Cette propriété est déterminée lors de la construction de l'objet et n'est accessible qu'en **lecture seule**.
+
+### Méthodes
+
+- {{jsxref("TypedArray.copyWithin", "Int16Array.prototype.copyWithin()")}}
+  - : Copie une suite d'éléments d'un tableau dans le tableau. Voir également {{jsxref("Array.prototype.copyWithin()")}}.
+- {{jsxref("TypedArray.entries", "Int16Array.prototype.entries()")}}
+  - : Renvoie un nouvel objet `Array Iterator` qui contient les paires clé/valeur pour chaque indice du tableau. Voir également {{jsxref("Array.prototype.entries()")}}.
+- {{jsxref("TypedArray.every", "Int16Array.prototype.every()")}}
+  - : Teste si l'ensemble des éléments du tableau remplissent une certaine condition donnée par une fonction de test. Voir également {{jsxref("Array.prototype.every()")}}.
+- {{jsxref("TypedArray.fill", "Int16Array.prototype.fill()")}}
+  - : Remplit les éléments d'un tableau avec une certaine valeur pour les éléments compris entre un indice de début et un indice de fin. Voir également {{jsxref("Array.prototype.fill()")}}.
+- {{jsxref("TypedArray.filter", "Int16Array.prototype.filter()")}}
+  - : Crée un nouveau tableau dont tous les éléments proviennent de ce tableau et respectent une condition fournie par une fonction de test. Voir également {{jsxref("Array.prototype.filter()")}}.
+- {{jsxref("TypedArray.find", "Int16Array.prototype.find()")}}
+  - : Renvoie une valeur trouvée dans le tableau s'il existe un élément du tableau qui satisfait une condition fournie par une fonction de test, s'il n'y a pas de tel élément `undefined` sera renvoyé. Voir également {{jsxref("Array.prototype.find()")}}.
+- {{jsxref("TypedArray.findIndex", "Int16Array.prototype.findIndex()")}}
+  - : Renvoie l'indice d'un élément qui satisfait une condition fournie par une fonction de test, si aucun élément ne remplit la condition -1 sera renvoyé. Voir également {{jsxref("Array.prototype.findIndex()")}}.
+- {{jsxref("TypedArray.forEach", "Int16Array.prototype.forEach()")}}
+  - : Appelle une fonction pour chacun des élément du tableau. Voir également {{jsxref("Array.prototype.forEach()")}}.
+- {{jsxref("TypedArray.includes", "Int16Array.prototype.includes()")}}
+  - : Détermine si le tableau typé contient un élément donné. Cette méthode renvoie `true` ou `false` selon le cas de figure. Voir également {{jsxref("Array.prototype.includes()")}}.
+- {{jsxref("TypedArray.indexOf", "Int16Array.prototype.indexOf()")}}
+  - : Renvoie le premier indice (le plus petit) d'un élément du tableau qui est égal à la valeur fournie. Si aucun élément ne correspond, la valeur -1 sera renvoyée. Voir également {{jsxref("Array.prototype.indexOf()")}}.
+- {{jsxref("TypedArray.join", "Int16Array.prototype.join()")}}
+  - : Fusionne l'ensemble des éléments du tableau en une chaîne de caractères. Voir également {{jsxref("Array.prototype.join()")}}.
+- {{jsxref("TypedArray.keys", "Int16Array.prototype.keys()")}}
+  - : Renvoie un nouvel objet `Array Iterator` qui contient les clés de chaque indice du tableau. Voir également {{jsxref("Array.prototype.keys()")}}.
+- {{jsxref("TypedArray.lastIndexOf", "Int16Array.prototype.lastIndexOf()")}}
+  - : Renvoie le dernier indice (le plus élevé) d'un élément du tableau qui est égal à la valeur fournie. Si aucun élément ne correspond, la valeur -1 sera renvoyée. Voir également {{jsxref("Array.prototype.lastIndexOf()")}}.
+- {{jsxref("TypedArray.map", "Int16Array.prototype.map()")}}
+  - : Crée un nouveau tableau dont les éléments sont les images des éléments du tableau courant par une fonction donnée. Voir également {{jsxref("Array.prototype.map()")}}.
+- {{jsxref("TypedArray.move", "Int16Array.prototype.move()")}} {{non-standard_inline}} {{unimplemented_inline}}
+  - : Ancienne version, non-standard, de {{jsxref("TypedArray.copyWithin", "Int16Array.prototype.copyWithin()")}}.
+- {{jsxref("TypedArray.reduce", "Int16Array.prototype.reduce()")}}
+  - : Applique une fonction sur un accumulateur et chaque élément du tableau (de gauche à droite) afin de réduire le tableau en une seule valeur. Voir également {{jsxref("Array.prototype.reduce()")}}.
+- {{jsxref("TypedArray.reduceRight", "Int16Array.prototype.reduceRight()")}}
+  - : Applique une fonction sur un accumulateur et chaque élément du tableau (de droite à gauche) afin de réduire le tableau en une seule valeur. Voir également {{jsxref("Array.prototype.reduceRight()")}}.
+- {{jsxref("TypedArray.reverse", "Int16Array.prototype.reverse()")}}
+  - : Inverse l'ordre des éléments d'un tableau. Le premier élément du tableau devient le dernier et le dernier devient le premier (et ainsi de suite). Voir également {{jsxref("Array.prototype.reverse()")}}.
+- {{jsxref("TypedArray.set", "Int16Array.prototype.set()")}}
+  - : Enregistre plusieurs valeurs dans le tableau typé à partir de valeurs d'un autre tableau.
+- {{jsxref("TypedArray.slice", "Int16Array.prototype.slice()")}}
+  - : Extrait un fragment d'un tableau et renvoie ce fragment. Voir également {{jsxref("Array.prototype.slice()")}}.
+- {{jsxref("TypedArray.some", "Int16Array.prototype.some()")}}
+  - : Renvoie `true` si au moins un des éléments remplit une condition donnée par une fonction de test. Voir également {{jsxref("Array.prototype.some()")}}.
+- {{jsxref("TypedArray.sort", "Int16Array.prototype.sort()")}}
+  - : Trie les éléments du tableau et renvoie ce tableau. Voir également {{jsxref("Array.prototype.sort()")}}.
+- {{jsxref("TypedArray.subarray", "Int16Array.prototype.subarray()")}}
+  - : Renvoie un nouvel objet `Int16Array` qui est le fragment du tableau courant, entre les indices de début et de fin donnés.
+- {{jsxref("TypedArray.values", "Int16Array.prototype.values()")}}
+  - : Renvoie un nouvel objet `Array Iterator` qui contient les valeurs correspondantes à chaque indice du tableau. Voir également {{jsxref("Array.prototype.values()")}}.
+- {{jsxref("TypedArray.toLocaleString", "Int16Array.prototype.toLocaleString()")}}
+  - : Renvoie une chaîne de caractères localisée qui représente le tableau et ses éléments. Voir également {{jsxref("Array.prototype.toLocaleString()")}}.
+- {{jsxref("TypedArray.toString", "Int16Array.prototype.toString()")}}
+  - : Renvoie une chaîne de caractère qui représente le tableau et ses éléments. Voir également {{jsxref("Array.prototype.toString()")}}.
+- {{jsxref("TypedArray.@@iterator", "Int16Array.prototype[@@iterator]()")}}
+  - : Renvoie un nouvel objet `Array Iterator` qui contient les valeurs correspondantes à chaque indice du tableau.
+
+## Exemples
+
+Différentes façons de créer un `Int16Array` :
+
+```js
+// Construction à partir d'une longueur
 var int16 = new Int16Array(2);
 int16[0] = 42;
 console.log(int16[0]); // 42
@@ -152,53 +145,36 @@ var z = new Int16Array(buffer, 0, 4);
 var iterable = function*(){ yield* [1,2,3]; }();
 var int16 = new Int16Array(iterable);
 // Int16Array[1, 2, 3]
-</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('Typed Array')}}</td>
-   <td>{{Spec2('Typed Array')}}</td>
-   <td>Remplacée dans ECMAScript 2015.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES2015', '#table-49', 'TypedArray constructors')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale au sein d'un standard ECMA. <code>new</code> est obligatoire.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#table-49', 'TypedArray constructors')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td>ECMAScript 2017 a modifié le constructeur <code>Int16Array</code> afin d'utiliser l'opération interne <code>ToIndex</code> pour permettre de l'utiliser sans argument.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Int16Array")}}</p>
-
-<h2 id="Notes_de_compatibilité">Notes de compatibilité</h2>
-
-<p>À partir d'ECMAScript 2015 (ES6), <code>Int16Array</code> doit être utilisé avec {{jsxref("Opérateurs/L_opérateur_new", "new")}}. Appeler un constructeur <code>Int16Array</code> comme une fonction, sans <code>new</code>, provoquera une exception {{jsxref("TypeError")}}.</p>
-
-<pre class="brush: js example-bad">var dv = Int16Array([1, 2, 3]);
+```
+
+## Spécifications
+
+| Spécification                                                                        | État                             | Commentaires                                                                                                                                     |
+| ------------------------------------------------------------------------------------ | -------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
+| {{SpecName('Typed Array')}}                                                 | {{Spec2('Typed Array')}} | Remplacée dans ECMAScript 2015.                                                                                                                  |
+| {{SpecName('ES2015', '#table-49', 'TypedArray constructors')}} | {{Spec2('ES2015')}}         | Définition initiale au sein d'un standard ECMA. `new` est obligatoire.                                                                           |
+| {{SpecName('ESDraft', '#table-49', 'TypedArray constructors')}} | {{Spec2('ESDraft')}}     | ECMAScript 2017 a modifié le constructeur `Int16Array` afin d'utiliser l'opération interne `ToIndex` pour permettre de l'utiliser sans argument. |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Int16Array")}}
+
+## Notes de compatibilité
+
+À partir d'ECMAScript 2015 (ES6), `Int16Array` doit être utilisé avec {{jsxref("Opérateurs/L_opérateur_new", "new")}}. Appeler un constructeur `Int16Array` comme une fonction, sans `new`, provoquera une exception {{jsxref("TypeError")}}.
+
+```js example-bad
+var dv = Int16Array([1, 2, 3]);
 // TypeError: calling a builtin Int16Array constructor
-// without new is forbidden</pre>
+// without new is forbidden
+```
 
-<pre class="brush: js example-good">var dv = new Int16Array([1, 2, 3]);</pre>
+```js example-good
+var dv = new Int16Array([1, 2, 3]);
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li><a href="/fr/docs/Web/JavaScript/Tableaux_typés" title="en/JavaScript typed arrays">Les tableaux typés (<em>typed arrays</em>) en JavaScript</a></li>
- <li>{{jsxref("ArrayBuffer")}}</li>
- <li>{{jsxref("DataView")}}</li>
-</ul>
+- [Les tableaux typés (_typed arrays_) en JavaScript](/fr/docs/Web/JavaScript/Tableaux_typés "en/JavaScript typed arrays")
+- {{jsxref("ArrayBuffer")}}
+- {{jsxref("DataView")}}
diff --git a/files/fr/web/javascript/reference/global_objects/int32array/index.md b/files/fr/web/javascript/reference/global_objects/int32array/index.md
index b2eac551a2..04ab728a41 100644
--- a/files/fr/web/javascript/reference/global_objects/int32array/index.md
+++ b/files/fr/web/javascript/reference/global_objects/int32array/index.md
@@ -10,125 +10,118 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Int32Array
 original_slug: Web/JavaScript/Reference/Objets_globaux/Int32Array
 ---
-<div>{{JSRef}}</div>
-
-<p>Le tableau typé <strong><code>Int32Array</code></strong> permet de représenter un tableau d'entiers signés (en complément à deux) représentés sur 32 bits et dans l'ordre des octets de la plate-forme. Pour avoir un contrôle sur le boutisme utilisé, il faudra utiliser un objet {{jsxref("DataView")}} à la place. Les éléments du tableau sont initialisés à 0. Une fois le tableau construit, il est possible de faire référence aux éléments en utilisant les méthodes de l'objet ou en utilisant la notation usuelle de parcours d'un tableau (la syntaxe utilisant les crochets).</p>
-
-<h2 id="Syntaxe">Syntaxe</h2>
-
-<pre class="syntaxbox">new Int32Array(); // apparu avec ES2017
-new Int32Array(longueur);
-new Int32Array(tableauTypé);
-new Int32Array(objet);
-new Int32Array(buffer [, positionOctet [, longueur]]);</pre>
-
-<p>Pour plus d'informations sur la syntaxe du constructeur, voir la page sur les <a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/TypedArray#Syntaxe">tableaux typés</a><em> (TypedArray)</em>.</p>
-
-<h2 id="Propriétés">Propriétés</h2>
-
-<dl>
- <dt>{{jsxref("TypedArray.BYTES_PER_ELEMENT", "Int32Array.BYTES_PER_ELEMENT")}}</dt>
- <dd>Renvoie un nombre représentant la taille d'un élément du tableau en termes d'octets. Dans le cas de <code>Int32Array</code>, la propriété vaudra 4.</dd>
- <dt><code>Int32Array.length</code></dt>
- <dd>Une propriété de longueur statique qui vaut 3. Pour connaître le nombre d'éléments, voir {{jsxref("TypedArray.prototype.length", "Int32Array.prototype.length")}}.</dd>
- <dt>{{jsxref("TypedArray.name", "Int32Array.name")}}</dt>
- <dd>Renvoie la chaîne de caractère représentant le nom du constructeur. Dans le cas de <code>Int32Array</code>, la propriété vaudra "Int32Array".</dd>
- <dt>{{jsxref("TypedArray.prototype", "Int32Array.prototype")}}</dt>
- <dd>Prototype pour les objets <em>TypedArray</em>.</dd>
-</dl>
-
-<h2 id="Méthodes">Méthodes</h2>
-
-<dl>
- <dt>Int32Array.from()</dt>
- <dd>Crée un nouvel objet <code>Int32Array</code> à partir d'un objet semblable à un tableau ou d'un objet itérable. Voir également la page {{jsxref("Array.from()")}}.</dd>
- <dt>Int32Array.of()</dt>
- <dd>Crée un nouvel objet <code>Int32Array</code> à partir d'un nombre variable d'arguments. Voir également la page {{jsxref("Array.of()")}}</dd>
-</dl>
-
-<h2 id="Prototype_de_Int32Array">Prototype de <code>Int32Array</code></h2>
-
-<p>Tous les objets <code>Int32Array</code> héritent de {{jsxref("TypedArray.prototype", "%TypedArray%.prototype")}}.</p>
-
-<h3 id="Propriétés_2">Propriétés</h3>
-
-<dl>
- <dt><code>Int32Array.prototype.constructor</code></dt>
- <dd>Renvoie la fonction qui a créé le prototype de l'instance. Par défaut, ce sera le constructeur natif<code> Int32Array</code>.</dd>
- <dt>{{jsxref("TypedArray.prototype.buffer", "Int32Array.prototype.buffer")}} {{readonlyInline}}</dt>
- <dd>Renvoie l'{{jsxref("ArrayBuffer")}} référencée par l'objet <code>Int32Array</code>. Cette propriété est déterminée lors de la construction de l'objet et n'est accessible qu'en <strong>lecture seule</strong>.</dd>
- <dt>{{jsxref("TypedArray.prototype.byteLength", "Int32Array.prototype.byteLength")}} {{readonlyInline}}</dt>
- <dd>Renvoie la longueur, exprimée en octets, de l'objet <code>Int32Array</code> depuis le début de l'{{jsxref("ArrayBuffer")}} correspondant. Cette propriété est déterminée lors de la construction de l'objet et n'est accessible qu'en <strong>lecture seule</strong>.</dd>
- <dt>{{jsxref("TypedArray.prototype.byteOffset", "Int32Array.prototype.byteOffset")}} {{readonlyInline}}</dt>
- <dd>Renvoie le décalage, exprimé en octets, entre l'objet <code>Int32Array</code> et le début de l'{{jsxref("ArrayBuffer")}} correspondant. Cette propriété est déterminée lors de la construction de l'objet et n'est accessible qu'en <strong>lecture seule</strong>.</dd>
- <dt>{{jsxref("TypedArray.prototype.length", "Int32Array.prototype.length")}} {{readonlyInline}}</dt>
- <dd>Renvoie le nombre d'éléments contenus dans l'objet <code>Int32Array</code>. Cette propriété est déterminée lors de la construction de l'objet et n'est accessible qu'en <strong>lecture seule</strong>.</dd>
-</dl>
-
-<h3 id="Méthodes_2">Méthodes</h3>
-
-<dl>
- <dt>{{jsxref("TypedArray.copyWithin", "Int32Array.prototype.copyWithin()")}}</dt>
- <dd>Copie une suite d'éléments d'un tableau dans le tableau. Voir également {{jsxref("Array.prototype.copyWithin()")}}.</dd>
- <dt>{{jsxref("TypedArray.entries", "Int32Array.prototype.entries()")}}</dt>
- <dd>Renvoie un nouvel objet <code>Array Iterator</code> qui contient les paires clé/valeur pour chaque indice du tableau. Voir également {{jsxref("Array.prototype.entries()")}}.</dd>
- <dt>{{jsxref("TypedArray.every", "Int32Array.prototype.every()")}}</dt>
- <dd>Teste si l'ensemble des éléments du tableau remplissent une certaine condition donnée par une fonction de test. Voir également {{jsxref("Array.prototype.every()")}}.</dd>
- <dt>{{jsxref("TypedArray.fill", "Int32Array.prototype.fill()")}}</dt>
- <dd>Remplit les éléments d'un tableau avec une certaine valeur pour les éléments compris entre un indice de début et un indice de fin. Voir également {{jsxref("Array.prototype.fill()")}}.</dd>
- <dt>{{jsxref("TypedArray.filter", "Int32Array.prototype.filter()")}}</dt>
- <dd>Crée un nouveau tableau dont tous les éléments proviennent de ce tableau et respectent une condition fournie par une fonction de test. Voir également {{jsxref("Array.prototype.filter()")}}.</dd>
- <dt>{{jsxref("TypedArray.find", "Int32Array.prototype.find()")}}</dt>
- <dd>Renvoie une valeur trouvée dans le tableau s'il existe un élément du tableau qui satisfait une condition fournie par une fonction de test, s'il n'y a pas de tel élément <code>undefined</code> sera renvoyé. Voir également {{jsxref("Array.prototype.find()")}}.</dd>
- <dt>{{jsxref("TypedArray.findIndex", "Int32Array.prototype.findIndex()")}}</dt>
- <dd>Renvoie l'indice d'un élément qui satisfait une condition fournie par une fonction de test, si aucun élément ne remplit la condition -1 sera renvoyé. Voir également {{jsxref("Array.prototype.findIndex()")}}.</dd>
- <dt>{{jsxref("TypedArray.forEach", "Int32Array.prototype.forEach()")}}</dt>
- <dd>Appelle une fonction pour chacun des élément du tableau. Voir également {{jsxref("Array.prototype.forEach()")}}.</dd>
- <dt>{{jsxref("TypedArray.includes", "Int32Array.prototype.includes()")}}</dt>
- <dd>Détermine si le tableau typé contient un élément donné. Cette méthode renvoie <code>true</code> ou <code>false</code> selon le cas de figure. Voir également {{jsxref("Array.prototype.includes()")}}.</dd>
- <dt>{{jsxref("TypedArray.indexOf", "Int32Array.prototype.indexOf()")}}</dt>
- <dd>Renvoie le premier indice (le plus petit) d'un élément du tableau qui est égal à la valeur fournie. Si aucun élément ne correspond, la valeur -1 sera renvoyée. Voir également {{jsxref("Array.prototype.indexOf()")}}.</dd>
- <dt>{{jsxref("TypedArray.join", "Int32Array.prototype.join()")}}</dt>
- <dd>Fusionne l'ensemble des éléments du tableau en une chaîne de caractères. Voir également {{jsxref("Array.prototype.join()")}}.</dd>
- <dt>{{jsxref("TypedArray.keys", "Int32Array.prototype.keys()")}}</dt>
- <dd>Renvoie un nouvel objet <code>Array Iterator</code> qui contient les clés de chaque indice du tableau. Voir également {{jsxref("Array.prototype.keys()")}}.</dd>
- <dt>{{jsxref("TypedArray.lastIndexOf", "Int32Array.prototype.lastIndexOf()")}}</dt>
- <dd>Renvoie le dernier indice (le plus élevé) d'un élément du tableau qui est égal à la valeur fournie. Si aucun élément ne correspond, la valeur -1 sera renvoyée. Voir également {{jsxref("Array.prototype.lastIndexOf()")}}.</dd>
- <dt>{{jsxref("TypedArray.map", "Int32Array.prototype.map()")}}</dt>
- <dd>Crée un nouveau tableau dont les éléments sont les images des éléments du tableau courant par une fonction donnée. Voir également {{jsxref("Array.prototype.map()")}}.</dd>
- <dt>{{jsxref("TypedArray.move", "Int32Array.prototype.move()")}} {{non-standard_inline}} {{unimplemented_inline}}</dt>
- <dd>Ancienne version, non-standard, de {{jsxref("TypedArray.copyWithin", "Int32Array.prototype.copyWithin()")}}.</dd>
- <dt>{{jsxref("TypedArray.reduce", "Int32Array.prototype.reduce()")}}</dt>
- <dd>Applique une fonction sur un accumulateur et chaque élément du tableau (de gauche à droite) afin de réduire le tableau en une seule valeur. Voir également {{jsxref("Array.prototype.reduce()")}}.</dd>
- <dt>{{jsxref("TypedArray.reduceRight", "Int32Array.prototype.reduceRight()")}}</dt>
- <dd>Applique une fonction sur un accumulateur et chaque élément du tableau (de droite à gauche) afin de réduire le tableau en une seule valeur. Voir également {{jsxref("Array.prototype.reduceRight()")}}.</dd>
- <dt>{{jsxref("TypedArray.reverse", "Int32Array.prototype.reverse()")}}</dt>
- <dd>Inverse l'ordre des éléments d'un tableau. Le premier élément du tableau devient le dernier et le dernier devient le premier (et ainsi de suite). Voir également {{jsxref("Array.prototype.reverse()")}}.</dd>
- <dt>{{jsxref("TypedArray.set", "Int32Array.prototype.set()")}}</dt>
- <dd>Enregistre plusieurs valeurs dans le tableau typé à partir de valeurs d'un autre tableau.</dd>
- <dt>{{jsxref("TypedArray.slice", "Int32Array.prototype.slice()")}}</dt>
- <dd>Extrait un fragment d'un tableau et renvoie ce fragment. Voir également {{jsxref("Array.prototype.slice()")}}.</dd>
- <dt>{{jsxref("TypedArray.some", "Int32Array.prototype.some()")}}</dt>
- <dd>Renvoie <code>true</code> si au moins un des éléments remplit une condition donnée par une fonction de test. Voir également {{jsxref("Array.prototype.some()")}}.</dd>
- <dt>{{jsxref("TypedArray.sort", "Int32Array.prototype.sort()")}}</dt>
- <dd>Trie les éléments du tableau et renvoie ce tableau. Voir également {{jsxref("Array.prototype.sort()")}}.</dd>
- <dt>{{jsxref("TypedArray.subarray", "Int32Array.prototype.subarray()")}}</dt>
- <dd>Renvoie un nouvel objet <code>Int32Array</code> qui est le fragment du tableau courant, entre les indices de début et de fin donnés.</dd>
- <dt>{{jsxref("TypedArray.values", "Int32Array.prototype.values()")}}</dt>
- <dd>Renvoie un nouvel objet <code>Array Iterator</code> qui contient les valeurs correspondantes à chaque indice du tableau. Voir également {{jsxref("Array.prototype.values()")}}.</dd>
- <dt>{{jsxref("TypedArray.toLocaleString", "Int32Array.prototype.toLocaleString()")}}</dt>
- <dd>Renvoie une chaîne de caractères localisée qui représente le tableau et ses éléments. Voir également {{jsxref("Array.prototype.toLocaleString()")}}.</dd>
- <dt>{{jsxref("TypedArray.toString", "Int32Array.prototype.toString()")}}</dt>
- <dd>Renvoie une chaîne de caractère qui représente le tableau et ses éléments. Voir également {{jsxref("Array.prototype.toString()")}}.</dd>
- <dt>{{jsxref("TypedArray.@@iterator", "Int32Array.prototype[@@iterator]()")}}</dt>
- <dd>Renvoie un nouvel objet <code>Array Iterator</code> qui contient les valeurs correspondantes à chaque indice du tableau.</dd>
-</dl>
-
-<h2 id="Exemples">Exemples</h2>
-
-<p>Différentes façons de créer un objet <code>Int32Array</code> :</p>
-
-<pre class="brush: js">// Construction à partir d'une longueur
+{{JSRef}}
+
+Le tableau typé **`Int32Array`** permet de représenter un tableau d'entiers signés (en complément à deux) représentés sur 32 bits et dans l'ordre des octets de la plate-forme. Pour avoir un contrôle sur le boutisme utilisé, il faudra utiliser un objet {{jsxref("DataView")}} à la place. Les éléments du tableau sont initialisés à 0. Une fois le tableau construit, il est possible de faire référence aux éléments en utilisant les méthodes de l'objet ou en utilisant la notation usuelle de parcours d'un tableau (la syntaxe utilisant les crochets).
+
+## Syntaxe
+
+    new Int32Array(); // apparu avec ES2017
+    new Int32Array(longueur);
+    new Int32Array(tableauTypé);
+    new Int32Array(objet);
+    new Int32Array(buffer [, positionOctet [, longueur]]);
+
+Pour plus d'informations sur la syntaxe du constructeur, voir la page sur les [tableaux typés](/fr/docs/Web/JavaScript/Reference/Objets_globaux/TypedArray#Syntaxe) _(TypedArray)_.
+
+## Propriétés
+
+- {{jsxref("TypedArray.BYTES_PER_ELEMENT", "Int32Array.BYTES_PER_ELEMENT")}}
+  - : Renvoie un nombre représentant la taille d'un élément du tableau en termes d'octets. Dans le cas de `Int32Array`, la propriété vaudra 4.
+- `Int32Array.length`
+  - : Une propriété de longueur statique qui vaut 3. Pour connaître le nombre d'éléments, voir {{jsxref("TypedArray.prototype.length", "Int32Array.prototype.length")}}.
+- {{jsxref("TypedArray.name", "Int32Array.name")}}
+  - : Renvoie la chaîne de caractère représentant le nom du constructeur. Dans le cas de `Int32Array`, la propriété vaudra "Int32Array".
+- {{jsxref("TypedArray.prototype", "Int32Array.prototype")}}
+  - : Prototype pour les objets _TypedArray_.
+
+## Méthodes
+
+- Int32Array.from()
+  - : Crée un nouvel objet `Int32Array` à partir d'un objet semblable à un tableau ou d'un objet itérable. Voir également la page {{jsxref("Array.from()")}}.
+- Int32Array.of()
+  - : Crée un nouvel objet `Int32Array` à partir d'un nombre variable d'arguments. Voir également la page {{jsxref("Array.of()")}}
+
+## Prototype de `Int32Array`
+
+Tous les objets `Int32Array` héritent de {{jsxref("TypedArray.prototype", "%TypedArray%.prototype")}}.
+
+### Propriétés
+
+- `Int32Array.prototype.constructor`
+  - : Renvoie la fonction qui a créé le prototype de l'instance. Par défaut, ce sera le constructeur natif` Int32Array`.
+- {{jsxref("TypedArray.prototype.buffer", "Int32Array.prototype.buffer")}} {{readonlyInline}}
+  - : Renvoie l'{{jsxref("ArrayBuffer")}} référencée par l'objet `Int32Array`. Cette propriété est déterminée lors de la construction de l'objet et n'est accessible qu'en **lecture seule**.
+- {{jsxref("TypedArray.prototype.byteLength", "Int32Array.prototype.byteLength")}} {{readonlyInline}}
+  - : Renvoie la longueur, exprimée en octets, de l'objet `Int32Array` depuis le début de l'{{jsxref("ArrayBuffer")}} correspondant. Cette propriété est déterminée lors de la construction de l'objet et n'est accessible qu'en **lecture seule**.
+- {{jsxref("TypedArray.prototype.byteOffset", "Int32Array.prototype.byteOffset")}} {{readonlyInline}}
+  - : Renvoie le décalage, exprimé en octets, entre l'objet `Int32Array` et le début de l'{{jsxref("ArrayBuffer")}} correspondant. Cette propriété est déterminée lors de la construction de l'objet et n'est accessible qu'en **lecture seule**.
+- {{jsxref("TypedArray.prototype.length", "Int32Array.prototype.length")}} {{readonlyInline}}
+  - : Renvoie le nombre d'éléments contenus dans l'objet `Int32Array`. Cette propriété est déterminée lors de la construction de l'objet et n'est accessible qu'en **lecture seule**.
+
+### Méthodes
+
+- {{jsxref("TypedArray.copyWithin", "Int32Array.prototype.copyWithin()")}}
+  - : Copie une suite d'éléments d'un tableau dans le tableau. Voir également {{jsxref("Array.prototype.copyWithin()")}}.
+- {{jsxref("TypedArray.entries", "Int32Array.prototype.entries()")}}
+  - : Renvoie un nouvel objet `Array Iterator` qui contient les paires clé/valeur pour chaque indice du tableau. Voir également {{jsxref("Array.prototype.entries()")}}.
+- {{jsxref("TypedArray.every", "Int32Array.prototype.every()")}}
+  - : Teste si l'ensemble des éléments du tableau remplissent une certaine condition donnée par une fonction de test. Voir également {{jsxref("Array.prototype.every()")}}.
+- {{jsxref("TypedArray.fill", "Int32Array.prototype.fill()")}}
+  - : Remplit les éléments d'un tableau avec une certaine valeur pour les éléments compris entre un indice de début et un indice de fin. Voir également {{jsxref("Array.prototype.fill()")}}.
+- {{jsxref("TypedArray.filter", "Int32Array.prototype.filter()")}}
+  - : Crée un nouveau tableau dont tous les éléments proviennent de ce tableau et respectent une condition fournie par une fonction de test. Voir également {{jsxref("Array.prototype.filter()")}}.
+- {{jsxref("TypedArray.find", "Int32Array.prototype.find()")}}
+  - : Renvoie une valeur trouvée dans le tableau s'il existe un élément du tableau qui satisfait une condition fournie par une fonction de test, s'il n'y a pas de tel élément `undefined` sera renvoyé. Voir également {{jsxref("Array.prototype.find()")}}.
+- {{jsxref("TypedArray.findIndex", "Int32Array.prototype.findIndex()")}}
+  - : Renvoie l'indice d'un élément qui satisfait une condition fournie par une fonction de test, si aucun élément ne remplit la condition -1 sera renvoyé. Voir également {{jsxref("Array.prototype.findIndex()")}}.
+- {{jsxref("TypedArray.forEach", "Int32Array.prototype.forEach()")}}
+  - : Appelle une fonction pour chacun des élément du tableau. Voir également {{jsxref("Array.prototype.forEach()")}}.
+- {{jsxref("TypedArray.includes", "Int32Array.prototype.includes()")}}
+  - : Détermine si le tableau typé contient un élément donné. Cette méthode renvoie `true` ou `false` selon le cas de figure. Voir également {{jsxref("Array.prototype.includes()")}}.
+- {{jsxref("TypedArray.indexOf", "Int32Array.prototype.indexOf()")}}
+  - : Renvoie le premier indice (le plus petit) d'un élément du tableau qui est égal à la valeur fournie. Si aucun élément ne correspond, la valeur -1 sera renvoyée. Voir également {{jsxref("Array.prototype.indexOf()")}}.
+- {{jsxref("TypedArray.join", "Int32Array.prototype.join()")}}
+  - : Fusionne l'ensemble des éléments du tableau en une chaîne de caractères. Voir également {{jsxref("Array.prototype.join()")}}.
+- {{jsxref("TypedArray.keys", "Int32Array.prototype.keys()")}}
+  - : Renvoie un nouvel objet `Array Iterator` qui contient les clés de chaque indice du tableau. Voir également {{jsxref("Array.prototype.keys()")}}.
+- {{jsxref("TypedArray.lastIndexOf", "Int32Array.prototype.lastIndexOf()")}}
+  - : Renvoie le dernier indice (le plus élevé) d'un élément du tableau qui est égal à la valeur fournie. Si aucun élément ne correspond, la valeur -1 sera renvoyée. Voir également {{jsxref("Array.prototype.lastIndexOf()")}}.
+- {{jsxref("TypedArray.map", "Int32Array.prototype.map()")}}
+  - : Crée un nouveau tableau dont les éléments sont les images des éléments du tableau courant par une fonction donnée. Voir également {{jsxref("Array.prototype.map()")}}.
+- {{jsxref("TypedArray.move", "Int32Array.prototype.move()")}} {{non-standard_inline}} {{unimplemented_inline}}
+  - : Ancienne version, non-standard, de {{jsxref("TypedArray.copyWithin", "Int32Array.prototype.copyWithin()")}}.
+- {{jsxref("TypedArray.reduce", "Int32Array.prototype.reduce()")}}
+  - : Applique une fonction sur un accumulateur et chaque élément du tableau (de gauche à droite) afin de réduire le tableau en une seule valeur. Voir également {{jsxref("Array.prototype.reduce()")}}.
+- {{jsxref("TypedArray.reduceRight", "Int32Array.prototype.reduceRight()")}}
+  - : Applique une fonction sur un accumulateur et chaque élément du tableau (de droite à gauche) afin de réduire le tableau en une seule valeur. Voir également {{jsxref("Array.prototype.reduceRight()")}}.
+- {{jsxref("TypedArray.reverse", "Int32Array.prototype.reverse()")}}
+  - : Inverse l'ordre des éléments d'un tableau. Le premier élément du tableau devient le dernier et le dernier devient le premier (et ainsi de suite). Voir également {{jsxref("Array.prototype.reverse()")}}.
+- {{jsxref("TypedArray.set", "Int32Array.prototype.set()")}}
+  - : Enregistre plusieurs valeurs dans le tableau typé à partir de valeurs d'un autre tableau.
+- {{jsxref("TypedArray.slice", "Int32Array.prototype.slice()")}}
+  - : Extrait un fragment d'un tableau et renvoie ce fragment. Voir également {{jsxref("Array.prototype.slice()")}}.
+- {{jsxref("TypedArray.some", "Int32Array.prototype.some()")}}
+  - : Renvoie `true` si au moins un des éléments remplit une condition donnée par une fonction de test. Voir également {{jsxref("Array.prototype.some()")}}.
+- {{jsxref("TypedArray.sort", "Int32Array.prototype.sort()")}}
+  - : Trie les éléments du tableau et renvoie ce tableau. Voir également {{jsxref("Array.prototype.sort()")}}.
+- {{jsxref("TypedArray.subarray", "Int32Array.prototype.subarray()")}}
+  - : Renvoie un nouvel objet `Int32Array` qui est le fragment du tableau courant, entre les indices de début et de fin donnés.
+- {{jsxref("TypedArray.values", "Int32Array.prototype.values()")}}
+  - : Renvoie un nouvel objet `Array Iterator` qui contient les valeurs correspondantes à chaque indice du tableau. Voir également {{jsxref("Array.prototype.values()")}}.
+- {{jsxref("TypedArray.toLocaleString", "Int32Array.prototype.toLocaleString()")}}
+  - : Renvoie une chaîne de caractères localisée qui représente le tableau et ses éléments. Voir également {{jsxref("Array.prototype.toLocaleString()")}}.
+- {{jsxref("TypedArray.toString", "Int32Array.prototype.toString()")}}
+  - : Renvoie une chaîne de caractère qui représente le tableau et ses éléments. Voir également {{jsxref("Array.prototype.toString()")}}.
+- {{jsxref("TypedArray.@@iterator", "Int32Array.prototype[@@iterator]()")}}
+  - : Renvoie un nouvel objet `Array Iterator` qui contient les valeurs correspondantes à chaque indice du tableau.
+
+## Exemples
+
+Différentes façons de créer un objet `Int32Array` :
+
+```js
+// Construction à partir d'une longueur
 var int32 = new Int32Array(2);
 int32[0] = 42;
 console.log(int32[0]); // 42
@@ -152,53 +145,36 @@ var z = new Int32Array(buffer, 0, 4);
 var iterable = function*(){ yield* [1,2,3]; }();
 var int32 = new Int32Array(iterable);
 // Int32Array[1, 2, 3]
-</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('Typed Array')}}</td>
-   <td>{{Spec2('Typed Array')}}</td>
-   <td>Remplacée dans ECMAScript 2015.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES2015', '#table-49', 'TypedArray constructors')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale au sein d'un standard ECMA. <code>new</code> est obligatoire.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#table-49', 'TypedArray constructors')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td>ECMAScript 2017 a modifié le constructeur afin de pouvoir utiliser l'opération interne <code>ToIndex</code> et permettre de l'utiliser sans argument.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Int32Array")}}</p>
-
-<h2 id="Notes_de_compatibilité">Notes de compatibilité</h2>
-
-<p>À partir d'ECMAScript 2015 (ES6), <code>Int32Array</code> doit être utilisé avec {{jsxref("Opérateurs/L_opérateur_new", "new")}}. Appeler un constructeur <code>Int32Array</code> comme une fonction, sans <code>new</code>, provoquera une exception {{jsxref("TypeError")}}.</p>
-
-<pre class="brush: js example-bad">var dv = Int32Array([1, 2, 3]);
+```
+
+## Spécifications
+
+| Spécification                                                                        | État                             | Commentaires                                                                                                                               |
+| ------------------------------------------------------------------------------------ | -------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------ |
+| {{SpecName('Typed Array')}}                                                 | {{Spec2('Typed Array')}} | Remplacée dans ECMAScript 2015.                                                                                                            |
+| {{SpecName('ES2015', '#table-49', 'TypedArray constructors')}} | {{Spec2('ES2015')}}         | Définition initiale au sein d'un standard ECMA. `new` est obligatoire.                                                                     |
+| {{SpecName('ESDraft', '#table-49', 'TypedArray constructors')}} | {{Spec2('ESDraft')}}     | ECMAScript 2017 a modifié le constructeur afin de pouvoir utiliser l'opération interne `ToIndex` et permettre de l'utiliser sans argument. |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Int32Array")}}
+
+## Notes de compatibilité
+
+À partir d'ECMAScript 2015 (ES6), `Int32Array` doit être utilisé avec {{jsxref("Opérateurs/L_opérateur_new", "new")}}. Appeler un constructeur `Int32Array` comme une fonction, sans `new`, provoquera une exception {{jsxref("TypeError")}}.
+
+```js example-bad
+var dv = Int32Array([1, 2, 3]);
 // TypeError: calling a builtin Int32Array constructor
-// without new is forbidden</pre>
+// without new is forbidden
+```
 
-<pre class="brush: js example-good">var dv = new Int32Array([1, 2, 3]);</pre>
+```js example-good
+var dv = new Int32Array([1, 2, 3]);
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li><a href="/fr/docs/Web/JavaScript/Tableaux_typés" title="en/JavaScript typed arrays">Les tableaux typés (<em>typed arrays</em>) en JavaScript</a></li>
- <li>{{jsxref("ArrayBuffer")}}</li>
- <li>{{jsxref("DataView")}}</li>
-</ul>
+- [Les tableaux typés (_typed arrays_) en JavaScript](/fr/docs/Web/JavaScript/Tableaux_typés "en/JavaScript typed arrays")
+- {{jsxref("ArrayBuffer")}}
+- {{jsxref("DataView")}}
diff --git a/files/fr/web/javascript/reference/global_objects/int8array/index.md b/files/fr/web/javascript/reference/global_objects/int8array/index.md
index b15a6f7ffd..9ba2e0b403 100644
--- a/files/fr/web/javascript/reference/global_objects/int8array/index.md
+++ b/files/fr/web/javascript/reference/global_objects/int8array/index.md
@@ -11,125 +11,118 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Int8Array
 original_slug: Web/JavaScript/Reference/Objets_globaux/Int8Array
 ---
-<div>{{JSRef}}</div>
-
-<p>Le tableau typé <strong><code>Int8Array</code></strong> permet de représenter un tableau d'entiers signés (en complément à deux) représentés sur 8 bits. Les éléments du tableau sont initialisés à 0. Une fois le tableau construit, il est possible de faire référence aux éléments en utilisant les méthodes de l'objet ou en utilisant la notation usuelle de parcours d'un tableau (la syntaxe utilisant les crochets).</p>
-
-<h2 id="Syntaxe">Syntaxe</h2>
-
-<pre class="syntaxbox">new Int8Array(); // apparu avec ES2017
-new Int8Array(length);
-new Int8Array(typedArray);
-new Int8Array(object);
-new Int8Array(buffer [, byteOffset [, length]]);</pre>
-
-<p>Pour plus d'informations sur la syntaxe du constructeur, voir la page sur les <a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/TypedArray#Syntaxe">tableaux typés</a><em> (TypedArray)</em>.</p>
-
-<h2 id="Propriétés">Propriétés</h2>
-
-<dl>
- <dt>{{jsxref("TypedArray.BYTES_PER_ELEMENT", "Int8Array.BYTES_PER_ELEMENT")}}</dt>
- <dd>Renvoie un nombre représentant la taille d'un élément du tableau en termes d'octets. Dans le cas de <code>Int8Array</code>, la propriété vaudra 1.</dd>
- <dt><code>Int8Array.length</code></dt>
- <dd>Une propriété de longueur statique qui vaut 3. Pour connaître le nombre d'élément, voir {{jsxref("TypedArray.prototype.length", "Int8Array.prototype.length")}}.</dd>
- <dt>{{jsxref("TypedArray.name", "Int8Array.name")}}</dt>
- <dd>Renvoie la chaîne de caractère représentant le nom du constructeur. Dans le cas de <code>Int8Array</code>, la propriété vaudra "Int8Array".</dd>
- <dt>{{jsxref("TypedArray.prototype", "Int8Array.prototype")}}</dt>
- <dd>Prototype pour les objets <em>TypedArray</em>.</dd>
-</dl>
-
-<h2 id="Méthodes">Méthodes</h2>
-
-<dl>
- <dt>Int8Array.from()</dt>
- <dd>Crée un nouvel objet <code>Int8Array</code> à partir d'un objet semblable à un tableau ou d'un objet itérable. Voir également la page {{jsxref("Array.from()")}}.</dd>
- <dt>Int8Array.of()</dt>
- <dd>Crée un nouvel objet <code>Int8Array</code> à partir d'un nombre variable d'arguments. Voir également la page {{jsxref("Array.of()")}}.</dd>
-</dl>
-
-<h2 id="Prototype_de_Int8Array">Prototype de <code>Int8Array</code></h2>
-
-<p>Tous les objets <code>Int8Array</code> héritent de {{jsxref("TypedArray.prototype", "%TypedArray%.prototype")}}.</p>
-
-<h3 id="Propriétés_2">Propriétés</h3>
-
-<dl>
- <dt><code>Int8Array.prototype.constructor</code></dt>
- <dd>Renvoie la fonction qui a créé l'instance. Par défaut, c'est le constructeur <code>Int8Array</code>.</dd>
- <dt>{{jsxref("TypedArray.prototype.buffer", "Int8Array.prototype.buffer")}} {{readonlyInline}}</dt>
- <dd>Renvoie l'objet {{jsxref("ArrayBuffer")}} auquel fait référence le tableau <code>Int8Array</code>. Cette valeur est fixée lors de la construction et est uniquement disponible en lecture.</dd>
- <dt>{{jsxref("TypedArray.prototype.byteLength", "Int8Array.prototype.byteLength")}} {{readonlyInline}}</dt>
- <dd>Renvoie la longueur (exprimée en octet) du tableau <code>Int8Array</code> depuis le début du tampon {{jsxref("ArrayBuffer")}}. Cette valeur est fixée lors de la construction et est uniquement disponible en lecture.</dd>
- <dt>{{jsxref("TypedArray.prototype.byteOffset", "Int8Array.prototype.byteOffset")}} {{readonlyInline}}</dt>
- <dd>Renvoie le décalage (exprimé en octets) du tableau <code>Int8Array</code> par rapport au début du tampon {{jsxref("ArrayBuffer")}}. Cette valeur est fixée lors de la construction et est uniquement disponible en lecture.</dd>
- <dt>{{jsxref("TypedArray.prototype.length", "Int8Array.prototype.length")}} {{readonlyInline}}</dt>
- <dd>Renvoie le nombre d'éléments contenus dans le tableau <code>Int8Array</code>. Cette valeur est fixée lors de la construction et est uniquement disponible en lecture.</dd>
-</dl>
-
-<h3 id="Méthodes_2">Méthodes</h3>
-
-<dl>
- <dt>{{jsxref("TypedArray.copyWithin", "Int8Array.prototype.copyWithin()")}}</dt>
- <dd>Copie une suite d'éléments d'un tableau dans le tableau. Voir également {{jsxref("Array.prototype.copyWithin()")}}.</dd>
- <dt>{{jsxref("TypedArray.entries", "Int8Array.prototype.entries()")}}</dt>
- <dd>Renvoie un nouvel objet <code>Array Iterator</code> qui contient les paires clé/valeur pour chaque indice du tableau. Voir également {{jsxref("Array.prototype.entries()")}}.</dd>
- <dt>{{jsxref("TypedArray.every", "Int8Array.prototype.every()")}}</dt>
- <dd>Teste si l'ensemble des éléments du tableau remplissent une certaine condition donnée par une fonction de test. Voir également {{jsxref("Array.prototype.every()")}}.</dd>
- <dt>{{jsxref("TypedArray.fill", "Int8Array.prototype.fill()")}}</dt>
- <dd>Remplit les éléments d'un tableau avec une certaine valeur pour les éléments compris entre un indice de début et un indice de fin. Voir également {{jsxref("Array.prototype.fill()")}}.</dd>
- <dt>{{jsxref("TypedArray.filter", "Int8Array.prototype.filter()")}}</dt>
- <dd>Crée un nouveau tableau dont tous les éléments proviennent de ce tableau et respectent une condition fournie par une fonction de test. Voir également {{jsxref("Array.prototype.filter()")}}.</dd>
- <dt>{{jsxref("TypedArray.find", "Int8Array.prototype.find()")}}</dt>
- <dd>Renvoie une valeur trouvée dans le tableau s'il existe un élément du tableau qui satisfait une condition fournie par une fonction de test, s'il n'y a pas de tel élément <code>undefined</code> sera renvoyé. Voir également {{jsxref("Array.prototype.find()")}}.</dd>
- <dt>{{jsxref("TypedArray.findIndex", "Int8Array.prototype.findIndex()")}}</dt>
- <dd>Renvoie l'indice d'un élément qui satisfait une condition fournie par une fonction de test, si aucun élément ne remplit la condition -1 sera renvoyé. Voir également {{jsxref("Array.prototype.findIndex()")}}.</dd>
- <dt>{{jsxref("TypedArray.forEach", "Int8Array.prototype.forEach()")}}</dt>
- <dd>Appelle une fonction pour chacun des élément du tableau. Voir également {{jsxref("Array.prototype.forEach()")}}.</dd>
- <dt>{{jsxref("TypedArray.includes", "Int8Array.prototype.includes()")}}</dt>
- <dd>Détermine si le tableau typé contient un élément donné. Cette méthode renvoie <code>true</code> ou <code>false</code> selon le cas de figure. Voir également {{jsxref("Array.prototype.includes()")}}.</dd>
- <dt>{{jsxref("TypedArray.indexOf", "Int8Array.prototype.indexOf()")}}</dt>
- <dd>Renvoie le premier indice (le plus petit) d'un élément du tableau qui est égal à la valeur fournie. Si aucun élément ne correspond, la valeur -1 sera renvoyée. Voir également {{jsxref("Array.prototype.indexOf()")}}.</dd>
- <dt>{{jsxref("TypedArray.join", "Int8Array.prototype.join()")}}</dt>
- <dd>Fusionne l'ensemble des éléments du tableau en une chaîne de caractères. Voir également {{jsxref("Array.prototype.join()")}}.</dd>
- <dt>{{jsxref("TypedArray.keys", "Int8Array.prototype.keys()")}}</dt>
- <dd>Renvoie un nouvel objet <code>Array Iterator</code> qui contient les clés de chaque indice du tableau. Voir également {{jsxref("Array.prototype.keys()")}}.</dd>
- <dt>{{jsxref("TypedArray.lastIndexOf", "Int8Array.prototype.lastIndexOf()")}}</dt>
- <dd>Renvoie le dernier indice (le plus élevé) d'un élément du tableau qui est égal à la valeur fournie. Si aucun élément ne correspond, la valeur -1 sera renvoyée. Voir également {{jsxref("Array.prototype.lastIndexOf()")}}.</dd>
- <dt>{{jsxref("TypedArray.map", "Int8Array.prototype.map()")}}</dt>
- <dd>Crée un nouveau tableau dont les éléments sont les images des éléments du tableau courant par une fonction donnée. Voir également {{jsxref("Array.prototype.map()")}}.</dd>
- <dt>{{jsxref("TypedArray.move", "Int8Array.prototype.move()")}} {{non-standard_inline}} {{unimplemented_inline}}</dt>
- <dd>Ancienne version, non-standard, de {{jsxref("TypedArray.copyWithin", "Int8Array.prototype.copyWithin()")}}.</dd>
- <dt>{{jsxref("TypedArray.reduce", "Int8Array.prototype.reduce()")}}</dt>
- <dd>Applique une fonction sur un accumulateur et chaque élément du tableau (de gauche à droite) afin de réduire le tableau en une seule valeur. Voir également {{jsxref("Array.prototype.reduce()")}}.</dd>
- <dt>{{jsxref("TypedArray.reduceRight", "Int8Array.prototype.reduceRight()")}}</dt>
- <dd>Applique une fonction sur un accumulateur et chaque élément du tableau (de droite à gauche) afin de réduire le tableau en une seule valeur. Voir également {{jsxref("Array.prototype.reduceRight()")}}.</dd>
- <dt>{{jsxref("TypedArray.reverse", "Int8Array.prototype.reverse()")}}</dt>
- <dd>Inverse l'ordre des éléments d'un tableau. Le premier élément du tableau devient le dernier et le dernier devient le premier (et ainsi de suite). Voir également {{jsxref("Array.prototype.reverse()")}}.</dd>
- <dt>{{jsxref("TypedArray.set", "Int8Array.prototype.set()")}}</dt>
- <dd>Enregistre plusieurs valeurs dans le tableau typé à partir de valeurs d'un autre tableau.</dd>
- <dt>{{jsxref("TypedArray.slice", "Int8Array.prototype.slice()")}}</dt>
- <dd>Extrait un fragment d'un tableau et renvoie ce fragment. Voir également {{jsxref("Array.prototype.slice()")}}.</dd>
- <dt>{{jsxref("TypedArray.some", "Int8Array.prototype.some()")}}</dt>
- <dd>Renvoie <code>true</code> si au moins un des éléments remplit une condition donnée par une fonction de test. Voir également {{jsxref("Array.prototype.some()")}}.</dd>
- <dt>{{jsxref("TypedArray.sort", "Int8Array.prototype.sort()")}}</dt>
- <dd>Trie les éléments du tableau et renvoie ce tableau. Voir également {{jsxref("Array.prototype.sort()")}}.</dd>
- <dt>{{jsxref("TypedArray.subarray", "Int8Array.prototype.subarray()")}}</dt>
- <dd>Renvoie un nouvel objet <code>Int8Array</code> qui est le fragment du tableau courant, entre les indices de début et de fin donnés.</dd>
- <dt>{{jsxref("TypedArray.values", "Int8Array.prototype.values()")}}</dt>
- <dd>Renvoie un nouvel objet <code>Array Iterator</code> qui contient les valeurs correspondantes à chaque indice du tableau. Voir également {{jsxref("Array.prototype.values()")}}.</dd>
- <dt>{{jsxref("TypedArray.toLocaleString", "Int8Array.prototype.toLocaleString()")}}</dt>
- <dd>Renvoie une chaîne de caractères localisée qui représente le tableau et ses éléments. Voir également {{jsxref("Array.prototype.toLocaleString()")}}.</dd>
- <dt>{{jsxref("TypedArray.toString", "Int8Array.prototype.toString()")}}</dt>
- <dd>Renvoie une chaîne de caractère qui représente le tableau et ses éléments. Voir également {{jsxref("Array.prototype.toString()")}}.</dd>
- <dt>{{jsxref("TypedArray.@@iterator", "Int8Array.prototype[@@iterator]()")}}</dt>
- <dd>Renvoie un nouvel objet <code>Array Iterator</code> qui contient les valeurs correspondantes à chaque indice du tableau.</dd>
-</dl>
-
-<h2 id="Exemples">Exemples</h2>
-
-<p>Différentes façons de créer un objet <code>Int8Array</code> :</p>
-
-<pre class="brush: js">// Construction à partir d'une longueur
+{{JSRef}}
+
+Le tableau typé **`Int8Array`** permet de représenter un tableau d'entiers signés (en complément à deux) représentés sur 8 bits. Les éléments du tableau sont initialisés à 0. Une fois le tableau construit, il est possible de faire référence aux éléments en utilisant les méthodes de l'objet ou en utilisant la notation usuelle de parcours d'un tableau (la syntaxe utilisant les crochets).
+
+## Syntaxe
+
+    new Int8Array(); // apparu avec ES2017
+    new Int8Array(length);
+    new Int8Array(typedArray);
+    new Int8Array(object);
+    new Int8Array(buffer [, byteOffset [, length]]);
+
+Pour plus d'informations sur la syntaxe du constructeur, voir la page sur les [tableaux typés](/fr/docs/Web/JavaScript/Reference/Objets_globaux/TypedArray#Syntaxe) _(TypedArray)_.
+
+## Propriétés
+
+- {{jsxref("TypedArray.BYTES_PER_ELEMENT", "Int8Array.BYTES_PER_ELEMENT")}}
+  - : Renvoie un nombre représentant la taille d'un élément du tableau en termes d'octets. Dans le cas de `Int8Array`, la propriété vaudra 1.
+- `Int8Array.length`
+  - : Une propriété de longueur statique qui vaut 3. Pour connaître le nombre d'élément, voir {{jsxref("TypedArray.prototype.length", "Int8Array.prototype.length")}}.
+- {{jsxref("TypedArray.name", "Int8Array.name")}}
+  - : Renvoie la chaîne de caractère représentant le nom du constructeur. Dans le cas de `Int8Array`, la propriété vaudra "Int8Array".
+- {{jsxref("TypedArray.prototype", "Int8Array.prototype")}}
+  - : Prototype pour les objets _TypedArray_.
+
+## Méthodes
+
+- Int8Array.from()
+  - : Crée un nouvel objet `Int8Array` à partir d'un objet semblable à un tableau ou d'un objet itérable. Voir également la page {{jsxref("Array.from()")}}.
+- Int8Array.of()
+  - : Crée un nouvel objet `Int8Array` à partir d'un nombre variable d'arguments. Voir également la page {{jsxref("Array.of()")}}.
+
+## Prototype de `Int8Array`
+
+Tous les objets `Int8Array` héritent de {{jsxref("TypedArray.prototype", "%TypedArray%.prototype")}}.
+
+### Propriétés
+
+- `Int8Array.prototype.constructor`
+  - : Renvoie la fonction qui a créé l'instance. Par défaut, c'est le constructeur `Int8Array`.
+- {{jsxref("TypedArray.prototype.buffer", "Int8Array.prototype.buffer")}} {{readonlyInline}}
+  - : Renvoie l'objet {{jsxref("ArrayBuffer")}} auquel fait référence le tableau `Int8Array`. Cette valeur est fixée lors de la construction et est uniquement disponible en lecture.
+- {{jsxref("TypedArray.prototype.byteLength", "Int8Array.prototype.byteLength")}} {{readonlyInline}}
+  - : Renvoie la longueur (exprimée en octet) du tableau `Int8Array` depuis le début du tampon {{jsxref("ArrayBuffer")}}. Cette valeur est fixée lors de la construction et est uniquement disponible en lecture.
+- {{jsxref("TypedArray.prototype.byteOffset", "Int8Array.prototype.byteOffset")}} {{readonlyInline}}
+  - : Renvoie le décalage (exprimé en octets) du tableau `Int8Array` par rapport au début du tampon {{jsxref("ArrayBuffer")}}. Cette valeur est fixée lors de la construction et est uniquement disponible en lecture.
+- {{jsxref("TypedArray.prototype.length", "Int8Array.prototype.length")}} {{readonlyInline}}
+  - : Renvoie le nombre d'éléments contenus dans le tableau `Int8Array`. Cette valeur est fixée lors de la construction et est uniquement disponible en lecture.
+
+### Méthodes
+
+- {{jsxref("TypedArray.copyWithin", "Int8Array.prototype.copyWithin()")}}
+  - : Copie une suite d'éléments d'un tableau dans le tableau. Voir également {{jsxref("Array.prototype.copyWithin()")}}.
+- {{jsxref("TypedArray.entries", "Int8Array.prototype.entries()")}}
+  - : Renvoie un nouvel objet `Array Iterator` qui contient les paires clé/valeur pour chaque indice du tableau. Voir également {{jsxref("Array.prototype.entries()")}}.
+- {{jsxref("TypedArray.every", "Int8Array.prototype.every()")}}
+  - : Teste si l'ensemble des éléments du tableau remplissent une certaine condition donnée par une fonction de test. Voir également {{jsxref("Array.prototype.every()")}}.
+- {{jsxref("TypedArray.fill", "Int8Array.prototype.fill()")}}
+  - : Remplit les éléments d'un tableau avec une certaine valeur pour les éléments compris entre un indice de début et un indice de fin. Voir également {{jsxref("Array.prototype.fill()")}}.
+- {{jsxref("TypedArray.filter", "Int8Array.prototype.filter()")}}
+  - : Crée un nouveau tableau dont tous les éléments proviennent de ce tableau et respectent une condition fournie par une fonction de test. Voir également {{jsxref("Array.prototype.filter()")}}.
+- {{jsxref("TypedArray.find", "Int8Array.prototype.find()")}}
+  - : Renvoie une valeur trouvée dans le tableau s'il existe un élément du tableau qui satisfait une condition fournie par une fonction de test, s'il n'y a pas de tel élément `undefined` sera renvoyé. Voir également {{jsxref("Array.prototype.find()")}}.
+- {{jsxref("TypedArray.findIndex", "Int8Array.prototype.findIndex()")}}
+  - : Renvoie l'indice d'un élément qui satisfait une condition fournie par une fonction de test, si aucun élément ne remplit la condition -1 sera renvoyé. Voir également {{jsxref("Array.prototype.findIndex()")}}.
+- {{jsxref("TypedArray.forEach", "Int8Array.prototype.forEach()")}}
+  - : Appelle une fonction pour chacun des élément du tableau. Voir également {{jsxref("Array.prototype.forEach()")}}.
+- {{jsxref("TypedArray.includes", "Int8Array.prototype.includes()")}}
+  - : Détermine si le tableau typé contient un élément donné. Cette méthode renvoie `true` ou `false` selon le cas de figure. Voir également {{jsxref("Array.prototype.includes()")}}.
+- {{jsxref("TypedArray.indexOf", "Int8Array.prototype.indexOf()")}}
+  - : Renvoie le premier indice (le plus petit) d'un élément du tableau qui est égal à la valeur fournie. Si aucun élément ne correspond, la valeur -1 sera renvoyée. Voir également {{jsxref("Array.prototype.indexOf()")}}.
+- {{jsxref("TypedArray.join", "Int8Array.prototype.join()")}}
+  - : Fusionne l'ensemble des éléments du tableau en une chaîne de caractères. Voir également {{jsxref("Array.prototype.join()")}}.
+- {{jsxref("TypedArray.keys", "Int8Array.prototype.keys()")}}
+  - : Renvoie un nouvel objet `Array Iterator` qui contient les clés de chaque indice du tableau. Voir également {{jsxref("Array.prototype.keys()")}}.
+- {{jsxref("TypedArray.lastIndexOf", "Int8Array.prototype.lastIndexOf()")}}
+  - : Renvoie le dernier indice (le plus élevé) d'un élément du tableau qui est égal à la valeur fournie. Si aucun élément ne correspond, la valeur -1 sera renvoyée. Voir également {{jsxref("Array.prototype.lastIndexOf()")}}.
+- {{jsxref("TypedArray.map", "Int8Array.prototype.map()")}}
+  - : Crée un nouveau tableau dont les éléments sont les images des éléments du tableau courant par une fonction donnée. Voir également {{jsxref("Array.prototype.map()")}}.
+- {{jsxref("TypedArray.move", "Int8Array.prototype.move()")}} {{non-standard_inline}} {{unimplemented_inline}}
+  - : Ancienne version, non-standard, de {{jsxref("TypedArray.copyWithin", "Int8Array.prototype.copyWithin()")}}.
+- {{jsxref("TypedArray.reduce", "Int8Array.prototype.reduce()")}}
+  - : Applique une fonction sur un accumulateur et chaque élément du tableau (de gauche à droite) afin de réduire le tableau en une seule valeur. Voir également {{jsxref("Array.prototype.reduce()")}}.
+- {{jsxref("TypedArray.reduceRight", "Int8Array.prototype.reduceRight()")}}
+  - : Applique une fonction sur un accumulateur et chaque élément du tableau (de droite à gauche) afin de réduire le tableau en une seule valeur. Voir également {{jsxref("Array.prototype.reduceRight()")}}.
+- {{jsxref("TypedArray.reverse", "Int8Array.prototype.reverse()")}}
+  - : Inverse l'ordre des éléments d'un tableau. Le premier élément du tableau devient le dernier et le dernier devient le premier (et ainsi de suite). Voir également {{jsxref("Array.prototype.reverse()")}}.
+- {{jsxref("TypedArray.set", "Int8Array.prototype.set()")}}
+  - : Enregistre plusieurs valeurs dans le tableau typé à partir de valeurs d'un autre tableau.
+- {{jsxref("TypedArray.slice", "Int8Array.prototype.slice()")}}
+  - : Extrait un fragment d'un tableau et renvoie ce fragment. Voir également {{jsxref("Array.prototype.slice()")}}.
+- {{jsxref("TypedArray.some", "Int8Array.prototype.some()")}}
+  - : Renvoie `true` si au moins un des éléments remplit une condition donnée par une fonction de test. Voir également {{jsxref("Array.prototype.some()")}}.
+- {{jsxref("TypedArray.sort", "Int8Array.prototype.sort()")}}
+  - : Trie les éléments du tableau et renvoie ce tableau. Voir également {{jsxref("Array.prototype.sort()")}}.
+- {{jsxref("TypedArray.subarray", "Int8Array.prototype.subarray()")}}
+  - : Renvoie un nouvel objet `Int8Array` qui est le fragment du tableau courant, entre les indices de début et de fin donnés.
+- {{jsxref("TypedArray.values", "Int8Array.prototype.values()")}}
+  - : Renvoie un nouvel objet `Array Iterator` qui contient les valeurs correspondantes à chaque indice du tableau. Voir également {{jsxref("Array.prototype.values()")}}.
+- {{jsxref("TypedArray.toLocaleString", "Int8Array.prototype.toLocaleString()")}}
+  - : Renvoie une chaîne de caractères localisée qui représente le tableau et ses éléments. Voir également {{jsxref("Array.prototype.toLocaleString()")}}.
+- {{jsxref("TypedArray.toString", "Int8Array.prototype.toString()")}}
+  - : Renvoie une chaîne de caractère qui représente le tableau et ses éléments. Voir également {{jsxref("Array.prototype.toString()")}}.
+- {{jsxref("TypedArray.@@iterator", "Int8Array.prototype[@@iterator]()")}}
+  - : Renvoie un nouvel objet `Array Iterator` qui contient les valeurs correspondantes à chaque indice du tableau.
+
+## Exemples
+
+Différentes façons de créer un objet `Int8Array` :
+
+```js
+// Construction à partir d'une longueur
 var int8 = new Int8Array(2);
 int8[0] = 42;
 console.log(int8[0]); // 42
@@ -153,53 +146,36 @@ var z = new Int8Array(buffer, 1, 4);
 var iterable = function*(){ yield* [1,2,3]; }();
 var int8 = new Int8Array(iterable);
 // Int8Array[1, 2, 3]
-</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('Typed Array')}}</td>
-   <td>{{Spec2('Typed Array')}}</td>
-   <td>Remplacée dans ECMAScript 2015.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES2015', '#table-49', 'TypedArray constructors')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale au sein d'un standard ECMA. <code>new</code> est obligatoire.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#table-49', 'TypedArray constructors')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td>ECMAScript 2017 a modifié le constructeur afin d'utiliser l'opération interne <code>ToIndex</code> et permettre de l'utiliser sans constructeur.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Int8Array")}}</p>
-
-<h2 id="Notes_de_compatibilité">Notes de compatibilité</h2>
-
-<p>À partir d'ECMAScript 2015 (ES6), <code>Int8Array</code> doit être utilisé avec {{jsxref("Opérateurs/L_opérateur_new", "new")}}. Appeler un constructeur <code>Int8Array</code> comme une fonction, sans <code>new</code>, provoquera une exception {{jsxref("TypeError")}}.</p>
-
-<pre class="brush: js example-bad">var dv = Int8Array([1, 2, 3]);
+```
+
+## Spécifications
+
+| Spécification                                                                        | État                             | Commentaires                                                                                                                          |
+| ------------------------------------------------------------------------------------ | -------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------- |
+| {{SpecName('Typed Array')}}                                                 | {{Spec2('Typed Array')}} | Remplacée dans ECMAScript 2015.                                                                                                       |
+| {{SpecName('ES2015', '#table-49', 'TypedArray constructors')}} | {{Spec2('ES2015')}}         | Définition initiale au sein d'un standard ECMA. `new` est obligatoire.                                                                |
+| {{SpecName('ESDraft', '#table-49', 'TypedArray constructors')}} | {{Spec2('ESDraft')}}     | ECMAScript 2017 a modifié le constructeur afin d'utiliser l'opération interne `ToIndex` et permettre de l'utiliser sans constructeur. |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Int8Array")}}
+
+## Notes de compatibilité
+
+À partir d'ECMAScript 2015 (ES6), `Int8Array` doit être utilisé avec {{jsxref("Opérateurs/L_opérateur_new", "new")}}. Appeler un constructeur `Int8Array` comme une fonction, sans `new`, provoquera une exception {{jsxref("TypeError")}}.
+
+```js example-bad
+var dv = Int8Array([1, 2, 3]);
 // TypeError: calling a builtin Int8Array constructor
-// without new is forbidden</pre>
+// without new is forbidden
+```
 
-<pre class="brush: js example-good">var dv = new Int8Array([1, 2, 3]);</pre>
+```js example-good
+var dv = new Int8Array([1, 2, 3]);
+```
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li><a href="/fr/docs/Web/JavaScript/Tableaux_typés" title="en/JavaScript typed arrays">Les tableaux typés (<em>typed arrays</em>) en JavaScript</a></li>
- <li>{{jsxref("ArrayBuffer")}}</li>
- <li>{{jsxref("DataView")}}</li>
-</ul>
+- [Les tableaux typés (_typed arrays_) en JavaScript](/fr/docs/Web/JavaScript/Tableaux_typés "en/JavaScript typed arrays")
+- {{jsxref("ArrayBuffer")}}
+- {{jsxref("DataView")}}
diff --git a/files/fr/web/javascript/reference/global_objects/internalerror/index.md b/files/fr/web/javascript/reference/global_objects/internalerror/index.md
index 02a1e3afdd..b29240ddb4 100644
--- a/files/fr/web/javascript/reference/global_objects/internalerror/index.md
+++ b/files/fr/web/javascript/reference/global_objects/internalerror/index.md
@@ -9,70 +9,62 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/InternalError
 original_slug: Web/JavaScript/Reference/Objets_globaux/InternalError
 ---
-<div>{{JSRef}} {{non-standard_header}}</div>
+{{JSRef}} {{non-standard_header}}
 
-<p>L'objet <strong><code>InternalError</code></strong> indique qu'une erreur liée au moteur JavaScript s'est produite. Par exemple <strong>"InternalError </strong>: Niveau de récursion trop important".</p>
+L'objet **`InternalError`** indique qu'une erreur liée au moteur JavaScript s'est produite. Par exemple **"InternalError** : Niveau de récursion trop important".
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">new InternalError([<var>message</var>[, <var>fileName</var>[, <var>lineNumber</var>]]])</pre>
+    new InternalError([message[, fileName[, lineNumber]]])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>message</code></dt>
- <dd>Paramètre optionnel. Une description de l'erreur compréhensible pour un être humain.</dd>
- <dt><code>fileName</code> {{Non-standard_inline}}</dt>
- <dd>Paramètre optionnel. Le nom du fichier contenant le code à l'origine de l'erreur.</dd>
- <dt><code>lineNumber</code> {{Non-standard_inline}}</dt>
- <dd>Paramètre optionnel. Le numéro de la ligne du code à l'origine de l'erreur.</dd>
-</dl>
+- `message`
+  - : Paramètre optionnel. Une description de l'erreur compréhensible pour un être humain.
+- `fileName` {{Non-standard_inline}}
+  - : Paramètre optionnel. Le nom du fichier contenant le code à l'origine de l'erreur.
+- `lineNumber` {{Non-standard_inline}}
+  - : Paramètre optionnel. Le numéro de la ligne du code à l'origine de l'erreur.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Une exception <code>InternalError</code> est levée à chaque fois qu'il se produit une erreur interne au moteur JavaScript.</p>
+Une exception `InternalError` est levée à chaque fois qu'il se produit une erreur interne au moteur JavaScript.
 
-<p>Le plus souvent, cette exception se produit lorsque quelque chose atteint un niveau trop élévé. Par exemple :</p>
+Le plus souvent, cette exception se produit lorsque quelque chose atteint un niveau trop élévé. Par exemple :
 
-<ul>
- <li>trop de cas dans une construction switch,</li>
- <li>trop de parenthèses au sein d'une expression rationnelle,</li>
- <li>un tableau littéral trop grand,</li>
- <li>trop de niveaux de récursion.</li>
-</ul>
+- trop de cas dans une construction switch,
+- trop de parenthèses au sein d'une expression rationnelle,
+- un tableau littéral trop grand,
+- trop de niveaux de récursion.
 
-<h2 id="Propriétés">Propriétés</h2>
+## Propriétés
 
-<dl>
- <dt>{{jsxref("InternalError.prototype")}}</dt>
- <dd>Permet l'ajout de nouvelles propriétés à un objet <code>InternalError</code>.</dd>
-</dl>
+- {{jsxref("InternalError.prototype")}}
+  - : Permet l'ajout de nouvelles propriétés à un objet `InternalError`.
 
-<h2 id="Méthodes">Méthodes</h2>
+## Méthodes
 
-<p>L'objet global <code>InternalError</code> ne contient pas de méthode propre. En revanche, il hérite de certaines méthodes via sa chaîne de prototypes.</p>
+L'objet global `InternalError` ne contient pas de méthode propre. En revanche, il hérite de certaines méthodes via sa chaîne de prototypes.
 
-<h2 id="Instances_de_InternalError">Instances de <code>InternalError</code></h2>
+## Instances de `InternalError`
 
-<h3 id="Propriétés_2">Propriétés</h3>
+### Propriétés
 
-<div>{{page("/fr/docs/JavaScript/Reference/Objets_globaux/InternalError/prototype","Properties")}}</div>
+{{page("/fr/docs/JavaScript/Reference/Objets_globaux/InternalError/prototype","Properties")}}
 
-<h3 id="Méthodes_2">Méthodes</h3>
+### Méthodes
 
-<div>{{page("/fr/docs/JavaScript/Reference/Objets_globaux/InternalError/prototype","Methods")}}</div>
+{{page("/fr/docs/JavaScript/Reference/Objets_globaux/InternalError/prototype","Methods")}}
 
-<h2 id="Spécifications">Spécifications</h2>
+## Spécifications
 
-<p>Cet objet ne fait partie d'aucune spécification.</p>
+Cet objet ne fait partie d'aucune spécification.
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.InternalError")}}</p>
+{{Compat("javascript.builtins.InternalError")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("Error")}}</li>
- <li>{{jsxref("InternalError.prototype")}}</li>
-</ul>
+- {{jsxref("Error")}}
+- {{jsxref("InternalError.prototype")}}
diff --git a/files/fr/web/javascript/reference/global_objects/intl/collator/compare/index.md b/files/fr/web/javascript/reference/global_objects/intl/collator/compare/index.md
index 90931a110d..0c4e0f30e3 100644
--- a/files/fr/web/javascript/reference/global_objects/intl/collator/compare/index.md
+++ b/files/fr/web/javascript/reference/global_objects/intl/collator/compare/index.md
@@ -13,86 +13,67 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Intl/Collator/compare
 original_slug: Web/JavaScript/Reference/Objets_globaux/Intl/Collator/compare
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>Intl.Collator.prototype.compare()</strong></code> compare deux chaînes de caractères en tenant compte des options spécifiées pour la locale et l'ordre de tri dans l'objet {{jsxref("Collator")}}.</p>
+La méthode **`Intl.Collator.prototype.compare()`** compare deux chaînes de caractères en tenant compte des options spécifiées pour la locale et l'ordre de tri dans l'objet {{jsxref("Collator")}}.
 
-<div>{{EmbedInteractiveExample("pages/js/intl-collator-prototype-compare.html")}}</div>
+{{EmbedInteractiveExample("pages/js/intl-collator-prototype-compare.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">collator.compare(chaine1, chaine2)</pre>
+    collator.compare(chaine1, chaine2)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>chaine1</code>, <code>chaine2</code></dt>
- <dd>Les chaînes de caractères à comparer.</dd>
-</dl>
+- `chaine1`, `chaine2`
+  - : Les chaînes de caractères à comparer.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>L'accesseur <code>compare</code> renvoie un nombre qui indique le résultat de la comparaison entre <code>chaine1</code> et <code>chaine2</code> selon l'ordre de tri de l'objet {{jsxref("Collator")}} : la valeur obtenue sera négative si <code>chaine1</code> précède <code>chaine2</code>, positive si <code>chaine1</code> succède à <code>chaine2</code>, nulle si les deux chaînes sont considérées égales.</p>
+L'accesseur `compare` renvoie un nombre qui indique le résultat de la comparaison entre `chaine1` et `chaine2` selon l'ordre de tri de l'objet {{jsxref("Collator")}} : la valeur obtenue sera négative si `chaine1` précède `chaine2`, positive si `chaine1` succède à `chaine2`, nulle si les deux chaînes sont considérées égales.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_compare_pour_trier_un_tableau">Utiliser <code>compare()</code> pour trier un tableau</h3>
+### Utiliser `compare()` pour trier un tableau
 
-<p>Dans cet exemple, on utilise la fonction de l'accesseur <code>compare</code> pour trier des tableaux. On observe que la fonction est liée à l'objet <code>Collator</code>, on peut donc directement la passer à la méthode {{jsxref("Array.prototype.sort()")}}.</p>
+Dans cet exemple, on utilise la fonction de l'accesseur `compare` pour trier des tableaux. On observe que la fonction est liée à l'objet `Collator`, on peut donc directement la passer à la méthode {{jsxref("Array.prototype.sort()")}}.
 
-<pre class="brush: js">var a = ["Offenbach", "Österreich", "Odenwald"];
+```js
+var a = ["Offenbach", "Österreich", "Odenwald"];
 var collator = new Intl.Collator("de-u-co-phonebk");
 a.sort(collator.compare);
 console.log(a.join(", "));
-// → "Odenwald, Österreich, Offenbach"</pre>
+// → "Odenwald, Österreich, Offenbach"
+```
 
-<h3 id="Utiliser_compare_pour_chercher_dans_un_tableau">Utiliser <code>compare()</code> pour chercher dans un tableau</h3>
+### Utiliser `compare()` pour chercher dans un tableau
 
-<p>Ici, on utilise la fonction de l'accesseur <code>compare</code> pour trouver les chaînes égales à une chaîne donnée parmi un tableau :</p>
+Ici, on utilise la fonction de l'accesseur `compare` pour trouver les chaînes égales à une chaîne donnée parmi un tableau :
 
-<pre class="brush: js">var a = ["Congrès", "congres", "Assemblée", "poisson"];
+```js
+var a = ["Congrès", "congres", "Assemblée", "poisson"];
 var collator = new Intl.Collator("fr", {usage: "search", sensitivity: "base"});
 var s = "congres";
 var matches = a.filter(function (v) {
     return collator.compare(v, s) === 0;
 });
 console.log(matches.join(", "));
-// → "Congrès, congres"</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('ES Int 1.0', '#sec-10.3.2', 'Intl.Collator.prototype.compare')}}</td>
-   <td>{{Spec2('ES Int 1.0')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES Int 2.0', '#sec-10.3.2', 'Intl.Collator.prototype.compare')}}</td>
-   <td>{{Spec2('ES Int 2.0')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES Int Draft', '#sec-Intl.Collator.prototype.compare', 'Intl.Collator.prototype.compare')}}</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.Intl.Collator.compare")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Collator", "Intl.Collator")}}</li>
- <li>{{jsxref("String.prototype.localeCompare()")}}</li>
-</ul>
+// → "Congrès, congres"
+```
+
+## Spécifications
+
+| Spécification                                                                                                                            | Statut                           | Commentaires         |
+| ---------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------- | -------------------- |
+| {{SpecName('ES Int 1.0', '#sec-10.3.2', 'Intl.Collator.prototype.compare')}}                                     | {{Spec2('ES Int 1.0')}} | Définition initiale. |
+| {{SpecName('ES Int 2.0', '#sec-10.3.2', 'Intl.Collator.prototype.compare')}}                                     | {{Spec2('ES Int 2.0')}} |                      |
+| {{SpecName('ES Int Draft', '#sec-Intl.Collator.prototype.compare', 'Intl.Collator.prototype.compare')}} | {{Spec2('ES Int Draft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Intl.Collator.compare")}}
+
+## Voir aussi
+
+- {{jsxref("Collator", "Intl.Collator")}}
+- {{jsxref("String.prototype.localeCompare()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/intl/collator/index.md b/files/fr/web/javascript/reference/global_objects/intl/collator/index.md
index 32b32ac4ef..497d476044 100644
--- a/files/fr/web/javascript/reference/global_objects/intl/collator/index.md
+++ b/files/fr/web/javascript/reference/global_objects/intl/collator/index.md
@@ -12,164 +12,137 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Intl/Collator
 original_slug: Web/JavaScript/Reference/Objets_globaux/Intl/Collator
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>L'objet <strong><code>Intl.Collator</code></strong> est un constructeur de « collecteurs », des objets permettant de comparer des chaînes de caractères en tenant compte de la locale.</p>
+L'objet **`Intl.Collator`** est un constructeur de « collecteurs », des objets permettant de comparer des chaînes de caractères en tenant compte de la locale.
 
-<div>{{EmbedInteractiveExample("pages/js/intl-collator.html")}}</div>
+{{EmbedInteractiveExample("pages/js/intl-collator.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">new Intl.Collator([<em>locales</em> [, <em>options</em>]])</pre>
+    new Intl.Collator([locales [, options]])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>locales</code></dt>
- <dd>
- <p>Une chaîne de caractères avec une balise de langue BCP 47 ou un tableau qui contient des chaînes dans ce format. Pour plus d'informations sur le format et l'interprétation de l'argument <code>locales</code>, voir la page {{jsxref("Objets_globaux/Intl", "Intl", "#Choix_de_la_locale")}}. Pour ce constructeur, les clés d'extensions Unicode suivantes sont acceptées :</p>
+- `locales`
 
- <dl>
-  <dt><code>co</code></dt>
-  <dd>Les variantes dans les méthodes de regroupement (« collation ») des chaînes de caractères. Les valeurs autorisées pour cette clé sont : <code>"big5han", "dict", "direct", "ducet", "gb2312", "phonebk", "phonetic", "pinyin", "reformed", "searchjl", "stroke", "trad", "unihan"</code>. Les valeurs <code>"standard"</code> et <code>"search"</code> sont ignorées. Elles sont remplacées par la propriété <code>usage</code> de l'argument <code>options</code> (voir ci-après).</dd>
-  <dt><code>kn</code></dt>
-  <dd>Indique si on ordonne les nombres (par exemple : "1" &lt; "2" &lt; "10"). Les valeurs possibles sont <code>"true"</code> et <code>"false"</code>. Cette option est également disponible via une propriété de l'objet <code>options</code>. Si l'extension Unicode et la propriété de l'objet <code>options</code> sont définies, ce sera cette dernière qui sera prise en compte.</dd>
-  <dt><code>kf</code></dt>
-  <dd>Indique si on ordonne les majuscules avant les minuscules ou l'inverse. Les valeurs possibles sont <code>"upper"</code>, <code>"lower"</code>, ou <code>"false"</code> (on utilise alors l'ordre par défaut de la locale). Cette option est également disponible via une propriété de l'objet <code>options</code>. Si l'extension Unicode et la propriété de l'objet <code>options</code> sont définies, ce sera cette dernière qui sera prise en compte.</dd>
- </dl>
- </dd>
- <dt><code>options</code></dt>
- <dd>
- <p>Un objet qui disposent des propriétés suivantes :</p>
+  - : Une chaîne de caractères avec une balise de langue BCP 47 ou un tableau qui contient des chaînes dans ce format. Pour plus d'informations sur le format et l'interprétation de l'argument `locales`, voir la page {{jsxref("Objets_globaux/Intl", "Intl", "#Choix_de_la_locale")}}. Pour ce constructeur, les clés d'extensions Unicode suivantes sont acceptées :
 
- <dl>
-  <dt><code>localeMatcher</code></dt>
-  <dd>L'algorithme de correspondance à utiliser pour les locales. Les valeurs possibles sont <code>"lookup"</code> et <code>"best fit"</code>. La valeur par défaut est "best fit". Voir la {{jsxref("Objets_globaux/Intl", "Intl", "#Choix_de_la_locale")}} pour plus d'informations à ce sujet.</dd>
-  <dt><code>usage</code></dt>
-  <dd>Indique l'usage de le comparaison : le tri ou la recherche de chaînes correspondantes. Les valeurs possibles sont "sort" pour le tri et "search" pour la recherche. La valeur par défaut est "sort".</dd>
-  <dt><code>sensitivity</code></dt>
-  <dd>Indique les différences entre les chaînes de caractères qui font qu'une chaîne est considérée différente d'une autre. Les valeurs possibles sont :
-  <ul>
-   <li><code>"base"</code> : Seules les chaînes dont les lettres de base sont différentes sont considérées inégales. Par exemple : a ≠ b, a = á, a = A.</li>
-   <li><code>"accent"</code> : Seules les chaînes de caractères dont les lettres de bases ou les accents ou les autres marques diacritiques diffèrent sont considérées inégales. Par exemple : a ≠ b, a ≠ á, a = A.</li>
-   <li><code>"case"</code> : Seules les chaines dont les lettres de base ou la casse sont diffèrent sont considérées comme inégales. Par exemple : a ≠ b, a = á, a ≠ A.</li>
-   <li><code>"variant"</code> : Les chaînes qui diffèrent par leurs caractères de base, leurs accents et autres marques diacritiques, la casse sont considérées comme inégales. D'autres différences peuvent également être prises en compte. Par exemple : a ≠ b, a ≠ á, a ≠ A.</li>
-  </ul>
+    - `co`
+      - : Les variantes dans les méthodes de regroupement (« collation ») des chaînes de caractères. Les valeurs autorisées pour cette clé sont : `"big5han", "dict", "direct", "ducet", "gb2312", "phonebk", "phonetic", "pinyin", "reformed", "searchjl", "stroke", "trad", "unihan"`. Les valeurs `"standard"` et `"search"` sont ignorées. Elles sont remplacées par la propriété `usage` de l'argument `options` (voir ci-après).
+    - `kn`
+      - : Indique si on ordonne les nombres (par exemple : "1" < "2" < "10"). Les valeurs possibles sont `"true"` et `"false"`. Cette option est également disponible via une propriété de l'objet `options`. Si l'extension Unicode et la propriété de l'objet `options` sont définies, ce sera cette dernière qui sera prise en compte.
+    - `kf`
+      - : Indique si on ordonne les majuscules avant les minuscules ou l'inverse. Les valeurs possibles sont `"upper"`, `"lower"`, ou `"false"` (on utilise alors l'ordre par défaut de la locale). Cette option est également disponible via une propriété de l'objet `options`. Si l'extension Unicode et la propriété de l'objet `options` sont définies, ce sera cette dernière qui sera prise en compte.
 
-  <p>La valeur par défaut est <code>"variant"</code> si on utilise la comparaison pour du tri (usage=<code>"sort"</code>). Pour l'utilisation <code>"search"</code> (recherche), la valeur par défaut dépend de la locale.</p>
-  </dd>
-  <dt><code>ignorePunctuation</code></dt>
-  <dd>Indique si la ponctuation doit être ignorée. Les valeurs possibles sont <code>true</code> et <code>false</code>. La valeur par défaut est <code>false</code>.</dd>
-  <dt><code>numeric</code></dt>
-  <dd>Indique si on ordonne les nombres (par exemple : "1" &lt; "2" &lt; "10"). Les valeurs possibles sont <code>true</code> et <code>false</code>. La valeur par défaut est <code>false</code>. Si l'extension Unicode correspondante et la propriété de l'objet <code>options</code> sont définies, ce sera cette dernière qui sera prise en compte.</dd>
-  <dt><code>caseFirst</code></dt>
-  <dd>Indique si on ordonne les majuscules avant les minuscules ou l'inverse. Les valeurs possibles sont <code>"upper"</code>, <code>"lower"</code>, ou <code>"false"</code> (on utilise alors l'ordre par défaut de la locale), la valeur par défaut est <code>"false"</code>. Si l'extension Unicode correspondante et la propriété de l'objet <code>options</code> sont définies, ce sera cette dernière qui sera prise en compte.</dd>
- </dl>
- </dd>
-</dl>
+- `options`
 
-<h2 id="Description">Description</h2>
+  - : Un objet qui disposent des propriétés suivantes :
 
-<p>L'objet <code>Intl.Collator</code> possède les propriétés et méthodes suivantes :</p>
+    - `localeMatcher`
+      - : L'algorithme de correspondance à utiliser pour les locales. Les valeurs possibles sont `"lookup"` et `"best fit"`. La valeur par défaut est "best fit". Voir la {{jsxref("Objets_globaux/Intl", "Intl", "#Choix_de_la_locale")}} pour plus d'informations à ce sujet.
+    - `usage`
+      - : Indique l'usage de le comparaison : le tri ou la recherche de chaînes correspondantes. Les valeurs possibles sont "sort" pour le tri et "search" pour la recherche. La valeur par défaut est "sort".
+    - `sensitivity`
 
-<h3 id="Propriétés">Propriétés</h3>
+      - : Indique les différences entre les chaînes de caractères qui font qu'une chaîne est considérée différente d'une autre. Les valeurs possibles sont :
 
-<dl>
- <dt>{{jsxref("Collator.prototype", "Intl.Collator.prototype")}}</dt>
- <dd>Permet d'ajouter des propriétés à toutes les instances.</dd>
-</dl>
+        - `"base"` : Seules les chaînes dont les lettres de base sont différentes sont considérées inégales. Par exemple : a ≠ b, a = á, a = A.
+        - `"accent"` : Seules les chaînes de caractères dont les lettres de bases ou les accents ou les autres marques diacritiques diffèrent sont considérées inégales. Par exemple : a ≠ b, a ≠ á, a = A.
+        - `"case"` : Seules les chaines dont les lettres de base ou la casse sont diffèrent sont considérées comme inégales. Par exemple : a ≠ b, a = á, a ≠ A.
+        - `"variant"` : Les chaînes qui diffèrent par leurs caractères de base, leurs accents et autres marques diacritiques, la casse sont considérées comme inégales. D'autres différences peuvent également être prises en compte. Par exemple : a ≠ b, a ≠ á, a ≠ A.
 
-<h3 id="Méthodes">Méthodes</h3>
+        La valeur par défaut est `"variant"` si on utilise la comparaison pour du tri (usage=`"sort"`). Pour l'utilisation `"search"` (recherche), la valeur par défaut dépend de la locale.
 
-<dl>
- <dt>{{jsxref("Collator.supportedLocalesOf", "Intl.Collator.supportedLocalesOf()")}}</dt>
- <dd>Renvoie un tableau qui contient les locales supportées pour lesquelles il n'est pas nécessaire de revenir à la locale par défaut de l'environnement.</dd>
-</dl>
+    - `ignorePunctuation`
+      - : Indique si la ponctuation doit être ignorée. Les valeurs possibles sont `true` et `false`. La valeur par défaut est `false`.
+    - `numeric`
+      - : Indique si on ordonne les nombres (par exemple : "1" < "2" < "10"). Les valeurs possibles sont `true` et `false`. La valeur par défaut est `false`. Si l'extension Unicode correspondante et la propriété de l'objet `options` sont définies, ce sera cette dernière qui sera prise en compte.
+    - `caseFirst`
+      - : Indique si on ordonne les majuscules avant les minuscules ou l'inverse. Les valeurs possibles sont `"upper"`, `"lower"`, ou `"false"` (on utilise alors l'ordre par défaut de la locale), la valeur par défaut est `"false"`. Si l'extension Unicode correspondante et la propriété de l'objet `options` sont définies, ce sera cette dernière qui sera prise en compte.
 
-<h2 id="Instances_de_Collator">Instances de <code>Collator</code></h2>
+## Description
 
-<h3 id="Propriétés_2">Propriétés</h3>
+L'objet `Intl.Collator` possède les propriétés et méthodes suivantes :
 
-<p>Les instances de <code>Collator</code> héritent des propriétés suivantes grâce à leur prototype :</p>
+### Propriétés
 
-<div>{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/Collator/prototype','Propriétés')}}</div>
+- {{jsxref("Collator.prototype", "Intl.Collator.prototype")}}
+  - : Permet d'ajouter des propriétés à toutes les instances.
 
-<h3 id="Méthodes_2">Méthodes</h3>
+### Méthodes
 
-<div>
-<p>Les instances de <code>Collator</code> héritent des méthodes suivantes grâce à leur prototype :</p>
-{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/Collator/prototype','Méthodes')}}</div>
+- {{jsxref("Collator.supportedLocalesOf", "Intl.Collator.supportedLocalesOf()")}}
+  - : Renvoie un tableau qui contient les locales supportées pour lesquelles il n'est pas nécessaire de revenir à la locale par défaut de l'environnement.
 
-<h2 id="Exemples">Exemples</h2>
+## Instances de `Collator`
 
-<h3 id="Utiliser_Collator">Utiliser <code>Collator</code></h3>
+### Propriétés
 
-<p>L'exemple qui suit illustre les différents résultats qu'on peut obtenir :</p>
+Les instances de `Collator` héritent des propriétés suivantes grâce à leur prototype :
 
-<pre class="brush: js">console.log(new Intl.Collator().compare('a', 'c')); // → une valeur négative
+{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/Collator/prototype','Propriétés')}}
+
+### Méthodes
+
+Les instances de `Collator` héritent des méthodes suivantes grâce à leur prototype :
+
+{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/Collator/prototype','Méthodes')}}
+
+## Exemples
+
+### Utiliser `Collator`
+
+L'exemple qui suit illustre les différents résultats qu'on peut obtenir :
+
+```js
+console.log(new Intl.Collator().compare('a', 'c')); // → une valeur négative
 console.log(new Intl.Collator().compare('c', 'a')); // → une valeur positive
 console.log(new Intl.Collator().compare('a', 'a')); // → 0
-</pre>
+```
 
-<p>Les résultats indiqués sont génériques et en pratique peuvent varier entre les navigateurs et les versions des navigateurs. En effet les valeurs obtenues dépendent de l'implémentation. Les spécifications indiquent uniquement le signe (positif ou négatif) du résultat.</p>
+Les résultats indiqués sont génériques et en pratique peuvent varier entre les navigateurs et les versions des navigateurs. En effet les valeurs obtenues dépendent de l'implémentation. Les spécifications indiquent uniquement le signe (positif ou négatif) du résultat.
 
-<h3 id="Utiliser_locales">Utiliser <code>locales</code></h3>
+### Utiliser `locales`
 
-<p>Les résultats fournis par {{jsxref("Collator.prototype.compare()")}} varient selon les locales. Afin d'obtenir le bon ordre lexicographique dans votre application, il est nécessaire de spécifier la locale de l'utilisateur (et éventuellement des locales pour des cas de replis) en utilisant l'argument <code>locales</code> :</p>
+Les résultats fournis par {{jsxref("Collator.prototype.compare()")}} varient selon les locales. Afin d'obtenir le bon ordre lexicographique dans votre application, il est nécessaire de spécifier la locale de l'utilisateur (et éventuellement des locales pour des cas de replis) en utilisant l'argument `locales` :
 
-<pre class="brush: js">// en allemand, 'ä' est équivalent à 'a' pour le tri
+```js
+// en allemand, 'ä' est équivalent à 'a' pour le tri
 console.log(new Intl.Collator("de").compare("ä", "z"));
 // → une valeur négative
 
 // en suédois, 'ä' arrive après 'z'
 console.log(new Intl.Collator("sv").compare("ä", "z"));
 // → une valeur positive
-</pre>
+```
 
-<h3 id="Utiliser_options">Utiliser <code>options</code></h3>
+### Utiliser `options`
 
-<p>Les résultats fournis par {{jsxref("Collator.prototype.compare()")}} peuvent être adaptés grâce à l'argument <code>options</code> :</p>
+Les résultats fournis par {{jsxref("Collator.prototype.compare()")}} peuvent être adaptés grâce à l'argument `options` :
 
-<pre class="brush: js">// en allemand, 'ä' est composé de la lettre de base 'a'
+```js
+// en allemand, 'ä' est composé de la lettre de base 'a'
 console.log(new Intl.Collator("de", {sensitivity: "base"}).compare("ä", "a"));
 // → 0
 
 // en suédois, 'ä' et 'a' sont distincts en termes de base
 console.log(new Intl.Collator("sv", {sensitivity: "base"}).compare("ä", "a"));
 // → une valeur positive
-</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('ES Int 1.0', '#sec-10.1', 'Intl.Collator')}}</td>
-   <td>{{Spec2('ES Int 1.0')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES Int 2.0', '#sec-10.1', 'Intl.Collator')}}</td>
-   <td>{{Spec2('ES Int 2.0')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES Int Draft', '#collator-objects', 'Intl.Collator')}}</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.Intl.Collator")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<p>{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/Intl','Voir_aussi')}}</p>
+```
+
+## Spécifications
+
+| Spécification                                                                            | État                             | Commentaires         |
+| ---------------------------------------------------------------------------------------- | -------------------------------- | -------------------- |
+| {{SpecName('ES Int 1.0', '#sec-10.1', 'Intl.Collator')}}             | {{Spec2('ES Int 1.0')}} | Définition initiale. |
+| {{SpecName('ES Int 2.0', '#sec-10.1', 'Intl.Collator')}}             | {{Spec2('ES Int 2.0')}} |                      |
+| {{SpecName('ES Int Draft', '#collator-objects', 'Intl.Collator')}} | {{Spec2('ES Int Draft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Intl.Collator")}}
+
+## Voir aussi
+
+{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/Intl','Voir_aussi')}}
diff --git a/files/fr/web/javascript/reference/global_objects/intl/collator/resolvedoptions/index.md b/files/fr/web/javascript/reference/global_objects/intl/collator/resolvedoptions/index.md
index 5a82466c9f..bad17cd5e5 100644
--- a/files/fr/web/javascript/reference/global_objects/intl/collator/resolvedoptions/index.md
+++ b/files/fr/web/javascript/reference/global_objects/intl/collator/resolvedoptions/index.md
@@ -13,38 +13,37 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Intl/Collator/resolvedOptions
 original_slug: Web/JavaScript/Reference/Objets_globaux/Intl/Collator/resolvedOptions
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>Intl.Collator.prototype.resolvedOptions()</strong></code> renvoie un nouvel objet dont les propriétés reflètent les options de locale et de collation calculées à l'initialisation de l'objet {{jsxref("Collator")}}.</p>
+La méthode **`Intl.Collator.prototype.resolvedOptions()`** renvoie un nouvel objet dont les propriétés reflètent les options de locale et de collation calculées à l'initialisation de l'objet {{jsxref("Collator")}}.
 
-<div>{{EmbedInteractiveExample("pages/js/intl-collator-prototype-resolvedoptions.html")}}</div>
+{{EmbedInteractiveExample("pages/js/intl-collator-prototype-resolvedoptions.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">collator.resolvedOptions()</pre>
+    collator.resolvedOptions()
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un nouvel objet dont les propriétés reflètent les options de locale et de collations calculées lors de l'initialisation de l'objet {{jsxref("Collator")}}.</p>
+Un nouvel objet dont les propriétés reflètent les options de locale et de collations calculées lors de l'initialisation de l'objet {{jsxref("Collator")}}.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>L'objet renvoyé par cette méthode contient les propriétés suivantes :</p>
+L'objet renvoyé par cette méthode contient les propriétés suivantes :
 
-<dl>
- <dt><code>locale</code></dt>
- <dd>La balise de langue BCP 47 qui est réellement utilisée. Si des extensions Unicode étaient fournies avec la balise d'origine et sont supportées pour la locale utilisée, les paires de clés-valeurs seront incluses dans <code>locale</code>.</dd>
- <dt><code>usage</code>,<code>sensitivity</code>, <code>ignorePunctuation</code></dt>
- <dd>Les valeurs demandées pour ces propriétés via l'argument <code>options</code> ou celles utilisées par défaut.</dd>
- <dt><code>collation</code></dt>
- <dd>La valeur demandée pour l'extension Unicode <code>"co"</code> si elle est supportée par la locale utilisée, sinon <code>"default"</code>.</dd>
- <dt><code>numeric</code>, <code>caseFirst</code></dt>
- <dd>Les valeurs demandées pour ces propriétés via l'argument <code>options</code> ou l'utilisation des extensions Unicode <code>"kn"</code> et <code>"kf"</code> ou les valeurs par défaut. Si l'implémentation utilisée ne supporte pas ces propriétés, elles sont omises.</dd>
-</dl>
+- `locale`
+  - : La balise de langue BCP 47 qui est réellement utilisée. Si des extensions Unicode étaient fournies avec la balise d'origine et sont supportées pour la locale utilisée, les paires de clés-valeurs seront incluses dans `locale`.
+- `usage`,`sensitivity`, `ignorePunctuation`
+  - : Les valeurs demandées pour ces propriétés via l'argument `options` ou celles utilisées par défaut.
+- `collation`
+  - : La valeur demandée pour l'extension Unicode `"co"` si elle est supportée par la locale utilisée, sinon `"default"`.
+- `numeric`, `caseFirst`
+  - : Les valeurs demandées pour ces propriétés via l'argument `options` ou l'utilisation des extensions Unicode `"kn"` et `"kf"` ou les valeurs par défaut. Si l'implémentation utilisée ne supporte pas ces propriétés, elles sont omises.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<pre class="brush: js">var de = new Intl.Collator('de', { sensitivity: 'base' })
+```js
+var de = new Intl.Collator('de', { sensitivity: 'base' })
 var usedOptions = de.resolvedOptions();
 
 usedOptions.locale;            // "de"
@@ -52,41 +51,21 @@ usedOptions.usage;             // "sort"
 usedOptions.sensitivity;        // "base"
 usedOptions.ignorePunctuation; // false
 usedOptions.collation;         // "default"
-usedOptions.numeric;           // 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('ES Int 1.0', '#sec-10.3.3', 'Intl.Collator.prototype.resolvedOptions')}}</td>
-   <td>{{Spec2('ES Int 1.0')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES Int 2.0', '#sec-10.3.3', 'Intl.Collator.prototype.resolvedOptions')}}</td>
-   <td>{{Spec2('ES Int 2.0')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES Int Draft', '#sec-Intl.Collator.prototype.resolvedOptions', 'Intl.Collator.prototype.resolvedOptions')}}</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.Intl.Collator.resolvedOptions")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Collator", "Intl.Collator")}}</li>
-</ul>
+usedOptions.numeric;           // false
+```
+
+## Spécifications
+
+| Spécification                                                                                                                                                    | État                             | Commentaires         |
+| ---------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------- | -------------------- |
+| {{SpecName('ES Int 1.0', '#sec-10.3.3', 'Intl.Collator.prototype.resolvedOptions')}}                                                 | {{Spec2('ES Int 1.0')}} | Définition initiale. |
+| {{SpecName('ES Int 2.0', '#sec-10.3.3', 'Intl.Collator.prototype.resolvedOptions')}}                                                 | {{Spec2('ES Int 2.0')}} |                      |
+| {{SpecName('ES Int Draft', '#sec-Intl.Collator.prototype.resolvedOptions', 'Intl.Collator.prototype.resolvedOptions')}} | {{Spec2('ES Int Draft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Intl.Collator.resolvedOptions")}}
+
+## Voir aussi
+
+- {{jsxref("Collator", "Intl.Collator")}}
diff --git a/files/fr/web/javascript/reference/global_objects/intl/collator/supportedlocalesof/index.md b/files/fr/web/javascript/reference/global_objects/intl/collator/supportedlocalesof/index.md
index 763a01dd1c..665b0ff858 100644
--- a/files/fr/web/javascript/reference/global_objects/intl/collator/supportedlocalesof/index.md
+++ b/files/fr/web/javascript/reference/global_objects/intl/collator/supportedlocalesof/index.md
@@ -12,84 +12,58 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Intl/Collator/supportedLocalesOf
 original_slug: Web/JavaScript/Reference/Objets_globaux/Intl/Collator/supportedLocalesOf
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>Intl.Collator.supportedLocalesOf()</strong></code> renvoie, parmi les locales fournies, un tableau contenant les locales supportées et qui ne nécessitent pas d'utiliser la locale par défaut de l'environnement.</p>
+La méthode **`Intl.Collator.supportedLocalesOf()`** renvoie, parmi les locales fournies, un tableau contenant les locales supportées et qui ne nécessitent pas d'utiliser la locale par défaut de l'environnement.
 
-<div>{{EmbedInteractiveExample("pages/js/intl-collator-prototype-supportedlocalesof.html")}}</div>
+{{EmbedInteractiveExample("pages/js/intl-collator-prototype-supportedlocalesof.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">Intl.Collator.supportedLocalesOf(locales [, options])</pre>
+    Intl.Collator.supportedLocalesOf(locales [, options])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>locales</code></dt>
- <dd>Une chaîne de caractères qui est une balise de langue BCP 47 ou bien un tableau de telles chaînes. Pour plus d'informations concernant la forme générale de l'argument <code>locales</code>, voir la page {{jsxref("Objets_globaux/Intl", "Intl", "#L'identification_et_le_choix_de_la_locale")}}.</dd>
- <dt><code>options</code>{{optional_inline}}</dt>
- <dd>
- <p>Paramètre facultatif. Un objet qui peut posséder les propriétés suivantes :</p>
+- `locales`
+  - : Une chaîne de caractères qui est une balise de langue BCP 47 ou bien un tableau de telles chaînes. Pour plus d'informations concernant la forme générale de l'argument `locales`, voir la page {{jsxref("Objets_globaux/Intl", "Intl", "#L'identification_et_le_choix_de_la_locale")}}.
+- `options`{{optional_inline}}
 
- <dl>
-  <dt><code>localeMatcher</code></dt>
-  <dd>
-  <p>L'algorithme utilisé pour la correspondance entre chaînes de caractères. Les valeurs possibles sont <code>"lookup"</code> et <code>"best fit"</code>. La valeur par défaut est <code>"best fit"</code>. Pour plus d'informations, voir la page {{jsxref("Objets_globaux/Intl", "Intl", "#Choix_de_la_locale")}}.</p>
-  </dd>
- </dl>
- </dd>
-</dl>
+  - : Paramètre facultatif. Un objet qui peut posséder les propriétés suivantes :
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+    - `localeMatcher`
+      - : L'algorithme utilisé pour la correspondance entre chaînes de caractères. Les valeurs possibles sont `"lookup"` et `"best fit"`. La valeur par défaut est `"best fit"`. Pour plus d'informations, voir la page {{jsxref("Objets_globaux/Intl", "Intl", "#Choix_de_la_locale")}}.
 
-<p>Un tableau de chaînes de caractères qui représente un sous-ensemble des balises de langues qui sont prises en charge pour la collation sans qu'il faille utiliser la locale par défaut de l'environnement d'exécution.</p>
+### Valeur de retour
 
-<h2 id="Description">Description</h2>
+Un tableau de chaînes de caractères qui représente un sous-ensemble des balises de langues qui sont prises en charge pour la collation sans qu'il faille utiliser la locale par défaut de l'environnement d'exécution.
 
-<p>Cette méthode renvoie un tableau qui est un sous-ensemble des balises de locales fournies avec l'argument <code>locales</code>. Les balises renvoyées sont celles supportées par l'environnement navigateur en termes de collation (comparaison) et qui ne nécessitent pas d'utiliser la locale par défaut.</p>
+## Description
 
-<h2 id="Exemples">Exemples</h2>
+Cette méthode renvoie un tableau qui est un sous-ensemble des balises de locales fournies avec l'argument `locales`. Les balises renvoyées sont celles supportées par l'environnement navigateur en termes de collation (comparaison) et qui ne nécessitent pas d'utiliser la locale par défaut.
 
-<p>Si on dispose d'un environnement (un navigateur par exemple) qui supporte la comparaison de chaînes dans les locales indonésienne, allemande mais pas balinaise,  <code>supportedLocalesOf</code> renvoie les balises pour l'indonésien et l'allemand quand bien même la collation avec pinyin n'est pas utilisée avec l'indonésien et qu'il n'existe pas une version spécifique de l'allemand pour l'Indonésie. On illustre ici l'algorithme <code>"lookup"</code>. SI on utilisait <code>"best fit"</code> pour trouver les locales correspondantes, on aurait pu avoir une balise supplémentaire pour le balinais en plus car la plupart des balinais comprennent l'indonésien.</p>
+## Exemples
 
-<pre class="brush: js">var locales = ["ban", "id-u-co-pinyin", "de-ID"];
+Si on dispose d'un environnement (un navigateur par exemple) qui supporte la comparaison de chaînes dans les locales indonésienne, allemande mais pas balinaise,  `supportedLocalesOf` renvoie les balises pour l'indonésien et l'allemand quand bien même la collation avec pinyin n'est pas utilisée avec l'indonésien et qu'il n'existe pas une version spécifique de l'allemand pour l'Indonésie. On illustre ici l'algorithme `"lookup"`. SI on utilisait `"best fit"` pour trouver les locales correspondantes, on aurait pu avoir une balise supplémentaire pour le balinais en plus car la plupart des balinais comprennent l'indonésien.
+
+```js
+var locales = ["ban", "id-u-co-pinyin", "de-ID"];
 var options = {localeMatcher: "lookup"};
 console.log(Intl.Collator.supportedLocalesOf(locales, options).join(", "));
-// → "id-u-co-pinyin, de-ID"</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('ES Int 1.0', '#sec-10.2.2', 'Intl.Collator.supportedLocalesOf')}}</td>
-   <td>{{Spec2('ES Int 1.0')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES Int 2.0', '#sec-10.2.2', 'Intl.Collator.supportedLocalesOf')}}</td>
-   <td>{{Spec2('ES Int 2.0')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES Int Draft', '#sec-Intl.Collator.supportedLocalesOf', 'Intl.Collator.supportedLocalesOf')}}</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.Intl.Collator.supportedLocalesOf")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Collator", "Intl.Collator")}}</li>
-</ul>
+// → "id-u-co-pinyin, de-ID"
+```
+
+## Spécifications
+
+| Spécification                                                                                                                                | État                             | Commentaires         |
+| -------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------- | -------------------- |
+| {{SpecName('ES Int 1.0', '#sec-10.2.2', 'Intl.Collator.supportedLocalesOf')}}                                     | {{Spec2('ES Int 1.0')}} | Définition initiale. |
+| {{SpecName('ES Int 2.0', '#sec-10.2.2', 'Intl.Collator.supportedLocalesOf')}}                                     | {{Spec2('ES Int 2.0')}} |                      |
+| {{SpecName('ES Int Draft', '#sec-Intl.Collator.supportedLocalesOf', 'Intl.Collator.supportedLocalesOf')}} | {{Spec2('ES Int Draft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Intl.Collator.supportedLocalesOf")}}
+
+## Voir aussi
+
+- {{jsxref("Collator", "Intl.Collator")}}
diff --git a/files/fr/web/javascript/reference/global_objects/intl/datetimeformat/format/index.md b/files/fr/web/javascript/reference/global_objects/intl/datetimeformat/format/index.md
index b04b345861..1fb93f7064 100644
--- a/files/fr/web/javascript/reference/global_objects/intl/datetimeformat/format/index.md
+++ b/files/fr/web/javascript/reference/global_objects/intl/datetimeformat/format/index.md
@@ -12,56 +12,59 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat/format
 original_slug: Web/JavaScript/Reference/Objets_globaux/Intl/DateTimeFormat/format
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>Intl.DateTimeFormat.prototype.format()</code></strong> est un accesseur formate une date selon les options de locale et de format de l'objet {{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}}.</p>
+La méthode **`Intl.DateTimeFormat.prototype.format()`** est un accesseur formate une date selon les options de locale et de format de l'objet {{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}}.
 
-<div>{{EmbedInteractiveExample("pages/js/intl-datetimeformat-prototype-format.html")}}</div>
+{{EmbedInteractiveExample("pages/js/intl-datetimeformat-prototype-format.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>dateTimeFormat</var>.format(<var>date</var>)</pre>
+    dateTimeFormat.format(date)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>date</code></dt>
- <dd>La date à formater.</dd>
-</dl>
+- `date`
+  - : La date à formater.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>L'accesseur <code>format</code> permet de formater une date en une chaîne de caractères en fonction des options de locale et de format définies pour l'objet {{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}}.</p>
+L'accesseur `format` permet de formater une date en une chaîne de caractères en fonction des options de locale et de format définies pour l'objet {{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}}.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_format">Utiliser <code>format</code></h3>
+### Utiliser `format`
 
-<p>On peut utiliser la fonction renvoyée par l'accesseur <code>format</code> pour formater une date. Par exemple selon la locale serbe :</p>
+On peut utiliser la fonction renvoyée par l'accesseur `format` pour formater une date. Par exemple selon la locale serbe :
 
-<pre class="brush: js">var options = {weekday: "long", year: "numeric", month: "long", day: "numeric"};
+```js
+var options = {weekday: "long", year: "numeric", month: "long", day: "numeric"};
 var dateTimeFormat = new Intl.DateTimeFormat("sr-RS", options);
 console.log(dateTimeFormat.format(new Date()));
-// → "недеља, 7. април 2013."</pre>
+// → "недеља, 7. април 2013."
+```
 
-<h3 id="Utiliser_format_avec_map">Utiliser <code>format</code> avec <code>map()</code></h3>
+### Utiliser `format` avec `map()`
 
-<p>On peut également utiliser la fonction renvoyée par l'accesseur <code>format</code> pour formater toutes les dates d'un tableau. On observe que la fonction est liée à l'objet <code>DateTimeFormat</code> dont elle provient, on peut donc la passer directement à {{jsxref("Array.prototype.map()")}}.</p>
+On peut également utiliser la fonction renvoyée par l'accesseur `format` pour formater toutes les dates d'un tableau. On observe que la fonction est liée à l'objet `DateTimeFormat` dont elle provient, on peut donc la passer directement à {{jsxref("Array.prototype.map()")}}.
 
-<pre class="brush: js">var a = [new Date(2012, 08), new Date(2012, 11), new Date(2012, 03)];
+```js
+var a = [new Date(2012, 08), new Date(2012, 11), new Date(2012, 03)];
 var options = {year: "numeric", month: "long"};
 var dateTimeFormat = new Intl.DateTimeFormat("pt-BR", options);
 var formatted = a.map(dateTimeFormat.format);
 console.log(formatted.join("; "));
-// → "setembro de 2012; dezembro de 2012; abril de 2012"</pre>
+// → "setembro de 2012; dezembro de 2012; abril de 2012"
+```
 
-<h3 id="Comparaison_des_dates_formatées_et_des_valeurs_statiques">Comparaison des dates formatées et des valeurs statiques</h3>
+### Comparaison des dates formatées et des valeurs statiques
 
-<p>La plupart du temps, le format renvoyé par <code>format()</code> est cohérent. Toutefois, cela peut évoluer à l'avenir et n'est pas garanti pour l'ensemble des langues (de telles variations sont souhaitables et permises par la spécification). Ainsi, IE et Edge ajoutent des caractères de contrôle bidirectionnels autour des dates afin que le texte produit ait une directionalité cohérente avec le texte avec lequel elles seront concaténées.</p>
+La plupart du temps, le format renvoyé par `format()` est cohérent. Toutefois, cela peut évoluer à l'avenir et n'est pas garanti pour l'ensemble des langues (de telles variations sont souhaitables et permises par la spécification). Ainsi, IE et Edge ajoutent des caractères de contrôle bidirectionnels autour des dates afin que le texte produit ait une directionalité cohérente avec le texte avec lequel elles seront concaténées.
 
-<p>Aussi, mieux vaut ne pas comparer un résultat fourni par <code>format()</code> avec une valeur statique :</p>
+Aussi, mieux vaut ne pas comparer un résultat fourni par `format()` avec une valeur statique :
 
-<pre class="brush: js; example-bad">let d = new Date("2019-01-01T00:00:00.000000Z");
+```js example-bad
+let d = new Date("2019-01-01T00:00:00.000000Z");
 let formattedDate = Intl.DateTimeFormat(undefined, {
   year: 'numeric',
   month: 'numeric',
@@ -74,50 +77,25 @@ let formattedDate = Intl.DateTimeFormat(undefined, {
 "1.1.2019, 01:00:00" === formattedDate;
 // true pour Firefox et les autres
 // false pour IE et Edge
-</pre>
-
-<div class="blockIndicator note">
-<p><strong>Note :</strong> Voir aussi ce fil <a href="https://stackoverflow.com/questions/25574963/ies-tolocalestring-has-strange-characters-in-results">StackOverflow</a> pour plus de détails et d'exemples.</p>
-</div>
-
-<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('ES Int 1.0', '#sec-12.3.2', 'Intl.DateTimeFormat.format')}}</td>
-   <td>{{Spec2('ES Int 1.0')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES Int 2.0', '#sec-12.3.2', 'Intl.DateTimeFormat.format')}}</td>
-   <td>{{Spec2('ES Int 2.0')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES Int Draft', '#sec-Intl.DateTimeFormat.prototype.format', 'Intl.DateTimeFormat.format')}}</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.Intl.DateTimeFormat.format")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}}</li>
- <li>{{jsxref("Date.prototype.toLocaleString")}}</li>
- <li>{{jsxref("Date.prototype.toLocaleDateString")}}</li>
- <li>{{jsxref("Date.prototype.toLocaleTimeString")}}</li>
-</ul>
+```
+
+> **Note :** Voir aussi ce fil [StackOverflow](https://stackoverflow.com/questions/25574963/ies-tolocalestring-has-strange-characters-in-results) pour plus de détails et d'exemples.
+
+## Spécifications
+
+| Spécification                                                                                                                            | État                             | Commentaires         |
+| ---------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------- | -------------------- |
+| {{SpecName('ES Int 1.0', '#sec-12.3.2', 'Intl.DateTimeFormat.format')}}                                         | {{Spec2('ES Int 1.0')}} | Définition initiale. |
+| {{SpecName('ES Int 2.0', '#sec-12.3.2', 'Intl.DateTimeFormat.format')}}                                         | {{Spec2('ES Int 2.0')}} |                      |
+| {{SpecName('ES Int Draft', '#sec-Intl.DateTimeFormat.prototype.format', 'Intl.DateTimeFormat.format')}} | {{Spec2('ES Int Draft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Intl.DateTimeFormat.format")}}
+
+## Voir aussi
+
+- {{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}}
+- {{jsxref("Date.prototype.toLocaleString")}}
+- {{jsxref("Date.prototype.toLocaleDateString")}}
+- {{jsxref("Date.prototype.toLocaleTimeString")}}
diff --git a/files/fr/web/javascript/reference/global_objects/intl/datetimeformat/formatrange/index.md b/files/fr/web/javascript/reference/global_objects/intl/datetimeformat/formatrange/index.md
index c618202292..28b72a5645 100644
--- a/files/fr/web/javascript/reference/global_objects/intl/datetimeformat/formatrange/index.md
+++ b/files/fr/web/javascript/reference/global_objects/intl/datetimeformat/formatrange/index.md
@@ -9,28 +9,29 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat/formatRange
 original_slug: Web/JavaScript/Reference/Objets_globaux/Intl/DateTimeFormat/formatRange
 ---
-<p>{{JSRef}}</p>
+{{JSRef}}
 
-<p>La méthode <strong><code>Intl.DateTimeFormat.prototype.formatRange()</code></strong> permet de formater un intervalle de dates de la façon la plus concise en fonction de la <strong><code>locale</code></strong> et des <code><strong>options</strong></code> fournies lors de l'initialisation de l'objet {{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}}.</p>
+La méthode **`Intl.DateTimeFormat.prototype.formatRange()`** permet de formater un intervalle de dates de la façon la plus concise en fonction de la **`locale`** et des **`options`** fournies lors de l'initialisation de l'objet {{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}}.
 
-<div>{{EmbedInteractiveExample("pages/js/intl-datetimeformat-prototype-formatrange.html")}}</div>
+{{EmbedInteractiveExample("pages/js/intl-datetimeformat-prototype-formatrange.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre>Intl.DateTimeFormat.prototype.formatRange(<var>dateDébut, dateFin</var>)</pre>
+    Intl.DateTimeFormat.prototype.formatRange(dateDébut, dateFin)
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utilisation_simple_de_formatRange">Utilisation simple de <code>formatRange()</code></h3>
+### Utilisation simple de `formatRange()`
 
-<p>Cette méthode reçoit comme arguments deux objets {{jsxref("Date")}} et renvoie l'intervalle de la façon la plus concise possible (selon les options fournies lors de l'instanciation du formateur <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat">Intl.DateTimeFormat</a></code>).</p>
+Cette méthode reçoit comme arguments deux objets {{jsxref("Date")}} et renvoie l'intervalle de la façon la plus concise possible (selon les options fournies lors de l'instanciation du formateur [`Intl.DateTimeFormat`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat)).
 
-<pre class="brush: js">let date1 = new Date(Date.UTC(2007, 0, 10, 10, 0, 0));
+```js
+let date1 = new Date(Date.UTC(2007, 0, 10, 10, 0, 0));
 let date2 = new Date(Date.UTC(2007, 0, 10, 11, 0, 0));
 let date3 = new Date(Date.UTC(2007, 0, 20, 10, 0, 0));
-// &gt; 'Wed, 10 Jan 2007 10:00:00 GMT'
-// &gt; 'Wed, 10 Jan 2007 11:00:00 GMT'
-// &gt; 'Sat, 20 Jan 2007 10:00:00 GMT'
+// > 'Wed, 10 Jan 2007 10:00:00 GMT'
+// > 'Wed, 10 Jan 2007 11:00:00 GMT'
+// > 'Sat, 20 Jan 2007 10:00:00 GMT'
 
 let fmt1 = new Intl.DateTimeFormat("en", {
     year: '2-digit',
@@ -42,9 +43,9 @@ let fmt1 = new Intl.DateTimeFormat("en", {
 console.log(fmt1.format(date1));
 console.log(fmt1.formatRange(date1, date2));
 console.log(fmt1.formatRange(date1, date3));
-// &gt; '1/10/07, 10:00 AM'
-// &gt; '1/10/07, 10:00 – 11:00 AM'
-// &gt; '1/10/07, 10:00 AM – 1/20/07, 10:00 AM'
+// > '1/10/07, 10:00 AM'
+// > '1/10/07, 10:00 – 11:00 AM'
+// > '1/10/07, 10:00 AM – 1/20/07, 10:00 AM'
 
 let fmt2 = new Intl.DateTimeFormat("en", {
     year: 'numeric',
@@ -54,28 +55,17 @@ let fmt2 = new Intl.DateTimeFormat("en", {
 console.log(fmt2.format(date1));
 console.log(fmt2.formatRange(date1, date2));
 console.log(fmt2.formatRange(date1, date3));
-// &gt; 'Jan 10, 2007'
-// &gt; 'Jan 10, 2007'
-// &gt; 'Jan 10 – 20, 2007'
-</pre>
+// > 'Jan 10, 2007'
+// > 'Jan 10, 2007'
+// > 'Jan 10 – 20, 2007'
+```
 
-<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><code><a href="https://rawgit.com/fabalbon/proposal-intl-DateTimeFormat-formatRange/master/out/#datetimeformat-objects">Intl.DateTimeFormat.prototype.formatRange</a></code></td>
-   <td>Brouillon de niveau 3</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
+| Spécification                                                                                                                                          | État                  | Commentaires |
+| ------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------- | ------------ |
+| [`Intl.DateTimeFormat.prototype.formatRange`](https://rawgit.com/fabalbon/proposal-intl-DateTimeFormat-formatRange/master/out/#datetimeformat-objects) | Brouillon de niveau 3 |              |
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<p>{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/Intl', 'Voir_aussi')}}</p>
+{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/Intl', 'Voir_aussi')}}
diff --git a/files/fr/web/javascript/reference/global_objects/intl/datetimeformat/formatrangetoparts/index.md b/files/fr/web/javascript/reference/global_objects/intl/datetimeformat/formatrangetoparts/index.md
index 1bc99d14f8..10f3db9b19 100644
--- a/files/fr/web/javascript/reference/global_objects/intl/datetimeformat/formatrangetoparts/index.md
+++ b/files/fr/web/javascript/reference/global_objects/intl/datetimeformat/formatrangetoparts/index.md
@@ -9,24 +9,25 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat/formatRangeToParts
 original_slug: Web/JavaScript/Reference/Objets_globaux/Intl/DateTimeFormat/formatRangeToParts
 ---
-<p>{{JSRef}}</p>
+{{JSRef}}
 
-<p>La fonction <strong><code>Intl.DateTimeFormat.prototype.formatRangeToParts()</code></strong> permet, selon la locale utilisée, de représenter chaque élément de l'intervalle de dates via <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat/prototype">DateTimeFormat</a></code>.</p>
+La fonction **`Intl.DateTimeFormat.prototype.formatRangeToParts()`** permet, selon la locale utilisée, de représenter chaque élément de l'intervalle de dates via [`DateTimeFormat`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat/prototype).
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre>Intl.DateTimeFormat.prototype.formatRangeToParts(<var>dateDebut, dateFin</var>)</pre>
+    Intl.DateTimeFormat.prototype.formatRangeToParts(dateDebut, dateFin)
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Usage_basique_de_formatRangeToParts">Usage basique de <code>formatRangeToParts</code></h3>
+### Usage basique de `formatRangeToParts`
 
-<p>Cette fonction reçoit deux <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date">Dates</a> et retourne un <a href="/en-US/docs/Glossary/array">Array</a> d'objets contenant les élements qui représentent chaque partie de l'intervalle de date formatée, selon la locale utilisée.</p>
+Cette fonction reçoit deux [Dates](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date) et retourne un [Array](/en-US/docs/Glossary/array) d'objets contenant les élements qui représentent chaque partie de l'intervalle de date formatée, selon la locale utilisée.
 
-<pre class="brush: js">let date1 = new Date(Date.UTC(2007, 0, 10, 10, 0, 0));
+```js
+let date1 = new Date(Date.UTC(2007, 0, 10, 10, 0, 0));
 let date2 = new Date(Date.UTC(2007, 0, 10, 11, 0, 0));
-// &gt; 'Wed, 10 Jan 2007 10:00:00 GMT'
-// &gt; 'Wed, 10 Jan 2007 11:00:00 GMT'
+// > 'Wed, 10 Jan 2007 10:00:00 GMT'
+// > 'Wed, 10 Jan 2007 11:00:00 GMT'
 
 let fmt = new Intl.DateTimeFormat("en", {
     hour: 'numeric',
@@ -34,7 +35,7 @@ let fmt = new Intl.DateTimeFormat("en", {
 });
 
 console.log(fmt.formatRange(date1, date2));
-// &gt; '10:00 – 11:00 AM'
+// > '10:00 – 11:00 AM'
 
 fmt.formatRangeToParts(date1, date2);
 // retourne la valeur:
@@ -48,27 +49,15 @@ fmt.formatRangeToParts(date1, date2);
 //   { type: 'minute',    value: '00',  source: "endRange"   },
 //   { type: 'literal',   value: ' ',   source: "shared"     },
 //   { type: 'dayPeriod', value: 'AM',  source: "shared"     }
-// ]</pre>
+// ]
+```
 
-<h2 id="Spécifications">Spécifications</h2>
+## Spécifications
 
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Specification</th>
-   <th scope="col">Status</th>
-   <th scope="col">Comment</th>
-  </tr>
-  <tr>
-   <td><a href="https://rawgit.com/fabalbon/proposal-intl-DateTimeFormat-formatRange/master/out/#datetimeformat-objects">Intl.DateTimeFormat.prototype.formatRange</a></td>
-   <td>Stage 3</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
+| Specification                                                                                                                                        | Status  | Comment |
+| ---------------------------------------------------------------------------------------------------------------------------------------------------- | ------- | ------- |
+| [Intl.DateTimeFormat.prototype.formatRange](https://rawgit.com/fabalbon/proposal-intl-DateTimeFormat-formatRange/master/out/#datetimeformat-objects) | Stage 3 |         |
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-
-
-<p>{{Compat("javascript.builtins.Intl.DateTimeFormat.formatRangeToParts")}}</p>
+{{Compat("javascript.builtins.Intl.DateTimeFormat.formatRangeToParts")}}
diff --git a/files/fr/web/javascript/reference/global_objects/intl/datetimeformat/formattoparts/index.md b/files/fr/web/javascript/reference/global_objects/intl/datetimeformat/formattoparts/index.md
index 4293903628..079ae0d33a 100644
--- a/files/fr/web/javascript/reference/global_objects/intl/datetimeformat/formattoparts/index.md
+++ b/files/fr/web/javascript/reference/global_objects/intl/datetimeformat/formattoparts/index.md
@@ -13,66 +13,65 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat/formatToParts
 original_slug: Web/JavaScript/Reference/Objets_globaux/Intl/DateTimeFormat/formatToParts
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>Intl.DateTimeFormat.prototype.formatToParts()</code></strong> permet de mettre en forme des chaînes de caractères avec des informations temporelles selon la locale utilisée.</p>
+La méthode **`Intl.DateTimeFormat.prototype.formatToParts()`** permet de mettre en forme des chaînes de caractères avec des informations temporelles selon la locale utilisée.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">Intl.DateTimeFormat.prototype.formatToParts(date)</pre>
+    Intl.DateTimeFormat.prototype.formatToParts(date)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>date</code> {{optional_inline}}</dt>
- <dd>La date qu'on souhaite mettre en forme.</dd>
-</dl>
+- `date` {{optional_inline}}
+  - : La date qu'on souhaite mettre en forme.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un tableau ({{jsxref("Array")}}) d'objets qui contiennent les composants de la date mis en forme.</p>
+Un tableau ({{jsxref("Array")}}) d'objets qui contiennent les composants de la date mis en forme.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La méthode <code>formatToParts()</code> est utile lorsqu'on souhaite mettre en forme des dates de façon personnalisée. Elle renvoie un tableau d'objets qui contiennent les fragments spécifiques à la locale, à partir desquels on peut construire des chaînes tout en conservant les parties spécifique à la locale. La structure de l'objet renvoyé par la méthode est semblable à celle-ci :</p>
+La méthode `formatToParts()` est utile lorsqu'on souhaite mettre en forme des dates de façon personnalisée. Elle renvoie un tableau d'objets qui contiennent les fragments spécifiques à la locale, à partir desquels on peut construire des chaînes tout en conservant les parties spécifique à la locale. La structure de l'objet renvoyé par la méthode est semblable à celle-ci :
 
-<pre class="brush: js">[
+```js
+[
   { type: "day", value: "17" },
   { type: "weekday", value "Monday" }
-]</pre>
-
-<p>Les types possibles sont :</p>
-
-<dl>
- <dt><code>day</code></dt>
- <dd>La chaîne utilisée pour désigner le jour, par exemple <code>"17"</code>.</dd>
- <dt><code>dayPeriod</code></dt>
- <dd>La chaîne utilisée pour désigner le moment de la journée, par exemple <code>"AM"</code> (qui désigne la matinée, avant midi) ou <code>"PM"</code> (qui désigne l'après-midi).</dd>
- <dt><code>era</code></dt>
- <dd>La chaîne utilisée pour l'ère (par exemple <code>"BC"</code> ou <code>"AD"</code>).</dd>
- <dt><code>hour</code></dt>
- <dd>La chaîne utilisée pour l'heure (par exemple <code>"3"</code> or <code>"03"</code>).</dd>
- <dt><code>literal</code></dt>
- <dd>La chaîne utilisée pour séparée le jour de l'heure (par exemple <code>"</code> <code>:</code> <code>,</code> <code>/</code> <code>"</code>).</dd>
- <dt><code>minute</code></dt>
- <dd>La chaîne utilisée pour les minutes (par exemple <code>"00"</code>).</dd>
- <dt><code>month</code></dt>
- <dd>La chaîne utilisée pour le mois (par exemple <code>"12"</code>).</dd>
- <dt><code>second</code></dt>
- <dd>La chaîne utilisée pour les secondes (par exemple <code>"02"</code>).</dd>
- <dt><code>timeZoneName</code></dt>
- <dd>La chaîne utilisée pour désigner le fuseau horaire (par exemple <code>"UTC"</code>).</dd>
- <dt><code>weekday</code></dt>
- <dd>La chaîne de caractères utilisée pour le jour de la semaine, par exemple <code>"M"</code>, <code>"Monday"</code> ou <code>"Montag"</code>.</dd>
- <dt><code>year</code></dt>
- <dd>La chaîne utilisée pour désigner l'année (par exemple <code>"2012"</code> ou <code>"96"</code>).</dd>
-</dl>
-
-<h2 id="Exemples">Exemples</h2>
-
-<p><code>DateTimeFormat</code> produit des chaînes localisées opaques qui ne peuvent pas être manipulées directement :</p>
-
-<pre class="brush: js">var date = Date.UTC(2012, 11, 17, 3, 0, 42);
+]
+```
+
+Les types possibles sont :
+
+- `day`
+  - : La chaîne utilisée pour désigner le jour, par exemple `"17"`.
+- `dayPeriod`
+  - : La chaîne utilisée pour désigner le moment de la journée, par exemple `"AM"` (qui désigne la matinée, avant midi) ou `"PM"` (qui désigne l'après-midi).
+- `era`
+  - : La chaîne utilisée pour l'ère (par exemple `"BC"` ou `"AD"`).
+- `hour`
+  - : La chaîne utilisée pour l'heure (par exemple `"3"` or `"03"`).
+- `literal`
+  - : La chaîne utilisée pour séparée le jour de l'heure (par exemple `"` `:` `,` `/` `"`).
+- `minute`
+  - : La chaîne utilisée pour les minutes (par exemple `"00"`).
+- `month`
+  - : La chaîne utilisée pour le mois (par exemple `"12"`).
+- `second`
+  - : La chaîne utilisée pour les secondes (par exemple `"02"`).
+- `timeZoneName`
+  - : La chaîne utilisée pour désigner le fuseau horaire (par exemple `"UTC"`).
+- `weekday`
+  - : La chaîne de caractères utilisée pour le jour de la semaine, par exemple `"M"`, `"Monday"` ou `"Montag"`.
+- `year`
+  - : La chaîne utilisée pour désigner l'année (par exemple `"2012"` ou `"96"`).
+
+## Exemples
+
+`DateTimeFormat` produit des chaînes localisées opaques qui ne peuvent pas être manipulées directement :
+
+```js
+var date = Date.UTC(2012, 11, 17, 3, 0, 42);
 
 var formatter = new Intl.DateTimeFormat("en-us", {
   weekday: 'long',
@@ -88,11 +87,12 @@ var formatter = new Intl.DateTimeFormat("en-us", {
 
 formatter.format(date);
 // "Monday, 12/17/2012, 3:00:42 AM"
-</pre>
+```
 
-<p>Cependant, pour de nombreuses interfaces utilisateur, on peut vouloir personnaliser la mise en forme de cette chaîne de caractères. La méthode <code>formatToParts</code> permet une mise en forme dans le souci de la locale en manipulant les différentes composantes :</p>
+Cependant, pour de nombreuses interfaces utilisateur, on peut vouloir personnaliser la mise en forme de cette chaîne de caractères. La méthode `formatToParts` permet une mise en forme dans le souci de la locale en manipulant les différentes composantes :
 
-<pre class="brush: js">formatter.formatToParts(date);
+```js
+formatter.formatToParts(date);
 
 // return value:
 [
@@ -112,54 +112,43 @@ formatter.format(date);
   { type: 'literal', value: ' '      },
   { type: 'dayPeriod', value: 'AM'     }
 ]
-</pre>
+```
 
-<p>L'information étant décomposée, on peut alors la mettre en forme et la recomposée de façon adaptée :</p>
+L'information étant décomposée, on peut alors la mettre en forme et la recomposée de façon adaptée :
 
-<pre class="brush: js">var dateString = formatter.formatToParts(date).map(({type, value}) =&gt; {
+```js
+var dateString = formatter.formatToParts(date).map(({type, value}) => {
   switch (type) {
-    case 'dayPeriod': return `&lt;strong&gt;${value}&lt;/strong&gt;`;
+    case 'dayPeriod': return `<strong>${value}</strong>`;
     default : return value;
   }
-}).reduce((string, part) =&gt; string + part);
+}).reduce((string, part) => string + part);
 
 console.log(formatter.format(date));
 // "Monday, 12/17/2012, 3:00:42 AM"
 
 console.log(dateString);
-// "Monday, 12/17/2012, 3:00:42 &lt;strong&gt;AM&lt;/strong&gt;"</pre>
-
-<h2 id="Prothèse_démulation_polyfill">Prothèse d'émulation (<em>polyfill</em>)</h2>
-
-<p>Une prothèse de cette fonctionnalité est disponible sur le dépôt décrivant <a href="https://github.com/zbraniecki/proposal-intl-formatToParts">la proposition de fonctionnalité</a>.</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('ES Int Draft', '#sec-Intl.DateTimeFormat.prototype.formatToParts', 'Intl.DateTimeFormat.prototype.formatToParts')}}</td>
-   <td>{{Spec2('ES Int Draft')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Intl.DateTimeFormat.formatToParts")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}}</li>
- <li>{{jsxref("DateTimeFormat.format", "Intl.DateTimeFormat.prototype.format")}}</li>
- <li>{{jsxref("Date.prototype.toLocaleString()")}}</li>
- <li>{{jsxref("Date.prototype.toLocaleDateString()")}}</li>
- <li>{{jsxref("Date.prototype.toLocaleTimeString()")}}</li>
-</ul>
+// "Monday, 12/17/2012, 3:00:42 <strong>AM</strong>"
+```
+
+## Prothèse d'émulation (_polyfill_)
+
+Une prothèse de cette fonctionnalité est disponible sur le dépôt décrivant [la proposition de fonctionnalité](https://github.com/zbraniecki/proposal-intl-formatToParts).
+
+## Spécifications
+
+| Spécification                                                                                                                                                            | État                             | Commentaires         |
+| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------- | -------------------- |
+| {{SpecName('ES Int Draft', '#sec-Intl.DateTimeFormat.prototype.formatToParts', 'Intl.DateTimeFormat.prototype.formatToParts')}} | {{Spec2('ES Int Draft')}} | Définition initiale. |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Intl.DateTimeFormat.formatToParts")}}
+
+## Voir aussi
+
+- {{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}}
+- {{jsxref("DateTimeFormat.format", "Intl.DateTimeFormat.prototype.format")}}
+- {{jsxref("Date.prototype.toLocaleString()")}}
+- {{jsxref("Date.prototype.toLocaleDateString()")}}
+- {{jsxref("Date.prototype.toLocaleTimeString()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/intl/datetimeformat/index.md b/files/fr/web/javascript/reference/global_objects/intl/datetimeformat/index.md
index d8cc5bc6fd..8c1bc5333b 100644
--- a/files/fr/web/javascript/reference/global_objects/intl/datetimeformat/index.md
+++ b/files/fr/web/javascript/reference/global_objects/intl/datetimeformat/index.md
@@ -10,187 +10,174 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat
 original_slug: Web/JavaScript/Reference/Objets_globaux/Intl/DateTimeFormat
 ---
-<div>{{JSRef}}</div>
-
-<p>L'objet <strong><code>Intl.DateTimeFormat</code></strong> est un constructeur d'objets permettant de formatter des dates et des heures selon une langue.</p>
-
-<div>{{EmbedInteractiveExample("pages/js/intl-datetimeformat.html")}}</div>
-
-<h2 id="Syntaxe">Syntaxe</h2>
-
-<pre class="syntaxbox">new Intl.DateTimeFormat([<var>locales</var>[, <var>options</var>]])
-Intl.DateTimeFormat.call(<var>this</var>[, <var>locales</var>[, <var>options</var>]])</pre>
-
-<h3 id="Paramètres">Paramètres</h3>
-
-<dl>
- <dt><code>locales</code>{{optional_inline}}</dt>
- <dd>
- <p>Ce paramètre optionnel est une chaine de caractères avec un identifiant de langue BCP 47, ou un tableau de ce type de chaine de caractères. Pour utiliser la locale par défaut du navigateur, on pourra omettre cet argument (ou passer la valeur <code>undefined</code>). Pour le format général et l'interprétation de l'argument <code>locales</code>, voir la page {{jsxref("Objets_globaux/Intl","Intl","#L'identification_et_le_choix_de_la_locale")}}. Les clefs d'extensions Unicode suivantes sont autorisées :</p>
-
- <dl>
-  <dt>nu</dt>
-  <dd>Système de numérotation. Les valeurs possibles incluent : <code>"arab", "arabext", "bali", "beng", "deva", "fullwide", "gujr", "guru", "hanidec", "khmr", "knda", "laoo", "latn", "limb", "mlym", "mong", "mymr", "orya", "tamldec", "telu", "thai", "tibt"</code>.</dd>
-  <dt>ca</dt>
-  <dd>Calendrier. Les valeurs possibles incluent : <code>"buddhist", "chinese", "coptic", "ethiopia", "ethiopic", "gregory", "hebrew", "indian", "islamic", "islamicc", "iso8601", "japanese", "persian", "roc"</code>.</dd>
-  <dt><code>hc</code></dt>
-  <dd>Le type de cycle horaire à utiliser. Les valeurs possibles sont <code>"h11"</code>, <code>"h12"</code>, <code>"h23"</code>, <code>"h24"</code>.</dd>
- </dl>
- </dd>
- <dt><code>options</code></dt>
- <dd>
- <p>Un objet avec certaines ou toutes les propriétés suivantes :</p>
-
- <dl>
-  <dt><code>localeMatcher</code></dt>
-  <dd>L'algorithme de correspondance à utiliser pour la locale. Les valeurs possibles sont <code>"lookup"</code> et <code>"best fit"</code> ; le défaut est <code>"best fit"</code>. Pour des informations sur cette option, voir la page {{jsxref("Objets_globaux/Intl","Intl","##Choix_de_la_locale")}}</dd>
-  <dt><code>timeZone</code></dt>
-  <dd>Le fuseau horaire à utiliser. La seule valeur que doivent reconnaitre les implémentations est "UTC" ; la valeur par défaut est le fuseau horaire du moteur JavaScript. Les implémentations peuvent aussi reconnaitre les noms de fuseau horaire de la <a href="https://www.iana.org/time-zones">base de données IANA de fuseaux horaires</a>, tel que <code>"Asia/Shanghai"</code>, <code>"Asia/Kolkata"</code>, <code>"America/New_York"</code>.</dd>
-  <dt><code>hour12</code></dt>
-  <dd>S'il faut utiliser le format horaire sur 12 heures (au lieu de celui-ci sur 24 heures). Les valeurs possibles sont <code>true</code> et <code>false</code> ; la valeur par défaut dépend de la locale. Cette option surcharge l'étiquette <code>hc</code> et/ou l'option <code>hourCycle</code>.</dd>
-  <dt><code>hourCycle</code></dt>
-  <dd>Le cycle horaire à utiliser. Les valeurs possibles sont <code>"h11"</code>, <code>"h12"</code>, <code>"h23"</code>, <code>"h24"</code>. Cette option surcharge l'étiquette <code>hc</code> mais sera remplacée par <code>hour12</code> si cette dernière est présente.</dd>
-  <dt><code>formatMatcher</code></dt>
-  <dd>L'algorithme de correspondance à utiliser pour le formattage. Les valeurs possibles sont <code>"basic"</code> et <code>"best fit"</code> ; par défaut <code>"best fit"</code>. Voir les paragraphes suivants pour des informations concernant l'usage de cette propriété.</dd>
- </dl>
-
- <p>Les propriétés suivantes décrivent les composants date-heure à utiliser pour le formattage de la sortie.  Les implémentations ont pour obligation de supporter au minimum les ensembles suivants :</p>
-
- <ul>
-  <li><code>weekday, year, month, day, hour, minute, second</code></li>
-  <li><code>weekday, year, month, day</code></li>
-  <li><code>year, month, day</code></li>
-  <li><code>year, month</code></li>
-  <li><code>month, day</code></li>
-  <li><code>hour, minute, second</code></li>
-  <li><code>hour, minute</code></li>
- </ul>
-
- <p>Les implémentations peuvent supporter d'autres sous-ensembles, et les demandes seront évaluées face à toutes les combinaisons de sous-ensembles disponibles pour trouver la meilleure correspondance. Deux algorithmes sont disponibles pour cette évaluation et choisis par la propriété <code>formatMatcher</code> : un <a href="https://www.ecma-international.org/ecma-402/1.0/#BasicFormatMatcher">algorithme "basic" complètement spécifié</a> et un algorithme <code>"best fit"</code> dépendant de l'implémentation.</p>
-
- <dl>
-  <dt><code>weekday</code></dt>
-  <dd>La représentation du jour de la semaine. Les valeurs possibles sont :
-  <ul>
-   <li><code>"long"</code> (par exemple <code>Thursday</code>)</li>
-   <li><code>"short"</code> (par exemple <code>Thu</code>)</li>
-   <li><code>"narrow"</code> (par exemple <code>T</code>). Deux jours de la semaines pourront partager la même représentation dans certaines locales (par exemple, en anglais <code>Tuesday</code> sera également représenté avec <code>T</code> en notation étroite).</li>
-  </ul>
-  </dd>
-  <dt><code>era</code></dt>
-  <dd>La représentation de l'ère. Les valeurs possibles sont :
-  <ul>
-   <li><code>"long"</code> (par exemple <code>Anno Domini</code>)</li>
-   <li><code>"short"</code> (par exemple <code>AD</code>)</li>
-   <li><code>"narrow"</code> (par exemple <code>A</code>)</li>
-  </ul>
-  </dd>
-  <dt><code>year</code></dt>
-  <dd>La représentation de l'année. Les valeurs possibles sont :
-  <ul>
-   <li><code>"numeric"</code> (par exemple <code>2012</code>)</li>
-   <li><code>"2-digit"</code> (par exemple <code>12</code>)</li>
-  </ul>
-  </dd>
-  <dt><code>month</code></dt>
-  <dd>La représentation du mois. Les valeurs possibles sont :
-  <ul>
-   <li><code>"numeric"</code> (par exemple <code>2</code>)</li>
-   <li><code>"2-digit"</code> (par exemple <code>02</code>)</li>
-   <li><code>"long"</code> (par exemple <code>March</code>)</li>
-   <li><code>"short"</code> (par exemple <code>Mar</code>)</li>
-   <li><code>"narrow"</code> (par exemple <code>M</code>). Dans certaines locales, deux mois pourront partager la même représentation avec le style étroit (par exemple, <code>May</code> en anglais, sera également représenté avec <code>M</code>).</li>
-  </ul>
-  </dd>
-  <dt><code>day</code></dt>
-  <dd>La représentation du jour. Les valeurs possibles sont :
-  <ul>
-   <li><code>"numeric"</code> (par exemple <code>1</code>)</li>
-   <li><code>"2-digit"</code> (par exemple <code>01</code>)</li>
-  </ul>
-  </dd>
-  <dt><code>hour</code></dt>
-  <dd>La représentation de l'heure. Les valeurs possibles sont :
-  <ul>
-   <li><code>"numeric"</code> (par exemple <code>1</code>)</li>
-   <li><code>"2-digit"</code> (par exemple <code>01</code>)</li>
-  </ul>
-  </dd>
-  <dt><code>minute</code></dt>
-  <dd>La représentation des minutes. Les valeurs possibles sont :
-  <ul>
-   <li><code>"numeric"</code> (par exemple <code>1</code>)</li>
-   <li><code>"2-digit"</code> (par exemple <code>01</code>)</li>
-  </ul>
-  </dd>
-  <dt><code>second</code></dt>
-  <dd>La représentation des secondes. Les valeurs possibles sont :
-  <ul>
-   <li><code>"numeric"</code> (par exemple <code>1</code>)</li>
-   <li><code>"2-digit"</code> (par exemple <code>01</code>)</li>
-  </ul>
-  </dd>
-  <dt><code>timeZoneName</code></dt>
-  <dd>La représentation du fuseau horaire. Les valeurs possibles sont :
-  <ul>
-   <li><code>"long"</code> (par exemple <code>British Summer Time</code>)</li>
-   <li><code>"short"</code> (par exemple <code>GMT+1</code>)</li>
-  </ul>
-  </dd>
- </dl>
-
- <p>La valeur par défaut pour chaque composante est {{jsxref("undefined")}}, mais si toutes les composantes valent <code>undefined</code>, alors <code>year</code>, <code>month</code>, et <code>day</code> seront considérés comme <code>"numeric"</code>.</p>
- </dd>
-</dl>
-
-<h2 id="Description">Description</h2>
-
-<h3 id="Propriétés">Propriétés</h3>
-
-<dl>
- <dt>{{jsxref("DateTimeFormat.prototype", "Intl.DateTimeFormat.prototype")}}</dt>
- <dd>Permet l'ajout de propriétés à tous les objets.</dd>
-</dl>
-
-<h3 id="Méthodes">Méthodes</h3>
-
-<dl>
- <dt>{{jsxref("DateTimeFormat.supportedLocalesOf", "Intl.DateTimeFormat.supportedLocalesOf()")}}</dt>
- <dd>Renvoie un tableau contenant les locales supportées parmis les locales fournies, sans qu'il soit nécessaire de recourir à la locale par défaut de l'implémentation.</dd>
-</dl>
-
-<h2 id="Instances_de_DateTimeFormat">Instances de<code> DateTimeFormat</code></h2>
-
-<h3 id="Propriétés_2">Propriétés</h3>
-
-<p>Les instances de<code> DateTimeFormat()</code> héritent des propriétés suivantes depuis leur prototype :</p>
-
-<div>{{page('fr/docs/Web/JavaScript/Reference/Objets_globaux/DateTimeFormat/prototype','Properties')}}</div>
-
-<h3 id="Méthodes_2">Méthodes</h3>
-
-<div>
-<p>Les instances de<code> DateTimeFormat()</code> héritent des propriétés suivantes depuis leur prototype :</p>
-{{page('fr/docs/Web/JavaScript/Reference/Objets_globaux/DateTimeFormat/prototype','Méthodes')}}</div>
-
-<h2 id="Exemples">Exemples</h2>
-
-<h3 id="Utiliser_DateTimeFormat">Utiliser <code>DateTimeFormat()</code></h3>
-
-<p>Dans une utilisation basique sans préciser de locale, <code>DateTimeFormat()</code> utilise la locale et les options par défaut</p>
-
-<pre class="brush:js">var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0));
+{{JSRef}}
+
+L'objet **`Intl.DateTimeFormat`** est un constructeur d'objets permettant de formatter des dates et des heures selon une langue.
+
+{{EmbedInteractiveExample("pages/js/intl-datetimeformat.html")}}
+
+## Syntaxe
+
+    new Intl.DateTimeFormat([locales[, options]])
+    Intl.DateTimeFormat.call(this[, locales[, options]])
+
+### Paramètres
+
+- `locales`{{optional_inline}}
+
+  - : Ce paramètre optionnel est une chaine de caractères avec un identifiant de langue BCP 47, ou un tableau de ce type de chaine de caractères. Pour utiliser la locale par défaut du navigateur, on pourra omettre cet argument (ou passer la valeur `undefined`). Pour le format général et l'interprétation de l'argument `locales`, voir la page {{jsxref("Objets_globaux/Intl","Intl","#L'identification_et_le_choix_de_la_locale")}}. Les clefs d'extensions Unicode suivantes sont autorisées :
+
+    - nu
+      - : Système de numérotation. Les valeurs possibles incluent : `"arab", "arabext", "bali", "beng", "deva", "fullwide", "gujr", "guru", "hanidec", "khmr", "knda", "laoo", "latn", "limb", "mlym", "mong", "mymr", "orya", "tamldec", "telu", "thai", "tibt"`.
+    - ca
+      - : Calendrier. Les valeurs possibles incluent : `"buddhist", "chinese", "coptic", "ethiopia", "ethiopic", "gregory", "hebrew", "indian", "islamic", "islamicc", "iso8601", "japanese", "persian", "roc"`.
+    - `hc`
+      - : Le type de cycle horaire à utiliser. Les valeurs possibles sont `"h11"`, `"h12"`, `"h23"`, `"h24"`.
+
+- `options`
+
+  - : Un objet avec certaines ou toutes les propriétés suivantes :
+
+    - `localeMatcher`
+      - : L'algorithme de correspondance à utiliser pour la locale. Les valeurs possibles sont `"lookup"` et `"best fit"` ; le défaut est `"best fit"`. Pour des informations sur cette option, voir la page {{jsxref("Objets_globaux/Intl","Intl","##Choix_de_la_locale")}}
+    - `timeZone`
+      - : Le fuseau horaire à utiliser. La seule valeur que doivent reconnaitre les implémentations est "UTC" ; la valeur par défaut est le fuseau horaire du moteur JavaScript. Les implémentations peuvent aussi reconnaitre les noms de fuseau horaire de la [base de données IANA de fuseaux horaires](https://www.iana.org/time-zones), tel que `"Asia/Shanghai"`, `"Asia/Kolkata"`, `"America/New_York"`.
+    - `hour12`
+      - : S'il faut utiliser le format horaire sur 12 heures (au lieu de celui-ci sur 24 heures). Les valeurs possibles sont `true` et `false` ; la valeur par défaut dépend de la locale. Cette option surcharge l'étiquette `hc` et/ou l'option `hourCycle`.
+    - `hourCycle`
+      - : Le cycle horaire à utiliser. Les valeurs possibles sont `"h11"`, `"h12"`, `"h23"`, `"h24"`. Cette option surcharge l'étiquette `hc` mais sera remplacée par `hour12` si cette dernière est présente.
+    - `formatMatcher`
+      - : L'algorithme de correspondance à utiliser pour le formattage. Les valeurs possibles sont `"basic"` et `"best fit"` ; par défaut `"best fit"`. Voir les paragraphes suivants pour des informations concernant l'usage de cette propriété.
+
+    Les propriétés suivantes décrivent les composants date-heure à utiliser pour le formattage de la sortie.  Les implémentations ont pour obligation de supporter au minimum les ensembles suivants :
+
+    - `weekday, year, month, day, hour, minute, second`
+    - `weekday, year, month, day`
+    - `year, month, day`
+    - `year, month`
+    - `month, day`
+    - `hour, minute, second`
+    - `hour, minute`
+
+    Les implémentations peuvent supporter d'autres sous-ensembles, et les demandes seront évaluées face à toutes les combinaisons de sous-ensembles disponibles pour trouver la meilleure correspondance. Deux algorithmes sont disponibles pour cette évaluation et choisis par la propriété `formatMatcher` : un [algorithme "basic" complètement spécifié](https://www.ecma-international.org/ecma-402/1.0/#BasicFormatMatcher) et un algorithme `"best fit"` dépendant de l'implémentation.
+
+    - `weekday`
+
+      - : La représentation du jour de la semaine. Les valeurs possibles sont :
+
+        - `"long"` (par exemple `Thursday`)
+        - `"short"` (par exemple `Thu`)
+        - `"narrow"` (par exemple `T`). Deux jours de la semaines pourront partager la même représentation dans certaines locales (par exemple, en anglais `Tuesday` sera également représenté avec `T` en notation étroite).
+
+    - `era`
+
+      - : La représentation de l'ère. Les valeurs possibles sont :
+
+        - `"long"` (par exemple `Anno Domini`)
+        - `"short"` (par exemple `AD`)
+        - `"narrow"` (par exemple `A`)
+
+    - `year`
+
+      - : La représentation de l'année. Les valeurs possibles sont :
+
+        - `"numeric"` (par exemple `2012`)
+        - `"2-digit"` (par exemple `12`)
+
+    - `month`
+
+      - : La représentation du mois. Les valeurs possibles sont :
+
+        - `"numeric"` (par exemple `2`)
+        - `"2-digit"` (par exemple `02`)
+        - `"long"` (par exemple `March`)
+        - `"short"` (par exemple `Mar`)
+        - `"narrow"` (par exemple `M`). Dans certaines locales, deux mois pourront partager la même représentation avec le style étroit (par exemple, `May` en anglais, sera également représenté avec `M`).
+
+    - `day`
+
+      - : La représentation du jour. Les valeurs possibles sont :
+
+        - `"numeric"` (par exemple `1`)
+        - `"2-digit"` (par exemple `01`)
+
+    - `hour`
+
+      - : La représentation de l'heure. Les valeurs possibles sont :
+
+        - `"numeric"` (par exemple `1`)
+        - `"2-digit"` (par exemple `01`)
+
+    - `minute`
+
+      - : La représentation des minutes. Les valeurs possibles sont :
+
+        - `"numeric"` (par exemple `1`)
+        - `"2-digit"` (par exemple `01`)
+
+    - `second`
+
+      - : La représentation des secondes. Les valeurs possibles sont :
+
+        - `"numeric"` (par exemple `1`)
+        - `"2-digit"` (par exemple `01`)
+
+    - `timeZoneName`
+
+      - : La représentation du fuseau horaire. Les valeurs possibles sont :
+
+        - `"long"` (par exemple `British Summer Time`)
+        - `"short"` (par exemple `GMT+1`)
+
+    La valeur par défaut pour chaque composante est {{jsxref("undefined")}}, mais si toutes les composantes valent `undefined`, alors `year`, `month`, et `day` seront considérés comme `"numeric"`.
+
+## Description
+
+### Propriétés
+
+- {{jsxref("DateTimeFormat.prototype", "Intl.DateTimeFormat.prototype")}}
+  - : Permet l'ajout de propriétés à tous les objets.
+
+### Méthodes
+
+- {{jsxref("DateTimeFormat.supportedLocalesOf", "Intl.DateTimeFormat.supportedLocalesOf()")}}
+  - : Renvoie un tableau contenant les locales supportées parmis les locales fournies, sans qu'il soit nécessaire de recourir à la locale par défaut de l'implémentation.
+
+## Instances de` DateTimeFormat`
+
+### Propriétés
+
+Les instances de` DateTimeFormat()` héritent des propriétés suivantes depuis leur prototype :
+
+{{page('fr/docs/Web/JavaScript/Reference/Objets_globaux/DateTimeFormat/prototype','Properties')}}
+
+### Méthodes
+
+Les instances de` DateTimeFormat()` héritent des propriétés suivantes depuis leur prototype :
+
+{{page('fr/docs/Web/JavaScript/Reference/Objets_globaux/DateTimeFormat/prototype','Méthodes')}}
+
+## Exemples
+
+### Utiliser `DateTimeFormat()`
+
+Dans une utilisation basique sans préciser de locale, `DateTimeFormat()` utilise la locale et les options par défaut
+
+```js
+var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0));
 
 // DateTimeFormat sans arguments dépend de l'implémentation,
 // la locale par défaut, et le fuseau horaire par défaut
 console.log(new Intl.DateTimeFormat().format(date));
-// → "20/12/2012" avec une locale fr-Fr et un fuseau horaire CEST</pre>
+// → "20/12/2012" avec une locale fr-Fr et un fuseau horaire CEST
+```
 
-<h3 id="Utiliser_locales">Utiliser <code>locales</code></h3>
+### Utiliser `locales`
 
-<p>Cet exemple montre quelques variations de formattage pour les dates et les heures localisées. Afin d'obtenir le langage utilisé au sein de l'interface utilisateur de votre application, vérifiez de bien fournir ce langage (et éventuellement des locales de recours) en utilisant l'argument <code>locales</code> :</p>
+Cet exemple montre quelques variations de formattage pour les dates et les heures localisées. Afin d'obtenir le langage utilisé au sein de l'interface utilisateur de votre application, vérifiez de bien fournir ce langage (et éventuellement des locales de recours) en utilisant l'argument `locales` :
 
-<pre class="brush: js">var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0));
+```js
+var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0));
 
 // les formats qui suivent se basent sur le
 // fuseau horaire CEST
@@ -209,7 +196,7 @@ console.log(new Intl.DateTimeFormat("ko-KR").format(date));
 
 // l'arabe, dans la plupart des pays arabophones, utilise les chiffres arabes
 console.log(new Intl.DateTimeFormat("ar-EG").format(date));
-// → "<span dir="rtl">٢٠‏/١٢‏/٢٠١٢</span>"
+// → "٢٠‏/١٢‏/٢٠١٢"
 
 // en ce qui concerne le japonais, les applications peuvent
 // souhaiter utiliser le calendrier japonais
@@ -221,13 +208,14 @@ console.log(new Intl.DateTimeFormat("ja-JP-u-ca-japanese").format(date));
 // il est possible de fournir un langage de recours (ici l'indonésien)
 console.log(new Intl.DateTimeFormat(["ban", "id"]).format(date));
 // → "20/12/2012"
-</pre>
+```
 
-<h3 id="Utiliser_options">Utiliser <code>options</code></h3>
+### Utiliser `options`
 
-<p>Les formats de la date et de l'heure peuvent être personnalisés en utilisant l'argument <code>options</code> :</p>
+Les formats de la date et de l'heure peuvent être personnalisés en utilisant l'argument `options` :
 
-<pre class="brush: js">var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0));
+```js
+var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0));
 
 // fournir le jour de la semaine avec une date longue
 var options = {weekday: "long", year: "numeric", month: "long", day: "numeric"};
@@ -256,39 +244,20 @@ console.log(new Intl.DateTimeFormat("en-US", options));
 // pour utiliser la locale par défaut du navigateur :
 console.log(new Intl.DateTimeFormat('default', options).format(date));
 // → "12/19/2012, 19:00:00" (peut varier selon la locale du navigateur)
-</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('ES Int 1.0', '#sec-12.1', 'Intl.DateTimeFormat')}}</td>
-   <td>{{Spec2('ES Int 1.0')}}</td>
-   <td>Première définition.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES Int 2.0', '#sec-12.1', 'Intl.DateTimeFormat')}}</td>
-   <td>{{Spec2('ES Int 2.0')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES Int Draft', '#datetimeformat-objects', 'Intl.DateTimeFormat')}}</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.Intl.DateTimeFormat")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<div>{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/Intl', 'Voir_aussi')}}</div>
+```
+
+## Spécifications
+
+| Spécification                                                                                            | État                             | Commentaires         |
+| -------------------------------------------------------------------------------------------------------- | -------------------------------- | -------------------- |
+| {{SpecName('ES Int 1.0', '#sec-12.1', 'Intl.DateTimeFormat')}}                     | {{Spec2('ES Int 1.0')}} | Première définition. |
+| {{SpecName('ES Int 2.0', '#sec-12.1', 'Intl.DateTimeFormat')}}                     | {{Spec2('ES Int 2.0')}} |                      |
+| {{SpecName('ES Int Draft', '#datetimeformat-objects', 'Intl.DateTimeFormat')}} | {{Spec2('ES Int Draft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Intl.DateTimeFormat")}}
+
+## Voir aussi
+
+{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/Intl', 'Voir_aussi')}}
diff --git a/files/fr/web/javascript/reference/global_objects/intl/datetimeformat/resolvedoptions/index.md b/files/fr/web/javascript/reference/global_objects/intl/datetimeformat/resolvedoptions/index.md
index e00599b987..26e4253671 100644
--- a/files/fr/web/javascript/reference/global_objects/intl/datetimeformat/resolvedoptions/index.md
+++ b/files/fr/web/javascript/reference/global_objects/intl/datetimeformat/resolvedoptions/index.md
@@ -13,61 +13,62 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat/resolvedOptions
 original_slug: Web/JavaScript/Reference/Objets_globaux/Intl/DateTimeFormat/resolvedOptions
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>Intl.DateTimeFormat.prototype.resolvedOptions()</strong></code> renvoie un nouvel objet dont les propriétés reflètent les options de format et de locale pour les heures et dates, calculées pendant l'initialisation de l'objet <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat"><code>Intl.DateTimeFormat</code></a>.</p>
+La méthode **`Intl.DateTimeFormat.prototype.resolvedOptions()`** renvoie un nouvel objet dont les propriétés reflètent les options de format et de locale pour les heures et dates, calculées pendant l'initialisation de l'objet [`Intl.DateTimeFormat`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat).
 
-<div>{{EmbedInteractiveExample("pages/js/intl-datetimeformat-prototype-resolvedoptions.html")}}</div>
+{{EmbedInteractiveExample("pages/js/intl-datetimeformat-prototype-resolvedoptions.html")}}
 
-<h2 id="syntax">Syntaxe</h2>
+## Syntaxe
 
-<pre class="brush: js">resolvedOptions()</pre>
+```js
+resolvedOptions()
+```
 
-<h3 id="return_value">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un nouvel objet dont les propriétés reflètent les options de format et de locale pour les heures et dates, calculées pendant l'initialisation de l'objet <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat"><code>Intl.DateTimeFormat</code></a>.</p>
+Un nouvel objet dont les propriétés reflètent les options de format et de locale pour les heures et dates, calculées pendant l'initialisation de l'objet [`Intl.DateTimeFormat`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat).
 
-<h2 id="description">Description</h2>
+## Description
 
-<p>La valeur renvoyée par cette méthode contient les propriétés suivantes :</p>
+La valeur renvoyée par cette méthode contient les propriétés suivantes :
 
-<dl>
- <dt><code>locale</code></dt>
- <dd>La balise de langue BCP 47 qui est réellement utilisée. Si des extensions Unicode étaient fournies avec la balise d'origine et sont supportées pour la locale utilisée, les paires de clés-valeurs seront incluses dans <code>locale</code>.</dd>
- <dt><code>calendar</code></dt>
- <dd>Le calendrier utilisé (ex. <code>"gregory"</code> pour le calendrier grégorien).</dd>
- <dt><code>numberingSystem</code></dt>
- <dd>Les valeurs demandées pour les extensions Unicode <code>"ca"</code> et <code>"nu"</code> ou leurs valeurs par défaut.</dd>
- <dt><code>timeZone</code></dt>
- <dd>La valeur fournie par l'argument <code>options</code> pour cette propriété ou <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/undefined"><code>undefined</code></a> (qui représente le fuseau horaire de l'environnement) si aucune valeur n'a été fournie. Les applications ne doivent pas s'appuyer sur ce dernier cas. En effet, de futures versions pourraient renvoyer une chaîne de caractères représentant le fuseau horaire de l'environnement et non pas <code>undefined</code>.</dd>
- <dt><code>hour12</code></dt>
- <dd>La valeur fournie pour cette propriété dans l'argument <code>options</code>.</dd>
- <dt><code>weekday</code>, <code>era</code>, <code>year</code>, <code>month</code>, <code>day</code>, <code>hour</code>, <code>minute</code>, <code>second</code>, <code>timeZoneName</code></dt>
- <dd>Les valeurs qui correspondent entre les propriétés de l'argument <code>options</code> et les combinaisons disponibles dans l'environnement pour les formats de date et d'heure pour la locale. Certaines de ces propriétés peuvent ne pas être présentes, cela indique que les composants indiqués ne seront pas représentés.</dd>
-</dl>
+- `locale`
+  - : La balise de langue BCP 47 qui est réellement utilisée. Si des extensions Unicode étaient fournies avec la balise d'origine et sont supportées pour la locale utilisée, les paires de clés-valeurs seront incluses dans `locale`.
+- `calendar`
+  - : Le calendrier utilisé (ex. `"gregory"` pour le calendrier grégorien).
+- `numberingSystem`
+  - : Les valeurs demandées pour les extensions Unicode `"ca"` et `"nu"` ou leurs valeurs par défaut.
+- `timeZone`
+  - : La valeur fournie par l'argument `options` pour cette propriété ou [`undefined`](/fr/docs/Web/JavaScript/Reference/Global_Objects/undefined) (qui représente le fuseau horaire de l'environnement) si aucune valeur n'a été fournie. Les applications ne doivent pas s'appuyer sur ce dernier cas. En effet, de futures versions pourraient renvoyer une chaîne de caractères représentant le fuseau horaire de l'environnement et non pas `undefined`.
+- `hour12`
+  - : La valeur fournie pour cette propriété dans l'argument `options`.
+- `weekday`, `era`, `year`, `month`, `day`, `hour`, `minute`, `second`, `timeZoneName`
+  - : Les valeurs qui correspondent entre les propriétés de l'argument `options` et les combinaisons disponibles dans l'environnement pour les formats de date et d'heure pour la locale. Certaines de ces propriétés peuvent ne pas être présentes, cela indique que les composants indiqués ne seront pas représentés.
 
-<h2 id="examples">Exemples</h2>
+## Exemples
 
-<h3 id="using_the_resolvedoptions_method">Utiliser la méthode resolvedOptions()</h3>
-<pre class="brush: js">var germanFakeRegion = new Intl.DateTimeFormat("de-XX", { timeZone: "UTC" });
+### Utiliser la méthode resolvedOptions()
+
+```js
+var germanFakeRegion = new Intl.DateTimeFormat("de-XX", { timeZone: "UTC" });
 var usedOptions = germanFakeRegion.resolvedOptions();
 
 usedOptions.locale;          // "de"
 usedOptions.calendar;        // "gregory"
 usedOptions.numberingSystem; // "latn"
 usedOptions.timeZone;        // "UTC"
-usedOptions.month;           // "numeric"</pre>
+usedOptions.month;           // "numeric"
+```
 
-<h2 id="specifications">Spécifications</h2>
+## Spécifications
 
 {{Specifications}}
 
-<h2 id="browser_compatibility">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<div>{{Compat}}</div>
+{{Compat}}
 
-<h2 id="see_also">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li><a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat"><code>Intl.DateTimeFormat</code></a></li>
-</ul>
+- [`Intl.DateTimeFormat`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat)
diff --git a/files/fr/web/javascript/reference/global_objects/intl/datetimeformat/supportedlocalesof/index.md b/files/fr/web/javascript/reference/global_objects/intl/datetimeformat/supportedlocalesof/index.md
index 73aecce3f5..13f5517dce 100644
--- a/files/fr/web/javascript/reference/global_objects/intl/datetimeformat/supportedlocalesof/index.md
+++ b/files/fr/web/javascript/reference/global_objects/intl/datetimeformat/supportedlocalesof/index.md
@@ -12,84 +12,60 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat/supportedLocalesOf
 original_slug: Web/JavaScript/Reference/Objets_globaux/Intl/DateTimeFormat/supportedLocalesOf
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>À partir d'une locale ou d'un tableau de locales <code><strong>Intl.DateTimeFormat.supportedLocalesOf()</strong></code> renvoie un tableau qui contient les locales supportées pour le formatage des dates et des heures qui ne nécessitent pas d'avoir recours à la locale par défaut de l'environnement.</p>
+À partir d'une locale ou d'un tableau de locales **`Intl.DateTimeFormat.supportedLocalesOf()`** renvoie un tableau qui contient les locales supportées pour le formatage des dates et des heures qui ne nécessitent pas d'avoir recours à la locale par défaut de l'environnement.
 
-<div>{{EmbedInteractiveExample("pages/js/intl-datetimeformat-prototype-supportedlocalesof.html")}}</div>
+{{EmbedInteractiveExample("pages/js/intl-datetimeformat-prototype-supportedlocalesof.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">Intl.DateTimeFormat.supportedLocalesOf(<var>locales</var>[, <var>options</var>])</pre>
+    Intl.DateTimeFormat.supportedLocalesOf(locales[, options])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>locales</code></dt>
- <dd>Un chaîne de caractères au format d'une balise de langue BCP 47 ou bien un tableau de telles chaînes. Pour plus d'informations sur le format de l'argument <code>locales</code>, voir la page {{jsxref("Intl", "Intl", "#L'identification_et_le_choix_de_la_locale")}}.</dd>
- <dt><code>options</code></dt>
- <dd>
- <p>Paramètre optionnel, un objet pouvant avoir la propriété suivante :</p>
+- `locales`
+  - : Un chaîne de caractères au format d'une balise de langue BCP 47 ou bien un tableau de telles chaînes. Pour plus d'informations sur le format de l'argument `locales`, voir la page {{jsxref("Intl", "Intl", "#L'identification_et_le_choix_de_la_locale")}}.
+- `options`
 
- <dl>
-  <dt><code>localeMatcher</code></dt>
-  <dd>L'algorithme de correspondance entre locales à utiliser. Les valeurs possibles sont "lookup" et "best fit". Pour plus d'informations sur ce sujet, voir la page {{jsxref("Intl", "Intl", "#Choix_de_la_locale")}}.</dd>
- </dl>
- </dd>
-</dl>
+  - : Paramètre optionnel, un objet pouvant avoir la propriété suivante :
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+    - `localeMatcher`
+      - : L'algorithme de correspondance entre locales à utiliser. Les valeurs possibles sont "lookup" et "best fit". Pour plus d'informations sur ce sujet, voir la page {{jsxref("Intl", "Intl", "#Choix_de_la_locale")}}.
 
-<p>Un tableau de chaînes de caractères qui représente un sous-ensemble des balises de langue qui sont prises en charge pour la mise en forme de l'heure et de la date sans qu'il soit nécessaire d'utiliser la locale par défaut de l'environnement d'exécution.</p>
+### Valeur de retour
 
-<h2 id="Description">Description</h2>
+Un tableau de chaînes de caractères qui représente un sous-ensemble des balises de langue qui sont prises en charge pour la mise en forme de l'heure et de la date sans qu'il soit nécessaire d'utiliser la locale par défaut de l'environnement d'exécution.
 
-<p>Renvoie un tableau qui est un sous-ensemble de <code>locales</code>. Les balises de langues renvoyées sont celles supportées par l'environnement pour le formatage des heures et des dates. Ces balises sont déterminées en fonction de l'algorithme de correspondances de locale et des locales utilisées. Le tableau résultant fournit les locales qui permettent de ne pas avoir à utiliser la locale par défaut.</p>
+## Description
 
-<h2 id="Exemple">Exemple</h2>
+Renvoie un tableau qui est un sous-ensemble de `locales`. Les balises de langues renvoyées sont celles supportées par l'environnement pour le formatage des heures et des dates. Ces balises sont déterminées en fonction de l'algorithme de correspondances de locale et des locales utilisées. Le tableau résultant fournit les locales qui permettent de ne pas avoir à utiliser la locale par défaut.
 
-<h3 id="Utiliser_supportedLocalesOf">Utiliser <code>supportedLocalesOf</code></h3>
+## Exemple
 
-<p>Si on dispose d'un environnement qui supporte les locales indonésienne et allemande mais pas balinaise pour le formatage des dates et des heures,  <code>supportedLocalesOf</code> renverra les balises BCP 47 pour l'indonésien et l'allemand (bien que la collation pinyin ne soit pas pertinente pour les dates ni pour l'indonésien et qu'il soit peu probable qu'une variante indonésienne existe pour l'allemand). Pour l'exemple, on l'utilise l'algorithme <code>"lookup"</code>. Si on utilisait <code>"best fit"</code>, on pourrait considérer que l'indonésien est adéquat pour la locale balinaise (sachant que la plupart des balinais comprend l'indonésien) et donc également renvoyer la balise balinaise.</p>
+### Utiliser `supportedLocalesOf`
 
-<pre class="brush: js">var locales = ["ban", "id-u-co-pinyin", "de-ID"];
+Si on dispose d'un environnement qui supporte les locales indonésienne et allemande mais pas balinaise pour le formatage des dates et des heures,  `supportedLocalesOf` renverra les balises BCP 47 pour l'indonésien et l'allemand (bien que la collation pinyin ne soit pas pertinente pour les dates ni pour l'indonésien et qu'il soit peu probable qu'une variante indonésienne existe pour l'allemand). Pour l'exemple, on l'utilise l'algorithme `"lookup"`. Si on utilisait `"best fit"`, on pourrait considérer que l'indonésien est adéquat pour la locale balinaise (sachant que la plupart des balinais comprend l'indonésien) et donc également renvoyer la balise balinaise.
+
+```js
+var locales = ["ban", "id-u-co-pinyin", "de-ID"];
 var options = {localeMatcher: "lookup"};
 console.log(Intl.DateTimeFormat.supportedLocalesOf(locales, options).join(", "));
-// → "id-u-co-pinyin, de-ID"</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('ES Int 1.0', '#sec-12.2.2', 'Intl.DateTimeFormat.supportedLocalesOf')}}</td>
-   <td>{{Spec2('ES Int 1.0')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES Int 2.0', '#sec-12.2.2', 'Intl.DateTimeFormat.supportedLocalesOf')}}</td>
-   <td>{{Spec2('ES Int 2.0')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES Int Draft', '#sec-Intl.DateTimeFormat.supportedLocalesOf', 'Intl.DateTimeFormat.supportedLocalesOf')}}</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.Intl.DateTimeFormat.supportedLocalesOf")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}}</li>
-</ul>
+// → "id-u-co-pinyin, de-ID"
+```
+
+## Spécifications
+
+| Spécification                                                                                                                                                | État                             | Commentaires         |
+| ------------------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------- | -------------------- |
+| {{SpecName('ES Int 1.0', '#sec-12.2.2', 'Intl.DateTimeFormat.supportedLocalesOf')}}                                             | {{Spec2('ES Int 1.0')}} | Définition initiale. |
+| {{SpecName('ES Int 2.0', '#sec-12.2.2', 'Intl.DateTimeFormat.supportedLocalesOf')}}                                             | {{Spec2('ES Int 2.0')}} |                      |
+| {{SpecName('ES Int Draft', '#sec-Intl.DateTimeFormat.supportedLocalesOf', 'Intl.DateTimeFormat.supportedLocalesOf')}} | {{Spec2('ES Int Draft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Intl.DateTimeFormat.supportedLocalesOf")}}
+
+## Voir aussi
+
+- {{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}}
diff --git a/files/fr/web/javascript/reference/global_objects/intl/displaynames/displaynames/index.md b/files/fr/web/javascript/reference/global_objects/intl/displaynames/displaynames/index.md
index ff150634f6..6ce729e68b 100644
--- a/files/fr/web/javascript/reference/global_objects/intl/displaynames/displaynames/index.md
+++ b/files/fr/web/javascript/reference/global_objects/intl/displaynames/displaynames/index.md
@@ -8,97 +8,76 @@ tags:
   - Reference
 translation_of: Web/JavaScript/Reference/Global_Objects/Intl/DisplayNames/DisplayNames
 ---
-<div>{{JSRef}}</div>
-
-<p>Le constructeur <strong><code>Intl.DisplayNames()</code></strong> crée des objets qui permettent de fournir des traductions constantes des noms de langues, régions et systèmes d'écriture.</p>
-
-<div>{{EmbedInteractiveExample("pages/js/intl-displaynames.html")}}</div>
-
-<h2 id="Syntaxe">Syntaxe</h2>
-
-<pre class="syntaxbox notranslate">new Intl.DisplayNames([<var>langues</var>[, <var>options</var>]])
-</pre>
-
-<h3 id="Paramètres">Paramètres</h3>
-
-<dl>
- <dt><code>langues</code> {{optional_inline}}</dt>
- <dd>
- <p>Une chaine avec un code de langue BCP 47, ou un tableau de telles chaines. Pour comprendre la forme générale et l'interprétation de cet argument, voyez {{jsxref("Intl", "Intl page", "#Locale_identification_and_negotiation", 1)}}. Les clés d'extensions Unicode suivantes sont permises :</p>
-
- <dl>
-  <dt><code>nu</code></dt>
-  <dd>Le système de numération à utiliser. Les valeurs possibles sont : <code>"arab"</code>, <code>"arabext"</code>, <code>"bali"</code>, <code>"beng"</code>, <code>"deva"</code>, <code>"fullwide"</code>, <code>"gujr"</code>, <code>"guru"</code>, <code>"hanidec"</code>, <code>"khmr"</code>, <code>"knda"</code>, <code>"laoo"</code>, <code>"latn"</code>, <code>"limb"</code>, <code>"mlym"</code>, <code>"mong"</code>, <code>"mymr"</code>, <code>"orya"</code>, <code>"tamldec"</code>, <code>"telu"</code>, <code>"thai"</code>, <code>"tibt"</code>.</dd>
- </dl>
- </dd>
- <dt><code>options</code> {{optional_inline}}</dt>
- <dd>
- <p>Un objet avec certaines des des propriétés suivantes :</p>
-
- <dl>
-  <dt><code>localeMatcher</code></dt>
-  <dd>L'algorithme de correspondance régional à utiliser. Les valeurs possibles sont <code>"lookup"</code> et <code>"best fit"</code> ; celle par défaut étant <code>"best fit"</code>. Pour plus d'informations à propos de cette option, voir {{jsxref("Global_Objects/Intl", "Intl page", "#Locale_negotiation", 1)}}.</dd>
-  <dt><code>style</code></dt>
-  <dd>Le style de mise en forme à utiliser, celui par défaut étant <code>"long"</code>.
-  <ul>
-   <li><code>"narrow"</code></li>
-   <li><code>"short"</code></li>
-   <li><code>"long"</code></li>
-  </ul>
-  </dd>
-  <dt><code>type</code></dt>
-  <dd>Le type à utiliser, celui par défaut étant <code>"language"</code>.
-  <ul>
-   <li><code>"language"</code></li>
-   <li><code>"region"</code></li>
-   <li><code>"script"</code></li>
-   <li><code>"currency"</code></li>
-  </ul>
-  </dd>
-  <dt><code>fallback</code></dt>
-  <dd>La valeur par défaut à utiliser, celle par défaut étant <code>"code"</code>.
-  <ul>
-   <li><code>"code"</code></li>
-   <li><code>"none"</code></li>
-  </ul>
-  </dd>
- </dl>
- </dd>
-</dl>
-
-<h2 id="Exemples">Exemples</h2>
-
-<h3 id="Utilisation_simple">Utilisation simple</h3>
-
-<p>Dans son utilisation simple, sans spécifier de langue, une chaine dans la langue locale par défaut et avec les options par défaut sera retournée.</p>
-
-<pre class="brush: js notranslate">console.log((new Intl.DisplayNames()).of('US'));
-// Expected output: 'us'
-</pre>
+{{JSRef}}
+
+Le constructeur **`Intl.DisplayNames()`** crée des objets qui permettent de fournir des traductions constantes des noms de langues, régions et systèmes d'écriture.
+
+{{EmbedInteractiveExample("pages/js/intl-displaynames.html")}}
+
+## Syntaxe
+
+    new Intl.DisplayNames([langues[, options]])
+
+### Paramètres
+
+- `langues` {{optional_inline}}
+
+  - : Une chaine avec un code de langue BCP 47, ou un tableau de telles chaines. Pour comprendre la forme générale et l'interprétation de cet argument, voyez {{jsxref("Intl", "Intl page", "#Locale_identification_and_negotiation", 1)}}. Les clés d'extensions Unicode suivantes sont permises :
+
+    - `nu`
+      - : Le système de numération à utiliser. Les valeurs possibles sont : `"arab"`, `"arabext"`, `"bali"`, `"beng"`, `"deva"`, `"fullwide"`, `"gujr"`, `"guru"`, `"hanidec"`, `"khmr"`, `"knda"`, `"laoo"`, `"latn"`, `"limb"`, `"mlym"`, `"mong"`, `"mymr"`, `"orya"`, `"tamldec"`, `"telu"`, `"thai"`, `"tibt"`.
+
+- `options` {{optional_inline}}
+
+  - : Un objet avec certaines des des propriétés suivantes :
+
+    - `localeMatcher`
+      - : L'algorithme de correspondance régional à utiliser. Les valeurs possibles sont `"lookup"` et `"best fit"` ; celle par défaut étant `"best fit"`. Pour plus d'informations à propos de cette option, voir {{jsxref("Global_Objects/Intl", "Intl page", "#Locale_negotiation", 1)}}.
+    - `style`
 
-<h2 id="Spécifications">Spécifications</h2>
+      - : Le style de mise en forme à utiliser, celui par défaut étant `"long"`.
 
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Spécification</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('Intl.DisplayNames', '#sec-intl-displaynames-constructor', 'the Intl.DisplayNames constructor')}}</td>
-  </tr>
- </tbody>
-</table>
+        - `"narrow"`
+        - `"short"`
+        - `"long"`
+
+    - `type`
+
+      - : Le type à utiliser, celui par défaut étant `"language"`.
+
+        - `"language"`
+        - `"region"`
+        - `"script"`
+        - `"currency"`
+
+    - `fallback`
+
+      - : La valeur par défaut à utiliser, celle par défaut étant `"code"`.
+
+        - `"code"`
+        - `"none"`
+
+## Exemples
+
+### Utilisation simple
+
+Dans son utilisation simple, sans spécifier de langue, une chaine dans la langue locale par défaut et avec les options par défaut sera retournée.
+
+```js
+console.log((new Intl.DisplayNames()).of('US'));
+// Expected output: 'us'
+```
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Spécifications
 
-<div>
+| Spécification                                                                                                                                    |
+| ------------------------------------------------------------------------------------------------------------------------------------------------ |
+| {{SpecName('Intl.DisplayNames', '#sec-intl-displaynames-constructor', 'the Intl.DisplayNames constructor')}} |
 
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.Intl.DisplayNames.DisplayNames")}}</p>
-</div>
+{{Compat("javascript.builtins.Intl.DisplayNames.DisplayNames")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("Intl.DisplayNames")}}</li>
-</ul>
+- {{jsxref("Intl.DisplayNames")}}
diff --git a/files/fr/web/javascript/reference/global_objects/intl/displaynames/index.md b/files/fr/web/javascript/reference/global_objects/intl/displaynames/index.md
index 91ea840564..2b0a70c94b 100644
--- a/files/fr/web/javascript/reference/global_objects/intl/displaynames/index.md
+++ b/files/fr/web/javascript/reference/global_objects/intl/displaynames/index.md
@@ -10,49 +10,42 @@ tags:
   - Reference
 translation_of: Web/JavaScript/Reference/Global_Objects/Intl/DisplayNames
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>L'objet <strong><code>Intl.DisplayNames</code></strong> est un constructeur d'objets qui permettent de fournir des traductions des noms de langues, régions et systèmes d'écriture.</p>
+L'objet **`Intl.DisplayNames`** est un constructeur d'objets qui permettent de fournir des traductions des noms de langues, régions et systèmes d'écriture.
 
-<div>{{EmbedInteractiveExample("pages/js/intl-displaynames.html")}}</div>
+{{EmbedInteractiveExample("pages/js/intl-displaynames.html")}}
 
+## Constructeur
 
+- [`Intl.DisplayNames()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/DisplayNames/DisplayNames)
+  - : Crée un nouvel objet `Intl.DisplayNames`.
 
-<h2 id="Constructeur">Constructeur</h2>
+## Méthodes statiques
 
-<dl>
- <dt><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/DisplayNames/DisplayNames"><code>Intl.DisplayNames()</code></a></dt>
- <dd>Crée un nouvel objet <code>Intl.DisplayNames</code>.</dd>
-</dl>
+- [`Intl.DisplayNames.supportedLocalesOf()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/DisplayNames/supportedLocalesOf)
+  - : Retourne un tableau contenant les langues fournies qui sont supportées sans avoir à se rabattre sur la langue locale par défaut au moment de l'exécution.
 
-<h2 id="Méthodes_statiques">Méthodes statiques</h2>
+## Méthodes des instances
 
-<dl>
- <dt><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/DisplayNames/supportedLocalesOf"><code>Intl.DisplayNames.supportedLocalesOf()</code></a></dt>
- <dd>Retourne un tableau contenant les langues fournies qui sont supportées sans avoir à se rabattre sur la langue locale par défaut au moment de l'exécution.</dd>
-</dl>
+- [`Intl.DisplayNames.prototype.of()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/DisplayNames/of)
+  - : Cette méthodes reçoit un `code` et retourne une chaine à partir sur la langue et les options fournies lors de l'instanciation de [`Intl.DisplayNames`](#).
+- [`Intl.DisplayNames.prototype.resolvedOptions()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/DisplayNames/resolvedOptions)
+  - : Retourne un nouvel objet dont les propriété feflètent la langue et les options de formattage calculées lors de l'initialisation de l'objet.
 
-<h2 id="Méthodes_des_instances">Méthodes des instances</h2>
+## Exemples
 
-<dl>
- <dt><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/DisplayNames/of"><code>Intl.DisplayNames.prototype.of()</code></a></dt>
- <dd>Cette méthodes reçoit un <code>code</code> et retourne une chaine à partir sur la langue et les options fournies lors de l'instanciation de <a href="#"><code>Intl.DisplayNames</code></a>.</dd>
- <dt><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/DisplayNames/resolvedOptions"><code>Intl.DisplayNames.prototype.resolvedOptions()</code></a></dt>
- <dd>Retourne un nouvel objet dont les propriété feflètent la langue et les options de formattage calculées lors de l'initialisation de l'objet.</dd>
-</dl>
+### Affichage des noms de régions
 
-<h2 id="Exemples">Exemples</h2>
+Pour créer un objet `Intl.DisplayNames` pour une langue et obtenir le nom correspondant à un code de région dans cette langue.
 
-<h3 id="Affichage_des_noms_de_régions">Affichage des noms de régions</h3>
-
-<p>Pour créer un objet <code>Intl.DisplayNames</code> pour une langue et obtenir le nom correspondant à un code de région dans cette langue.</p>
-
-<pre class="brush: js notranslate">// Obtenir le nom d'une région en anglais
+```js
+// Obtenir le nom d'une région en anglais
 let nomsRégions = new Intl.DisplayNames(['en'], {type: 'region'});
 nomsRégions.of('419'); // "Latin America"
 nomsRégions.of('BZ');  // "Belize"
 nomsRégions.of('US');  // "United States"
-nomsRégions.of('BA');  // "Bosnia &amp; Herzegovina"
+nomsRégions.of('BA');  // "Bosnia & Herzegovina"
 nomsRégions.of('MM');  // "Myanmar (Burma)"
 
 // Obtenir le nom d'une région en chinois traditionnel
@@ -61,13 +54,15 @@ nomsRégions.of('419'; // "拉丁美洲"
 nomsRégions.of('BZ'); // "貝里斯"
 nomsRégions.of('US'); // "美國"
 nomsRégions.of('BA'); // "波士尼亞與赫塞哥維納"
-nomsRégions.of('MM'); // "緬甸"</pre>
+nomsRégions.of('MM'); // "緬甸"
+```
 
-<h3 id="Affichage_des_noms_de_langues">Affichage des noms de langues</h3>
+### Affichage des noms de langues
 
-<p>Pour créer un objet <code>Intl.DisplayNames</code> pour une langue et obtenir le nom correspondant à un code de langue (possiblement suivi d'un code de système d'écriture ou de région) dans cette langue.</p>
+Pour créer un objet `Intl.DisplayNames` pour une langue et obtenir le nom correspondant à un code de langue (possiblement suivi d'un code de système d'écriture ou de région) dans cette langue.
 
-<pre class="brush: js notranslate">// Obtenir le nom d'une langue en anglais
+```js
+// Obtenir le nom d'une langue en anglais
 let nomsLangues= new Intl.DisplayNames(['en'], {type: 'language'});
 nomsLangues.of('fr');      // "French"
 nomsLangues.of('de');      // "German"
@@ -80,15 +75,17 @@ nomsLangues.of('zh-TW');   // "Chinese (Taiwan)"
 nomsLangues = new Intl.DisplayNames(['zh-Hant'], {type: 'language'});
 nomsLangues.of('fr'); // "法文"
 nomsLangues.of('zh'); // "中文"
-nomsLangues.of('de'); // "德文"</pre>
+nomsLangues.of('de'); // "德文"
+```
 
-<h3 id="Affichage_des_noms_de_systèmes_décriture">Affichage des noms de systèmes d'écriture</h3>
+### Affichage des noms de systèmes d'écriture
 
-<p>To create an <code>Intl.DisplayNames</code> for a locale and get the display name for a script code.</p>
+To create an `Intl.DisplayNames` for a locale and get the display name for a script code.
 
-<p>Pour créer un objet <code>Intl.DisplayNames</code> pour une langue et obtenir le nom correspondant à un code de système d'écriture dans cette langue.</p>
+Pour créer un objet `Intl.DisplayNames` pour une langue et obtenir le nom correspondant à un code de système d'écriture dans cette langue.
 
-<pre class="brush: js notranslate">// Obtenir le nom d'un système d'écriture en anglais
+```js
+// Obtenir le nom d'un système d'écriture en anglais
 let nomsSystèmes = new Intl.DisplayNames(['en'], {type: 'script'});
 nomsSystèmes.of('Latn'); // "Latin"
 nomsSystèmes.of('Arab'); // "Arabic"
@@ -98,13 +95,15 @@ nomsSystèmes.of('Kana'); // "Katakana"
 nomsSystèmes = new Intl.DisplayNames(['zh-Hant'], {type: 'script'});
 nomsSystèmes.of('Latn'); // "拉丁文"
 nomsSystèmes.of('Arab'); // "阿拉伯文"
-nomsSystèmes.of('Kana'); // "片假名"</pre>
+nomsSystèmes.of('Kana'); // "片假名"
+```
 
-<h3 id="Affichage_des_noms_de_devises">Affichage des noms de devises</h3>
+### Affichage des noms de devises
 
-<p>Pour créer un objet <code>Intl.DisplayNames</code> pour une langue et obtenir le nom correspondant au code d'une devise.</p>
+Pour créer un objet `Intl.DisplayNames` pour une langue et obtenir le nom correspondant au code d'une devise.
 
-<pre class="brush: js notranslate">// Obtenir le nom d'une devise in English
+```js
+// Obtenir le nom d'une devise in English
 let nomsDevises = new Intl.DisplayNames(['en'], {type: 'currency'});
 nomsDevises.of('USD'); // "US Dollar"
 nomsDevises.of('EUR'); // "Euro"
@@ -116,29 +115,19 @@ nomsDevises = new Intl.DisplayNames(['zh-Hant'], {type: 'currency'});
 nomsDevises.of('USD'); // "美元"
 nomsDevises.of('EUR'); // "歐元"
 nomsDevises.of('TWD'); // "新台幣"
-nomsDevises.of('CNY'); // "人民幣"</pre>
+nomsDevises.of('CNY'); // "人民幣"
+```
 
-<h2 id="Spécifications">Spécifications</h2>
+## Spécifications
 
-<table class="standard-table">
- <thead>
-  <tr>
-   <th scope="col">Spécification</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td>{{SpecName('Intl.DisplayNames', '#intl-displaynames-objects', 'DisplayNames')}}</td>
-  </tr>
- </tbody>
-</table>
+| Spécification                                                                                            |
+| -------------------------------------------------------------------------------------------------------- |
+| {{SpecName('Intl.DisplayNames', '#intl-displaynames-objects', 'DisplayNames')}} |
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.Intl.DisplayNames")}}</p>
+{{Compat("javascript.builtins.Intl.DisplayNames")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("Intl")}}</li>
-</ul>
+- {{jsxref("Intl")}}
diff --git a/files/fr/web/javascript/reference/global_objects/intl/getcanonicallocales/index.md b/files/fr/web/javascript/reference/global_objects/intl/getcanonicallocales/index.md
index a239a169c1..2970706d63 100644
--- a/files/fr/web/javascript/reference/global_objects/intl/getcanonicallocales/index.md
+++ b/files/fr/web/javascript/reference/global_objects/intl/getcanonicallocales/index.md
@@ -10,61 +10,47 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Intl/getCanonicalLocales
 original_slug: Web/JavaScript/Reference/Objets_globaux/Intl/getCanonicalLocales
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>Intl.getCanonicalLocales()</code></strong> renvoie un tableau contenant les noms canoniques des locales. Les doublons seront fusionnés et les éléments passés en arguments doivent être des étiquettes de langues valides.</p>
+La méthode **`Intl.getCanonicalLocales()`** renvoie un tableau contenant les noms canoniques des locales. Les doublons seront fusionnés et les éléments passés en arguments doivent être des étiquettes de langues valides.
 
-<div>{{EmbedInteractiveExample("pages/js/intl-getcanonicallocales.html")}}</div>
+{{EmbedInteractiveExample("pages/js/intl-getcanonicallocales.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">Intl.getCanonicalLocales(locales)</pre>
+    Intl.getCanonicalLocales(locales)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>locales</code></dt>
- <dd>Une liste de chaînes ({{jsxref("String")}}) dont on veut obtenir les noms canoniques pour les locales correspondantes.</dd>
-</dl>
+- `locales`
+  - : Une liste de chaînes ({{jsxref("String")}}) dont on veut obtenir les noms canoniques pour les locales correspondantes.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un tableau qui contient les noms canoniques des locales.</p>
+Un tableau qui contient les noms canoniques des locales.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<pre class="brush: js">Intl.getCanonicalLocales("EN-US"); // ["en-US"]
+```js
+Intl.getCanonicalLocales("EN-US"); // ["en-US"]
 Intl.getCanonicalLocales(["EN-US", "Fr"]); // ["en-US", "fr"]
 
 Intl.getCanonicalLocales("EN_US");
 // RangeError:'EN_US' is not a structurally valid language tag
-</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('ES Int Draft', '#sec-intl.getcanonicallocales', 'Intl.getCanonicalLocales')}}</td>
-   <td>{{Spec2('ES Int Draft')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Intl.getCanonicalLocales")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("NumberFormat.supportedLocalesOf", "Intl.NumberFormat.supportedLocalesOf()")}}</li>
- <li>{{jsxref("DateTimeFormat.supportedLocalesOf", "Intl.DateTimeFormat.supportedLocalesOf()")}}</li>
- <li>{{jsxref("Collator.supportedLocalesOf", "Intl.Collator.supportedLocalesOf()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                            | État                             | Commentaires         |
+| ------------------------------------------------------------------------------------------------------------------------ | -------------------------------- | -------------------- |
+| {{SpecName('ES Int Draft', '#sec-intl.getcanonicallocales', 'Intl.getCanonicalLocales')}} | {{Spec2('ES Int Draft')}} | Définition initiale. |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Intl.getCanonicalLocales")}}
+
+## Voir aussi
+
+- {{jsxref("NumberFormat.supportedLocalesOf", "Intl.NumberFormat.supportedLocalesOf()")}}
+- {{jsxref("DateTimeFormat.supportedLocalesOf", "Intl.DateTimeFormat.supportedLocalesOf()")}}
+- {{jsxref("Collator.supportedLocalesOf", "Intl.Collator.supportedLocalesOf()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/intl/index.md b/files/fr/web/javascript/reference/global_objects/intl/index.md
index 7f1ccb56fd..71920ac7ae 100644
--- a/files/fr/web/javascript/reference/global_objects/intl/index.md
+++ b/files/fr/web/javascript/reference/global_objects/intl/index.md
@@ -10,86 +10,79 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Intl
 original_slug: Web/JavaScript/Reference/Objets_globaux/Intl
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>L'objet <strong><code>Intl</code></strong> est l'espace de noms pour l'API d'Internationalisation d'ECMAScript. Elle fournit des outils de comparaison de chaînes de caractères, de formatage des nombres, de dates et de l'heure selon les langues. <code>Intl</code> donne accès à plusieurs constructeurs et fonctionnalités communs aux constructeurs destinés à l'internationalion et à d'autres fonctions dépendantes des langues.</p>
+L'objet **`Intl`** est l'espace de noms pour l'API d'Internationalisation d'ECMAScript. Elle fournit des outils de comparaison de chaînes de caractères, de formatage des nombres, de dates et de l'heure selon les langues. `Intl` donne accès à plusieurs constructeurs et fonctionnalités communs aux constructeurs destinés à l'internationalion et à d'autres fonctions dépendantes des langues.
 
-<h2 id="Propriétés_constructrices">Propriétés constructrices</h2>
+## Propriétés constructrices
 
-<dl>
- <dt>{{jsxref("Objets_globaux/Collator", "Intl.Collator")}}</dt>
- <dd>Le constructeur pour les ordonnanceurs (<em>collators</em> en anglais) et les objets qui permettent la comparaison de chaînes de caractères selon les règles spécifiques d'une langue.</dd>
- <dt>{{jsxref("Objets_globaux/DateTimeFormat", "Intl.DateTimeFormat")}}</dt>
- <dd>Le constructeur pour les objets qui permettent le formatage des dates et de l'heure selon les règles spécifiques d'une langue.</dd>
- <dt>{{jsxref("Global_Objects/Intl/DisplayNames/DisplayNames", "Intl.DisplayNames()")}}</dt>
- <dd>Le constructeur pour les objets qui permettent de fournir des traductions constantes de noms de langues, régions et systèmes d'écriture.</dd>
- <dt>{{jsxref("Objets_globaux/ListFormat", "Intl.ListFormat")}}</dt>
- <dd>Le constructeur pour les objets qui permettent le formatage des listes selon les règles spécifiques d'une langue.</dd>
- <dt>{{jsxref("Global_Objects/Intl/Locale/Locale", "Intl.Locale()")}}</dt>
- <dd>Le constructeur pour les objets qui représentent un identifiant de langue Unicode.</dd>
- <dt>{{jsxref("Objets_globaux/NumberFormat", "Intl.NumberFormat")}}</dt>
- <dd>Le constructeur pour les objets qui permettent le formatage des nombres selon les règles spécifiques d'une langue.</dd>
- <dt>{{jsxref("Objets_globaux/PluralRules","Intl.PluralRules")}}</dt>
- <dd>Le constructeur pour les objets qui permettent le formatage prenant en compte le pluriel et les règles de pluriel spécifiques d'une langue.</dd>
- <dt>{{jsxref("Objets_globaux/RelativeTimeFormat","Intl.RelativeTimeFormat")}}</dt>
- <dd>Le constructeur pour les objets qui permettent le formatage d'intervalles de temps spécifiques d'une langue.</dd>
-</dl>
+- {{jsxref("Objets_globaux/Collator", "Intl.Collator")}}
+  - : Le constructeur pour les ordonnanceurs (_collators_ en anglais) et les objets qui permettent la comparaison de chaînes de caractères selon les règles spécifiques d'une langue.
+- {{jsxref("Objets_globaux/DateTimeFormat", "Intl.DateTimeFormat")}}
+  - : Le constructeur pour les objets qui permettent le formatage des dates et de l'heure selon les règles spécifiques d'une langue.
+- {{jsxref("Global_Objects/Intl/DisplayNames/DisplayNames", "Intl.DisplayNames()")}}
+  - : Le constructeur pour les objets qui permettent de fournir des traductions constantes de noms de langues, régions et systèmes d'écriture.
+- {{jsxref("Objets_globaux/ListFormat", "Intl.ListFormat")}}
+  - : Le constructeur pour les objets qui permettent le formatage des listes selon les règles spécifiques d'une langue.
+- {{jsxref("Global_Objects/Intl/Locale/Locale", "Intl.Locale()")}}
+  - : Le constructeur pour les objets qui représentent un identifiant de langue Unicode.
+- {{jsxref("Objets_globaux/NumberFormat", "Intl.NumberFormat")}}
+  - : Le constructeur pour les objets qui permettent le formatage des nombres selon les règles spécifiques d'une langue.
+- {{jsxref("Objets_globaux/PluralRules","Intl.PluralRules")}}
+  - : Le constructeur pour les objets qui permettent le formatage prenant en compte le pluriel et les règles de pluriel spécifiques d'une langue.
+- {{jsxref("Objets_globaux/RelativeTimeFormat","Intl.RelativeTimeFormat")}}
+  - : Le constructeur pour les objets qui permettent le formatage d'intervalles de temps spécifiques d'une langue.
 
-<h2 id="Méthodes_statiques">Méthodes statiques</h2>
+## Méthodes statiques
 
-<dl>
- <dt>{{jsxref("Intl.getCanonicalLocales()")}}</dt>
- <dd>Méthode renvoyant les noms canoniques des locales.</dd>
-</dl>
+- {{jsxref("Intl.getCanonicalLocales()")}}
+  - : Méthode renvoyant les noms canoniques des locales.
 
-<h2 id="Identification_et_choix_de_la_locale">Identification et choix de la locale</h2>
+## Identification et choix de la locale
 
-<p>Les constructeurs d'internationalisation, ainsi que plusieurs autres méthodes spécifiques à une langue dans d'autres constructeurs (voir ci-dessous {{anch("See_also", "Voir aussi")}}), utilisent un schéma commun pour identifier les locales et déterminer celle qu'ils utiliseront effectivement : ils acceptent tous les arguments <code>locales</code> et <code>options</code>, et ils négocient les locales demandées face aux locales qu'ils supportent, en utilisant un algorithme spécifié dans la propriété <code>options.localeMatcher</code>.</p>
+Les constructeurs d'internationalisation, ainsi que plusieurs autres méthodes spécifiques à une langue dans d'autres constructeurs (voir ci-dessous {{anch("See_also", "Voir aussi")}}), utilisent un schéma commun pour identifier les locales et déterminer celle qu'ils utiliseront effectivement : ils acceptent tous les arguments `locales` et `options`, et ils négocient les locales demandées face aux locales qu'ils supportent, en utilisant un algorithme spécifié dans la propriété `options.localeMatcher`.
 
-<h3 id="Argument_locales">Argument <code>locales</code></h3>
+### Argument `locales`
 
-<p>L'argument <code>locales</code> peut être soit une chaîne de caractères comportant une <a href="http://tools.ietf.org/html/rfc5646">balise de langue BCP 47</a>, soit un tableau de telles balises. Si l'argument n'est pas fourni ou est indéfini, la locale par défaut de l'environnement d'exécution est utilisée.</p>
+L'argument `locales` peut être soit une chaîne de caractères comportant une [balise de langue BCP 47](http://tools.ietf.org/html/rfc5646), soit un tableau de telles balises. Si l'argument n'est pas fourni ou est indéfini, la locale par défaut de l'environnement d'exécution est utilisée.
 
-<p>Une balise de langue BCP 47 définit un langage et contient au minimum un code de langue principale. Dans sa forme la plus fréquente, elle peut contenir, dans l'ordre : un code de langue, un code de script et un code de pays ou de région, tous séparés par des tirets. Bien que la balise ne soit sensible à la casse, il est recommandé d'utiliser des initiales majuscules pour le code de script, des majuscules pour les codes de pays et de région, et des minuscules pour tout le reste.</p>
+Une balise de langue BCP 47 définit un langage et contient au minimum un code de langue principale. Dans sa forme la plus fréquente, elle peut contenir, dans l'ordre : un code de langue, un code de script et un code de pays ou de région, tous séparés par des tirets. Bien que la balise ne soit sensible à la casse, il est recommandé d'utiliser des initiales majuscules pour le code de script, des majuscules pour les codes de pays et de région, et des minuscules pour tout le reste.
 
-<p>Exemples :</p>
+Exemples :
 
-<ul>
- <li><code>"hi"</code> : Hindi (langue principale).</li>
- <li><code>"de-AT"</code> : Allemand tel qu'utilisé en Autriche (langue principale avec un code pays).</li>
- <li><code>"zh-Hans-CN"</code> : Le chinois écrit en caractères simplifiés tel qu'utilisé en Chine (langue principale avec des codes de script et de pays).</li>
-</ul>
+- `"hi"` : Hindi (langue principale).
+- `"de-AT"` : Allemand tel qu'utilisé en Autriche (langue principale avec un code pays).
+- `"zh-Hans-CN"` : Le chinois écrit en caractères simplifiés tel qu'utilisé en Chine (langue principale avec des codes de script et de pays).
 
-<p>Les sous balises identifiant les langues, les scripts, les pays (régions) et les variantes (rarement utilisées) dans les balises de langue BCP 47 peuvent être trouvées dans le <a href="http://www.iana.org/assignments/language-subtag-registry">registre IANA des Sous balises de Langues</a></p>
+Les sous balises identifiant les langues, les scripts, les pays (régions) et les variantes (rarement utilisées) dans les balises de langue BCP 47 peuvent être trouvées dans le [registre IANA des Sous balises de Langues](http://www.iana.org/assignments/language-subtag-registry)
 
-<p>La BCP 47 permet également des extensions. Les fonctions d'internalisation de JavaScript utilisent l'extension "u" (Unicode), qui peut utilisée pour demander une personnalisation supplémentaire des objets {{jsxref("Collator")}}, {{jsxref("NumberFormat")}}, ou {{jsxref("DateTimeFormat")}}. Exemples :</p>
+La BCP 47 permet également des extensions. Les fonctions d'internalisation de JavaScript utilisent l'extension "u" (Unicode), qui peut utilisée pour demander une personnalisation supplémentaire des objets {{jsxref("Collator")}}, {{jsxref("NumberFormat")}}, ou {{jsxref("DateTimeFormat")}}. Exemples :
 
-<ul>
- <li><code>"de-DE-u-co-phonebk"</code> : utiliser la variante annuaire de l'ordre de tri allemand, qui décompose les voyelles infléchies (à umlaut) en paires de caractères : ä → ae, ö → oe, ü → ue.</li>
- <li><code>"th-TH-u-nu-thai"</code> : utiliser les chiffres thaïs (๐, ๑, ๒, ๓, ๔, ๕, ๖, ๗, ๘, ๙) dans le formatage des nombres.</li>
- <li><code>"ja-JP-u-ca-japanese"</code> : utiliser le calendrier japonais dans le formatage des dates et des heures, de sorte que 2013 soit exprimé comme l'an 25 de l'ère Heisei, ou 平成25.</li>
- <li><code>"en-GB-u-ca-islamic"</code> : utiliser l'anglais britannique avec le calendrier islamique (Hijri), où la date grégorienne 14 octobre 2017 est la date de l'ère de l'Hégire 24 Muharram,1439.</li>
-</ul>
+- `"de-DE-u-co-phonebk"` : utiliser la variante annuaire de l'ordre de tri allemand, qui décompose les voyelles infléchies (à umlaut) en paires de caractères : ä → ae, ö → oe, ü → ue.
+- `"th-TH-u-nu-thai"` : utiliser les chiffres thaïs (๐, ๑, ๒, ๓, ๔, ๕, ๖, ๗, ๘, ๙) dans le formatage des nombres.
+- `"ja-JP-u-ca-japanese"` : utiliser le calendrier japonais dans le formatage des dates et des heures, de sorte que 2013 soit exprimé comme l'an 25 de l'ère Heisei, ou 平成 25.
+- `"en-GB-u-ca-islamic"` : utiliser l'anglais britannique avec le calendrier islamique (Hijri), où la date grégorienne 14 octobre 2017 est la date de l'ère de l'Hégire 24 Muharram,1439.
 
-<h3 id="Négociation_de_la_locale">Négociation de la locale</h3>
+### Négociation de la locale
 
-<p>L'argument <code>locales</code>, après retrait de toutes les extensions Unicode, est interprété comme une requête classée par priorité émanant de l'application. L'environnement d'exécution le compare aux locales dont il dispose et choisit la meilleure disponible. Il existe deux algorithmes d'association : l'apparieur "lookup" suit l'algorithme Lookup spécifié dans <a href="http://tools.ietf.org/html/rfc4647#section-3.4">BCP 47</a>; l'apparieur "meilleure correspondance" laisse l'environnement d'exécution fournir une locale qui est au moins aussi, mais possiblement mieux, adaptée à la demande que le résultat de l'algorithme Lookup. Si l'application ne fournit pas d'argument <code>locales</code> ou que l'environnement d'exécution ne dispose pas d'une locale qui corresponde à la requête, alors la locale par défaut de l'environnement d'exécution est utilisée. L'apparieur peut être choisi en utilisant une propriété de l'argument <code>options</code> (voir ci-dessous).</p>
+L'argument `locales`, après retrait de toutes les extensions Unicode, est interprété comme une requête classée par priorité émanant de l'application. L'environnement d'exécution le compare aux locales dont il dispose et choisit la meilleure disponible. Il existe deux algorithmes d'association : l'apparieur "lookup" suit l'algorithme Lookup spécifié dans [BCP 47](http://tools.ietf.org/html/rfc4647#section-3.4); l'apparieur "meilleure correspondance" laisse l'environnement d'exécution fournir une locale qui est au moins aussi, mais possiblement mieux, adaptée à la demande que le résultat de l'algorithme Lookup. Si l'application ne fournit pas d'argument `locales` ou que l'environnement d'exécution ne dispose pas d'une locale qui corresponde à la requête, alors la locale par défaut de l'environnement d'exécution est utilisée. L'apparieur peut être choisi en utilisant une propriété de l'argument `options` (voir ci-dessous).
 
-<p>Si la balise de la langue choisie comporte une sous chaîne d'extension Unicode, cette extension est maintenant utilisée pour personnaliser l'objet construit ou le comportement de la fonction. Chaque constructeur ou fonction ne supporte qu'un sous-ensemble des clés définies pour le extension Unicode, et les valeurs supportées dépendent souvent de la balise de langue. Par exemple, la clé "co" (collation) n'est supportée que par le constructeur {{jsxref("Collator")}}, et sa valeur "phonebk" n'est supportée que pour l'allemand.</p>
+Si la balise de la langue choisie comporte une sous chaîne d'extension Unicode, cette extension est maintenant utilisée pour personnaliser l'objet construit ou le comportement de la fonction. Chaque constructeur ou fonction ne supporte qu'un sous-ensemble des clés définies pour le extension Unicode, et les valeurs supportées dépendent souvent de la balise de langue. Par exemple, la clé "co" (collation) n'est supportée que par le constructeur {{jsxref("Collator")}}, et sa valeur "phonebk" n'est supportée que pour l'allemand.
 
-<h3 id="Argument_options">Argument <code>options</code></h3>
+### Argument `options`
 
-<p>L'argument <code>options</code> doit être un objet ayant des propriétés qui varient suivant qu'il s'agit des constructeurs ou des fonctions. Si l'argument <code>options</code> n'est pas fourni ou est indéfini, des valeurs par défaut seront utilisées pour toutes les propriétés.</p>
+L'argument `options` doit être un objet ayant des propriétés qui varient suivant qu'il s'agit des constructeurs ou des fonctions. Si l'argument `options` n'est pas fourni ou est indéfini, des valeurs par défaut seront utilisées pour toutes les propriétés.
 
-<p>Une propriété est supportée par tous les constructeurs et toutes les fonctions fondés sur les locales : la propriété <code>localeMatcher</code>, dont la valeur doit être la chaîne <code>"lookup"</code> ou <code>"best fit"</code>, et qui sélectionne l'un des algorithmes d'appariement décrits ci-dessus.</p>
+Une propriété est supportée par tous les constructeurs et toutes les fonctions fondés sur les locales : la propriété `localeMatcher`, dont la valeur doit être la chaîne `"lookup"` ou `"best fit"`, et qui sélectionne l'un des algorithmes d'appariement décrits ci-dessus.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Formater_des_dates_et_nombres">Formater des dates et nombres</h3>
+### Formater des dates et nombres
 
-<p>Vous pouvez utiliser Intl pour formater des dates et nombres dans un format qui est conventionnel pour une langue et une région spécifiques :</p>
+Vous pouvez utiliser Intl pour formater des dates et nombres dans un format qui est conventionnel pour une langue et une région spécifiques :
 
-<pre class="brush: js notranslate">const compte = 26254.39;
+```js
+const compte = 26254.39;
 const date = new Date("2012-05-24");
 
 function afficher (langue) {
@@ -102,61 +95,38 @@ afficher("en-US");
 // résultat attendu : 5/24/2012 26,254.39
 
 afficher("de-DE");
-// résultat attendu : 24.5.2012 26.254,39</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('ES Int 1.0', '#sec-8', 'Intl')}}</td>
-   <td>{{Spec2('ES Int 1.0')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES Int 2.0', '#sec-8', 'Intl')}}</td>
-   <td>{{Spec2('ES Int 2.0')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES Int Draft', '#intl-object', 'Intl')}}</td>
-   <td>{{Spec2('ES Int Draft')}}</td>
-   <td>Ajout de <code>Intl.getCanonicalLocales</code> dans la 4e édition.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Intl")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>Introduction : <a href="http://norbertlindenberg.com/2012/12/ecmascript-internationalization-api/index.html">'The ECMAScript Internationalisation API</a></li>
- <li>Constructeurs
-  <ul>
-   <li>{{jsxref("Collator", "Intl.Collator")}}</li>
-   <li>{{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}}</li>
-   <li>{{jsxref("ListFormat", "Intl.ListFormat")}}</li>
-   <li>{{jsxref("NumberFormat", "Intl.NumberFormat")}}</li>
-   <li>{{jsxref("PluralRules", "Intl.PluralRules")}}</li>
-   <li>{{jsxref("RelativeTimeFormat", "Intl.RelativeTimeFormat")}}</li>
-   <li>{{jsxref("Locale", "Intl.Locale")}}</li>
-  </ul>
- </li>
- <li>Méthodes
-  <ul>
-   <li>{{jsxref("String.prototype.localeCompare()")}}</li>
-   <li>{{jsxref("Number.prototype.toLocaleString()")}}</li>
-   <li>{{jsxref("Date.prototype.toLocaleString()")}}</li>
-   <li>{{jsxref("Date.prototype.toLocaleDateString()")}}</li>
-   <li>{{jsxref("Date.prototype.toLocaleTimeString()")}}</li>
-  </ul>
- </li>
-</ul>
+// résultat attendu : 24.5.2012 26.254,39
+```
+
+## Spécifications
+
+| Spécification                                                        | État                             | Commentaires                                            |
+| -------------------------------------------------------------------- | -------------------------------- | ------------------------------------------------------- |
+| {{SpecName('ES Int 1.0', '#sec-8', 'Intl')}}         | {{Spec2('ES Int 1.0')}} | Définition initiale.                                    |
+| {{SpecName('ES Int 2.0', '#sec-8', 'Intl')}}         | {{Spec2('ES Int 2.0')}} |                                                         |
+| {{SpecName('ES Int Draft', '#intl-object', 'Intl')}} | {{Spec2('ES Int Draft')}} | Ajout de `Intl.getCanonicalLocales` dans la 4e édition. |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Intl")}}
+
+## Voir aussi
+
+- Introduction : ['The ECMAScript Internationalisation API](http://norbertlindenberg.com/2012/12/ecmascript-internationalization-api/index.html)
+- Constructeurs
+
+  - {{jsxref("Collator", "Intl.Collator")}}
+  - {{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}}
+  - {{jsxref("ListFormat", "Intl.ListFormat")}}
+  - {{jsxref("NumberFormat", "Intl.NumberFormat")}}
+  - {{jsxref("PluralRules", "Intl.PluralRules")}}
+  - {{jsxref("RelativeTimeFormat", "Intl.RelativeTimeFormat")}}
+  - {{jsxref("Locale", "Intl.Locale")}}
+
+- Méthodes
+
+  - {{jsxref("String.prototype.localeCompare()")}}
+  - {{jsxref("Number.prototype.toLocaleString()")}}
+  - {{jsxref("Date.prototype.toLocaleString()")}}
+  - {{jsxref("Date.prototype.toLocaleDateString()")}}
+  - {{jsxref("Date.prototype.toLocaleTimeString()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/intl/listformat/format/index.md b/files/fr/web/javascript/reference/global_objects/intl/listformat/format/index.md
index ab43e1466e..f18d79b75b 100644
--- a/files/fr/web/javascript/reference/global_objects/intl/listformat/format/index.md
+++ b/files/fr/web/javascript/reference/global_objects/intl/listformat/format/index.md
@@ -12,56 +12,39 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Intl/ListFormat/format
 original_slug: Web/JavaScript/Reference/Objets_globaux/Intl/ListFormat/format
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>format()</code></strong> renvoie une chaîne de caractères représentant la liste passée en argument, mise en forme selon la langue choisie (lors de la construction de l'objet <code>Intl.ListFormat</code>).</p>
+La méthode **`format()`** renvoie une chaîne de caractères représentant la liste passée en argument, mise en forme selon la langue choisie (lors de la construction de l'objet `Intl.ListFormat`).
 
-<div>{{EmbedInteractiveExample("pages/js/intl-listformat.html")}}</div>
+{{EmbedInteractiveExample("pages/js/intl-listformat.html")}}
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La méthode <strong><code>format()</code></strong> renvoie une chaîne de caractères qui a été formatée en fonction des paramètres fournis à l'objet <code>Intl.ListFormat</code>. Les paramètres <code>locales</code> et <code>options</code> permettent de personnaliser le comportement de <code>format()</code> et de gérer différentes conventions linguistiques au sein d'une application, notamment pour la mise en forme des listes.</p>
+La méthode **`format()`** renvoie une chaîne de caractères qui a été formatée en fonction des paramètres fournis à l'objet `Intl.ListFormat`. Les paramètres `locales` et `options` permettent de personnaliser le comportement de `format()` et de gérer différentes conventions linguistiques au sein d'une application, notamment pour la mise en forme des listes.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><em>listFormat</em>.format([<em>list</em>]);</pre>
+    listFormat.format([list]);
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><strong><code>list</code></strong></dt>
- <dd>Un objet itérable (ex. un tableau / {{jsxref("Array")}}).</dd>
-</dl>
+- **`list`**
+  - : Un objet itérable (ex. un tableau / {{jsxref("Array")}}).
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une chaîne de caractères représentant les éléments de la liste et mise en forme en fonction de la langue souhaitée (grâce au paramètre <code>locales</code> passé au constructeur <code>Intl.ListFormat</code>).</p>
+Une chaîne de caractères représentant les éléments de la liste et mise en forme en fonction de la langue souhaitée (grâce au paramètre `locales` passé au constructeur `Intl.ListFormat`).
 
-<h2 id="Spécifications">Spécifications</h2>
+## Spécifications
 
-<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><a href="https://tc39.github.io/proposal-intl-list-format/#sec-Intl.ListFormat.prototype.format">Proposition pour <code>Intl.ListFormat.prototype.format</code></a></td>
-   <td>Proposition de niveau 3</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
+| Spécification                                                                                                                                 | État                    | Commentaires |
+| --------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------- | ------------ |
+| [Proposition pour `Intl.ListFormat.prototype.format`](https://tc39.github.io/proposal-intl-list-format/#sec-Intl.ListFormat.prototype.format) | Proposition de niveau 3 |              |
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.Intl.ListFormat.format")}}</p>
+{{Compat("javascript.builtins.Intl.ListFormat.format")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("ListFormat", "Intl.ListFormat")}}</li>
-</ul>
+- {{jsxref("ListFormat", "Intl.ListFormat")}}
diff --git a/files/fr/web/javascript/reference/global_objects/intl/listformat/formattoparts/index.md b/files/fr/web/javascript/reference/global_objects/intl/listformat/formattoparts/index.md
index 8f13257373..2730cf774b 100644
--- a/files/fr/web/javascript/reference/global_objects/intl/listformat/formattoparts/index.md
+++ b/files/fr/web/javascript/reference/global_objects/intl/listformat/formattoparts/index.md
@@ -12,37 +12,35 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Intl/ListFormat/formatToParts
 original_slug: Web/JavaScript/Reference/Objets_globaux/Intl/ListFormat/formatToParts
 ---
-<div>{{JSRef}}{{Draft}}</div>
+{{JSRef}}{{Draft}}
 
-<p>La méthode <strong><code>Intl.ListFormat.prototype.formatToParts()</code></strong> renvoie un tableau ({{jsxref("Array")}}) d'objets représentants les différentes composantes de la chaine de caractères qui est le résultat du formatage de la liste (selon les options de locale et de style indiquées).</p>
+La méthode **`Intl.ListFormat.prototype.formatToParts()`** renvoie un tableau ({{jsxref("Array")}}) d'objets représentants les différentes composantes de la chaine de caractères qui est le résultat du formatage de la liste (selon les options de locale et de style indiquées).
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">Intl.ListFormat.prototype.formatToParts(<var>list</var>)
-</pre>
+    Intl.ListFormat.prototype.formatToParts(list)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>list</code></dt>
- <dd>Un tableau ({{jsxref("Array")}}) de valeurs à mettre en forme selon une locale et des options de style.</dd>
-</dl>
+- `list`
+  - : Un tableau ({{jsxref("Array")}}) de valeurs à mettre en forme selon une locale et des options de style.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un tableau ({{jsxref("Array")}}) de fragments composants la chaîne de caractères pour la liste formatée.</p>
+Un tableau ({{jsxref("Array")}}) de fragments composants la chaîne de caractères pour la liste formatée.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Alors que la méthode {{jsxref("ListFormat.prototype.format()", "Intl.ListFormat.prototype.format()")}} renvoie une chaîne de caractères avec la liste formatée (en fonction de la locale et des options de style), <code>formatToParts()</code> renvoie un tableau des différentes composantes de cette chaîne.</p>
+Alors que la méthode {{jsxref("ListFormat.prototype.format()", "Intl.ListFormat.prototype.format()")}} renvoie une chaîne de caractères avec la liste formatée (en fonction de la locale et des options de style), `formatToParts()` renvoie un tableau des différentes composantes de cette chaîne.
 
-<p>Chaque élément du tableau résultant possède deux propriétés : <code>type</code> et <code>value</code>. La propriété <code>type</code> pourra valoir <code>"element"</code> (pour indiquer une valeur de la liste) ou <code>"literal"</code> (pour indiquer un élément linguistique). La propriété <code>value</code> fournit quant à elle le contenu du fragment sous forme d'une chaîne de caractères.</p>
+Chaque élément du tableau résultant possède deux propriétés : `type` et `value`. La propriété `type` pourra valoir `"element"` (pour indiquer une valeur de la liste) ou `"literal"` (pour indiquer un élément linguistique). La propriété `value` fournit quant à elle le contenu du fragment sous forme d'une chaîne de caractères.
 
-<p>Les options de locale et de style utilisées pour le formatage sont fournies lors de la construction de l'instance {{jsxref("ListFormat", "Intl.ListFormat")}}.</p>
+Les options de locale et de style utilisées pour le formatage sont fournies lors de la construction de l'instance {{jsxref("ListFormat", "Intl.ListFormat")}}.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<pre class="brush: js">const fruits = ['Apple', 'Orange', 'Pineapple'];
+```js
+const fruits = ['Apple', 'Orange', 'Pineapple'];
 const myListFormat = new Intl.ListFormat('en-GB', { style: 'long', type: 'conjunction' });
 
 console.table(myListFormat.formatToParts(fruits));
@@ -53,37 +51,22 @@ console.table(myListFormat.formatToParts(fruits));
 //  { "type": "literal", "value": ", and " },
 //  { "type": "element", "value": "Pineapple" }
 // ]
-</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><a href="https://tc39.github.io/proposal-intl-list-format/#sec-Intl.ListFormat.prototype.formatToParts"><code>Intl.ListFormat.prototype.formatToParts</code> proposal</a></td>
-   <td>Stage 3</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Intl.ListFormat.formatToParts")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("ListFormat", "Intl.ListFormat")}}</li>
- <li>{{jsxref("ListFormat.prototype.format()", "Intl.ListFormat.prototype.format()")}}</li>
- <li>{{jsxref("RelativeTimeFormat.formatToParts()", "Intl.RelativeTimeFormat.prototype.formatToParts()")}}</li>
- <li>{{jsxref("NumberFormat.formatToParts()", "Intl.NumberFormat.prototype.formatToParts()")}}</li>
- <li>{{jsxref("DateTimeFormat.formatToParts()", "Intl.DateTimeFormat.prototype.formatToParts()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                                                       | État    | Commentaires |
+| --------------------------------------------------------------------------------------------------------------------------------------------------- | ------- | ------------ |
+| [`Intl.ListFormat.prototype.formatToParts` proposal](https://tc39.github.io/proposal-intl-list-format/#sec-Intl.ListFormat.prototype.formatToParts) | Stage 3 |              |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Intl.ListFormat.formatToParts")}}
+
+## Voir aussi
+
+- {{jsxref("ListFormat", "Intl.ListFormat")}}
+- {{jsxref("ListFormat.prototype.format()", "Intl.ListFormat.prototype.format()")}}
+- {{jsxref("RelativeTimeFormat.formatToParts()", "Intl.RelativeTimeFormat.prototype.formatToParts()")}}
+- {{jsxref("NumberFormat.formatToParts()", "Intl.NumberFormat.prototype.formatToParts()")}}
+- {{jsxref("DateTimeFormat.formatToParts()", "Intl.DateTimeFormat.prototype.formatToParts()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/intl/listformat/index.md b/files/fr/web/javascript/reference/global_objects/intl/listformat/index.md
index 6bc6208998..af5f79508d 100644
--- a/files/fr/web/javascript/reference/global_objects/intl/listformat/index.md
+++ b/files/fr/web/javascript/reference/global_objects/intl/listformat/index.md
@@ -11,142 +11,112 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Intl/ListFormat
 original_slug: Web/JavaScript/Reference/Objets_globaux/Intl/ListFormat
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>L'objet <strong><code>Intl.ListFormat</code></strong> est un constructeur d'objets qui permettent de formater des listes de façon différente selon la langue utilisée.</p>
+L'objet **`Intl.ListFormat`** est un constructeur d'objets qui permettent de formater des listes de façon différente selon la langue utilisée.
 
-<div>{{EmbedInteractiveExample("pages/js/intl-listformat.html")}}</div>
+{{EmbedInteractiveExample("pages/js/intl-listformat.html")}}
 
+## Syntax
 
+    new Intl.ListFormat([locales[, options]])
 
-<h2 id="Syntax">Syntax</h2>
+### Paramètres
 
-<pre class="syntaxbox">new Intl.ListFormat([<var>locales</var>[, <var>options</var>]])
-</pre>
+- `locales`{{optional_inline}}
+  - : Paramètre optionnel. Une chaine de caractères avec un identifiant de langue BCP 47, ou un tableau de ce type de chaine de caractères. Pour le format général et l'interprétation de l'argument `locales`, voir la page {{jsxref("Intl","Intl","#L'identification_et_le_choix_de_la_locale")}}.
+- `options`{{optional_inline}}
 
-<h3 id="Paramètres">Paramètres</h3>
+  - : Paramètre optionnel. Un objet avec certaines ou toutes les propriétés suivantes :
 
-<dl>
- <dt><code>locales</code>{{optional_inline}}</dt>
- <dd>
- <p>Paramètre optionnel. Une chaine de caractères avec un identifiant de langue BCP 47, ou un tableau de ce type de chaine de caractères. Pour le format général et l'interprétation de l'argument <code>locales</code>, voir la page {{jsxref("Intl","Intl","#L'identification_et_le_choix_de_la_locale")}}.</p>
- </dd>
- <dt><code>options</code>{{optional_inline}}</dt>
- <dd>
- <p>Paramètre optionnel. Un objet avec certaines ou toutes les propriétés suivantes :</p>
+    - `localeMatcher`
+      - : L'algorithme de correspondance à utiliser pour la locale. Les valeurs possibles sont `"lookup"` et `"best fit"` ; le défaut est `"best fit"`. Pour des informations sur cette option, voir la page {{jsxref("Intl","Intl","##Choix_de_la_locale")}}.
+    - `type`
 
- <dl>
-  <dt><code>localeMatcher</code></dt>
-  <dd>L'algorithme de correspondance à utiliser pour la locale. Les valeurs possibles sont <code>"lookup"</code> et <code>"best fit"</code> ; le défaut est <code>"best fit"</code>. Pour des informations sur cette option, voir la page {{jsxref("Intl","Intl","##Choix_de_la_locale")}}.</dd>
-  <dt><code>type</code></dt>
-  <dd>Le format de sortie pour le message. Les valeurs possibles sont :
-  <ul>
-   <li><code>"conjunction"</code> : qui concaténera les éléments de la liste avec des <em>et</em>. Cela produira par exemple, en anglais : <code>A, B, and C</code></li>
-   <li><code>"disjunction"</code> : qui concaténera les éléments de la liste avec des <em>ou</em>. Cela produira par exemple, en anglais : <code>A, B, or C</code></li>
-   <li><code>"unit"</code> : qui permet de gérer des listes de valeurs avec des unités. Cela produira par exemple <code>5 livres, 12 onces</code></li>
-  </ul>
-  </dd>
-  <dt><code>style</code></dt>
-  <dd>Le niveau de concision/longueur du message obtenu. Les valeurs possibles sont :
-  <ul>
-   <li><code>"long"</code> : par exemple <code>A, B, and C</code></li>
-   <li><code>"narrow"</code> : cette valeur permet uniquement d'utiliser le type <code>unit</code> et affichera un message concis : par exemple <code>A, B, C</code></li>
-   <li><code>"short"</code> : par exemple <code>A, B, C</code></li>
-  </ul>
-  </dd>
- </dl>
- </dd>
-</dl>
+      - : Le format de sortie pour le message. Les valeurs possibles sont :
 
-<h2 id="Description">Description</h2>
+        - `"conjunction"` : qui concaténera les éléments de la liste avec des _et_. Cela produira par exemple, en anglais : `A, B, and C`
+        - `"disjunction"` : qui concaténera les éléments de la liste avec des _ou_. Cela produira par exemple, en anglais : `A, B, or C`
+        - `"unit"` : qui permet de gérer des listes de valeurs avec des unités. Cela produira par exemple `5 livres, 12 onces`
 
-<h3 id="Propriétés">Propriétés</h3>
+    - `style`
 
-<dl>
- <dt>{{jsxref("ListFormat.prototype", "Intl.ListFormat.prototype")}}</dt>
- <dd>Cette propriété permet d'ajouter des propriétés à l'ensemble des objets de ce type.</dd>
-</dl>
+      - : Le niveau de concision/longueur du message obtenu. Les valeurs possibles sont :
 
-<h3 id="Méthodes">Méthodes</h3>
+        - `"long"` : par exemple `A, B, and C`
+        - `"narrow"` : cette valeur permet uniquement d'utiliser le type `unit` et affichera un message concis : par exemple `A, B, C`
+        - `"short"` : par exemple `A, B, C`
 
-<dl>
- <dt>{{jsxref("ListFormat.supportedLocalesOf", "Intl.ListFormat.supportedLocalesOf()")}}</dt>
- <dd>Cette méthode renvoie un tableau des locales prises en charge par le moteur pour le formatage des heures sans qu'il y ait besoin d'utiliser la locale de l'environnement d'exécution.</dd>
-</dl>
+## Description
 
-<h2 id="Instances_de_Intl.ListFormat">Instances de <code>Intl.ListFormat</code></h2>
+### Propriétés
 
-<p>Toutes les instances de <code>Intl.ListFormat</code> héritent de <code>Intl.ListFormat.prototype</code>.</p>
+- {{jsxref("ListFormat.prototype", "Intl.ListFormat.prototype")}}
+  - : Cette propriété permet d'ajouter des propriétés à l'ensemble des objets de ce type.
 
-<h3 id="Propriétés_2">Propriétés</h3>
+### Méthodes
 
-<dl>
- <dt><code>Intl.ListFormat.prototype.constructor</code></dt>
- <dd>Définit la fonction qui crée le prototype d'un objet.</dd>
-</dl>
+- {{jsxref("ListFormat.supportedLocalesOf", "Intl.ListFormat.supportedLocalesOf()")}}
+  - : Cette méthode renvoie un tableau des locales prises en charge par le moteur pour le formatage des heures sans qu'il y ait besoin d'utiliser la locale de l'environnement d'exécution.
 
-<h3 id="Méthodes_2">Méthodes</h3>
+## Instances de `Intl.ListFormat`
 
-<dl>
- <dt>{{jsxref("ListFormat.prototype.format","Intl.ListFormat.prototype.format()")}}</dt>
- <dd>Renvoie une chaîne de caractères mise en forme selon la langue voulue et qui représente les éléments de la liste.</dd>
-</dl>
+Toutes les instances de `Intl.ListFormat` héritent de `Intl.ListFormat.prototype`.
 
-<h2 id="Exemples">Exemples</h2>
+### Propriétés
 
-<h3 id="Utiliser_format()">Utiliser <code>format()</code></h3>
+- `Intl.ListFormat.prototype.constructor`
+  - : Définit la fonction qui crée le prototype d'un objet.
 
-<p>Dans l'exemple qui suit, on voit comment créer un formateur de liste pour l'anglais.</p>
+### Méthodes
 
-<pre class="brush: js">const list = ['Motorcycle', 'Bus', 'Car'];
+- {{jsxref("ListFormat.prototype.format","Intl.ListFormat.prototype.format()")}}
+  - : Renvoie une chaîne de caractères mise en forme selon la langue voulue et qui représente les éléments de la liste.
+
+## Exemples
+
+### Utiliser `format()`
+
+Dans l'exemple qui suit, on voit comment créer un formateur de liste pour l'anglais.
+
+```js
+const list = ['Motorcycle', 'Bus', 'Car'];
 
  console.log(new Intl.ListFormat('en-GB', { style: 'long', type: 'conjunction' }).format(list));
-// &gt; Motorcycle, Bus and Car
+// > Motorcycle, Bus and Car
 
  console.log(new Intl.ListFormat('en-GB', { style: 'short', type: 'disjunction' }).format(list));
-// &gt; Motorcycle, Bus or Car
+// > Motorcycle, Bus or Car
 
  console.log(new Intl.ListFormat('en-GB', { style: 'narrow', type: 'unit' }).format(list));
-// &gt; Motorcycle Bus Car
-</pre>
+// > Motorcycle Bus Car
+```
 
-<h3 id="Utiliser_formatToParts()">Utiliser <code>formatToParts()</code></h3>
+### Utiliser `formatToParts()`
 
-<p>Dans l'exemple qui suit, on voit comment créer un formateur de liste, renvoyant les fragments, pour l'anglais</p>
+Dans l'exemple qui suit, on voit comment créer un formateur de liste, renvoyant les fragments, pour l'anglais
 
-<pre class="brush: js">const list = ['Motorcycle', 'Bus', 'Car'];
+```js
+const list = ['Motorcycle', 'Bus', 'Car'];
 console.log(new Intl.ListFormat('en-GB', { style: 'long', type: 'conjunction' }).formatToParts(list));
 
-// &gt; [ { "type": "element", "value": "Motorcycle" },
+// > [ { "type": "element", "value": "Motorcycle" },
        { "type": "literal", "value": ", " },
        { "type": "element", "value": "Bus" },
        { "type": "literal", "value": ", and " },
        { "type": "element", "value": "Car" } ];
-</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><a href="https://tc39.github.io/proposal-intl-list-format/#listformat-objects">Proposition pour <code>Intl.ListFormat</code></a></td>
-   <td>Proposition de niveau 3</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Intl.ListFormat")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<div>{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/Intl', 'Voir_aussi')}}</div>
+```
+
+## Spécifications
+
+| Spécification                                                                                              | État                    | Commentaires |
+| ---------------------------------------------------------------------------------------------------------- | ----------------------- | ------------ |
+| [Proposition pour `Intl.ListFormat`](https://tc39.github.io/proposal-intl-list-format/#listformat-objects) | Proposition de niveau 3 |              |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Intl.ListFormat")}}
+
+## Voir aussi
+
+{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/Intl', 'Voir_aussi')}}
diff --git a/files/fr/web/javascript/reference/global_objects/intl/listformat/resolvedoptions/index.md b/files/fr/web/javascript/reference/global_objects/intl/listformat/resolvedoptions/index.md
index c486feed3d..8262926d17 100644
--- a/files/fr/web/javascript/reference/global_objects/intl/listformat/resolvedoptions/index.md
+++ b/files/fr/web/javascript/reference/global_objects/intl/listformat/resolvedoptions/index.md
@@ -12,70 +12,54 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Intl/ListFormat/resolvedOptions
 original_slug: Web/JavaScript/Reference/Objets_globaux/Intl/ListFormat/resolvedOptions
 ---
-<div>{{JSRef}}{{Draft}}</div>
+{{JSRef}}{{Draft}}
 
-<p>La méthode  <code><strong>Intl.ListFormat.prototype.resolvedOptions()</strong></code> renvoie un nouvel objet dont les propriétés reflètent les options de locale et de style calculées à l'initialisation de l'objet {{jsxref("ListFormat")}}.</p>
+La méthode  **`Intl.ListFormat.prototype.resolvedOptions()`** renvoie un nouvel objet dont les propriétés reflètent les options de locale et de style calculées à l'initialisation de l'objet {{jsxref("ListFormat")}}.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>listFormat</var>.resolvedOptions()</pre>
+    listFormat.resolvedOptions()
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un nouvel objet dont les propriétés reflètent les options de locale et de style calculées lors de l'initialisation de l'objet {{jsxref("ListFormat")}}.</p>
+Un nouvel objet dont les propriétés reflètent les options de locale et de style calculées lors de l'initialisation de l'objet {{jsxref("ListFormat")}}.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>L'objet renvoyé par <code>resolvedOptions()</code> possède les propriétés suivantes :</p>
+L'objet renvoyé par `resolvedOptions()` possède les propriétés suivantes :
 
-<dl>
- <dt><code>locale</code></dt>
- <dd>La balise de langue BCP 47 qui est réellement utilisée. Si des extensions Unicode étaient fournies avec la balise d'origine et sont supportées pour la locale utilisée, les paires de clés-valeurs seront incluses dans <code>locale</code>.</dd>
- <dt><code>style</code></dt>
- <dd>La valeur fournie au constructeur via l'argument <code>options</code> ou la valeur utilisée par défaut (<code>"long"</code>). Cette propriété peut valoir <code>"long"</code>, <code>"short"</code> ou <code>"narrow"</code>.</dd>
- <dt><code>type</code></dt>
- <dd>La valeur fournie au constructeur via l'argument <code>options</code> ou la valeur par défaut (<code>"conjunction"</code>). Cette propriété peut valoir <code>"conjunction"</code>, <code>"disjunction"</code> ou <code>"unit"</code>.</dd>
-</dl>
+- `locale`
+  - : La balise de langue BCP 47 qui est réellement utilisée. Si des extensions Unicode étaient fournies avec la balise d'origine et sont supportées pour la locale utilisée, les paires de clés-valeurs seront incluses dans `locale`.
+- `style`
+  - : La valeur fournie au constructeur via l'argument `options` ou la valeur utilisée par défaut (`"long"`). Cette propriété peut valoir `"long"`, `"short"` ou `"narrow"`.
+- `type`
+  - : La valeur fournie au constructeur via l'argument `options` ou la valeur par défaut (`"conjunction"`). Cette propriété peut valoir `"conjunction"`, `"disjunction"` ou `"unit"`.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<pre class="brush: js">const deListFormatter = new Intl.ListFormat("de-DE", { style: "short" });
+```js
+const deListFormatter = new Intl.ListFormat("de-DE", { style: "short" });
 
 const usedOptions = de.resolvedOptions();
 console.log(usedOptions.locale); // "de-DE"
 console.log(usedOptions.style);  // "short"
 console.log(usedOptions.type);   // "conjunction" (la valeur par défaut)
-</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><a href="https://tc39.github.io/proposal-intl-list-format/#sec-Intl.ListFormat.prototype.resolvedOptions">Proposition pour <code>Intl.ListFormat.prototype.resolvedOptions()</code></a></td>
-   <td>Proposition de niveau 3</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Intl.ListFormat.resolvedOptions")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("ListFormat", "Intl.ListFormat")}}</li>
- <li>{{jsxref("NumberFormat.prototype.resolvedOptions()", "Intl.NumberFormat.prototype.resolvedOptions()")}}</li>
- <li>{{jsxref("Collator.prototype.resolvedOptions()", "Intl.Collator.prototype.resolvedOptions()")}}</li>
- <li>{{jsxref("DateTimeFormat.prototype.resolvedOptions()", "Intl.DateTimeFormat.prototype.resolvedOptions()")}}</li>
- <li>{{jsxref("PluralRules.prototype.resolvedOptions()", "Intl.PluralRules.prototype.resolvedOptions()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                                                                     | État                    | Commentaires |
+| ----------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------- | ------------ |
+| [Proposition pour `Intl.ListFormat.prototype.resolvedOptions()`](https://tc39.github.io/proposal-intl-list-format/#sec-Intl.ListFormat.prototype.resolvedOptions) | Proposition de niveau 3 |              |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Intl.ListFormat.resolvedOptions")}}
+
+## Voir aussi
+
+- {{jsxref("ListFormat", "Intl.ListFormat")}}
+- {{jsxref("NumberFormat.prototype.resolvedOptions()", "Intl.NumberFormat.prototype.resolvedOptions()")}}
+- {{jsxref("Collator.prototype.resolvedOptions()", "Intl.Collator.prototype.resolvedOptions()")}}
+- {{jsxref("DateTimeFormat.prototype.resolvedOptions()", "Intl.DateTimeFormat.prototype.resolvedOptions()")}}
+- {{jsxref("PluralRules.prototype.resolvedOptions()", "Intl.PluralRules.prototype.resolvedOptions()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/intl/listformat/supportedlocalesof/index.md b/files/fr/web/javascript/reference/global_objects/intl/listformat/supportedlocalesof/index.md
index b5f54c9535..ae6a5c4f24 100644
--- a/files/fr/web/javascript/reference/global_objects/intl/listformat/supportedlocalesof/index.md
+++ b/files/fr/web/javascript/reference/global_objects/intl/listformat/supportedlocalesof/index.md
@@ -11,77 +11,56 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Intl/ListFormat/supportedLocalesOf
 original_slug: Web/JavaScript/Reference/Objets_globaux/Intl/ListFormat/supportedLocalesOf
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>The <strong><code>Intl.ListFormat.supportedLocalesOf()</code></strong> renvoie, parmi les locales fournies, un tableau contenant les locales supportées pour le formatage des listes et qui ne nécessitent pas d'utiliser la locale par défaut de l'environnement.</p>
+The **`Intl.ListFormat.supportedLocalesOf()`** renvoie, parmi les locales fournies, un tableau contenant les locales supportées pour le formatage des listes et qui ne nécessitent pas d'utiliser la locale par défaut de l'environnement.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre>Intl.ListFormat.supportedLocalesOf(<var>locales</var>[, <var>options</var>])</pre>
+    Intl.ListFormat.supportedLocalesOf(locales[, options])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>locales</code></dt>
- <dd>Une chaîne de caractères qui est une balise de langue BCP 47 ou bien un tableau de telles chaînes. Pour plus d'informations concernant la forme générale de l'argument <code>locales</code>, voir la page {{jsxref("Objets_globaux/Intl", "Intl", "#L'identification_et_le_choix_de_la_locale")}}.</dd>
- <dt><code>options</code>{{optional_inline}}</dt>
- <dd>
- <p>Paramètre facultatif. Un objet qui peut posséder les propriétés suivantes :</p>
+- `locales`
+  - : Une chaîne de caractères qui est une balise de langue BCP 47 ou bien un tableau de telles chaînes. Pour plus d'informations concernant la forme générale de l'argument `locales`, voir la page {{jsxref("Objets_globaux/Intl", "Intl", "#L'identification_et_le_choix_de_la_locale")}}.
+- `options`{{optional_inline}}
 
- <dl>
-  <dt><code>localeMatcher</code></dt>
-  <dd>
-  <p>L'algorithme utilisé pour la correspondance entre chaînes de caractères. Les valeurs possibles sont <code>"lookup"</code> et <code>"best fit"</code>. La valeur par défaut est <code>"best fit"</code>. Pour plus d'informations, voir la page {{jsxref("Objets_globaux/Intl", "Intl", "#Choix_de_la_locale")}}.</p>
-  </dd>
- </dl>
- </dd>
-</dl>
+  - : Paramètre facultatif. Un objet qui peut posséder les propriétés suivantes :
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+    - `localeMatcher`
+      - : L'algorithme utilisé pour la correspondance entre chaînes de caractères. Les valeurs possibles sont `"lookup"` et `"best fit"`. La valeur par défaut est `"best fit"`. Pour plus d'informations, voir la page {{jsxref("Objets_globaux/Intl", "Intl", "#Choix_de_la_locale")}}.
 
-<p>Un tableau de chaînes de caractères qui représente un sous-ensemble des balises de langues qui sont prises en charge pour le formatage des listes sans qu'il faille utiliser la locale par défaut de l'environnement d'exécution.</p>
+### Valeur de retour
 
-<h2 id="Description">Description</h2>
+Un tableau de chaînes de caractères qui représente un sous-ensemble des balises de langues qui sont prises en charge pour le formatage des listes sans qu'il faille utiliser la locale par défaut de l'environnement d'exécution.
 
-<p>Cette méthode renvoie un tableau qui est un sous-ensemble des balises de locales fournies avec l'argument <code>locales</code>. Les balises renvoyées sont celles supportées par l'environnement navigateur en termes de formatage des listes et qui ne nécessitent pas d'utiliser la locale par défaut.</p>
+## Description
 
-<h2 id="Exemples">Exemples</h2>
+Cette méthode renvoie un tableau qui est un sous-ensemble des balises de locales fournies avec l'argument `locales`. Les balises renvoyées sont celles supportées par l'environnement navigateur en termes de formatage des listes et qui ne nécessitent pas d'utiliser la locale par défaut.
 
-<h3 id="Utiliser_supportedLocalesOf">Utiliser <code>supportedLocalesOf</code></h3>
+## Exemples
 
-<p>Si on dispose d'un environnement (un navigateur par exemple) qui supporte le formatage des listes dans les locales indonésienne, allemande mais pas balinaise,  <code>supportedLocalesOf</code> renvoie les balises pour l'indonésien et l'allemand quand bien même le formatage des listes pinyin n'est pas utilisée avec l'indonésien et qu'il n'existe pas une version spécifique de l'allemand pour l'Indonésie. On illustre ici l'algorithme <code>"lookup"</code>. SI on utilisait <code>"best fit"</code> pour trouver les locales correspondantes, on aurait pu avoir une balise supplémentaire pour le balinais en plus car la plupart des balinais comprennent l'indonésien.</p>
+### Utiliser `supportedLocalesOf`
 
-<pre class="brush: js">const locales = ['ban', 'id-u-co-pinyin', 'de-ID'];
+Si on dispose d'un environnement (un navigateur par exemple) qui supporte le formatage des listes dans les locales indonésienne, allemande mais pas balinaise,  `supportedLocalesOf` renvoie les balises pour l'indonésien et l'allemand quand bien même le formatage des listes pinyin n'est pas utilisée avec l'indonésien et qu'il n'existe pas une version spécifique de l'allemand pour l'Indonésie. On illustre ici l'algorithme `"lookup"`. SI on utilisait `"best fit"` pour trouver les locales correspondantes, on aurait pu avoir une balise supplémentaire pour le balinais en plus car la plupart des balinais comprennent l'indonésien.
+
+```js
+const locales = ['ban', 'id-u-co-pinyin', 'de-ID'];
 const options = { localeMatcher: 'lookup' };
 console.log(Intl.ListFormat.supportedLocalesOf(locales, options).join(', '));
 // → "id-u-co-pinyin, de-ID"
-</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><a href="https://tc39.github.io/proposal-intl-list-format/#sec-Intl.ListFormat.supportedLocalesOf">Proposition pour <code>Intl.ListFormat.supportedLocalesOf</code></a></td>
-   <td>Proposition de niveau 3</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Intl.ListFormat.supportedLocalesOf")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("ListFormat", "Intl.ListFormat")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                                                     | État                    | Commentaires |
+| ------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------- | ------------ |
+| [Proposition pour `Intl.ListFormat.supportedLocalesOf`](https://tc39.github.io/proposal-intl-list-format/#sec-Intl.ListFormat.supportedLocalesOf) | Proposition de niveau 3 |              |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Intl.ListFormat.supportedLocalesOf")}}
+
+## Voir aussi
+
+- {{jsxref("ListFormat", "Intl.ListFormat")}}
diff --git a/files/fr/web/javascript/reference/global_objects/intl/locale/basename/index.md b/files/fr/web/javascript/reference/global_objects/intl/locale/basename/index.md
index a13032aa1d..cbbb4f6856 100644
--- a/files/fr/web/javascript/reference/global_objects/intl/locale/basename/index.md
+++ b/files/fr/web/javascript/reference/global_objects/intl/locale/basename/index.md
@@ -10,65 +10,58 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Intl/Locale/baseName
 original_slug: Web/JavaScript/Reference/Objets_globaux/Intl/Locale/baseName
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La propriété <strong><code>Intl.Locale.prototype.baseName</code></strong> renvoie un extrait de la chaîne de caractères représentant l'objet <code>Locale</code>. Cet extrait contient les informations essentielles à propos de l'objet <code>Locale</code>.</p>
+La propriété **`Intl.Locale.prototype.baseName`** renvoie un extrait de la chaîne de caractères représentant l'objet `Locale`. Cet extrait contient les informations essentielles à propos de l'objet `Locale`.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Un objet <code>Intl.Locale</code> représente une locale ainsi que des options qui lui sont associées. La propriété <code>baseName</code> renvoie des informations essentielles quant à la locale sous la forme d'une chaîne de caractères. Cette chaîne est un extrait de la représentation textuelle complète de l'objet <code>Locale</code>. Cet extrait contient notamment la langue, le script utilisé ainsi que la région (s'ils sont disponibles).</p>
+Un objet `Intl.Locale` représente une locale ainsi que des options qui lui sont associées. La propriété `baseName` renvoie des informations essentielles quant à la locale sous la forme d'une chaîne de caractères. Cette chaîne est un extrait de la représentation textuelle complète de l'objet `Locale`. Cet extrait contient notamment la langue, le script utilisé ainsi que la région (s'ils sont disponibles).
 
-<p>Si on utilise <a href="https://www.unicode.org/reports/tr35/#Identifiers">la grammaire Unicode</a>, <code>baseName</code> renvoie la sous-séquence <code>language ["-" script] ["-" region] *("-" variant)</code>.</p>
+Si on utilise [la grammaire Unicode](https://www.unicode.org/reports/tr35/#Identifiers), `baseName` renvoie la sous-séquence `language ["-" script] ["-" region] *("-" variant)`.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Exemple_simple">Exemple simple</h3>
+### Exemple simple
 
-<pre class="brush: js">let myLoc = new Intl.Locale("fr-Latn-CA"); // Sets locale to Candanian French
+```js
+let myLoc = new Intl.Locale("fr-Latn-CA"); // Sets locale to Candanian French
 console.log(myLoc.toString()); // Prints out "fr-Latn-CA-u-ca-gregory"
-console.log(myLoc.baseName); // Prints out "fr-Latn-CA"</pre>
+console.log(myLoc.baseName); // Prints out "fr-Latn-CA"
+```
 
-<h3 id="Exemple_avec_certaines_options">Exemple avec certaines options</h3>
+### Exemple avec certaines options
 
-<pre class="brush: js">// Sets language to Japanese, region to Japan,
+```js
+// Sets language to Japanese, region to Japan,
 
 // calendar to Gregorian, hour cycle to 24 hours
 let japan = new Intl.Locale("ja-JP-u-ca-gregory-hc-24");
 console.log(japan.toString()); // Prints out "ja-JP-u-ca-gregory-hc-h24"
-console.log(japan.baseName); // Prints out "ja-JP"</pre>
+console.log(japan.baseName); // Prints out "ja-JP"
+```
 
-<h3 id="Exemple_avec_options_qui_surchargent">Exemple avec options qui surchargent</h3>
+### Exemple avec options qui surchargent
 
-<pre class="brush: js">// Input string indicates language as Dutch and region as Belgium,
+```js
+// Input string indicates language as Dutch and region as Belgium,
 
 // but options object overrides the region and sets it to the Netherlands
 let dutch = new Intl.Locale("nl-Latn-BE", {region: "NL"});
 
-console.log(dutch.baseName); // Prints out "nl-Latn-NL"</pre>
+console.log(dutch.baseName); // Prints out "nl-Latn-NL"
+```
 
-<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><a href="https://tc39.github.io/proposal-intl-locale/#sec-Intl.Locale.prototype.baseName">Proposition pour <code>Intl.Locale.prototype.baseName</code></a></td>
-   <td>Proposition de niveau 3</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
+| Spécification                                                                                                                        | État                    | Commentaires |
+| ------------------------------------------------------------------------------------------------------------------------------------ | ----------------------- | ------------ |
+| [Proposition pour `Intl.Locale.prototype.baseName`](https://tc39.github.io/proposal-intl-locale/#sec-Intl.Locale.prototype.baseName) | Proposition de niveau 3 |              |
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<div>{{Compat("javascript.builtins.Intl.Locale.baseName")}}</div>
+{{Compat("javascript.builtins.Intl.Locale.baseName")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("Locale", "Intl.Locale")}}</li>
-</ul>
+- {{jsxref("Locale", "Intl.Locale")}}
diff --git a/files/fr/web/javascript/reference/global_objects/intl/locale/calendar/index.md b/files/fr/web/javascript/reference/global_objects/intl/locale/calendar/index.md
index a27a8efbb5..e9d990d117 100644
--- a/files/fr/web/javascript/reference/global_objects/intl/locale/calendar/index.md
+++ b/files/fr/web/javascript/reference/global_objects/intl/locale/calendar/index.md
@@ -11,147 +11,159 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Intl/Locale/calendar
 original_slug: Web/JavaScript/Reference/Objets_globaux/Intl/Locale/calendar
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La propriété <strong><code>Intl.Locale.prototype.calendar</code></strong> est une propriété (via un accesseur) qui renvoie le type de calendrier utilisé par l'instance de <code>Locale</code>.</p>
+La propriété **`Intl.Locale.prototype.calendar`** est une propriété (via un accesseur) qui renvoie le type de calendrier utilisé par l'instance de `Locale`.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La propriété <code>calendar</code> renvoie la partie de la locale qui indique le calendrier utilisé. Bien que la plupart des régions utilise le calendrier grégorien, il existe différents calendriers utilisés. Le tableau qui suit indique les clés Unicode pour les différents calendriers ainsi qu'une description.</p>
+La propriété `calendar` renvoie la partie de la locale qui indique le calendrier utilisé. Bien que la plupart des régions utilise le calendrier grégorien, il existe différents calendriers utilisés. Le tableau qui suit indique les clés Unicode pour les différents calendriers ainsi qu'une description.
 
 <table class="standard-table">
- <caption>Clés Unicode pour les calendriers</caption>
- <thead>
-  <tr>
-   <th scope="col">Clé Unicode</th>
-   <th scope="col">Description</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td><code>buddhist</code></td>
-   <td>Calendrier bouddhiste</td>
-  </tr>
-  <tr>
-   <td><code>chinese</code></td>
-   <td>Calendrier chinois traditionnel</td>
-  </tr>
-  <tr>
-   <td><code>coptic</code></td>
-   <td>Calendrier copte</td>
-  </tr>
-  <tr>
-   <td><code>dangi</code></td>
-   <td>Calendrier coréen traditionnel</td>
-  </tr>
-  <tr>
-   <td><code>ethioaa</code></td>
-   <td>Calendrier éthiopique, Amete Alem (an 0 situé environ à  5493 ans avant notre ère)</td>
-  </tr>
-  <tr>
-   <td><code>ethiopic</code></td>
-   <td>Calendrier éthiopique, Amete Mihret (an 0 situé environ à 8 ans de notre ère)</td>
-  </tr>
-  <tr>
-   <td><code>gregory</code></td>
-   <td>Calendrier grégorien</td>
-  </tr>
-  <tr>
-   <td><code>hebrew</code></td>
-   <td>Calendrier traditionnel hébreux</td>
-  </tr>
-  <tr>
-   <td><code>indian</code></td>
-   <td>Calendrier indien</td>
-  </tr>
-  <tr>
-   <td><code>islamic</code></td>
-   <td>Calendrier islamique</td>
-  </tr>
-  <tr>
-   <td><code>islamic-umalqura</code></td>
-   <td>Calendrier islamique, Umm al-Qura</td>
-  </tr>
-  <tr>
-   <td><code>islamic-tbla</code></td>
-   <td>Calendrier islamique tabulaire (années intercalaires [2,5,7,10,13,16,18,21,24,26,29] - origine des temps astronomique)</td>
-  </tr>
-  <tr>
-   <td><code>islamic-civil</code></td>
-   <td>Calendrier islamique tabulaire (années intercalaires [2,5,7,10,13,16,18,21,24,26,29] - origine des temps civile)</td>
-  </tr>
-  <tr>
-   <td><code>islamic-rgsa</code></td>
-   <td>Calendrier islamique vu de l'Arabie saoudite</td>
-  </tr>
-  <tr>
-   <td><code>iso8601</code></td>
-   <td>Calendrier ISO (calendrier grégorien utilisant la numérotation des semaines ISO 8601)</td>
-  </tr>
-  <tr>
-   <td><code>japanese</code></td>
-   <td>Calendrier japonais impérial</td>
-  </tr>
-  <tr>
-   <td><code>persian</code></td>
-   <td>Calendrier perse</td>
-  </tr>
-  <tr>
-   <td><code>roc</code></td>
-   <td>Calendrier de la République de Chine</td>
-  </tr>
-  <tr>
-   <td>
-    <div class="warning"><p><strong>Attention :</strong> La clé  <code>islamicc</code> est désormais dépréciée et il faut utiliser <code>islamic-civil</code> à la place.</p></div>
-
-    <p><code>islamicc</code></p>
-   </td>
-   <td>Calendrier arabe civil (algorithmique)</td>
-  </tr>
- </tbody>
+  <caption>
+    Clés Unicode pour les calendriers
+  </caption>
+  <thead>
+    <tr>
+      <th scope="col">Clé Unicode</th>
+      <th scope="col">Description</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td><code>buddhist</code></td>
+      <td>Calendrier bouddhiste</td>
+    </tr>
+    <tr>
+      <td><code>chinese</code></td>
+      <td>Calendrier chinois traditionnel</td>
+    </tr>
+    <tr>
+      <td><code>coptic</code></td>
+      <td>Calendrier copte</td>
+    </tr>
+    <tr>
+      <td><code>dangi</code></td>
+      <td>Calendrier coréen traditionnel</td>
+    </tr>
+    <tr>
+      <td><code>ethioaa</code></td>
+      <td>
+        Calendrier éthiopique, Amete Alem (an 0 situé environ à  5493 ans avant
+        notre ère)
+      </td>
+    </tr>
+    <tr>
+      <td><code>ethiopic</code></td>
+      <td>
+        Calendrier éthiopique, Amete Mihret (an 0 situé environ à 8 ans de notre
+        ère)
+      </td>
+    </tr>
+    <tr>
+      <td><code>gregory</code></td>
+      <td>Calendrier grégorien</td>
+    </tr>
+    <tr>
+      <td><code>hebrew</code></td>
+      <td>Calendrier traditionnel hébreux</td>
+    </tr>
+    <tr>
+      <td><code>indian</code></td>
+      <td>Calendrier indien</td>
+    </tr>
+    <tr>
+      <td><code>islamic</code></td>
+      <td>Calendrier islamique</td>
+    </tr>
+    <tr>
+      <td><code>islamic-umalqura</code></td>
+      <td>Calendrier islamique, Umm al-Qura</td>
+    </tr>
+    <tr>
+      <td><code>islamic-tbla</code></td>
+      <td>
+        Calendrier islamique tabulaire (années intercalaires
+        [2,5,7,10,13,16,18,21,24,26,29] - origine des temps astronomique)
+      </td>
+    </tr>
+    <tr>
+      <td><code>islamic-civil</code></td>
+      <td>
+        Calendrier islamique tabulaire (années intercalaires
+        [2,5,7,10,13,16,18,21,24,26,29] - origine des temps civile)
+      </td>
+    </tr>
+    <tr>
+      <td><code>islamic-rgsa</code></td>
+      <td>Calendrier islamique vu de l'Arabie saoudite</td>
+    </tr>
+    <tr>
+      <td><code>iso8601</code></td>
+      <td>
+        Calendrier ISO (calendrier grégorien utilisant la numérotation des
+        semaines ISO 8601)
+      </td>
+    </tr>
+    <tr>
+      <td><code>japanese</code></td>
+      <td>Calendrier japonais impérial</td>
+    </tr>
+    <tr>
+      <td><code>persian</code></td>
+      <td>Calendrier perse</td>
+    </tr>
+    <tr>
+      <td><code>roc</code></td>
+      <td>Calendrier de la République de Chine</td>
+    </tr>
+    <tr>
+      <td>
+        <div class="warning">
+          <p>
+            <strong>Attention :</strong> La clé  <code>islamicc</code> est
+            désormais dépréciée et il faut utiliser <code>islamic-civil</code> à
+            la place.
+          </p>
+        </div>
+        <p><code>islamicc</code></p>
+      </td>
+      <td>Calendrier arabe civil (algorithmique)</td>
+    </tr>
+  </tbody>
 </table>
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Indiquer_le_calendrier_via_la_chaîne_de_définition_de_la_locale">Indiquer le calendrier via la chaîne de définition de la locale</h3>
+### Indiquer le calendrier via la chaîne de définition de la locale
 
-<p>Les calendriers font partie des « clés d'extension ». Ces clés permettent d'ajouter des informations supplémentaires aux locales et sont ajoutées via l'extension <code>-u</code>. Ainsi, on peut indiquer le calendrier utilisé via la chaîne de locale passée comme argument au constructeur {{jsxref("Locale", "Intl.Locale")}}. Pour ce faire, on ajoutera d'abord <code>-u</code> à la chaîne « courte » de la locale puis <code>-ca</code> afin d'indiquer qu'on précise le calendrier et enfin la chaîne représentant la clé du calendrier.</p>
+Les calendriers font partie des « clés d'extension ». Ces clés permettent d'ajouter des informations supplémentaires aux locales et sont ajoutées via l'extension `-u`. Ainsi, on peut indiquer le calendrier utilisé via la chaîne de locale passée comme argument au constructeur {{jsxref("Locale", "Intl.Locale")}}. Pour ce faire, on ajoutera d'abord `-u` à la chaîne « courte » de la locale puis `-ca` afin d'indiquer qu'on précise le calendrier et enfin la chaîne représentant la clé du calendrier.
 
-<pre class="brush: js">let frBuddhist = new Intl.Locale("fr-FR-u-ca-buddhist");
-console.log(frBuddhist.calendar); // affiche "buddhist" dans la console</pre>
+```js
+let frBuddhist = new Intl.Locale("fr-FR-u-ca-buddhist");
+console.log(frBuddhist.calendar); // affiche "buddhist" dans la console
+```
 
-<h3 id="Spécifier_un_calendrier_grâce_à_un_objet_de_configuration">Spécifier un calendrier grâce à un objet de configuration</h3>
+### Spécifier un calendrier grâce à un objet de configuration
 
-<p>Le constructeur {{jsxref("Locale", "Intl.Locale")}} peut utiliser un argument optionnel qui est un objet permettant de configurer la locale via différentes extensions dont les calendriers. En utilisant la propriété <code>calendar</code> de cet objet, on définit le calendrier qui sera utilisé :</p>
+Le constructeur {{jsxref("Locale", "Intl.Locale")}} peut utiliser un argument optionnel qui est un objet permettant de configurer la locale via différentes extensions dont les calendriers. En utilisant la propriété `calendar` de cet objet, on définit le calendrier qui sera utilisé :
 
-<pre class="brush: js">let frBuddhist = new Intl.Locale("fr-FR", {calendar: "buddhist"});
+```js
+let frBuddhist = new Intl.Locale("fr-FR", {calendar: "buddhist"});
 console.log(frBuddhist.calendar); // affiche "buddhist" dans la console
-</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><a href="https://tc39.github.io/proposal-intl-locale/#sec-Intl.Locale.prototype.calendar">Proposition pour <code>Intl.Locale.prototype.calendar</code></a></td>
-   <td>Proposition de niveau 3</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
+| Spécification                                                                                                                        | État                    | Commentaires |
+| ------------------------------------------------------------------------------------------------------------------------------------ | ----------------------- | ------------ |
+| [Proposition pour `Intl.Locale.prototype.calendar`](https://tc39.github.io/proposal-intl-locale/#sec-Intl.Locale.prototype.calendar) | Proposition de niveau 3 |              |
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<div>{{Compat("javascript.builtins.Intl.Locale.calendar")}}</div>
+{{Compat("javascript.builtins.Intl.Locale.calendar")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("Locale", "Intl.Locale")}}</li>
- <li><a href="https://www.unicode.org/reports/tr35/#UnicodeCalendarIdentifier">Identifiants Unicode pour les calendriers</a></li>
-</ul>
+- {{jsxref("Locale", "Intl.Locale")}}
+- [Identifiants Unicode pour les calendriers](https://www.unicode.org/reports/tr35/#UnicodeCalendarIdentifier)
diff --git a/files/fr/web/javascript/reference/global_objects/intl/locale/casefirst/index.md b/files/fr/web/javascript/reference/global_objects/intl/locale/casefirst/index.md
index e271f2b621..b5e2d8d422 100644
--- a/files/fr/web/javascript/reference/global_objects/intl/locale/casefirst/index.md
+++ b/files/fr/web/javascript/reference/global_objects/intl/locale/casefirst/index.md
@@ -12,82 +12,55 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Intl/Locale/caseFirst
 original_slug: Web/JavaScript/Reference/Objets_globaux/Intl/Locale/caseFirst
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La propriété <strong><code>Intl.Locale.prototype.caseFirst</code></strong> est une propriété (via un accesseur) qui renvoie si la casse est prise en compte par la locale pour ses règles de collation (celles qui permettent d'ordonner des chaînes de caractères entre elles).</p>
+La propriété **`Intl.Locale.prototype.caseFirst`** est une propriété (via un accesseur) qui renvoie si la casse est prise en compte par la locale pour ses règles de collation (celles qui permettent d'ordonner des chaînes de caractères entre elles).
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Les règles de collation des locales sont utilisées afin de déterminer la façon dont les chaînes sont ordonnées pour cette locale. Certaines locales utilisent la casse (minuscule ou majuscule) dans ce processus de collation. Cette règle peut être exprimée via la propriété <code>caseFirst</code> d'une instance <code>Locale</code>.</p>
+Les règles de collation des locales sont utilisées afin de déterminer la façon dont les chaînes sont ordonnées pour cette locale. Certaines locales utilisent la casse (minuscule ou majuscule) dans ce processus de collation. Cette règle peut être exprimée via la propriété `caseFirst` d'une instance `Locale`.
 
-<p>Cette propriété peut avoir une des 3 valeurs suivantes :</p>
+Cette propriété peut avoir une des 3 valeurs suivantes :
 
-<table class="standard-table">
- <caption>Valeurs pour <code>caseFirst</code></caption>
- <thead>
-  <tr>
-   <th scope="col">Valeur</th>
-   <th scope="col">Description</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td><code>upper</code></td>
-   <td>Les majuscules devraient être triées avant les minuscules.</td>
-  </tr>
-  <tr>
-   <td><code>lower</code></td>
-   <td>Les minuscules devraient être triées avant les majuscules.</td>
-  </tr>
-  <tr>
-   <td><code>false</code></td>
-   <td>La casse n'a pas d'importance pour le tri des chaînes.</td>
-  </tr>
- </tbody>
-</table>
+| Valeur  | Description                                                |
+| ------- | ---------------------------------------------------------- |
+| `upper` | Les majuscules devraient être triées avant les minuscules. |
+| `lower` | Les minuscules devraient être triées avant les majuscules. |
+| `false` | La casse n'a pas d'importance pour le tri des chaînes.     |
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Définir_caseFirst_grâce_à_la_chaîne_de_description_de_la_locale">Définir <code>caseFirst</code> grâce à la chaîne de description de la locale</h3>
+### Définir `caseFirst` grâce à la chaîne de description de la locale
 
-<p>Le constructeur <a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Locale" title="The Intl.Locale constructor is a standard built-in property of the Intl object."><code>Intl.Locale</code></a> prend comme premier argument une chaîne de caractères qui décrit la locale. On peut allonger cette chaîne avec certaines valeurs afin de l'affiner.</p>
+Le constructeur [`Intl.Locale`](/fr/docs/Web/JavaScript/Reference/Objets_globaux/Locale "The Intl.Locale constructor is a standard built-in property of the Intl object.") prend comme premier argument une chaîne de caractères qui décrit la locale. On peut allonger cette chaîne avec certaines valeurs afin de l'affiner.
 
-<p>Dans la <a href="https://www.unicode.org/reports/tr35/">spécification Unicode sur les clés des extensions</a>, <code>caseFirst</code> correspond à la clé<code> kf</code>. <code>kf</code>. Il est possible d'ajouter des extensions à la chaîne identifiant la locale en la concaténant à <code>-u</code> puis en concaténant la clé de l'extension qu'on souhaite préciser (ici <code>-kf</code>) puis en ajoutant enfin la valeur pour cette extension (ici <code>upper</code>) :</p>
+Dans la [spécification Unicode sur les clés des extensions](https://www.unicode.org/reports/tr35/), `caseFirst` correspond à la clé` kf`. `kf`. Il est possible d'ajouter des extensions à la chaîne identifiant la locale en la concaténant à `-u` puis en concaténant la clé de l'extension qu'on souhaite préciser (ici `-kf`) puis en ajoutant enfin la valeur pour cette extension (ici `upper`) :
 
-<pre class="brush: js">let caseFirstStr = new Intl.Locale("fr-Latn-FR-u-kf-upper");
-console.log(caseFirstStr.caseFirst); // Prints "upper"</pre>
+```js
+let caseFirstStr = new Intl.Locale("fr-Latn-FR-u-kf-upper");
+console.log(caseFirstStr.caseFirst); // Prints "upper"
+```
 
-<h3 id="Définir_caseFirst_via_lobjet_de_configuration">Définir <code>caseFirst</code> via l'objet de configuration</h3>
+### Définir `caseFirst` via l'objet de configuration
 
-<p>Le constructeur <a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Locale" title="The Intl.Locale constructor is a standard built-in property of the Intl object."><code>Intl.Locale</code></a> permet d'utiliser un objet de configuration comme deuxième argument. Les propriétés de cet objet seront autant d'extensions Unicode à utiliser pour la locale. Ici, on peut utiliser un objet avec la propriété <code>caseFirst</code> pour indiquer l'impact de la casse sur la collation de cette locale :</p>
+Le constructeur [`Intl.Locale`](/fr/docs/Web/JavaScript/Reference/Objets_globaux/Locale "The Intl.Locale constructor is a standard built-in property of the Intl object.") permet d'utiliser un objet de configuration comme deuxième argument. Les propriétés de cet objet seront autant d'extensions Unicode à utiliser pour la locale. Ici, on peut utiliser un objet avec la propriété `caseFirst` pour indiquer l'impact de la casse sur la collation de cette locale :
 
-<pre class="brush: js">let caseFirstObj= new Intl.Locale("en-Latn-US", {caseFirst: "lower"});
-console.log(us12hour.caseFirst); // affichera "lower" dans la console.</pre>
+```js
+let caseFirstObj= new Intl.Locale("en-Latn-US", {caseFirst: "lower"});
+console.log(us12hour.caseFirst); // affichera "lower" dans la console.
+```
 
-<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><a href="https://tc39.github.io/proposal-intl-locale/#sec-Intl.Locale.prototype.caseFirst">Proposition pour <code>Intl.Locale</code></a></td>
-   <td>Proposition de niveau 3</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
+| Spécification                                                                                                      | État                    | Commentaires |
+| ------------------------------------------------------------------------------------------------------------------ | ----------------------- | ------------ |
+| [Proposition pour `Intl.Locale`](https://tc39.github.io/proposal-intl-locale/#sec-Intl.Locale.prototype.caseFirst) | Proposition de niveau 3 |              |
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<div>{{Compat("javascript.builtins.Intl.Locale.caseFirst")}}</div>
+{{Compat("javascript.builtins.Intl.Locale.caseFirst")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("Locale", "Intl.Locale")}}</li>
- <li><a href="https://github.com/unicode-org/cldr/blob/master/common/bcp47/collation.xml#L49">Spécification Unicode pour la collation selon la casse</a></li>
-</ul>
+- {{jsxref("Locale", "Intl.Locale")}}
+- [Spécification Unicode pour la collation selon la casse](https://github.com/unicode-org/cldr/blob/master/common/bcp47/collation.xml#L49)
diff --git a/files/fr/web/javascript/reference/global_objects/intl/locale/collation/index.md b/files/fr/web/javascript/reference/global_objects/intl/locale/collation/index.md
index fe261c15a3..3e856490ab 100644
--- a/files/fr/web/javascript/reference/global_objects/intl/locale/collation/index.md
+++ b/files/fr/web/javascript/reference/global_objects/intl/locale/collation/index.md
@@ -11,156 +11,173 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Intl/Locale/collation
 original_slug: Web/JavaScript/Reference/Objets_globaux/Intl/Locale/collation
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La propriété <strong><code>Intl.Locale.prototype.collation</code></strong> est une propriété (à laquelle on accède via un accesseur) qui renvoie le <a href="https://www.unicode.org/reports/tr35/tr35-collation.html#CLDR_Collation">type de collation</a> pour l'instance de <code>Locale</code> courante. La collation est la méthode qui permet d'ordonner des chaînes de caractères en fonction des règles de la locale.</p>
+La propriété **`Intl.Locale.prototype.collation`** est une propriété (à laquelle on accède via un accesseur) qui renvoie le [type de collation](https://www.unicode.org/reports/tr35/tr35-collation.html#CLDR_Collation) pour l'instance de `Locale` courante. La collation est la méthode qui permet d'ordonner des chaînes de caractères en fonction des règles de la locale.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La collation est la façon dont les chaînes de caractères sont ordonnées. Elle est utilisée lorsqu'on doit trier des chaînes de caractères (des résultats de recherche, des enregistrements dans une base de donnée, etc.). Bien que cela puisse sembler trivial, la collation varie d'une région à l'autre et d'une langue à une autre. Cette propriété permet aux développeurs de connaître le type de collation pour une locale donnée.</p>
+La collation est la façon dont les chaînes de caractères sont ordonnées. Elle est utilisée lorsqu'on doit trier des chaînes de caractères (des résultats de recherche, des enregistrements dans une base de donnée, etc.). Bien que cela puisse sembler trivial, la collation varie d'une région à l'autre et d'une langue à une autre. Cette propriété permet aux développeurs de connaître le type de collation pour une locale donnée.
 
-<p>Voici un tableau listant les types de collation possibles tels que définis dans <a href="https://github.com/unicode-org/cldr/blob/2dd06669d833823e26872f249aa304bc9d9d2a90/common/bcp47/collation.xml">la spécification Unicode sur la collation</a>.</p>
+Voici un tableau listant les types de collation possibles tels que définis dans [la spécification Unicode sur la collation](https://github.com/unicode-org/cldr/blob/2dd06669d833823e26872f249aa304bc9d9d2a90/common/bcp47/collation.xml).
 
 <table class="standard-table">
- <caption>Les différents types de collation</caption>
- <thead>
-  <tr>
-   <th scope="col">Type de collation</th>
-   <th scope="col">Description</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td><code>big5han</code></td>
-   <td>Ordre pinyin pour l'alphabet latin et ordre big5 pour les caractères CJK (utilisés en chinois)</td>
-  </tr>
-  <tr>
-   <td><code>compat</code></td>
-   <td>Une version précédente de l'ordre, utilisée à des fins de compatibilité</td>
-  </tr>
-  <tr>
-   <td><code>dict</code></td>
-   <td>Ordre à la façon d'un dictionnaire (comme utilisé en cingalais)</td>
-  </tr>
-  <tr>
-   <td>
-    <div class="warning">
-    <p><strong>Attention :</strong> Le type <code>direct</code> a été déprécié et ne doit pas être utilisé.</p>
-    </div>
-
-    <p><code>direct</code></p>
-   </td>
-   <td>Ordre des points de code binaires (utilisé en hindoux)</td>
-  </tr>
-  <tr>
-   <td><code>ducet</code></td>
-   <td>La collation Unicode par défaut pour les éléments d'un tableau</td>
-  </tr>
-  <tr>
-   <td><code>emoji</code></td>
-   <td>L'ordre recommandé pour les émojis</td>
-  </tr>
-  <tr>
-   <td><code>eor</code></td>
-   <td>Règles d'ordre européennes</td>
-  </tr>
-  <tr>
-   <td><code>gb2312</code></td>
-   <td>Ordre pinyin pour l'alphabet latin et ordre gb2312han pour les caractères CJK (utilisés en chinois)</td>
-  </tr>
-  <tr>
-   <td><code>phonebk</code></td>
-   <td>Ordre à la façon d'un annuaire (tel qu'en allemand)</td>
-  </tr>
-  <tr>
-   <td><code>phonetic</code></td>
-   <td>Ordre phonétique, basé sur la prononciation</td>
-  </tr>
-  <tr>
-   <td><code>pinyin</code></td>
-   <td>Ordre pinyin pour les caractères de l'alphabet latin et les caractères CJK (utilisés en chniois)</td>
-  </tr>
-  <tr>
-   <td><code>reformed</code></td>
-   <td>Ordre réformé (tel qu'en suédois)</td>
-  </tr>
-  <tr>
-   <td><code>search</code></td>
-   <td>Collation spéciale pour les chaînes de caractères utilisées pour des recherches</td>
-  </tr>
-  <tr>
-   <td><code>searchjl</code></td>
-   <td>Collation spéciale pour la recherche des consonnes initiales en coréen</td>
-  </tr>
-  <tr>
-   <td><code>standard</code></td>
-   <td>L'ordre par défaut pour chaque langue</td>
-  </tr>
-  <tr>
-   <td><code>stroke</code></td>
-   <td>Ordre pinyin pour l'alphabet latin et ordre de dessin (<em>stroke</em>) pour les caractères CJK (utilisés en chinois)</td>
-  </tr>
-  <tr>
-   <td><code>trad</code></td>
-   <td>Ordre traditionnel (tel qu'en espagnol)</td>
-  </tr>
-  <tr>
-   <td><code>unihan</code></td>
-   <td>Ordre pinyin pour l'alphabet latin et ordre Unihan radical pour les caractères CJK (utilisés en chinois)</td>
-  </tr>
-  <tr>
-   <td><code>zhuyin</code></td>
-   <td>
-    <p>Ordre pinyin pour l'alphabet latin, ordre zhuyin pour les caractères Bopomofo et CJK (utilisés en chinois)</p>
-   </td>
-  </tr>
- </tbody>
+  <caption>
+    Les différents types de collation
+  </caption>
+  <thead>
+    <tr>
+      <th scope="col">Type de collation</th>
+      <th scope="col">Description</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td><code>big5han</code></td>
+      <td>
+        Ordre pinyin pour l'alphabet latin et ordre big5 pour les caractères CJK
+        (utilisés en chinois)
+      </td>
+    </tr>
+    <tr>
+      <td><code>compat</code></td>
+      <td>
+        Une version précédente de l'ordre, utilisée à des fins de compatibilité
+      </td>
+    </tr>
+    <tr>
+      <td><code>dict</code></td>
+      <td>Ordre à la façon d'un dictionnaire (comme utilisé en cingalais)</td>
+    </tr>
+    <tr>
+      <td>
+        <div class="warning">
+          <p>
+            <strong>Attention :</strong> Le type <code>direct</code> a été
+            déprécié et ne doit pas être utilisé.
+          </p>
+        </div>
+        <p><code>direct</code></p>
+      </td>
+      <td>Ordre des points de code binaires (utilisé en hindoux)</td>
+    </tr>
+    <tr>
+      <td><code>ducet</code></td>
+      <td>La collation Unicode par défaut pour les éléments d'un tableau</td>
+    </tr>
+    <tr>
+      <td><code>emoji</code></td>
+      <td>L'ordre recommandé pour les émojis</td>
+    </tr>
+    <tr>
+      <td><code>eor</code></td>
+      <td>Règles d'ordre européennes</td>
+    </tr>
+    <tr>
+      <td><code>gb2312</code></td>
+      <td>
+        Ordre pinyin pour l'alphabet latin et ordre gb2312han pour les
+        caractères CJK (utilisés en chinois)
+      </td>
+    </tr>
+    <tr>
+      <td><code>phonebk</code></td>
+      <td>Ordre à la façon d'un annuaire (tel qu'en allemand)</td>
+    </tr>
+    <tr>
+      <td><code>phonetic</code></td>
+      <td>Ordre phonétique, basé sur la prononciation</td>
+    </tr>
+    <tr>
+      <td><code>pinyin</code></td>
+      <td>
+        Ordre pinyin pour les caractères de l'alphabet latin et les caractères
+        CJK (utilisés en chniois)
+      </td>
+    </tr>
+    <tr>
+      <td><code>reformed</code></td>
+      <td>Ordre réformé (tel qu'en suédois)</td>
+    </tr>
+    <tr>
+      <td><code>search</code></td>
+      <td>
+        Collation spéciale pour les chaînes de caractères utilisées pour des
+        recherches
+      </td>
+    </tr>
+    <tr>
+      <td><code>searchjl</code></td>
+      <td>
+        Collation spéciale pour la recherche des consonnes initiales en coréen
+      </td>
+    </tr>
+    <tr>
+      <td><code>standard</code></td>
+      <td>L'ordre par défaut pour chaque langue</td>
+    </tr>
+    <tr>
+      <td><code>stroke</code></td>
+      <td>
+        Ordre pinyin pour l'alphabet latin et ordre de dessin (<em>stroke</em>)
+        pour les caractères CJK (utilisés en chinois)
+      </td>
+    </tr>
+    <tr>
+      <td><code>trad</code></td>
+      <td>Ordre traditionnel (tel qu'en espagnol)</td>
+    </tr>
+    <tr>
+      <td><code>unihan</code></td>
+      <td>
+        Ordre pinyin pour l'alphabet latin et ordre Unihan radical pour les
+        caractères CJK (utilisés en chinois)
+      </td>
+    </tr>
+    <tr>
+      <td><code>zhuyin</code></td>
+      <td>
+        <p>
+          Ordre pinyin pour l'alphabet latin, ordre zhuyin pour les caractères
+          Bopomofo et CJK (utilisés en chinois)
+        </p>
+      </td>
+    </tr>
+  </tbody>
 </table>
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<p>À l'instar des autres étiquettes, le type de collation peut être défini pour l'objet {{jsxref("Locale", "Intl.Locale")}} via la chaîne de caractères qui définit la locale ou grâce au deuxième paramètre du constructeur qui est un objet de configuration.</p>
+À l'instar des autres étiquettes, le type de collation peut être défini pour l'objet {{jsxref("Locale", "Intl.Locale")}} via la chaîne de caractères qui définit la locale ou grâce au deuxième paramètre du constructeur qui est un objet de configuration.
 
-<h3 id="Définir_le_type_de_collation_via_la_chaîne_décrivant_la_locale">Définir le type de collation via la chaîne décrivant la locale</h3>
+### Définir le type de collation via la chaîne décrivant la locale
 
-<p>Le premier argument passé à <a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Locale" title="The Intl.Locale constructor is a standard built-in property of the Intl object."><code>Intl.Locale</code></a> est une chaîne de caractères qui décrit la locale. Cette chaîne peut contenir des fragments additionnels (en plus de l'identifiant canonique de la locale). Pour cela, on ajoutera <code>-u</code> afin d'indiquer qu'on définit une extension. On ajoutera ensuite la clé identifiant cette extension, ici <code>-co</code> pour la collation. Enfin, on ajoutera la valeur souhaitée pour cette extension (dans cet exemple, <code>-emoji</code>) :</p>
+Le premier argument passé à [`Intl.Locale`](/fr/docs/Web/JavaScript/Reference/Objets_globaux/Locale "The Intl.Locale constructor is a standard built-in property of the Intl object.") est une chaîne de caractères qui décrit la locale. Cette chaîne peut contenir des fragments additionnels (en plus de l'identifiant canonique de la locale). Pour cela, on ajoutera `-u` afin d'indiquer qu'on définit une extension. On ajoutera ensuite la clé identifiant cette extension, ici `-co` pour la collation. Enfin, on ajoutera la valeur souhaitée pour cette extension (dans cet exemple, `-emoji`) :
 
-<pre class="brush: js">let stringColl = new Intl.Locale("en-Latn-US-u-co-emoji");
+```js
+let stringColl = new Intl.Locale("en-Latn-US-u-co-emoji");
 console.log(stringColl.collation); // Affichera "emoji" dans la console
-</pre>
+```
 
-<h3 id="Définir_le_type_de_collation_via_lobjet_de_configuration">Définir le type de collation via l'objet de configuration</h3>
+### Définir le type de collation via l'objet de configuration
 
-<p>Le constructeur <a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Locale" title="The Intl.Locale constructor is a standard built-in property of the Intl object."><code>Intl.Locale</code></a> possède un deuxième argument optionnel qui est un objet de configuration. Chaque propriété de cet objet pourra permettre de préciser une extension à la locale, y compris un type de collation. Pour définir le type de collation, on pourra utiliser une propriété <code>collation</code> sur cet objet avec une des valeurs indiquées ci-avant :</p>
+Le constructeur [`Intl.Locale`](/fr/docs/Web/JavaScript/Reference/Objets_globaux/Locale "The Intl.Locale constructor is a standard built-in property of the Intl object.") possède un deuxième argument optionnel qui est un objet de configuration. Chaque propriété de cet objet pourra permettre de préciser une extension à la locale, y compris un type de collation. Pour définir le type de collation, on pourra utiliser une propriété `collation` sur cet objet avec une des valeurs indiquées ci-avant :
 
-<pre class="brush: js">let configColl = new Intl.Locale("en-Latn-US", {collation: "emoji"});
-console.log(configColl.collation); // Affichera "emoji" dans la console</pre>
+```js
+let configColl = new Intl.Locale("en-Latn-US", {collation: "emoji"});
+console.log(configColl.collation); // Affichera "emoji" dans la console
+```
 
-<h2 id="Spécifications">Spécifications</h2>
+## Spécifications
 
-<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><a href="https://tc39.github.io/proposal-intl-locale/#sec-Intl.Locale.prototype.collation">Proposition pour <code>Intl.Locale.prototype.collation</code></a></td>
-   <td>Proposition de niveau 3</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
+| Spécification                                                                                                                          | État                    | Commentaires |
+| -------------------------------------------------------------------------------------------------------------------------------------- | ----------------------- | ------------ |
+| [Proposition pour `Intl.Locale.prototype.collation`](https://tc39.github.io/proposal-intl-locale/#sec-Intl.Locale.prototype.collation) | Proposition de niveau 3 |              |
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.Intl.Locale.collation")}}</p>
+{{Compat("javascript.builtins.Intl.Locale.collation")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("Locale", "Intl.Locale")}}</li>
-</ul>
+- {{jsxref("Locale", "Intl.Locale")}}
diff --git a/files/fr/web/javascript/reference/global_objects/intl/locale/hourcycle/index.md b/files/fr/web/javascript/reference/global_objects/intl/locale/hourcycle/index.md
index c46c209435..14cb734a56 100644
--- a/files/fr/web/javascript/reference/global_objects/intl/locale/hourcycle/index.md
+++ b/files/fr/web/javascript/reference/global_objects/intl/locale/hourcycle/index.md
@@ -11,84 +11,52 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Intl/Locale/hourCycle
 original_slug: Web/JavaScript/Reference/Objets_globaux/Intl/Locale/hourCycle
 ---
-<div>{{JSRef}}</div>
-
-<p>La propriété <strong><code>Intl.Locale.prototype.hourCycle</code></strong> est une propriété accessible via un accesseur qui renvoie la convention pour le format des heures utilisée par la locale courante.</p>
-
-<h2 id="Description">Description</h2>
-
-<p>Il existe deux types de conventions pour la représentation des heures : sur douze heures d'une part et sur vingt-quatre heures d'autre part. La propriété <code>hourCycle</code> permet aux développeurs de connaître la représentation utilisée par une locale donnée. À l'instar des autres données fournies par les instances de <code>Locale</code>, <code>hourCycle</code> représente une <a href="https://www.unicode.org/reports/tr35/#u_Extension">extension Unicode</a> qui permet d'affiner le comportement d'une locale. Les valeurs de cette propriété/extension peuvent être :</p>
-
-<table class="standard-table">
- <caption>Valeurs possibles pour l'extension <code>hourCycle</code></caption>
- <thead>
-  <tr>
-   <th scope="col">Clé</th>
-   <th scope="col">Description</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td><code>h12</code></td>
-   <td>Système horaire sur les heures 1 à 12 (correspond à la notation "h" pour les motifs de recherche). L'horloge est sur douze heures et minuit commence à 12:00 AM.</td>
-  </tr>
-  <tr>
-   <td><code>h23</code></td>
-   <td>Système horaire sur les heures 0 à 23 (correspond à la notation "H" pour les motifs de recherche). L'horloge est sur vingt-quatre heures et minuit commence à 0:00.</td>
-  </tr>
-  <tr>
-   <td><code>h11</code></td>
-   <td>Système horaire sur les heures 0 à 11 (correspond à la notation "K" pour les motifs de recherche). L'horloge est sur douze heures et minuit commence à 0:00 AM.</td>
-  </tr>
-  <tr>
-   <td><code>h24</code></td>
-   <td>Système horaire sur les heures 1 à 24 (correspond à la notation "K" pour les motifs de recherche). L'horloge est sur vingt-quatre heures et minuit commence à 24:00.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Exemples">Exemples</h2>
-
-<h3 id="Définir_le_format_horaire_grâce_à_la_chaîne_décrivant_la_locale">Définir le format horaire grâce à la chaîne décrivant la locale</h3>
-
-<p>Il est possible de préciser la valeur d'une extension Unicode dans la chaîne de caractères représentant la locale. Pour indiquer l'extension, on ajoutera le suffixe <code>-u</code> qui indique une clé d'extension à venir, ensuite on ajoutera la clé de l'extension en question (ici <code>-hc</code>) et enfin on ajoutera la valeur souhaitée pour cette extension.</p>
-
-<pre class="brush: js">let fr24hour = new Intl.Locale("fr-FR-u-hc-h23");
-console.log(fr24hour.hourCycle); // Affichera "h23" dans la console</pre>
-
-<h3 id="Définir_le_format_horaire_grâce_à_un_objet_de_configuration">Définir le format horaire grâce à un objet de configuration</h3>
-
-<p>Le constructeur <a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Locale" title="The Intl.Locale constructor is a standard built-in property of the Intl object."><code>Intl.Locale</code></a> permet d'utiliser un objet de configuration comme deuxième argument. Les propriétés de cet objet permettent de définir différentes extensions, y compris celle pour le format horaire. Pour cela, on indiquera la propriété <code>hourCycle</code> sur l'objet de configuration avec la valeur souhaitée et on passera cet objet au constructeur.</p>
-
-<pre class="brush: js">let us12hour = new Intl.Locale("en-US-u-hc-h12");
-console.log(us12hour.hourCycle); // Affichera "h12" 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><a href="https://tc39.github.io/proposal-intl-locale/#sec-Intl.Locale.prototype.hourCycle">Proposition pour <code>Intl.Locale</code></a></td>
-   <td>Proposition de niveau 3</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<div>{{Compat("javascript.builtins.Intl.Locale.hourCycle")}}</div>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Locale", "Intl.Locale")}}</li>
- <li><a href="https://www.unicode.org/reports/tr35/#UnicodeHourCycleIdentifier">Spécification pour l'extension Unicode des cycles horaires</a></li>
-</ul>
+{{JSRef}}
+
+La propriété **`Intl.Locale.prototype.hourCycle`** est une propriété accessible via un accesseur qui renvoie la convention pour le format des heures utilisée par la locale courante.
+
+## Description
+
+Il existe deux types de conventions pour la représentation des heures : sur douze heures d'une part et sur vingt-quatre heures d'autre part. La propriété `hourCycle` permet aux développeurs de connaître la représentation utilisée par une locale donnée. À l'instar des autres données fournies par les instances de `Locale`, `hourCycle` représente une [extension Unicode](https://www.unicode.org/reports/tr35/#u_Extension) qui permet d'affiner le comportement d'une locale. Les valeurs de cette propriété/extension peuvent être :
+
+| Clé   | Description                                                                                                                                                          |
+| ----- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `h12` | Système horaire sur les heures 1 à 12 (correspond à la notation "h" pour les motifs de recherche). L'horloge est sur douze heures et minuit commence à 12:00 AM.     |
+| `h23` | Système horaire sur les heures 0 à 23 (correspond à la notation "H" pour les motifs de recherche). L'horloge est sur vingt-quatre heures et minuit commence à 0:00.  |
+| `h11` | Système horaire sur les heures 0 à 11 (correspond à la notation "K" pour les motifs de recherche). L'horloge est sur douze heures et minuit commence à 0:00 AM.      |
+| `h24` | Système horaire sur les heures 1 à 24 (correspond à la notation "K" pour les motifs de recherche). L'horloge est sur vingt-quatre heures et minuit commence à 24:00. |
+
+## Exemples
+
+### Définir le format horaire grâce à la chaîne décrivant la locale
+
+Il est possible de préciser la valeur d'une extension Unicode dans la chaîne de caractères représentant la locale. Pour indiquer l'extension, on ajoutera le suffixe `-u` qui indique une clé d'extension à venir, ensuite on ajoutera la clé de l'extension en question (ici `-hc`) et enfin on ajoutera la valeur souhaitée pour cette extension.
+
+```js
+let fr24hour = new Intl.Locale("fr-FR-u-hc-h23");
+console.log(fr24hour.hourCycle); // Affichera "h23" dans la console
+```
+
+### Définir le format horaire grâce à un objet de configuration
+
+Le constructeur [`Intl.Locale`](/fr/docs/Web/JavaScript/Reference/Objets_globaux/Locale "The Intl.Locale constructor is a standard built-in property of the Intl object.") permet d'utiliser un objet de configuration comme deuxième argument. Les propriétés de cet objet permettent de définir différentes extensions, y compris celle pour le format horaire. Pour cela, on indiquera la propriété `hourCycle` sur l'objet de configuration avec la valeur souhaitée et on passera cet objet au constructeur.
+
+```js
+let us12hour = new Intl.Locale("en-US-u-hc-h12");
+console.log(us12hour.hourCycle); // Affichera "h12" dans la console
+```
+
+## Spécifications
+
+| Spécification                                                                                                      | État                    | Commentaires |
+| ------------------------------------------------------------------------------------------------------------------ | ----------------------- | ------------ |
+| [Proposition pour `Intl.Locale`](https://tc39.github.io/proposal-intl-locale/#sec-Intl.Locale.prototype.hourCycle) | Proposition de niveau 3 |              |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Intl.Locale.hourCycle")}}
+
+## Voir aussi
+
+- {{jsxref("Locale", "Intl.Locale")}}
+- [Spécification pour l'extension Unicode des cycles horaires](https://www.unicode.org/reports/tr35/#UnicodeHourCycleIdentifier)
diff --git a/files/fr/web/javascript/reference/global_objects/intl/locale/index.md b/files/fr/web/javascript/reference/global_objects/intl/locale/index.md
index 07608fd53c..95dbb3bc0d 100644
--- a/files/fr/web/javascript/reference/global_objects/intl/locale/index.md
+++ b/files/fr/web/javascript/reference/global_objects/intl/locale/index.md
@@ -10,62 +10,45 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Intl/Locale
 original_slug: Web/JavaScript/Reference/Objets_globaux/Intl/Locale
 ---
-<div>{{JSRef}}{{SeeCompatTable}}</div>
+{{JSRef}}{{SeeCompatTable}}
 
-<p>Le constructeur <strong><code>Intl.Locale</code></strong> est une propriété native de l'objet <code>Intl</code> représentant l'identifiant d'une locale Unicode.</p>
+Le constructeur **`Intl.Locale`** est une propriété native de l'objet `Intl` représentant l'identifiant d'une locale Unicode.
 
-<p>{{EmbedInteractiveExample("pages/js/intl-locale.html")}}</p>
+{{EmbedInteractiveExample("pages/js/intl-locale.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">new Intl.Locale([<var>tag</var>[, <var>options</var>]])</pre>
+    new Intl.Locale([tag[, options]])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>tag</code></dt>
- <dd>La chaîne de caractère représentant l'identifiant d'une locale Unicode.</dd>
- <dt><code>options</code></dt>
- <dd>Un objet contenant la configuration pour la locale. Les clés (noms des propriétés) de cet objets sont des balises Unicode et les valeurs de ces propriétés doivent être des valeurs de balises Unicode valides.</dd>
-</dl>
+- `tag`
+  - : La chaîne de caractère représentant l'identifiant d'une locale Unicode.
+- `options`
+  - : Un objet contenant la configuration pour la locale. Les clés (noms des propriétés) de cet objets sont des balises Unicode et les valeurs de ces propriétés doivent être des valeurs de balises Unicode valides.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>L'objet <code>Intl.locale</code> a été conçu afin de manipuler des locales Unicode. Les locales Unicode sont représentées par une chaîne de caractères qu'on appelle « identifiant de locale ». L'identifant de locale se compose d'un identifiant de langue et d'extensions. Les identifiants de langue sont la composante principale d'une locale et contiennent une langue, un système d'écriture et des extensions régionales. Les informations complémentaires sont stockées via les extensions. Ces extensions peuvent fournir des informations quant au type de calendrier utilisé, le format d'heure utilisé ou la numération utilisée.</p>
+L'objet `Intl.locale` a été conçu afin de manipuler des locales Unicode. Les locales Unicode sont représentées par une chaîne de caractères qu'on appelle « identifiant de locale ». L'identifant de locale se compose d'un identifiant de langue et d'extensions. Les identifiants de langue sont la composante principale d'une locale et contiennent une langue, un système d'écriture et des extensions régionales. Les informations complémentaires sont stockées via les extensions. Ces extensions peuvent fournir des informations quant au type de calendrier utilisé, le format d'heure utilisé ou la numération utilisée.
 
-<p>L'objet <code>Intl.Locale</code> possède les propriétés et méthodes suivantes.</p>
+L'objet `Intl.Locale` possède les propriétés et méthodes suivantes.
 
-<h3 id="Propriétés">Propriétés</h3>
+### Propriétés
 
-<dl>
- <dt>{{jsxref("Locale.prototype","Intl.Locale.prototype")}}</dt>
- <dd>Le prototype pour le constructeur <code>Locale</code>.</dd>
-</dl>
+- {{jsxref("Locale.prototype","Intl.Locale.prototype")}}
+  - : Le prototype pour le constructeur `Locale`.
 
-<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><a href="https://tc39.github.io/proposal-intl-locale/#locale-objects">Proposition pour <code>Intl.Locale</code></a></td>
-   <td>Proposition de niveau 3</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
+| Spécification                                                                                 | État                    | Commentaires |
+| --------------------------------------------------------------------------------------------- | ----------------------- | ------------ |
+| [Proposition pour `Intl.Locale`](https://tc39.github.io/proposal-intl-locale/#locale-objects) | Proposition de niveau 3 |              |
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.Intl.Locale")}}</p>
+{{Compat("javascript.builtins.Intl.Locale")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li><a href="https://github.com/zbraniecki/Intl.js/tree/intllocale">La prothèse d'émulation (<em>polyfill</em>) pour <code>Intl.Locale</code></a></li>
- <li><a href="https://www.unicode.org/reports/tr35/#Canonical_Unicode_Locale_Identifiers">La spécification Unicode pour les identifiants de locale</a></li>
-</ul>
+- [La prothèse d'émulation (_polyfill_) pour `Intl.Locale`](https://github.com/zbraniecki/Intl.js/tree/intllocale)
+- [La spécification Unicode pour les identifiants de locale](https://www.unicode.org/reports/tr35/#Canonical_Unicode_Locale_Identifiers)
diff --git a/files/fr/web/javascript/reference/global_objects/intl/locale/language/index.md b/files/fr/web/javascript/reference/global_objects/intl/locale/language/index.md
index 4fe3adfb90..c5e52123c9 100644
--- a/files/fr/web/javascript/reference/global_objects/intl/locale/language/index.md
+++ b/files/fr/web/javascript/reference/global_objects/intl/locale/language/index.md
@@ -11,58 +11,47 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Intl/Locale/language
 original_slug: Web/JavaScript/Reference/Objets_globaux/Intl/Locale/language
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La propriété <strong><code>Intl.Locale.prototype.language</code></strong> est une propriété fournie via un accesseur qui renvoie la langue associée à la locale.</p>
+La propriété **`Intl.Locale.prototype.language`** est une propriété fournie via un accesseur qui renvoie la langue associée à la locale.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La langue est l'une des caractéristiques majeurs d'une locale. La spécification Unicode indique que l'identifiant de la langue d'une locale est composée de l'identifiant canonique de la langue et de l'identifiant de la réponse (on pourra ainsi distinguer l'anglais britannique de l'anglais américain). Toutefois, la propriété <code>language</code> de {{jsxref("Locale", "Locale")}} renvoie uniquement la composante relative à la langue.</p>
+La langue est l'une des caractéristiques majeurs d'une locale. La spécification Unicode indique que l'identifiant de la langue d'une locale est composée de l'identifiant canonique de la langue et de l'identifiant de la réponse (on pourra ainsi distinguer l'anglais britannique de l'anglais américain). Toutefois, la propriété `language` de {{jsxref("Locale", "Locale")}} renvoie uniquement la composante relative à la langue.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Indiquer_la_langue_via_la_chaîne_décrivant_la_locale">Indiquer la langue via la chaîne décrivant la locale</h3>
+### Indiquer la langue via la chaîne décrivant la locale
 
-<p>Afin de pouvoir représenter une locale Unicode correctement, une chaîne doit commencer par un identifiant de langue. Le principal argument du constructeur {{jsxref("Locale", "Locale")}} doit être un identifiant valide et doit donc contenir la composante liée à la langue.</p>
+Afin de pouvoir représenter une locale Unicode correctement, une chaîne doit commencer par un identifiant de langue. Le principal argument du constructeur {{jsxref("Locale", "Locale")}} doit être un identifiant valide et doit donc contenir la composante liée à la langue.
 
-<pre class="brush: js">let langStr = new Intl.Locale("en-Latn-US");
+```js
+let langStr = new Intl.Locale("en-Latn-US");
 
-console.log(langStr.language); // Affichera "en" dans la console</pre>
+console.log(langStr.language); // Affichera "en" dans la console
+```
 
-<h3 id="Surcharger_la_langue_via_lobjet_de_configuration">Surcharger la langue via l'objet de configuration</h3>
+### Surcharger la langue via l'objet de configuration
 
-<p>Bien que la composante de la langue doive être indiquée dans le premier paramètre, le constructeur {{jsxref("Locale", "Locale")}} prend comme deuxième argument un objet de configuration qui permet de surcharger cette composante.</p>
+Bien que la composante de la langue doive être indiquée dans le premier paramètre, le constructeur {{jsxref("Locale", "Locale")}} prend comme deuxième argument un objet de configuration qui permet de surcharger cette composante.
 
-<pre class="brush: js">let langObj = new Intl.Locale("en-Latn-US", {language: "es"});
+```js
+let langObj = new Intl.Locale("en-Latn-US", {language: "es"});
 
-console.log(langObj.language); // Affichera "es" dans la console</pre>
+console.log(langObj.language); // Affichera "es" dans la console
+```
 
-<h2 id="Spécifications">Spécifications</h2>
+## Spécifications
 
-<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><a href="https://tc39.github.io/proposal-intl-locale/#sec-Intl.Locale.prototype.language">Proposition pour <code>Intl.Locale.prototype.language</code></a></td>
-   <td>Proposition de niveau 3</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
+| Spécification                                                                                                                        | État                    | Commentaires |
+| ------------------------------------------------------------------------------------------------------------------------------------ | ----------------------- | ------------ |
+| [Proposition pour `Intl.Locale.prototype.language`](https://tc39.github.io/proposal-intl-locale/#sec-Intl.Locale.prototype.language) | Proposition de niveau 3 |              |
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<div>{{Compat("javascript.builtins.Intl.Locale.language")}}</div>
+{{Compat("javascript.builtins.Intl.Locale.language")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("Locale", "Locale")}}</li>
- <li><a href="https://www.unicode.org/reports/tr35/#unicode_language_subtag_validity">Spécification des extensions Unicode</a></li>
-</ul>
+- {{jsxref("Locale", "Locale")}}
+- [Spécification des extensions Unicode](https://www.unicode.org/reports/tr35/#unicode_language_subtag_validity)
diff --git a/files/fr/web/javascript/reference/global_objects/intl/locale/maximize/index.md b/files/fr/web/javascript/reference/global_objects/intl/locale/maximize/index.md
index 74411b818c..f125b58901 100644
--- a/files/fr/web/javascript/reference/global_objects/intl/locale/maximize/index.md
+++ b/files/fr/web/javascript/reference/global_objects/intl/locale/maximize/index.md
@@ -10,27 +10,28 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Intl/Locale/maximize
 original_slug: Web/JavaScript/Reference/Objets_globaux/Intl/Locale/maximize
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>Intl.Locale.prototype.maximize()</code></strong> permet d'obtenir les valeurs les plus vraisemblantes pour la langue, le script et la région de la locale en fonction des valeurs existantes.</p>
+La méthode **`Intl.Locale.prototype.maximize()`** permet d'obtenir les valeurs les plus vraisemblantes pour la langue, le script et la région de la locale en fonction des valeurs existantes.
 
-<p>{{EmbedInteractiveExample("pages/js/intl-locale-prototype-maximize.html")}}</p>
+{{EmbedInteractiveExample("pages/js/intl-locale-prototype-maximize.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><code><em>locale</em>.maximize()</code></pre>
+    locale.maximize()
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une instance {{jsxref("Locale", "Locale")}} dont la propriété <code>baseName</code> renvoie le résultat de l'algorithme de <a href="https://www.unicode.org/reports/tr35/#Likely_Subtags">vraisemblance des composantes</a> lancé sur <code><em>{{jsxref("Locale/baseName", "locale.baseName")}}</em></code>.</p>
+Une instance {{jsxref("Locale", "Locale")}} dont la propriété `baseName` renvoie le résultat de l'algorithme de [vraisemblance des composantes](https://www.unicode.org/reports/tr35/#Likely_Subtags) lancé sur `{{jsxref("Locale/baseName", "locale.baseName")}}`.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Il est parfois utile d'identifier les composantes les plus probables d'une locale en fonction d'un identifiant incomplet. Cette méthode utilise un algorithme qui permet de déduire les composantes restantes les plus probables. Par exemple, si on fournit la langue <code>"en"</code>, l'algorithme renverra <code>"en-Latn-US"</code>, car l'anglais ne s'écrit qu'avec l'alphabet latin et est le plus largement parlé aux États-Unis. La méthode <code>maximize()</code> n'opère que sur les composantes principales (langue, script, région) et pas sur les extensions éventuellement indiquées après <code>"-u"</code> (dont <a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Locale/hourCycle" title="The Intl.Locale.prototype.hourCycle property is an accessor property that returns the time keeping format convention used by the locale."><code>Locale.hourCycle</code></a>, <a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Locale/calendar" title="The Intl.Locale.prototype.calendar property is an accessor property which returns the type of calendar used in the Locale."><code>Locale.calendar</code></a> et <a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Locale/numeric" title="The Intl.Locale.prototype.numeric property is an accessor property that returns whether the locale has special collation handling for numeric characters."><code>Locale.numeric</code></a> entre autres).</p>
+Il est parfois utile d'identifier les composantes les plus probables d'une locale en fonction d'un identifiant incomplet. Cette méthode utilise un algorithme qui permet de déduire les composantes restantes les plus probables. Par exemple, si on fournit la langue `"en"`, l'algorithme renverra `"en-Latn-US"`, car l'anglais ne s'écrit qu'avec l'alphabet latin et est le plus largement parlé aux États-Unis. La méthode `maximize()` n'opère que sur les composantes principales (langue, script, région) et pas sur les extensions éventuellement indiquées après `"-u"` (dont [`Locale.hourCycle`](/fr/docs/Web/JavaScript/Reference/Objets_globaux/Locale/hourCycle "The Intl.Locale.prototype.hourCycle property is an accessor property that returns the time keeping format convention used by the locale."), [`Locale.calendar`](/fr/docs/Web/JavaScript/Reference/Objets_globaux/Locale/calendar "The Intl.Locale.prototype.calendar property is an accessor property which returns the type of calendar used in the Locale.") et [`Locale.numeric`](/fr/docs/Web/JavaScript/Reference/Objets_globaux/Locale/numeric "The Intl.Locale.prototype.numeric property is an accessor property that returns whether the locale has special collation handling for numeric characters.") entre autres).
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<pre class="brush: js">let maLocale = new Intl.Locale("fr", {hourCycle: "h24", calendar: "gregory"});
+```js
+let maLocale = new Intl.Locale("fr", {hourCycle: "h24", calendar: "gregory"});
 console.log(maLocale.baseName); // Affiche "fr"
 console.log(maLocale.toString()); // Affiche "fr-u-ca-gregory-hc-h24"
 let maLocMaximized = maLocale.maximize();
@@ -41,35 +42,21 @@ console.log(maLocMaximized.baseName);
 
 // Affiche "fr-Latn-FR-u-ca-gregory-hc-h24".
 // On notera que les extensions (après "-u") restent inchangées.
-console.log(myLocMaximized.toString()); </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><a href="https://tc39.github.io/proposal-intl-locale/#sec-Intl.Locale.prototype.maximize">Proposition pour <code>Intl.Locale.prototype.maximize()</code></a></td>
-   <td></td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Intl.Locale.maximize")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Locale", "Intl.Locale")}}</li>
- <li>{{jsxref("Locale/baseName", "Locale.baseName")}}</li>
- <li><a href="https://www.unicode.org/reports/tr35/#Likely_Subtags">Spécification Unicode sur la vraisemblance entre composantes</a></li>
-</ul>
+console.log(myLocMaximized.toString()); 
+```
+
+## Spécifications
+
+| Spécification                                                                                                                          | État | Commentaires |
+| -------------------------------------------------------------------------------------------------------------------------------------- | ---- | ------------ |
+| [Proposition pour `Intl.Locale.prototype.maximize()`](https://tc39.github.io/proposal-intl-locale/#sec-Intl.Locale.prototype.maximize) |      |              |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Intl.Locale.maximize")}}
+
+## Voir aussi
+
+- {{jsxref("Locale", "Intl.Locale")}}
+- {{jsxref("Locale/baseName", "Locale.baseName")}}
+- [Spécification Unicode sur la vraisemblance entre composantes](https://www.unicode.org/reports/tr35/#Likely_Subtags)
diff --git a/files/fr/web/javascript/reference/global_objects/intl/locale/minimize/index.md b/files/fr/web/javascript/reference/global_objects/intl/locale/minimize/index.md
index 78de1ee9b5..47b6aa48f0 100644
--- a/files/fr/web/javascript/reference/global_objects/intl/locale/minimize/index.md
+++ b/files/fr/web/javascript/reference/global_objects/intl/locale/minimize/index.md
@@ -11,29 +11,30 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Intl/Locale/minimize
 original_slug: Web/JavaScript/Reference/Objets_globaux/Intl/Locale/minimize
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>Intl.Locale.prototype.minimize()</code></strong> tente de retirer les informations qui auraient pu être ajoutée à une locale lors d'un appel à {{jsxref("Locale/maximize", "Locale.maximize()")}}.</p>
+La méthode **`Intl.Locale.prototype.minimize()`** tente de retirer les informations qui auraient pu être ajoutée à une locale lors d'un appel à {{jsxref("Locale/maximize", "Locale.maximize()")}}.
 
-<p>{{EmbedInteractiveExample("pages/js/intl-locale-prototype-minimize.html")}}</p>
+{{EmbedInteractiveExample("pages/js/intl-locale-prototype-minimize.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><code><em>locale</em>.minimize()</code></pre>
+    locale.minimize()
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une instance {{jsxref("Locale", "Locale")}} dont la propriété <code>baseName</code> renvoie le résultat de l'exécution de <a href="https://www.unicode.org/reports/tr35/#Likely_Subtags">l'algorithme de suppression des composantes probables</a> sur <code><em>locale.baseName</em></code>. </p>
+Une instance {{jsxref("Locale", "Locale")}} dont la propriété `baseName` renvoie le résultat de l'exécution de [l'algorithme de suppression des composantes probables](https://www.unicode.org/reports/tr35/#Likely_Subtags) sur `locale.baseName`.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Cette méthode effectue l'opération inverse de {{jsxref("Locale/maximize", "maximize()")}}, en retirant les fragments de langue/script ou de région qui sont superflus. Ainsi, <code>"en-Latn"</code> pourra être minimisé en <code>"en"</code> car l'anglais s'écrit uniquement à l'aide de l'alphabet latin.</p>
+Cette méthode effectue l'opération inverse de {{jsxref("Locale/maximize", "maximize()")}}, en retirant les fragments de langue/script ou de région qui sont superflus. Ainsi, `"en-Latn"` pourra être minimisé en `"en"` car l'anglais s'écrit uniquement à l'aide de l'alphabet latin.
 
-<p><code>minimize()</code> ne modifie pas les éventuelles extensions décrites dans la chaîne de locale (après le <code>"-u"</code>) ou via l'objet de configuration (elle ne modifie donc pas les valeurs de {{jsxref("Locale/hourCycle", "Locale.hourCycle")}}, {{jsxref("Locale/calendar", "Locale.calendar")}} et {{jsxref("Locale/numeric", "Locale.numeric")}}).</p>
+`minimize()` ne modifie pas les éventuelles extensions décrites dans la chaîne de locale (après le `"-u"`) ou via l'objet de configuration (elle ne modifie donc pas les valeurs de {{jsxref("Locale/hourCycle", "Locale.hourCycle")}}, {{jsxref("Locale/calendar", "Locale.calendar")}} et {{jsxref("Locale/numeric", "Locale.numeric")}}).
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<pre class="brush: js">let maLocale = new Intl.Locale("fr-Latn-FR", {hourCycle: "h24", calendar: "gregory"});
+```js
+let maLocale = new Intl.Locale("fr-Latn-FR", {hourCycle: "h24", calendar: "gregory"});
 console.log(maLocale.baseName); // Affiche "fr-Latn-FR"
 console.log(maLocale.toString()); // Affiche "fr-Latn-FR-u-ca-gregory-hc-h24"
 let maLocMinimized = maLocale.minimize();
@@ -44,34 +45,20 @@ console.log(maLocMinimized.baseName);
 
 console.log(maLocMinimized.toString());
 // Affiche "fr-u-ca-gregory-hc-h24". On voit ici que les extensions
-// (décrites après "-u") restent inchangées.</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><a href="https://tc39.github.io/proposal-intl-locale/#sec-Intl.Locale.prototype.minimize">Proposition pour <code>Intl.Locale.prototype.minimize()</code></a></td>
-   <td></td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Intl.Locale.minimize")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Locale", "Intl.Locale")}}</li>
- <li>{{jsxref("Locale/baseName", "Intl.Locale.baseName")}}</li>
-</ul>
+// (décrites après "-u") restent inchangées.
+```
+
+## Spécifications
+
+| Spécification                                                                                                                          | État | Commentaires |
+| -------------------------------------------------------------------------------------------------------------------------------------- | ---- | ------------ |
+| [Proposition pour `Intl.Locale.prototype.minimize()`](https://tc39.github.io/proposal-intl-locale/#sec-Intl.Locale.prototype.minimize) |      |              |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Intl.Locale.minimize")}}
+
+## Voir aussi
+
+- {{jsxref("Locale", "Intl.Locale")}}
+- {{jsxref("Locale/baseName", "Intl.Locale.baseName")}}
diff --git a/files/fr/web/javascript/reference/global_objects/intl/locale/numberingsystem/index.md b/files/fr/web/javascript/reference/global_objects/intl/locale/numberingsystem/index.md
index a57835345c..212cc4c37f 100644
--- a/files/fr/web/javascript/reference/global_objects/intl/locale/numberingsystem/index.md
+++ b/files/fr/web/javascript/reference/global_objects/intl/locale/numberingsystem/index.md
@@ -11,414 +11,138 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Intl/Locale/numberingSystem
 original_slug: Web/JavaScript/Reference/Objets_globaux/Intl/Locale/numberingSystem
 ---
-<div>{{JSRef}}</div>
-
-<p>La propriété <strong><code>Intl.Locale.prototype.numberingSystem</code></strong> est une propriété fournie par un accesseur qui renvoie le <a href="https://en.wikipedia.org/wiki/Numeral_system">système de numération</a> utilisée par la locale.</p>
-
-<h2 id="Description">Description</h2>
-
-<p>Un système de numération est un système qui permet d'exprimer les nombres. La propriété <code>numberingSystem</code> permet de connaître le système de numérati Unicode. A table of the standard Unicode numeral systems can be seen belowon de la locale. Les valeurs qui peuvent être fournies par cette propriété sont standardisées par Unicode.</p>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th>Valeur</th>
-   <th>Description</th>
-  </tr>
-  <tr>
-   <td><code>adlm</code></td>
-   <td>Chiffres adlams</td>
-  </tr>
-  <tr>
-   <td><code>ahom</code></td>
-   <td>Chiffres ahoms</td>
-  </tr>
-  <tr>
-   <td><code>arab</code></td>
-   <td>Chiffres arabes</td>
-  </tr>
-  <tr>
-   <td><code>arabext</code></td>
-   <td>Chiffres arabes étendus</td>
-  </tr>
-  <tr>
-   <td><code>armn</code></td>
-   <td>Numération arménienne majuscule (algorithmique)</td>
-  </tr>
-  <tr>
-   <td><code>armnlow</code></td>
-   <td>Numération arménienne minuscule (algorithmique)</td>
-  </tr>
-  <tr>
-   <td><code>bali</code></td>
-   <td>Chiffres balinais</td>
-  </tr>
-  <tr>
-   <td><code>beng</code></td>
-   <td>Chiffres bengalis</td>
-  </tr>
-  <tr>
-   <td><code>bhks</code></td>
-   <td>Chiffres bhaiksuki</td>
-  </tr>
-  <tr>
-   <td><code>brah</code></td>
-   <td>Chiffres brahmis</td>
-  </tr>
-  <tr>
-   <td><code>cakm</code></td>
-   <td>Chiffres chakmas</td>
-  </tr>
-  <tr>
-   <td><code>cham</code></td>
-   <td>Chiffres chams</td>
-  </tr>
-  <tr>
-   <td><code>cyrl</code></td>
-   <td>Numération cyrillique (algorithmique)</td>
-  </tr>
-  <tr>
-   <td><code>deva</code></td>
-   <td>Chiffres devanagaris</td>
-  </tr>
-  <tr>
-   <td><code>ethi</code></td>
-   <td>Numération éthiopienne (algorithmique)</td>
-  </tr>
-  <tr>
-   <td><code>finance</code></td>
-   <td>Numération financière (peut être algorithmique)</td>
-  </tr>
-  <tr>
-   <td><code>fullwide</code></td>
-   <td>Chiffres à pleine chasse</td>
-  </tr>
-  <tr>
-   <td><code>geor</code></td>
-   <td>Numération géorgienne (algorithmique)</td>
-  </tr>
-  <tr>
-   <td><code>gong</code></td>
-   <td>Chiffres Gunjala Gondis</td>
-  </tr>
-  <tr>
-   <td><code>gonm</code></td>
-   <td>Chiffres Masaram Gondis</td>
-  </tr>
-  <tr>
-   <td><code>grek</code></td>
-   <td>Numération greque majuscule (algorithmique)</td>
-  </tr>
-  <tr>
-   <td><code>greklow</code></td>
-   <td>Numération greque minuscule (algorithmique)</td>
-  </tr>
-  <tr>
-   <td><code>gujr</code></td>
-   <td>Chiffres Gujaratis</td>
-  </tr>
-  <tr>
-   <td><code>guru</code></td>
-   <td>Chiffres Gurmukhis</td>
-  </tr>
-  <tr>
-   <td><code>hanidays</code></td>
-   <td>Numération du jour du mois avec caractère Han (utilisée avec les calendriers lunaires ou traditionnels)</td>
-  </tr>
-  <tr>
-   <td><code>hanidec</code></td>
-   <td>Système décimal positionnel utilisant les idéographes des nombres chinois comme chiffres</td>
-  </tr>
-  <tr>
-   <td><code>hans</code></td>
-   <td>Numération chinoise simplifiée (algorithmique)</td>
-  </tr>
-  <tr>
-   <td><code>hansfin</code></td>
-   <td>Numération chinoise simplifiée financière (algorithmique)</td>
-  </tr>
-  <tr>
-   <td><code>hant</code></td>
-   <td>Numération chinoise traditionnelle (algorithmique)</td>
-  </tr>
-  <tr>
-   <td><code>hantfin</code></td>
-   <td>Numération chinoise traditionnelle financière (algorithmique)</td>
-  </tr>
-  <tr>
-   <td><code>hebr</code></td>
-   <td>Numération hébraïque (algorithmique)</td>
-  </tr>
-  <tr>
-   <td><code>hmng</code></td>
-   <td>Chiffres Pahawh Hmongs</td>
-  </tr>
-  <tr>
-   <td><code>hmnp</code></td>
-   <td>Chiffres Nyiakeng Puachue Hmongs</td>
-  </tr>
-  <tr>
-   <td><code>java</code></td>
-   <td>Chiffres javanais</td>
-  </tr>
-  <tr>
-   <td><code>jpan</code></td>
-   <td>Numération japonaise (algorithmique)</td>
-  </tr>
-  <tr>
-   <td><code>jpanfin</code></td>
-   <td>Numération japonaise financière (algorithmique)</td>
-  </tr>
-  <tr>
-   <td><code>jpanyear</code></td>
-   <td>Numération basée sur la première année Gannen du calendrier japonais</td>
-  </tr>
-  <tr>
-   <td><code>kali</code></td>
-   <td>Chiffres Kayah Lis</td>
-  </tr>
-  <tr>
-   <td><code>khmr</code></td>
-   <td>Chiffres Khmers</td>
-  </tr>
-  <tr>
-   <td><code>knda</code></td>
-   <td>Chiffres Kannadas</td>
-  </tr>
-  <tr>
-   <td><code>lana</code></td>
-   <td>Chiffres Tai Tham Hora séculiers</td>
-  </tr>
-  <tr>
-   <td><code>lanatham</code></td>
-   <td>Chiffres Tai Tham Tham ecclésiastiques</td>
-  </tr>
-  <tr>
-   <td><code>laoo</code></td>
-   <td>Chiffres laotien</td>
-  </tr>
-  <tr>
-   <td><code>latn</code></td>
-   <td>Chiffres latins</td>
-  </tr>
-  <tr>
-   <td><code>lepc</code></td>
-   <td>Chiffres Lepchas</td>
-  </tr>
-  <tr>
-   <td><code>limb</code></td>
-   <td>Chiffres Limbus</td>
-  </tr>
-  <tr>
-   <td><code>mathbold</code></td>
-   <td>Chiffres mathématiques en gras</td>
-  </tr>
-  <tr>
-   <td><code>mathdbl</code></td>
-   <td>Chiffres mathématiques barrés en double</td>
-  </tr>
-  <tr>
-   <td><code>mathmono</code></td>
-   <td>Chiffres mathématiques à chasse fixe</td>
-  </tr>
-  <tr>
-   <td><code>mathsanb</code></td>
-   <td>Chiffres mathématiques en gras sans empattements</td>
-  </tr>
-  <tr>
-   <td><code>mathsans</code></td>
-   <td>Chiffres mathématiques sans empattements</td>
-  </tr>
-  <tr>
-   <td><code>mlym</code></td>
-   <td>Chiffres Malayalams</td>
-  </tr>
-  <tr>
-   <td><code>modi</code></td>
-   <td>Chiffres Modis</td>
-  </tr>
-  <tr>
-   <td><code>mong</code></td>
-   <td>Chiffres mongols</td>
-  </tr>
-  <tr>
-   <td><code>mroo</code></td>
-   <td>Chiffres Mros</td>
-  </tr>
-  <tr>
-   <td><code>mtei</code></td>
-   <td>Chiffres Meetei Mayeks</td>
-  </tr>
-  <tr>
-   <td><code>mymr</code></td>
-   <td>Chiffres Myanmars</td>
-  </tr>
-  <tr>
-   <td><code>mymrshan</code></td>
-   <td>Chiffres Myanmar Shans</td>
-  </tr>
-  <tr>
-   <td><code>mymrtlng</code></td>
-   <td>Chiffres Myanmar Tai Laings</td>
-  </tr>
-  <tr>
-   <td><code>native</code></td>
-   <td>Chiffres natifs</td>
-  </tr>
-  <tr>
-   <td><code>newa</code></td>
-   <td>Chiffres Newas</td>
-  </tr>
-  <tr>
-   <td><code>nkoo</code></td>
-   <td>Chiffres N'Kos</td>
-  </tr>
-  <tr>
-   <td><code>olck</code></td>
-   <td>Chiffres Ol Chikis</td>
-  </tr>
-  <tr>
-   <td><code>orya</code></td>
-   <td>Chiffres Oriyas</td>
-  </tr>
-  <tr>
-   <td><code>osma</code></td>
-   <td>Chiffres Osmanyas</td>
-  </tr>
-  <tr>
-   <td><code>rohg</code></td>
-   <td>Chiffres Hanifi Rohingyas</td>
-  </tr>
-  <tr>
-   <td><code>roman</code></td>
-   <td>Numération romaine majuscule (algorithmique)</td>
-  </tr>
-  <tr>
-   <td><code>romanlow</code></td>
-   <td>Numération romaine minuscule (algorithmique)</td>
-  </tr>
-  <tr>
-   <td><code>saur</code></td>
-   <td>Chiffres Saurashtras</td>
-  </tr>
-  <tr>
-   <td><code>shrd</code></td>
-   <td>Chiffres Sharadas</td>
-  </tr>
-  <tr>
-   <td><code>sind</code></td>
-   <td>Chiffres Khudawadis</td>
-  </tr>
-  <tr>
-   <td><code>sinh</code></td>
-   <td>Chiffres Sinhala Liths</td>
-  </tr>
-  <tr>
-   <td><code>sora</code></td>
-   <td>Chiffres Sora_Sompengs</td>
-  </tr>
-  <tr>
-   <td><code>sund</code></td>
-   <td>Chiffres soudanais</td>
-  </tr>
-  <tr>
-   <td><code>takr</code></td>
-   <td>Chiffres Takris</td>
-  </tr>
-  <tr>
-   <td><code>talu</code></td>
-   <td>Chiffres New Tai Lues</td>
-  </tr>
-  <tr>
-   <td><code>taml</code></td>
-   <td>Numération tamoule (algorithmique=</td>
-  </tr>
-  <tr>
-   <td><code>tamldec</code></td>
-   <td>Chiffres tamouls décimaux modernes</td>
-  </tr>
-  <tr>
-   <td><code>telu</code></td>
-   <td>Chiffres Telugus</td>
-  </tr>
-  <tr>
-   <td><code>thai</code></td>
-   <td>Chiffres thaïs</td>
-  </tr>
-  <tr>
-   <td><code>tirh</code></td>
-   <td>Chiffres Tirhutas</td>
-  </tr>
-  <tr>
-   <td><code>tibt</code></td>
-   <td>Chiffres tibétains</td>
-  </tr>
-  <tr>
-   <td><code>traditio</code></td>
-   <td>Numération traditionnelle (peut être algorithmique)</td>
-  </tr>
-  <tr>
-   <td><code>vaii</code></td>
-   <td>Chiffres Vais</td>
-  </tr>
-  <tr>
-   <td><code>wara</code></td>
-   <td>Chiffres Warang Citis</td>
-  </tr>
-  <tr>
-   <td><code>wcho</code></td>
-   <td>Chiffres Wanchos</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Exemples">Exemples</h2>
-
-<h3 id="Définir_la_valeur_de_numberingSystem_grâce_à_la_chaîne_décrivant_la_locale">Définir la valeur de <code>numberingSystem</code> grâce à la chaîne décrivant la locale</h3>
-
-<p>D'après <a href="https://www.unicode.org/reports/tr35/" rel="noopener">la spécification Unicode sur les chaînes décrivant les locales</a>, l'extension décrivant le système de numération est indiquée par la clé <code>nu</code>.</p>
-
-<p>Le constructeur <code><a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Locale">Intl.locale</a></code> prend comme premier argument une chaîne de caractères décrivant la locale. Aussi, on peut indiquer le système de numération après les composantes principales de la chaîne de caractères en lui ajoutant un <code>"-u"</code> (indiquant la présence d'une extension), suivi d'un <code>"-nu"</code> (indiquant que l'extension qui sera indiquée décrit le système de numération, suivi de la valeur voulue pour le système de numération.</p>
-
-<pre class="brush: js">let numberingSystemViaStr = new Intl.Locale("fr-Latn-FR-u-nu-mong");
+{{JSRef}}
+
+La propriété **`Intl.Locale.prototype.numberingSystem`** est une propriété fournie par un accesseur qui renvoie le [système de numération](https://en.wikipedia.org/wiki/Numeral_system) utilisée par la locale.
+
+## Description
+
+Un système de numération est un système qui permet d'exprimer les nombres. La propriété `numberingSystem` permet de connaître le système de numérati Unicode. A table of the standard Unicode numeral systems can be seen belowon de la locale. Les valeurs qui peuvent être fournies par cette propriété sont standardisées par Unicode.
+
+| Valeur     | Description                                                                                             |
+| ---------- | ------------------------------------------------------------------------------------------------------- |
+| `adlm`     | Chiffres adlams                                                                                         |
+| `ahom`     | Chiffres ahoms                                                                                          |
+| `arab`     | Chiffres arabes                                                                                         |
+| `arabext`  | Chiffres arabes étendus                                                                                 |
+| `armn`     | Numération arménienne majuscule (algorithmique)                                                         |
+| `armnlow`  | Numération arménienne minuscule (algorithmique)                                                         |
+| `bali`     | Chiffres balinais                                                                                       |
+| `beng`     | Chiffres bengalis                                                                                       |
+| `bhks`     | Chiffres bhaiksuki                                                                                      |
+| `brah`     | Chiffres brahmis                                                                                        |
+| `cakm`     | Chiffres chakmas                                                                                        |
+| `cham`     | Chiffres chams                                                                                          |
+| `cyrl`     | Numération cyrillique (algorithmique)                                                                   |
+| `deva`     | Chiffres devanagaris                                                                                    |
+| `ethi`     | Numération éthiopienne (algorithmique)                                                                  |
+| `finance`  | Numération financière (peut être algorithmique)                                                         |
+| `fullwide` | Chiffres à pleine chasse                                                                                |
+| `geor`     | Numération géorgienne (algorithmique)                                                                   |
+| `gong`     | Chiffres Gunjala Gondis                                                                                 |
+| `gonm`     | Chiffres Masaram Gondis                                                                                 |
+| `grek`     | Numération greque majuscule (algorithmique)                                                             |
+| `greklow`  | Numération greque minuscule (algorithmique)                                                             |
+| `gujr`     | Chiffres Gujaratis                                                                                      |
+| `guru`     | Chiffres Gurmukhis                                                                                      |
+| `hanidays` | Numération du jour du mois avec caractère Han (utilisée avec les calendriers lunaires ou traditionnels) |
+| `hanidec`  | Système décimal positionnel utilisant les idéographes des nombres chinois comme chiffres                |
+| `hans`     | Numération chinoise simplifiée (algorithmique)                                                          |
+| `hansfin`  | Numération chinoise simplifiée financière (algorithmique)                                               |
+| `hant`     | Numération chinoise traditionnelle (algorithmique)                                                      |
+| `hantfin`  | Numération chinoise traditionnelle financière (algorithmique)                                           |
+| `hebr`     | Numération hébraïque (algorithmique)                                                                    |
+| `hmng`     | Chiffres Pahawh Hmongs                                                                                  |
+| `hmnp`     | Chiffres Nyiakeng Puachue Hmongs                                                                        |
+| `java`     | Chiffres javanais                                                                                       |
+| `jpan`     | Numération japonaise (algorithmique)                                                                    |
+| `jpanfin`  | Numération japonaise financière (algorithmique)                                                         |
+| `jpanyear` | Numération basée sur la première année Gannen du calendrier japonais                                    |
+| `kali`     | Chiffres Kayah Lis                                                                                      |
+| `khmr`     | Chiffres Khmers                                                                                         |
+| `knda`     | Chiffres Kannadas                                                                                       |
+| `lana`     | Chiffres Tai Tham Hora séculiers                                                                        |
+| `lanatham` | Chiffres Tai Tham Tham ecclésiastiques                                                                  |
+| `laoo`     | Chiffres laotien                                                                                        |
+| `latn`     | Chiffres latins                                                                                         |
+| `lepc`     | Chiffres Lepchas                                                                                        |
+| `limb`     | Chiffres Limbus                                                                                         |
+| `mathbold` | Chiffres mathématiques en gras                                                                          |
+| `mathdbl`  | Chiffres mathématiques barrés en double                                                                 |
+| `mathmono` | Chiffres mathématiques à chasse fixe                                                                    |
+| `mathsanb` | Chiffres mathématiques en gras sans empattements                                                        |
+| `mathsans` | Chiffres mathématiques sans empattements                                                                |
+| `mlym`     | Chiffres Malayalams                                                                                     |
+| `modi`     | Chiffres Modis                                                                                          |
+| `mong`     | Chiffres mongols                                                                                        |
+| `mroo`     | Chiffres Mros                                                                                           |
+| `mtei`     | Chiffres Meetei Mayeks                                                                                  |
+| `mymr`     | Chiffres Myanmars                                                                                       |
+| `mymrshan` | Chiffres Myanmar Shans                                                                                  |
+| `mymrtlng` | Chiffres Myanmar Tai Laings                                                                             |
+| `native`   | Chiffres natifs                                                                                         |
+| `newa`     | Chiffres Newas                                                                                          |
+| `nkoo`     | Chiffres N'Kos                                                                                          |
+| `olck`     | Chiffres Ol Chikis                                                                                      |
+| `orya`     | Chiffres Oriyas                                                                                         |
+| `osma`     | Chiffres Osmanyas                                                                                       |
+| `rohg`     | Chiffres Hanifi Rohingyas                                                                               |
+| `roman`    | Numération romaine majuscule (algorithmique)                                                            |
+| `romanlow` | Numération romaine minuscule (algorithmique)                                                            |
+| `saur`     | Chiffres Saurashtras                                                                                    |
+| `shrd`     | Chiffres Sharadas                                                                                       |
+| `sind`     | Chiffres Khudawadis                                                                                     |
+| `sinh`     | Chiffres Sinhala Liths                                                                                  |
+| `sora`     | Chiffres Sora_Sompengs                                                                                  |
+| `sund`     | Chiffres soudanais                                                                                      |
+| `takr`     | Chiffres Takris                                                                                         |
+| `talu`     | Chiffres New Tai Lues                                                                                   |
+| `taml`     | Numération tamoule (algorithmique=                                                                      |
+| `tamldec`  | Chiffres tamouls décimaux modernes                                                                      |
+| `telu`     | Chiffres Telugus                                                                                        |
+| `thai`     | Chiffres thaïs                                                                                          |
+| `tirh`     | Chiffres Tirhutas                                                                                       |
+| `tibt`     | Chiffres tibétains                                                                                      |
+| `traditio` | Numération traditionnelle (peut être algorithmique)                                                     |
+| `vaii`     | Chiffres Vais                                                                                           |
+| `wara`     | Chiffres Warang Citis                                                                                   |
+| `wcho`     | Chiffres Wanchos                                                                                        |
+
+## Exemples
+
+### Définir la valeur de `numberingSystem` grâce à la chaîne décrivant la locale
+
+D'après [la spécification Unicode sur les chaînes décrivant les locales](https://www.unicode.org/reports/tr35/), l'extension décrivant le système de numération est indiquée par la clé `nu`.
+
+Le constructeur [`Intl.locale`](/fr/docs/Web/JavaScript/Reference/Objets_globaux/Locale) prend comme premier argument une chaîne de caractères décrivant la locale. Aussi, on peut indiquer le système de numération après les composantes principales de la chaîne de caractères en lui ajoutant un `"-u"` (indiquant la présence d'une extension), suivi d'un `"-nu"` (indiquant que l'extension qui sera indiquée décrit le système de numération, suivi de la valeur voulue pour le système de numération.
+
+```js
+let numberingSystemViaStr = new Intl.Locale("fr-Latn-FR-u-nu-mong");
 console.log(numberingSystemStr.numberingSystem);
-// affichera "mong" dans la console</pre>
+// affichera "mong" dans la console
+```
 
-<h3 id="Définir_la_valeur_de_numberingSystem_grâce_à_un_objet_de_configuration">Définir la valeur de <code>numberingSystem</code> grâce à un objet de configuration</h3>
+### Définir la valeur de `numberingSystem` grâce à un objet de configuration
 
-<p>Le constructeur <a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Locale" title="The Intl.Locale constructor is a standard built-in property of the Intl object."><code>Intl.Locale</code></a> possède un deuxième argument, optionnel, qui est un objet permettant de configurer la locale. Les propriétés de cet objet sont utilisées comme extensions pour la locale ; les clés des propriétés sont les noms des extensions et leurs valeurs sont celles utilisées pour chaque extension. On peut donc utiliser la propriété <code>numberingSystem</code> sur cet objet afin de définir le système de numération à utiliser pour cette locale.</p>
+Le constructeur [`Intl.Locale`](/fr/docs/Web/JavaScript/Reference/Objets_globaux/Locale "The Intl.Locale constructor is a standard built-in property of the Intl object.") possède un deuxième argument, optionnel, qui est un objet permettant de configurer la locale. Les propriétés de cet objet sont utilisées comme extensions pour la locale ; les clés des propriétés sont les noms des extensions et leurs valeurs sont celles utilisées pour chaque extension. On peut donc utiliser la propriété `numberingSystem` sur cet objet afin de définir le système de numération à utiliser pour cette locale.
 
-<pre class="brush: js">let numberingSystemViaObj= new Intl.Locale("en-Latn-US", {numberingSystem: "latn"});
+```js
+let numberingSystemViaObj= new Intl.Locale("en-Latn-US", {numberingSystem: "latn"});
 console.log(us12hour.numberingSystem);
 // affichera "latn" dans la console
-</pre>
+```
 
-<h2 id="Spécifications">Spécifications</h2>
+## Spécifications
 
-<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><a href="https://tc39.github.io/proposal-intl-locale/#sec-Intl.Locale.prototype.numberingSystem">Proposition pour <code>Intl.Locale</code></a></td>
-   <td>Proposition de niveau 3</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
+| Spécification                                                                                                            | État                    | Commentaires |
+| ------------------------------------------------------------------------------------------------------------------------ | ----------------------- | ------------ |
+| [Proposition pour `Intl.Locale`](https://tc39.github.io/proposal-intl-locale/#sec-Intl.Locale.prototype.numberingSystem) | Proposition de niveau 3 |              |
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<div>{{Compat("javascript.builtins.Intl.Locale.numberingSystem")}}</div>
+{{Compat("javascript.builtins.Intl.Locale.numberingSystem")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("Locale", "Intl.Locale")}}</li>
- <li><a href="https://github.com/unicode-org/cldr/blob/master/common/supplemental/numberingSystems.xml">Détails sur les systèmes de numération dans le standard Unicode</a></li>
-</ul>
+- {{jsxref("Locale", "Intl.Locale")}}
+- [Détails sur les systèmes de numération dans le standard Unicode](https://github.com/unicode-org/cldr/blob/master/common/supplemental/numberingSystems.xml)
diff --git a/files/fr/web/javascript/reference/global_objects/intl/locale/numeric/index.md b/files/fr/web/javascript/reference/global_objects/intl/locale/numeric/index.md
index d38122f7be..7d9b8d02f4 100644
--- a/files/fr/web/javascript/reference/global_objects/intl/locale/numeric/index.md
+++ b/files/fr/web/javascript/reference/global_objects/intl/locale/numeric/index.md
@@ -11,58 +11,46 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Intl/Locale/numeric
 original_slug: Web/JavaScript/Reference/Objets_globaux/Intl/Locale/numeric
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La propriété <strong><code>Intl.Locale.prototype.numeric</code></strong> est une propriété fournie par un accesseur et qui indique si la locale possède une collation spécifique pour les caractères numériques (la collation étant la méthode qui permet d'ordonner des chaînes de caractères entre elles).</p>
+La propriété **`Intl.Locale.prototype.numeric`** est une propriété fournie par un accesseur et qui indique si la locale possède une collation spécifique pour les caractères numériques (la collation étant la méthode qui permet d'ordonner des chaînes de caractères entre elles).
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>À l'instar de {{jsxref("Locale.caseFirst", "Intl.Locale.caseFirst")}}, <code>numeric</code> représente une modification des règles de collation utilisée par la locale. <code>numeric</code> est un booléen (<code>true</code> ou <code>false</code>). Lorsque cette propriété vaut <code>false</code>, il n'y a pas de gestion particulière des chiffres et si cette propriété vaut <code>true</code>, cela indique que les caractères numériques sont pris en compte lors de la collation des chaînes. Ainsi, les séquences de chiffres décimaux seront comparés comme des nombres. Ainsi, la chaîne de caractères <code>"A-21"</code> sera considérée inférieure à <code>"A-123"</code>.</p>
+À l'instar de {{jsxref("Locale.caseFirst", "Intl.Locale.caseFirst")}}, `numeric` représente une modification des règles de collation utilisée par la locale. `numeric` est un booléen (`true` ou `false`). Lorsque cette propriété vaut `false`, il n'y a pas de gestion particulière des chiffres et si cette propriété vaut `true`, cela indique que les caractères numériques sont pris en compte lors de la collation des chaînes. Ainsi, les séquences de chiffres décimaux seront comparés comme des nombres. Ainsi, la chaîne de caractères `"A-21"` sera considérée inférieure à `"A-123"`.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Définir_numeric_grâce_à_la_chaîne_de_description_de_la_locale">Définir <code>numeric</code> grâce à la chaîne de description de la locale</h3>
+### Définir `numeric` grâce à la chaîne de description de la locale
 
-<p>Selon <a href="https://www.unicode.org/reports/tr35/" rel="noopener">la spécification Unicode sur les chaînes de caractères décrivant les locales</a>, les valeurs de <code>numeric</code> sont associées à la clé <code>kn</code>. Pour utiliser cette clé dans la chaîne de description de la locale (le premier argument de <a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Locale" title="The Intl.Locale constructor is a standard built-in property of the Intl object."><code>Intl.Locale</code></a>), après la chaîne de base, on pourra ajouter un suffixe avec <code>"-u"</code> afin d'indiquer la présence d'une extension, puis <code>"-kn"</code> afin de préciser l'extension en question et enfin la valeur souhaitée pour cette extension. Si on veut que <code>numeric</code> soit <code>true</code>, il suffit d'ajouter la clé <code>kn</code>. Pour indiquer la valeur <code>false</code>, il faudra explicitement ajouter <code>"-false"</code>.</p>
+Selon [la spécification Unicode sur les chaînes de caractères décrivant les locales](https://www.unicode.org/reports/tr35/), les valeurs de `numeric` sont associées à la clé `kn`. Pour utiliser cette clé dans la chaîne de description de la locale (le premier argument de [`Intl.Locale`](/fr/docs/Web/JavaScript/Reference/Objets_globaux/Locale "The Intl.Locale constructor is a standard built-in property of the Intl object.")), après la chaîne de base, on pourra ajouter un suffixe avec `"-u"` afin d'indiquer la présence d'une extension, puis `"-kn"` afin de préciser l'extension en question et enfin la valeur souhaitée pour cette extension. Si on veut que `numeric` soit `true`, il suffit d'ajouter la clé `kn`. Pour indiquer la valeur `false`, il faudra explicitement ajouter `"-false"`.
 
-<pre class="brush: js">let numericViaStr = new Intl.Locale("fr-Latn-FR-u-kn-false");
+```js
+let numericViaStr = new Intl.Locale("fr-Latn-FR-u-kn-false");
 console.log(numericStr.numeric);
-// Affichera "false" dans la console</pre>
+// Affichera "false" dans la console
+```
 
-<h3 id="Définir_numeric_via_lobjet_de_configuration_de_linstance">Définir <code>numeric</code> via l'objet de configuration de l'instance</h3>
+### Définir `numeric` via l'objet de configuration de l'instance
 
-<p>Le constructeur <a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Locale" title="The Intl.Locale constructor is a standard built-in property of the Intl object."><code>Intl.Locale</code></a> possède un deuxième argument, optionnel, qui est un objet permettant de configurer la locale. Les propriétés de cet objet sont utilisées comme extensions pour la locale ; les clés des propriétés sont les noms des extensions et leurs valeurs sont celles utilisées pour chaque extension. On peut donc utiliser la propriété <code>numeric</code> sur cet objet afin de définir le système de numération à utiliser pour cette locale.</p>
+Le constructeur [`Intl.Locale`](/fr/docs/Web/JavaScript/Reference/Objets_globaux/Locale "The Intl.Locale constructor is a standard built-in property of the Intl object.") possède un deuxième argument, optionnel, qui est un objet permettant de configurer la locale. Les propriétés de cet objet sont utilisées comme extensions pour la locale ; les clés des propriétés sont les noms des extensions et leurs valeurs sont celles utilisées pour chaque extension. On peut donc utiliser la propriété `numeric` sur cet objet afin de définir le système de numération à utiliser pour cette locale.
 
-<pre class="brush: js">let numericViaObj= new Intl.Locale("en-Latn-US", {numeric: true});
+```js
+let numericViaObj= new Intl.Locale("en-Latn-US", {numeric: true});
 console.log(us12hour.numeric);
 // Affichera "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><a href="https://tc39.github.io/proposal-intl-locale/#sec-Intl.Locale.prototype.numeric">Proposition pour <code>Intl.Locale</code></a></td>
-   <td>Proposition de niveau 3</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<div>{{Compat("javascript.builtins.Intl.Locale.numeric")}}</div>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Locale", "Intl.Locale")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                    | État                    | Commentaires |
+| ---------------------------------------------------------------------------------------------------------------- | ----------------------- | ------------ |
+| [Proposition pour `Intl.Locale`](https://tc39.github.io/proposal-intl-locale/#sec-Intl.Locale.prototype.numeric) | Proposition de niveau 3 |              |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Intl.Locale.numeric")}}
+
+## Voir aussi
+
+- {{jsxref("Locale", "Intl.Locale")}}
diff --git a/files/fr/web/javascript/reference/global_objects/intl/locale/region/index.md b/files/fr/web/javascript/reference/global_objects/intl/locale/region/index.md
index 603db078a8..d3430cbde4 100644
--- a/files/fr/web/javascript/reference/global_objects/intl/locale/region/index.md
+++ b/files/fr/web/javascript/reference/global_objects/intl/locale/region/index.md
@@ -11,60 +11,49 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Intl/Locale/region
 original_slug: Web/JavaScript/Reference/Objets_globaux/Intl/Locale/region
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La propriété <strong><code>Intl.Locale.prototype.region</code></strong> est fournie par un accesseur qui renvoie la région du monde (il s'agit généralement d'un pays) associée à la locale courante.</p>
+La propriété **`Intl.Locale.prototype.region`** est fournie par un accesseur qui renvoie la région du monde (il s'agit généralement d'un pays) associée à la locale courante.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La région est un fragment majeur de l'identifiant de la locale car il situe la locale dans une zone donnée du monde. Connaître la région associée à la locale est crucial pour identifier les différences entre les locales. Ainsi, on parle anglais aux États-Unis et au Royaume-Uni mais il existe certaines différences d'orthographe entre ces pays. Connaître la région d'une locale peut permettre aux développeurs d'adapter leurs sites et applications selon la région depuis laquelle ils sont consultés.</p>
+La région est un fragment majeur de l'identifiant de la locale car il situe la locale dans une zone donnée du monde. Connaître la région associée à la locale est crucial pour identifier les différences entre les locales. Ainsi, on parle anglais aux États-Unis et au Royaume-Uni mais il existe certaines différences d'orthographe entre ces pays. Connaître la région d'une locale peut permettre aux développeurs d'adapter leurs sites et applications selon la région depuis laquelle ils sont consultés.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Définir_la_région_avec_la_chaîne_de_caractères_décrivant_la_locale">Définir la région avec la chaîne de caractères décrivant la locale</h3>
+### Définir la région avec la chaîne de caractères décrivant la locale
 
-<p>La région est la troisième composante d'une chaîne représentant un identifiant de langue Unicode. Cette chaîne de caractères est généralement passée au constructeur {{jsxref("Locale", "Locale")}}.</p>
+La région est la troisième composante d'une chaîne représentant un identifiant de langue Unicode. Cette chaîne de caractères est généralement passée au constructeur {{jsxref("Locale", "Locale")}}.
 
-<pre class="brush: js">let regionStr = new Intl.Locale("en-Latn-US");
+```js
+let regionStr = new Intl.Locale("en-Latn-US");
 
 console.log(regionStr.region);
-// Affichera "US" dans la console</pre>
+// Affichera "US" dans la console
+```
 
-<h3 id="Définir_la_région_via_lobjet_de_configuration_du_constructeur">Définir la région via l'objet de configuration du constructeur</h3>
+### Définir la région via l'objet de configuration du constructeur
 
-<p>Le constructeur {{jsxref("Locale", "Locale")}} prend comme second argument un objet de paramétrage dont chacune des propriétés permet de définir une extension ou une composante de la locale.</p>
+Le constructeur {{jsxref("Locale", "Locale")}} prend comme second argument un objet de paramétrage dont chacune des propriétés permet de définir une extension ou une composante de la locale.
 
-<pre class="brush: js">let regionObj = new Intl.Locale("fr-Latn", {region: "FR"});
+```js
+let regionObj = new Intl.Locale("fr-Latn", {region: "FR"});
 
 console.log(regionObj.region);
-// Affichera "FR" 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><a href="https://tc39.github.io/proposal-intl-locale/#sec-Intl.Locale.prototype.region">Proposition pour <code>Intl.Locale.prototype.region</code></a></td>
-   <td>Proposition de niveau 3</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<div>{{Compat("javascript.builtins.Intl.Locale.region")}}</div>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Locale", "Intl.Locale")}}</li>
- <li><a href="https://www.unicode.org/cldr/charts/latest/supplemental/territory_containment_un_m_49.html">Tableau Unicode des régions</a></li>
-</ul>
+// Affichera "FR" dans la console
+```
+
+## Spécifications
+
+| Spécification                                                                                                                    | État                    | Commentaires |
+| -------------------------------------------------------------------------------------------------------------------------------- | ----------------------- | ------------ |
+| [Proposition pour `Intl.Locale.prototype.region`](https://tc39.github.io/proposal-intl-locale/#sec-Intl.Locale.prototype.region) | Proposition de niveau 3 |              |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Intl.Locale.region")}}
+
+## Voir aussi
+
+- {{jsxref("Locale", "Intl.Locale")}}
+- [Tableau Unicode des régions](https://www.unicode.org/cldr/charts/latest/supplemental/territory_containment_un_m_49.html)
diff --git a/files/fr/web/javascript/reference/global_objects/intl/locale/script/index.md b/files/fr/web/javascript/reference/global_objects/intl/locale/script/index.md
index 138d442ed8..ecafc1ab87 100644
--- a/files/fr/web/javascript/reference/global_objects/intl/locale/script/index.md
+++ b/files/fr/web/javascript/reference/global_objects/intl/locale/script/index.md
@@ -10,58 +10,47 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Intl/Locale/script
 original_slug: Web/JavaScript/Reference/Objets_globaux/Intl/Locale/script
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La propriété <strong><code>Intl.Locale.prototype.script</code></strong> est fournie via un accesseur et renvoie le script utilisé pour l'écriture d'une langue donnée pour la locale courante.</p>
+La propriété **`Intl.Locale.prototype.script`** est fournie via un accesseur et renvoie le script utilisé pour l'écriture d'une langue donnée pour la locale courante.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Un script, ou système d'écriture, est l'une des caractéristiques fondamentales d'une locale. Il décrit l'ensemble des symboles (ou glyphes) qui sont utilisés pour écrire dans une langue donnée. Ainsi, le script associé à l'anglais est l'alphabet latin, le script associé au coréen est le Hangul. Dans la plupart des cas, indiquer le script n'est pas strictement nécessaire car une langue ne s'écrit que dans un script donné. Il existe toutefois des exceptions et il est préférable d'indique le script afin d'avoir un identifiant de langue Unicode complet.</p>
+Un script, ou système d'écriture, est l'une des caractéristiques fondamentales d'une locale. Il décrit l'ensemble des symboles (ou glyphes) qui sont utilisés pour écrire dans une langue donnée. Ainsi, le script associé à l'anglais est l'alphabet latin, le script associé au coréen est le Hangul. Dans la plupart des cas, indiquer le script n'est pas strictement nécessaire car une langue ne s'écrit que dans un script donné. Il existe toutefois des exceptions et il est préférable d'indique le script afin d'avoir un identifiant de langue Unicode complet.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Définir_le_script_via_la_chaîne_de_description_de_la_locale">Définir le script via la chaîne de description de la locale</h3>
+### Définir le script via la chaîne de description de la locale
 
-<p>Le script correspond à la deuxième partie d'un identifiant de langue Unicode valide. On peut donc le définir en passant un tel identifiant au constructeur {{jsxref("Locale", "Locale")}}. Toutefois, cette composante n'est pas obligatoire pour créer une instance de <code>Locale</code>.</p>
+Le script correspond à la deuxième partie d'un identifiant de langue Unicode valide. On peut donc le définir en passant un tel identifiant au constructeur {{jsxref("Locale", "Locale")}}. Toutefois, cette composante n'est pas obligatoire pour créer une instance de `Locale`.
 
-<pre class="brush: js">let scriptStr = new Intl.Locale("en-Latn-US");
+```js
+let scriptStr = new Intl.Locale("en-Latn-US");
 
-console.log(scriptStr.script); // Affichera "Latn" dans la console</pre>
+console.log(scriptStr.script); // Affichera "Latn" dans la console
+```
 
-<h3 id="Définir_le_script_grâce_à_lobjet_de_configuration_du_constructeur">Définir le script grâce à l'objet de configuration du constructeur</h3>
+### Définir le script grâce à l'objet de configuration du constructeur
 
-<p>Le constructeur {{jsxref("Locale", "Locale")}} permet d'utiliser un objet de configuration dont les propriétés définiront les caractéristiques de la locale :</p>
+Le constructeur {{jsxref("Locale", "Locale")}} permet d'utiliser un objet de configuration dont les propriétés définiront les caractéristiques de la locale :
 
-<pre class="brush: js">let scriptObj = new Intl.Locale("fr-FR", {script: "Latn"});
+```js
+let scriptObj = new Intl.Locale("fr-FR", {script: "Latn"});
 
-console.log(scriptObj.script); // Affichera "Latn" dans la console</pre>
+console.log(scriptObj.script); // Affichera "Latn" dans la console
+```
 
-<h2 id="Spécifications">Spécifications</h2>
+## Spécifications
 
-<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><a href="https://tc39.github.io/proposal-intl-locale/#sec-Intl.Locale.prototype.script">Proposition pour <code>Intl.Locale.prototype.script</code></a></td>
-   <td>Proposition de niveau 3</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
+| Spécification                                                                                                                    | État                    | Commentaires |
+| -------------------------------------------------------------------------------------------------------------------------------- | ----------------------- | ------------ |
+| [Proposition pour `Intl.Locale.prototype.script`](https://tc39.github.io/proposal-intl-locale/#sec-Intl.Locale.prototype.script) | Proposition de niveau 3 |              |
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<div>{{Compat("javascript.builtins.Intl.Locale.script")}}</div>
+{{Compat("javascript.builtins.Intl.Locale.script")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("Locale", "Intl.Locale")}}</li>
- <li><a href="https://www.unicode.org/reports/tr35/#unicode_script_subtag_validity">Spécification Unicode pour la composante script</a></li>
-</ul>
+- {{jsxref("Locale", "Intl.Locale")}}
+- [Spécification Unicode pour la composante script](https://www.unicode.org/reports/tr35/#unicode_script_subtag_validity)
diff --git a/files/fr/web/javascript/reference/global_objects/intl/locale/tostring/index.md b/files/fr/web/javascript/reference/global_objects/intl/locale/tostring/index.md
index 96e0b7767b..e25a84aadc 100644
--- a/files/fr/web/javascript/reference/global_objects/intl/locale/tostring/index.md
+++ b/files/fr/web/javascript/reference/global_objects/intl/locale/tostring/index.md
@@ -10,57 +10,43 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Intl/Locale/toString
 original_slug: Web/JavaScript/Reference/Objets_globaux/Intl/Locale/toString
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>Intl.Locale.prototype.toString()</code></strong> renvoie <a href="https://www.unicode.org/reports/tr35/#Unicode_locale_identifier">l'identifiant de locale complet</a> pour la locale courante.</p>
+La méthode **`Intl.Locale.prototype.toString()`** renvoie [l'identifiant de locale complet](https://www.unicode.org/reports/tr35/#Unicode_locale_identifier) pour la locale courante.
 
-<p>{{EmbedInteractiveExample("pages/js/intl-locale-prototype-tostring.html")}}</p>
+{{EmbedInteractiveExample("pages/js/intl-locale-prototype-tostring.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><code><em>locale</em>.toString()</code></pre>
+    locale.toString()
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>La chaîne de caractères représentant l'identifiant complet de la locale.</p>
+La chaîne de caractères représentant l'identifiant complet de la locale.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Une instance de <code>Locale</code> est une représentation JavaScript d'une locale au sens Unicode. Les informations décrivant une locale donnée (la langue, le système d'écriture, le type de calendrier, etc.) peuvent être encodées en une chaîne de caractères qui est l'identifiant de la locale. Lorsqu'on appelle la méthode <code>toString()</code> sur une instance de <code>Locale</code>, on obtiendra l'identifiant complet de la locale.</p>
+Une instance de `Locale` est une représentation JavaScript d'une locale au sens Unicode. Les informations décrivant une locale donnée (la langue, le système d'écriture, le type de calendrier, etc.) peuvent être encodées en une chaîne de caractères qui est l'identifiant de la locale. Lorsqu'on appelle la méthode `toString()` sur une instance de `Locale`, on obtiendra l'identifiant complet de la locale.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<pre class="brush: js">let maLocale = new Intl.Locale("fr-Latn-FR", {hourCycle: "h24", calendar: "gregory"});
+```js
+let maLocale = new Intl.Locale("fr-Latn-FR", {hourCycle: "h24", calendar: "gregory"});
 console.log(maLocale.baseName); // Affiche "fr-Latn-FR"
 console.log(maLocale.toString()); // Affiche "fr-Latn-FR-u-ca-gregory-hc-h24"
-</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><a href="https://tc39.github.io/proposal-intl-locale/#sec-Intl.Locale.prototype.toString">Proposition pour <code>Intl.Locale.prototype.toString()</code></a></td>
-   <td>Proposition de niveau 3</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Intl.Locale.toString")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Locale", "Intl.Locale")}}</li>
- <li>{{jsxref("Locale/baseName", "Intl.Locale.baseName")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                                          | État                    | Commentaires |
+| -------------------------------------------------------------------------------------------------------------------------------------- | ----------------------- | ------------ |
+| [Proposition pour `Intl.Locale.prototype.toString()`](https://tc39.github.io/proposal-intl-locale/#sec-Intl.Locale.prototype.toString) | Proposition de niveau 3 |              |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Intl.Locale.toString")}}
+
+## Voir aussi
+
+- {{jsxref("Locale", "Intl.Locale")}}
+- {{jsxref("Locale/baseName", "Intl.Locale.baseName")}}
diff --git a/files/fr/web/javascript/reference/global_objects/intl/numberformat/format/index.md b/files/fr/web/javascript/reference/global_objects/intl/numberformat/format/index.md
index d912f25f6f..bac7a3220c 100644
--- a/files/fr/web/javascript/reference/global_objects/intl/numberformat/format/index.md
+++ b/files/fr/web/javascript/reference/global_objects/intl/numberformat/format/index.md
@@ -13,82 +13,63 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat/format
 original_slug: Web/JavaScript/Reference/Objets_globaux/Intl/NumberFormat/format
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>Intl.NumberFormat.prototype.format()</strong></code> formate un nombre en fonction des options de locales et de formats définis dans l'objet {{jsxref("NumberFormat", "Intl.NumberFormat")}} correspondant.</p>
+La méthode **`Intl.NumberFormat.prototype.format()`** formate un nombre en fonction des options de locales et de formats définis dans l'objet {{jsxref("NumberFormat", "Intl.NumberFormat")}} correspondant.
 
-<div>{{EmbedInteractiveExample("pages/js/intl-numberformat-prototype-format.html")}}</div>
+{{EmbedInteractiveExample("pages/js/intl-numberformat-prototype-format.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>numberFormat</var>.format(<var>nombre</var>)</pre>
+    numberFormat.format(nombre)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>nombre</code></dt>
- <dd>Le nombre qu'on souhaite formater.</dd>
-</dl>
+- `nombre`
+  - : Le nombre qu'on souhaite formater.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La fonction d'accesseur <code>format</code> permet de formater un nombre donné en une chaîne de caractères selon les options de locale et de format de l'objet {{jsxref("NumberFormat", "Intl.NumberFormat")}}.</p>
+La fonction d'accesseur `format` permet de formater un nombre donné en une chaîne de caractères selon les options de locale et de format de l'objet {{jsxref("NumberFormat", "Intl.NumberFormat")}}.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_format">Utiliser <code>format()</code></h3>
+### Utiliser `format()`
 
-<p>On peut utiliser la fonction renvoyée par <code>format</code> pour formater une valeur monétaire selon la locale russe :</p>
+On peut utiliser la fonction renvoyée par `format` pour formater une valeur monétaire selon la locale russe :
 
-<pre class="brush: js">var options = {style: "currency", currency: "RUB"};
+```js
+var options = {style: "currency", currency: "RUB"};
 var numberFormat = new Intl.NumberFormat("ru-RU", options);
 console.log(numberFormat.format(654321.987));
-// → "654 321,99 руб."</pre>
+// → "654 321,99 руб."
+```
 
-<h3 id="Utiliser_format_avec_map">Utiliser <code>format()</code> avec <code>map()</code></h3>
+### Utiliser `format()` avec `map()`
 
-<p>On peut également utiliser la fonction <code>format</code> pour formater les nombres contenus dans un tableau. On notera que la fonction est liée à l'objet <code>NumberFormat</code> dont elle provient, on peut donc directement l'utiliser avec {{jsxref("Array.prototype.map")}}.</p>
+On peut également utiliser la fonction `format` pour formater les nombres contenus dans un tableau. On notera que la fonction est liée à l'objet `NumberFormat` dont elle provient, on peut donc directement l'utiliser avec {{jsxref("Array.prototype.map")}}.
 
-<pre class="brush: js">var a = [123456.789, 987654.321, 456789.123];
+```js
+var a = [123456.789, 987654.321, 456789.123];
 var numberFormat = new Intl.NumberFormat("es-ES");
 var formatted = a.map(numberFormat.format);
 console.log(formatted.join("; "));
-// → "123.456,789; 987.654,321; 456.789,123"</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('ES Int 1.0', '#sec-11.3.2', 'Intl.NumberFormat.prototype.format')}}</td>
-   <td>{{Spec2('ES Int 1.0')}}</td>
-   <td>Définition initiale</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES Int 2.0', '#sec-11.3.2', 'Intl.NumberFormat.prototype.format')}}</td>
-   <td>{{Spec2('ES Int 2.0')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES Int Draft', '#sec-Intl.NumberFormat.prototype.format', 'Intl.NumberFormat.prototype.format')}}</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.Intl.NumberFormat.format")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("NumberFormat", "Intl.NumberFormat")}}</li>
- <li>{{jsxref("Number.prototype.toLocaleString()")}}</li>
-</ul>
+// → "123.456,789; 987.654,321; 456.789,123"
+```
+
+## Spécifications
+
+| Spécification                                                                                                                                    | État                             | Commentaires        |
+| ------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------- | ------------------- |
+| {{SpecName('ES Int 1.0', '#sec-11.3.2', 'Intl.NumberFormat.prototype.format')}}                                         | {{Spec2('ES Int 1.0')}} | Définition initiale |
+| {{SpecName('ES Int 2.0', '#sec-11.3.2', 'Intl.NumberFormat.prototype.format')}}                                         | {{Spec2('ES Int 2.0')}} |                     |
+| {{SpecName('ES Int Draft', '#sec-Intl.NumberFormat.prototype.format', 'Intl.NumberFormat.prototype.format')}} | {{Spec2('ES Int Draft')}} |                     |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Intl.NumberFormat.format")}}
+
+## Voir aussi
+
+- {{jsxref("NumberFormat", "Intl.NumberFormat")}}
+- {{jsxref("Number.prototype.toLocaleString()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/intl/numberformat/formattoparts/index.md b/files/fr/web/javascript/reference/global_objects/intl/numberformat/formattoparts/index.md
index caadb942cb..66f86323c6 100644
--- a/files/fr/web/javascript/reference/global_objects/intl/numberformat/formattoparts/index.md
+++ b/files/fr/web/javascript/reference/global_objects/intl/numberformat/formattoparts/index.md
@@ -12,67 +12,66 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat/formatToParts
 original_slug: Web/JavaScript/Reference/Objets_globaux/Intl/NumberFormat/formatToParts
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>Intl.Numberformat.prototype.formatToParts()</code></strong> permet de produire des fragments de chaînes à partir d'un nombre pour le mettre en forme avec des formateurs <code>NumberTimeFormat</code>.</p>
+La méthode **`Intl.Numberformat.prototype.formatToParts()`** permet de produire des fragments de chaînes à partir d'un nombre pour le mettre en forme avec des formateurs `NumberTimeFormat`.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">Intl.NumberFormat.prototype.formatToParts(nombre)</pre>
+    Intl.NumberFormat.prototype.formatToParts(nombre)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>nombre</code> {{optional_inline}}</dt>
- <dd>Le nombre qu'on souhaite mettre en forme.</dd>
-</dl>
+- `nombre` {{optional_inline}}
+  - : Le nombre qu'on souhaite mettre en forme.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un tableau {{jsxref("Array")}} contenant des objets correspondants aux différents fragments du nombres.</p>
+Un tableau {{jsxref("Array")}} contenant des objets correspondants aux différents fragments du nombres.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La méthode <code>formatToParts()</code> est peut être utilisée lorsqu'on met en forme des chaînes de caractères représentant des valeurs numériques. Cette méthode renvoie un tableau ({{jsxref("Array")}}) d'objets qui sont les différents fragments spécifiques aux locales et qui permettent de construire des chaînes dans un format spécifiques tout en conservant les parties liées à la locale. <code>formatToParts()</code> renvoie une structure analogue à :</p>
+La méthode `formatToParts()` est peut être utilisée lorsqu'on met en forme des chaînes de caractères représentant des valeurs numériques. Cette méthode renvoie un tableau ({{jsxref("Array")}}) d'objets qui sont les différents fragments spécifiques aux locales et qui permettent de construire des chaînes dans un format spécifiques tout en conservant les parties liées à la locale. `formatToParts()` renvoie une structure analogue à :
 
-<pre class="brush: js">[
+```js
+[
   { type: "integer", value: "3" }
   { type: "group", value: "." }
   { type: "integer", value: "500" }
-]</pre>
-
-<p>Les valeurs possibles pour l'attribut <code>type</code> sont :</p>
-
-<dl>
- <dt><code>currency</code></dt>
- <dd>Le suffixe associé à la devise. Ce peut être le symbole "$", "€" ou bien le nom de la devise "Dollar", "Euro" selon la façon dont <code>currencyDisplay</code>  est indiquée.</dd>
- <dt><code>decimal</code></dt>
- <dd>Le séparateur décimal utilisé (".").</dd>
- <dt><code>fraction</code></dt>
- <dd>La partie fractionnaire du nombre.</dd>
- <dt><code>group</code></dt>
- <dd>La chaîne de caractères utilisée pour indiquer un groupe (",").</dd>
- <dt><code>infinity</code></dt>
- <dd>La chaîne de caractères qui représente la valeur {{jsxref("Infinity")}} ("∞").</dd>
- <dt><code>integer</code></dt>
- <dd>La partie entière du nombre.</dd>
- <dt><code>literal</code></dt>
- <dd>Toute chaîne de caractères littérale ou blanc utilisée dans le nombre mis en forme.</dd>
- <dt><code>minusSign</code></dt>
- <dd>La chaîne de caractères utilisée pour le signe moins ("-").</dd>
- <dt><code>nan</code></dt>
- <dd>La chaîne de caractères utilisée pour représenter la valeur {{jsxref("NaN")}} ("NaN").</dd>
- <dt><code>plusSign</code></dt>
- <dd>La chaîne de caractères utilisée pour le signe plus ("+").</dd>
- <dt><code>percentSign</code></dt>
- <dd>La châine de caractères utilisée pour le symbole pourcent ("%").</dd>
-</dl>
-
-<h2 id="Exemples">Exemples</h2>
-
-<p><code>NumberFormat</code> produit une chaîne localisée opaque qui ne peut pas être manipulée directement :</p>
-
-<pre class="brush: js">var number = 3500;
+]
+```
+
+Les valeurs possibles pour l'attribut `type` sont :
+
+- `currency`
+  - : Le suffixe associé à la devise. Ce peut être le symbole "$", "€" ou bien le nom de la devise "Dollar", "Euro" selon la façon dont `currencyDisplay`  est indiquée.
+- `decimal`
+  - : Le séparateur décimal utilisé (".").
+- `fraction`
+  - : La partie fractionnaire du nombre.
+- `group`
+  - : La chaîne de caractères utilisée pour indiquer un groupe (",").
+- `infinity`
+  - : La chaîne de caractères qui représente la valeur {{jsxref("Infinity")}} ("∞").
+- `integer`
+  - : La partie entière du nombre.
+- `literal`
+  - : Toute chaîne de caractères littérale ou blanc utilisée dans le nombre mis en forme.
+- `minusSign`
+  - : La chaîne de caractères utilisée pour le signe moins ("-").
+- `nan`
+  - : La chaîne de caractères utilisée pour représenter la valeur {{jsxref("NaN")}} ("NaN").
+- `plusSign`
+  - : La chaîne de caractères utilisée pour le signe plus ("+").
+- `percentSign`
+  - : La châine de caractères utilisée pour le symbole pourcent ("%").
+
+## Exemples
+
+`NumberFormat` produit une chaîne localisée opaque qui ne peut pas être manipulée directement :
+
+```js
+var number = 3500;
 
 var formatter = new Intl.NumberFormat('de-DE', {
   style: 'currency',
@@ -81,11 +80,12 @@ var formatter = new Intl.NumberFormat('de-DE', {
 
 formatter.format(number);
 // "3.500,00 €"
-</pre>
+```
 
-<p>Toutefois, pour certaines applications, on souhaite adapter la mise en forme de cette chaîne de caractères. La méthode <code>formatToParts</code> permet d'obtenir cette flexibilité tout en conservant les différents fragments produits par <code>NumberFormat</code> :</p>
+Toutefois, pour certaines applications, on souhaite adapter la mise en forme de cette chaîne de caractères. La méthode `formatToParts` permet d'obtenir cette flexibilité tout en conservant les différents fragments produits par `NumberFormat` :
 
-<pre class="brush: js">formatter.formatToParts(number);
+```js
+formatter.formatToParts(number);
 
 // return value:
 [
@@ -97,52 +97,42 @@ formatter.format(number);
   { type: "literal",  value: " "   }
   { type: "currency", value: "€"   }
 ]
-</pre>
+```
 
-<p>Maintenant que la chaîne est décomposée, on peut la réassembler d'une façon spécifique. On peut, par exemple utiliser {{jsxref("Array.prototype.map()")}}, <a href="/fr/docs/Web/JavaScript/Reference/Fonctions/Fonctions_fléchées">une fonction fléchée</a>, une <a href="/fr/docs/Web/JavaScript/Reference/Instructions/switch">instruction <code>switch</code></a>, <a href="/fr/docs/Web/JavaScript/Reference/Littéraux_gabarits">des littéraux de gabarits</a> et {{jsxref("Array.prototype.reduce()")}}.</p>
+Maintenant que la chaîne est décomposée, on peut la réassembler d'une façon spécifique. On peut, par exemple utiliser {{jsxref("Array.prototype.map()")}}, [une fonction fléchée](/fr/docs/Web/JavaScript/Reference/Fonctions/Fonctions_fléchées), une [instruction `switch`](/fr/docs/Web/JavaScript/Reference/Instructions/switch), [des littéraux de gabarits](/fr/docs/Web/JavaScript/Reference/Littéraux_gabarits) et {{jsxref("Array.prototype.reduce()")}}.
 
-<pre class="brush: js">var numberString = formatter.formatToParts(number).map(({type, value}) =&gt; {
+```js
+var numberString = formatter.formatToParts(number).map(({type, value}) => {
   switch (type) {
-    case 'currency': return `&lt;strong&gt;${value}&lt;/strong&gt;`;
+    case 'currency': return `<strong>${value}</strong>`;
     default : return value;
   }
-}).reduce((string, part) =&gt; string + part);
-</pre>
+}).reduce((string, part) => string + part);
+```
 
-<p>Grâce à cette fonction, on pourra mettre en gras le suffixe associé à la devise :</p>
+Grâce à cette fonction, on pourra mettre en gras le suffixe associé à la devise :
 
-<pre class="brush: js">console.log(numberString);
-// "3.500,00 &lt;strong&gt;€&lt;/strong&gt;"</pre>
+```js
+console.log(numberString);
+// "3.500,00 <strong>€</strong>"
+```
 
-<h2 id="Prothèse_démulation_polyfill">Prothèse d'émulation (<em>polyfill</em>)</h2>
+## Prothèse d'émulation (_polyfill_)
 
-<p>Une prothèse pour cette fonctionnalité est disponible <a href="https://github.com/zbraniecki/proposal-intl-formatToParts">dans le dépôt associé à la proposition</a>.</p>
+Une prothèse pour cette fonctionnalité est disponible [dans le dépôt associé à la proposition](https://github.com/zbraniecki/proposal-intl-formatToParts).
 
-<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('ES Int Draft', '#sec-Intl.NumberFormat.prototype.formatToParts', 'Intl.NumberFormat.prototype.formatToParts')}}</td>
-   <td>{{Spec2('ES Int Draft')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
- </tbody>
-</table>
+| Spécification                                                                                                                                                        | État                             | Commentaires         |
+| -------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------- | -------------------- |
+| {{SpecName('ES Int Draft', '#sec-Intl.NumberFormat.prototype.formatToParts', 'Intl.NumberFormat.prototype.formatToParts')}} | {{Spec2('ES Int Draft')}} | Définition initiale. |
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.Intl.NumberFormat.formatToParts")}}</p>
+{{Compat("javascript.builtins.Intl.NumberFormat.formatToParts")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("NumberFormat", "Intl.NumberFormat")}}</li>
- <li>{{jsxref("NumberFormat.format", "Intl.NumberFormat.prototype.format")}}</li>
- <li>Formater des dates : {{jsxref("DateTimeFormat.formatToParts", "Intl.DateTimeFormat.prototype.formatToParts()")}}</li>
-</ul>
+- {{jsxref("NumberFormat", "Intl.NumberFormat")}}
+- {{jsxref("NumberFormat.format", "Intl.NumberFormat.prototype.format")}}
+- Formater des dates : {{jsxref("DateTimeFormat.formatToParts", "Intl.DateTimeFormat.prototype.formatToParts()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/intl/numberformat/index.md b/files/fr/web/javascript/reference/global_objects/intl/numberformat/index.md
index 5c8188d5f9..248d95d5ed 100644
--- a/files/fr/web/javascript/reference/global_objects/intl/numberformat/index.md
+++ b/files/fr/web/javascript/reference/global_objects/intl/numberformat/index.md
@@ -10,110 +10,99 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat
 original_slug: Web/JavaScript/Reference/Objets_globaux/Intl/NumberFormat
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>L'objet <strong><code>Intl.NumberFormat</code></strong> est un constructeur permettant de créer des objets pour formater des nombres en fonction de la locale.</p>
+L'objet **`Intl.NumberFormat`** est un constructeur permettant de créer des objets pour formater des nombres en fonction de la locale.
 
-<div>{{EmbedInteractiveExample("pages/js/intl-numberformat.html")}}</div>
+{{EmbedInteractiveExample("pages/js/intl-numberformat.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">new Intl.NumberFormat([<var>locales</var>[, <var>options</var>]])
-Intl.NumberFormat.call(<var>this</var>[, <var>locales</var>[, <var>options</var>]])</pre>
+    new Intl.NumberFormat([locales[, options]])
+    Intl.NumberFormat.call(this[, locales[, options]])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>locales</code></dt>
- <dd>
- <p>Paramètre optionnel. Une chaine de caractères avec un identifiant de langue BCP 47, ou un tableau de ce type de chaine de caractères. Pour le format général et l'interprétation de l'argument <code>locales</code>, voir la page {{jsxref("Intl","Intl","#L'identification_et_le_choix_de_la_locale")}}. Les clefs d'extensions Unicode suivantes sont autorisées :</p>
+- `locales`
 
- <dl>
-  <dt>nu</dt>
-  <dd>Le système numérique à utiliser. Parmi les valeurs possibles, on a : <code>"arab", "arabext", "bali", "beng", "deva", "fullwide", "gujr", "guru", "hanidec", "khmr", "knda", "laoo", "latn", "limb", "mlym", "mong", "mymr", "orya", "tamldec", "telu", "thai", "tibt".</code></dd>
- </dl>
- </dd>
- <dt><code>options</code></dt>
- <dd>
- <p>Paramètre optionnel. Un objet avec certaines ou toutes les propriétés suivantes :</p>
+  - : Paramètre optionnel. Une chaine de caractères avec un identifiant de langue BCP 47, ou un tableau de ce type de chaine de caractères. Pour le format général et l'interprétation de l'argument `locales`, voir la page {{jsxref("Intl","Intl","#L'identification_et_le_choix_de_la_locale")}}. Les clefs d'extensions Unicode suivantes sont autorisées :
 
- <dl>
-  <dt><code>localeMatcher</code></dt>
-  <dd>L'algorithme de correspondance à utiliser pour la locale. Les valeurs possibles sont <code>"lookup"</code> et <code>"best fit"</code> ; le défaut est <code>"best fit"</code>. Pour des informations sur cette option, voir la page {{jsxref("Intl","Intl","##Choix_de_la_locale")}}.</dd>
-  <dt><code>style</code></dt>
-  <dd>Le style de formatage. Les valeurs possibles sont <code>"decimal"</code> pour l'affichage de nombres simple, <code>"currency"</code> pour un affichage en fonction de la devise et <code>"percent"</code> pour afficher des pourcentages. La valeur par défaut est <code>"decimal"</code>.</dd>
-  <dt><code>currency</code></dt>
-  <dd>La devise à utiliser pour le formatage. Les valeurs possibles sont les codes ISO 4217 pour les devises, tels que <code>"USD"</code> pour le dollar américain, <code>"EUR"</code> pour l'euro, ou <code>"CNY"</code> pour le yuan chinois. Voir la page listant <a href="http://www.currency-iso.org/en/home/tables/table-a1.html">les codes actuels pour les devises et les fonds</a> (en anglais). Il n'y a pas de valeur par défaut. Si le style choisi avec l'option <code>style</code> est "currency", la propriété <code>currency</code> doit être définie.</dd>
-  <dt><code>currencyDisplay</code></dt>
-  <dd>La façon d'afficher la devise dans le format courant. Les valeurs possibles sont <code>"symbol"</code> qui permet d'utiliser un symbole localisé comme '€', <code>"code"</code> qui affichera le code ISO de la devise (voir ci-avant), <code>"name"</code>  affichera un nom localisé pour la devise comme <code>"dollar"</code>. La valeur par défaut est <code>"symbol"</code>.</dd>
-  <dt><code>useGrouping</code></dt>
-  <dd>Cette option indique si on doit utiliser des séparateurs de groupes (comme les séparateurs de milliers ou autres comme lakhs et crores). Les valeurs possibles sont <code>true</code> et <code>false</code>. La valeur par défaut <code>true</code>.</dd>
- </dl>
+    - nu
+      - : Le système numérique à utiliser. Parmi les valeurs possibles, on a : `"arab", "arabext", "bali", "beng", "deva", "fullwide", "gujr", "guru", "hanidec", "khmr", "knda", "laoo", "latn", "limb", "mlym", "mong", "mymr", "orya", "tamldec", "telu", "thai", "tibt".`
 
- <p>Les propriétés suivantes peuvent être classées en deux groupes. Dans le premier on aura <code>minimumIntegerDigits</code>, <code>minimumFractionDigits</code>, <code>maximumFractionDigits</code> et dans le second on aura <code>minimumSignificantDigits</code> et <code>maximumSignificantDigits</code>. S'il existe une option définie pour le second groupe, les options du premier groupe seront ignorées.</p>
+- `options`
 
- <dl>
-  <dt><code>minimumIntegerDigits</code></dt>
-  <dd>Le nombre minimal de chiffres à utiliser pour la partie entière. Les valeurs possibles sont comprises entre 1 to 21. La valeur par défaut est 1.</dd>
-  <dt><code>minimumFractionDigits</code></dt>
-  <dd>Le nombre minimal de chiffres à utiliser pour la partie fractionnaire. Les valeurs possibles sont comprises entre 0 et 20. Pour les formats <code>"decimal"</code> et <code>"percent"</code>, la valeur par défaut est 0. La valeur par défaut pour le formatage monétaire (<code>"currency"</code>) correspond au nombre de chiffres défini par <a href="https://www.currency-iso.org/en/home/tables/table-a1.html">la liste de codes de devises ISO 4217</a>, si cette valeur n'est pas définie dans cette liste, on aura 2 chiffres.</dd>
-  <dt><code>maximumFractionDigits</code></dt>
-  <dd>Le nombre maximal de chiffres à utiliser pour représenter la partie fractionnaire. Les valeurs possibles sont comprises entre 0 et 20. Pour le format <code>"decimal"</code>, la valeur par défaut est le maximum entre 3 et <code>minimumFractionDigits</code>. Pour le format monétaire (<code>"currency"</code>), la valeur par défaut est le maximum entre  <code>minimumFractionDigits</code> et le nombre de chiffres prévus par la liste <a href="https://www.currency-iso.org/en/home/tables/table-a1.html">ISO 4217 des codes de devises</a> (ou 2 si cette information n'est pas disponible dans cette liste). Pour le format en pourcent, la valeur par défaut est le maximum entre <code>minimumFractionDigits</code> et 0.</dd>
-  <dt><code>minimumSignificantDigits</code></dt>
-  <dd>Le nombre minimal de chiffres significatifs à utiliser. Les valeurs possibles sont comprises entre 1 et 21. La valeur par défaut est 1.</dd>
-  <dt><code>maximumSignificantDigits</code></dt>
-  <dd>Le nombre maximal de chiffres significatifs à utiliser. Les valeurs possibles sont comprises entre 1 et 21. La valeur par défaut est <code>minimumSignificantDigits</code>.</dd>
- </dl>
- </dd>
-</dl>
+  - : Paramètre optionnel. Un objet avec certaines ou toutes les propriétés suivantes :
 
-<h2 id="Description">Description</h2>
+    - `localeMatcher`
+      - : L'algorithme de correspondance à utiliser pour la locale. Les valeurs possibles sont `"lookup"` et `"best fit"` ; le défaut est `"best fit"`. Pour des informations sur cette option, voir la page {{jsxref("Intl","Intl","##Choix_de_la_locale")}}.
+    - `style`
+      - : Le style de formatage. Les valeurs possibles sont `"decimal"` pour l'affichage de nombres simple, `"currency"` pour un affichage en fonction de la devise et `"percent"` pour afficher des pourcentages. La valeur par défaut est `"decimal"`.
+    - `currency`
+      - : La devise à utiliser pour le formatage. Les valeurs possibles sont les codes ISO 4217 pour les devises, tels que `"USD"` pour le dollar américain, `"EUR"` pour l'euro, ou `"CNY"` pour le yuan chinois. Voir la page listant [les codes actuels pour les devises et les fonds](http://www.currency-iso.org/en/home/tables/table-a1.html) (en anglais). Il n'y a pas de valeur par défaut. Si le style choisi avec l'option `style` est "currency", la propriété `currency` doit être définie.
+    - `currencyDisplay`
+      - : La façon d'afficher la devise dans le format courant. Les valeurs possibles sont `"symbol"` qui permet d'utiliser un symbole localisé comme '€', `"code"` qui affichera le code ISO de la devise (voir ci-avant), `"name"`  affichera un nom localisé pour la devise comme `"dollar"`. La valeur par défaut est `"symbol"`.
+    - `useGrouping`
+      - : Cette option indique si on doit utiliser des séparateurs de groupes (comme les séparateurs de milliers ou autres comme lakhs et crores). Les valeurs possibles sont `true` et `false`. La valeur par défaut `true`.
 
-<h3 id="Propriétés">Propriétés</h3>
+    Les propriétés suivantes peuvent être classées en deux groupes. Dans le premier on aura `minimumIntegerDigits`, `minimumFractionDigits`, `maximumFractionDigits` et dans le second on aura `minimumSignificantDigits` et `maximumSignificantDigits`. S'il existe une option définie pour le second groupe, les options du premier groupe seront ignorées.
 
-<dl>
- <dt>{{jsxref("NumberFormat.prototype", "Intl.NumberFormat.prototype")}}</dt>
- <dd>Permet d'ajouter des propriétés à toutes les instances.</dd>
-</dl>
+    - `minimumIntegerDigits`
+      - : Le nombre minimal de chiffres à utiliser pour la partie entière. Les valeurs possibles sont comprises entre 1 to 21. La valeur par défaut est 1.
+    - `minimumFractionDigits`
+      - : Le nombre minimal de chiffres à utiliser pour la partie fractionnaire. Les valeurs possibles sont comprises entre 0 et 20. Pour les formats `"decimal"` et `"percent"`, la valeur par défaut est 0. La valeur par défaut pour le formatage monétaire (`"currency"`) correspond au nombre de chiffres défini par [la liste de codes de devises ISO 4217](https://www.currency-iso.org/en/home/tables/table-a1.html), si cette valeur n'est pas définie dans cette liste, on aura 2 chiffres.
+    - `maximumFractionDigits`
+      - : Le nombre maximal de chiffres à utiliser pour représenter la partie fractionnaire. Les valeurs possibles sont comprises entre 0 et 20. Pour le format `"decimal"`, la valeur par défaut est le maximum entre 3 et `minimumFractionDigits`. Pour le format monétaire (`"currency"`), la valeur par défaut est le maximum entre  `minimumFractionDigits` et le nombre de chiffres prévus par la liste [ISO 4217 des codes de devises](https://www.currency-iso.org/en/home/tables/table-a1.html) (ou 2 si cette information n'est pas disponible dans cette liste). Pour le format en pourcent, la valeur par défaut est le maximum entre `minimumFractionDigits` et 0.
+    - `minimumSignificantDigits`
+      - : Le nombre minimal de chiffres significatifs à utiliser. Les valeurs possibles sont comprises entre 1 et 21. La valeur par défaut est 1.
+    - `maximumSignificantDigits`
+      - : Le nombre maximal de chiffres significatifs à utiliser. Les valeurs possibles sont comprises entre 1 et 21. La valeur par défaut est `minimumSignificantDigits`.
 
-<h3 id="Méthodes">Méthodes</h3>
+## Description
 
-<dl>
- <dt>{{jsxref("NumberFormat.supportedLocalesOf", "Intl.NumberFormat.supportedLocalesOf()")}}</dt>
- <dd>Renvoie un tableau des locales supportées parmi les locales données afin d'éviter d'utiliser la locale par défaut de l'environnement.</dd>
-</dl>
+### Propriétés
 
-<h2 id="Instances_de_NumberFormat">Instances de <code>NumberFormat</code></h2>
+- {{jsxref("NumberFormat.prototype", "Intl.NumberFormat.prototype")}}
+  - : Permet d'ajouter des propriétés à toutes les instances.
 
-<h3 id="Propriétés_2">Propriétés</h3>
+### Méthodes
 
-<p>Les instances de <code>NumberFormat</code> héritent des propriétés suivantes grâce à leur prototype :</p>
+- {{jsxref("NumberFormat.supportedLocalesOf", "Intl.NumberFormat.supportedLocalesOf()")}}
+  - : Renvoie un tableau des locales supportées parmi les locales données afin d'éviter d'utiliser la locale par défaut de l'environnement.
 
-<div>{{page('fr/docs/Web/JavaScript/Reference/Global_Objects/NumberFormat/prototype','Properties')}}</div>
+## Instances de `NumberFormat`
 
-<h3 id="Méthods">Méthods</h3>
+### Propriétés
 
-<div>
-<p>Les instances de <code>NumberFormat</code> héritent des méthodes suivantes grâce à leur prototype :</p>
-{{page('fr/docs/Web/JavaScript/Reference/Global_Objects/NumberFormat/prototype','Methods')}}</div>
+Les instances de `NumberFormat` héritent des propriétés suivantes grâce à leur prototype :
 
-<h2 id="Exemples">Exemples</h2>
+{{page('fr/docs/Web/JavaScript/Reference/Global_Objects/NumberFormat/prototype','Properties')}}
 
-<h3 id="Usage_simple">Usage simple</h3>
+### Méthods
 
-<p>Sans aucune spécification, le résultat sera une chaîne de caractères avec la locale et les options par défaut :</p>
+Les instances de `NumberFormat` héritent des méthodes suivantes grâce à leur prototype :
 
-<pre class="brush: js">var nombre = 3500;
+{{page('fr/docs/Web/JavaScript/Reference/Global_Objects/NumberFormat/prototype','Methods')}}
+
+## Exemples
+
+### Usage simple
+
+Sans aucune spécification, le résultat sera une chaîne de caractères avec la locale et les options par défaut :
+
+```js
+var nombre = 3500;
 
 console.log(new Intl.NumberFormat().format(nombre));
 // → "3 500" pour la locale fr
-</pre>
+```
 
-<h3 id="Utiliser_locales">Utiliser <code>locales</code></h3>
+### Utiliser `locales`
 
-<p>Cet exemple illustre les variations possibles des formats numériques localisés. Si vous souhaitez que votre application utilise le format de la locale de l'utilisateur, assurez vous de l'indiquer via l'argument <code>locales</code> (voire avec d'autres locales de secours) :</p>
+Cet exemple illustre les variations possibles des formats numériques localisés. Si vous souhaitez que votre application utilise le format de la locale de l'utilisateur, assurez vous de l'indiquer via l'argument `locales` (voire avec d'autres locales de secours) :
 
-<pre class="brush: js">var nombre = 123456.789;
+```js
+var nombre = 123456.789;
 
 // L'allemand utilise la virgule comme séparateur décimal
 // et un point pour indiquer les milliers
@@ -139,13 +128,14 @@ console.log(new Intl.NumberFormat("zh-Hans-CN-u-nu-hanidec").format(nombre));
 // on peut inclure une locale de secours (ici l'indonésien)
 console.log(new Intl.NumberFormat(["ban", "id"]).format(nombre));
 // → 123.456,789
-</pre>
+```
 
-<h3 id="Utiliser_options">Utiliser <code>options</code></h3>
+### Utiliser `options`
 
-<p>Les résultats fournis par <code>toLocaleString</code> peuvent être paramétrés grâce à l'argument <code>options</code> :</p>
+Les résultats fournis par `toLocaleString` peuvent être paramétrés grâce à l'argument `options` :
 
-<pre class="brush: js">var nombre = 123456.789;
+```js
+var nombre = 123456.789;
 
 // on affiche une devise avec le style "currency"
 console.log(new Intl.NumberFormat("de-DE", {style: "currency", currency: "EUR"}).format(nombre));
@@ -158,41 +148,20 @@ console.log(new Intl.NumberFormat("ja-JP", {style: "currency", currency: "JPY"})
 // On se limite ici à trois chiffres significatifs
 console.log(new Intl.NumberFormat("en-IN", {maximumSignificantDigits: 3}).format(nombre));
 // → 1,23,000
-</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('ES Int 1.0', '#sec-11.1', 'Intl.NumberFormat')}}</td>
-   <td>{{Spec2('ES Int 1.0')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES Int 2.0', '#sec-11.1', 'Intl.NumberFormat')}}</td>
-   <td>{{Spec2('ES Int 2.0')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES Int Draft', '#numberformat-objects', 'Intl.NumberFormat')}}</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.Intl.NumberFormat")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<p>{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/Intl','Voir_aussi')}}</p>
+```
+
+## Spécifications
+
+| Spécification                                                                                        | État                             | Commentaires         |
+| ---------------------------------------------------------------------------------------------------- | -------------------------------- | -------------------- |
+| {{SpecName('ES Int 1.0', '#sec-11.1', 'Intl.NumberFormat')}}                     | {{Spec2('ES Int 1.0')}} | Définition initiale. |
+| {{SpecName('ES Int 2.0', '#sec-11.1', 'Intl.NumberFormat')}}                     | {{Spec2('ES Int 2.0')}} |                      |
+| {{SpecName('ES Int Draft', '#numberformat-objects', 'Intl.NumberFormat')}} | {{Spec2('ES Int Draft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Intl.NumberFormat")}}
+
+## Voir aussi
+
+{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/Intl','Voir_aussi')}}
diff --git a/files/fr/web/javascript/reference/global_objects/intl/numberformat/resolvedoptions/index.md b/files/fr/web/javascript/reference/global_objects/intl/numberformat/resolvedoptions/index.md
index f980e6608a..84d7961afb 100644
--- a/files/fr/web/javascript/reference/global_objects/intl/numberformat/resolvedoptions/index.md
+++ b/files/fr/web/javascript/reference/global_objects/intl/numberformat/resolvedoptions/index.md
@@ -13,49 +13,46 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat/resolvedOptions
 original_slug: Web/JavaScript/Reference/Objets_globaux/Intl/NumberFormat/resolvedOptions
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>Intl.NumberFormat.prototype.resolvedOptions()</strong></code> renvoie un nouvel objet dont les propriétés correspondent aux options de locales et de format calculées à l'initialisation de l'objet {{jsxref("NumberFormat", "Intl.NumberFormat")}}.</p>
+La méthode **`Intl.NumberFormat.prototype.resolvedOptions()`** renvoie un nouvel objet dont les propriétés correspondent aux options de locales et de format calculées à l'initialisation de l'objet {{jsxref("NumberFormat", "Intl.NumberFormat")}}.
 
-<div>{{EmbedInteractiveExample("pages/js/intl-numberformat-prototype-resolvedoptions.html")}}</div>
+{{EmbedInteractiveExample("pages/js/intl-numberformat-prototype-resolvedoptions.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>numberFormat</var>.resolvedOptions()</pre>
+    numberFormat.resolvedOptions()
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un objet dont les propriétés correspondent aux options de locale et de format calculées lors de l'initialisation de l'objet {{jsxref("NumberFormat", "Intl.NumberFormat")}}.</p>
+Un objet dont les propriétés correspondent aux options de locale et de format calculées lors de l'initialisation de l'objet {{jsxref("NumberFormat", "Intl.NumberFormat")}}.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Cette méthode renvoie un objet composé des propriétés suivantes :</p>
+Cette méthode renvoie un objet composé des propriétés suivantes :
 
-<dl>
- <dt><code>locale</code></dt>
- <dd>La balise de langue BCP 47 qui est utilisée. Si des extensions Unicode avaient été rajoutées à la balise BCP 47 demandée, les paires de clés-valeurs qui ont été demandées et qui sont supportées sont inscrites dans <code>locale</code>.</dd>
- <dt><code>numberingSystem</code></dt>
- <dd>La valeur requise via l'extension Unicode <code>"nu"</code> ou celle qui est utilisée par défaut.</dd>
- <dt><code>style</code>, <code>useGrouping</code></dt>
- <dd>Les valeurs fournies pour ces propriétés via l'argument <code>options</code> ou bien les valeurs par défaut.</dd>
- <dt><code>currency</code>, <code>currencyDisplay</code></dt>
- <dd>Les valeurs fournies pour ces propriétés via l'argument <code>options</code> ou bien les valeurs par défaut. Ces valeurs sont présentes uniquement si <code>style</code> vaut <code>"currency"</code>.</dd>
-</dl>
+- `locale`
+  - : La balise de langue BCP 47 qui est utilisée. Si des extensions Unicode avaient été rajoutées à la balise BCP 47 demandée, les paires de clés-valeurs qui ont été demandées et qui sont supportées sont inscrites dans `locale`.
+- `numberingSystem`
+  - : La valeur requise via l'extension Unicode `"nu"` ou celle qui est utilisée par défaut.
+- `style`, `useGrouping`
+  - : Les valeurs fournies pour ces propriétés via l'argument `options` ou bien les valeurs par défaut.
+- `currency`, `currencyDisplay`
+  - : Les valeurs fournies pour ces propriétés via l'argument `options` ou bien les valeurs par défaut. Ces valeurs sont présentes uniquement si `style` vaut `"currency"`.
 
-<p>Un seul des deux groupes suivants est inclus dans les propriétés :</p>
+Un seul des deux groupes suivants est inclus dans les propriétés :
 
-<dl>
- <dt><code>minimumIntegerDigits</code>,<code>minimumFractionDigits</code>, <code>maximumFractionDigits</code></dt>
- <dd>Les valeurs fournies pour ces propriétés via l'argument <code>options</code> ou bien les valeurs par défaut. Ces propriétés ne sont présentes que si <code>minimumSignificantDigits</code> ou <code>maximumSignificantDigits</code> n'ont pas été fournies à l'argument <code>options</code>.</dd>
- <dt><code>minimumSignificantDigits</code>,<code>maximumSignificantDigits</code></dt>
- <dd>Les valeurs fournies pour ces propriétés via l'argument <code>options</code> ou bien les valeurs par défaut. Ces propriétés sont présentes si au moins une d'entre elles a été fournie via l'argument <code>options</code>.</dd>
-</dl>
+- `minimumIntegerDigits`,`minimumFractionDigits`, `maximumFractionDigits`
+  - : Les valeurs fournies pour ces propriétés via l'argument `options` ou bien les valeurs par défaut. Ces propriétés ne sont présentes que si `minimumSignificantDigits` ou `maximumSignificantDigits` n'ont pas été fournies à l'argument `options`.
+- `minimumSignificantDigits`,`maximumSignificantDigits`
+  - : Les valeurs fournies pour ces propriétés via l'argument `options` ou bien les valeurs par défaut. Ces propriétés sont présentes si au moins une d'entre elles a été fournie via l'argument `options`.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_la_méthode_resolvedOptions">Utiliser la méthode <code>resolvedOptions()</code></h3>
+### Utiliser la méthode `resolvedOptions()`
 
-<pre class="brush: js">var de = new Intl.NumberFormat('de-DE');
+```js
+var de = new Intl.NumberFormat('de-DE');
 var usedOptions = de.resolvedOptions();
 
 usedOptions.locale;                // "de-DE"
@@ -64,41 +61,21 @@ usedOption.style;                  // "decimal"
 usedOptions.minimumIntegerDigits;  // 1
 usedOptions.minimumFractionDigits; // 0
 usedOptions.maximumFractionDigits; // 3
-usedOptions.useGrouping;           // 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('ES Int 1.0', '#sec-11.3.3', 'Intl.NumberFormat.prototype.resolvedOptions')}}</td>
-   <td>{{Spec2('ES Int 1.0')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES Int 2.0', '#sec-11.3.3', 'Intl.NumberFormat.prototype.resolvedOptions')}}</td>
-   <td>{{Spec2('ES Int 2.0')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES Int Draft', '#sec-Intl.NumberFormat.prototype.resolvedOptions', 'Intl.NumberFormat.prototype.resolvedOptions')}}</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.Intl.NumberFormat.resolvedOptions")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("NumberFormat", "Intl.NumberFormat")}}</li>
-</ul>
+usedOptions.useGrouping;           // true
+```
+
+## Spécifications
+
+| Spécification                                                                                                                                                            | État                             | Commentaires         |
+| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------- | -------------------- |
+| {{SpecName('ES Int 1.0', '#sec-11.3.3', 'Intl.NumberFormat.prototype.resolvedOptions')}}                                                     | {{Spec2('ES Int 1.0')}} | Définition initiale. |
+| {{SpecName('ES Int 2.0', '#sec-11.3.3', 'Intl.NumberFormat.prototype.resolvedOptions')}}                                                     | {{Spec2('ES Int 2.0')}} |                      |
+| {{SpecName('ES Int Draft', '#sec-Intl.NumberFormat.prototype.resolvedOptions', 'Intl.NumberFormat.prototype.resolvedOptions')}} | {{Spec2('ES Int Draft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Intl.NumberFormat.resolvedOptions")}}
+
+## Voir aussi
+
+- {{jsxref("NumberFormat", "Intl.NumberFormat")}}
diff --git a/files/fr/web/javascript/reference/global_objects/intl/numberformat/supportedlocalesof/index.md b/files/fr/web/javascript/reference/global_objects/intl/numberformat/supportedlocalesof/index.md
index 6e622f3240..0e53d66889 100644
--- a/files/fr/web/javascript/reference/global_objects/intl/numberformat/supportedlocalesof/index.md
+++ b/files/fr/web/javascript/reference/global_objects/intl/numberformat/supportedlocalesof/index.md
@@ -12,84 +12,60 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat/supportedLocalesOf
 original_slug: Web/JavaScript/Reference/Objets_globaux/Intl/NumberFormat/supportedLocalesOf
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>Intl.NumberFormat.supportedLocalesOf()</strong></code> renvoie un tableau de locales supportées parmi les locales fournies en argument afin d'éviter d'utiliser celle par défaut de l'environnement.</p>
+La méthode **`Intl.NumberFormat.supportedLocalesOf()`** renvoie un tableau de locales supportées parmi les locales fournies en argument afin d'éviter d'utiliser celle par défaut de l'environnement.
 
-<div>{{EmbedInteractiveExample("pages/js/intl-numberformat-prototype-supportedlocalesof.html")}}</div>
+{{EmbedInteractiveExample("pages/js/intl-numberformat-prototype-supportedlocalesof.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">Intl.NumberFormat.supportedLocalesOf(<var>locales</var>[, <var>options</var>])</pre>
+    Intl.NumberFormat.supportedLocalesOf(locales[, options])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>locales</code></dt>
- <dd>Une chaîne de caractères qui est une balise BCP 47 ou un tableau composé de telles chaînes. Pour plus d'informations sur la forme générale de l'argument <code>locales</code>, voir la page {{jsxref("Intl","Intl","#L'identification_et_le_choix_de_la_locale")}}.</dd>
- <dt><code>options</code></dt>
- <dd>
- <p>Un objet qui peut avoir la propriété suivante :</p>
+- `locales`
+  - : Une chaîne de caractères qui est une balise BCP 47 ou un tableau composé de telles chaînes. Pour plus d'informations sur la forme générale de l'argument `locales`, voir la page {{jsxref("Intl","Intl","#L'identification_et_le_choix_de_la_locale")}}.
+- `options`
 
- <dl>
-  <dt><code>localeMatcher</code></dt>
-  <dd>L'algorithme de correspondance des locales à utiliser. Les valeurs possibles sont "lookup" et "best fit". La valeur par défaut est "best fit". Pour plus d'informations,, voir la page {{jsxref("Intl","Intl","#Choix_de_la_locale")}}.</dd>
- </dl>
- </dd>
-</dl>
+  - : Un objet qui peut avoir la propriété suivante :
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+    - `localeMatcher`
+      - : L'algorithme de correspondance des locales à utiliser. Les valeurs possibles sont "lookup" et "best fit". La valeur par défaut est "best fit". Pour plus d'informations,, voir la page {{jsxref("Intl","Intl","#Choix_de_la_locale")}}.
 
-<p>Un tableau de chaînes de caractères représentant un sous-ensemble des balises de langues qui sont prises en charge pour la mise en forme des nombres sans qu'il soit nécessaire d'utiliser la locale par défaut de l'environnement d'exécution.</p>
+### Valeur de retour
 
-<h2 id="Description">Description</h2>
+Un tableau de chaînes de caractères représentant un sous-ensemble des balises de langues qui sont prises en charge pour la mise en forme des nombres sans qu'il soit nécessaire d'utiliser la locale par défaut de l'environnement d'exécution.
 
-<p>Cette méthode renvoie un tableau de locales supportées parmi les locales fournies en argument afin d'éviter d'utiliser celle par défaut de l'environnement. Les locales renvoyées sont celles considérées comme équivalentes aux locales fournies avec l'algorithme indiqué.</p>
+## Description
 
-<h2 id="Exemples">Exemples</h2>
+Cette méthode renvoie un tableau de locales supportées parmi les locales fournies en argument afin d'éviter d'utiliser celle par défaut de l'environnement. Les locales renvoyées sont celles considérées comme équivalentes aux locales fournies avec l'algorithme indiqué.
 
-<h3 id="Utiliser_supportedLocalesOf">Utiliser <code>supportedLocalesOf()</code></h3>
+## Exemples
 
-<p>Si on dispose d'un environnement qui supporte les locales indonésienne et allemande mais pas balinaise pour le formatage des dates et des heures, <code>supportedLocalesOf</code> renverra les balises BCP 47 pour l'indonésien et l'allemand (bien que la collation pinyin ne soit pas pertinente pour les nombres ni pour l'indonésien et qu'il soit peu probable qu'une variante indonésienne existe pour l'allemand). Pour l'exemple, on l'utilise l'algorithme <code>"lookup"</code>. Si on utilisait <code>"best fit"</code>, on pourrait considérer que l'indonésien est adéquat pour la locale balinaise (sachant que la plupart des balinais comprend l'indonésien) et donc également renvoyer la balise balinaise.</p>
+### Utiliser `supportedLocalesOf()`
 
-<pre class="brush: js">var locales = ["ban", "id-u-co-pinyin", "de-ID"];
+Si on dispose d'un environnement qui supporte les locales indonésienne et allemande mais pas balinaise pour le formatage des dates et des heures, `supportedLocalesOf` renverra les balises BCP 47 pour l'indonésien et l'allemand (bien que la collation pinyin ne soit pas pertinente pour les nombres ni pour l'indonésien et qu'il soit peu probable qu'une variante indonésienne existe pour l'allemand). Pour l'exemple, on l'utilise l'algorithme `"lookup"`. Si on utilisait `"best fit"`, on pourrait considérer que l'indonésien est adéquat pour la locale balinaise (sachant que la plupart des balinais comprend l'indonésien) et donc également renvoyer la balise balinaise.
+
+```js
+var locales = ["ban", "id-u-co-pinyin", "de-ID"];
 var options = {localeMatcher: "lookup"};
 console.log(Intl.NumberFormat.supportedLocalesOf(locales, options).join(", "));
-// → "id-u-co-pinyin, de-ID"</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('ES Int 1.0', '#sec-11.2.2', 'Intl.NumberFormat.supportedLocalesOf')}}</td>
-   <td>{{Spec2('ES Int 1.0')}}</td>
-   <td>Définition initiale</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES Int 2.0', '#sec-11.2.2', 'Intl.NumberFormat.supportedLocalesOf')}}</td>
-   <td>{{Spec2('ES Int 2.0')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES Int Draft', '#sec-Intl.NumberFormat.supportedLocalesOf', 'Intl.NumberFormat.supportedLocalesOf')}}</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.Intl.NumberFormat.supportedLocalesOf")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("NumberFormat", "Intl.NumberFormat")}}</li>
-</ul>
+// → "id-u-co-pinyin, de-ID"
+```
+
+## Spécifications
+
+| Spécification                                                                                                                                            | État                             | Commentaires        |
+| -------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------- | ------------------- |
+| {{SpecName('ES Int 1.0', '#sec-11.2.2', 'Intl.NumberFormat.supportedLocalesOf')}}                                             | {{Spec2('ES Int 1.0')}} | Définition initiale |
+| {{SpecName('ES Int 2.0', '#sec-11.2.2', 'Intl.NumberFormat.supportedLocalesOf')}}                                             | {{Spec2('ES Int 2.0')}} |                     |
+| {{SpecName('ES Int Draft', '#sec-Intl.NumberFormat.supportedLocalesOf', 'Intl.NumberFormat.supportedLocalesOf')}} | {{Spec2('ES Int Draft')}} |                     |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Intl.NumberFormat.supportedLocalesOf")}}
+
+## Voir aussi
+
+- {{jsxref("NumberFormat", "Intl.NumberFormat")}}
diff --git a/files/fr/web/javascript/reference/global_objects/intl/pluralrules/index.md b/files/fr/web/javascript/reference/global_objects/intl/pluralrules/index.md
index 1e106a5079..dcb8012ff4 100644
--- a/files/fr/web/javascript/reference/global_objects/intl/pluralrules/index.md
+++ b/files/fr/web/javascript/reference/global_objects/intl/pluralrules/index.md
@@ -10,77 +10,65 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Intl/PluralRules
 original_slug: Web/JavaScript/Reference/Objets_globaux/Intl/PluralRules
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>L'objet <strong><code>Intl.PluralRules</code></strong> est un constructeur d'objets qui permettent de mettre en forme des chaînes de caractères en fonction des règles de nombre (pluriel) d'une langue donnée.</p>
+L'objet **`Intl.PluralRules`** est un constructeur d'objets qui permettent de mettre en forme des chaînes de caractères en fonction des règles de nombre (pluriel) d'une langue donnée.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><code>new Intl.PluralRules([<var>locales</var>[, <var>options</var>]])
-</code></pre>
+    new Intl.PluralRules([locales[, options]])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>locales</code></dt>
- <dd>
- <p>Une chaine de caractères avec un identifiant de langue BCP 47, ou un tableau de ce type de chaine de caractères. Pour le format général et l'interprétation de l'argument <code>locales</code>, voir la page {{jsxref("Objets_globaux/Intl","Intl","#L'identification_et_le_choix_de_la_locale")}}.</p>
- </dd>
- <dt><code>options</code> {{optional_inline}}</dt>
- <dd>
- <p>Optionnel, un objet possédant tout ou partie des propriétés suivantes :</p>
+- `locales`
+  - : Une chaine de caractères avec un identifiant de langue BCP 47, ou un tableau de ce type de chaine de caractères. Pour le format général et l'interprétation de l'argument `locales`, voir la page {{jsxref("Objets_globaux/Intl","Intl","#L'identification_et_le_choix_de_la_locale")}}.
+- `options` {{optional_inline}}
 
- <dl>
-  <dt><code>localeMatcher</code></dt>
-  <dd>L'algorithme de correspondance à utiliser pour la locale. Les valeurs possibles sont <code>"lookup"</code> et <code>"best fit"</code> ; le défaut est <code>"best fit"</code>. Pour des informations sur cette option, voir la page {{jsxref("Objets_globaux/Intl","Intl","##Choix_de_la_locale")}}</dd>
-  <dt><code>type</code></dt>
-  <dd>Le type de numérotation à utiliser. Les valeurs possibles sont :
-  <ul>
-   <li><code>"cardinal"</code> pour les nombres cardinaux (la quantité de telle ou telle chose). Cette valeur est la valeur par défaut.</li>
-   <li><code>"ordinal"</code> pour les nombres ordinaux (l'ordre relatif de différentes choses « premier », « deuxième », « troisième »).</li>
-  </ul>
-  </dd>
- </dl>
- </dd>
-</dl>
+  - : Optionnel, un objet possédant tout ou partie des propriétés suivantes :
 
-<h2 id="Description">Description</h2>
+    - `localeMatcher`
+      - : L'algorithme de correspondance à utiliser pour la locale. Les valeurs possibles sont `"lookup"` et `"best fit"` ; le défaut est `"best fit"`. Pour des informations sur cette option, voir la page {{jsxref("Objets_globaux/Intl","Intl","##Choix_de_la_locale")}}
+    - `type`
 
-<h3 id="Propriétés">Propriétés</h3>
+      - : Le type de numérotation à utiliser. Les valeurs possibles sont :
 
-<dl>
- <dt>{{jsxref("PluralRules.prototype", "Intl.PluralRules.prototype")}}</dt>
- <dd>Cette propriété permet d'ajouter des propriétés aux objets <code>Intl.PluralRules</code>.</dd>
-</dl>
+        - `"cardinal"` pour les nombres cardinaux (la quantité de telle ou telle chose). Cette valeur est la valeur par défaut.
+        - `"ordinal"` pour les nombres ordinaux (l'ordre relatif de différentes choses « premier », « deuxième », « troisième »).
 
-<h3 id="Méthodes">Méthodes</h3>
+## Description
 
-<dl>
- <dt>{{jsxref("PluralRules.supportedLocalesOf", "Intl.PluralRules.supportedLocalesOf()")}}</dt>
- <dd>Cette méthode renvoie un tableau contenant les locales prises en charge sans que le moteur ait à utiliser la locale par défaut du système d'exécution.</dd>
-</dl>
+### Propriétés
 
-<h2 id="Instances_de_PluralRules">Instances de <code>PluralRules</code></h2>
+- {{jsxref("PluralRules.prototype", "Intl.PluralRules.prototype")}}
+  - : Cette propriété permet d'ajouter des propriétés aux objets `Intl.PluralRules`.
 
-<h3 id="Propriétés_2">Propriétés</h3>
+### Méthodes
 
-<p>Les instances de <code>PluralRules</code> héritent des propriétés suivantes de par leur prototype :</p>
+- {{jsxref("PluralRules.supportedLocalesOf", "Intl.PluralRules.supportedLocalesOf()")}}
+  - : Cette méthode renvoie un tableau contenant les locales prises en charge sans que le moteur ait à utiliser la locale par défaut du système d'exécution.
 
-<div>{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/PluralRules/prototype', 'Propriétés')}}</div>
+## Instances de `PluralRules`
 
-<h3 id="Méthodes_2">Méthodes</h3>
+### Propriétés
 
-<p>Les instances de <code>PluralRules</code> héritent des méthodes suivantes de par leur prototype :</p>
+Les instances de `PluralRules` héritent des propriétés suivantes de par leur prototype :
 
-<div>{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/PluralRules/prototype', 'Méthodes')}}</div>
+{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/PluralRules/prototype', 'Propriétés')}}
 
-<h2 id="Exemples">Exemples</h2>
+### Méthodes
 
-<h3 id="Exemple_simple">Exemple simple</h3>
+Les instances de `PluralRules` héritent des méthodes suivantes de par leur prototype :
 
-<p>Sans indiquer de locale, une chaîne formatée dans la locale par défaut et avec les options par défaut est renvoyée. On peut ainsi différencier entre le singulier et le pluriel (par exemple "chien" et "chiens").</p>
+{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/PluralRules/prototype', 'Méthodes')}}
 
-<pre class="brush: js">var pr = new Intl.PluralRules();
+## Exemples
+
+### Exemple simple
+
+Sans indiquer de locale, une chaîne formatée dans la locale par défaut et avec les options par défaut est renvoyée. On peut ainsi différencier entre le singulier et le pluriel (par exemple "chien" et "chiens").
+
+```js
+var pr = new Intl.PluralRules();
 
 pr.select(0);
 // → 'one' si utilisée avec une locale anglais américain
@@ -90,13 +78,14 @@ pr.select(1);
 
 pr.select(2);
 // → 'other' si utilisée avec une locale anglais américain
-</pre>
+```
 
-<h3 id="Utiliser_locales">Utiliser <code>locales</code></h3>
+### Utiliser `locales`
 
-<p>Dans cet exemple, on voit l'impact de la locale sur les règles de nombre. Afin de respecter la langue de l'utilisateur dans votre application, assurez vous d'indiquer cette langue (et éventuellement une langue de secours) grâce à l'argument <code>locales</code> :</p>
+Dans cet exemple, on voit l'impact de la locale sur les règles de nombre. Afin de respecter la langue de l'utilisateur dans votre application, assurez vous d'indiquer cette langue (et éventuellement une langue de secours) grâce à l'argument `locales` :
 
-<pre class="brush: js">// L'arabe possède plusieurs règles
+```js
+// L'arabe possède plusieurs règles
 // de nombre
 
 new Intl.PluralRules('ar-EG').select(0);
@@ -109,13 +98,14 @@ new Intl.PluralRules('ar-EG').select(6);
 // → 'few'
 new Intl.PluralRules('ar-EG').select(18);
 // → 'many'
-</pre>
+```
 
-<h3 id="Utiliser_options">Utiliser <code>options</code></h3>
+### Utiliser `options`
 
-<p>Les résultats obtenus peuvent être adaptés grâce à l'argument <code>options</code>. Celui-ci possède une propriété appelée <code>type</code> qui peut valoir <code>ordinal</code>. Cela peut être utile afin de déterminer la forme d'un indicateur ordinal (par exemple, "1er", "2e", etc.).</p>
+Les résultats obtenus peuvent être adaptés grâce à l'argument `options`. Celui-ci possède une propriété appelée `type` qui peut valoir `ordinal`. Cela peut être utile afin de déterminer la forme d'un indicateur ordinal (par exemple, "1er", "2e", etc.).
 
-<pre class="brush: js">var pr = new Intl.PluralRules('en-US', { type: 'ordinal' });
+```js
+var pr = new Intl.PluralRules('en-US', { type: 'ordinal' });
 
 pr.select(0);
 // → 'other'
@@ -129,29 +119,18 @@ pr.select(4);
 // → 'other'
 pr.select(42);
 // → 'two'
-</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><a href="https://tc39.es/ecma402/#sec-intl-pluralrules-constructor">Proposition pour le constructeur <code>Intl.PluralRules</code></a></td>
-   <td>{{Spec2('ES Int Draft')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
- </tbody>
-</table>
+| Spécification                                                                                                    | État                             | Commentaires         |
+| ---------------------------------------------------------------------------------------------------------------- | -------------------------------- | -------------------- |
+| [Proposition pour le constructeur `Intl.PluralRules`](https://tc39.es/ecma402/#sec-intl-pluralrules-constructor) | {{Spec2('ES Int Draft')}} | Définition initiale. |
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.Intl.PluralRules")}}</p>
+{{Compat("javascript.builtins.Intl.PluralRules")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<div>{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/Intl', 'Voir_aussi')}}</div>
+{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/Intl', 'Voir_aussi')}}
diff --git a/files/fr/web/javascript/reference/global_objects/intl/pluralrules/resolvedoptions/index.md b/files/fr/web/javascript/reference/global_objects/intl/pluralrules/resolvedoptions/index.md
index 8279bdd641..3e43bd2616 100644
--- a/files/fr/web/javascript/reference/global_objects/intl/pluralrules/resolvedoptions/index.md
+++ b/files/fr/web/javascript/reference/global_objects/intl/pluralrules/resolvedoptions/index.md
@@ -12,45 +12,42 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Intl/PluralRules/resolvedOptions
 original_slug: Web/JavaScript/Reference/Objets_globaux/Intl/PluralRules/resolvedOptions
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>Intl.PluralRules.prototype.resolvedOptions()</code></strong> renvoie un nouvel objet dont les propriétés reflètent la locale et les options de formatage relatives aux règles de nombre calculées lors de l'initialisation de l'objet {{jsxref("PluralRules")}}.</p>
+La méthode **`Intl.PluralRules.prototype.resolvedOptions()`** renvoie un nouvel objet dont les propriétés reflètent la locale et les options de formatage relatives aux règles de nombre calculées lors de l'initialisation de l'objet {{jsxref("PluralRules")}}.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><code><var>pluralRule</var>.resolvedOptions()</code></pre>
+    pluralRule.resolvedOptions()
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un nouvel objet dont les propriétés reflètent la locale et les options de formatage relatives aux règles de nombre calculées lors de l'initialisation de l'objet {{jsxref("PluralRules")}}.</p>
+Un nouvel objet dont les propriétés reflètent la locale et les options de formatage relatives aux règles de nombre calculées lors de l'initialisation de l'objet {{jsxref("PluralRules")}}.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>L'objet produit possède les propriétés suivantes :</p>
+L'objet produit possède les propriétés suivantes :
 
-<dl>
- <dt><code>locale</code></dt>
- <dd>La balise de langue BCP 47 pour la locale réellement utilisée. Si une extension Unicode a été demandée dans la balise de langue BCP 47 ayant menée à cette locale, les paires clé/valeur qui ont été demandées et qui sont prises en charge dans cette locale sont incluses dans l'objet <code>locale</code>.</dd>
- <dt><code>pluralCategories</code></dt>
- <dd>Un tableau {{jsxref("Array")}} des règles de nombre utilisée pour la langue donnée.</dd>
- <dt><code>type</code></dt>
- <dd>Le type de règle utilisée (<code>cardinal</code> ou <code>ordinal</code>).</dd>
-</dl>
+- `locale`
+  - : La balise de langue BCP 47 pour la locale réellement utilisée. Si une extension Unicode a été demandée dans la balise de langue BCP 47 ayant menée à cette locale, les paires clé/valeur qui ont été demandées et qui sont prises en charge dans cette locale sont incluses dans l'objet `locale`.
+- `pluralCategories`
+  - : Un tableau {{jsxref("Array")}} des règles de nombre utilisée pour la langue donnée.
+- `type`
+  - : Le type de règle utilisée (`cardinal` ou `ordinal`).
 
-<p>Seul l'un de ces deux groupes de propriétés est inclus :</p>
+Seul l'un de ces deux groupes de propriétés est inclus :
 
-<dl>
- <dt><code>minimumIntegerDigits</code>, <code>minimumFractionDigits</code>, <code>maximumFractionDigits</code></dt>
- <dd>Les valeurs fournies pour ces propriétés via l'argument <code>options</code> ou les valeurs par défaut. Ces propriétés sont uniquement présentes si aucunes des propriétés <code>minimumSignificantDigits</code> ou <code>maximumSignificantDigits</code> n'a été fournie dans l'argument <code>options</code>.</dd>
- <dt><code>minimumSignificantDigits</code>, <code>maximumSignificantDigits</code></dt>
- <dd>Les valeurs fournies par ces propriétés via l'argument <code>options</code> ou les valeurs par défaut. Ces propriétés sont uniquement présentes si au moins l'une d'entre elles a été fournie dans l'argument <code>options</code>.</dd>
-</dl>
+- `minimumIntegerDigits`, `minimumFractionDigits`, `maximumFractionDigits`
+  - : Les valeurs fournies pour ces propriétés via l'argument `options` ou les valeurs par défaut. Ces propriétés sont uniquement présentes si aucunes des propriétés `minimumSignificantDigits` ou `maximumSignificantDigits` n'a été fournie dans l'argument `options`.
+- `minimumSignificantDigits`, `maximumSignificantDigits`
+  - : Les valeurs fournies par ces propriétés via l'argument `options` ou les valeurs par défaut. Ces propriétés sont uniquement présentes si au moins l'une d'entre elles a été fournie dans l'argument `options`.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_resolvedOptions">Utiliser <code>resolvedOptions()</code></h3>
+### Utiliser `resolvedOptions()`
 
-<pre class="brush: js">var de = new Intl.PluralRules('de-DE');
+```js
+var de = new Intl.PluralRules('de-DE');
 var usedOptions = de.resolvedOptions();
 
 usedOptions.locale;                // "de-DE"
@@ -59,31 +56,18 @@ usedOptions.minimumFractionDigits; // 0
 usedOptions.minimumIntegerDigits;  // 1
 usedOptions.pluralCategories;      // Array [ "one", "other" ]
 usedOptions.type;                  // "cardinal"
-</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><a href="https://rawgit.com/caridy/intl-plural-rules-spec/master/index.html">Brouillon pour les règles de nombre avec <code>Intl</code></a></td>
-   <td>Brouillon</td>
-   <td>Définition initiale.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Intl.PluralRules.resolvedOptions")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("PluralRules", "Intl.PluralRules")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                         | État      | Commentaires         |
+| --------------------------------------------------------------------------------------------------------------------- | --------- | -------------------- |
+| [Brouillon pour les règles de nombre avec `Intl`](https://rawgit.com/caridy/intl-plural-rules-spec/master/index.html) | Brouillon | Définition initiale. |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Intl.PluralRules.resolvedOptions")}}
+
+## Voir aussi
+
+- {{jsxref("PluralRules", "Intl.PluralRules")}}
diff --git a/files/fr/web/javascript/reference/global_objects/intl/pluralrules/select/index.md b/files/fr/web/javascript/reference/global_objects/intl/pluralrules/select/index.md
index d8a329b4a8..cc4c837203 100644
--- a/files/fr/web/javascript/reference/global_objects/intl/pluralrules/select/index.md
+++ b/files/fr/web/javascript/reference/global_objects/intl/pluralrules/select/index.md
@@ -11,28 +11,27 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Intl/PluralRules/select
 original_slug: Web/JavaScript/Reference/Objets_globaux/Intl/PluralRules/select
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>Intl.PluralRules.prototype.select</code></strong> renvoie une chaîne de caractères qui indique la règle de nombre utilisée pour le formatage relatif à la locale.</p>
+La méthode **`Intl.PluralRules.prototype.select`** renvoie une chaîne de caractères qui indique la règle de nombre utilisée pour le formatage relatif à la locale.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><code><var>pluralRule</var>.select(<var>nombre</var>)</code></pre>
+    pluralRule.select(nombre)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>nombre</code></dt>
- <dd>Le nombre pour lequel on souhaite obtenir la règle de nombre associée.</dd>
-</dl>
+- `nombre`
+  - : Le nombre pour lequel on souhaite obtenir la règle de nombre associée.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Cette fonction permet de sélectionner une règle de nombre en fonction de la locale et des options de formatage choisies via un objet {{jsxref("PluralRules")}}.</p>
+Cette fonction permet de sélectionner une règle de nombre en fonction de la locale et des options de formatage choisies via un objet {{jsxref("PluralRules")}}.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<pre class="brush: js"> new Intl.PluralRules('ar-EG').select(0);
+```js
+ new Intl.PluralRules('ar-EG').select(0);
 // → 'zero'
 
 new Intl.PluralRules('ar-EG').select(1);
@@ -46,31 +45,18 @@ new Intl.PluralRules('ar-EG').select(6);
 
 new Intl.PluralRules('ar-EG').select(18);
 // → 'many'
-</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><a href="https://rawgit.com/caridy/intl-plural-rules-spec/master/index.html">Brouillon pour les règles de nombre avec Intl</a></td>
-   <td>{{Spec2('ES Int Draft')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Intl.PluralRules.select")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("PluralRules", "Intl.PluralRules")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                       | État                             | Commentaires         |
+| ------------------------------------------------------------------------------------------------------------------- | -------------------------------- | -------------------- |
+| [Brouillon pour les règles de nombre avec Intl](https://rawgit.com/caridy/intl-plural-rules-spec/master/index.html) | {{Spec2('ES Int Draft')}} | Définition initiale. |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Intl.PluralRules.select")}}
+
+## Voir aussi
+
+- {{jsxref("PluralRules", "Intl.PluralRules")}}
diff --git a/files/fr/web/javascript/reference/global_objects/intl/pluralrules/supportedlocalesof/index.md b/files/fr/web/javascript/reference/global_objects/intl/pluralrules/supportedlocalesof/index.md
index 0c20fbcf7e..8f93737a64 100644
--- a/files/fr/web/javascript/reference/global_objects/intl/pluralrules/supportedlocalesof/index.md
+++ b/files/fr/web/javascript/reference/global_objects/intl/pluralrules/supportedlocalesof/index.md
@@ -11,71 +11,54 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Intl/PluralRules/supportedLocalesOf
 original_slug: Web/JavaScript/Reference/Objets_globaux/Intl/PluralRules/supportedLocalesOf
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>Intl.PluralRules.supportedLocalesOf()</code></strong> renvoie un tableau contenant les locales prises en charge, parmi celles passées en argument, pour les règles de nombre (sans avoir à utiliser la locale par défaut du système d'exécution).</p>
+La méthode **`Intl.PluralRules.supportedLocalesOf()`** renvoie un tableau contenant les locales prises en charge, parmi celles passées en argument, pour les règles de nombre (sans avoir à utiliser la locale par défaut du système d'exécution).
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><code>Intl.PluralRules.supportedLocalesOf(<var>locales</var>[, <var>options</var>])</code></pre>
+    Intl.PluralRules.supportedLocalesOf(locales[, options])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>locales</code></dt>
- <dd>Une chaîne de caractères représentant une balise de langue BCP 47 ou bien un tableau de telles chaînes. Pour la forme générale de l'argument <code>locales</code>, se référer à la page {{jsxref("Intl", "Intl", "#Identification_et_choix_de_la_locale", 1)}}.</dd>
- <dt><code>options</code> {{optional_inline}}</dt>
- <dd>
- <p>Optionnel. Un objet pouvant contenir la propriété suivante :</p>
+- `locales`
+  - : Une chaîne de caractères représentant une balise de langue BCP 47 ou bien un tableau de telles chaînes. Pour la forme générale de l'argument `locales`, se référer à la page {{jsxref("Intl", "Intl", "#Identification_et_choix_de_la_locale", 1)}}.
+- `options` {{optional_inline}}
 
- <dl>
-  <dt><code>localeMatcher</code></dt>
-  <dd>L'algorithme de correspondance à utiliser pour la locale. Les valeurs possibles sont <code>"lookup"</code> et <code>"best fit"</code> ; le défaut est <code>"best fit"</code>. Pour des informations sur cette option, voir la page {{jsxref("Objets_globaux/Intl","Intl","##Choix_de_la_locale")}}.</dd>
- </dl>
- </dd>
-</dl>
+  - : Optionnel. Un objet pouvant contenir la propriété suivante :
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+    - `localeMatcher`
+      - : L'algorithme de correspondance à utiliser pour la locale. Les valeurs possibles sont `"lookup"` et `"best fit"` ; le défaut est `"best fit"`. Pour des informations sur cette option, voir la page {{jsxref("Objets_globaux/Intl","Intl","##Choix_de_la_locale")}}.
 
-<p>Un tableau de chaînes de caractères représentant le sous-ensemble de balises de langues prises en charge pour le formatage avec les règles de nombre (sans qu'il soit nécssaire d'utiliser la locale par défaut du système d'exploitation).</p>
+### Valeur de retour
 
-<h2 id="Description">Description</h2>
+Un tableau de chaînes de caractères représentant le sous-ensemble de balises de langues prises en charge pour le formatage avec les règles de nombre (sans qu'il soit nécssaire d'utiliser la locale par défaut du système d'exploitation).
 
-<p>Cette méthode renvoie un tableau contenant un sous-ensemble des balises de langue fournies dans l'argument <code>locales</code>. Les balises de langue sont celles qui sont prises en charge par l'environnement pour le formatage avec les règles de nombre et pour lesquelles la locale respecte l'algorithme de correspondance indiqué. Les locales de ce tableau évitent d'avoir à utiliser la locale du système d'exécution par défaut.</p>
+## Description
 
-<h2 id="Exemples">Exemples</h2>
+Cette méthode renvoie un tableau contenant un sous-ensemble des balises de langue fournies dans l'argument `locales`. Les balises de langue sont celles qui sont prises en charge par l'environnement pour le formatage avec les règles de nombre et pour lesquelles la locale respecte l'algorithme de correspondance indiqué. Les locales de ce tableau évitent d'avoir à utiliser la locale du système d'exécution par défaut.
 
-<p>Dans l'hypothèse où on utilise un système prenant en charge l'indonésien, l'allemand mais pas le balinais pour le formatage avec les règles de nombre, <code>supportedLocalesOf</code> renvoie les balises de langue indonésienne et allemande inchangées bien que la collation <code>pinyin</code> ne soit pas pertinente ni utilisée avec l'indonésien (et qu'il est peu probable qu'une variante indonésienne pour l'allemand soit prise en charge). On notera que l'algorithme de correspondance <code>"lookup"</code> est utilisé ici. L'algorithme <code>"best fit"</code> aurait pu déterminer que l'indonésien aurait pu remplacer le balinais car la plupart des personnes parlant le balinais comprend également l'indonésien, la fonction aurait alors pu remplacer la balise de langue balinaise.</p>
+## Exemples
 
-<pre class="brush: js">var locales = ['ban', 'id-u-co-pinyin', 'de-ID'];
+Dans l'hypothèse où on utilise un système prenant en charge l'indonésien, l'allemand mais pas le balinais pour le formatage avec les règles de nombre, `supportedLocalesOf` renvoie les balises de langue indonésienne et allemande inchangées bien que la collation `pinyin` ne soit pas pertinente ni utilisée avec l'indonésien (et qu'il est peu probable qu'une variante indonésienne pour l'allemand soit prise en charge). On notera que l'algorithme de correspondance `"lookup"` est utilisé ici. L'algorithme `"best fit"` aurait pu déterminer que l'indonésien aurait pu remplacer le balinais car la plupart des personnes parlant le balinais comprend également l'indonésien, la fonction aurait alors pu remplacer la balise de langue balinaise.
+
+```js
+var locales = ['ban', 'id-u-co-pinyin', 'de-ID'];
 var options = { localeMatcher: 'lookup' };
 console.log(Intl.PluralRules.supportedLocalesOf(locales, options).join(', '));
 // → "id-u-co-pinyin, de-ID"
-</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><a href="https://rawgit.com/caridy/intl-plural-rules-spec/master/index.html">Brouillon pour les règles de nombre avec <code>Intl</code></a></td>
-   <td>{{Spec2('ES Int Draft')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Intl.PluralRules.supportedLocalesOf")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("PluralRules", "Intl.PluralRules")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                         | État                             | Commentaires         |
+| --------------------------------------------------------------------------------------------------------------------- | -------------------------------- | -------------------- |
+| [Brouillon pour les règles de nombre avec `Intl`](https://rawgit.com/caridy/intl-plural-rules-spec/master/index.html) | {{Spec2('ES Int Draft')}} | Définition initiale. |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Intl.PluralRules.supportedLocalesOf")}}
+
+## Voir aussi
+
+- {{jsxref("PluralRules", "Intl.PluralRules")}}
diff --git a/files/fr/web/javascript/reference/global_objects/intl/relativetimeformat/format/index.md b/files/fr/web/javascript/reference/global_objects/intl/relativetimeformat/format/index.md
index ad924c3837..3f1e19cee0 100644
--- a/files/fr/web/javascript/reference/global_objects/intl/relativetimeformat/format/index.md
+++ b/files/fr/web/javascript/reference/global_objects/intl/relativetimeformat/format/index.md
@@ -10,36 +10,33 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Intl/RelativeTimeFormat/format
 original_slug: Web/JavaScript/Reference/Objets_globaux/Intl/RelativeTimeFormat/format
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}La méthode **`Intl.RelativeTimeFormat.prototype.format()`** permet de formater une valeur avec une unité selon des options de locale et de formatage stockées dans l'objet {{jsxref("RelativeTimeFormat")}}.{{EmbedInteractiveExample("pages/js/intl-relativetimeformat-prototype-format.html")}}
 
-<div>La méthode <strong><code>Intl.RelativeTimeFormat.prototype.format()</code></strong> permet de formater une valeur avec une unité selon des options de locale et de formatage stockées dans l'objet {{jsxref("RelativeTimeFormat")}}.</div>
+## Syntaxe
 
-<div>{{EmbedInteractiveExample("pages/js/intl-relativetimeformat-prototype-format.html")}}</div>
+```js
+RelativeTimeFormat.format(valeur, unite)
+```
 
-<h2 id="Syntaxe">Syntaxe</h2>
+### Paramètres
 
-<pre class="brush: js"><code>RelativeTimeFormat.format(valeur, unite)</code></pre>
+- `valeur`
+  - : Une valeur numérique qu'on souhaite utiliser pour exprimer un temps relatif dans un message internationalisé.
+- `unite`
+  - : L'unité à utiliser pour le message internationalisé exprimant le temps relatif. Les valeurs possibles pour cet argument sont `"year"` (année), `"quarter"` (trimestre), `"month"` (mois), `"week"` (semaine), `"day"` (jour), `"hour"` (heure), `"minute"` (minute), `"second"` (secondes). Les formes plurielles sont également autorisées.
 
-<h3 id="Paramètres">Paramètres</h3>
+## Description
 
-<dl>
- <dt><code>valeur</code></dt>
- <dd>Une valeur numérique qu'on souhaite utiliser pour exprimer un temps relatif dans un message internationalisé.</dd>
- <dt><code>unite</code></dt>
- <dd>L'unité à utiliser pour le message internationalisé exprimant le temps relatif. Les valeurs possibles pour cet argument sont <code>"year"</code> (année), <code>"quarter"</code> (trimestre), <code>"month"</code> (mois), <code>"week"</code> (semaine), <code>"day"</code> (jour), <code>"hour"</code> (heure), <code>"minute"</code> (minute), <code>"second"</code> (secondes). Les formes plurielles sont également autorisées.</dd>
-</dl>
+La fonction renvoyée par l'accesseur `format` permet de formater une valeur et une unité en une chaîne de caractères en prenant en compte la locale et les options de formatage associées à l'objet {{jsxref("RelativeTimeFormat", "Intl.RelativeTimeFormat")}} utilisé.
 
-<h2 id="Description">Description</h2>
+## Exemples
 
-<p>La fonction renvoyée par l'accesseur <code>format</code> permet de formater une valeur et une unité en une chaîne de caractères en prenant en compte la locale et les options de formatage associées à l'objet {{jsxref("RelativeTimeFormat", "Intl.RelativeTimeFormat")}} utilisé.</p>
+### Utilisation simple de `format`
 
-<h2 id="Exemples">Exemples</h2>
+L'exemple suivant illustre comment créer un outil de formatage pour les valeurs de temps relatifs en anglais.
 
-<h3 id="Utilisation_simple_de_format">Utilisation simple de <code>format</code></h3>
-
-<p>L'exemple suivant illustre comment créer un outil de formatage pour les valeurs de temps relatifs en anglais.</p>
-
-<pre class="brush: js">// On crée un outil de formatage pour les valeurs exprimant
+```js
+// On crée un outil de formatage pour les valeurs exprimant
 // les temps relatifs en anglais, avec les valeurs par défaut
 // utilisées explicitement.
 const rtf = new Intl.RelativeTimeFormat("en", {
@@ -50,48 +47,37 @@ const rtf = new Intl.RelativeTimeFormat("en", {
 
 // Formatage d'une valeur relative négative.
 rtf.format(-1, "day");
-// &gt; "1 day ago"
+// > "1 day ago"
 
 // Formatage d'une valeur relative positive.
 rtf.format(1, "day");
-// &gt; "in 1 day"</pre>
+// > "in 1 day"
+```
 
-<h3 id="Utiliser_loption_auto">Utiliser l'option <code>auto</code></h3>
+### Utiliser l'option `auto`
 
-<p>Si on passe l'option <code>numeric:auto</code>, c'est la chaîne de caractères <code>yesterday</code> ou <code>tomorrow</code> qui sera produite (en anglais) plutôt que <code>1 day ago</code> ou <code>in 1 day</code>. Cela permet de n'avoir pas nécessairement une valeur numérique en résultat.</p>
+Si on passe l'option `numeric:auto`, c'est la chaîne de caractères `yesterday` ou `tomorrow` qui sera produite (en anglais) plutôt que `1 day ago` ou `in 1 day`. Cela permet de n'avoir pas nécessairement une valeur numérique en résultat.
 
-<pre class="brush: js">// On crée un formateur en anglais avec l'option
+```js
+// On crée un formateur en anglais avec l'option
 // numeric: "auto".
 const rtf = new Intl.RelativeTimeFormat("en", { numeric: "auto" });
 
 // Formatage d'une valeur relative négative.
 rtf.format(-1, "day");
-// &gt; "yesterday"
+// > "yesterday"
 
 // Formatage d'une valeur relative positive.
 rtf.format(1, "day");
-// &gt; "tomorrow"
-</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><a href="https://tc39.github.io/proposal-intl-relative-time/#sec-Intl.RelativeTimeFormat.prototype.format">Proposition pour <code>Intl.RelativeTime</code></a></td>
-   <td>Proposition de niveau 3</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Intl.RelativeTimeFormat.format")}}</p>
+// > "tomorrow"
+```
+
+## Spécifications
+
+| Spécification                                                                                                                            | État                    | Commentaires |
+| ---------------------------------------------------------------------------------------------------------------------------------------- | ----------------------- | ------------ |
+| [Proposition pour `Intl.RelativeTime`](https://tc39.github.io/proposal-intl-relative-time/#sec-Intl.RelativeTimeFormat.prototype.format) | Proposition de niveau 3 |              |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Intl.RelativeTimeFormat.format")}}
diff --git a/files/fr/web/javascript/reference/global_objects/intl/relativetimeformat/formattoparts/index.md b/files/fr/web/javascript/reference/global_objects/intl/relativetimeformat/formattoparts/index.md
index c8c141e6e3..be57f9e3d3 100644
--- a/files/fr/web/javascript/reference/global_objects/intl/relativetimeformat/formattoparts/index.md
+++ b/files/fr/web/javascript/reference/global_objects/intl/relativetimeformat/formattoparts/index.md
@@ -10,71 +10,58 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Intl/RelativeTimeFormat/formatToParts
 original_slug: Web/JavaScript/Reference/Objets_globaux/Intl/RelativeTimeFormat/formatToParts
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>Intl.RelativeTimeFormat.prototype.formatToParts()</code></strong> est une méthode analogue à <code><a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Intl.RelativeTimeFormat/format">format()</a></code> qui renvoie un tableau d'objets contenant les différentes parties représentant le message internationalisé pour le temps relatif.</p>
+La méthode **`Intl.RelativeTimeFormat.prototype.formatToParts()`** est une méthode analogue à [`format()`](/fr/docs/Web/JavaScript/Reference/Objets_globaux/Intl.RelativeTimeFormat/format) qui renvoie un tableau d'objets contenant les différentes parties représentant le message internationalisé pour le temps relatif.
 
-<div>{{EmbedInteractiveExample("pages/js/intl-relativetimeformat-prototype-formattoparts.html")}}</div>
+{{EmbedInteractiveExample("pages/js/intl-relativetimeformat-prototype-formattoparts.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="brush: js"><code>RelativeTimeFormat.formatToParts(valeur, unite)</code></pre>
+```js
+RelativeTimeFormat.formatToParts(valeur, unite)
+```
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>valeur</code></dt>
- <dd>Une valeur numérique qu'on souhaite formater pour un message internationalisé exprimant un temps relatif.</dd>
- <dt><code>unite</code></dt>
- <dd>L'unité à utiliser pour le message internationalisé exprimant le temps relatif. Les valeurs possibles pour cet argument sont <code>"year"</code> (année), <code>"quarter"</code> (trimestre), <code>"month"</code> (mois), <code>"week"</code> (semaine), <code>"day"</code> (jour), <code>"hour"</code> (heure), <code>"minute"</code> (minute), <code>"second"</code> (secondes). Les formes plurielles sont également autorisées.</dd>
-</dl>
+- `valeur`
+  - : Une valeur numérique qu'on souhaite formater pour un message internationalisé exprimant un temps relatif.
+- `unite`
+  - : L'unité à utiliser pour le message internationalisé exprimant le temps relatif. Les valeurs possibles pour cet argument sont `"year"` (année), `"quarter"` (trimestre), `"month"` (mois), `"week"` (semaine), `"day"` (jour), `"hour"` (heure), `"minute"` (minute), `"second"` (secondes). Les formes plurielles sont également autorisées.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un tableau ({{jsxref("Array")}}) d'objets contenant les fragments composant la chaîne de caractères localisée et mise en forme pour exprimer le temps relatif.</p>
+Un tableau ({{jsxref("Array")}}) d'objets contenant les fragments composant la chaîne de caractères localisée et mise en forme pour exprimer le temps relatif.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<div>La méthode <code>Intl.RelativeTimeFormat.prototype.formatToParts()</code> est une méthode analogue à la méthode <code>format()</code> mais renvoie un tableau d'objets représentant chacun une partie du message internationalisé. Ces objets ont deux propriétés : <code>type</code> et <code>value</code>. Si un des composants provient de <code>NumberFormat</code>, il aura une propriété <code>unit</code> indiquant l'unité utilisée pour le formatage.</div>
+La méthode `Intl.RelativeTimeFormat.prototype.formatToParts()` est une méthode analogue à la méthode `format()` mais renvoie un tableau d'objets représentant chacun une partie du message internationalisé. Ces objets ont deux propriétés : `type` et `value`. Si un des composants provient de `NumberFormat`, il aura une propriété `unit` indiquant l'unité utilisée pour le formatage.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<pre class="brush: js">const rtf = new Intl.RelativeTimeFormat("en", { numeric: "auto" });
+```js
+const rtf = new Intl.RelativeTimeFormat("en", { numeric: "auto" });
 
 // Format relative time using the day unit.
 rtf.formatToParts(-1, "day");
-// &gt; [{ type: "literal", value: "yesterday"}]
+// > [{ type: "literal", value: "yesterday"}]
 
 rtf.formatToParts(100, "day");
-// &gt; [{ type: "literal", value: "in " },
+// > [{ type: "literal", value: "in " },
       { type: "integer", value: "100", unit: "day" },
-      { type: "literal", value: " days" }]</pre>
-
-<h2 id="Spécifications">Spécifications</h2>
-
-<table class="standard-table">
- <thead>
-  <tr>
-   <th scope="col">Spécifications</th>
-   <th scope="col">État</th>
-   <th scope="col">Commentaires</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td><a href="https://tc39.github.io/proposal-intl-relative-time/#sec-Intl.RelativeTimeFormat.prototype.formatToParts">Proposition pour <code>Intl.RelativeTime</code></a></td>
-   <td>Proposition de niveau 3</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Intl.RelativeTimeFormat.formatToParts")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("RelativeTimeFormat", "Intl.RelativeTimeFormat")}}</li>
-</ul>
+      { type: "literal", value: " days" }]
+```
+
+## Spécifications
+
+| Spécifications                                                                                                                                  | État                    | Commentaires |
+| ----------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------- | ------------ |
+| [Proposition pour `Intl.RelativeTime`](https://tc39.github.io/proposal-intl-relative-time/#sec-Intl.RelativeTimeFormat.prototype.formatToParts) | Proposition de niveau 3 |              |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Intl.RelativeTimeFormat.formatToParts")}}
+
+## Voir aussi
+
+- {{jsxref("RelativeTimeFormat", "Intl.RelativeTimeFormat")}}
diff --git a/files/fr/web/javascript/reference/global_objects/intl/relativetimeformat/index.md b/files/fr/web/javascript/reference/global_objects/intl/relativetimeformat/index.md
index 96a0d534dd..85bfd8665a 100644
--- a/files/fr/web/javascript/reference/global_objects/intl/relativetimeformat/index.md
+++ b/files/fr/web/javascript/reference/global_objects/intl/relativetimeformat/index.md
@@ -10,74 +10,65 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Intl/RelativeTimeFormat
 original_slug: Web/JavaScript/Reference/Objets_globaux/Intl/RelativeTimeFormat
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>L'objet <strong><code>Intl.RelativeTimeFormat</code></strong> est un constructeur fournissant des objets pour mettre en forme des données temporelles relatives en respectant le format des locales.</p>
+L'objet **`Intl.RelativeTimeFormat`** est un constructeur fournissant des objets pour mettre en forme des données temporelles relatives en respectant le format des locales.
 
-<div>{{EmbedInteractiveExample("pages/js/intl-relativetimeformat.html")}}</div>
+{{EmbedInteractiveExample("pages/js/intl-relativetimeformat.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre>new Intl.RelativeTimeFormat([<var>locales</var>[, <var>options</var>]])</pre>
+    new Intl.RelativeTimeFormat([locales[, options]])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>locales</code></dt>
- <dd>
- <p>Une chaine de caractères avec un identifiant de langue BCP 47, ou un tableau de ce type de chaine de caractères. Pour le format général et l'interprétation de l'argument <code>locales</code>, voir la page {{jsxref("Objets_globaux/Intl","Intl","#L'identification_et_le_choix_de_la_locale")}}.</p>
- </dd>
- <dt><code>options</code> {{optional_inline}}</dt>
- <dd>
- <p>Optionnel, un objet possédant tout ou partie des propriétés suivantes :</p>
- <dl>
-  <dt><code>localeMatcher</code></dt>
-  <dd>L'algorithme de correspondance à utiliser pour la locale. Les valeurs possibles sont <code>"lookup"</code> et <code>"best fit"</code> ; le défaut est <code>"best fit"</code>. Pour des informations sur cette option, voir la page {{jsxref("Objets_globaux/Intl","Intl","##Choix_de_la_locale")}}.</dd>
-  <dt><code>numeric</code></dt>
-  <dd>Le format du message de sortie. Les valeurs possibles sont <code>"always"</code> (par exemple <code>1 day ago</code>) ou  <code>"auto"</code> (par exemple <code>yesterday</code>). <code>"auto"</code> permet de ne pas toujours avoir de valeurs numériques dans le message produit.</dd>
-  <dt><code>style</code></dt>
-  <dd>La longueur du message internationalisé. Les valeurs possibles sont : <code>"long"</code> (la valeur par défaut) (par exemple : <code>in 1 month</code>), <code>"short"</code> (par exemple : <code>in 1 mo.</code>) ou  <code>"narrow"</code> (par exemple : <code>in 1 mo.</code>). Le style <code>narrow</code> peut être semblable au style <code>short</code> pour certaines locales.</dd>
- </dl>
- </dd>
-</dl>
+- `locales`
+  - : Une chaine de caractères avec un identifiant de langue BCP 47, ou un tableau de ce type de chaine de caractères. Pour le format général et l'interprétation de l'argument `locales`, voir la page {{jsxref("Objets_globaux/Intl","Intl","#L'identification_et_le_choix_de_la_locale")}}.
+- `options` {{optional_inline}}
 
-<h2 id="Description">Description</h2>
+  - : Optionnel, un objet possédant tout ou partie des propriétés suivantes :
 
-<h3 id="Propriétés">Propriétés</h3>
+    - `localeMatcher`
+      - : L'algorithme de correspondance à utiliser pour la locale. Les valeurs possibles sont `"lookup"` et `"best fit"` ; le défaut est `"best fit"`. Pour des informations sur cette option, voir la page {{jsxref("Objets_globaux/Intl","Intl","##Choix_de_la_locale")}}.
+    - `numeric`
+      - : Le format du message de sortie. Les valeurs possibles sont `"always"` (par exemple `1 day ago`) ou  `"auto"` (par exemple `yesterday`). `"auto"` permet de ne pas toujours avoir de valeurs numériques dans le message produit.
+    - `style`
+      - : La longueur du message internationalisé. Les valeurs possibles sont : `"long"` (la valeur par défaut) (par exemple : `in 1 month`), `"short"` (par exemple : `in 1 mo.`) ou  `"narrow"` (par exemple : `in 1 mo.`). Le style `narrow` peut être semblable au style `short` pour certaines locales.
 
-<dl>
- <dt>{{jsxref("RelativeTimeFormat.prototype", "Intl.RelativeTimeFormat.prototype")}}</dt>
- <dd>Cette propriété permet d'ajouter des propriétés à l'ensemble des instances.</dd>
-</dl>
+## Description
 
-<h3 id="Méthodes">Méthodes</h3>
+### Propriétés
 
-<dl>
- <dt>{{jsxref("RelativeTimeFormat.supportedLocalesOf", "Intl.RelativeTimeFormat.supportedLocalesOf()")}}</dt>
- <dd>Cette méthode renvoie un tableau des locales, parmi celles passées en argument, qui sont pris en charge pour le formatage internationalisé des temps relatifs sans qu'il y ait besoin d'utiliser la locale par défaut de l'environnement d'exécution.</dd>
-</dl>
+- {{jsxref("RelativeTimeFormat.prototype", "Intl.RelativeTimeFormat.prototype")}}
+  - : Cette propriété permet d'ajouter des propriétés à l'ensemble des instances.
 
-<h2 id="Les_instances_de_RelativeTimeFormat">Les instances de <code>RelativeTimeFormat</code></h2>
+### Méthodes
 
-<h3 id="Propriétés_2">Propriétés</h3>
+- {{jsxref("RelativeTimeFormat.supportedLocalesOf", "Intl.RelativeTimeFormat.supportedLocalesOf()")}}
+  - : Cette méthode renvoie un tableau des locales, parmi celles passées en argument, qui sont pris en charge pour le formatage internationalisé des temps relatifs sans qu'il y ait besoin d'utiliser la locale par défaut de l'environnement d'exécution.
 
-<p>Les instances de RelativeTimeFormat héritent des propriétés suivantes grâce à leur prototype :</p>
+## Les instances de `RelativeTimeFormat`
 
-<p>{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/Intl.RelativeTimeFormat/prototype', 'Propriétés')}}</p>
+### Propriétés
 
-<h3 id="Méthodes_2">Méthodes</h3>
+Les instances de RelativeTimeFormat héritent des propriétés suivantes grâce à leur prototype :
 
-<p>Les instances de <code>RelativeTimeFormat</code> héritent des méthodes suivantes grâce à leur prototype :</p>
+{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/Intl.RelativeTimeFormat/prototype', 'Propriétés')}}
 
-<p>{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/Intl.RelativeTimeFormat/prototype', 'Méthodes')}}</p>
+### Méthodes
 
-<h2 id="Exemples">Exemples</h2>
+Les instances de `RelativeTimeFormat` héritent des méthodes suivantes grâce à leur prototype :
 
-<h3 id="Utiliser_format">Utiliser <code>format()</code></h3>
+{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/Intl.RelativeTimeFormat/prototype', 'Méthodes')}}
 
-<p>L'exemple suivant illustre comment créer un formateur de temps relatif en anglais :</p>
+## Exemples
 
-<pre class="brush: js">// On crée un formateur en anglais en utilisant explicitement
+### Utiliser `format()`
+
+L'exemple suivant illustre comment créer un formateur de temps relatif en anglais :
+
+```js
+// On crée un formateur en anglais en utilisant explicitement
 // les valeurs par défaut.
 const rtf = new Intl.RelativeTimeFormat("en", {
     localeMatcher: "best fit", // autre valeur possible : "lookup"
@@ -87,68 +78,58 @@ const rtf = new Intl.RelativeTimeFormat("en", {
 
 // On formate un temps relatif avec une valeur négative (-1).
 rtf.format(-1, "day");
-// &gt; "1 day ago"
+// > "1 day ago"
 
 // On formate un temps relatif avec une valeur positive (1).
 rtf.format(1, "day");
-// &gt; "in 1 day"</pre>
+// > "in 1 day"
+```
 
-<h3 id="Utiliser_loption_auto">Utiliser l'option <code>auto</code></h3>
+### Utiliser l'option `auto`
 
-<p>Si l'option <code>numeric:auto</code> est passée, on aura la chaîne de caractères <code>yesterday</code> ou <code>tomorrow</code> plutôt que <code>1 day ago</code> ou <code>in 1 day</code>. De cette façon, on peut ne pas avoir de valeur numérique dans la valeur produite.</p>
+Si l'option `numeric:auto` est passée, on aura la chaîne de caractères `yesterday` ou `tomorrow` plutôt que `1 day ago` ou `in 1 day`. De cette façon, on peut ne pas avoir de valeur numérique dans la valeur produite.
 
-<pre class="brush: js">// On crée un formateur en anglais avec l'option
+```js
+// On crée un formateur en anglais avec l'option
 // numeric: "auto".
 const rtf = new Intl.RelativeTimeFormat("en", { numeric: "auto" });
 
 // On formate un temps relatif avec une valeur négative (-1).
 rtf.format(-1, "day");
-// &gt; "yesterday"
+// > "yesterday"
 
 // On formate un temps relatif avec une valeur positive (1).
 rtf.format(1, "day");
-// &gt; "tomorrow"
-</pre>
+// > "tomorrow"
+```
 
-<h3 id="Utiliser_formatToParts">Utiliser <code>formatToParts()</code></h3>
+### Utiliser `formatToParts()`
 
-<p>L'exemple suivant illustre comment créer un formateur de temps relatif qui renvoie les différents fragments pour exprimer le temps relatif internationalisé.</p>
+L'exemple suivant illustre comment créer un formateur de temps relatif qui renvoie les différents fragments pour exprimer le temps relatif internationalisé.
 
-<pre class="brush: js">const rtf = new Intl.RelativeTimeFormat("en", { numeric: "auto" });
+```js
+const rtf = new Intl.RelativeTimeFormat("en", { numeric: "auto" });
 
 // On crée un temps relatif exprimé en jour.
 rtf.formatToParts(-1, "day");
-// &gt; [{ type: "literal", value: "yesterday"}]
+// > [{ type: "literal", value: "yesterday"}]
 
 rtf.formatToParts(100, "day");
-// &gt; [{ type: "literal", value: "in " },
+// > [{ type: "literal", value: "in " },
       { type: "integer", value: "100", unit: "day" },
       { type: "literal", value: " days" }]
-</pre>
-
-<h2 id="Spécifications">Spécifications</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">Etat</th>
-   <th scope="col">Commentaires</th>
-  </tr>
-  <tr>
-   <td><a href="https://tc39.es/proposal-intl-relative-time/#sec-intl-relativetimeformat-constructor">Proposition pour le constructeur <code>Intl.RelativeTimeFormat</code></a></td>
-   <td>Proposition de niveau 3</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Intl.RelativeTimeFormat")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li><a href="https://developers.google.com/web/updates/2018/10/intl-relativetimeformat">L'API <code>Intl.RelativeTimeFormat</code>, un billet de Mathias Bynens (en anglais)</a></li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                                                      | Etat                    | Commentaires |
+| -------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------- | ------------ |
+| [Proposition pour le constructeur `Intl.RelativeTimeFormat`](https://tc39.es/proposal-intl-relative-time/#sec-intl-relativetimeformat-constructor) | Proposition de niveau 3 |              |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Intl.RelativeTimeFormat")}}
+
+## Voir aussi
+
+- [L'API `Intl.RelativeTimeFormat`, un billet de Mathias Bynens (en anglais)](https://developers.google.com/web/updates/2018/10/intl-relativetimeformat)
diff --git a/files/fr/web/javascript/reference/global_objects/intl/relativetimeformat/resolvedoptions/index.md b/files/fr/web/javascript/reference/global_objects/intl/relativetimeformat/resolvedoptions/index.md
index ed4d45c451..daa3fcb143 100644
--- a/files/fr/web/javascript/reference/global_objects/intl/relativetimeformat/resolvedoptions/index.md
+++ b/files/fr/web/javascript/reference/global_objects/intl/relativetimeformat/resolvedoptions/index.md
@@ -15,84 +15,67 @@ translation_of: >-
 original_slug: >-
   Web/JavaScript/Reference/Objets_globaux/Intl/RelativeTimeFormat/resolvedOptions
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>Intl.RelativeTimeFormat.prototype.resolvedOptions()</code></strong> renvoie un nouvel objet dont les propriétés reflètent les options de format et de locale pour les valeurs temporelles relatives, calculées pendant l'initialisation de l'objet {{jsxref("RelativeTimeFormat")}}.</p>
+La méthode **`Intl.RelativeTimeFormat.prototype.resolvedOptions()`** renvoie un nouvel objet dont les propriétés reflètent les options de format et de locale pour les valeurs temporelles relatives, calculées pendant l'initialisation de l'objet {{jsxref("RelativeTimeFormat")}}.
 
-<div>{{EmbedInteractiveExample("pages/js/intl-relativetimeformat-prototype-resolvedoptions.html")}}</div>
+{{EmbedInteractiveExample("pages/js/intl-relativetimeformat-prototype-resolvedoptions.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>relativeTimeFormat</var>.resolvedOptions()</pre>
+    relativeTimeFormat.resolvedOptions()
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un nouvel objet dont les propriétés reflètent les options de locale et de formatage calculées lors de l'initialisation de l'objet {{jsxref("RelativeTimeFormat")}}.</p>
+Un nouvel objet dont les propriétés reflètent les options de locale et de formatage calculées lors de l'initialisation de l'objet {{jsxref("RelativeTimeFormat")}}.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>L'objet renvoyé par cette méthode possèdera les propriétés suivantes :</p>
+L'objet renvoyé par cette méthode possèdera les propriétés suivantes :
 
-<dl>
- <dt><code>locale</code></dt>
- <dd>La balise de langue BCP 47 qui est réellement utilisée. Si des extensions Unicode étaient fournies avec la balise d'origine et sont supportées pour la locale utilisée, les paires de clés-valeurs seront incluses dans <code>locale</code>.</dd>
- <dt><code>style</code></dt>
- <dd>La longueur du message internationalisé. Les valeurs possibles sont :
- <ul>
-  <li><code>"long"</code> : la valeur par défaut, peu concise (par exemple <code>in 1 month</code>)</li>
-  <li><code>"short"</code> : une valeur plus courte (par exemple <code>in 1 mo.</code>),</li>
-  <li><code>"narrow"</code> : une valeur encore plus courte (pouvant être ambigüe selon les locales) (par exemple <code>in 1 mo.</code>). Les styles <code>narrow</code> et <code>short</code> peuvent être similaires voire identiques pour certaines locales.</li>
- </ul>
- </dd>
- <dt><code>numeric</code></dt>
- <dd>Le format du message produit. Les valeurs possibles sont :
- <ul>
-  <li><code>"always"</code> : la valeur par défaut (par exemple  <code>1 day ago</code>),</li>
-  <li><code>"auto"</code> : cette valeur indique qu'il n'est pas nécessaire d'utiliser de valeur numérique dans le message produit (par exemple <code>yesterday</code>).</li>
- </ul>
- </dd>
- <dt><code>numberingSystem</code></dt>
- <dd>La valeur demandée pour la clé d'extension Unicode <code>"nu"</code> ou la valeur remplie par défaut.</dd>
-</dl>
+- `locale`
+  - : La balise de langue BCP 47 qui est réellement utilisée. Si des extensions Unicode étaient fournies avec la balise d'origine et sont supportées pour la locale utilisée, les paires de clés-valeurs seront incluses dans `locale`.
+- `style`
 
-<h2 id="Exemples">Exemples</h2>
+  - : La longueur du message internationalisé. Les valeurs possibles sont :
 
-<pre class="brush: js">var de = new Intl.RelativeTimeFormat('de-DE');
+    - `"long"` : la valeur par défaut, peu concise (par exemple `in 1 month`)
+    - `"short"` : une valeur plus courte (par exemple `in 1 mo.`),
+    - `"narrow"` : une valeur encore plus courte (pouvant être ambigüe selon les locales) (par exemple `in 1 mo.`). Les styles `narrow` et `short` peuvent être similaires voire identiques pour certaines locales.
+
+- `numeric`
+
+  - : Le format du message produit. Les valeurs possibles sont :
+
+    - `"always"` : la valeur par défaut (par exemple  `1 day ago`),
+    - `"auto"` : cette valeur indique qu'il n'est pas nécessaire d'utiliser de valeur numérique dans le message produit (par exemple `yesterday`).
+
+- `numberingSystem`
+  - : La valeur demandée pour la clé d'extension Unicode `"nu"` ou la valeur remplie par défaut.
+
+## Exemples
+
+```js
+var de = new Intl.RelativeTimeFormat('de-DE');
 var usedOptions = de.resolvedOptions();
 
 usedOptions.locale;          // "de-DE"
 usedOptions.style;           // "long"
 usedOptions.numeric;         // "always"
 usedOptions.numberingSystem; // "latn"
-</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>
-  <tr>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td><a href="https://tc39.github.io/proposal-intl-relative-time/#sec-intl.relativetimeformat.prototype.resolvedoptions">Proposition pour <code>Intl.RelativeTime</code></a></td>
-   <td>Proposition de niveau 3</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Intl.RelativeTimeFormat.resolvedOptions")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("RelativeTimeFormat", "Intl.RelativeTimeFormat")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                                                     | État                    | Commentaires |
+| ------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------- | ------------ |
+|                                                                                                                                                   |                         |              |
+| [Proposition pour `Intl.RelativeTime`](https://tc39.github.io/proposal-intl-relative-time/#sec-intl.relativetimeformat.prototype.resolvedoptions) | Proposition de niveau 3 |              |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Intl.RelativeTimeFormat.resolvedOptions")}}
+
+## Voir aussi
+
+- {{jsxref("RelativeTimeFormat", "Intl.RelativeTimeFormat")}}
diff --git a/files/fr/web/javascript/reference/global_objects/intl/relativetimeformat/supportedlocalesof/index.md b/files/fr/web/javascript/reference/global_objects/intl/relativetimeformat/supportedlocalesof/index.md
index e0a6433b75..261968f2ba 100644
--- a/files/fr/web/javascript/reference/global_objects/intl/relativetimeformat/supportedlocalesof/index.md
+++ b/files/fr/web/javascript/reference/global_objects/intl/relativetimeformat/supportedlocalesof/index.md
@@ -13,73 +13,53 @@ translation_of: >-
 original_slug: >-
   Web/JavaScript/Reference/Objets_globaux/Intl/RelativeTimeFormat/supportedLocalesOf
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>Intl.RelativeTimeFormat.supportedLocalesOf()</code></strong> renvoie un tableau contenant l'ensemble des locales, parmi celles fournies en argument, qui sont prises en charge pour le formatage internationalisé du temps relatif, sans avoir à utiliser la locale par défaut de l'environnement d'exécution.</p>
+La méthode **`Intl.RelativeTimeFormat.supportedLocalesOf()`** renvoie un tableau contenant l'ensemble des locales, parmi celles fournies en argument, qui sont prises en charge pour le formatage internationalisé du temps relatif, sans avoir à utiliser la locale par défaut de l'environnement d'exécution.
 
-<div>{{EmbedInteractiveExample("pages/js/intl-relativetimeformat-prototype-supportedlocalesof.html")}}</div>
+{{EmbedInteractiveExample("pages/js/intl-relativetimeformat-prototype-supportedlocalesof.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre>Intl.RelativeTimeFormat.supportedLocalesOf(<var>locales</var>[, <var>options</var>])</pre>
+    Intl.RelativeTimeFormat.supportedLocalesOf(locales[, options])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>locales</code></dt>
- <dd>Un chaîne de caractères au format d'une balise de langue BCP 47 ou bien un tableau de telles chaînes. Pour plus d'informations sur le format de l'argument <code>locales</code>, voir la page {{jsxref("Intl", "Intl", "#L'identification_et_le_choix_de_la_locale")}}.</dd>
- <dt><code>options</code></dt>
- <dd>
- <p>Paramètre optionnel, un objet pouvant avoir la propriété suivante :</p>
+- `locales`
+  - : Un chaîne de caractères au format d'une balise de langue BCP 47 ou bien un tableau de telles chaînes. Pour plus d'informations sur le format de l'argument `locales`, voir la page {{jsxref("Intl", "Intl", "#L'identification_et_le_choix_de_la_locale")}}.
+- `options`
 
- <dl>
-  <dt><code>localeMatcher</code></dt>
-  <dd>L'algorithme de correspondance entre locales à utiliser. Les valeurs possibles sont "lookup" et "best fit". Pour plus d'informations sur ce sujet, voir la page {{jsxref("Intl", "Intl", "#Choix_de_la_locale")}}.</dd>
- </dl>
- </dd>
-</dl>
+  - : Paramètre optionnel, un objet pouvant avoir la propriété suivante :
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+    - `localeMatcher`
+      - : L'algorithme de correspondance entre locales à utiliser. Les valeurs possibles sont "lookup" et "best fit". Pour plus d'informations sur ce sujet, voir la page {{jsxref("Intl", "Intl", "#Choix_de_la_locale")}}.
 
-<p>Un tableau de chaînes de caractères qui représente un sous-ensemble des balises de langue qui sont prises en charge pour la mise en forme du temps relatif sans qu'il soit nécessaire d'utiliser la locale par défaut de l'environnement d'exécution.</p>
+### Valeur de retour
 
-<h2 id="Description">Description</h2>
+Un tableau de chaînes de caractères qui représente un sous-ensemble des balises de langue qui sont prises en charge pour la mise en forme du temps relatif sans qu'il soit nécessaire d'utiliser la locale par défaut de l'environnement d'exécution.
 
-<p>Cette méthode renvoie un tableau qui est un sous-ensemble de <code>locales</code>. Les balises de langues renvoyées sont celles supportées par l'environnement pour le formatage des temps relatifs. Ces balises sont déterminées en fonction de l'algorithme de correspondances de locale et des locales utilisées. Le tableau résultant fournit les locales qui permettent de ne pas avoir à utiliser la locale par défaut.</p>
+## Description
 
-<h2 id="Examples">Examples</h2>
+Cette méthode renvoie un tableau qui est un sous-ensemble de `locales`. Les balises de langues renvoyées sont celles supportées par l'environnement pour le formatage des temps relatifs. Ces balises sont déterminées en fonction de l'algorithme de correspondances de locale et des locales utilisées. Le tableau résultant fournit les locales qui permettent de ne pas avoir à utiliser la locale par défaut.
 
-<h3 id="Utiliser_supportedLocalesOf">Utiliser <code>supportedLocalesOf()</code></h3>
+## Examples
 
-<p>Si on dispose d'un environnement qui supporte les locales indonésienne et allemande mais pas balinaise pour le formatage des temps relatifs, <code>supportedLocalesOf</code> renverra les balises BCP 47 pour l'indonésien et l'allemand (bien que la collation pinyin ne soit pas pertinente pour les dates ni pour l'indonésien et qu'il soit peu probable qu'une variante indonésienne existe pour l'allemand). Pour l'exemple, on l'utilise l'algorithme <code>"lookup"</code>. Si on utilisait <code>"best fit"</code>, on pourrait considérer que l'indonésien est adéquat pour la locale balinaise (sachant que la plupart des balinais comprend l'indonésien) et donc également renvoyer la balise balinaise.</p>
+### Utiliser `supportedLocalesOf()`
 
-<pre>var locales = ['ban', 'id-u-co-pinyin', 'de-ID'];var options = { localeMatcher: 'lookup' };console.log(Intl.RelativeTimeFormat.supportedLocalesOf(locales, options).join(', '));// → "id-u-co-pinyin, de-ID"</pre>
+Si on dispose d'un environnement qui supporte les locales indonésienne et allemande mais pas balinaise pour le formatage des temps relatifs, `supportedLocalesOf` renverra les balises BCP 47 pour l'indonésien et l'allemand (bien que la collation pinyin ne soit pas pertinente pour les dates ni pour l'indonésien et qu'il soit peu probable qu'une variante indonésienne existe pour l'allemand). Pour l'exemple, on l'utilise l'algorithme `"lookup"`. Si on utilisait `"best fit"`, on pourrait considérer que l'indonésien est adéquat pour la locale balinaise (sachant que la plupart des balinais comprend l'indonésien) et donc également renvoyer la balise balinaise.
 
-<h2 id="Spécifications">Spécifications</h2>
+    var locales = ['ban', 'id-u-co-pinyin', 'de-ID'];var options = { localeMatcher: 'lookup' };console.log(Intl.RelativeTimeFormat.supportedLocalesOf(locales, options).join(', '));// → "id-u-co-pinyin, de-ID"
 
-<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><a href="https://tc39.github.io/proposal-intl-relative-time/#sec-Intl.RelativeTimeFormat.supportedLocalesOf">Proposition pour <code>Intl.RelativeTime</code></a></td>
-   <td>Proposition de niveau 3</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
+## Spécifications
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+| Spécification                                                                                                                              | État                    | Commentaires |
+| ------------------------------------------------------------------------------------------------------------------------------------------ | ----------------------- | ------------ |
+| [Proposition pour `Intl.RelativeTime`](https://tc39.github.io/proposal-intl-relative-time/#sec-Intl.RelativeTimeFormat.supportedLocalesOf) | Proposition de niveau 3 |              |
 
-<p>{{Compat("javascript.builtins.Intl.RelativeTimeFormat.supportedLocalesOf")}}</p>
+## Compatibilité des navigateurs
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+{{Compat("javascript.builtins.Intl.RelativeTimeFormat.supportedLocalesOf")}}
 
-<ul>
- <li>{{jsxref("RelativeTimeFormat", "Intl.RelativeTimeFormat")}}</li>
-</ul>
+## Voir aussi
+
+- {{jsxref("RelativeTimeFormat", "Intl.RelativeTimeFormat")}}
diff --git a/files/fr/web/javascript/reference/global_objects/isfinite/index.md b/files/fr/web/javascript/reference/global_objects/isfinite/index.md
index a127177d6e..2bfa521574 100644
--- a/files/fr/web/javascript/reference/global_objects/isfinite/index.md
+++ b/files/fr/web/javascript/reference/global_objects/isfinite/index.md
@@ -8,36 +8,35 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/isFinite
 original_slug: Web/JavaScript/Reference/Objets_globaux/isFinite
 ---
-<div>{{jsSidebar("Objects")}}</div>
+{{jsSidebar("Objects")}}
 
-<p>La fonction globale <code><strong>isFinite()</strong></code> détermine si la valeur passée en argument est un nombre fini. Si nécessaire, le paramètre est d'abord converti en nombre.</p>
+La fonction globale **`isFinite()`** détermine si la valeur passée en argument est un nombre fini. Si nécessaire, le paramètre est d'abord converti en nombre.
 
-<div>{{EmbedInteractiveExample("pages/js/globalprops-isfinite.html")}}</div>
+{{EmbedInteractiveExample("pages/js/globalprops-isfinite.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">isFinite(<var>valeurÀTester</var>)</pre>
+    isFinite(valeurÀTester)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>valeurÀTester</code></dt>
- <dd>La valeur dont on souhaite savoir si elle est finie ou non.</dd>
-</dl>
+- `valeurÀTester`
+  - : La valeur dont on souhaite savoir si elle est finie ou non.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p><code>false</code> si la valeur passée en argument vaut {{jsxref("Infinity")}} (en positif ou en négatif),{{jsxref("NaN")}} ou {{jsxref("undefined")}}, <code>true</code> sinon.</p>
+`false` si la valeur passée en argument vaut {{jsxref("Infinity")}} (en positif ou en négatif),{{jsxref("NaN")}} ou {{jsxref("undefined")}}, `true` sinon.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p><code>isFinite()</code> est une fonction qui n'est rattachée à aucun objet et qui est disponible au plus haut niveau.</p>
+`isFinite()` est une fonction qui n'est rattachée à aucun objet et qui est disponible au plus haut niveau.
 
-<p>Cette fonction peut être utilisée pour déterminer si un nombre est fini ou non. La fonction <code>isFinite()</code> examine le nombre passé en argument : si celui-ci vaut {{jsxref("NaN")}}, {{jsxref("Infinity")}} (pour l'infini) ou {{jsxref("Infinity","-Infinity")}} (pour l'infini négatif), cette fonction renvoie <code>false</code> sinon elle renvoie <code>true</code>.</p>
+Cette fonction peut être utilisée pour déterminer si un nombre est fini ou non. La fonction `isFinite()` examine le nombre passé en argument : si celui-ci vaut {{jsxref("NaN")}}, {{jsxref("Infinity")}} (pour l'infini) ou {{jsxref("Infinity","-Infinity")}} (pour l'infini négatif), cette fonction renvoie `false` sinon elle renvoie `true`.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<pre class="brush: js">isFinite(Infinity);  // false
+```js
+isFinite(Infinity);  // false
 isFinite(NaN);       // false
 isFinite(-Infinity); // false
 
@@ -50,49 +49,24 @@ isFinite(null);      // true, ce qui aurait été false
 
 isFinite("0");       // true ce qui aurait été false
                      // avec la méthode Number.isFinite("0")
-</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('ES2')}}</td>
-   <td>{{Spec2('ES3')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.1.2.5', 'isFinite')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-isfinite-number', 'isFinite')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-isfinite-number', 'isFinite')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.isFinite")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Number.isFinite()")}}</li>
- <li>{{jsxref("Number.NaN")}}</li>
- <li>{{jsxref("Number.POSITIVE_INFINITY")}}</li>
- <li>{{jsxref("Number.NEGATIVE_INFINITY")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                    | État                         | Commentaires         |
+| -------------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ES2')}}                                                         | {{Spec2('ES3')}}         | Définition initiale. |
+| {{SpecName('ES5.1', '#sec-15.1.2.5', 'isFinite')}}             | {{Spec2('ES5.1')}}     |                      |
+| {{SpecName('ES6', '#sec-isfinite-number', 'isFinite')}}         | {{Spec2('ES6')}}         |                      |
+| {{SpecName('ESDraft', '#sec-isfinite-number', 'isFinite')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.isFinite")}}
+
+## Voir aussi
+
+- {{jsxref("Number.isFinite()")}}
+- {{jsxref("Number.NaN")}}
+- {{jsxref("Number.POSITIVE_INFINITY")}}
+- {{jsxref("Number.NEGATIVE_INFINITY")}}
diff --git a/files/fr/web/javascript/reference/global_objects/isnan/index.md b/files/fr/web/javascript/reference/global_objects/isnan/index.md
index af6f562a83..acc31bfd71 100644
--- a/files/fr/web/javascript/reference/global_objects/isnan/index.md
+++ b/files/fr/web/javascript/reference/global_objects/isnan/index.md
@@ -8,63 +8,66 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/isNaN
 original_slug: Web/JavaScript/Reference/Objets_globaux/isNaN
 ---
-<div>{{jsSidebar("Objects")}}</div>
+{{jsSidebar("Objects")}}
 
-<p>La fonction <code><strong>isNaN()</strong></code> permet de déterminer si une valeur est {{jsxref("NaN")}}. On notera que cette fonction utilise des règles de conversion différentes de {{jsxref("Number.isNaN()")}}, définie avec ECMAScript 2015 (ES6).</p>
+La fonction **`isNaN()`** permet de déterminer si une valeur est {{jsxref("NaN")}}. On notera que cette fonction utilise des règles de conversion différentes de {{jsxref("Number.isNaN()")}}, définie avec ECMAScript 2015 (ES6).
 
-<div>{{EmbedInteractiveExample("pages/js/globalprops-isnan.html")}}</div>
+{{EmbedInteractiveExample("pages/js/globalprops-isnan.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">isNaN(<var>valeurÀTester</var>)</pre>
+    isNaN(valeurÀTester)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>valeurÀTester</code></dt>
- <dd>La valeur dont on souhaite déterminer si elle est {{jsxref("NaN")}}.</dd>
-</dl>
+- `valeurÀTester`
+  - : La valeur dont on souhaite déterminer si elle est {{jsxref("NaN")}}.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p><code>true</code> si la valeur fournie vaut {{jsxref("NaN")}}, sinon, la méthode renverra <code>false</code>.</p>
+`true` si la valeur fournie vaut {{jsxref("NaN")}}, sinon, la méthode renverra `false`.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<h3 id="La_nécessité_d'avoir_isNaN()">La nécessité d'avoir <code>isNaN()</code></h3>
+### La nécessité d'avoir `isNaN()`
 
-<p>À la différence des autres valeurs JavaScript, il est impossible d'utiliser les opérateurs d'égalité faible et stricte ({{jsxref("Opérateurs/Opérateurs_de_comparaison","==","#.C3.89galit.C3.A9_simple_(.3D.3D)")}} et {{jsxref("Opérateurs/Opérateurs_de_comparaison","===","#.C3.89galit.C3.A9_stricte_(.3D.3D.3D)")}}) afin de déterminer si une valeur <em>est </em>ou<em> n'est pas</em> réellement {{jsxref("NaN")}}. En effet <code>NaN == NaN</code> et <code>NaN === NaN</code> renvoient <code>false</code> tous les deux. C'est pour cela qu'il est nécessaire d'avoir la fonction <code>isNaN()</code>.</p>
+À la différence des autres valeurs JavaScript, il est impossible d'utiliser les opérateurs d'égalité faible et stricte ({{jsxref("Opérateurs/Opérateurs_de_comparaison","==","#.C3.89galit.C3.A9_simple_(.3D.3D)")}} et {{jsxref("Opérateurs/Opérateurs_de_comparaison","===","#.C3.89galit.C3.A9_stricte_(.3D.3D.3D)")}}) afin de déterminer si une valeur _est_ ou _n'est pas_ réellement {{jsxref("NaN")}}. En effet `NaN == NaN` et `NaN === NaN` renvoient `false` tous les deux. C'est pour cela qu'il est nécessaire d'avoir la fonction `isNaN()`.
 
-<h3 id="Les_origines_de_NaN">Les origines de <code>NaN</code></h3>
+### Les origines de `NaN`
 
-<p>La valeur <code>NaN</code> est générée lorsqu'une opération arithmétique résulte en une valeur indéfinie ou non représentable. De telles valeurs ne représentent pas nécessairement des dépassements de condition. <code>NaN</code> peut également être le résultat d'une conversion numérique pour les valeurs qui n'ont pas de valeurs numériques correspondantes (par exemple lorsqu'on souhaite convertir la chaîne <code>"toto"</code> en un nombre).</p>
+La valeur `NaN` est générée lorsqu'une opération arithmétique résulte en une valeur indéfinie ou non représentable. De telles valeurs ne représentent pas nécessairement des dépassements de condition. `NaN` peut également être le résultat d'une conversion numérique pour les valeurs qui n'ont pas de valeurs numériques correspondantes (par exemple lorsqu'on souhaite convertir la chaîne `"toto"` en un nombre).
 
-<p>Par exemple, lorsqu'on divise zéro par zéro, on obtient <code>NaN</code>. En revanche, lorsqu'on divise d'autres nombres par zéro, on n'obtient pas ce résultat.</p>
+Par exemple, lorsqu'on divise zéro par zéro, on obtient `NaN`. En revanche, lorsqu'on divise d'autres nombres par zéro, on n'obtient pas ce résultat.
 
-<h3 id="Comportement_étrange_de_isNaN()">Comportement étrange de <code>isNaN()</code></h3>
+### Comportement étrange de `isNaN()`
 
-<p>Depuis les premières spécifications pour <code>isNaN()</code>, son comportement sur les arguments non-numériques a toujours été source de confusion. Lorsque l'argument passé à la fonction n'est pas du type <a href="https://es5.github.com/#x8.5">Number</a>, la valeur est d'abord convertie en une valeur du type Number. La valeur résultante est ensuite utilisée lors du test afin de déterminer si c'est {{jsxref("NaN")}}. Ainsi pour valeurs non numériques qui sont converties en une valeur non-NaN numérique (notamment la chaîne vide, les valeurs booléennes qui donnent zéro ou un), la fonction renverra <code>false</code>, ce qui pourrait être inattendu (en effet, la chaîne vide <em>n'est pas un nombre</em>). Ici, la confusion provient du fait que « not a number » a un sens particulier pour les valeurs numériques représentées selon IEEE-754. Cette fonction doit plutôt être vue comme la réponse à la question « est-ce que cette valeur, lorsqu'elle est convertie en une valeur numérique, correspond à la valeur IEEE-754 "Not A Number" ? ».</p>
+Depuis les premières spécifications pour `isNaN()`, son comportement sur les arguments non-numériques a toujours été source de confusion. Lorsque l'argument passé à la fonction n'est pas du type [Number](https://es5.github.com/#x8.5), la valeur est d'abord convertie en une valeur du type Number. La valeur résultante est ensuite utilisée lors du test afin de déterminer si c'est {{jsxref("NaN")}}. Ainsi pour valeurs non numériques qui sont converties en une valeur non-NaN numérique (notamment la chaîne vide, les valeurs booléennes qui donnent zéro ou un), la fonction renverra `false`, ce qui pourrait être inattendu (en effet, la chaîne vide _n'est pas un nombre_). Ici, la confusion provient du fait que « not a number » a un sens particulier pour les valeurs numériques représentées selon IEEE-754. Cette fonction doit plutôt être vue comme la réponse à la question « est-ce que cette valeur, lorsqu'elle est convertie en une valeur numérique, correspond à la valeur IEEE-754 "Not A Number" ? ».
 
-<p>La version ECMAScript ES2015 ajoute la méthode {{jsxref("Number.isNaN()")}}. <code>Number.isNaN(x)</code> permettra de tester de façon plus fiable si <code>x</code> vaut <code>NaN</code> ou non. Si on ne dispose pas de cette méthode, on peut également utiliser l'expression <code>(x != x)</code> afin de tester de façon plus certaine si <code>x</code> vaut <code>NaN</code> ou non (en effet le résultat de cette expression n'aura pas les faux positifs de <code>isNaN</code>). Sous cet angle, <code>isNaN()</code> peut être vu comme :</p>
+La version ECMAScript ES2015 ajoute la méthode {{jsxref("Number.isNaN()")}}. `Number.isNaN(x)` permettra de tester de façon plus fiable si `x` vaut `NaN` ou non. Si on ne dispose pas de cette méthode, on peut également utiliser l'expression `(x != x)` afin de tester de façon plus certaine si `x` vaut `NaN` ou non (en effet le résultat de cette expression n'aura pas les faux positifs de `isNaN`). Sous cet angle, `isNaN()` peut être vu comme :
 
-<pre class="brush: js">var isNaN = function(valeur) {
+```js
+var isNaN = function(valeur) {
   return Number.isNaN(Number(valeur));
-};</pre>
+};
+```
 
-<p>Ou encore, en utilisant le fait que <code>NaN</code> est la seule valeur différente d'elle-même :</p>
+Ou encore, en utilisant le fait que `NaN` est la seule valeur différente d'elle-même :
 
-<pre class="brush: js">var isNaN = function(valeur) {
+```js
+var isNaN = function(valeur) {
   var n = Number(valeur);
   return n !== n;
-};</pre>
+};
+```
 
-<h3 id="NaN_est_«_empoisonné_»"><code>NaN</code> est « empoisonné »</h3>
+### `NaN` est « empoisonné »
 
-<p>Cette fonction peut être utilisée afin de déterminer si la valeur courante peut faire partie d'une expression arithmétique. En effet, si un des composants d'une expression arithmétique vaut <code>NaN</code>, le résultat de l'expression sera <code>NaN</code> également (on dit alors que <code>NaN</code> « empoisonne » l'expression). La méthode <code>isNaN()</code> permet alors de vérifier, avant de construire une expression, que les valeurs utilisées n'empoisonneront pas l'expression.</p>
+Cette fonction peut être utilisée afin de déterminer si la valeur courante peut faire partie d'une expression arithmétique. En effet, si un des composants d'une expression arithmétique vaut `NaN`, le résultat de l'expression sera `NaN` également (on dit alors que `NaN` « empoisonne » l'expression). La méthode `isNaN()` permet alors de vérifier, avant de construire une expression, que les valeurs utilisées n'empoisonneront pas l'expression.
 
-<p>On peut par exemple construire une fonction dont on souhaite qu'elle incrémente l'argument et que la valeur qu'elle renvoie ne puisse pas être <code>NaN</code>. Le code de cette fonction pourrait être :</p>
+On peut par exemple construire une fonction dont on souhaite qu'elle incrémente l'argument et que la valeur qu'elle renvoie ne puisse pas être `NaN`. Le code de cette fonction pourrait être :
 
-<pre class="brush: js">function incrément(x) {
+```js
+function incrément(x) {
   if (isNaN(x)){
     x = 0;
   }
@@ -80,11 +83,12 @@ function incrémentCourt(x) {
 incrément("blabla");  // 1
 incrément(1);         // 2
 incrément(NaN);       // 1
-</pre>
+```
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<pre class="brush: js">isNaN(NaN);       // true
+```js
+isNaN(NaN);       // true
 isNaN(undefined); // true
 isNaN({});        // true
 
@@ -108,47 +112,22 @@ isNaN(new Date().toString());     // true
 isNaN("blabla")   // true : "blabla" est converti en un nombre
                   // Si on souhaite convertir cette valeur en nombre, cela échoue
                   // et on obtient NaN
-</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.1.2.4', 'isNaN')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-isnan-number', 'isNaN')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-isnan-number', 'isNaN')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.isNaN")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("NaN")}}</li>
- <li>{{jsxref("Number.isNaN()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                            | État                         | Commentaires         |
+| ------------------------------------------------------------------------ | ---------------------------- | -------------------- |
+| {{SpecName('ES1')}}                                                 | {{Spec2('ES1')}}         | Définition initiale. |
+| {{SpecName('ES5.1', '#sec-15.1.2.4', 'isNaN')}}         | {{Spec2('ES5.1')}}     |                      |
+| {{SpecName('ES6', '#sec-isnan-number', 'isNaN')}}         | {{Spec2('ES6')}}         |                      |
+| {{SpecName('ESDraft', '#sec-isnan-number', 'isNaN')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.isNaN")}}
+
+## Voir aussi
+
+- {{jsxref("NaN")}}
+- {{jsxref("Number.isNaN()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/json/index.md b/files/fr/web/javascript/reference/global_objects/json/index.md
index cd592c8638..ac25b46a6b 100644
--- a/files/fr/web/javascript/reference/global_objects/json/index.md
+++ b/files/fr/web/javascript/reference/global_objects/json/index.md
@@ -10,141 +10,112 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/JSON
 original_slug: Web/JavaScript/Reference/Objets_globaux/JSON
 ---
-<div>{{JSRef}}</div>
-
-<p>L’objet <strong><code>JSON</code></strong> contient des méthodes pour interpréter du <a class="external" href="https://json.org/">JSON</a> (JavaScript Object Notation) (voir également la page du glossaire {{glossary("JSON")}}) et convertir des valeurs en JSON. Il ne peut être appelé ou construit, et, en dehors de ses deux méthodes, n’a pas de fonctionnalité propre.</p>
-
-<h2 id="Différences_entres_JavaScript_et_JSON">Différences entres JavaScript et JSON</h2>
-
-<p>JSON est une syntaxe pour sérialiser des objets, tableaux, nombres, chaînes de caractères, booléens et valeurs <em>null</em>. Elle est basée sur la syntaxe de JavaScript mais en est distincte : du code JavaScript n’est pas nécessairement du JSON, et du JSON n’est pas nécessairement du JavaScript.</p>
-
-<ul>
- <li>Pour les objets et les tableaux
-  <ul>
-   <li>Les noms de propriété doivent être des chaînes de caractères délimitées par des guillements doubles ; les <em>trailing commas</em> sont interdits</li>
-  </ul>
- </li>
- <li>Pour les nombres
-  <ul>
-   <li>Les zéros non significatifs sont interdits ; un point décimal doit être suivi d’au moins un chiffre (plus exactement : <code>JSON.stringify()</code> ignorera les zéros mais <code>JSON.parse()</code> déclenchera une exception <code>SyntaxError</code>).</li>
-  </ul>
- </li>
- <li>Pour le texte : <strong>tout texte JSON est une expression JavaScript</strong> (pour les moteurs qui implémentent <a href="https://github.com/tc39/proposal-json-superset">cette proposition</a>).
-  <ul>
-   <li>Pour les autres moteurs, seul un jeu limité de caractères peut être échappé ; certains caractères de contrôle sont interdits ; le séparateur de ligne Unicode (<a href="https://unicode-table.com/en/2028/">U+2028</a>) et le séparateur de paragraphe (<a href="https://unicode-table.com/en/2029/">U+2029</a>) sont autorisés en JSON mais pas en JavaScript dans les littéraux de chaînes de caractères.</li>
-  </ul>
- </li>
-</ul>
-
-<p>Dans l'exemple suivant, on utilise {{jsxref("JSON.parse()")}} afin d'analyser la chaîne JSON et <code>eval</code> afin d'exécuter le code correspondant :</p>
-
-<pre class="brush: js">var code = '"\u2028\u2029"';
+{{JSRef}}
+
+L’objet **`JSON`** contient des méthodes pour interpréter du [JSON](https://json.org/) (JavaScript Object Notation) (voir également la page du glossaire {{glossary("JSON")}}) et convertir des valeurs en JSON. Il ne peut être appelé ou construit, et, en dehors de ses deux méthodes, n’a pas de fonctionnalité propre.
+
+## Différences entres JavaScript et JSON
+
+JSON est une syntaxe pour sérialiser des objets, tableaux, nombres, chaînes de caractères, booléens et valeurs _null_. Elle est basée sur la syntaxe de JavaScript mais en est distincte : du code JavaScript n’est pas nécessairement du JSON, et du JSON n’est pas nécessairement du JavaScript.
+
+- Pour les objets et les tableaux
+
+  - Les noms de propriété doivent être des chaînes de caractères délimitées par des guillements doubles ; les _trailing commas_ sont interdits
+
+- Pour les nombres
+
+  - Les zéros non significatifs sont interdits ; un point décimal doit être suivi d’au moins un chiffre (plus exactement : `JSON.stringify()` ignorera les zéros mais `JSON.parse()` déclenchera une exception `SyntaxError`).
+
+- Pour le texte : **tout texte JSON est une expression JavaScript** (pour les moteurs qui implémentent [cette proposition](https://github.com/tc39/proposal-json-superset)).
+
+  - Pour les autres moteurs, seul un jeu limité de caractères peut être échappé ; certains caractères de contrôle sont interdits ; le séparateur de ligne Unicode ([U+2028](https://unicode-table.com/en/2028/)) et le séparateur de paragraphe ([U+2029](https://unicode-table.com/en/2029/)) sont autorisés en JSON mais pas en JavaScript dans les littéraux de chaînes de caractères.
+
+Dans l'exemple suivant, on utilise {{jsxref("JSON.parse()")}} afin d'analyser la chaîne JSON et `eval` afin d'exécuter le code correspondant :
+
+```js
+var code = '"\u2028\u2029"';
 JSON.parse(code); // vaut "\u2028\u2029" pour tous les moteurs
-eval(code); // provoque une SyntaxError pour les anciens moteurs</pre>
-
-<h2 id="Syntaxe_complète">Syntaxe complète</h2>
-
-<pre class="syntaxbox"><var>JSON</var> = <strong>null</strong>
-    <em>ou</em> <strong>true</strong> <em>ou</em> <strong>false</strong>
-    <em>ou</em> <var>NombreJSON</var>
-    <em>ou</em> <var>ChaîneJSON</var>
-    <em>ou</em> <var>ObjetJSON</var>
-    <em>ou</em> <var>TableauJSON</var>
-
-<var>NombreJSON</var> = <strong>-</strong> <var>NombrePositif</var>
-          <em>ou</em> <var>NombrePositif</var>
-<var>NombrePositif</var> = NombreDécimal
-              <em>ou</em> <var>NombreDécimal</var> <strong>.</strong> <var>Chiffres</var>
-              <em>ou</em> <var>NombreDécimal</var> <strong>.</strong> <var>Chiffres</var> <var>PartiExposant</var>
-              <em>ou</em> <var>NombreDécimal</var> <var>PartiExposant</var>
-<var>NombreDécimal</var> = <strong>0</strong>
-             <em>ou</em> <var>UnÀNeuf</var> <var>Chiffres</var>
-<var>PartiExposant</var> = <strong>e</strong> <var>Exposant</var>
-            <em>ou</em> <strong>E</strong> <var>Exposant</var>
-<var>Exposant</var> = <var>Chiffres</var>
-        <em>ou</em> <strong>+</strong> <var>Chiffres</var>
-        <em>ou</em> <strong>-</strong> <var>Chiffres</var>
-<var>Chiffres</var> = <var>Chiffre</var>
-      <em>ou</em> <var>Chiffres</var> <var>Chiffre</var>
-<var>Chiffre</var> = <strong>0</strong> à <strong>9</strong>
-<var>UnÀNeuf</var> = <strong>1</strong> à <strong>9</strong>
-
-<var>ChaîneJSON</var> = <strong>""</strong>
-          <em>ou</em> <strong>"</strong> <var>ChaîneCaractères</var> <strong>"</strong>
-<var>ChaîneCaractères</var> = <var>ChaîneCaractère</var>
-                <em>ou</em> <var>ChaîneCaractères</var> <var>ChaîneCaractère</var>
-<var>ChaîneCaractère</var> = un caractère
-                  <em>sauf</em> <strong>"</strong> <em>ou</em> <strong>\</strong> <em>ou</em> U+0000 à U+001F
-               <em>ou</em> <var>SéquenceÉchappement</var>
-<var>SéquenceÉchappement</var> = <strong>\" </strong><em>ou</em> <strong>\/ </strong><em>ou</em> <strong>\\ </strong><em>ou</em> <strong>\b </strong><em>ou</em> <strong>\f </strong><em>ou</em> <strong>\n </strong><em>ou</em> <strong>\r </strong><em>ou</em> <strong>\t</strong>
-              <em>ou</em> <strong>\u</strong> <var>ChifreHexadécimal</var> <var>ChifreHexadécimal</var> <var>ChifreHexadécimal</var> <var>ChifreHexadécimal</var>
-<var>ChifreHexadécimal</var> = <strong>0</strong> à <strong>9</strong>
-        <em>ou</em> <strong>A</strong> à <strong>F</strong>
-        <em>ou</em> <strong>a</strong> à <strong>f</strong>
-
-<var>ObjetJSON</var> = <strong>{</strong> <strong>}</strong>
-          <em>ou</em> <strong>{</strong> <var>Membres</var> <strong>}</strong>
-<var>Membres</var> = <var>ChaîneJSON</var> <strong>:</strong> <var>JSON</var>
-       <em>ou</em> <var>Membres</var> <strong>,</strong> <var>ChaîneJSON</var> <strong>:</strong> <var>JSON</var>
-
-<var>TableauJSON</var> = <strong>[</strong> <strong>]</strong>
-         <em>ou</em> <strong>[</strong> <var>ÉlémentsTableau</var> <strong>]</strong>
-<var>ÉlémentsTableau</var> = <var>JSON</var>
-             <em>ou</em> <var>ÉlémentsTableau</var> <strong>,</strong> <var>JSON</var></pre>
-
-<p>Des espaces blancs insignifiants peuvent être présents n’importe où sauf dans un <code><var>JSONNumber</var></code> (les nombres ne doivent pas contenir d’espaces blancs) ou dans un <code><var>JSONString</var></code> (where it is interpreted as the corresponding character in the string, or would cause an error). Les caractères tabulation (<a href="https://unicode-table.com/en/0009/">U+0009</a>), retour chariot (<a href="https://unicode-table.com/en/000D/">U+000D</a>), saut de ligne (<a href="https://unicode-table.com/en/000A/">U+000A</a>), and espace (<a href="https://unicode-table.com/en/0020/">U+0020</a>) sont les seuls caractères blancs valides.</p>
-
-<h2 id="Méthodes">Méthodes</h2>
-
-<dl>
- <dt>{{jsxref("JSON.parse()", "JSON.parse(<var>texte</var>[, <var>revivificateur</var>])")}}</dt>
- <dd>Analysez le <code>texte</code> de la chaîne comme JSON, transformez éventuellement la valeur produite et ses propriétés, et renvoyez la valeur. Toute violation de la syntaxe JSON, y compris celles concernant les différences entre JavaScript et JSON, entraîne l'envoi d'un {{jsxref("SyntaxError")}}. L'option "<code>revivificateur</code>" permet d'interpréter ce que le <code>remplacement</code> a utilisé pour remplacer d'autres types de données.</dd>
- <dt>{{jsxref("JSON.stringify()", "JSON.stringify(<var>valeur</var>[, remplacement[, expace]])")}}</dt>
- <dd>Retourne une chaîne JSON correspondant à la valeur spécifiée, en incluant éventuellement seulement certaines propriétés ou en remplaçant les valeurs des propriétés d'une manière définie par l'utilisateur. Par défaut, toutes les instances de {{jsxref("undefined")}} sont remplacées par {{jsxref("null")}}, et les autres types de données natives non prises en charge sont censurés. L'option de <code>remplacement</code> permet de spécifier un autre comportement.</dd>
-</dl>
-
-<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.12', 'JSON')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-json-object', 'JSON')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-json-object', 'JSON')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.JSON")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Date.prototype.toJSON()")}}</li>
- <li>Quelques outils permettant de manipuler des données en JSON
-  <ul>
-   <li><a href="http://jsoncompare.org/">JSON Compare</a> qui permet de comparer deux JSON</li>
-   <li><a href="http://jsonbeautifier.org/">JSON Beautifier</a> qui permet de visualiser et d'éditer un fichier JSON</li>
-   <li><a href="https://jsonparser.org/">JSON Parser</a> qui permet de formatter une chaîne JSON</li>
-   <li><a href="https://extendsclass.com/json-validator.html">JSON Formatter</a> qui permet de formatter et échapper une chaîne JSON </li>
-   <li><a href="https://tools.learningcontainer.com/json-validator/">JSON Validator</a> qui permet de valider une chaîne JSON</li>
-  </ul>
- </li>
-</ul>
+eval(code); // provoque une SyntaxError pour les anciens moteurs
+```
+
+## Syntaxe complète
+
+    JSON = null
+        ou true ou false
+        ou NombreJSON
+        ou ChaîneJSON
+        ou ObjetJSON
+        ou TableauJSON
+
+    NombreJSON = - NombrePositif
+              ou NombrePositif
+    NombrePositif = NombreDécimal
+                  ou NombreDécimal . Chiffres
+                  ou NombreDécimal . Chiffres PartiExposant
+                  ou NombreDécimal PartiExposant
+    NombreDécimal = 0
+                 ou UnÀNeuf Chiffres
+    PartiExposant = e Exposant
+                ou E Exposant
+    Exposant = Chiffres
+            ou + Chiffres
+            ou - Chiffres
+    Chiffres = Chiffre
+          ou Chiffres Chiffre
+    Chiffre = 0 à 9
+    UnÀNeuf = 1 à 9
+
+    ChaîneJSON = ""
+              ou " ChaîneCaractères "
+    ChaîneCaractères = ChaîneCaractère
+                    ou ChaîneCaractères ChaîneCaractère
+    ChaîneCaractère = un caractère
+                      sauf " ou \ ou U+0000 à U+001F
+                   ou SéquenceÉchappement
+    SéquenceÉchappement = \" ou \/ ou \\ ou \b ou \f ou \n ou \r ou \t
+                  ou \u ChifreHexadécimal ChifreHexadécimal ChifreHexadécimal ChifreHexadécimal
+    ChifreHexadécimal = 0 à 9
+            ou A à F
+            ou a à f
+
+    ObjetJSON = { }
+              ou { Membres }
+    Membres = ChaîneJSON : JSON
+           ou Membres , ChaîneJSON : JSON
+
+    TableauJSON = [ ]
+             ou [ ÉlémentsTableau ]
+    ÉlémentsTableau = JSON
+                 ou ÉlémentsTableau , JSON
+
+Des espaces blancs insignifiants peuvent être présents n’importe où sauf dans un `JSONNumber` (les nombres ne doivent pas contenir d’espaces blancs) ou dans un `JSONString` (where it is interpreted as the corresponding character in the string, or would cause an error). Les caractères tabulation ([U+0009](https://unicode-table.com/en/0009/)), retour chariot ([U+000D](https://unicode-table.com/en/000D/)), saut de ligne ([U+000A](https://unicode-table.com/en/000A/)), and espace ([U+0020](https://unicode-table.com/en/0020/)) sont les seuls caractères blancs valides.
+
+## Méthodes
+
+- {{jsxref("JSON.parse()", "JSON.parse(<var>texte</var>[, <var>revivificateur</var>])")}}
+  - : Analysez le `texte` de la chaîne comme JSON, transformez éventuellement la valeur produite et ses propriétés, et renvoyez la valeur. Toute violation de la syntaxe JSON, y compris celles concernant les différences entre JavaScript et JSON, entraîne l'envoi d'un {{jsxref("SyntaxError")}}. L'option "`revivificateur`" permet d'interpréter ce que le `remplacement` a utilisé pour remplacer d'autres types de données.
+- {{jsxref("JSON.stringify()", "JSON.stringify(<var>valeur</var>[, remplacement[, expace]])")}}
+  - : Retourne une chaîne JSON correspondant à la valeur spécifiée, en incluant éventuellement seulement certaines propriétés ou en remplaçant les valeurs des propriétés d'une manière définie par l'utilisateur. Par défaut, toutes les instances de {{jsxref("undefined")}} sont remplacées par {{jsxref("null")}}, et les autres types de données natives non prises en charge sont censurés. L'option de `remplacement` permet de spécifier un autre comportement.
+
+## Spécifications
+
+| Spécification                                                        | État                         | Commentaires         |
+| -------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ES5.1', '#sec-15.12', 'JSON')}}             | {{Spec2('ES5.1')}}     | Définition initiale. |
+| {{SpecName('ES6', '#sec-json-object', 'JSON')}}     | {{Spec2('ES6')}}         |                      |
+| {{SpecName('ESDraft', '#sec-json-object', 'JSON')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.JSON")}}
+
+## Voir aussi
+
+- {{jsxref("Date.prototype.toJSON()")}}
+- Quelques outils permettant de manipuler des données en JSON
+
+  - [JSON Compare](http://jsoncompare.org/) qui permet de comparer deux JSON
+  - [JSON Beautifier](http://jsonbeautifier.org/) qui permet de visualiser et d'éditer un fichier JSON
+  - [JSON Parser](https://jsonparser.org/) qui permet de formatter une chaîne JSON
+  - [JSON Formatter](https://extendsclass.com/json-validator.html) qui permet de formatter et échapper une chaîne JSON
+  - [JSON Validator](https://tools.learningcontainer.com/json-validator/) qui permet de valider une chaîne JSON
diff --git a/files/fr/web/javascript/reference/global_objects/json/parse/index.md b/files/fr/web/javascript/reference/global_objects/json/parse/index.md
index 071d0c8a92..723c68223b 100644
--- a/files/fr/web/javascript/reference/global_objects/json/parse/index.md
+++ b/files/fr/web/javascript/reference/global_objects/json/parse/index.md
@@ -10,38 +10,37 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/JSON/parse
 original_slug: Web/JavaScript/Reference/Objets_globaux/JSON/parse
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>JSON.parse()</strong></code> analyse une chaîne de caractères JSON et construit la valeur JavaScript ou l'objet décrit par cette chaîne. On peut éventuellement utiliser cette fonction avec un paramètre de modification permettant de traiter l'objet avant qu'il soit renvoyé.</p>
+La méthode **`JSON.parse()`** analyse une chaîne de caractères JSON et construit la valeur JavaScript ou l'objet décrit par cette chaîne. On peut éventuellement utiliser cette fonction avec un paramètre de modification permettant de traiter l'objet avant qu'il soit renvoyé.
 
-<div>{{EmbedInteractiveExample("pages/js/json-parse.html")}}</div>
+{{EmbedInteractiveExample("pages/js/json-parse.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">JSON.parse(<var>texte</var>[, <var>reviver</var>])</pre>
+    JSON.parse(texte[, reviver])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>texte</code></dt>
- <dd>La chaine de caractère à analyser comme du JSON. Voir l'objet {{jsxref("JSON")}} pour une description de la syntaxe JSON.</dd>
- <dt><code>reviver</code></dt>
- <dd>Si l'argument est une fonction, effectue une opération de transformation sur la valeur analysée avant de la renvoyer.</dd>
-</dl>
+- `texte`
+  - : La chaine de caractère à analyser comme du JSON. Voir l'objet {{jsxref("JSON")}} pour une description de la syntaxe JSON.
+- `reviver`
+  - : Si l'argument est une fonction, effectue une opération de transformation sur la valeur analysée avant de la renvoyer.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un objet ({{jsxref("Object")}}) correspondant au texte envoyé.</p>
+Un objet ({{jsxref("Object")}}) correspondant au texte envoyé.
 
-<h3 id="Exceptions">Exceptions</h3>
+### Exceptions
 
-<p>Lève une exception {{jsxref("SyntaxError")}} si la chaine de caractère à analyser ne contient pas du JSON valide.</p>
+Lève une exception {{jsxref("SyntaxError")}} si la chaine de caractère à analyser ne contient pas du JSON valide.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_JSON.parse">Utiliser <code>JSON.parse()</code></h3>
+### Utiliser `JSON.parse()`
 
-<pre class="brush: js">try {
+```js
+try {
   JSON.parse('{}');              // {}
   JSON.parse('true');            // true
   JSON.parse('"toto"');          // "toto"
@@ -50,15 +49,16 @@ original_slug: Web/JavaScript/Reference/Objets_globaux/JSON/parse
 } catch (e) {
   console.error("Parsing error:", e);
 }
-</pre>
+```
 
-<h3 id="Utiliser_le_paramètre_reviver">Utiliser le paramètre <code>reviver</code></h3>
+### Utiliser le paramètre `reviver`
 
-<p>Si un <em>reviver</em> est spécifié, la valeur obtenue par l'analyse est transformée avant d'être renvoyée. Plus précisément, la valeur calculée, et toutes les propriétés (commençant avec les propriétés les plus imbriquées), sont passées individuellement au <em>reviver</em>, qui est appelé avec : l'objet contenant la propriété en cours de traitement, le nom de la propriété en chaine de caractères et la valeur de la propriété. Si la fonction <em>reviver</em> retourne {{jsxref("undefined")}} (ou ne retourne aucune valeur, par exemple si l'exécution s'arrête à la fin de la fonction), la propriété est supprimée de l'objet. Autrement la propriété est redéfinie avec la valeur retournée.</p>
+Si un _reviver_ est spécifié, la valeur obtenue par l'analyse est transformée avant d'être renvoyée. Plus précisément, la valeur calculée, et toutes les propriétés (commençant avec les propriétés les plus imbriquées), sont passées individuellement au _reviver_, qui est appelé avec : l'objet contenant la propriété en cours de traitement, le nom de la propriété en chaine de caractères et la valeur de la propriété. Si la fonction _reviver_ retourne {{jsxref("undefined")}} (ou ne retourne aucune valeur, par exemple si l'exécution s'arrête à la fin de la fonction), la propriété est supprimée de l'objet. Autrement la propriété est redéfinie avec la valeur retournée.
 
-<p>Si le <em>reviver</em> ne transforme que certaines valeurs et pas d'autres, assurez-vous que les valeurs inchangées soient renvoyées telles quelles. En effet, si elles ne sont pas renvoyées, elles seront supprimés sur l'objet obtenu !</p>
+Si le _reviver_ ne transforme que certaines valeurs et pas d'autres, assurez-vous que les valeurs inchangées soient renvoyées telles quelles. En effet, si elles ne sont pas renvoyées, elles seront supprimés sur l'objet obtenu !
 
-<pre class="brush: js">JSON.parse('{"p": 5}', (key, value) =&gt; {
+```js
+JSON.parse('{"p": 5}', (key, value) => {
   if (typeof value === 'number') {
     return value * 2;  // renvoie value * 2 pour les nombres
   }
@@ -67,7 +67,7 @@ original_slug: Web/JavaScript/Reference/Objets_globaux/JSON/parse
 
 // { p: 10 }
 
-JSON.parse('{"1": 1, "2": 2,"3": {"4": 4, "5": {"6": 6}}}', (key, value) =&gt; {
+JSON.parse('{"1": 1, "2": 2,"3": {"4": 4, "5": {"6": 6}}}', (key, value) => {
     console.log(key);            // on affiche le nom de la propriété dans la console
     return value;                // et on renvoie la valeur inchangée.
 });
@@ -78,51 +78,29 @@ JSON.parse('{"1": 1, "2": 2,"3": {"4": 4, "5": {"6": 6}}}', (key, value) =&gt; {
 // 6
 // 5
 // 3
-// ""</pre>
+// ""
+```
 
-<h3 id="JSON.parse_naccepte_pas_les_virgules_en_fin_de_tableau"><code>JSON.parse()</code> n'accepte pas les virgules en fin de tableau</h3>
+### `JSON.parse()` n'accepte pas les virgules en fin de tableau
 
-<pre class="brush: js example-bad">// les deux instructions qui suivent lèveront une SyntaxError
+```js example-bad
+// les deux instructions qui suivent lèveront une SyntaxError
 JSON.parse('[1, 2, 3, 4, ]');
 JSON.parse('{ "toto" : 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('ES5.1', '#sec-15.12.2', 'JSON.parse')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td>Définition initiale.<br>
-    Implementée avec JavaScript 1.7.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-json.parse', 'JSON.parse')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-json.parse', 'JSON.parse')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.JSON.parse")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("JSON.stringify()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                | État                         | Commentaires                                          |
+| ---------------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- |
+| {{SpecName('ES5.1', '#sec-15.12.2', 'JSON.parse')}}         | {{Spec2('ES5.1')}}     | Définition initiale. Implementée avec JavaScript 1.7. |
+| {{SpecName('ES6', '#sec-json.parse', 'JSON.parse')}}         | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-json.parse', 'JSON.parse')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.JSON.parse")}}
+
+## Voir aussi
+
+- {{jsxref("JSON.stringify()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/json/stringify/index.md b/files/fr/web/javascript/reference/global_objects/json/stringify/index.md
index be5bb15eac..3d5282d7a1 100644
--- a/files/fr/web/javascript/reference/global_objects/json/stringify/index.md
+++ b/files/fr/web/javascript/reference/global_objects/json/stringify/index.md
@@ -9,62 +9,55 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/JSON/stringify
 original_slug: Web/JavaScript/Reference/Objets_globaux/JSON/stringify
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>JSON.stringify()</strong></code> convertit une valeur JavaScript en chaîne JSON. Optionnellement, elle peut remplacer des valeurs ou spécifier les propriétés à inclure si un tableau de propriétés a été fourni.</p>
+La méthode **`JSON.stringify()`** convertit une valeur JavaScript en chaîne JSON. Optionnellement, elle peut remplacer des valeurs ou spécifier les propriétés à inclure si un tableau de propriétés a été fourni.
 
-<div>{{EmbedInteractiveExample("pages/js/json-stringify.html")}}</div>
+{{EmbedInteractiveExample("pages/js/json-stringify.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">JSON.stringify( <var>valeur</var>[, <var>remplaçant</var> [, <var>espace</var>]])</pre>
+    JSON.stringify( valeur[, remplaçant [, espace]])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>valeur</code></dt>
- <dd>La valeur à convertir en chaîne JSON.</dd>
- <dt><code>remplaçant</code> {{optional_inline}}</dt>
- <dd>
- <p>Une fonction qui modifie le processus de transformation ou un tableau de chaînes de caractères et de nombres qui sont utilisés comme liste blanche pour sélectionner/filtrer les propriétés de l'objet à inclure dans la chaîne JSON. Si cette valeur est {{jsxref("null")}} ou n'est pas fournie, toutes les propriétés de l'objet seront inclues dans la chaîne résultante.</p>
- </dd>
- <dt><code>espace</code> {{optional_inline}}</dt>
- <dd>Un objet {{jsxref("String")}} ou {{jsxref("Number")}} qui est utilisé pour insérer des blancs dans la chaîne JSON produite afin de faciliter la lisibilité.</dd>
-</dl>
+- `valeur`
+  - : La valeur à convertir en chaîne JSON.
+- `remplaçant` {{optional_inline}}
+  - : Une fonction qui modifie le processus de transformation ou un tableau de chaînes de caractères et de nombres qui sont utilisés comme liste blanche pour sélectionner/filtrer les propriétés de l'objet à inclure dans la chaîne JSON. Si cette valeur est {{jsxref("null")}} ou n'est pas fournie, toutes les propriétés de l'objet seront inclues dans la chaîne résultante.
+- `espace` {{optional_inline}}
+  - : Un objet {{jsxref("String")}} ou {{jsxref("Number")}} qui est utilisé pour insérer des blancs dans la chaîne JSON produite afin de faciliter la lisibilité.
 
-<ul>
- <li>Si cet argument est un nombre, il indiquera le nombre d'espaces à utiliser pour l'indentation (la valeur est ramenée à 10 si elle dépasse 10).</li>
- <li>Si l'argument est une chaîne, les 10 premiers caractères (ou la chaîne si elle est plus courte) seront utilisés pour les blancs.</li>
- <li>Si le paramètre n'est pas fourni (ou s'il est nul), aucun blanc ne sera utilisé.</li>
-</ul>
+<!---->
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+- Si cet argument est un nombre, il indiquera le nombre d'espaces à utiliser pour l'indentation (la valeur est ramenée à 10 si elle dépasse 10).
+- Si l'argument est une chaîne, les 10 premiers caractères (ou la chaîne si elle est plus courte) seront utilisés pour les blancs.
+- Si le paramètre n'est pas fourni (ou s'il est nul), aucun blanc ne sera utilisé.
 
-<p>Une chaîne de caractères JSON qui représente la valeur indiquée.</p>
+### Valeur de retour
 
-<h3 id="Exceptions">Exceptions</h3>
+Une chaîne de caractères JSON qui représente la valeur indiquée.
 
-<ul>
- <li>Cette méthode lève une exception {{jsxref("TypeError")}} (« <em>cyclic object value</em> ») lorsqu'elle trouve une référence circulaire.</li>
- <li>Cette méthode lève une exception {{jsxref("TypeError")}} (« <em>BigInt value can't be serialized in JSON</em> ») lorsqu'on tente de convertir une valeur {{jsxref("BigInt")}} en une chaîne de caractères JSON.</li>
-</ul>
+### Exceptions
 
-<h2 id="Description">Description</h2>
+- Cette méthode lève une exception {{jsxref("TypeError")}} (« _cyclic object value_ ») lorsqu'elle trouve une référence circulaire.
+- Cette méthode lève une exception {{jsxref("TypeError")}} (« _BigInt value can't be serialized in JSON_ ») lorsqu'on tente de convertir une valeur {{jsxref("BigInt")}} en une chaîne de caractères JSON.
 
-<p>La fonction <code>JSON.stringify()</code> convertit un objet en JSON :</p>
+## Description
 
-<ul>
- <li>L'ordre des propriétés des objets qui ne sont pas des tableaux n'est pas garanti. Par la suite, ne pas supposer que cet ordre soit respecté.</li>
- <li>Les objets {{jsxref("Boolean")}}, {{jsxref("Number")}} et {{jsxref("String")}} sont convertis en leur valeur primitive correspondante, en accord avec la sémantique traditionnelle.</li>
- <li>Si {{jsxref("undefined")}}, une fonction ou un symbole est rencontré lors de la conversion , il est soit omis ( quand il se trouve dans un objet ) ou ramené à {{jsxref("null")}} ( quand il se trouve dans un tableau). <code>JSON.stringify()</code> peut également renvoyer <code>undefined</code> lorsqu'il reçoit des valeurs « brutes » qui ne sont pas objectifiées comme par exemple <code>JSON.stringify(function(){})</code> ou <code>JSON.stringify(undefined)</code>.</li>
- <li>Toutes les propriétés liées aux symboles (cf. {{jsxref("Symbol")}}) seront complètement ignorées , même lorsque la fonction <code>remplaçant</code> est utilisée.</li>
- <li>Les propriétés qui ne sont pas énumérables seront ignorées.</li>
- <li>Les instances de {{jsxref("Date")}} implémentent la fonction <code>toJSON()</code> en renvoyant une chaîne de caractères (identique à celle renvoyée par <code>date.toISOString()</code>). Aussi, les dates sont traitées comme des chaînes de caractères.</li>
- <li>Les nombres {{jsxref("Infinity")}} et {{jsxref("NaN")}}, ainsi que l'objet {{jsxref("null")}} sont traités comme <code>null</code>.</li>
- <li>Pour les autres instances d'objets tels que {{jsxref("Map")}}, {{jsxref("Set")}}, {{jsxref("WeakMap")}} et {{jsxref("WeakSet")}}, seules les propriétés énumérables sont sérialisées.</li>
-</ul>
+La fonction `JSON.stringify()` convertit un objet en JSON :
 
-<pre class="brush: js">JSON.stringify({});                        // '{}'
+- L'ordre des propriétés des objets qui ne sont pas des tableaux n'est pas garanti. Par la suite, ne pas supposer que cet ordre soit respecté.
+- Les objets {{jsxref("Boolean")}}, {{jsxref("Number")}} et {{jsxref("String")}} sont convertis en leur valeur primitive correspondante, en accord avec la sémantique traditionnelle.
+- Si {{jsxref("undefined")}}, une fonction ou un symbole est rencontré lors de la conversion , il est soit omis ( quand il se trouve dans un objet ) ou ramené à {{jsxref("null")}} ( quand il se trouve dans un tableau). `JSON.stringify()` peut également renvoyer `undefined` lorsqu'il reçoit des valeurs « brutes » qui ne sont pas objectifiées comme par exemple `JSON.stringify(function(){})` ou `JSON.stringify(undefined)`.
+- Toutes les propriétés liées aux symboles (cf. {{jsxref("Symbol")}}) seront complètement ignorées , même lorsque la fonction `remplaçant` est utilisée.
+- Les propriétés qui ne sont pas énumérables seront ignorées.
+- Les instances de {{jsxref("Date")}} implémentent la fonction `toJSON()` en renvoyant une chaîne de caractères (identique à celle renvoyée par `date.toISOString()`). Aussi, les dates sont traitées comme des chaînes de caractères.
+- Les nombres {{jsxref("Infinity")}} et {{jsxref("NaN")}}, ainsi que l'objet {{jsxref("null")}} sont traités comme `null`.
+- Pour les autres instances d'objets tels que {{jsxref("Map")}}, {{jsxref("Set")}}, {{jsxref("WeakMap")}} et {{jsxref("WeakSet")}}, seules les propriétés énumérables sont sérialisées.
+
+```js
+JSON.stringify({});                        // '{}'
 JSON.stringify(true);                      // 'true'
 JSON.stringify("toto");                    // '"toto"'
 JSON.stringify([1, "false", false]);       // '[1,"false",false]'
@@ -140,28 +133,27 @@ JSON.stringify(Object.create(null, { x: { value: 'x', enumerable: false }, y: {
 // Échec avec BigInt
 JSON.stringify({x: 2n});
 // TypeError: BigInt value can't be serialized in JSON
-</pre>
+```
 
-<h3 id="L'argument_remplaçant">L'argument <code>remplaçant</code></h3>
+### L'argument `remplaçant`
 
-<p>L'argument <code>remplaçant</code> est une fonction ou un tableau. Si c'est une fonction, elle prend deux paramètres : une clé et la valeur qui est traitée pour être convertie en chaîne. L'objet dans lequel la clé a été trouvée sera fourni comme paramètre <code>this</code> pour la fonction. Cette fonction est d'abord appelée avec une chaîne vide comme clé représentant l'objet à transformer puis elle est appelée sur chaque propriété de l'objet ou du tableau à transformer en chaîne. Cette fonction renvoie la valeur à ajouter à la chaîne JSON :</p>
+L'argument `remplaçant` est une fonction ou un tableau. Si c'est une fonction, elle prend deux paramètres : une clé et la valeur qui est traitée pour être convertie en chaîne. L'objet dans lequel la clé a été trouvée sera fourni comme paramètre `this` pour la fonction. Cette fonction est d'abord appelée avec une chaîne vide comme clé représentant l'objet à transformer puis elle est appelée sur chaque propriété de l'objet ou du tableau à transformer en chaîne. Cette fonction renvoie la valeur à ajouter à la chaîne JSON :
 
-<ul>
- <li>Si la valeur renvoyée est un nombre ({{jsxref("Number")}}), la chaîne correspondante au nombre sera utilisée comme valeur à ajouter à la chaîne pour représenter la valeur de la propriété traitée.</li>
- <li>Si la valeur renvoyée est une chaîne de caractères ({{jsxref("String")}}), cette chaîne sera utilisée pour représenter la valeur de la propriété dans la chaîne JSON.</li>
- <li>Si la valeur renvoyée est un {{jsxref("Boolean")}}, "true" ou "false" sera utilisé pour représenter la valeur de la propriété et sera ajouté à la chaîne JSON.</li>
- <li>Si la valeur renvoyée est <code>null</code>, <code>null</code> sera ajouté à la chaîne JSON.</li>
- <li>Si la valeur renvoyée est un autre objet, cet objet sera, de façon récursive, transformé en une chaîne JSON en appelant la fonction <code>remplaçant</code> sur chaque propriété sauf si l'objet est une fonction auquel cas, rien n'est ajouté à la chaîne JSON.</li>
- <li>Si la valeur renvoyée est {{jsxref("undefined")}}, la propriété ne sera pas incluse dans la chaîne JSON.</li>
-</ul>
+- Si la valeur renvoyée est un nombre ({{jsxref("Number")}}), la chaîne correspondante au nombre sera utilisée comme valeur à ajouter à la chaîne pour représenter la valeur de la propriété traitée.
+- Si la valeur renvoyée est une chaîne de caractères ({{jsxref("String")}}), cette chaîne sera utilisée pour représenter la valeur de la propriété dans la chaîne JSON.
+- Si la valeur renvoyée est un {{jsxref("Boolean")}}, "true" ou "false" sera utilisé pour représenter la valeur de la propriété et sera ajouté à la chaîne JSON.
+- Si la valeur renvoyée est `null`, `null` sera ajouté à la chaîne JSON.
+- Si la valeur renvoyée est un autre objet, cet objet sera, de façon récursive, transformé en une chaîne JSON en appelant la fonction `remplaçant` sur chaque propriété sauf si l'objet est une fonction auquel cas, rien n'est ajouté à la chaîne JSON.
+- Si la valeur renvoyée est {{jsxref("undefined")}}, la propriété ne sera pas incluse dans la chaîne JSON.
 
-<div class="note"><p><strong>Note :</strong> la fonction <code>remplaçant</code> ne peut pas être utilisée pour retirer des valeurs d'un tableau. Si on renvoie <code>undefined</code> ou une fonction, ce sera la valeur <code>null</code> qui sera utilisée.</p></div>
+> **Note :** la fonction `remplaçant` ne peut pas être utilisée pour retirer des valeurs d'un tableau. Si on renvoie `undefined` ou une fonction, ce sera la valeur `null` qui sera utilisée.
 
-<div class="note"><p><strong>Note :</strong> Si on souhaite que la fonction <code>remplaçant</code> distingue un objet dont une propriété a un clé qui est « réellement » une chaîne vide, il faudra avoir un compteur pour le nombre d'itération. Si le compteur indique que la première itération est passée, alors il s'agit bien d'un clé avec une chaîne vide.</p></div>
+> **Note :** Si on souhaite que la fonction `remplaçant` distingue un objet dont une propriété a un clé qui est « réellement » une chaîne vide, il faudra avoir un compteur pour le nombre d'itération. Si le compteur indique que la première itération est passée, alors il s'agit bien d'un clé avec une chaîne vide.
 
-<h4 id="Exemple_avec_une_fonction">Exemple avec une fonction</h4>
+#### Exemple avec une fonction
 
-<pre class="brush: js">function remplaçant(clé, valeur) {
+```js
+function remplaçant(clé, valeur) {
   if (typeof valeur === "string") {
     return undefined;
   }
@@ -170,54 +162,54 @@ JSON.stringify({x: 2n});
 
 var toto = {fondation: "Mozilla", modèle: "boîte", semaine: 45, transport: "bus", mois: 7};
 console.log(JSON.stringify(toto, remplaçant)); // {"semaine":45, "mois":7}
-</pre>
+```
 
-<h4 id="Exemple_avec_un_tableau">Exemple avec un tableau</h4>
+#### Exemple avec un tableau
 
-<p>Si <code>remplaçant</code> est un tableau, les valeurs du tableau indiquent les propriétés de l'objet à inclure dans la chaîne JSON.</p>
+Si `remplaçant` est un tableau, les valeurs du tableau indiquent les propriétés de l'objet à inclure dans la chaîne JSON.
 
-<pre class="brush: js">JSON.stringify(toto, ['semaine', 'mois']);
+```js
+JSON.stringify(toto, ['semaine', 'mois']);
 // '{"semaine":45,"mois":7}', on ne garde que "semaines" et "mois"
-</pre>
+```
 
-<h3 id="L'argument_espace">L'argument <code>espace</code></h3>
+### L'argument `espace`
 
-<p>L'argument <code>espace</code> est utilisé pour contrôler les espacements utilisés dans la chaîne finale.</p>
+L'argument `espace` est utilisé pour contrôler les espacements utilisés dans la chaîne finale.
 
-<ul>
- <li>Si c'est un nombre, les différents niveaux d'indentation auront autant d'espaces qu'indiqué grâce à ce paramètre (jusqu'à 10).</li>
- <li>Si c'est une chaîne, les dix premiers caractères (ou la chaîne complète si elle est plus courte)</li>
-</ul>
+- Si c'est un nombre, les différents niveaux d'indentation auront autant d'espaces qu'indiqué grâce à ce paramètre (jusqu'à 10).
+- Si c'est une chaîne, les dix premiers caractères (ou la chaîne complète si elle est plus courte)
 
-<pre class="brush: js">JSON.stringify({ a: 2 }, null, ' ');
+```js
+JSON.stringify({ a: 2 }, null, ' ');
 // '{
 //  "a": 2
 // }'
-</pre>
+```
 
-<p>Dans l'exemple suivant on utilise la tabulation pour rendre lisible le résultat :</p>
+Dans l'exemple suivant on utilise la tabulation pour rendre lisible le résultat :
 
-<pre class="brush: js">JSON.stringify({ uno: 1, dos: 2 }, null, '\t');
+```js
+JSON.stringify({ uno: 1, dos: 2 }, null, '\t');
 // renverra
 // '{
 //     "uno": 1,
 //     "dos": 2
 // }'
-</pre>
+```
 
-<h3 id="La_fonction_toJSON()">La fonction <code>toJSON()</code></h3>
+### La fonction `toJSON()`
 
-<p>Pour personnaliser la valeur d'un objet lors de sa conversion en JSON, on peut surcharger la méthode <code>toJSON()</code> : la valeur retournée par cette méthode <code>toJSON()</code> sera alors utilisée. <code>JSON.stringify()</code> invoquera la méthode <code>toJSON()</code> de l'objet avec un paramètre :</p>
+Pour personnaliser la valeur d'un objet lors de sa conversion en JSON, on peut surcharger la méthode `toJSON()` : la valeur retournée par cette méthode `toJSON()` sera alors utilisée. `JSON.stringify()` invoquera la méthode `toJSON()` de l'objet avec un paramètre :
 
-<ul>
- <li>Si cet objet est une propriété de donnée, ce sera le nom de la propriété</li>
- <li>Si cet objet est un tableau, ce sera l'indice de l'élément du tableau sous la forme d'une chaîne de caractères</li>
- <li>Une chaîne vide si <code>JSON.stringify()</code> était directement appelé sur l'objet.</li>
-</ul>
+- Si cet objet est une propriété de donnée, ce sera le nom de la propriété
+- Si cet objet est un tableau, ce sera l'indice de l'élément du tableau sous la forme d'une chaîne de caractères
+- Une chaîne vide si `JSON.stringify()` était directement appelé sur l'objet.
 
-<p>Ainsi :</p>
+Ainsi :
 
-<pre class="brush: js">var obj = {
+```js
+var obj = {
   data: 'data',
   toJSON(clef){
     if(clef) {
@@ -236,28 +228,30 @@ JSON.stringify({ obj })
 
 JSON.stringify([ obj ])
 // '["Un objet imbriqué sous la clef '0'"]'
-</pre>
+```
 
-<h3 id="Le_problème_des_références_circulaires">Le problème des références circulaires</h3>
+### Le problème des références circulaires
 
-<p><a href="https://www.json.org/">Le format JSON</a> ne prend pas en charge les références (bien <a href="http://tools.ietf.org/html/draft-pbryan-zyp-json-ref-03">qu'un brouillon IETF existe</a>) et une exception {{jsxref("TypeError")}} sera levée si on tente d'encoder un objet possédant des références circulaires.</p>
+[Le format JSON](https://www.json.org/) ne prend pas en charge les références (bien [qu'un brouillon IETF existe](http://tools.ietf.org/html/draft-pbryan-zyp-json-ref-03)) et une exception {{jsxref("TypeError")}} sera levée si on tente d'encoder un objet possédant des références circulaires.
 
-<pre class="brush: js example-bad">const circularReference = {};
+```js example-bad
+const circularReference = {};
 circularReference.myself = circularReference;
 
 // Sérialiser un objet avec des références circulaires déclenche une "TypeError: cyclic object value"
 JSON.stringify(circularReference);
-</pre>
+```
 
-<p>Pour sérialiser les références circulaires, on peut utiliser une bibliothèque (<a href="https://github.com/douglascrockford/JSON-js/blob/master/cycle.js">cycle.js</a> par exemple) ou implémenter sa propre solution (qui consistera à trouver et à remplacer le cycle par des valeurs sérialisables).</p>
+Pour sérialiser les références circulaires, on peut utiliser une bibliothèque ([cycle.js](https://github.com/douglascrockford/JSON-js/blob/master/cycle.js) par exemple) ou implémenter sa propre solution (qui consistera à trouver et à remplacer le cycle par des valeurs sérialisables).
 
-<h3 id="Gestion_des_terminateurs_de_ligne">Gestion des terminateurs de ligne</h3>
+### Gestion des terminateurs de ligne
 
-<p>Par le passé, JSON n'était pas un sous-ensemble strict de JavaScript. En effet, en JSON, deux terminateurs de ligne (le caractère de séparation de ligne U+2028 LINE SEPARATOR et le caractère de séparation de paragraphe U+2029 PARAGRAPH SEPARATOR) n'avaient pas besoin d'être échappés dans des données JSON alors qu'ils devaient l'être en JavaScript. Cela a désormais évolué et les deux points de code peuvent apparaître tant en JSON qu'en JavaScript.</p>
+Par le passé, JSON n'était pas un sous-ensemble strict de JavaScript. En effet, en JSON, deux terminateurs de ligne (le caractère de séparation de ligne U+2028 LINE SEPARATOR et le caractère de séparation de paragraphe U+2029 PARAGRAPH SEPARATOR) n'avaient pas besoin d'être échappés dans des données JSON alors qu'ils devaient l'être en JavaScript. Cela a désormais évolué et les deux points de code peuvent apparaître tant en JSON qu'en JavaScript.
 
-<p>Ainsi, si on souhaite avoir une compatibilité avec les anciens moteurs JavaScript, on pourra évaluer ou utiliser les données JSON avec <a href="https://fr.wikipedia.org/wiki/JSONP">JSONP</a> et la fonction utilitaire suivante :</p>
+Ainsi, si on souhaite avoir une compatibilité avec les anciens moteurs JavaScript, on pourra évaluer ou utiliser les données JSON avec [JSONP](https://fr.wikipedia.org/wiki/JSONP) et la fonction utilitaire suivante :
 
-<pre class="brush: js">function jsFriendlyJSONStringify (s) {
+```js
+function jsFriendlyJSONStringify (s) {
     return JSON.stringify(s).
         replace(/\u2028/g, '\\u2028').
         replace(/\u2029/g, '\\u2029');
@@ -270,28 +264,27 @@ var s = {
 
 // dans Firefox, console.log enlève les échappements
 // des caractères Unicode, on utilise donc alert :(
-alert(jsFriendlyJSONStringify(s)); // {"a":"\u2028","b":"\u2029"}</pre>
+alert(jsFriendlyJSONStringify(s)); // {"a":"\u2028","b":"\u2029"}
+```
 
-<div class="note">
-<p><strong>Note :</strong> Les propriétés des objets qui ne sont pas des tableaux ne sont pas transformées en chaînes de caractères selon un ordre particulier. Aussi, l'ordre des données en JSON ne saurait constituer une information utile.</p>
-</div>
+> **Note :** Les propriétés des objets qui ne sont pas des tableaux ne sont pas transformées en chaînes de caractères selon un ordre particulier. Aussi, l'ordre des données en JSON ne saurait constituer une information utile.
 
-<pre class="brush: js">var a = JSON.stringify({toto: "truc", bidule: "machin"});
+```js
+var a = JSON.stringify({toto: "truc", bidule: "machin"});
 // '{"toto":"truc","bidule":"machin"}'
 var b = JSON.stringify({bidule: "machin", toto: "truc"});
 // '{"bidule":"machin","toto":"truc"}'
 console.log(a !== b); // true
-</pre>
+```
 
-<h3 id="Utiliser_JSON.stringify_avec_localStorage">Utiliser <code>JSON.stringify</code> avec localStorage</h3>
+### Utiliser `JSON.stringify` avec localStorage
 
-<p>Dans le cas où on souhaite enregistrer un objet créé par l'utilisateur afin de le restorer plus tard (y compris après que le navigateur ait été fermé), on peut utiliser <code>JSON.stringify</code>.</p>
+Dans le cas où on souhaite enregistrer un objet créé par l'utilisateur afin de le restorer plus tard (y compris après que le navigateur ait été fermé), on peut utiliser `JSON.stringify`.
 
-<div class="warning">
-<p><strong>Attention :</strong> Les fonctions n'ont pas de correspondances en JSON, il ne sera donc pas possible de les enregistrer de cette façon. En revanche, elles peuvent être affichées si elles ont été converties en texte avec la fonction de remplacement. De même, certains objets comme les dates seront transformées en chaîne de caractères après l'utilisation de JSON.parse().</p>
-</div>
+> **Attention :** Les fonctions n'ont pas de correspondances en JSON, il ne sera donc pas possible de les enregistrer de cette façon. En revanche, elles peuvent être affichées si elles ont été converties en texte avec la fonction de remplacement. De même, certains objets comme les dates seront transformées en chaîne de caractères après l'utilisation de JSON.parse().
 
-<pre class="brush: js">// On crée un objet pour l'exemple
+```js
+// On crée un objet pour l'exemple
 var session = {
     'screens' : [],
     'state' : true
@@ -314,54 +307,37 @@ var sessionRestaurée = JSON.parse(localStorage.getItem('session'));
 // La variable sessionRestaurée contient désormais l'objet précédent
 // qui avait été sauvegardé dans localStorage
 console.log(sessionRestaurée);
-</pre>
+```
 
-<h3 id="Chaînes_bien_formées_et_JSON.stringify()">Chaînes bien formées et <code>JSON.stringify()</code></h3>
+### Chaînes bien formées et `JSON.stringify()`
 
-<p>Les moteurs, qui implémentent la spécification sur JSON.stringify() bien formé, transformeront en chaîne de caractères les éléments isolés de paires <em>surrogates</em> via des séquences d'échappement Unicode plutôt que d'utiliser leurs valeurs littérales. Avant cette modification de spécification, <code>JSON.stringify()</code> n'aurait pas encodé les éléments <em>surrogates</em> isolés et les chaînes produites n'étaient pas valides selon UTF-8 ou UTF-16 :</p>
+Les moteurs, qui implémentent la spécification sur JSON.stringify() bien formé, transformeront en chaîne de caractères les éléments isolés de paires _surrogates_ via des séquences d'échappement Unicode plutôt que d'utiliser leurs valeurs littérales. Avant cette modification de spécification, `JSON.stringify()` n'aurait pas encodé les éléments _surrogates_ isolés et les chaînes produites n'étaient pas valides selon UTF-8 ou UTF-16 :
 
-<pre class="brush: js">JSON.stringify("\uD800"); // '"�"'</pre>
+```js
+JSON.stringify("\uD800"); // '"�"'
+```
 
-<p>Avec cette modification, les séquences d'échappement produites permettent d'avoir un contenu UTF-16 ou UTF-8 lisible :</p>
+Avec cette modification, les séquences d'échappement produites permettent d'avoir un contenu UTF-16 ou UTF-8 lisible :
 
-<pre class="brush: js">JSON.stringify("\uD800"); // '"\\ud800"'</pre>
+```js
+JSON.stringify("\uD800"); // '"\\ud800"'
+```
 
-<p>Cette modification est rétrocompatible pour toutes les opérations où le résultat de <code>JSON.stringify()</code> est passé à des API comme <code>JSON.parse()</code> qui acceptent du texte JSON valide. En effet, ces API traiteront les séquences d'échappement de <em>surrogates</em> isolés comme les caractères correspondants. Seul le cas où le code interprète directement le résultat de <code>JSON.stringify()</code> doit être adapté afin de gérer les deux encodages possibles pour ces cas.</p>
+Cette modification est rétrocompatible pour toutes les opérations où le résultat de `JSON.stringify()` est passé à des API comme `JSON.parse()` qui acceptent du texte JSON valide. En effet, ces API traiteront les séquences d'échappement de _surrogates_ isolés comme les caractères correspondants. Seul le cas où le code interprète directement le résultat de `JSON.stringify()` doit être adapté afin de gérer les deux encodages possibles pour ces cas.
 
-<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('ES5.1', '#sec-15.12.3', 'JSON.stringify')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td>Définition initiale. Implémentée avec JavaScript 1.7.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-json.stringify', 'JSON.stringify')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-json.stringify', 'JSON.stringify')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
+| Spécification                                                                        | État                         | Commentaires                                          |
+| ------------------------------------------------------------------------------------ | ---------------------------- | ----------------------------------------------------- |
+| {{SpecName('ES5.1', '#sec-15.12.3', 'JSON.stringify')}}             | {{Spec2('ES5.1')}}     | Définition initiale. Implémentée avec JavaScript 1.7. |
+| {{SpecName('ES6', '#sec-json.stringify', 'JSON.stringify')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-json.stringify', 'JSON.stringify')}} | {{Spec2('ESDraft')}} |                                                       |
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.JSON.stringify")}}</p>
+{{Compat("javascript.builtins.JSON.stringify")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("JSON.parse()")}}</li>
- <li><a href="https://github.com/douglascrockford/JSON-js/blob/master/cycle.js">cycle.js</a> qui ajoute deux fonctions <code>JSON.decycle</code> et <code>JSON.retrocycle</code> qui permettent d'encoder et de décoder des structures cycliques.</li>
-</ul>
+- {{jsxref("JSON.parse()")}}
+- [cycle.js](https://github.com/douglascrockford/JSON-js/blob/master/cycle.js) qui ajoute deux fonctions `JSON.decycle` et `JSON.retrocycle` qui permettent d'encoder et de décoder des structures cycliques.
diff --git a/files/fr/web/javascript/reference/global_objects/map/@@iterator/index.md b/files/fr/web/javascript/reference/global_objects/map/@@iterator/index.md
index 72bc8d1d13..a971dab13c 100644
--- a/files/fr/web/javascript/reference/global_objects/map/@@iterator/index.md
+++ b/files/fr/web/javascript/reference/global_objects/map/@@iterator/index.md
@@ -12,25 +12,26 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Map/@@iterator
 original_slug: Web/JavaScript/Reference/Global_Objects/Map/@@iterator
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La valeur initiale de la propriété <code><strong>@@iterator</strong></code> est la même fonction que la valeur initiale de la propriété {{jsxref("Map.prototype.entries()", "entries")}}.</p>
+La valeur initiale de la propriété **`@@iterator`** est la même fonction que la valeur initiale de la propriété {{jsxref("Map.prototype.entries()", "entries")}}.
 
-<div>{{EmbedInteractiveExample("pages/js/map-prototype-@@iterator.html")}}</div>
+{{EmbedInteractiveExample("pages/js/map-prototype-@@iterator.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><em>maMap</em>[Symbol.iterator]</pre>
+    maMap[Symbol.iterator]
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>La fonction d'itération (le symbole <code>@@iterator</code>) de l'objet, par défaut, c'est la fonction {{jsxref("Map.prototype.entries()","entries()")}}.</p>
+La fonction d'itération (le symbole `@@iterator`) de l'objet, par défaut, c'est la fonction {{jsxref("Map.prototype.entries()","entries()")}}.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_iterator()">Utiliser <code>[@@iterator]()</code></h3>
+### Utiliser `[@@iterator]()`
 
-<pre class="brush:js">var maMap = new Map();
+```js
+var maMap = new Map();
 maMap.set("0", "toto");
 maMap.set(1, "truc");
 maMap.set({}, "bidule");
@@ -40,11 +41,12 @@ var mapIter = myMap[Symbol.iterator]();
 console.log(mapIter.next().value); // ["0", "toto"]
 console.log(mapIter.next().value); // [1, "truc"]
 console.log(mapIter.next().value); // [Object, "bidule"]
-</pre>
+```
 
-<h3 id="Utiliser_iterator()_avec_for..of">Utiliser <code>[@@iterator]()</code> avec <code>for..of</code></h3>
+### Utiliser `[@@iterator]()` avec `for..of`
 
-<pre class="brush:js">var maMap = new Map();
+```js
+var maMap = new Map();
 maMap.set("0", "toto");
 maMap.set(1, "truc");
 maMap.set({}, "bidule");
@@ -52,38 +54,21 @@ maMap.set({}, "bidule");
 for (var v of maMap) {
   console.log(v);
 }
-</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-map.prototype-@@iterator', 'Map.prototype[@@iterator]()')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-map.prototype-@@iterator', 'Map.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.Map.@@iterator")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Map.prototype.entries()")}}</li>
- <li>{{jsxref("Map.prototype.keys()")}}</li>
- <li>{{jsxref("Map.prototype.values()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                        | État                         | Commentaires        |
+| -------------------------------------------------------------------------------------------------------------------- | ---------------------------- | ------------------- |
+| {{SpecName('ES2015', '#sec-map.prototype-@@iterator', 'Map.prototype[@@iterator]()')}} | {{Spec2('ES2015')}}     | Définition initiale |
+| {{SpecName('ESDraft', '#sec-map.prototype-@@iterator', 'Map.prototype[@@iterator]()')}} | {{Spec2('ESDraft')}} |                     |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Map.@@iterator")}}
+
+## Voir aussi
+
+- {{jsxref("Map.prototype.entries()")}}
+- {{jsxref("Map.prototype.keys()")}}
+- {{jsxref("Map.prototype.values()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/map/@@species/index.md b/files/fr/web/javascript/reference/global_objects/map/@@species/index.md
index dddc3795f8..69c46bb86c 100644
--- a/files/fr/web/javascript/reference/global_objects/map/@@species/index.md
+++ b/files/fr/web/javascript/reference/global_objects/map/@@species/index.md
@@ -10,62 +10,48 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Map/@@species
 original_slug: Web/JavaScript/Reference/Global_Objects/Map/@@species
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p><code><strong>Map[@@species]</strong></code> renvoie le constructeur <code>Map</code>.</p>
+**`Map[@@species]`** renvoie le constructeur `Map`.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">Map[Symbol.species]
-</pre>
+    Map[Symbol.species]
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>L'accesseur <code>species</code> renvoie le constructeur par défaut pour les objets <code>Map</code>. Les constructeurs des sous-classes peuvent surcharger ce constructeur afin de modifier ce qui est fait lors de la construction de l'objet et son affectation</p>
+L'accesseur `species` renvoie le constructeur par défaut pour les objets `Map`. Les constructeurs des sous-classes peuvent surcharger ce constructeur afin de modifier ce qui est fait lors de la construction de l'objet et son affectation
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<p>La propriété <code>species</code> renvoie la fonction correspondant au constructeur par défaut. Pour les objets <code>Map</code>, ce sera le constructeur <code>Map</code> :</p>
+La propriété `species` renvoie la fonction correspondant au constructeur par défaut. Pour les objets `Map`, ce sera le constructeur `Map` :
 
-<pre class="brush: js">Map[Symbol.species]; // function Map()</pre>
+```js
+Map[Symbol.species]; // function Map()
+```
 
-<p>Pour des objets dérivés (par exemple un dictionnaire <code>MaMap</code> que vous auriez construit), la propriété <code>species</code> correspondra au constructeur <code>MaMap</code>. Si vous souhaitez surcharger cela pour renvoyer le constructeur parent <code>Map</code>, vous pourrez utiliser :</p>
+Pour des objets dérivés (par exemple un dictionnaire `MaMap` que vous auriez construit), la propriété `species` correspondra au constructeur `MaMap`. Si vous souhaitez surcharger cela pour renvoyer le constructeur parent `Map`, vous pourrez utiliser :
 
-<pre class="brush: js">class MaMap extends Map {
+```js
+class MaMap extends Map {
   // On surcharge le symbole species de MaMap
   // avec le constructeur Map parent
   static get [Symbol.species]() { return Map; }
-}</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('ES2015', '#sec-get-map-@@species', 'get Map [ @@species ]')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-get-map-@@species', 'get Map [ @@species ]')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Map.@@species")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Map")}}</li>
- <li>{{jsxref("Symbol.species")}}</li>
-</ul>
+}
+```
+
+## Spécifications
+
+| Spécification                                                                                        | Statut                       | Commentaires         |
+| ---------------------------------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ES2015', '#sec-get-map-@@species', 'get Map [ @@species ]')}}     | {{Spec2('ES2015')}}     | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-get-map-@@species', 'get Map [ @@species ]')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Map.@@species")}}
+
+## Voir aussi
+
+- {{jsxref("Map")}}
+- {{jsxref("Symbol.species")}}
diff --git a/files/fr/web/javascript/reference/global_objects/map/@@tostringtag/index.md b/files/fr/web/javascript/reference/global_objects/map/@@tostringtag/index.md
index 251a4c46eb..0618585f04 100644
--- a/files/fr/web/javascript/reference/global_objects/map/@@tostringtag/index.md
+++ b/files/fr/web/javascript/reference/global_objects/map/@@tostringtag/index.md
@@ -11,44 +11,29 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Map/@@toStringTag
 original_slug: Web/JavaScript/Reference/Global_Objects/Map/@@toStringTag
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La propriété <strong><code>Map[@@toStringTag]</code></strong> vaut "Map" initialement.</p>
+La propriété **`Map[@@toStringTag]`** vaut "Map" initialement.
 
-<div>{{EmbedInteractiveExample("pages/js/map-prototype-@@tostringtag.html")}}</div>
+{{EmbedInteractiveExample("pages/js/map-prototype-@@tostringtag.html")}}{{js_property_attributes(0,0,1)}}
 
-<div>{{js_property_attributes(0,0,1)}}</div>
+## Syntaxe
 
-<h2 id="Syntaxe">Syntaxe</h2>
+    Map[Symbol.toStringTag]
 
-<pre class="syntaxbox">Map[Symbol.toStringTag]</pre>
+## Exemple
 
-<h2 id="Exemple">Exemple</h2>
+```js
+Object.prototype.toString.call(new Map()) // "[object Map]"
+```
 
-<pre class="brush:js">Object.prototype.toString.call(new Map()) // "[object Map]"</pre>
+## Spécifications
 
-<h2 id="Spécifications">Spécifications</h2>
+| Spécification                                                                                                            | État                         | Commentaires         |
+| ------------------------------------------------------------------------------------------------------------------------ | ---------------------------- | -------------------- |
+| {{SpecName('ES2015', '#sec-map.prototype-@@tostringtag', 'Map.prototype[@@toStringTag]')}} | {{Spec2('ES2015')}}     | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-map.prototype-@@tostringtag', 'Map.prototype[@@toStringTag]')}} | {{Spec2('ESDraft')}} |                      |
 
-<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-map.prototype-@@tostringtag', 'Map.prototype[@@toStringTag]')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-map.prototype-@@tostringtag', 'Map.prototype[@@toStringTag]')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
+## Compatibilité des navigateurs
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Map.@@toStringTag")}}</p>
+{{Compat("javascript.builtins.Map.@@toStringTag")}}
diff --git a/files/fr/web/javascript/reference/global_objects/map/clear/index.md b/files/fr/web/javascript/reference/global_objects/map/clear/index.md
index 5c0dbc8661..7eb0c53805 100644
--- a/files/fr/web/javascript/reference/global_objects/map/clear/index.md
+++ b/files/fr/web/javascript/reference/global_objects/map/clear/index.md
@@ -11,25 +11,26 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Map/clear
 original_slug: Web/JavaScript/Reference/Global_Objects/Map/clear
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>clear()</strong></code> supprime tous les éléments d'un objet <code>Map</code>.</p>
+La méthode **`clear()`** supprime tous les éléments d'un objet `Map`.
 
-<div>{{EmbedInteractiveExample("pages/js/map-prototype-clear.html")}}</div>
+{{EmbedInteractiveExample("pages/js/map-prototype-clear.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>maMap</var>.clear();</pre>
+    maMap.clear();
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>{{jsxref("undefined")}}.</p>
+{{jsxref("undefined")}}.
 
-<h2 id="Exemple">Exemple</h2>
+## Exemple
 
-<h3 id="Utiliser_la_méthode_clear()">Utiliser la méthode <code>clear()</code></h3>
+### Utiliser la méthode `clear()`
 
-<pre class="brush: js">var maMap = new Map();
+```js
+var maMap = new Map();
 maMap.set("truc", "bidule");
 maMap.set(1, "toto");
 
@@ -40,36 +41,19 @@ maMap.clear();
 
 maMap.size;        // 0
 maMap.has("truc")  // 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('ES2015', '#sec-map.prototype.clear', 'Map.prototype.clear')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-map.prototype.clear', 'Map.prototype.clear')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Map.clear")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Map")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                        | État                         | Commentaires         |
+| ---------------------------------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ES2015', '#sec-map.prototype.clear', 'Map.prototype.clear')}}     | {{Spec2('ES2015')}}     | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-map.prototype.clear', 'Map.prototype.clear')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Map.clear")}}
+
+## Voir aussi
+
+- {{jsxref("Map")}}
diff --git a/files/fr/web/javascript/reference/global_objects/map/delete/index.md b/files/fr/web/javascript/reference/global_objects/map/delete/index.md
index 3705d6bacc..0e8aa9ecf5 100644
--- a/files/fr/web/javascript/reference/global_objects/map/delete/index.md
+++ b/files/fr/web/javascript/reference/global_objects/map/delete/index.md
@@ -11,64 +11,46 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Map/delete
 original_slug: Web/JavaScript/Reference/Global_Objects/Map/delete
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>delete()</code></strong> permet de retirer un élément donné d'un objet <code>Map</code> grâce à sa clé.</p>
+La méthode **`delete()`** permet de retirer un élément donné d'un objet `Map` grâce à sa clé.
 
-<div>{{EmbedInteractiveExample("pages/js/map-prototype-delete.html")}}</div>
+{{EmbedInteractiveExample("pages/js/map-prototype-delete.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>maMap</var>.delete(clé);</pre>
+    maMap.delete(clé);
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>clé</code></dt>
- <dd>Ce paramètre obligatoire correspond à la clé de l'élément qu'on souhaite retirer de l'objet <code>Map</code>.</dd>
-</dl>
+- `clé`
+  - : Ce paramètre obligatoire correspond à la clé de l'élément qu'on souhaite retirer de l'objet `Map`.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un booléen. La méthode renvoie <code>true</code> si un élément de l'objet <code>Map</code> a bien été retiré ou <code>false</code> si l'élément n'existe pas.</p>
+Un booléen. La méthode renvoie `true` si un élément de l'objet `Map` a bien été retiré ou `false` si l'élément n'existe pas.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<pre class="brush: js">var maMap = new Map();
+```js
+var maMap = new Map();
 maMap.set("truc", "toto");
 
 maMap.delete("truc"); // Renvoie true. La suppression est OK.
 maMap.has("truc");    // Renvoie false. "truc" n'est plus présent.
-</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-map.prototype.delete', 'Map.prototype.delete')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-map.prototype.delete', 'Map.prototype.delete')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Map.delete")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Map")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                        | État                         | Commentaires         |
+| ---------------------------------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ES2015', '#sec-map.prototype.delete', 'Map.prototype.delete')}} | {{Spec2('ES2015')}}     | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-map.prototype.delete', 'Map.prototype.delete')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Map.delete")}}
+
+## Voir aussi
+
+- {{jsxref("Map")}}
diff --git a/files/fr/web/javascript/reference/global_objects/map/entries/index.md b/files/fr/web/javascript/reference/global_objects/map/entries/index.md
index 3deaed0bd3..a03e8f96c4 100644
--- a/files/fr/web/javascript/reference/global_objects/map/entries/index.md
+++ b/files/fr/web/javascript/reference/global_objects/map/entries/index.md
@@ -12,25 +12,26 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Map/entries
 original_slug: Web/JavaScript/Reference/Global_Objects/Map/entries
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>entries()</code></strong> renvoie un objet <code><a href="/fr/docs/Web/JavaScript/Guide/iterateurs_et_generateurs#Itérateurs">Iterator</a></code> qui contient les paires <code>[clé, valeur]</code> pour chaque élément de l'objet <code>Map</code>, dans leur ordre d'insertion.</p>
+La méthode **`entries()`** renvoie un objet [`Iterator`](/fr/docs/Web/JavaScript/Guide/iterateurs_et_generateurs#Itérateurs) qui contient les paires `[clé, valeur]` pour chaque élément de l'objet `Map`, dans leur ordre d'insertion.
 
-<div>{{EmbedInteractiveExample("pages/js/map-prototype-entries.html")}}</div>
+{{EmbedInteractiveExample("pages/js/map-prototype-entries.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><em>maMap</em>.entries()</pre>
+    maMap.entries()
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un nouvel objet <code>Iterator</code> {{jsxref("Map")}}.</p>
+Un nouvel objet `Iterator` {{jsxref("Map")}}.
 
-<h2 id="Exemple">Exemple</h2>
+## Exemple
 
-<h3 id="Utiliser_entries()">Utiliser <code>entries()</code></h3>
+### Utiliser `entries()`
 
-<pre class="brush:js">var maMap = new Map();
+```js
+var maMap = new Map();
 maMap.set("0", "toto");
 maMap.set(1, "truc");
 maMap.set({}, "bidule");
@@ -40,39 +41,20 @@ var mapIter = maMap.entries();
 console.log(mapIter.next().value); // ["0", "toto"]
 console.log(mapIter.next().value); // [1, "truc"]
 console.log(mapIter.next().value); // [Object, "bidule"]
-</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('ES2015', '#sec-map.prototype.entries', 'Map.prototype.entries')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Défintion initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-map.prototype.entries', 'Map.prototype.entries')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Map.entries")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Map.prototype.keys()")}}</li>
- <li>{{jsxref("Map.prototype.values()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                            | État                         | Commentaires        |
+| -------------------------------------------------------------------------------------------------------- | ---------------------------- | ------------------- |
+| {{SpecName('ES2015', '#sec-map.prototype.entries', 'Map.prototype.entries')}} | {{Spec2('ES2015')}}     | Défintion initiale. |
+| {{SpecName('ESDraft', '#sec-map.prototype.entries', 'Map.prototype.entries')}} | {{Spec2('ESDraft')}} |                     |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Map.entries")}}
+
+## Voir aussi
+
+- {{jsxref("Map.prototype.keys()")}}
+- {{jsxref("Map.prototype.values()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/map/foreach/index.md b/files/fr/web/javascript/reference/global_objects/map/foreach/index.md
index 4d2fbfdd70..da31bd273a 100644
--- a/files/fr/web/javascript/reference/global_objects/map/foreach/index.md
+++ b/files/fr/web/javascript/reference/global_objects/map/foreach/index.md
@@ -11,52 +11,49 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Map/forEach
 original_slug: Web/JavaScript/Reference/Global_Objects/Map/forEach
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>forEach()</strong></code> exécute une fonction donnée sur chaque élément clé-valeur de l'objet <code>Map</code> dans l'ordre d'insertion.</p>
+La méthode **`forEach()`** exécute une fonction donnée sur chaque élément clé-valeur de l'objet `Map` dans l'ordre d'insertion.
 
-<div>{{EmbedInteractiveExample("pages/js/map-prototype-foreach.html")}}</div>
+{{EmbedInteractiveExample("pages/js/map-prototype-foreach.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><em>maMap</em>.forEach(<em>callback</em>[, <em>thisArg</em>])</pre>
+    maMap.forEach(callback[, thisArg])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>callback</code></dt>
- <dd>La fonction à exécuter pour chaque élément.</dd>
- <dt><code>thisArg</code></dt>
- <dd>La valeur à utiliser comme contexte <code>this</code> lors de l'exécution de <code>callback</code>.</dd>
-</dl>
+- `callback`
+  - : La fonction à exécuter pour chaque élément.
+- `thisArg`
+  - : La valeur à utiliser comme contexte `this` lors de l'exécution de `callback`.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>{{jsxref("undefined")}}</p>
+{{jsxref("undefined")}}
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La méthode <code>forEach</code> exécute la fonction <code>callback</code> donnée sur chacune des clés qui existe. Elle n'est pas appelée pour les clés qui ont été supprimées. En revanche, elle est appelée pour les valeurs qui sont présentes mais qui sont égales à <code>undefined</code>.</p>
+La méthode `forEach` exécute la fonction `callback` donnée sur chacune des clés qui existe. Elle n'est pas appelée pour les clés qui ont été supprimées. En revanche, elle est appelée pour les valeurs qui sont présentes mais qui sont égales à `undefined`.
 
-<p><code>callback</code> est appelé avec <strong>trois arguments</strong> :</p>
+`callback` est appelé avec **trois arguments** :
 
-<ul>
- <li>la <strong>valeur de l'élément</strong></li>
- <li>la <strong>clé de l'élément</strong></li>
- <li>l'objet <strong><code>Map</code> parcouru</strong></li>
-</ul>
+- la **valeur de l'élément**
+- la **clé de l'élément**
+- l'objet **`Map` parcouru**
 
-<p>Si un argument <code>thisArg</code> est fourni à la méthode <code>forEach</code>, il sera passé au <code>callback</code> quand il sera appelé et celui-ci l'utilisera comme valeur <code>this</code>. Dans les autres cas, la valeur <code>undefined</code> sera utilisée comme contexte <code>this</code>. La valeur <code>this</code> observée par la fonction <code>callback</code> est déterminée selon <a href="/fr/docs/JavaScript/Reference/Opérateurs/Opérateurs_spéciaux/L'opérateur_this">les règles appliquées à l'opérateur <code>this</code></a>.</p>
+Si un argument `thisArg` est fourni à la méthode `forEach`, il sera passé au `callback` quand il sera appelé et celui-ci l'utilisera comme valeur `this`. Dans les autres cas, la valeur `undefined` sera utilisée comme contexte `this`. La valeur `this` observée par la fonction `callback` est déterminée selon [les règles appliquées à l'opérateur `this`](/fr/docs/JavaScript/Reference/Opérateurs/Opérateurs_spéciaux/L'opérateur_this).
 
-<p>Chacune des valeurs sera traitée une fois sauf si celle-ci a été supprimée puis réajoutée avant la fin de <code>forEach</code>. <code>callback</code> n'est pas appelé pour les valeurs qui sont supprimés avant le passage de la fonction. Les valeurs qui sont ajoutées avant que <code>forEach</code> ait parcouru l'ensemble seront traitées.</p>
+Chacune des valeurs sera traitée une fois sauf si celle-ci a été supprimée puis réajoutée avant la fin de `forEach`. `callback` n'est pas appelé pour les valeurs qui sont supprimés avant le passage de la fonction. Les valeurs qui sont ajoutées avant que `forEach` ait parcouru l'ensemble seront traitées.
 
-<p><code>forEach</code> exécute la fonction <code>callback</code> une fois pour chaque élément de l'objet <code>Map</code> : il ne renvoie pas de valeur.</p>
+`forEach` exécute la fonction `callback` une fois pour chaque élément de l'objet `Map` : il ne renvoie pas de valeur.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<p>Le fragment de code suivant enregistre une ligne pour chaque élément d'un objet<code> Map </code>:</p>
+Le fragment de code suivant enregistre une ligne pour chaque élément d'un objet` Map `:
 
-<pre class="brush:js">function logMapElements(valeur, clé, map) {
+```js
+function logMapElements(valeur, clé, map) {
     console.log(`map.get('${clé}') = ${value}`);
 }
 
@@ -66,37 +63,20 @@ new Map([["toto", 3], ["truc", {}], ["bidule", undefined]]).forEach(logMapElemen
 // "map.get('toto') = 3"
 // "map.get('truc') = [object Object]"
 // "map.get('bidule') = undefined"
-</pre>
-
-<h2 id="Spécifications">Spécifications</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">État</th>
-   <th scope="col">Commentaires</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES2015', '#sec-map.prototype.foreach', 'Map.prototype.forEach')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-map.prototype.foreach', 'Map.prototype.forEach')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Map.forEach")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Array.prototype.forEach()")}}</li>
- <li>{{jsxref("Set.prototype.forEach()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                            | État                         | Commentaires         |
+| -------------------------------------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ES2015', '#sec-map.prototype.foreach', 'Map.prototype.forEach')}} | {{Spec2('ES2015')}}     | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-map.prototype.foreach', 'Map.prototype.forEach')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Map.forEach")}}
+
+## Voir aussi
+
+- {{jsxref("Array.prototype.forEach()")}}
+- {{jsxref("Set.prototype.forEach()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/map/get/index.md b/files/fr/web/javascript/reference/global_objects/map/get/index.md
index bf2e8cba01..5dbc57ae3a 100644
--- a/files/fr/web/javascript/reference/global_objects/map/get/index.md
+++ b/files/fr/web/javascript/reference/global_objects/map/get/index.md
@@ -11,66 +11,48 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Map/get
 original_slug: Web/JavaScript/Reference/Global_Objects/Map/get
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>get()</strong></code> renvoie un élément précisé d'un objet <code>Map</code>. Si la valeur associée à la clé fournie est un objet, alors on obtient une référence à cet objet et tous changements apporté à cet objet sera aussi visible à l'intérieur de l'objet <code>Map</code>.</p>
+La méthode **`get()`** renvoie un élément précisé d'un objet `Map`. Si la valeur associée à la clé fournie est un objet, alors on obtient une référence à cet objet et tous changements apporté à cet objet sera aussi visible à l'intérieur de l'objet `Map`.
 
-<div>{{EmbedInteractiveExample("pages/js/map-prototype-get.html")}}</div>
+{{EmbedInteractiveExample("pages/js/map-prototype-get.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox notranslate"><em>maMap</em>.get(clé)</pre>
+    maMap.get(clé)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>clé</code></dt>
- <dd>La clé de l'élément à renvoyer depuis l'objet <code>Map</code>.</dd>
-</dl>
+- `clé`
+  - : La clé de l'élément à renvoyer depuis l'objet `Map`.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>L'élément associée à la clé donnée ou {{jsxref("undefined")}} si la clé ne fait pas partie de l'objet <code>Map</code>.</p>
+L'élément associée à la clé donnée ou {{jsxref("undefined")}} si la clé ne fait pas partie de l'objet `Map`.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<pre class="brush: js notranslate">var maMap = new Map();
+```js
+var maMap = new Map();
 maMap.set("truc", "toto");
 
 maMap.get("truc");     // Renvoie "toto".
 maMap.get("machin");   // Renvoie undefined.
-</pre>
-
-<h2 id="Spécifications">Spécifications</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">État</th>
-   <th scope="col">Commentaires</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES2015', '#sec-map.prototype.get', 'Map.prototype.get')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-map.prototype.get', 'Map.prototype.get')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Map.get")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Map")}}</li>
- <li>{{jsxref("Map.prototype.set()")}}</li>
- <li>{{jsxref("Map.prototype.has()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                | État                         | Commentaires         |
+| -------------------------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ES2015', '#sec-map.prototype.get', 'Map.prototype.get')}} | {{Spec2('ES2015')}}     | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-map.prototype.get', 'Map.prototype.get')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Map.get")}}
+
+## Voir aussi
+
+- {{jsxref("Map")}}
+- {{jsxref("Map.prototype.set()")}}
+- {{jsxref("Map.prototype.has()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/map/has/index.md b/files/fr/web/javascript/reference/global_objects/map/has/index.md
index ce26d66e47..998b7fe3bc 100644
--- a/files/fr/web/javascript/reference/global_objects/map/has/index.md
+++ b/files/fr/web/javascript/reference/global_objects/map/has/index.md
@@ -11,66 +11,48 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Map/has
 original_slug: Web/JavaScript/Reference/Global_Objects/Map/has
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>has()</strong></code> renvoie un booléen permettant de déterminer si l'objet <code>Map</code> en question contient la clé donnée.</p>
+La méthode **`has()`** renvoie un booléen permettant de déterminer si l'objet `Map` en question contient la clé donnée.
 
-<div>{{EmbedInteractiveExample("pages/js/map-prototype-has.html")}}</div>
+{{EmbedInteractiveExample("pages/js/map-prototype-has.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><em>maMap</em>.has(clé);</pre>
+    maMap.has(clé);
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>clé</code></dt>
- <dd>Ce paramètre obligatoire correspond à la clé dont on veut savoir si elle appartient à l'objet <code>Map</code>.</dd>
-</dl>
+- `clé`
+  - : Ce paramètre obligatoire correspond à la clé dont on veut savoir si elle appartient à l'objet `Map`.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Cette méthode renvoie un booléen : <code>true</code> si un élément avec cette clé existe au sein de l'objet <code>Map</code> et <code>false</code> sinon.</p>
+Cette méthode renvoie un booléen : `true` si un élément avec cette clé existe au sein de l'objet `Map` et `false` sinon.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<pre class="brush: js">var maMap = new Map();
+```js
+var maMap = new Map();
 maMap.set("truc", "toto");
 
 maMap.has("truc");  // renvoie true
 maMap.has("machin");// renvoie 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('ES2015', '#sec-map.prototype.has', 'Map.prototype.has')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-map.prototype.has', 'Map.prototype.has')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Map.has")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Map")}}</li>
- <li>{{jsxref("Map.prototype.set()")}}</li>
- <li>{{jsxref("Map.prototype.get()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                | État                         | Commentaires         |
+| -------------------------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ES2015', '#sec-map.prototype.has', 'Map.prototype.has')}} | {{Spec2('ES2015')}}     | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-map.prototype.has', 'Map.prototype.has')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Map.has")}}
+
+## Voir aussi
+
+- {{jsxref("Map")}}
+- {{jsxref("Map.prototype.set()")}}
+- {{jsxref("Map.prototype.get()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/map/index.md b/files/fr/web/javascript/reference/global_objects/map/index.md
index 7e49822844..81d5b8cb36 100644
--- a/files/fr/web/javascript/reference/global_objects/map/index.md
+++ b/files/fr/web/javascript/reference/global_objects/map/index.md
@@ -9,82 +9,75 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Map
 original_slug: Web/JavaScript/Reference/Global_Objects/Map
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>L'objet <strong><code>Map</code></strong> représente un dictionnaire, autrement dit une carte de clés/valeurs. N'importe quelle valeur valable en JavaScript (que ce soit les objets ou les valeurs de types primitifs) peut être utilisée comme clé ou comme valeur.</p>
+L'objet **`Map`** représente un dictionnaire, autrement dit une carte de clés/valeurs. N'importe quelle valeur valable en JavaScript (que ce soit les objets ou les valeurs de types primitifs) peut être utilisée comme clé ou comme valeur.
 
-<p>L'ordre d'insertion des clés est mémorisé dans l'objet et les boucles sur les <code>Map</code> parcourent les clés dans cet ordre.</p>
+L'ordre d'insertion des clés est mémorisé dans l'objet et les boucles sur les `Map` parcourent les clés dans cet ordre.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox notranslate">new Map([<var>iterable</var>])</pre>
+    new Map([iterable])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>itérable</code></dt>
- <dd>Un tableau ({{jsxref("Array")}}) ou tout autre objet <a href="/fr/docs/Web/JavaScript/Reference/Les_protocoles_iteration#Le_protocole_«_itérable_»">itérable</a> dont les éléments sont des paires clé/valeur (par exemple un tableau de la forme <code>[[1 , "toto"],[2, "truc"]]</code>). Chaque paire clé/valeur sera ajoutée au nouvel objet <code>Map</code>. {{jsxref("null")}} est traité comme {{jsxref("undefined")}}.</dd>
-</dl>
+- `itérable`
+  - : Un tableau ({{jsxref("Array")}}) ou tout autre objet [itérable](/fr/docs/Web/JavaScript/Reference/Les_protocoles_iteration#Le_protocole_«_itérable_») dont les éléments sont des paires clé/valeur (par exemple un tableau de la forme `[[1 , "toto"],[2, "truc"]]`). Chaque paire clé/valeur sera ajoutée au nouvel objet `Map`. {{jsxref("null")}} est traité comme {{jsxref("undefined")}}.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Un objet <code>Map</code> permet de retrouver ses éléments dans leur ordre d'insertion. Par exemple, une boucle {{jsxref("Instructions/for...of","for...of")}} renverra un tableau de <code>[clé, valeur]</code> pour chaque itération.</p>
+Un objet `Map` permet de retrouver ses éléments dans leur ordre d'insertion. Par exemple, une boucle {{jsxref("Instructions/for...of","for...of")}} renverra un tableau de `[clé, valeur]` pour chaque itération.
 
-<p>On notera qu'un objet <code>Map</code> contenant des objets ne sera parcouru que dans l'ordre d'insertion de ces objets. Avec ES2015, l'ordre d'itération est fixé pour les objets. Toutefois, pour les versions antérieures d'ECMAScript, cet ordre n'est pas garanti.</p>
+On notera qu'un objet `Map` contenant des objets ne sera parcouru que dans l'ordre d'insertion de ces objets. Avec ES2015, l'ordre d'itération est fixé pour les objets. Toutefois, pour les versions antérieures d'ECMAScript, cet ordre n'est pas garanti.
 
-<h3 id="Égalité_des_clés">Égalité des clés</h3>
+### Égalité des clés
 
-<p>L'égalité des clés est testée avec l'algorithme basé sur <a href="/fr/docs/JavaScript/Les_différents_tests_d_Égalité_comment_les_utiliser#.C3.89galit.C3.A9_de_valeurs">l'égalité de valeurs</a> :</p>
+L'égalité des clés est testée avec l'algorithme basé sur [l'égalité de valeurs](/fr/docs/JavaScript/Les_différents_tests_d_Égalité_comment_les_utiliser#.C3.89galit.C3.A9_de_valeurs) :
 
-<ul>
- <li>{{jsxref("NaN")}} est considéré égal à <code>NaN</code> (bien que, pour l'égalité stricte <code>NaN !== NaN</code>)</li>
- <li>les autres valeurs sont considérées égales au sens de l'égalité stricte (l'opérateur  <code>===</code>).</li>
-</ul>
+- {{jsxref("NaN")}} est considéré égal à `NaN` (bien que, pour l'égalité stricte `NaN !== NaN`)
+- les autres valeurs sont considérées égales au sens de l'égalité stricte (l'opérateur  `===`).
 
-<p>Dans les versions précédentes des brouillons ECMAScript 2015 (ES6) <code>-0</code> et <code>+0</code> étaient considérés différents (bien que <code>-0 === +0</code>), ceci a été changé dans les versions ultérieures et a été adapté avec Gecko 29 {{geckoRelease("29")}} ({{bug("952870")}}) et une version nocturne de <a href="https://code.google.com/p/v8/issues/detail?id=3069">Chrome</a>.</p>
+Dans les versions précédentes des brouillons ECMAScript 2015 (ES6) `-0` et `+0` étaient considérés différents (bien que `-0 === +0`), ceci a été changé dans les versions ultérieures et a été adapté avec Gecko 29 {{geckoRelease("29")}} ({{bug("952870")}}) et une version nocturne de [Chrome](https://code.google.com/p/v8/issues/detail?id=3069).
 
-<h3 id="Comparaison_entre_objets_et_maps">Comparaison entre objets et maps</h3>
+### Comparaison entre objets et maps
 
-<p>Les {{jsxref("Object", "objets","",1)}} sont similaires aux <code>Maps</code>, chacun manipulant des clés associées à des valeurs, récupérant ces valeurs, supprimant des clés... Il n'y avait auparavant pas d'alternatives natives et c'est pourquoi, historiquement, les objets JavaScript ont été utilisés comme des <code>Maps</code>. Malgré tout, il y a des différences importantes entre<code> Objects</code> et <code>Maps</code> qui permettent de distinguer une utilisation des objets <code>Map</code> plus efficace :</p>
+Les {{jsxref("Object", "objets","",1)}} sont similaires aux `Maps`, chacun manipulant des clés associées à des valeurs, récupérant ces valeurs, supprimant des clés... Il n'y avait auparavant pas d'alternatives natives et c'est pourquoi, historiquement, les objets JavaScript ont été utilisés comme des `Maps`. Malgré tout, il y a des différences importantes entre` Objects` et `Maps` qui permettent de distinguer une utilisation des objets `Map` plus efficace :
 
-<ul>
- <li>Un <code>Object</code> possède un prototype, certaines clés par défaut peuvent donc entrer en collision avec les clés qu'on souhaite créer. À partir d'ES5, on peut écrire <code>map = </code> {{jsxref("Object.create", "Object.create(null)")}} mais cette formulation est rarement utilisée.</li>
- <li>Les clés d'une <code>Map</code> sont ordonnées tandis que les clés d'un objet n'ont pas d'ordre particulier. Ainsi, quand on parcourt une <code>Map</code>, on obtient les clés selon leur ordre d'insertion. On notera qu'à partir d'ECMAScript 2015, la spécification pour les objets indique de conserver l'ordre de création pour les clés qui sont des chaînes et des symboles.</li>
- <li>Les clés d'un <code>Object</code> sont des {{jsxref("String", "chaînes de caractères","",1)}} ou des symboles (cf. {{jsxref("Symbol")}}), alors que pour une <code>Map</code> ça peut être n'importe quelle valeur.</li>
- <li>Il est possible d'obtenir facilement la taille d'une <code>Map</code> avec <code>size</code>. En revanche, pour un <code>Object</code> il faudra compter « manuellement ».</li>
- <li>Un objet <code>Map</code> est un <a href="/fr/docs/Web/JavaScript/Reference/Les_protocoles_iteration#Le_protocole_«_itérable_»">itérable</a> et on peut donc le parcourir directement. En revanche, itérer sur un <code>Object</code> nécessite de récupérer les clés de l'objet pour ensuite les parcourir.</li>
- <li>Un objet <code>Map</code> permettra d'obtenir de meilleures performances si on ajoute et supprime des éléments fréquemment.</li>
-</ul>
+- Un `Object` possède un prototype, certaines clés par défaut peuvent donc entrer en collision avec les clés qu'on souhaite créer. À partir d'ES5, on peut écrire `map = `{{jsxref("Object.create", "Object.create(null)")}} mais cette formulation est rarement utilisée.
+- Les clés d'une `Map` sont ordonnées tandis que les clés d'un objet n'ont pas d'ordre particulier. Ainsi, quand on parcourt une `Map`, on obtient les clés selon leur ordre d'insertion. On notera qu'à partir d'ECMAScript 2015, la spécification pour les objets indique de conserver l'ordre de création pour les clés qui sont des chaînes et des symboles.
+- Les clés d'un `Object` sont des {{jsxref("String", "chaînes de caractères","",1)}} ou des symboles (cf. {{jsxref("Symbol")}}), alors que pour une `Map` ça peut être n'importe quelle valeur.
+- Il est possible d'obtenir facilement la taille d'une `Map` avec `size`. En revanche, pour un `Object` il faudra compter « manuellement ».
+- Un objet `Map` est un [itérable](/fr/docs/Web/JavaScript/Reference/Les_protocoles_iteration#Le_protocole_«_itérable_») et on peut donc le parcourir directement. En revanche, itérer sur un `Object` nécessite de récupérer les clés de l'objet pour ensuite les parcourir.
+- Un objet `Map` permettra d'obtenir de meilleures performances si on ajoute et supprime des éléments fréquemment.
 
-<h2 id="Propriétés">Propriétés</h2>
+## Propriétés
 
-<dl>
- <dt><code>Map.length</code></dt>
- <dd>La valeur de la propriété <code>length</code> est 0.<br>
- Attention, pour compter le nombre d'élément contenu dans une <code>Map</code>, on utilisera plutôt {{jsxref("Map.prototype.size")}}.</dd>
- <dt>{{jsxref("Map.@@species", "get Map[@@species]")}}</dt>
- <dd>La fonction constructeur utilisée pour créer des objets dérivées.</dd>
- <dt>{{jsxref("Map.prototype")}}</dt>
- <dd>Représente le prototype du constructeur <code>Map</code>. Permet l'addition de propriétés à tous les objets <code>Map</code>.</dd>
-</dl>
+- `Map.length`
+  - : La valeur de la propriété `length` est 0.
+    Attention, pour compter le nombre d'élément contenu dans une `Map`, on utilisera plutôt {{jsxref("Map.prototype.size")}}.
+- {{jsxref("Map.@@species", "get Map[@@species]")}}
+  - : La fonction constructeur utilisée pour créer des objets dérivées.
+- {{jsxref("Map.prototype")}}
+  - : Représente le prototype du constructeur `Map`. Permet l'addition de propriétés à tous les objets `Map`.
 
-<h2 id="Instances_de_Map">Instances de <code>Map</code></h2>
+## Instances de `Map`
 
-<p>Toutes les instances de <code>Map</code> héritent de {{jsxref("Map.prototype")}}.</p>
+Toutes les instances de `Map` héritent de {{jsxref("Map.prototype")}}.
 
-<h3 id="Propriétés_2">Propriétés</h3>
+### Propriétés
 
-<p>{{page('fr/docs/Web/JavaScript/Reference/Objets_globaux/Map/prototype','Propriétés')}}</p>
+{{page('fr/docs/Web/JavaScript/Reference/Objets_globaux/Map/prototype','Propriétés')}}
 
-<h3 id="Méthodes">Méthodes</h3>
+### Méthodes
 
-<p>{{page('fr/docs/Web/JavaScript/Reference/Objets_globaux/Map/prototype','Méthodes')}}</p>
+{{page('fr/docs/Web/JavaScript/Reference/Objets_globaux/Map/prototype','Méthodes')}}
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_un_objet_Map">Utiliser un objet <code>Map</code></h3>
+### Utiliser un objet `Map`
 
-<pre class="brush: js notranslate">const myMap = new Map();
+```js
+const myMap = new Map();
 
 const objectKey = {},
     functionKey = function () {},
@@ -106,26 +99,28 @@ myMap.get("une chaîne");  // "valeur associée à 'une chaîne'"
                           // car chaineClé === 'une chaîne'
 myMap.get({});            // indéfini car objetClé !== {}
 myMap.get(function() {}); // indéfini car fonctionClé !== function () {}
-</pre>
+```
 
-<h3 id="Utiliser_NaN_comme_clé">Utiliser <code>NaN</code> comme clé</h3>
+### Utiliser `NaN` comme clé
 
-<p>{{jsxref("NaN")}} peut être utilisé comme une clé. Bien que <code>NaN</code> ne soit pas strictement égal à lui-même (<code>NaN !== NaN</code> est vérifié), on peut bâtir l'exemple suivant car on ne peut pas distinguer deux valeurs <code>NaN </code>:</p>
+{{jsxref("NaN")}} peut être utilisé comme une clé. Bien que `NaN` ne soit pas strictement égal à lui-même (`NaN !== NaN` est vérifié), on peut bâtir l'exemple suivant car on ne peut pas distinguer deux valeurs `NaN `:
 
-<pre class="brush: js notranslate">const myMap = new Map();
+```js
+const myMap = new Map();
 myMap.set(NaN, "not a number");
 
 myMap.get(NaN); // "not a number"
 
 const otherNaN = Number("toto");
 myMap.get(otherNaN); // "not a number"
-</pre>
+```
 
-<h3 id="Parcourir_des_objets_Maps_avec_for..of">Parcourir des objets <code>Maps</code> avec <code>for..of</code></h3>
+### Parcourir des objets `Maps` avec `for..of`
 
-<p>Il est possible de parcourir les objets <code>Map </code>grâce à des boucles <code>for..of</code> :</p>
+Il est possible de parcourir les objets `Map `grâce à des boucles `for..of` :
 
-<pre class="brush: js notranslate">const myMap = new Map();
+```js
+const myMap = new Map();
 myMap.set(0, "zéro");
 myMap.set(1, "un");
 for (const [key, value] of myMap) {
@@ -157,11 +152,12 @@ myMap.forEach(function(value, key) {
 });
 // On aura 2 lignes : la première avec "0 = zéro"
 // la seconde avec "1 = un"
-</pre>
+```
 
-<h3 id="Relation_avec_les_objets_Array">Relation avec les objets <code>Array</code></h3>
+### Relation avec les objets `Array`
 
-<pre class="brush: js notranslate">const keyValuePair = [["clé1", "valeur1"], ["clé2", "valeur2"]];
+```js
+const keyValuePair = [["clé1", "valeur1"], ["clé2", "valeur2"]];
 
 // On utilise le constructeur Map
 // pour transformer un tableau de clés/valeurs
@@ -176,26 +172,30 @@ console.log(Array.from(myMap)); // affichera la même chose que tableauCléValeu
 
 // On peut aussi l'utiliser pour n'extraire que les clés
 // ou les valeurs et créer le tableau associé
-console.log(Array.from(myMap.keys())); // affichera ["clé1", "clé2"]</pre>
+console.log(Array.from(myMap.keys())); // affichera ["clé1", "clé2"]
+```
 
-<h3 id="Cloner_et_fusionner_des_objets_Map">Cloner et fusionner des objets <code>Map</code></h3>
+### Cloner et fusionner des objets `Map`
 
-<p>Il est possible de cloner des <code>Map</code> comme on clone des tableaux :</p>
+Il est possible de cloner des `Map` comme on clone des tableaux :
 
-<pre class="brush: js notranslate">const original = new Map([
+```js
+const original = new Map([
   [1, 'un']
 ]);
 
 const clone = new Map(original);
 
 console.log(clone.get(1)); // un
-console.log(original === clone); // false. Utile pour une comparaison superficielle</pre>
+console.log(original === clone); // false. Utile pour une comparaison superficielle
+```
 
-<p>Attention, la donnée contenue dans la <code>Map</code> n'est pas clonée.</p>
+Attention, la donnée contenue dans la `Map` n'est pas clonée.
 
-<p>Il est également possible de fusionner deux <code>Map</code> en conservant le critère d'unicité sur les clés :</p>
+Il est également possible de fusionner deux `Map` en conservant le critère d'unicité sur les clés :
 
-<pre class="brush: js notranslate">const first = new Map([
+```js
+const first = new Map([
   [1, 'un'],
   [2, 'deux'],
   [3, 'trois'],
@@ -214,11 +214,13 @@ const fusion = new Map([...first, ...second]);
 
 console.log(fusion.get(1)); // uno
 console.log(fusion.get(2)); // dos
-console.log(fusion.get(3)); // trois</pre>
+console.log(fusion.get(3)); // trois
+```
 
-<p>Il est également possible de fusionner des objets <code>Map</code> avec des objets <code>Array</code> :</p>
+Il est également possible de fusionner des objets `Map` avec des objets `Array` :
 
-<pre class="brush: js notranslate">const first = new Map([
+```js
+const first = new Map([
   [1, 'un'],
   [2, 'deux'],
   [3, 'trois'],
@@ -235,42 +237,24 @@ const fusion = new Map([...first, ...second, [1, 'eins']]);
 
 console.log(fusion.get(1)); // eins
 console.log(fusion.get(2)); // dos
-console.log(fusion.get(3)); // trois</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('ES2015', '#sec-map-objects', 'Map')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-map-objects', 'Map')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Map")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li><a class="link-https" href="https://bugzilla.mozilla.org/show_bug.cgi?id=697479">Le bug sur Map et Set pour Mozilla</a></li>
- <li><a class="external" href="https://web.archive.org/web/20170105121945/http://wiki.ecmascript.org:80/doku.php?id=harmony:simple_maps_and_sets">La proposition ECMAScript Harmony</a></li>
- <li>{{jsxref("Set")}}</li>
- <li>{{jsxref("WeakMap")}}</li>
- <li>{{jsxref("WeakSet")}}</li>
-</ul>
+console.log(fusion.get(3)); // trois
+```
+
+## Spécifications
+
+| Spécification                                                        | État                         | Commentaires         |
+| -------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ES2015', '#sec-map-objects', 'Map')}}     | {{Spec2('ES2015')}}     | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-map-objects', 'Map')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Map")}}
+
+## Voir aussi
+
+- [Le bug sur Map et Set pour Mozilla](https://bugzilla.mozilla.org/show_bug.cgi?id=697479)
+- [La proposition ECMAScript Harmony](https://web.archive.org/web/20170105121945/http://wiki.ecmascript.org:80/doku.php?id=harmony:simple_maps_and_sets)
+- {{jsxref("Set")}}
+- {{jsxref("WeakMap")}}
+- {{jsxref("WeakSet")}}
diff --git a/files/fr/web/javascript/reference/global_objects/map/keys/index.md b/files/fr/web/javascript/reference/global_objects/map/keys/index.md
index 423cf8d7dd..94943f763b 100644
--- a/files/fr/web/javascript/reference/global_objects/map/keys/index.md
+++ b/files/fr/web/javascript/reference/global_objects/map/keys/index.md
@@ -11,25 +11,26 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Map/keys
 original_slug: Web/JavaScript/Reference/Global_Objects/Map/keys
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>keys()</strong></code> renvoie un objet <code><a href="/fr/docs/Web/JavaScript/Guide/iterateurs_et_generateurs">Iterator</a></code> qui contient les clés de chaque élément de l'objet <code>Map</code>, dans leur ordre d'insertion.</p>
+La méthode **`keys()`** renvoie un objet [`Iterator`](/fr/docs/Web/JavaScript/Guide/iterateurs_et_generateurs) qui contient les clés de chaque élément de l'objet `Map`, dans leur ordre d'insertion.
 
-<div>{{EmbedInteractiveExample("pages/js/map-prototype-keys.html")}}</div>
+{{EmbedInteractiveExample("pages/js/map-prototype-keys.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><em>maMap</em>.keys()</pre>
+    maMap.keys()
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un nouvel objet <code>Iterator</code> {{jsxref("Map")}}.</p>
+Un nouvel objet `Iterator` {{jsxref("Map")}}.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_keys()">Utiliser <code>keys()</code></h3>
+### Utiliser `keys()`
 
-<pre class="brush:js">var maMap = new Map();
+```js
+var maMap = new Map();
 maMap.set("0", "toto");
 maMap.set(1, "truc");
 maMap.set({}, "bidule");
@@ -39,37 +40,20 @@ var mapIter = maMap.keys();
 console.log(mapIter.next().value); // "0"
 console.log(mapIter.next().value); // 1
 console.log(mapIter.next().value); // Object
-</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-map.prototype.keys', 'Map.prototype.keys')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-map.prototype.keys', 'Map.prototype.keys')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Map.keys")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Map.prototype.entries()")}}</li>
- <li>{{jsxref("Map.prototype.values()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                    | État                         | Commentaires         |
+| ------------------------------------------------------------------------------------------------ | ---------------------------- | -------------------- |
+| {{SpecName('ES2015', '#sec-map.prototype.keys', 'Map.prototype.keys')}} | {{Spec2('ES2015')}}     | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-map.prototype.keys', 'Map.prototype.keys')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Map.keys")}}
+
+## Voir aussi
+
+- {{jsxref("Map.prototype.entries()")}}
+- {{jsxref("Map.prototype.values()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/map/set/index.md b/files/fr/web/javascript/reference/global_objects/map/set/index.md
index b0e695aed3..b25fc7c250 100644
--- a/files/fr/web/javascript/reference/global_objects/map/set/index.md
+++ b/files/fr/web/javascript/reference/global_objects/map/set/index.md
@@ -11,34 +11,33 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Map/set
 original_slug: Web/JavaScript/Reference/Global_Objects/Map/set
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>set()</strong></code> ajoute un nouvel élément avec une <code>clé</code> et une <code>valeur</code> données à un objet <code>Map</code>.</p>
+La méthode **`set()`** ajoute un nouvel élément avec une `clé` et une `valeur` données à un objet `Map`.
 
-<div>{{EmbedInteractiveExample("pages/js/map-prototype-set.html")}}</div>
+{{EmbedInteractiveExample("pages/js/map-prototype-set.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><em>maMap</em>.set(clé, valeur);</pre>
+    maMap.set(clé, valeur);
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>clé</code></dt>
- <dd>Ce paramètre représente la clé de l'élément à ajouter à l'objet <code>Map</code>.</dd>
- <dt><code>valeur</code></dt>
- <dd>Ce paramètre représente la valeur de l'élément à ajouter à l'objet <code>Map</code>.</dd>
-</dl>
+- `clé`
+  - : Ce paramètre représente la clé de l'élément à ajouter à l'objet `Map`.
+- `valeur`
+  - : Ce paramètre représente la valeur de l'élément à ajouter à l'objet `Map`.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>L'objet <code>Map</code> courant (auquel l'élément a été ajouté).</p>
+L'objet `Map` courant (auquel l'élément a été ajouté).
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_la_méthode_set()">Utiliser la méthode <code>set()</code></h3>
+### Utiliser la méthode `set()`
 
-<pre class="brush: js">var maMap = new Map();
+```js
+var maMap = new Map();
 
 // On ajoute de nouveaux éléments à l'objet map
 maMap.set("truc", "toto");
@@ -46,48 +45,33 @@ maMap.set(1, "bidule");
 
 // On met à jour un élément
 maMap.set("truc", "fuuu");
-</pre>
+```
 
-<h3 id="Utiliser_la_méthode_set()_avec_un_enchaînement">Utiliser la méthode <code>set()</code> avec un enchaînement</h3>
+### Utiliser la méthode `set()` avec un enchaînement
 
-<p>La méthode <code>set()</code> renvoie le même objet <code>Map</code> et on peut donc la « chaîner » pour des opérations successives :</p>
+La méthode `set()` renvoie le même objet `Map` et on peut donc la « chaîner » pour des opérations successives :
 
-<pre class="brush: js">// On ajoute de nouveaux éléments
+```js
+// On ajoute de nouveaux éléments
 // en enchaînant les appels à set()
 maMap.set('truc', 'toto')
      .set(1, 'tototruc')
-     .set(2, 'bidule');</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-map.prototype.set', 'Map.prototype.set')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-map.prototype.set', 'Map.prototype.set')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Map.set")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Map")}}</li>
- <li>{{jsxref("Map.prototype.get()")}}</li>
- <li>{{jsxref("Map.prototype.has()")}}</li>
-</ul>
+     .set(2, 'bidule');
+```
+
+## Spécifications
+
+| Spécification                                                                                | État                         | Commentaires         |
+| -------------------------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ES2015', '#sec-map.prototype.set', 'Map.prototype.set')}} | {{Spec2('ES2015')}}     | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-map.prototype.set', 'Map.prototype.set')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Map.set")}}
+
+## Voir aussi
+
+- {{jsxref("Map")}}
+- {{jsxref("Map.prototype.get()")}}
+- {{jsxref("Map.prototype.has()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/map/size/index.md b/files/fr/web/javascript/reference/global_objects/map/size/index.md
index 0473610825..898542a176 100644
--- a/files/fr/web/javascript/reference/global_objects/map/size/index.md
+++ b/files/fr/web/javascript/reference/global_objects/map/size/index.md
@@ -10,56 +10,40 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Map/size
 original_slug: Web/JavaScript/Reference/Global_Objects/Map/size
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>L'accesseur <code><strong>size</strong></code> est une propriété renvoyant le nombre d'éléments d'un objet {{jsxref("Map")}}.</p>
+L'accesseur **`size`** est une propriété renvoyant le nombre d'éléments d'un objet {{jsxref("Map")}}.
 
-<div>{{EmbedInteractiveExample("pages/js/map-prototype-size.html")}}</div>
+{{EmbedInteractiveExample("pages/js/map-prototype-size.html")}}
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La valeur de <code>size</code> est un entier représentant le nombre d'entrées d'un objet <code>Map</code>. Le mutateur correspond à cette propriété est {{jsxref("undefined")}}, on ne peut pas donc pas modifier cette propriété.</p>
+La valeur de `size` est un entier représentant le nombre d'entrées d'un objet `Map`. Le mutateur correspond à cette propriété est {{jsxref("undefined")}}, on ne peut pas donc pas modifier cette propriété.
 
-<h2 id="Exemple">Exemple</h2>
+## Exemple
 
-<h3 id="Utiliser_size">Utiliser <code>size</code></h3>
+### Utiliser `size`
 
-<pre class="brush:js">var maMap = new Map();
+```js
+var maMap = new Map();
 maMap.set("a", "alpha");
 maMap.set("b", "beta");
 maMap.set("g", "gamma");
 
 maMap.size // 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-get-map.prototype.size', 'Map.prototype.size')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-get-map.prototype.size', 'Map.prototype.size')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
+| Spécification                                                                                        | État                         | Commentaires         |
+| ---------------------------------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ES2015', '#sec-get-map.prototype.size', 'Map.prototype.size')}} | {{Spec2('ES2015')}}     | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-get-map.prototype.size', 'Map.prototype.size')}} | {{Spec2('ESDraft')}} |                      |
 
-<h2 id="Compatibliité_des_navigateurs">Compatibliité des navigateurs</h2>
+## Compatibliité des navigateurs
 
-<p>{{Compat("javascript.builtins.Map.size")}}</p>
+{{Compat("javascript.builtins.Map.size")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("Map")}}</li>
-</ul>
+- {{jsxref("Map")}}
diff --git a/files/fr/web/javascript/reference/global_objects/map/values/index.md b/files/fr/web/javascript/reference/global_objects/map/values/index.md
index 8071caa2d0..07c000c242 100644
--- a/files/fr/web/javascript/reference/global_objects/map/values/index.md
+++ b/files/fr/web/javascript/reference/global_objects/map/values/index.md
@@ -12,25 +12,26 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Map/values
 original_slug: Web/JavaScript/Reference/Global_Objects/Map/values
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>values()</strong></code> renvoie un objet <code><a href="/fr/docs/Web/JavaScript/Guide/iterateurs_et_generateurs">Iterator</a></code> qui contient les valeurs de chacun des éléments contenu dans l'objet <code>Map</code> donné, dans leur ordre d'insertion.</p>
+La méthode **`values()`** renvoie un objet [`Iterator`](/fr/docs/Web/JavaScript/Guide/iterateurs_et_generateurs) qui contient les valeurs de chacun des éléments contenu dans l'objet `Map` donné, dans leur ordre d'insertion.
 
-<div>{{EmbedInteractiveExample("pages/js/map-prototype-values.html")}}</div>
+{{EmbedInteractiveExample("pages/js/map-prototype-values.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><em>maMap</em>.values()</pre>
+    maMap.values()
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un nouvel objet <code>Iterator</code> {{jsxref("Map")}}.</p>
+Un nouvel objet `Iterator` {{jsxref("Map")}}.
 
-<h2 id="Exemple">Exemple</h2>
+## Exemple
 
-<h3 id="Utiliser_values()">Utiliser <code>values()</code></h3>
+### Utiliser `values()`
 
-<pre class="brush:js">var maMap = new Map();
+```js
+var maMap = new Map();
 maMap.set("0", "toto");
 maMap.set(1, "truc");
 maMap.set({}, "licorne");
@@ -39,37 +40,21 @@ var mapIter = maMap.values();
 
 console.log(mapIter.next().value); // "toto"
 console.log(mapIter.next().value); // "truc"
-console.log(mapIter.next().value); // "licorne"</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-map.prototype.values', 'Map.prototype.values')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-map.prototype.values', 'Map.prototype.values')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Map.values")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Map.prototype.entries()")}}</li>
- <li>{{jsxref("Map.prototype.keys()")}}</li>
-</ul>
+console.log(mapIter.next().value); // "licorne"
+```
+
+## Spécifications
+
+| Spécification                                                                                        | État                         | Commentaires         |
+| ---------------------------------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ES2015', '#sec-map.prototype.values', 'Map.prototype.values')}} | {{Spec2('ES2015')}}     | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-map.prototype.values', 'Map.prototype.values')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Map.values")}}
+
+## Voir aussi
+
+- {{jsxref("Map.prototype.entries()")}}
+- {{jsxref("Map.prototype.keys()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/math/abs/index.md b/files/fr/web/javascript/reference/global_objects/math/abs/index.md
index c632d426db..6a1a7d758d 100644
--- a/files/fr/web/javascript/reference/global_objects/math/abs/index.md
+++ b/files/fr/web/javascript/reference/global_objects/math/abs/index.md
@@ -9,40 +9,39 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Math/abs
 original_slug: Web/JavaScript/Reference/Objets_globaux/Math/abs
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La fonction <code><strong>Math.abs()</strong></code> retourne la valeur absolue d'un nombre, c'est-à-dire</p>
+La fonction **`Math.abs()`** retourne la valeur absolue d'un nombre, c'est-à-dire
 
-<p><math><semantics><mrow><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.abs</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mrow><mo stretchy="false">|</mo><mi>x</mi><mo stretchy="false">|</mo></mrow><mo>=</mo><mrow><mo>{</mo><mtable columnalign="left left"><mtr><mtd><mi>x</mi></mtd><mtd><mtext>si</mtext><mspace width="1em"></mspace><mi>x</mi><mo>≥</mo><mn>0</mn></mtd></mtr><mtr><mtd><mo>-</mo><mi>x</mi></mtd><mtd><mtext>si</mtext><mspace width="1em"></mspace><mi>x</mi><mo>&lt;</mo><mn>0</mn></mtd></mtr></mtable></mrow></mrow><annotation encoding="TeX">{\mathtt{\operatorname{Math.abs}(x)}} = {|x|} = \begin{cases} x &amp; \text{si} \quad x \geq 0 \\ -x &amp; \text{si} \quad x &lt; 0 \end{cases} </annotation></semantics></math></p>
+<math><semantics><mrow><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.abs</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mrow><mo stretchy="false">|</mo><mi>x</mi><mo stretchy="false">|</mo></mrow><mo>=</mo><mrow><mo>{</mo><mtable columnalign="left left"><mtr><mtd><mi>x</mi></mtd><mtd><mtext>si</mtext><mspace width="1em"></mspace><mi>x</mi><mo>≥</mo><mn>0</mn></mtd></mtr><mtr><mtd><mo>-</mo><mi>x</mi></mtd><mtd><mtext>si</mtext><mspace width="1em"></mspace><mi>x</mi><mo>&#x3C;</mo><mn>0</mn></mtd></mtr></mtable></mrow></mrow><annotation encoding="TeX">{\mathtt{\operatorname{Math.abs}(x)}} = {|x|} = \begin{cases} x &#x26; \text{si} \quad x \geq 0 \\ -x &#x26; \text{si} \quad x &#x3C; 0 \end{cases}</annotation></semantics></math>
 
-<div>{{EmbedInteractiveExample("pages/js/math-abs.html")}}</div>
+{{EmbedInteractiveExample("pages/js/math-abs.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">Math.abs(<em>x</em>);</pre>
+    Math.abs(x);
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>x</code></dt>
- <dd>Un nombre.</dd>
-</dl>
+- `x`
+  - : Un nombre.
 
-<h3 id="Valeur_absolue">Valeur absolue</h3>
+### Valeur absolue
 
-<p>La valeur absolue du nombre passé en argument.</p>
+La valeur absolue du nombre passé en argument.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p><code>abs</code> est une méthode statique de l'objet <code>Math</code> et doit toujours être utilisée avec la syntaxe <code>Math.abs()</code>.</p>
+`abs` est une méthode statique de l'objet `Math` et doit toujours être utilisée avec la syntaxe `Math.abs()`.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_Math.abs()">Utiliser <code>Math.abs()</code></h3>
+### Utiliser `Math.abs()`
 
-<p>Si la méthode est utilisée avec une chaîne de caractères non numérique, avec un tableau à plus d'un élément, sans paramètre ou avec {{jsxref("undefined")}}, la valeur retournée sera {{jsxref("NaN")}}. Si elle est utilisée avec {{jsxref("null")}}, la fonction renverra 0.</p>
+Si la méthode est utilisée avec une chaîne de caractères non numérique, avec un tableau à plus d'un élément, sans paramètre ou avec {{jsxref("undefined")}}, la valeur retournée sera {{jsxref("NaN")}}. Si elle est utilisée avec {{jsxref("null")}}, la fonction renverra 0.
 
-<pre class="brush:js">Math.abs('-1');     // 1
+```js
+Math.abs('-1');     // 1
 Math.abs(-2);       // 2
 Math.abs(null);     // 0
 Math.abs('');       // 0
@@ -51,50 +50,26 @@ Math.abs([2]);      // 2
 Math.abs([1,2]);    // NaN
 Math.abs({});       // NaN
 Math.abs("string"); // NaN
-Math.abs();         // NaN</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.0.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.8.2.1', 'Math.abs')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-math.abs', 'Math.abs')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-math.abs', 'Math.abs')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Math.abs")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Math.ceil()")}}</li>
- <li>{{jsxref("Math.floor()")}}</li>
- <li>{{jsxref("Math.round()")}}</li>
- <li>{{jsxref("Math.sign()")}}</li>
- <li>{{jsxref("Math.trunc()")}}</li>
-</ul>
+Math.abs();         // NaN
+```
+
+## 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.8.2.1', 'Math.abs')}} | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-math.abs', 'Math.abs')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-math.abs', 'Math.abs')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Math.abs")}}
+
+## Voir aussi
+
+- {{jsxref("Math.ceil()")}}
+- {{jsxref("Math.floor()")}}
+- {{jsxref("Math.round()")}}
+- {{jsxref("Math.sign()")}}
+- {{jsxref("Math.trunc()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/math/acos/index.md b/files/fr/web/javascript/reference/global_objects/math/acos/index.md
index 3a2f6fa132..2d120f115d 100644
--- a/files/fr/web/javascript/reference/global_objects/math/acos/index.md
+++ b/files/fr/web/javascript/reference/global_objects/math/acos/index.md
@@ -9,92 +9,66 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Math/acos
 original_slug: Web/JavaScript/Reference/Objets_globaux/Math/acos
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La fonction <code><strong>Math.acos()</strong></code> renvoie l'arc cosinus d'une valeur exprimée en radians. Cela est défini par :</p>
+La fonction **`Math.acos()`** renvoie l'arc cosinus d'une valeur exprimée en radians. Cela est défini par :
 
-<p><math><semantics><mrow><mo>∀</mo><mi>x</mi><mo>∊</mo><mo stretchy="false">[</mo><mrow><mo>-</mo><mn>1</mn></mrow><mo>;</mo><mn>1</mn><mo stretchy="false">]</mo><mo>,</mo><mspace width="thickmathspace"></mspace><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.acos</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">arccos</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext> le seul  </mtext><mi>y</mi><mo>∊</mo><mo stretchy="false">[</mo><mn>0</mn><mo>;</mo><mi>π</mi><mo stretchy="false">]</mo><mspace width="thinmathspace"></mspace><mtext>tel que</mtext><mspace width="thickmathspace"></mspace><mo lspace="0em" rspace="0em">cos</mo><mo stretchy="false">(</mo><mi>y</mi><mo stretchy="false">)</mo><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\forall x \in [{-1};1],\;\mathtt{\operatorname{Math.acos}(x)} = \arccos(x) = \text{ the unique } \; y \in [0; \pi] \, \text{such that} \; \cos(y) = x</annotation></semantics></math></p>
+<math><semantics><mrow><mo>∀</mo><mi>x</mi><mo>∊</mo><mo stretchy="false">[</mo><mrow><mo>-</mo><mn>1</mn></mrow><mo>;</mo><mn>1</mn><mo stretchy="false">]</mo><mo>,</mo><mspace width="thickmathspace"></mspace><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.acos</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">arccos</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext> le seul  </mtext><mi>y</mi><mo>∊</mo><mo stretchy="false">[</mo><mn>0</mn><mo>;</mo><mi>π</mi><mo stretchy="false">]</mo><mspace width="thinmathspace"></mspace><mtext>tel que</mtext><mspace width="thickmathspace"></mspace><mo lspace="0em" rspace="0em">cos</mo><mo stretchy="false">(</mo><mi>y</mi><mo stretchy="false">)</mo><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\forall x \in [{-1};1],\;\mathtt{\operatorname{Math.acos}(x)} = \arccos(x) = \text{ the unique } \; y \in [0; \pi] \, \text{such that} \; \cos(y) = x</annotation></semantics></math>
 
-<div>{{EmbedInteractiveExample("pages/js/math-acos.html")}}</div>
+{{EmbedInteractiveExample("pages/js/math-acos.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">Math.acos(<em>x</em>) </pre>
+    Math.acos(x)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>x</code></dt>
- <dd>Un nombre (représentant un angle exprimé en radians).</dd>
-</dl>
+- `x`
+  - : Un nombre (représentant un angle exprimé en radians).
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>L'arc cosinus du nombre passé en argument si celui est compris entre -1 et 1. La méthode renvoie {{jsxref("NaN")}} sinon.</p>
+L'arc cosinus du nombre passé en argument si celui est compris entre -1 et 1. La méthode renvoie {{jsxref("NaN")}} sinon.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La méthode <code>acos</code> renvoie une valeur numérique comprise entre 0 et Pi pour x compris entre -1 et 1. Si la valeur de <code>x</code> est hors de cet intervalle, la méthode renverra {{jsxref("NaN")}}.</p>
+La méthode `acos` renvoie une valeur numérique comprise entre 0 et Pi pour x compris entre -1 et 1. Si la valeur de `x` est hors de cet intervalle, la méthode renverra {{jsxref("NaN")}}.
 
-<p><code>acos</code> est une méhode statique de <code>Math</code> et doit toujours être utilisée avec la syntaxe <code>Math.acos()</code>, elle ne doit pas être appelée depuis un autre objet qui aurait été créé (<code>Math</code> n'est pas un constructeur).</p>
+`acos` est une méhode statique de `Math` et doit toujours être utilisée avec la syntaxe `Math.acos()`, elle ne doit pas être appelée depuis un autre objet qui aurait été créé (`Math` n'est pas un constructeur).
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_Math.acos()">Utiliser <code>Math.acos()</code></h3>
+### Utiliser `Math.acos()`
 
-<pre class="brush:js">Math.acos(-2);  // NaN
+```js
+Math.acos(-2);  // NaN
 Math.acos(-1);  // 3.141592653589793
 Math.acos(0);   // 1.5707963267948966
 Math.acos(0.5); // 1.0471975511965979
 Math.acos(1);   // 0
 Math.acos(2);   // NaN
-</pre>
-
-<p>Pour les valeurs (strictement) inférieures à -1 ou supérieures à 1, <code>Math.acos</code> renvoie <code>NaN</code>.</p>
-
-<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. Implémentée avec JavaScript 1.0.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.8.2.2', 'Math.acos')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-math.acos', 'Math.acos')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-math.acos', 'Math.acos')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Math.acos")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Math.asin()")}}</li>
- <li>{{jsxref("Math.atan()")}}</li>
- <li>{{jsxref("Math.atan2()")}}</li>
- <li>{{jsxref("Math.cos()")}}</li>
- <li>{{jsxref("Math.sin()")}}</li>
- <li>{{jsxref("Math.tan()")}}</li>
-</ul>
+```
+
+Pour les valeurs (strictement) inférieures à -1 ou supérieures à 1, `Math.acos` renvoie `NaN`.
+
+## 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.8.2.2', 'Math.acos')}}     | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-math.acos', 'Math.acos')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-math.acos', 'Math.acos')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Math.acos")}}
+
+## Voir aussi
+
+- {{jsxref("Math.asin()")}}
+- {{jsxref("Math.atan()")}}
+- {{jsxref("Math.atan2()")}}
+- {{jsxref("Math.cos()")}}
+- {{jsxref("Math.sin()")}}
+- {{jsxref("Math.tan()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/math/acosh/index.md b/files/fr/web/javascript/reference/global_objects/math/acosh/index.md
index 26a4b11b80..cb4ff0b1c1 100644
--- a/files/fr/web/javascript/reference/global_objects/math/acosh/index.md
+++ b/files/fr/web/javascript/reference/global_objects/math/acosh/index.md
@@ -10,88 +10,70 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Math/acosh
 original_slug: Web/JavaScript/Reference/Objets_globaux/Math/acosh
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La fonction <code><strong>Math.acosh()</strong></code> renvoie l'arc cosinus hyperbolique d'un nombre.Elle est définie par :</p>
+La fonction **`Math.acosh()`** renvoie l'arc cosinus hyperbolique d'un nombre.Elle est définie par :
 
-<p><math display="block"><semantics><mrow><mo>∀</mo><mi>x</mi><mo>≥</mo><mn>1</mn><mo>,</mo><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.acosh</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="thinmathspace">arcosh</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext> l'unique </mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mo>≥</mo><mn>0</mn><mspace width="thickmathspace"></mspace><mtext>tel que</mtext><mspace width="thickmathspace"></mspace><mo lspace="0em" rspace="0em">cosh</mo><mo stretchy="false">(</mo><mi>y</mi><mo stretchy="false">)</mo><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\forall x \geq 1, \mathtt{\operatorname{Math.acosh}(x)} = \operatorname{arcosh}(x) = \text{ the unique } \; y \geq 0 \; \text{such that} \; \cosh(y) = x</annotation></semantics></math></p>
+<math display="block"><semantics><mrow><mo>∀</mo><mi>x</mi><mo>≥</mo><mn>1</mn><mo>,</mo><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.acosh</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="thinmathspace">arcosh</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext> l'unique </mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mo>≥</mo><mn>0</mn><mspace width="thickmathspace"></mspace><mtext>tel que</mtext><mspace width="thickmathspace"></mspace><mo lspace="0em" rspace="0em">cosh</mo><mo stretchy="false">(</mo><mi>y</mi><mo stretchy="false">)</mo><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\forall x \geq 1, \mathtt{\operatorname{Math.acosh}(x)} = \operatorname{arcosh}(x) = \text{ the unique } \; y \geq 0 \; \text{such that} \; \cosh(y) = x</annotation></semantics></math>
 
-<div>{{EmbedInteractiveExample("pages/js/math-acosh.html")}}</div>
+{{EmbedInteractiveExample("pages/js/math-acosh.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">Math.acosh(<var>x</var>)</pre>
+    Math.acosh(x)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>x</code></dt>
- <dd>Un nombre.</dd>
-</dl>
+- `x`
+  - : Un nombre.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>L'arc cosinus hyperbolique du nombre en argument. Si le nombre est inférieur à 1, la valeur renvoyée sera {{jsxref("NaN")}}.</p>
+L'arc cosinus hyperbolique du nombre en argument. Si le nombre est inférieur à 1, la valeur renvoyée sera {{jsxref("NaN")}}.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p><code>acos</code>h étant une méthode statique de <code>Math</code>, il faut l'utiliser avec <code>Math.acosh()</code>, plutôt qu'en faisant appel à une méthode d'un autre objet créé (<code>Math</code> n'est pas un constructeur).</p>
+`acos`h étant une méthode statique de `Math`, il faut l'utiliser avec `Math.acosh()`, plutôt qu'en faisant appel à une méthode d'un autre objet créé (`Math` n'est pas un constructeur).
 
-<h2 id="Exemple">Exemple</h2>
+## Exemple
 
-<h3 id="Utiliser_Math.acosh()">Utiliser <code>Math.acosh()</code></h3>
+### Utiliser `Math.acosh()`
 
-<pre class="brush:js">Math.acosh(-1);  // NaN
+```js
+Math.acosh(-1);  // NaN
 Math.acosh(0);   // NaN
 Math.acosh(0.5); // NaN
 Math.acosh(1);   // 0
-Math.acosh(2);   // 1.3169578969248166</pre>
+Math.acosh(2);   // 1.3169578969248166
+```
 
-<p>Pour les valeurs strictement inférieures à 1 <code>Math.acosh</code> renvoie {{jsxref("NaN")}}.</p>
+Pour les valeurs strictement inférieures à 1 `Math.acosh` renvoie {{jsxref("NaN")}}.
 
-<h2 id="Prothèse_d'émulation_(polyfill)">Prothèse d'émulation (<em>polyfill</em>)</h2>
+## Prothèse d'émulation (_polyfill_)
 
-<p>Pour tout <math><semantics><mrow><mi>x</mi><mo>≥</mo><mn>1</mn></mrow><annotation encoding="TeX">x \geq 1</annotation></semantics></math>, <math><semantics><mrow><mo lspace="0em" rspace="thinmathspace">arcosh</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mo lspace="0em" rspace="0em">ln</mo><mrow><mo>(</mo><mrow><mi>x</mi><mo>+</mo><msqrt><mrow><msup><mi>x</mi><mn>2</mn></msup><mo>-</mo><mn>1</mn></mrow></msqrt></mrow><mo>)</mo></mrow></mrow><annotation encoding="TeX">\operatorname {arcosh} (x) = \ln \left(x + \sqrt{x^{2} - 1} \right)</annotation></semantics></math>, on peut donc émuler cette fonction avec le code suivant :</p>
+Pour tout <math><semantics><mrow><mi>x</mi><mo>≥</mo><mn>1</mn></mrow><annotation encoding="TeX">x \geq 1</annotation></semantics></math>, <math><semantics><mrow><mo lspace="0em" rspace="thinmathspace">arcosh</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mo lspace="0em" rspace="0em">ln</mo><mrow><mo>(</mo><mrow><mi>x</mi><mo>+</mo><msqrt><mrow><msup><mi>x</mi><mn>2</mn></msup><mo>-</mo><mn>1</mn></mrow></msqrt></mrow><mo>)</mo></mrow></mrow><annotation encoding="TeX">\operatorname {arcosh} (x) = \ln \left(x + \sqrt{x^{2} - 1} \right)</annotation></semantics></math>, on peut donc émuler cette fonction avec le code suivant :
 
-<pre class="brush: js">function acosh(x) {
+```js
+function acosh(x) {
   return Math.log(x + Math.sqrt(x * x - 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('ES6', '#sec-math.acosh', 'Math.acosh')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Définition initiale</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-math.acosh', 'Math.acosh')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Math.acosh")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Math.asinh()")}}</li>
- <li>{{jsxref("Math.atanh()")}}</li>
- <li>{{jsxref("Math.cosh()")}}</li>
- <li>{{jsxref("Math.sinh()")}}</li>
- <li>{{jsxref("Math.tanh()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                | État                         | Commentaires        |
+| ---------------------------------------------------------------------------- | ---------------------------- | ------------------- |
+| {{SpecName('ES6', '#sec-math.acosh', 'Math.acosh')}}         | {{Spec2('ES6')}}         | Définition initiale |
+| {{SpecName('ESDraft', '#sec-math.acosh', 'Math.acosh')}} | {{Spec2('ESDraft')}} |                     |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Math.acosh")}}
+
+## Voir aussi
+
+- {{jsxref("Math.asinh()")}}
+- {{jsxref("Math.atanh()")}}
+- {{jsxref("Math.cosh()")}}
+- {{jsxref("Math.sinh()")}}
+- {{jsxref("Math.tanh()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/math/asin/index.md b/files/fr/web/javascript/reference/global_objects/math/asin/index.md
index b094e1bdce..b7d502cfb9 100644
--- a/files/fr/web/javascript/reference/global_objects/math/asin/index.md
+++ b/files/fr/web/javascript/reference/global_objects/math/asin/index.md
@@ -9,91 +9,66 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Math/asin
 original_slug: Web/JavaScript/Reference/Objets_globaux/Math/asin
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La fonction <code><strong>Math.asin()</strong></code> renvoie l'arc sinus d'un nombre (en radians). Elle est définie par :</p>
+La fonction **`Math.asin()`** renvoie l'arc sinus d'un nombre (en radians). Elle est définie par :
 
-<p><math display="block"><semantics><mrow><mo>∀</mo><mi>x</mi><mo>∊</mo><mo stretchy="false">[</mo><mrow><mo>-</mo><mn>1</mn></mrow><mo>;</mo><mn>1</mn><mo stretchy="false">]</mo><mo>,</mo><mspace width="thickmathspace"></mspace><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.asin</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">arcsin</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext> le seul </mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mo>∊</mo><mrow><mo>[</mo><mrow><mo>-</mo><mfrac><mi>π</mi><mn>2</mn></mfrac><mo>;</mo><mfrac><mi>π</mi><mn>2</mn></mfrac></mrow><mo>]</mo></mrow><mspace width="thinmathspace"></mspace><mtext>tel que</mtext><mspace width="thickmathspace"></mspace><mo lspace="0em" rspace="0em">sin</mo><mo stretchy="false">(</mo><mi>y</mi><mo stretchy="false">)</mo><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\forall x \in [{-1};1],\;\mathtt{\operatorname{Math.asin}(x)} = \arcsin(x) = \text{ the unique } \; y \in \left[-\frac{\pi}{2}; \frac{\pi}{2}\right] \, \text{such that} \; \sin(y) = x</annotation></semantics></math></p>
+<math display="block"><semantics><mrow><mo>∀</mo><mi>x</mi><mo>∊</mo><mo stretchy="false">[</mo><mrow><mo>-</mo><mn>1</mn></mrow><mo>;</mo><mn>1</mn><mo stretchy="false">]</mo><mo>,</mo><mspace width="thickmathspace"></mspace><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.asin</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">arcsin</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext> le seul </mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mo>∊</mo><mrow><mo>[</mo><mrow><mo>-</mo><mfrac><mi>π</mi><mn>2</mn></mfrac><mo>;</mo><mfrac><mi>π</mi><mn>2</mn></mfrac></mrow><mo>]</mo></mrow><mspace width="thinmathspace"></mspace><mtext>tel que</mtext><mspace width="thickmathspace"></mspace><mo lspace="0em" rspace="0em">sin</mo><mo stretchy="false">(</mo><mi>y</mi><mo stretchy="false">)</mo><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\forall x \in [{-1};1],\;\mathtt{\operatorname{Math.asin}(x)} = \arcsin(x) = \text{ the unique } \; y \in \left[-\frac{\pi}{2}; \frac{\pi}{2}\right] \, \text{such that} \; \sin(y) = x</annotation></semantics></math>
 
-<div>{{EmbedInteractiveExample("pages/js/math-asin.html")}}</div>
+{{EmbedInteractiveExample("pages/js/math-asin.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">Math.asin(<var>x</var>)</pre>
+    Math.asin(x)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>x</code></dt>
- <dd>Un nombre.</dd>
-</dl>
+- `x`
+  - : Un nombre.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>L'arc sinus du nombre passé en argument (exprimé en radians). Si ce nombre n'est pas compris entre -1 et 1, la valeur renvoyée sera {{jsxref("NaN")}}.</p>
+L'arc sinus du nombre passé en argument (exprimé en radians). Si ce nombre n'est pas compris entre -1 et 1, la valeur renvoyée sera {{jsxref("NaN")}}.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La méthode <code>Math.asin()</code> renvoie une valeur numérique comprise entre <math><semantics><mrow><mo>-</mo><mfrac><mi>π</mi><mn>2</mn></mfrac></mrow><annotation encoding="TeX">-\frac{\pi}{2}</annotation></semantics></math> et <math><semantics><mfrac><mi>π</mi><mn>2</mn></mfrac><annotation encoding="TeX">\frac{\pi}{2}</annotation></semantics></math> pour <code>x</code> compris entre -1 et 1. Si <code>x</code> est hors de cet intervalle, la méthode renverra {{jsxref("NaN")}}.</p>
+La méthode `Math.asin()` renvoie une valeur numérique comprise entre <math><semantics><mrow><mo>-</mo><mfrac><mi>π</mi><mn>2</mn></mfrac></mrow><annotation encoding="TeX">-\frac{\pi}{2}</annotation></semantics></math> et <math><semantics><mfrac><mi>π</mi><mn>2</mn></mfrac><annotation encoding="TeX">\frac{\pi}{2}</annotation></semantics></math> pour `x` compris entre -1 et 1. Si `x` est hors de cet intervalle, la méthode renverra {{jsxref("NaN")}}.
 
-<p><code>Math.asin()</code> est une méthode statique de <code>Math</code> et doit toujours être utilisée avec la syntaxe <code>Math.asin()</code>, elle ne doit pas être appelée à partir d'un autre objet créé (<code>Math</code> n'est pas un constructeur).</p>
+`Math.asin()` est une méthode statique de `Math` et doit toujours être utilisée avec la syntaxe `Math.asin()`, elle ne doit pas être appelée à partir d'un autre objet créé (`Math` n'est pas un constructeur).
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_Math.asin()">Utiliser <code>Math.asin()</code></h3>
+### Utiliser `Math.asin()`
 
-<pre class="brush:js">Math.asin(-2);  // NaN
+```js
+Math.asin(-2);  // NaN
 Math.asin(-1);  // -1.570796326794897 (-pi/2)
 Math.asin(0);   // 0
 Math.asin(0.5); // 0.5235987755982989
 Math.asin(1);   // 1.570796326794897 (pi/2)
-Math.asin(2);   // NaN</pre>
-
-<p>Pour les valeurs (strictement) inférieures à -1 ou supérieures à 1, <code>Math.asin()</code> renvoie {{jsxref("NaN")}}.</p>
-
-<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. Implémentée avec JavaScript 1.0.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.8.2.3', 'Math.asin')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-math.asin', 'Math.asin')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-math.asin', 'Math.asin')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<div>{{Compat("javascript.builtins.Math.asin")}}</div>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Math.acos()")}}</li>
- <li>{{jsxref("Math.atan()")}}</li>
- <li>{{jsxref("Math.atan2()")}}</li>
- <li>{{jsxref("Math.cos()")}}</li>
- <li>{{jsxref("Math.sin()")}}</li>
- <li>{{jsxref("Math.tan()")}}</li>
-</ul>
+Math.asin(2);   // NaN
+```
+
+Pour les valeurs (strictement) inférieures à -1 ou supérieures à 1, `Math.asin()` renvoie {{jsxref("NaN")}}.
+
+## 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.8.2.3', 'Math.asin')}}     | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-math.asin', 'Math.asin')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-math.asin', 'Math.asin')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Math.asin")}}
+
+## Voir aussi
+
+- {{jsxref("Math.acos()")}}
+- {{jsxref("Math.atan()")}}
+- {{jsxref("Math.atan2()")}}
+- {{jsxref("Math.cos()")}}
+- {{jsxref("Math.sin()")}}
+- {{jsxref("Math.tan()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/math/asinh/index.md b/files/fr/web/javascript/reference/global_objects/math/asinh/index.md
index e831b9abcb..607a90d9f4 100644
--- a/files/fr/web/javascript/reference/global_objects/math/asinh/index.md
+++ b/files/fr/web/javascript/reference/global_objects/math/asinh/index.md
@@ -9,80 +9,60 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Math/asinh
 original_slug: Web/JavaScript/Reference/Objets_globaux/Math/asinh
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La fonction <code><strong>Math.asinh()</strong></code> renvoie l'arc sinus hyperbolique d'un nombre :</p>
+La fonction **`Math.asinh()`** renvoie l'arc sinus hyperbolique d'un nombre :
 
-<p><math><semantics><mrow><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.asinh</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="thinmathspace">arsinh</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext> le seul </mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mspace width="thickmathspace"></mspace><mtext>tel que</mtext><mspace width="thickmathspace"></mspace><mo lspace="0em" rspace="0em">sinh</mo><mo stretchy="false">(</mo><mi>y</mi><mo stretchy="false">)</mo><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\mathtt{\operatorname{Math.asinh}(x)} = \operatorname{arsinh}(x) = \text{ the unique } \; y \; \text{such that} \; \sinh(y) = x</annotation></semantics></math></p>
+<math><semantics><mrow><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.asinh</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="thinmathspace">arsinh</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext> le seul </mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mspace width="thickmathspace"></mspace><mtext>tel que</mtext><mspace width="thickmathspace"></mspace><mo lspace="0em" rspace="0em">sinh</mo><mo stretchy="false">(</mo><mi>y</mi><mo stretchy="false">)</mo><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\mathtt{\operatorname{Math.asinh}(x)} = \operatorname{arsinh}(x) = \text{ the unique } \; y \; \text{such that} \; \sinh(y) = x</annotation></semantics></math>
 
-<div>{{EmbedInteractiveExample("pages/js/math-asinh.html")}}</div>
+{{EmbedInteractiveExample("pages/js/math-asinh.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">Math.asinh(<var>x</var>)</pre>
+    Math.asinh(x)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>x</code></dt>
- <dd>Un nombre.</dd>
-</dl>
+- `x`
+  - : Un nombre.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>L'arc sinus hyperbolique du nombre passé en argument.</p>
+L'arc sinus hyperbolique du nombre passé en argument.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p><code>asinh()</code> étant une méthode statique de <code>Math</code>, elle doit toujours être utilisée avec la syntaxe <code>Math.asinh()</code> et ne doit pas être appelée depuis un autre objet qui aurait été créé (Math n'est pas un constructeur).</p>
+`asinh()` étant une méthode statique de `Math`, elle doit toujours être utilisée avec la syntaxe `Math.asinh()` et ne doit pas être appelée depuis un autre objet qui aurait été créé (Math n'est pas un constructeur).
 
-<h2 id="Exemple">Exemple</h2>
+## Exemple
 
-<h3 id="Utiliser_Math.asinh()">Utiliser <code>Math.asinh()</code></h3>
+### Utiliser `Math.asinh()`
 
-<pre class="brush: js">Math.asinh = Math.asinh || function(x) {
+```js
+Math.asinh = Math.asinh || function(x) {
   if (x === -Infinity) {
     return x;
   } else {
     return Math.log(x + Math.sqrt(x * x + 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('ES6', '#sec-math.asinh', 'Math.asinh')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-math.asinh', 'Math.asinh')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Math.asinh")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Math.acosh()")}}</li>
- <li>{{jsxref("Math.atanh()")}}</li>
- <li>{{jsxref("Math.cosh()")}}</li>
- <li>{{jsxref("Math.sinh()")}}</li>
- <li>{{jsxref("Math.tanh()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                | État                         | Commentaires         |
+| ---------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ES6', '#sec-math.asinh', 'Math.asinh')}}         | {{Spec2('ES6')}}         | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-math.asinh', 'Math.asinh')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Math.asinh")}}
+
+## Voir aussi
+
+- {{jsxref("Math.acosh()")}}
+- {{jsxref("Math.atanh()")}}
+- {{jsxref("Math.cosh()")}}
+- {{jsxref("Math.sinh()")}}
+- {{jsxref("Math.tanh()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/math/atan/index.md b/files/fr/web/javascript/reference/global_objects/math/atan/index.md
index 3c6754866d..3f9a23100f 100644
--- a/files/fr/web/javascript/reference/global_objects/math/atan/index.md
+++ b/files/fr/web/javascript/reference/global_objects/math/atan/index.md
@@ -9,40 +9,39 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Math/atan
 original_slug: Web/JavaScript/Reference/Objets_globaux/Math/atan
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La fonction <code><strong>Math.atan()</strong></code> renvoie l'arc tangente d'un nombre exprimée en radians. Elle est définie par :</p>
+La fonction **`Math.atan()`** renvoie l'arc tangente d'un nombre exprimée en radians. Elle est définie par :
 
-<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.atan</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">arctan</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo>le seul<mspace width="thickmathspace"></mspace><mi>y</mi><mo>∊</mo><mrow><mo>[</mo><mrow><mo>-</mo><mfrac><mi>π</mi><mn>2</mn></mfrac><mo>;</mo><mfrac><mi>π</mi><mn>2</mn></mfrac></mrow><mo>]</mo></mrow><mspace width="thinmathspace"></mspace><mtext>tel que</mtext><mspace width="thickmathspace"></mspace><mo lspace="0em" rspace="0em">tan</mo><mo stretchy="false">(</mo><mi>y</mi><mo stretchy="false">)</mo><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\mathtt{\operatorname{Math.atan}(x)} = \arctan(x) = \text{ the unique } \; y \in \left[-\frac{\pi}{2}; \frac{\pi}{2}\right] \, \text{such that} \; \tan(y) = x</annotation></semantics></math></p>
+<math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.atan</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">arctan</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo>le seul<mspace width="thickmathspace"></mspace><mi>y</mi><mo>∊</mo><mrow><mo>[</mo><mrow><mo>-</mo><mfrac><mi>π</mi><mn>2</mn></mfrac><mo>;</mo><mfrac><mi>π</mi><mn>2</mn></mfrac></mrow><mo>]</mo></mrow><mspace width="thinmathspace"></mspace><mtext>tel que</mtext><mspace width="thickmathspace"></mspace><mo lspace="0em" rspace="0em">tan</mo><mo stretchy="false">(</mo><mi>y</mi><mo stretchy="false">)</mo><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\mathtt{\operatorname{Math.atan}(x)} = \arctan(x) = \text{ the unique } \; y \in \left[-\frac{\pi}{2}; \frac{\pi}{2}\right] \, \text{such that} \; \tan(y) = x</annotation></semantics></math>
 
-<div>{{EmbedInteractiveExample("pages/js/math-atan.html")}}</div>
+{{EmbedInteractiveExample("pages/js/math-atan.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">Math.atan(<var>x</var>)</pre>
+    Math.atan(x)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>x</code></dt>
- <dd>Un nombre.</dd>
-</dl>
+- `x`
+  - : Un nombre.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>L'arc tangente du nombre passé en argument (exprimé en radians).</p>
+L'arc tangente du nombre passé en argument (exprimé en radians).
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La méthode <code>Math.atan()</code> renvoie une valeur numérique comprise entre <math><semantics><mrow><mo>-</mo><mfrac><mi>π</mi><mn>2</mn></mfrac></mrow><annotation encoding="TeX">-\frac{\pi}{2}</annotation></semantics></math> et <math><semantics><mfrac><mi>π</mi><mn>2</mn></mfrac><annotation encoding="TeX">\frac{\pi}{2}</annotation></semantics></math>.</p>
+La méthode `Math.atan()` renvoie une valeur numérique comprise entre <math><semantics><mrow><mo>-</mo><mfrac><mi>π</mi><mn>2</mn></mfrac></mrow><annotation encoding="TeX">-\frac{\pi}{2}</annotation></semantics></math> et <math><semantics><mfrac><mi>π</mi><mn>2</mn></mfrac><annotation encoding="TeX">\frac{\pi}{2}</annotation></semantics></math>.
 
-<p><code>atan()</code> est une méthode statique de <code>Math</code> et doit toujours être utilisée avec la syntaxe <code>Math.atan()</code>, elle ne doit pas être utilisée comme une méthode d'un autre objet qui aurait été créé (<code>Math</code> n'est pas un constructeur).</p>
+`atan()` est une méthode statique de `Math` et doit toujours être utilisée avec la syntaxe `Math.atan()`, elle ne doit pas être utilisée comme une méthode d'un autre objet qui aurait été créé (`Math` n'est pas un constructeur).
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_Math.atan()">Utiliser <code>Math.atan()</code></h3>
+### Utiliser `Math.atan()`
 
-<pre class="brush:js">Math.atan(1);  // 0.7853981633974483
+```js
+Math.atan(1);  // 0.7853981633974483
 Math.atan(0);  // 0
 Math.atan(-0); // -0
 
@@ -52,51 +51,26 @@ Math.atan(-Infinity); // -1.5707963267948966
 // L'angle formé entre la droite [(0,0);(x,y)] et l'axe des abscisses
 // dans un système de coordonnées cartésienne
 Math.atan(y / x);
-</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.0.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.8.2.4', 'Math.atan')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-math.atan', 'Math.atan')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-math.atan', 'Math.atan')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<div>{{Compat("javascript.builtins.Math.atan")}}</div>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Math.acos()")}}</li>
- <li>{{jsxref("Math.asin()")}}</li>
- <li>{{jsxref("Math.atan2()")}}</li>
- <li>{{jsxref("Math.cos()")}}</li>
- <li>{{jsxref("Math.sin()")}}</li>
- <li>{{jsxref("Math.tan()")}}</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.8.2.4', 'Math.atan')}}     | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-math.atan', 'Math.atan')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-math.atan', 'Math.atan')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Math.atan")}}
+
+## Voir aussi
+
+- {{jsxref("Math.acos()")}}
+- {{jsxref("Math.asin()")}}
+- {{jsxref("Math.atan2()")}}
+- {{jsxref("Math.cos()")}}
+- {{jsxref("Math.sin()")}}
+- {{jsxref("Math.tan()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/math/atan2/index.md b/files/fr/web/javascript/reference/global_objects/math/atan2/index.md
index 24923087e3..c95dd9050b 100644
--- a/files/fr/web/javascript/reference/global_objects/math/atan2/index.md
+++ b/files/fr/web/javascript/reference/global_objects/math/atan2/index.md
@@ -9,102 +9,76 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Math/atan2
 original_slug: Web/JavaScript/Reference/Objets_globaux/Math/atan2
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La fonction <code><strong>Math.atan2()</strong></code> renvoie l'arc tangente du quotient de ses arguments.</p>
+La fonction **`Math.atan2()`** renvoie l'arc tangente du quotient de ses arguments.
 
-<div>{{EmbedInteractiveExample("pages/js/math-atan2.html")}}</div>
+{{EmbedInteractiveExample("pages/js/math-atan2.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">Math.atan2(<var>y</var>, <var>x</var>) </pre>
+    Math.atan2(y, x)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>x</code></dt>
- <dd>La coordonnée en abscisse du point.</dd>
- <dt><code>y</code></dt>
- <dd>La coordonnée en ordonnée du point.</dd>
-</dl>
+- `x`
+  - : La coordonnée en abscisse du point.
+- `y`
+  - : La coordonnée en ordonnée du point.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>L'arc tangente du quotient formé par les deux arguments, c'est-à-dire l'angle, exprimé en radians entre l'axe des abscisses et la droite passant par l'origin (0,0) et le point de coordonnées (x,y).</p>
+L'arc tangente du quotient formé par les deux arguments, c'est-à-dire l'angle, exprimé en radians entre l'axe des abscisses et la droite passant par l'origin (0,0) et le point de coordonnées (x,y).
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La méthode <code>Math.atan2()</code> renvoie une valeur numérique comprise entre -Pi et Pi qui représente l'angle theta d'un point de coordonnées (x,y). Cela correspond à l'angle (dans le sens trigonométrique) entre l'axe des abscisses et le point de coordonnées (<code>x,y</code>). Attention, le premier argument de la fonction est l'ordonnée (y) et le second est l'abscisse (x).</p>
+La méthode `Math.atan2()` renvoie une valeur numérique comprise entre -Pi et Pi qui représente l'angle theta d'un point de coordonnées (x,y). Cela correspond à l'angle (dans le sens trigonométrique) entre l'axe des abscisses et le point de coordonnées (`x,y`). Attention, le premier argument de la fonction est l'ordonnée (y) et le second est l'abscisse (x).
 
-<p><img alt="Graphique explicitant l'angle donné par un point de coordonnées X/Y" src="https://mdn.mozillademos.org/files/11565/atan2.png"></p>
+![Graphique explicitant l'angle donné par un point de coordonnées X/Y](https://mdn.mozillademos.org/files/11565/atan2.png)
 
-<p><code>Math.atan2()</code> utilise deux arguments <code>x</code> et <code>y</code>, alors que la méthode <code>Math.atan()</code> utilise le ratio de deux nombres comme un seul argument.</p>
+`Math.atan2()` utilise deux arguments `x` et `y`, alors que la méthode `Math.atan()` utilise le ratio de deux nombres comme un seul argument.
 
-<p><code>atan2()</code> est une méthode statique de l'objet <code>Math</code>, elle doit toujours être utilisée avec la syntaxe <code>Math.atan2()</code>, elle ne doit pas être utilisée comme la méthode d'un autre objet qui aurait été créé (<code>Math</code> n'est pas un constructeur).</p>
+`atan2()` est une méthode statique de l'objet `Math`, elle doit toujours être utilisée avec la syntaxe `Math.atan2()`, elle ne doit pas être utilisée comme la méthode d'un autre objet qui aurait été créé (`Math` n'est pas un constructeur).
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_Math.atan2()">Utiliser <code>Math.atan2()</code></h3>
+### Utiliser `Math.atan2()`
 
-<pre class="brush:js">Math.atan2(90, 15); // 1.4056476493802699
+```js
+Math.atan2(90, 15); // 1.4056476493802699
 Math.atan2(15, 90); // 0.16514867741462683
 
 Math.atan2( ±0, -0 );               // ±PI.
 Math.atan2( ±0, +0 );               // ±0.
-Math.atan2( ±0, -x );               // ±PI pour x &gt; 0.
-Math.atan2( ±0, x );                // ±0 pour x &gt; 0.
-Math.atan2( -y, ±0 );               // -PI/2 pour y &gt; 0.
-Math.atan2( y, ±0 );                // PI/2 pour y &gt; 0.
-Math.atan2( ±y, -Infinity );        // ±PI pour y qui est un nombre fini &gt; 0.
-Math.atan2( ±y, +Infinity );        // ±0 pour y qui est un nombre fini &gt; 0.
+Math.atan2( ±0, -x );               // ±PI pour x > 0.
+Math.atan2( ±0, x );                // ±0 pour x > 0.
+Math.atan2( -y, ±0 );               // -PI/2 pour y > 0.
+Math.atan2( y, ±0 );                // PI/2 pour y > 0.
+Math.atan2( ±y, -Infinity );        // ±PI pour y qui est un nombre fini > 0.
+Math.atan2( ±y, +Infinity );        // ±0 pour y qui est un nombre fini > 0.
 Math.atan2( ±Infinity, x );         // ±PI/2 pour x qui est un nombre fini.
 Math.atan2( ±Infinity, -Infinity ); // ±3*PI/4.
 Math.atan2( ±Infinity, +Infinity ); // ±PI/4.
-</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.0.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.8.2.5', 'Math.atan2')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-math.atan2', 'Math.atan2')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-math.atan2', 'Math.atan2')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Math.atan2")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Math.acos()")}}</li>
- <li>{{jsxref("Math.asin()")}}</li>
- <li>{{jsxref("Math.atan()")}}</li>
- <li>{{jsxref("Math.cos()")}}</li>
- <li>{{jsxref("Math.sin()")}}</li>
- <li>{{jsxref("Math.tan()")}}</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.8.2.5', 'Math.atan2')}}         | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-math.atan2', 'Math.atan2')}}         | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-math.atan2', 'Math.atan2')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Math.atan2")}}
+
+## Voir aussi
+
+- {{jsxref("Math.acos()")}}
+- {{jsxref("Math.asin()")}}
+- {{jsxref("Math.atan()")}}
+- {{jsxref("Math.cos()")}}
+- {{jsxref("Math.sin()")}}
+- {{jsxref("Math.tan()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/math/atanh/index.md b/files/fr/web/javascript/reference/global_objects/math/atanh/index.md
index f159f35630..ce23e62351 100644
--- a/files/fr/web/javascript/reference/global_objects/math/atanh/index.md
+++ b/files/fr/web/javascript/reference/global_objects/math/atanh/index.md
@@ -10,90 +10,71 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Math/atanh
 original_slug: Web/JavaScript/Reference/Objets_globaux/Math/atanh
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La fonction <code><strong>Math.atanh()</strong></code> renvoie l'arc tangente hyperbolique d'un nombre :</p>
+La fonction **`Math.atanh()`** renvoie l'arc tangente hyperbolique d'un nombre :
 
-<p><math><semantics><mrow><mo>∀</mo><mi>x</mi><mo>∊</mo><mrow><mo>(</mo><mrow><mo>-</mo><mn>1</mn><mo>,</mo><mn>1</mn></mrow><mo>)</mo></mrow><mo>,</mo><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.atanh</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="thinmathspace">arctanh</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext> le seul </mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mtext>  tel que</mtext><mspace width="thickmathspace"></mspace><mo lspace="0em" rspace="0em">tanh</mo><mo stretchy="false">(</mo><mi>y</mi><mo stretchy="false">)</mo><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\forall x \in \left( -1, 1 \right), \mathtt{\operatorname{Math.atanh}(x)} = \operatorname{arctanh}(x) = \text{ the unique } \; y \; \text{such that} \; \tanh(y) = x</annotation></semantics></math></p>
+<math><semantics><mrow><mo>∀</mo><mi>x</mi><mo>∊</mo><mrow><mo>(</mo><mrow><mo>-</mo><mn>1</mn><mo>,</mo><mn>1</mn></mrow><mo>)</mo></mrow><mo>,</mo><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.atanh</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="thinmathspace">arctanh</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext> le seul </mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mtext>  tel que</mtext><mspace width="thickmathspace"></mspace><mo lspace="0em" rspace="0em">tanh</mo><mo stretchy="false">(</mo><mi>y</mi><mo stretchy="false">)</mo><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\forall x \in \left( -1, 1 \right), \mathtt{\operatorname{Math.atanh}(x)} = \operatorname{arctanh}(x) = \text{ the unique } \; y \; \text{such that} \; \tanh(y) = x</annotation></semantics></math>
 
-<div>{{EmbedInteractiveExample("pages/js/math-atanh.html")}}</div>
+{{EmbedInteractiveExample("pages/js/math-atanh.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">Math.atanh(<var>x</var>)</pre>
+    Math.atanh(x)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>x</code></dt>
- <dd>Un nombre.</dd>
-</dl>
+- `x`
+  - : Un nombre.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>L'arc tangente hyperbolique du nombre passé en argument.</p>
+L'arc tangente hyperbolique du nombre passé en argument.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p><code>atanh()</code> est une méthode statique de <code>Math</code>, il faut utiliser la syntaxe <code>Math.atanh()</code>, et non pas une méthode d'un objet <code>Math</code> créé sur mesure (<code>Math</code> n'est pas un constructeur).</p>
+`atanh()` est une méthode statique de `Math`, il faut utiliser la syntaxe `Math.atanh()`, et non pas une méthode d'un objet `Math` créé sur mesure (`Math` n'est pas un constructeur).
 
-<h2 id="Exemple">Exemple</h2>
+## Exemple
 
-<h3 id="Utiliser_Math.atanh()">Utiliser <code>Math.atanh()</code></h3>
+### Utiliser `Math.atanh()`
 
-<pre class="brush:js">Math.atanh(-2);  // NaN
+```js
+Math.atanh(-2);  // NaN
 Math.atanh(-1);  // -Infinity
 Math.atanh(0);   // 0
 Math.atanh(0.5); // 0.5493061443340548
 Math.atanh(1);   // Infinity
 Math.atanh(2);   // NaN
-</pre>
+```
 
-<p>Pour les valeurs strictement inférieures à -1 ou strictement supérieures à 1, {{jsxref("NaN")}} sera renvoyé.</p>
+Pour les valeurs strictement inférieures à -1 ou strictement supérieures à 1, {{jsxref("NaN")}} sera renvoyé.
 
-<h2 id="Prothèse_d'émulation_(polyfill)">Prothèse d'émulation (<em>polyfill</em>)</h2>
+## Prothèse d'émulation (_polyfill_)
 
-<p>Pour <math><semantics><mrow><mrow><mo>|</mo><mi>x</mi><mo>|</mo></mrow><mo>&lt;</mo><mn>1</mn></mrow><annotation encoding="TeX">\left|x\right| &lt; 1</annotation></semantics></math>, on a la formule suivante : <math><semantics><mrow><mo lspace="0em" rspace="thinmathspace">artanh</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mfrac><mn>1</mn><mn>2</mn></mfrac><mo lspace="0em" rspace="0em">ln</mo><mrow><mo>(</mo><mfrac><mrow><mn>1</mn><mo>+</mo><mi>x</mi></mrow><mrow><mn>1</mn><mo>-</mo><mi>x</mi></mrow></mfrac><mo>)</mo></mrow></mrow><annotation encoding="TeX">\operatorname {artanh} (x) = \frac{1}{2}\ln \left( \frac{1 + x}{1 - x} \right)</annotation></semantics></math>et on peut donc émuler la fonction avec :</p>
+Pour <math><semantics><mrow><mrow><mo>|</mo><mi>x</mi><mo>|</mo></mrow><mo>&#x3C;</mo><mn>1</mn></mrow><annotation encoding="TeX">\left|x\right| &#x3C; 1</annotation></semantics></math>, on a la formule suivante : <math><semantics><mrow><mo lspace="0em" rspace="thinmathspace">artanh</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mfrac><mn>1</mn><mn>2</mn></mfrac><mo lspace="0em" rspace="0em">ln</mo><mrow><mo>(</mo><mfrac><mrow><mn>1</mn><mo>+</mo><mi>x</mi></mrow><mrow><mn>1</mn><mo>-</mo><mi>x</mi></mrow></mfrac><mo>)</mo></mrow></mrow><annotation encoding="TeX">\operatorname {artanh} (x) = \frac{1}{2}\ln \left( \frac{1 + x}{1 - x} \right)</annotation></semantics></math>et on peut donc émuler la fonction avec :
 
-<pre class="brush: js">Math.atanh = Math.atanh || function(x) {
+```js
+Math.atanh = Math.atanh || function(x) {
   return Math.log((1+x)/(1-x)) / 2;
 };
-</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">Commentaires</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-math.atanh', 'Math.atanh')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-math.atanh', 'Math.atanh')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Math.atanh")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Math.acosh()")}}</li>
- <li>{{jsxref("Math.asinh()")}}</li>
- <li>{{jsxref("Math.cosh()")}}</li>
- <li>{{jsxref("Math.sinh()")}}</li>
- <li>{{jsxref("Math.tanh()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                | Statut                       | Commentaires         |
+| ---------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ES6', '#sec-math.atanh', 'Math.atanh')}}         | {{Spec2('ES6')}}         | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-math.atanh', 'Math.atanh')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Math.atanh")}}
+
+## Voir aussi
+
+- {{jsxref("Math.acosh()")}}
+- {{jsxref("Math.asinh()")}}
+- {{jsxref("Math.cosh()")}}
+- {{jsxref("Math.sinh()")}}
+- {{jsxref("Math.tanh()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/math/cbrt/index.md b/files/fr/web/javascript/reference/global_objects/math/cbrt/index.md
index fb9daa3cc0..8fe0f00c04 100644
--- a/files/fr/web/javascript/reference/global_objects/math/cbrt/index.md
+++ b/files/fr/web/javascript/reference/global_objects/math/cbrt/index.md
@@ -11,38 +11,37 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Math/cbrt
 original_slug: Web/JavaScript/Reference/Objets_globaux/Math/cbrt
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La fonction <code><strong>Math.cbrt()</strong></code> renvoie la racine cubique (le nom anglais étant <em>cubic root</em>) d'un nombre :</p>
+La fonction **`Math.cbrt()`** renvoie la racine cubique (le nom anglais étant _cubic root_) d'un nombre :
 
-<p><math><semantics><mrow><mstyle mathvariant="monospace"><mrow><mi>M</mi><mi>a</mi><mi>t</mi><mi>h</mi><mo>.</mo><mi>c</mi><mi>b</mi><mi>r</mi><mi>t</mi><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mroot><mi>x</mi><mn>3</mn></mroot><mo>=</mo><mtext>le seul</mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mspace width="thickmathspace"></mspace><mtext>tel que</mtext><mspace width="thickmathspace"></mspace><msup><mi>y</mi><mn>3</mn></msup><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\mathtt{Math.cbrt(x)} = \sqrt[3]{x} = \text{the unique} \; y \; \text{such that} \; y^3 = x</annotation></semantics></math></p>
+<math><semantics><mrow><mstyle mathvariant="monospace"><mrow><mi>M</mi><mi>a</mi><mi>t</mi><mi>h</mi><mo>.</mo><mi>c</mi><mi>b</mi><mi>r</mi><mi>t</mi><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mroot><mi>x</mi><mn>3</mn></mroot><mo>=</mo><mtext>le seul</mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mspace width="thickmathspace"></mspace><mtext>tel que</mtext><mspace width="thickmathspace"></mspace><msup><mi>y</mi><mn>3</mn></msup><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\mathtt{Math.cbrt(x)} = \sqrt[3]{x} = \text{the unique} \; y \; \text{such that} \; y^3 = x</annotation></semantics></math>
 
-<div>{{EmbedInteractiveExample("pages/js/math-cbrt.html")}}</div>
+{{EmbedInteractiveExample("pages/js/math-cbrt.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">Math.cbrt(<var>x</var>)</pre>
+    Math.cbrt(x)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>x</code></dt>
- <dd>Un nombre.</dd>
-</dl>
+- `x`
+  - : Un nombre.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>La racine cubique du nombre passé en argument.</p>
+La racine cubique du nombre passé en argument.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p><code>cbrt()</code> étant une méthode statique de <code>Math</code>, il faut utiliser <code>Math.cbrt()</code>, et non pas la méthode d'un autre objet créé (<code>Math</code> n'est pas un constructeur).</p>
+`cbrt()` étant une méthode statique de `Math`, il faut utiliser `Math.cbrt()`, et non pas la méthode d'un autre objet créé (`Math` n'est pas un constructeur).
 
-<h2 id="Exemple">Exemple</h2>
+## Exemple
 
-<h3 id="Utiliser_Math.cbrt()">Utiliser <code>Math.cbrt()</code></h3>
+### Utiliser `Math.cbrt()`
 
-<pre class="brush:js">Math.cbrt(NaN); // NaN
+```js
+Math.cbrt(NaN); // NaN
 Math.cbrt(-1); // -1
 Math.cbrt(-0); // -0
 Math.cbrt(-Infinity); // -Infinity
@@ -50,39 +49,21 @@ Math.cbrt(0); // 0
 Math.cbrt(1); // 1
 Math.cbrt(Infinity); // Infinity
 Math.cbrt(null); // 0
-Math.cbrt(2);  // 1.2599210498948732</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('ES6', '#sec-math.cbrt', 'Math.cbrt')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-math.cbrt', 'Math.cbrt')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Math.cbrt")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Math.pow()")}}</li>
- <li>{{jsxref("Math.sqrt()")}}</li>
-</ul>
+Math.cbrt(2);  // 1.2599210498948732
+```
+
+## Spécifications
+
+| Spécification                                                            | État                         | Commentaires         |
+| ------------------------------------------------------------------------ | ---------------------------- | -------------------- |
+| {{SpecName('ES6', '#sec-math.cbrt', 'Math.cbrt')}}     | {{Spec2('ES6')}}         | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-math.cbrt', 'Math.cbrt')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Math.cbrt")}}
+
+## Voir aussi
+
+- {{jsxref("Math.pow()")}}
+- {{jsxref("Math.sqrt()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/math/ceil/index.md b/files/fr/web/javascript/reference/global_objects/math/ceil/index.md
index 93e8919368..fced464d1b 100644
--- a/files/fr/web/javascript/reference/global_objects/math/ceil/index.md
+++ b/files/fr/web/javascript/reference/global_objects/math/ceil/index.md
@@ -9,52 +9,51 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Math/ceil
 original_slug: Web/JavaScript/Reference/Objets_globaux/Math/ceil
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La fonction <code><strong>Math.ceil()</strong></code> retourne le plus petit entier supérieur ou égal au nombre donné.</p>
+La fonction **`Math.ceil()`** retourne le plus petit entier supérieur ou égal au nombre donné.
 
-<div>{{EmbedInteractiveExample("pages/js/math-ceil.html")}}</div>
+{{EmbedInteractiveExample("pages/js/math-ceil.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">Math.ceil(<var>x</var>) </pre>
+    Math.ceil(x)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>x</code></dt>
- <dd>Un nombre.</dd>
-</dl>
+- `x`
+  - : Un nombre.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Le plus petit entier qui est supérieur ou égal au nombre donné.</p>
+Le plus petit entier qui est supérieur ou égal au nombre donné.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p><code>ceil()</code> est une méthode statique de <code>Math</code>. Elle doit être utilisée avec la syntaxe <code>Math.ceil()</code>, plutôt que comme une méthode d'un autre objet qui aurait été créé (<code>Math</code> n'est pas un constructeur).</p>
+`ceil()` est une méthode statique de `Math`. Elle doit être utilisée avec la syntaxe `Math.ceil()`, plutôt que comme une méthode d'un autre objet qui aurait été créé (`Math` n'est pas un constructeur).
 
-<div class="blockIndicator note">
-<p><strong>Note :</strong> <code>Math.ceil(null)</code> renverra <code>0</code> et pas {{jsxref("NaN")}}.</p>
-</div>
+> **Note :** `Math.ceil(null)` renverra `0` et pas {{jsxref("NaN")}}.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_Math.ceil()">Utiliser <code>Math.ceil()</code></h3>
+### Utiliser `Math.ceil()`
 
-<p>Voici un exemple d'utilisation de <code>Math.ceil()</code>.</p>
+Voici un exemple d'utilisation de `Math.ceil()`.
 
-<pre class="brush:js;">Math.ceil(.95);    // 1
+```js
+Math.ceil(.95);    // 1
 Math.ceil(4);      // 4
 Math.ceil(7.004);  // 8
 Math.ceil(-0.95);  // -0
 Math.ceil(-4);     // -4
 Math.ceil(-7.004); // -7
-Math.ceil(null);   // 0</pre>
+Math.ceil(null);   // 0
+```
 
-<h3 id="Arrondi_décimal">Arrondi décimal</h3>
+### Arrondi décimal
 
-<pre class="brush:js">// Fermeture
+```js
+// Fermeture
 (function(){
 
 	/**
@@ -74,7 +73,7 @@ Math.ceil(null);   // 0</pre>
 		exp = +exp;
 		// Si value n'est pas un nombre
         // ou si l'exposant n'est pas entier
-		if (isNaN(value) || !(typeof exp === 'number' &amp;&amp; exp % 1 === 0)) {
+		if (isNaN(value) || !(typeof exp === 'number' && exp % 1 === 0)) {
 			return NaN;
 		}
 		// Décalage
@@ -125,50 +124,25 @@ Math.ceil10(55.51, -1); // 55.6
 Math.ceil10(51, 1); // 60
 Math.ceil10(-55.59, -1); // -55.5
 Math.ceil10(-59, 1); // -50
-</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.0.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.8.2.6', 'Math.ceil')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-math.ceil', 'Math.ceil')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-math.ceil', 'Math.ceil')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Math.ceil")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Math.abs()")}}</li>
- <li>{{jsxref("Math.floor()")}}</li>
- <li>{{jsxref("Math.round()")}}</li>
- <li>{{jsxref("Math.sign()")}}</li>
- <li>{{jsxref("Math.trunc()")}}{</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.8.2.6', 'Math.ceil')}}     | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-math.ceil', 'Math.ceil')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-math.ceil', 'Math.ceil')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Math.ceil")}}
+
+## Voir aussi
+
+- {{jsxref("Math.abs()")}}
+- {{jsxref("Math.floor()")}}
+- {{jsxref("Math.round()")}}
+- {{jsxref("Math.sign()")}}
+- {{jsxref("Math.trunc()")}}{
diff --git a/files/fr/web/javascript/reference/global_objects/math/clz32/index.md b/files/fr/web/javascript/reference/global_objects/math/clz32/index.md
index c3298823a6..416bc22e28 100644
--- a/files/fr/web/javascript/reference/global_objects/math/clz32/index.md
+++ b/files/fr/web/javascript/reference/global_objects/math/clz32/index.md
@@ -11,82 +11,61 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Math/clz32
 original_slug: Web/JavaScript/Reference/Objets_globaux/Math/clz32
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La fonction <code><strong>Math.clz32()</strong></code> renvoie le nombre de zéros de tête dans la représentation binaire sur 32 bits d'un nombre.</p>
+La fonction **`Math.clz32()`** renvoie le nombre de zéros de tête dans la représentation binaire sur 32 bits d'un nombre.
 
-<div>{{EmbedInteractiveExample("pages/js/math-clz32.html")}}</div>
+{{EmbedInteractiveExample("pages/js/math-clz32.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">Math.clz32(<var>x</var>)
-</pre>
+    Math.clz32(x)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>x</code></dt>
- <dd>Un nombre.</dd>
-</dl>
+- `x`
+  - : Un nombre.
 
-<h3 id="Valeur_retournée">Valeur retournée</h3>
+### Valeur retournée
 
-<p>Le nombre de bits à zéro en tête de la représentation binaire sur 32 bits du nombre donné.</p>
+Le nombre de bits à zéro en tête de la représentation binaire sur 32 bits du nombre donné.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>"<code>clz32</code>" est un raccourci pour CountLeadingZeroes32 (en français, « compter les zéros de tête »).</p>
+"`clz32`" est un raccourci pour CountLeadingZeroes32 (en français, « compter les zéros de tête »).
 
-<p>Si <code>x</code> n'est pas un nombre, il sera d'abord converti en nombre puis converti en un entier non signé sur 32 bits.</p>
+Si `x` n'est pas un nombre, il sera d'abord converti en nombre puis converti en un entier non signé sur 32 bits.
 
-<p>Si l'entier non signé sur 32 bits résultant vaut <code>0</code>, la fonction renverra <code>32</code>, car tous les bits valent <code>0</code>.</p>
+Si l'entier non signé sur 32 bits résultant vaut `0`, la fonction renverra `32`, car tous les bits valent `0`.
 
-<p>Cette fonction est particulièrement utile aux systèmes qui compilent du code JavaScript, comme <a href="/fr/docs/Emscripten">Emscripten</a>.</p>
+Cette fonction est particulièrement utile aux systèmes qui compilent du code JavaScript, comme [Emscripten](/fr/docs/Emscripten).
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<pre class="brush: js">Math.clz32(1)                // 31
+```js
+Math.clz32(1)                // 31
 Math.clz32(1000)             // 22
 Math.clz32()                 // 32
 
 var liste = [NaN, Infinity, -Infinity, 0, -0, null, undefined, 'machin', {}, []];
-liste.every(n =&gt; Math.clz32(n) == 32); // true
+liste.every(n => Math.clz32(n) == 32); // true
 
 Math.clz32(true)             // 31
 Math.clz32(3.5)              // 30
-</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('ES2015', '#sec-math.clz32', 'Math.clz32')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-math.clz32', 'Math.clz32')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Math.clz32")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Math")}}</li>
- <li>{{jsxref("Math.imul")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                | Statut                       | Commentaire          |
+| ---------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ES2015', '#sec-math.clz32', 'Math.clz32')}}     | {{Spec2('ES2015')}}     | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-math.clz32', 'Math.clz32')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Math.clz32")}}
+
+## Voir aussi
+
+- {{jsxref("Math")}}
+- {{jsxref("Math.imul")}}
diff --git a/files/fr/web/javascript/reference/global_objects/math/cos/index.md b/files/fr/web/javascript/reference/global_objects/math/cos/index.md
index 2015708e27..9b78bfd357 100644
--- a/files/fr/web/javascript/reference/global_objects/math/cos/index.md
+++ b/files/fr/web/javascript/reference/global_objects/math/cos/index.md
@@ -9,87 +9,61 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Math/cos
 original_slug: Web/JavaScript/Reference/Objets_globaux/Math/cos
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La fonction <code><strong>Math.cos()</strong></code> retourne le <a href="https://fr.wikipedia.org/wiki/Cosinus">cosinus</a> d'un angle dont la valeur est exprimée en <a href="https://fr.wikipedia.org/wiki/Radian">radians</a>.</p>
+La fonction **`Math.cos()`** retourne le [cosinus](https://fr.wikipedia.org/wiki/Cosinus) d'un angle dont la valeur est exprimée en [radians](https://fr.wikipedia.org/wiki/Radian).
 
-<div>{{EmbedInteractiveExample("pages/js/math-cos.html")}}</div>
+{{EmbedInteractiveExample("pages/js/math-cos.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">Math.cos(<var>x</var>)</pre>
+    Math.cos(x)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>x</code></dt>
- <dd>Une valeur numérique (exprimée en radians).</dd>
-</dl>
+- `x`
+  - : Une valeur numérique (exprimée en radians).
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Le cosinus de l'angle fourni en argument (exprimé en radians).</p>
+Le cosinus de l'angle fourni en argument (exprimé en radians).
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La méthode <code>Math.cos()</code> renvoie une valeur numérique comprise entre -1 et 1. Cela représente la valeur du cosinus de l'angle correspondant à cette valeur.</p>
+La méthode `Math.cos()` renvoie une valeur numérique comprise entre -1 et 1. Cela représente la valeur du cosinus de l'angle correspondant à cette valeur.
 
-<p><code>cos</code> est une méthode statique de <code>Math</code>, elle doit toujours être utilisée avec la syntaxe <code>Math.cos()</code>, ne pas utiliser une méthode d'un objet qui aurait été créé (<code>Math</code> n'est pas un constructeur).</p>
+`cos` est une méthode statique de `Math`, elle doit toujours être utilisée avec la syntaxe `Math.cos()`, ne pas utiliser une méthode d'un objet qui aurait été créé (`Math` n'est pas un constructeur).
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_Math.cos()">Utiliser <code>Math.cos()</code></h3>
+### Utiliser `Math.cos()`
 
-<pre class="brush:js">Math.cos(0);           // 1
+```js
+Math.cos(0);           // 1
 Math.cos(1);           // 0.5403023058681398
 
 Math.cos(Math.PI);     // -1
 Math.cos(2 * Math.PI); // 1
-</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.0.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.8.2.7', 'Math.cos')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-math.cos', 'Math.cos')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-math.cos', 'Math.cos')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Math.cos")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Math.acos()")}}</li>
- <li>{{jsxref("Math.asin()")}}</li>
- <li>{{jsxref("Math.atan()")}}</li>
- <li>{{jsxref("Math.atan2()")}}</li>
- <li>{{jsxref("Math.sin()")}}</li>
- <li>{{jsxref("Math.tan()")}}</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.8.2.7', 'Math.cos')}} | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-math.cos', 'Math.cos')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-math.cos', 'Math.cos')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Math.cos")}}
+
+## Voir aussi
+
+- {{jsxref("Math.acos()")}}
+- {{jsxref("Math.asin()")}}
+- {{jsxref("Math.atan()")}}
+- {{jsxref("Math.atan2()")}}
+- {{jsxref("Math.sin()")}}
+- {{jsxref("Math.tan()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/math/cosh/index.md b/files/fr/web/javascript/reference/global_objects/math/cosh/index.md
index 76c7d9fe17..d0306213b6 100644
--- a/files/fr/web/javascript/reference/global_objects/math/cosh/index.md
+++ b/files/fr/web/javascript/reference/global_objects/math/cosh/index.md
@@ -11,93 +11,77 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Math/cosh
 original_slug: Web/JavaScript/Reference/Objets_globaux/Math/cosh
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La fonction <code><strong>Math.cosh()</strong></code> renvoie le cosinus hyperbolique d'un nombre, défini par :</p>
+La fonction **`Math.cosh()`** renvoie le cosinus hyperbolique d'un nombre, défini par :
 
-<p><math><semantics><mrow><mstyle mathvariant="monospace"><mo lspace="0em" rspace="thinmathspace">Math.cosh(x)</mo></mstyle><mo>=</mo><mfrac><mrow><msup><mi>e</mi><mi>x</mi></msup><mo>+</mo><msup><mi>e</mi><mrow><mo>-</mo><mi>x</mi></mrow></msup></mrow><mn>2</mn></mfrac></mrow><annotation encoding="TeX">\mathtt{\operatorname{Math.cosh(x)}} = \frac{e^x + e^{-x}}{2}</annotation></semantics></math></p>
+<math><semantics><mrow><mstyle mathvariant="monospace"><mo lspace="0em" rspace="thinmathspace">Math.cosh(x)</mo></mstyle><mo>=</mo><mfrac><mrow><msup><mi>e</mi><mi>x</mi></msup><mo>+</mo><msup><mi>e</mi><mrow><mo>-</mo><mi>x</mi></mrow></msup></mrow><mn>2</mn></mfrac></mrow><annotation encoding="TeX">\mathtt{\operatorname{Math.cosh(x)}} = \frac{e^x + e^{-x}}{2}</annotation></semantics></math>
 
-<div>{{EmbedInteractiveExample("pages/js/math-cosh.html")}}</div>
+{{EmbedInteractiveExample("pages/js/math-cosh.html")}}
 
+(Voir la page sur {{jsxref("Objets_globaux/Math/E","e","",1)}})
 
+## Syntaxe
 
-<p>(Voir la page sur {{jsxref("Objets_globaux/Math/E","e","",1)}})</p>
+    Math.cosh(x)
 
-<h2 id="Syntaxe">Syntaxe</h2>
+### Paramètres
 
-<pre class="syntaxbox">Math.cosh(<var>x</var>)</pre>
+- `x`
+  - : Un nombre.
 
-<h3 id="Paramètres">Paramètres</h3>
+### Valeur de retour
 
-<dl>
- <dt><code>x</code></dt>
- <dd>Un nombre.</dd>
-</dl>
+Le cosinus hyperbolique du nombre passé en argument.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+## Description
 
-<p>Le cosinus hyperbolique du nombre passé en argument.</p>
+`cosh()` étant une méthode statique de `Math`, il faut utiliser `Math.cosh()` et non pas la méthode d'un objet `Math` créé sur mesure (`Math` n'est pas un constructeur).
 
-<h2 id="Description">Description</h2>
+## Exemple
 
-<p><code>cosh()</code> étant une méthode statique de <code>Math</code>, il faut utiliser <code>Math.cosh()</code> et non pas la méthode d'un objet <code>Math</code> créé sur mesure (<code>Math</code> n'est pas un constructeur).</p>
+### Utiliser `Math.cosh()`
 
-<h2 id="Exemple">Exemple</h2>
-
-<h3 id="Utiliser_Math.cosh()">Utiliser <code>Math.cosh()</code></h3>
-
-<pre class="brush:js">Math.cosh(0);  // 1
+```js
+Math.cosh(0);  // 1
 Math.cosh(1);  // 1.5430806348152437
 Math.cosh(-1); // 1.5430806348152437
-</pre>
+```
 
-<h2 id="Prothèse_d'émulation_(polyfill)">Prothèse d'émulation (<em>polyfill</em>)</h2>
+## Prothèse d'émulation (_polyfill_)
 
-<p>Cette fonction peut être émulée grâce à la fonction {{jsxref("Objets_globaux/Math/exp", "Math.exp()")}} :</p>
+Cette fonction peut être émulée grâce à la fonction {{jsxref("Objets_globaux/Math/exp", "Math.exp()")}} :
 
-<pre class="brush: js">Math.cosh = Math.cosh || function(x) {
+```js
+Math.cosh = Math.cosh || function(x) {
     return (Math.exp(x) + Math.exp(-x)) / 2;
-}</pre>
+}
+```
 
-<p>On peut également utiliser un unique appel à {{jsxref("Objets_globaux/Math/exp", "exp()")}} :</p>
+On peut également utiliser un unique appel à {{jsxref("Objets_globaux/Math/exp", "exp()")}} :
 
-<pre class="brush: js">Math.cosh = Math.cosh || function(x) {
+```js
+Math.cosh = Math.cosh || function(x) {
     var y = Math.exp(x);
     return (y + 1 / y) / 2;
-}</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-math.cosh', 'Math.cosh')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-math.cosh', 'Math.cosh')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Math.cosh")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Math.acosh()")}}</li>
- <li>{{jsxref("Math.asinh()")}}</li>
- <li>{{jsxref("Math.atanh()")}}</li>
- <li>{{jsxref("Math.sinh()")}}</li>
- <li>{{jsxref("Math.tanh()")}}</li>
-</ul>
+}
+```
+
+## Spécifications
+
+| Spécification                                                            | État                         | Commentaires         |
+| ------------------------------------------------------------------------ | ---------------------------- | -------------------- |
+| {{SpecName('ES6', '#sec-math.cosh', 'Math.cosh')}}     | {{Spec2('ES6')}}         | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-math.cosh', 'Math.cosh')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Math.cosh")}}
+
+## Voir aussi
+
+- {{jsxref("Math.acosh()")}}
+- {{jsxref("Math.asinh()")}}
+- {{jsxref("Math.atanh()")}}
+- {{jsxref("Math.sinh()")}}
+- {{jsxref("Math.tanh()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/math/e/index.md b/files/fr/web/javascript/reference/global_objects/math/e/index.md
index f4df99a2cb..540d7769eb 100644
--- a/files/fr/web/javascript/reference/global_objects/math/e/index.md
+++ b/files/fr/web/javascript/reference/global_objects/math/e/index.md
@@ -9,74 +9,47 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Math/E
 original_slug: Web/JavaScript/Reference/Objets_globaux/Math/E
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La propriété <code><strong>Math.E</strong></code> représente la base du logarithme naturel, e, et vaut environ 2.718.</p>
+La propriété **`Math.E`** représente la base du logarithme naturel, e, et vaut environ 2.718.
 
-<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.E</mi></mstyle><mo>=</mo><mi>e</mi><mo>≈</mo><mn>2.718</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.E}} = e \approx 2.718</annotation></semantics></math></p>
+<math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.E</mi></mstyle><mo>=</mo><mi>e</mi><mo>≈</mo><mn>2.718</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.E}} = e \approx 2.718</annotation></semantics></math>
 
-<div>{{EmbedInteractiveExample("pages/js/math-e.html")}}</div>
+{{EmbedInteractiveExample("pages/js/math-e.html")}}{{js_property_attributes(0,0,0)}}
 
+## Description
 
+`E` étant une propriété statique de `Math`, il doit toujours être utilisé avec la syntaxe `Math.E`, et non pas être appelé comme propriété d'un autre objet `Math` qui aurait été créé (`Math` n'est pas un constructeur).
 
-<div>{{js_property_attributes(0,0,0)}}</div>
+## Exemples
 
-<h2 id="Description">Description</h2>
+### Utiliser `Math.E`
 
-<p><code>E</code> étant une propriété statique de <code>Math</code>, il doit toujours être utilisé avec la syntaxe <code>Math.E</code>, et non pas être appelé comme propriété d'un autre objet <code>Math</code> qui aurait été créé (<code>Math</code> n'est pas un constructeur).</p>
+La fonction suivante renvoie la valeur de e :
 
-<h2 id="Exemples">Exemples</h2>
+```js
+function getNapier() {
+   return Math.E;
+}
 
-<h3 id="Utiliser_Math.E">Utiliser <code>Math.E</code></h3>
+getNapier(); // 2.718281828459045
+```
 
-<p>La fonction suivante renvoie la valeur de e :</p>
+## Spécifications
 
-<pre class="brush:js">function getNapier() {
-   return Math.E;
-}
+| Spécification                                                    | Statut                       | Commentaires                                          |
+| ---------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- |
+| {{SpecName('ES1')}}                                         | {{Spec2('ES1')}}         | Définition initiale. Implémentée avec JavaScript 1.0. |
+| {{SpecName('ES5.1', '#sec-15.8.1.1', 'Math.E')}} | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-math.e', 'Math.E')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-math.e', 'Math.E')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Math.E")}}
+
+## Voir aussi
 
-getNapier(); // 2.718281828459045</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. Implémentée avec JavaScript 1.0.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.8.1.1', 'Math.E')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-math.e', 'Math.E')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-math.e', 'Math.E')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Math.E")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Math.exp()")}}</li>
- <li>{{jsxref("Math.log()")}}</li>
- <li>{{jsxref("Math.log1p()")}}</li>
-</ul>
+- {{jsxref("Math.exp()")}}
+- {{jsxref("Math.log()")}}
+- {{jsxref("Math.log1p()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/math/exp/index.md b/files/fr/web/javascript/reference/global_objects/math/exp/index.md
index 29ac4ef407..e6be9fc5c3 100644
--- a/files/fr/web/javascript/reference/global_objects/math/exp/index.md
+++ b/files/fr/web/javascript/reference/global_objects/math/exp/index.md
@@ -9,85 +9,58 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Math/exp
 original_slug: Web/JavaScript/Reference/Objets_globaux/Math/exp
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La fonction <code><strong>Math.exp()</strong></code> renvoie l'exponentielle d'un nombre (donnée par <code>e^x</code>, où <code>x</code> est la valeur passée en argument et <code>e</code> la valeur du {{jsxref("Objets_globaux/Math/E","nombre d'Euler (parfois appelé constante de Napier)","",1)}}.</p>
+La fonction **`Math.exp()`** renvoie l'exponentielle d'un nombre (donnée par `e^x`, où `x` est la valeur passée en argument et `e` la valeur du {{jsxref("Objets_globaux/Math/E","nombre d'Euler (parfois appelé constante de Napier)","",1)}}.
 
-<div>{{EmbedInteractiveExample("pages/js/math-exp.html")}}</div>
+{{EmbedInteractiveExample("pages/js/math-exp.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">Math.exp(<var>x</var>)</pre>
+    Math.exp(x)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>x</code></dt>
- <dd>
- <p>Un nombre.</p>
- </dd>
-</dl>
+- `x`
+  - : Un nombre.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>L'exponentielle du nombre passé en argument (<code>e^x</code>).</p>
+L'exponentielle du nombre passé en argument (`e^x`).
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p><code>exp()</code> est une méthode statique de <code>Math</code>, elle doit toujours être utilisée avec la syntaxe <code>Math.exp()</code>, elle ne doit pas être utilisée avec un objet qui aurait été créé (<code>Math</code> n'est pas un constructeur).</p>
+`exp()` est une méthode statique de `Math`, elle doit toujours être utilisée avec la syntaxe `Math.exp()`, elle ne doit pas être utilisée avec un objet qui aurait été créé (`Math` n'est pas un constructeur).
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_Math.exp()">Utiliser <code>Math.exp()</code></h3>
+### Utiliser `Math.exp()`
 
-<pre class="brush:js">Math.exp(-1); // 0.36787944117144233
+```js
+Math.exp(-1); // 0.36787944117144233
 Math.exp(0);  // 1
-Math.exp(1);  // 2.718281828459045</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.0.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.8.2.8', 'Math.exp')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-math.exp', 'Math.exp')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-math.exp', 'Math.exp')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Math.exp")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Math.E")}}</li>
- <li>{{jsxref("Math.expm1()")}}</li>
- <li>{{jsxref("Math.log()")}}</li>
- <li>{{jsxref("Math.log10()")}}</li>
- <li>{{jsxref("Math.log1p()")}}</li>
- <li>{{jsxref("Math.log2()")}}</li>
- <li>{{jsxref("Math.pow()")}}</li>
-</ul>
+Math.exp(1);  // 2.718281828459045
+```
+
+## 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.8.2.8', 'Math.exp')}} | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-math.exp', 'Math.exp')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-math.exp', 'Math.exp')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Math.exp")}}
+
+## Voir aussi
+
+- {{jsxref("Math.E")}}
+- {{jsxref("Math.expm1()")}}
+- {{jsxref("Math.log()")}}
+- {{jsxref("Math.log10()")}}
+- {{jsxref("Math.log1p()")}}
+- {{jsxref("Math.log2()")}}
+- {{jsxref("Math.pow()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/math/expm1/index.md b/files/fr/web/javascript/reference/global_objects/math/expm1/index.md
index 372880a5df..2d8223041f 100644
--- a/files/fr/web/javascript/reference/global_objects/math/expm1/index.md
+++ b/files/fr/web/javascript/reference/global_objects/math/expm1/index.md
@@ -11,81 +11,66 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Math/expm1
 original_slug: Web/JavaScript/Reference/Objets_globaux/Math/expm1
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La fonction <code><strong>Math.expm1()</strong></code> renvoie<code> e^x</code> - 1, avec <code>x</code> l'argument donné et {{jsxref("Objets_globaux/Math/E","e")}} la base du logarithme nepérien.</p>
+La fonction **`Math.expm1()`** renvoie` e^x` - 1, avec `x` l'argument donné et {{jsxref("Objets_globaux/Math/E","e")}} la base du logarithme nepérien.
 
-<div>{{EmbedInteractiveExample("pages/js/math-expm1.html")}}</div>
+{{EmbedInteractiveExample("pages/js/math-expm1.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">Math.expm1(<var>x</var>)</pre>
+    Math.expm1(x)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>x</code></dt>
- <dd>Un nombre.</dd>
-</dl>
+- `x`
+  - : Un nombre.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un nombre qui représente <code>e^x- 1</code> où <code>x</code> est la valeur passée en argument et <code>e^x</code> l'exponentielle du nombre.</p>
+Un nombre qui représente `e^x- 1` où `x` est la valeur passée en argument et `e^x` l'exponentielle du nombre.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p><code>expm1()</code> étant une méthode statique de <code>Math</code>, il faut utiliser <code>Math.expm1()</code>et non pas la méthode d'un autre objet qui aurait été créé sur mesure (<code>Math </code>n'est pas un constructeur).</p>
+`expm1()` étant une méthode statique de `Math`, il faut utiliser `Math.expm1()`et non pas la méthode d'un autre objet qui aurait été créé sur mesure (`Math `n'est pas un constructeur).
 
-<h2 id="Exemple">Exemple</h2>
+## Exemple
 
-<h3 id="Utiliser_Math.expm1()">Utiliser <code>Math.expm1()</code></h3>
+### Utiliser `Math.expm1()`
 
-<pre class="brush:js">Math.expm1(-1); // -0.6321205588285577
+```js
+Math.expm1(-1); // -0.6321205588285577
 Math.expm1(0);  // 0
-Math.expm1(1);  // 1.718281828459045</pre>
+Math.expm1(1);  // 1.718281828459045
+```
 
-<h2 id="Prothèse_d'émulation_(polyfill)">Prothèse d'émulation (<em>polyfill</em>)</h2>
+## Prothèse d'émulation (_polyfill_)
 
-<p>Cette fonction peut être émulée en utilisant la fonction {{jsxref("Objets_globaux/Math/exp", "Math.exp()")}} :</p>
+Cette fonction peut être émulée en utilisant la fonction {{jsxref("Objets_globaux/Math/exp", "Math.exp()")}} :
 
-<pre class="brush: js">Math.expm1 = Math.expm1 || function(x) {
+```js
+Math.expm1 = Math.expm1 || function(x) {
     return Math.exp(x) - 1;
-};</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-math.expm1', 'Math.expm1')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-math.expm1', 'Math.expm1')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Math.expm1")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Math.E")}}</li>
- <li>{{jsxref("Math.exp()")}}</li>
- <li>{{jsxref("Math.log()")}}</li>
- <li>{{jsxref("Math.log10()")}}</li>
- <li>{{jsxref("Math.log1p()")}}</li>
- <li>{{jsxref("Math.log2()")}}</li>
- <li>{{jsxref("Math.pow()")}}</li>
-</ul>
+};
+```
+
+## Spécifications
+
+| Spécification                                                                | État                         | Commentaires         |
+| ---------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ES6', '#sec-math.expm1', 'Math.expm1')}}         | {{Spec2('ES6')}}         | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-math.expm1', 'Math.expm1')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Math.expm1")}}
+
+## Voir aussi
+
+- {{jsxref("Math.E")}}
+- {{jsxref("Math.exp()")}}
+- {{jsxref("Math.log()")}}
+- {{jsxref("Math.log10()")}}
+- {{jsxref("Math.log1p()")}}
+- {{jsxref("Math.log2()")}}
+- {{jsxref("Math.pow()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/math/floor/index.md b/files/fr/web/javascript/reference/global_objects/math/floor/index.md
index 4b9a6e5422..65bc3d23fc 100644
--- a/files/fr/web/javascript/reference/global_objects/math/floor/index.md
+++ b/files/fr/web/javascript/reference/global_objects/math/floor/index.md
@@ -9,89 +9,61 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Math/floor
 original_slug: Web/JavaScript/Reference/Objets_globaux/Math/floor
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La fonction <code><strong>Math.floor(x)</strong></code> renvoie le plus grand entier qui est inférieur ou égal à un nombre <code>x</code>.</p>
+La fonction **`Math.floor(x)`** renvoie le plus grand entier qui est inférieur ou égal à un nombre `x`.
 
-<div>{{EmbedInteractiveExample("pages/js/math-floor.html")}}</div>
+{{EmbedInteractiveExample("pages/js/math-floor.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">Math.floor(<var>x</var>)</pre>
+    Math.floor(x)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>x</code></dt>
- <dd>Un nombre.</dd>
-</dl>
+- `x`
+  - : Un nombre.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un nombre qui représente le plus grand entier inférieur ou égal à la valeur passée en argument.</p>
+Un nombre qui représente le plus grand entier inférieur ou égal à la valeur passée en argument.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p><code>floor()</code> est une méthode statique de l'objet <code>Math</code>, elle doit toujours être utilisée avec la syntaxe  <code>Math.floor()</code>, elle ne doit pas être utilisée avec un autre objet qui aurait été créé (<code>Math</code> n'est pas un constructeur).</p>
+`floor()` est une méthode statique de l'objet `Math`, elle doit toujours être utilisée avec la syntaxe  `Math.floor()`, elle ne doit pas être utilisée avec un autre objet qui aurait été créé (`Math` n'est pas un constructeur).
 
-<div class="blockIndicator note">
-<p><strong>Note :</strong> <code>Math.floor(null)</code> renvoie <code>0</code> et pas {{jsxref("NaN")}}.</p>
-</div>
+> **Note :** `Math.floor(null)` renvoie `0` et pas {{jsxref("NaN")}}.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_Math.floor">Utiliser <code>Math.floor</code></h3>
+### Utiliser `Math.floor`
 
-<pre class="brush:js">Math.floor( 45.95); //  45
+```js
+Math.floor( 45.95); //  45
 Math.floor( 45.05); //  45
 Math.floor(  4   ); //   4
 Math.floor(-45.05); // -46
 Math.floor(-45.95); // -46
 Math.floor(null);   // 0
-</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.0.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.8.2.9', 'Math.floor')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-math.floor', 'Math.floor')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-math.floor', 'Math.floor')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Math.floor")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Math.abs()")}}</li>
- <li>{{jsxref("Math.ceil()")}}</li>
- <li>{{jsxref("Math.round()")}}</li>
- <li>{{jsxref("Math.sign()")}}</li>
- <li>{{jsxref("Math.trunc()")}}</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.8.2.9', 'Math.floor')}}         | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-math.floor', 'Math.floor')}}         | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-math.floor', 'Math.floor')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Math.floor")}}
+
+## Voir aussi
+
+- {{jsxref("Math.abs()")}}
+- {{jsxref("Math.ceil()")}}
+- {{jsxref("Math.round()")}}
+- {{jsxref("Math.sign()")}}
+- {{jsxref("Math.trunc()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/math/fround/index.md b/files/fr/web/javascript/reference/global_objects/math/fround/index.md
index 6b5ec47735..77cf804d99 100644
--- a/files/fr/web/javascript/reference/global_objects/math/fround/index.md
+++ b/files/fr/web/javascript/reference/global_objects/math/fround/index.md
@@ -10,40 +10,39 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Math/fround
 original_slug: Web/JavaScript/Reference/Objets_globaux/Math/fround
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La fonction <code><strong>Math.fround()</strong></code> renvoie le nombre flottant à <a class="external" href="https://en.wikipedia.org/wiki/Single_precision" title="link to the wikipedia page on single precision">précision simple</a> sur 32 bits qui est le plus proche du nombre fourni.</p>
+La fonction **`Math.fround()`** renvoie le nombre flottant à [précision simple](https://en.wikipedia.org/wiki/Single_precision "link to the wikipedia page on single precision") sur 32 bits qui est le plus proche du nombre fourni.
 
-<div>{{EmbedInteractiveExample("pages/js/math-fround.html")}}</div>
+{{EmbedInteractiveExample("pages/js/math-fround.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">Math.fround(<var>x</var>)</pre>
+    Math.fround(x)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>x</code></dt>
- <dd>Un nombre.</dd>
-</dl>
+- `x`
+  - : Un nombre.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Le nombre flottant à précision simple sur 32 bits qui est le plus proche de la valeur fournie en argument.</p>
+Le nombre flottant à précision simple sur 32 bits qui est le plus proche de la valeur fournie en argument.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Un moteur JavaScript utilise des nombres flottant à précision simple sur 64 bits. Cela permet d'obtenir une précision fine. Toutefois, lorsqu'on manipule des valeurs représentées sur 32 bits (par exemple des valeurs extraites d'un {{jsxref("Float32Array")}}) et qu'on souhaite comparer celles-ci avec des valeurs sur 32 bits, on peut obtenir des inégalités alors que les valeurs semblent identiques.</p>
+Un moteur JavaScript utilise des nombres flottant à précision simple sur 64 bits. Cela permet d'obtenir une précision fine. Toutefois, lorsqu'on manipule des valeurs représentées sur 32 bits (par exemple des valeurs extraites d'un {{jsxref("Float32Array")}}) et qu'on souhaite comparer celles-ci avec des valeurs sur 32 bits, on peut obtenir des inégalités alors que les valeurs semblent identiques.
 
-<p>Pour résoudre ce problème, on peut utiliser <code>Math.fround()</code> afin de transformer un nombre représenté sur 64 bits en un nombre représenté sur 32 bits. Pour le moteur JavaScript, la valeur sera toujours représentée sur 64 bits mais elle aura été « arrondie » à partir du 23e bit de la mantisse. Si le nombre passé en argument se situe en dehors de l'intervalle représentable sur 32 bits, la méthode renverra {{jsxref("Infinity")}} ou <code>-Infinity</code>.</p>
+Pour résoudre ce problème, on peut utiliser `Math.fround()` afin de transformer un nombre représenté sur 64 bits en un nombre représenté sur 32 bits. Pour le moteur JavaScript, la valeur sera toujours représentée sur 64 bits mais elle aura été « arrondie » à partir du 23e bit de la mantisse. Si le nombre passé en argument se situe en dehors de l'intervalle représentable sur 32 bits, la méthode renverra {{jsxref("Infinity")}} ou `-Infinity`.
 
-<p><code>fround </code>étant une méthode statique de <code>Math</code>, il faut utiliser <code>Math.<code>fround</code>()</code> et non pas la méthode d'un autre objet qui aurait été créé (<code>Math</code> n'est pas un constructeur).</p>
+`fround `étant une méthode statique de `Math`, il faut utiliser `Math.fround()` et non pas la méthode d'un autre objet qui aurait été créé (`Math` n'est pas un constructeur).
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_Math.fround()">Utiliser <code>Math.fround()</code></h3>
+### Utiliser `Math.fround()`
 
-<pre class="brush: js">Math.fround(0);     // 0
+```js
+Math.fround(0);     // 0
 Math.fround(1);     // 1
 
 // 1.337 ne peut pas être représenté correctement
@@ -51,36 +50,20 @@ Math.fround(1);     // 1
 Math.fround(1.337); // 1.3370000123977661
 
 Math.fround(1.5);   // 1.5
-Math.fround(NaN);   // NaN</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-math.fround', 'Math.fround')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-math.fround', 'Math.fround')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Math.fround")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Math.round()")}}</li>
-</ul>
+Math.fround(NaN);   // NaN
+```
+
+## Spécifications
+
+| Spécification                                                                | État                         | Commentaires         |
+| ---------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ES6', '#sec-math.fround', 'Math.fround')}}     | {{Spec2('ES6')}}         | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-math.fround', 'Math.fround')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Math.fround")}}
+
+## Voir aussi
+
+- {{jsxref("Math.round()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/math/hypot/index.md b/files/fr/web/javascript/reference/global_objects/math/hypot/index.md
index bba9aaebe8..977f6c4965 100644
--- a/files/fr/web/javascript/reference/global_objects/math/hypot/index.md
+++ b/files/fr/web/javascript/reference/global_objects/math/hypot/index.md
@@ -11,59 +11,59 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Math/hypot
 original_slug: Web/JavaScript/Reference/Objets_globaux/Math/hypot
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La fonction <code><strong>Math.hypot()</strong></code> renvoie la racine carrée de la somme des carrés de ses arguments. On peut également la définir avec la formule suivante :</p>
+La fonction **`Math.hypot()`** renvoie la racine carrée de la somme des carrés de ses arguments. On peut également la définir avec la formule suivante :
 
-<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.hypot</mo><mo stretchy="false">(</mo><msub><mi>v</mi><mn>1</mn></msub><mo>,</mo><msub><mi>v</mi><mn>2</mn></msub><mo>,</mo><mo>…</mo><mo>,</mo><msub><mi>v</mi><mi>n</mi></msub><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><msqrt><mrow><munderover><mo>∑</mo><mrow><mi>i</mi><mo>=</mo><mn>1</mn></mrow><mi>n</mi></munderover><msubsup><mi>v</mi><mi>i</mi><mn>2</mn></msubsup></mrow></msqrt><mo>=</mo><msqrt><mrow><msubsup><mi>v</mi><mn>1</mn><mn>2</mn></msubsup><mo>+</mo><msubsup><mi>v</mi><mn>2</mn><mn>2</mn></msubsup><mo>+</mo><mo>…</mo><mo>+</mo><msubsup><mi>v</mi><mi>n</mi><mn>2</mn></msubsup></mrow></msqrt></mrow><annotation encoding="TeX">\mathtt{\operatorname{Math.hypot}(v_1, v_2, \dots, v_n)} = \sqrt{\sum_{i=1}^n v_i^2} = \sqrt{v_1^2 + v_2^2 + \dots + v_n^2}</annotation></semantics></math></p>
+<math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.hypot</mo><mo stretchy="false">(</mo><msub><mi>v</mi><mn>1</mn></msub><mo>,</mo><msub><mi>v</mi><mn>2</mn></msub><mo>,</mo><mo>…</mo><mo>,</mo><msub><mi>v</mi><mi>n</mi></msub><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><msqrt><mrow><munderover><mo>∑</mo><mrow><mi>i</mi><mo>=</mo><mn>1</mn></mrow><mi>n</mi></munderover><msubsup><mi>v</mi><mi>i</mi><mn>2</mn></msubsup></mrow></msqrt><mo>=</mo><msqrt><mrow><msubsup><mi>v</mi><mn>1</mn><mn>2</mn></msubsup><mo>+</mo><msubsup><mi>v</mi><mn>2</mn><mn>2</mn></msubsup><mo>+</mo><mo>…</mo><mo>+</mo><msubsup><mi>v</mi><mi>n</mi><mn>2</mn></msubsup></mrow></msqrt></mrow><annotation encoding="TeX">\mathtt{\operatorname{Math.hypot}(v*1, v_2, \dots, v_n)} = \sqrt{\sum*{i=1}^n v_i^2} = \sqrt{v_1^2 + v_2^2 + \dots + v_n^2}</annotation></semantics></math>
 
-<div>{{EmbedInteractiveExample("pages/js/math-hypot.html")}}</div>
+{{EmbedInteractiveExample("pages/js/math-hypot.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">Math.hypot([valeur<var>1</var>[,<var>valeur2</var>, ...]]) </pre>
+    Math.hypot([valeur1[,valeur2, ...]])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>valeur1, valeur2, ...</code></dt>
- <dd>Des nombres.</dd>
-</dl>
+- `valeur1, valeur2, ...`
+  - : Des nombres.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>La racine carrée de la somme des carrés des arguments. S'il existe un des arguments qui ne peut pas être converti en un nombre, c'est la valeur {{jsxref("NaN")}} qui sera renvoyée.</p>
+La racine carrée de la somme des carrés des arguments. S'il existe un des arguments qui ne peut pas être converti en un nombre, c'est la valeur {{jsxref("NaN")}} qui sera renvoyée.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p><code>hypot()</code> étant une méthode statique de <code>Math</code>, il faut utiliser <code>Math.<code>hypot</code>()</code>et non pas la méthode d'un autre objet qui aurait été créé (<code>Math</code> n'est pas un constructeur).</p>
+`hypot()` étant une méthode statique de `Math`, il faut utiliser `Math.hypot()`et non pas la méthode d'un autre objet qui aurait été créé (`Math` n'est pas un constructeur).
 
-<p>Si aucun argument n'est donné, le résultat sera +0.Si, parmi les arguments, au moins un ne peut pas être converti en un nombre, le résultat sera {{jsxref("NaN")}}.Si cette fonction est utilisée avec un argument : <code>Math.hypot(x)</code> sera équivalente à <code>Math.abs(x)</code>.</p>
+Si aucun argument n'est donné, le résultat sera +0.Si, parmi les arguments, au moins un ne peut pas être converti en un nombre, le résultat sera {{jsxref("NaN")}}.Si cette fonction est utilisée avec un argument : `Math.hypot(x)` sera équivalente à `Math.abs(x)`.
 
-<p>Cette fonction permet entre autres de gérer certains cas où, pour les grands nombres, l'utilisation de {{jsxref("Math.sqrt()")}} aurait renvoyé {{jsxref("Infinity")}} à cause des calculs intermédiaires.</p>
+Cette fonction permet entre autres de gérer certains cas où, pour les grands nombres, l'utilisation de {{jsxref("Math.sqrt()")}} aurait renvoyé {{jsxref("Infinity")}} à cause des calculs intermédiaires.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_Math.hypot()">Utiliser <code>Math.hypot()</code></h3>
+### Utiliser `Math.hypot()`
 
-<pre class="brush:js">Math.hypot(3, 4)        // 5
+```js
+Math.hypot(3, 4)        // 5
 Math.hypot(3, 4, 5)     // 7.0710678118654755
 Math.hypot()            // 0
 Math.hypot(NaN)         // NaN
-Math.hypot(3, 4, "toto") // NaN, +"toto" =&gt; NaN
-Math.hypot(3, 4, "5")   // 7.0710678118654755, +"5" =&gt; 5
+Math.hypot(3, 4, "toto") // NaN, +"toto" => NaN
+Math.hypot(3, 4, "5")   // 7.0710678118654755, +"5" => 5
 Math.hypot(-3)          // 3, the same as Math.abs(-3)
-</pre>
+```
 
-<h2 id="Prothèse_d'émulation_(polyfill)">Prothèse d'émulation (<em>polyfill</em>)</h2>
+## Prothèse d'émulation (_polyfill_)
 
-<p>Si elle n'est pas disponible, cette fonction peut être émulée de la façon suivante :</p>
+Si elle n'est pas disponible, cette fonction peut être émulée de la façon suivante :
 
-<pre class="brush: js">Math.hypot =  Math.hypot || function() {
+```js
+Math.hypot =  Math.hypot || function() {
     var y = 0;
     var length = arguments.length;
 
-    for (var i = 0; i &lt; length; i++) {
+    for (var i = 0; i < length; i++) {
       if(arguments[i] === Infinity || arguments[i] === -Infinity) {
         return Infinity;
       }
@@ -71,56 +71,40 @@ Math.hypot(-3)          // 3, the same as Math.abs(-3)
     }
     return Math.sqrt(y);
 };
-</pre>
+```
 
-<p>Voici une seconde version qui évite les dépassements :</p>
+Voici une seconde version qui évite les dépassements :
 
-<pre class="brush: js">Math.hypot = function (x, y) {
+```js
+Math.hypot = function (x, y) {
   // https://bugzilla.mozilla.org/show_bug.cgi?id=896264#c28
   var max = 0;
   var s = 0;
-  for (var i = 0; i &lt; arguments.length; i += 1) {
+  for (var i = 0; i < arguments.length; i += 1) {
     var arg = Math.abs(Number(arguments[i]));
-    if (arg &gt; max) {
+    if (arg > max) {
       s *= (max / arg) * (max / arg);
       max = arg;
     }
-    s += arg === 0 &amp;&amp; max === 0 ? 0 : (arg / max) * (arg / max);
+    s += arg === 0 && max === 0 ? 0 : (arg / max) * (arg / max);
   }
   return max === 1 / 0 ? 1 / 0 : max * Math.sqrt(s);
 };
-</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-math.hypot', 'Math.hypot')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-math.hypot', 'Math.hypot')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Math.hypot")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Math.abs()")}}</li>
- <li>{{jsxref("Math.pow()")}}</li>
- <li>{{jsxref("Math.sqrt()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                | État                         | Commentaires        |
+| ---------------------------------------------------------------------------- | ---------------------------- | ------------------- |
+| {{SpecName('ES2015', '#sec-math.hypot', 'Math.hypot')}}     | {{Spec2('ES2015')}}     | Définition initiale |
+| {{SpecName('ESDraft', '#sec-math.hypot', 'Math.hypot')}} | {{Spec2('ESDraft')}} |                     |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Math.hypot")}}
+
+## Voir aussi
+
+- {{jsxref("Math.abs()")}}
+- {{jsxref("Math.pow()")}}
+- {{jsxref("Math.sqrt()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/math/imul/index.md b/files/fr/web/javascript/reference/global_objects/math/imul/index.md
index bdfb591384..507c94f070 100644
--- a/files/fr/web/javascript/reference/global_objects/math/imul/index.md
+++ b/files/fr/web/javascript/reference/global_objects/math/imul/index.md
@@ -10,81 +10,66 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Math/imul
 original_slug: Web/JavaScript/Reference/Objets_globaux/Math/imul
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La fonction <code><strong>Math.imul()</strong></code> renvoie le résultat de la multiplication de deux nombres, calculée avec la représentation sur 32 bits de ces nombres, à la façon du langage C.</p>
+La fonction **`Math.imul()`** renvoie le résultat de la multiplication de deux nombres, calculée avec la représentation sur 32 bits de ces nombres, à la façon du langage C.
 
-<div>{{EmbedInteractiveExample("pages/js/math-imul.html")}}</div>
+{{EmbedInteractiveExample("pages/js/math-imul.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">Math.imul(<var>a</var>, <var>b</var>)</pre>
+    Math.imul(a, b)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>a</code></dt>
- <dd>Le premier nombre.</dd>
- <dt><code>b</code></dt>
- <dd>Le second nombre.</dd>
-</dl>
+- `a`
+  - : Le premier nombre.
+- `b`
+  - : Le second nombre.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Le résultat de la multiplication sur 32 bits des valeurs passées en argument (comme en C).</p>
+Le résultat de la multiplication sur 32 bits des valeurs passées en argument (comme en C).
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p><code>Math.imul()</code> permet d'effectuer une multiplication rapide pour des entiers sur 32 bits avec une sémantique proche du langage C. Cela est utile pour des aspects de performance, notamment pour des projets comme <a href="/fr/docs/Mozilla/Projects/Emscripten">Emscripten</a>. <code>imul() </code>étant une méthode statique de <code>Math</code>, il faut utiliser <code>Math.<code>imul</code>()</code> et non pas la méthode d'un autre objet qui aurait été créé (<code>Math</code> n'est pas un constructeur). Attention à l'utilisation de nombres flottants avec <code>Math.imul()</code> car cela implique une opération de conversion des flottants vers les entiers pour la multiplication puis une opération de conversion du résultat en flottant. Dans la pratique, <code>Math</code><code>.imul()</code> est notamment pertinent pour asm.js.</p>
+`Math.imul()` permet d'effectuer une multiplication rapide pour des entiers sur 32 bits avec une sémantique proche du langage C. Cela est utile pour des aspects de performance, notamment pour des projets comme [Emscripten](/fr/docs/Mozilla/Projects/Emscripten). `imul() `étant une méthode statique de `Math`, il faut utiliser `Math.imul()` et non pas la méthode d'un autre objet qui aurait été créé (`Math` n'est pas un constructeur). Attention à l'utilisation de nombres flottants avec `Math.imul()` car cela implique une opération de conversion des flottants vers les entiers pour la multiplication puis une opération de conversion du résultat en flottant. Dans la pratique, ` Math``.imul() ` est notamment pertinent pour asm.js.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_Math.imul()">Utiliser <code>Math.imul()</code></h3>
+### Utiliser `Math.imul()`
 
-<pre class="brush: js">Math.imul(2, 4);          // 8
+```js
+Math.imul(2, 4);          // 8
 Math.imul(-1, 8);         //-8
 Math.imul(-2, -2);        // 4
 Math.imul(0xffffffff, 5); //-5
 Math.imul(0xfffffffe, 5); //-10
-</pre>
+```
 
-<h2 id="Prothèse_d'émulation_(polyfill)">Prothèse d'émulation (<em>polyfill</em>)</h2>
+## Prothèse d'émulation (_polyfill_)
 
-<p>Si elle n'est pas disponible, cette fonction peut être émulée de la façon suivante :</p>
+Si elle n'est pas disponible, cette fonction peut être émulée de la façon suivante :
 
-<pre class="brush: js">Math.imul = Math.imul || function(a, b) {
-  var ah  = (a &gt;&gt;&gt; 16) &amp; 0xffff;
-  var al = a &amp; 0xffff;
-  var bh  = (b &gt;&gt;&gt; 16) &amp; 0xffff;
-  var bl = b &amp; 0xffff;
+```js
+Math.imul = Math.imul || function(a, b) {
+  var ah  = (a >>> 16) & 0xffff;
+  var al = a & 0xffff;
+  var bh  = (b >>> 16) & 0xffff;
+  var bl = b & 0xffff;
   // Le décalage par 0 rétablit le signe de la partie haute
   // le |0 final convertit la valeur non-signée en une valeur signée
-  return ((al * bl) + (((ah * bl + al * bh) &lt;&lt; 16) &gt;&gt;&gt; 0)|0);
+  return ((al * bl) + (((ah * bl + al * bh) << 16) >>> 0)|0);
 };
-</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-math.imul', 'Math.imul')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Définition initiale</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-math.imul', 'Math.imul')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Math.imul")}}</p>
+```
+
+## Spécifications
+
+| Spécification                                                            | État                         | Commentaires        |
+| ------------------------------------------------------------------------ | ---------------------------- | ------------------- |
+| {{SpecName('ES6', '#sec-math.imul', 'Math.imul')}}     | {{Spec2('ES6')}}         | Définition initiale |
+| {{SpecName('ESDraft', '#sec-math.imul', 'Math.imul')}} | {{Spec2('ESDraft')}} |                     |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Math.imul")}}
diff --git a/files/fr/web/javascript/reference/global_objects/math/index.md b/files/fr/web/javascript/reference/global_objects/math/index.md
index 86ab1bee47..f0fd2ba0b4 100644
--- a/files/fr/web/javascript/reference/global_objects/math/index.md
+++ b/files/fr/web/javascript/reference/global_objects/math/index.md
@@ -8,163 +8,138 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Math
 original_slug: Web/JavaScript/Reference/Objets_globaux/Math
 ---
-<div>{{JSRef}}</div>
-
-<p>L'objet <strong><code>Math</code></strong> est un objet natif dont les méthodes et propriétés permettent l'utilisation de constantes et fonctions mathématiques. Cet objet n'est pas une fonction.</p>
-
-<div class="warning">
-<p><strong>Attention :</strong> <code>Math</code> fonctionne avec le type {{jsxref("Number")}}. Il ne fonctionne pas avec les grands entiers/{{jsxref("BigInt")}}.</p>
-</div>
-
-<h2 id="Description">Description</h2>
-
-<p>Contrairement aux autres objets globaux, <code>Math</code> n'est pas un constructeur. Toutes les propriétés et les méthodes de <code>Math</code> sont statiques (pour éventuellement étendre cette API, ce qui est fortement déconseillé, on n'utilisera donc pas <code>Math.prototype</code>).</p>
-
-<p>Pour accéder à la constante PI, on utilise <code>Math.PI</code>.<br>
- Pour accéder à la fonction <em>sinus</em>, on utilise <code>Math.sin(x)</code> où <code>x</code> est l'argument de cette méthode.</p>
-
-<p>Les constantes sont définies avec la précision des nombres réels en JavaScript.</p>
-
-<h2 id="Propriétés">Propriétés</h2>
-
-<dl>
- <dt>{{jsxref("Math.E")}}</dt>
- <dd>Nombre d'Euler, la base des logarithmes naturels, environ 2,718.</dd>
- <dt>{{jsxref("Math.LN2")}}</dt>
- <dd>Logarithme naturel de 2, environ 0,693.</dd>
- <dt>{{jsxref("Math.LN10")}}</dt>
- <dd>Logarithme naturel de 10, environ 2,302.</dd>
- <dt>{{jsxref("Math.LOG2E")}}</dt>
- <dd>Logarithme de base 2 de E, environ 1,442.</dd>
- <dt>{{jsxref("Math.LOG10E")}}</dt>
- <dd>Logarithme de base 10 de E, environ 0,434.</dd>
- <dt>{{jsxref("Math.PI")}}</dt>
- <dd>Quotient de la circonférence d'un cercle par son diamètre, environ 3,14159.</dd>
- <dt>{{jsxref("Math.SQRT1_2")}}</dt>
- <dd>Racine carrée de 1/2 ; équivalent de 1 sur la racine carrée de 2, environ 0,707.</dd>
- <dt>{{jsxref("Math.SQRT2")}}</dt>
- <dd>Racine carrée de 2, environ 1,414.</dd>
-</dl>
-
-<h2 id="Méthodes">Méthodes</h2>
-
-<div class="note"><p><strong>Note :</strong> Les fonctions trigonométriques (<code>sin()</code>, <code>cos()</code>, <code>tan()</code>, <code>asin()</code>, <code>acos()</code>, <code>atan()</code>, <code>atan2()</code>) acceptent ou retournent des angles en radians. Pour convertir des degrés en radians, multipliez la valeur en degrés par (<code>Math.PI / 180</code>). Pour passer des radians en degrés, divisez la valeur en radians par (<code>Math.PI / 180</code>).</p></div>
-
-<div class="note"><p><strong>Note :</strong> La précision des fonctions mathématiques dépend notamment de l'implémentation. Cela signifie que différents navigateurs peuvent fournir des résultats différents. On peut même avoir un même moteur JavaScript qui, sur des architectures et/ou des systèmes d'exploitation différents, fournit des résultats différents.</p></div>
-
-<dl>
- <dt>{{jsxref("Objets_globaux/Math/abs", "Math.abs(x)")}}</dt>
- <dd>Retourne la valeur absolue d'un nombre.</dd>
- <dt>{{jsxref("Objets_globaux/Math/acos", "Math.acos(x)")}}</dt>
- <dd>Retourne l'arc cosinus d'un nombre.</dd>
- <dt>{{jsxref("Objets_globaux/Math/acosh", "Math.acosh(x)")}}</dt>
- <dd>Retourne l'arc cosinus hyperbolique d'un nombre.</dd>
- <dt>{{jsxref("Objets_globaux/Math/asin", "Math.asin(x)")}}</dt>
- <dd>Retourne l'arc sinus d'un nombre.</dd>
- <dt>{{jsxref("Objets_globaux/Math/asinh", "Math.asinh(x)")}}</dt>
- <dd>Retourne l'arc sinus hyperbolique d'un nombre.</dd>
- <dt>{{jsxref("Objets_globaux/Math/atan", "Math.atan(x)")}}</dt>
- <dd>Retourne l'arc tangente d'un nombre.</dd>
- <dt>{{jsxref("Objets_globaux/Math/atanh", "Math.atanh(x)")}}</dt>
- <dd>Retourne l'arc tangente hyperbolique d'un nombre</dd>
- <dt>{{jsxref("Objets_globaux/Math/atan2", "Math.atan2(y, x)")}}</dt>
- <dd>Retourne l'arc tangente du quotient de ses arguments.</dd>
- <dt>{{jsxref("Objets_globaux/Math/cbrt", "Math.cbrt(x)")}}</dt>
- <dd>Renvoie la racine cubique d'un nombre.</dd>
- <dt>{{jsxref("Objets_globaux/Math/ceil", "Math.ceil(x)")}}</dt>
- <dd>Retourne le plus petit entier supérieur ou égal à la valeur passée en paramètre.</dd>
- <dt>{{jsxref("Objets_globaux/Math/clz32", "Math.clz32(x)")}}</dt>
- <dd>Renvoie le nombre de zéros qui préfixent un entier sur 32 bits.</dd>
- <dt>{{jsxref("Objets_globaux/Math/cos", "Math.cos(x)")}}</dt>
- <dd>Retourne le cosinus d'un nombre.</dd>
- <dt>{{jsxref("Objets_globaux/Math/cosh", "Math.cosh(x)")}}</dt>
- <dd>Renvoie le cosinus hyperbolique d'un nombre.</dd>
- <dt>{{jsxref("Objets_globaux/Math/exp", "Math.exp(x)")}}</dt>
- <dd>Renvoie l'exponentielle d'un nombre (soit E^nombre) avec E la constante d'Euler (2,718...).</dd>
- <dt>{{jsxref("Objets_globaux/Math/expm1", "Math.expm1(x)")}}</dt>
- <dd>Renvoie le résultat de 1 moins l'exponentielle d'un nombre.</dd>
- <dt>{{jsxref("Objets_globaux/Math/floor", "Math.floor(x)")}}</dt>
- <dd>Retourne le plus grand entier inférieur ou égal à la valeur passée en paramètre.</dd>
- <dt>{{jsxref("Objets_globaux/Math/fround", "Math.fround(x)")}}</dt>
- <dd>Renvoie le nombre flottant exprimé sur 32 bits le plus proche de l'argument.</dd>
- <dt>{{jsxref("Objets_globaux/Math/hypot", "Math.hypot([x[,y[,…]]])")}}</dt>
- <dd>Retourne la racine carré de la somme des carrés des arguments.</dd>
- <dt>{{jsxref("Objets_globaux/Math/imul", "Math.imul(x, y)")}}</dt>
- <dd>Retourne le résultat de la multiplication d'entiers sur 32 bits.</dd>
- <dt>{{jsxref("Objets_globaux/Math/log", "Math.log(x)")}}</dt>
- <dd>Retourne le logarithme naturel (log<sub>e</sub>) d'un nombre.</dd>
- <dt>{{jsxref("Objets_globaux/Math/log1p", "Math.log1p(x)")}}</dt>
- <dd>Retourne le logarithme naturel de 1 + un nombre.</dd>
- <dt>{{jsxref("Objets_globaux/Math/log10", "Math.log10(x)")}}</dt>
- <dd>Retourne le logarithme en base 10 d'un nombre.</dd>
- <dt>{{jsxref("Objets_globaux/Math/log2", "Math.log2(x)")}}</dt>
- <dd>Retourne le logarithme en base 2 d'un nombre.</dd>
- <dt>{{jsxref("Objets_globaux/Math/max", "Math.max([x[,y[,…]]])")}}</dt>
- <dd>Retourne la plus grande valeur d'une liste de nombres.</dd>
- <dt>{{jsxref("Objets_globaux/Math/min", "Math.min([x[,y[,…]]])")}}</dt>
- <dd>Retourne la plus petite valeur d'une liste de nombres.</dd>
- <dt>{{jsxref("Objets_globaux/Math/pow", "Math.pow(x,y)")}}</dt>
- <dd>Retourne le calcul de x à la puissance y (x correspond à la base et y à l'exposant).</dd>
- <dt>{{jsxref("Objets_globaux/Math/random", "Math.random()")}}</dt>
- <dd>Retourne un nombre pseudo-aléatoire compris entre 0 (inclus) et 1 (exclu).</dd>
- <dt>{{jsxref("Objets_globaux/Math/round", "Math.round(x)")}}</dt>
- <dd>Retourne l'arrondi d'un nombre.</dd>
- <dt>{{jsxref("Objets_globaux/Math/sign", "Math.sign(x)")}}</dt>
- <dd>Retourne le signe d'un nombre, indiquant s'il est positif, négatif ou égal à zéro.</dd>
- <dt>{{jsxref("Objets_globaux/Math/sin", "Math.sin(x)")}}</dt>
- <dd>Retourne le sinus d'un nombre.</dd>
- <dt>{{jsxref("Objets_globaux/Math/sinh", "Math.sinh(x)")}}</dt>
- <dd>Retourne le sinus hyperbolique d'un nombre.</dd>
- <dt>{{jsxref("Objets_globaux/Math/sqrt", "Math.sqrt(x)")}}</dt>
- <dd>Retourne la racine carrée d'un nombre.</dd>
- <dt>{{jsxref("Objets_globaux/Math/tan", "Math.tan(x)")}}</dt>
- <dd>Retourne la tangente d'un nombre.</dd>
- <dt>{{jsxref("Objets_globaux/Math/tanh", "Math.tanh(x)")}}</dt>
- <dd>Retourne la tangente hyperbolique d'un nombre</dd>
- <dt><code>Math.toSource()</code> {{Non-standard_inline}}</dt>
- <dd>Renvoie la chaîne de caractères <code>"Math"</code>.</dd>
- <dt>{{jsxref("Objets_globaux/Math/trunc", "Math.trunc(x)")}}</dt>
- <dd>Retourne la partie entière d'un nombre (la partie décimale est retirée).</dd>
-</dl>
-
-<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.8', 'Math')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-math-object', 'Math')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Nouvelles méthodes ajoutées : {{jsxref("Math.log10()", "log10()")}}, {{jsxref("Math.log2()", "log2()")}}, {{jsxref("Math.log1p()", "log1p()")}}, {{jsxref("Math.expm1()", "expm1()")}}, {{jsxref("Math.cosh()", "cosh()")}}, {{jsxref("Math.sinh()", "sinh()")}}, {{jsxref("Math.tanh()", "tanh()")}}, {{jsxref("Math.acosh()", "acosh()")}}, {{jsxref("Math.asinh()", "asinh()")}}, {{jsxref("Math.atanh()", "atanh()")}}, {{jsxref("Math.hypot()", "hypot()")}}, {{jsxref("Math.trunc()", "trunc()")}}, {{jsxref("Math.sign()", "sign()")}}, {{jsxref("Math.imul()", "imul()")}}, {{jsxref("Math.fround()", "fround()")}}, {{jsxref("Math.cbrt()", "cbrt()")}} et {{jsxref("Math.clz32()", "clz32()")}}.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-math-object', 'Math')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Math")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Number")}}</li>
-</ul>
+{{JSRef}}
+
+L'objet **`Math`** est un objet natif dont les méthodes et propriétés permettent l'utilisation de constantes et fonctions mathématiques. Cet objet n'est pas une fonction.
+
+> **Attention :** `Math` fonctionne avec le type {{jsxref("Number")}}. Il ne fonctionne pas avec les grands entiers/{{jsxref("BigInt")}}.
+
+## Description
+
+Contrairement aux autres objets globaux, `Math` n'est pas un constructeur. Toutes les propriétés et les méthodes de `Math` sont statiques (pour éventuellement étendre cette API, ce qui est fortement déconseillé, on n'utilisera donc pas `Math.prototype`).
+
+Pour accéder à la constante PI, on utilise `Math.PI`.
+Pour accéder à la fonction _sinus_, on utilise `Math.sin(x)` où `x` est l'argument de cette méthode.
+
+Les constantes sont définies avec la précision des nombres réels en JavaScript.
+
+## Propriétés
+
+- {{jsxref("Math.E")}}
+  - : Nombre d'Euler, la base des logarithmes naturels, environ 2,718.
+- {{jsxref("Math.LN2")}}
+  - : Logarithme naturel de 2, environ 0,693.
+- {{jsxref("Math.LN10")}}
+  - : Logarithme naturel de 10, environ 2,302.
+- {{jsxref("Math.LOG2E")}}
+  - : Logarithme de base 2 de E, environ 1,442.
+- {{jsxref("Math.LOG10E")}}
+  - : Logarithme de base 10 de E, environ 0,434.
+- {{jsxref("Math.PI")}}
+  - : Quotient de la circonférence d'un cercle par son diamètre, environ 3,14159.
+- {{jsxref("Math.SQRT1_2")}}
+  - : Racine carrée de 1/2 ; équivalent de 1 sur la racine carrée de 2, environ 0,707.
+- {{jsxref("Math.SQRT2")}}
+  - : Racine carrée de 2, environ 1,414.
+
+## Méthodes
+
+> **Note :** Les fonctions trigonométriques (`sin()`, `cos()`, `tan()`, `asin()`, `acos()`, `atan()`, `atan2()`) acceptent ou retournent des angles en radians. Pour convertir des degrés en radians, multipliez la valeur en degrés par (`Math.PI / 180`). Pour passer des radians en degrés, divisez la valeur en radians par (`Math.PI / 180`).
+
+> **Note :** La précision des fonctions mathématiques dépend notamment de l'implémentation. Cela signifie que différents navigateurs peuvent fournir des résultats différents. On peut même avoir un même moteur JavaScript qui, sur des architectures et/ou des systèmes d'exploitation différents, fournit des résultats différents.
+
+- {{jsxref("Objets_globaux/Math/abs", "Math.abs(x)")}}
+  - : Retourne la valeur absolue d'un nombre.
+- {{jsxref("Objets_globaux/Math/acos", "Math.acos(x)")}}
+  - : Retourne l'arc cosinus d'un nombre.
+- {{jsxref("Objets_globaux/Math/acosh", "Math.acosh(x)")}}
+  - : Retourne l'arc cosinus hyperbolique d'un nombre.
+- {{jsxref("Objets_globaux/Math/asin", "Math.asin(x)")}}
+  - : Retourne l'arc sinus d'un nombre.
+- {{jsxref("Objets_globaux/Math/asinh", "Math.asinh(x)")}}
+  - : Retourne l'arc sinus hyperbolique d'un nombre.
+- {{jsxref("Objets_globaux/Math/atan", "Math.atan(x)")}}
+  - : Retourne l'arc tangente d'un nombre.
+- {{jsxref("Objets_globaux/Math/atanh", "Math.atanh(x)")}}
+  - : Retourne l'arc tangente hyperbolique d'un nombre
+- {{jsxref("Objets_globaux/Math/atan2", "Math.atan2(y, x)")}}
+  - : Retourne l'arc tangente du quotient de ses arguments.
+- {{jsxref("Objets_globaux/Math/cbrt", "Math.cbrt(x)")}}
+  - : Renvoie la racine cubique d'un nombre.
+- {{jsxref("Objets_globaux/Math/ceil", "Math.ceil(x)")}}
+  - : Retourne le plus petit entier supérieur ou égal à la valeur passée en paramètre.
+- {{jsxref("Objets_globaux/Math/clz32", "Math.clz32(x)")}}
+  - : Renvoie le nombre de zéros qui préfixent un entier sur 32 bits.
+- {{jsxref("Objets_globaux/Math/cos", "Math.cos(x)")}}
+  - : Retourne le cosinus d'un nombre.
+- {{jsxref("Objets_globaux/Math/cosh", "Math.cosh(x)")}}
+  - : Renvoie le cosinus hyperbolique d'un nombre.
+- {{jsxref("Objets_globaux/Math/exp", "Math.exp(x)")}}
+  - : Renvoie l'exponentielle d'un nombre (soit E^nombre) avec E la constante d'Euler (2,718...).
+- {{jsxref("Objets_globaux/Math/expm1", "Math.expm1(x)")}}
+  - : Renvoie le résultat de 1 moins l'exponentielle d'un nombre.
+- {{jsxref("Objets_globaux/Math/floor", "Math.floor(x)")}}
+  - : Retourne le plus grand entier inférieur ou égal à la valeur passée en paramètre.
+- {{jsxref("Objets_globaux/Math/fround", "Math.fround(x)")}}
+  - : Renvoie le nombre flottant exprimé sur 32 bits le plus proche de l'argument.
+- {{jsxref("Objets_globaux/Math/hypot", "Math.hypot([x[,y[,…]]])")}}
+  - : Retourne la racine carré de la somme des carrés des arguments.
+- {{jsxref("Objets_globaux/Math/imul", "Math.imul(x, y)")}}
+  - : Retourne le résultat de la multiplication d'entiers sur 32 bits.
+- {{jsxref("Objets_globaux/Math/log", "Math.log(x)")}}
+
+  - : Retourne le logarithme naturel (log
+
+    <sub>e</sub>
+
+    ) d'un nombre.
+
+- {{jsxref("Objets_globaux/Math/log1p", "Math.log1p(x)")}}
+  - : Retourne le logarithme naturel de 1 + un nombre.
+- {{jsxref("Objets_globaux/Math/log10", "Math.log10(x)")}}
+  - : Retourne le logarithme en base 10 d'un nombre.
+- {{jsxref("Objets_globaux/Math/log2", "Math.log2(x)")}}
+  - : Retourne le logarithme en base 2 d'un nombre.
+- {{jsxref("Objets_globaux/Math/max", "Math.max([x[,y[,…]]])")}}
+  - : Retourne la plus grande valeur d'une liste de nombres.
+- {{jsxref("Objets_globaux/Math/min", "Math.min([x[,y[,…]]])")}}
+  - : Retourne la plus petite valeur d'une liste de nombres.
+- {{jsxref("Objets_globaux/Math/pow", "Math.pow(x,y)")}}
+  - : Retourne le calcul de x à la puissance y (x correspond à la base et y à l'exposant).
+- {{jsxref("Objets_globaux/Math/random", "Math.random()")}}
+  - : Retourne un nombre pseudo-aléatoire compris entre 0 (inclus) et 1 (exclu).
+- {{jsxref("Objets_globaux/Math/round", "Math.round(x)")}}
+  - : Retourne l'arrondi d'un nombre.
+- {{jsxref("Objets_globaux/Math/sign", "Math.sign(x)")}}
+  - : Retourne le signe d'un nombre, indiquant s'il est positif, négatif ou égal à zéro.
+- {{jsxref("Objets_globaux/Math/sin", "Math.sin(x)")}}
+  - : Retourne le sinus d'un nombre.
+- {{jsxref("Objets_globaux/Math/sinh", "Math.sinh(x)")}}
+  - : Retourne le sinus hyperbolique d'un nombre.
+- {{jsxref("Objets_globaux/Math/sqrt", "Math.sqrt(x)")}}
+  - : Retourne la racine carrée d'un nombre.
+- {{jsxref("Objets_globaux/Math/tan", "Math.tan(x)")}}
+  - : Retourne la tangente d'un nombre.
+- {{jsxref("Objets_globaux/Math/tanh", "Math.tanh(x)")}}
+  - : Retourne la tangente hyperbolique d'un nombre
+- `Math.toSource()` {{Non-standard_inline}}
+  - : Renvoie la chaîne de caractères `"Math"`.
+- {{jsxref("Objets_globaux/Math/trunc", "Math.trunc(x)")}}
+  - : Retourne la partie entière d'un nombre (la partie décimale est retirée).
+
+## 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.8', 'Math')}}             | {{Spec2('ES5.1')}}     |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| {{SpecName('ES6', '#sec-math-object', 'Math')}}     | {{Spec2('ES6')}}         | Nouvelles méthodes ajoutées : {{jsxref("Math.log10()", "log10()")}}, {{jsxref("Math.log2()", "log2()")}}, {{jsxref("Math.log1p()", "log1p()")}}, {{jsxref("Math.expm1()", "expm1()")}}, {{jsxref("Math.cosh()", "cosh()")}}, {{jsxref("Math.sinh()", "sinh()")}}, {{jsxref("Math.tanh()", "tanh()")}}, {{jsxref("Math.acosh()", "acosh()")}}, {{jsxref("Math.asinh()", "asinh()")}}, {{jsxref("Math.atanh()", "atanh()")}}, {{jsxref("Math.hypot()", "hypot()")}}, {{jsxref("Math.trunc()", "trunc()")}}, {{jsxref("Math.sign()", "sign()")}}, {{jsxref("Math.imul()", "imul()")}}, {{jsxref("Math.fround()", "fround()")}}, {{jsxref("Math.cbrt()", "cbrt()")}} et {{jsxref("Math.clz32()", "clz32()")}}. |
+| {{SpecName('ESDraft', '#sec-math-object', 'Math')}} | {{Spec2('ESDraft')}} |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Math")}}
+
+## Voir aussi
+
+- {{jsxref("Number")}}
diff --git a/files/fr/web/javascript/reference/global_objects/math/ln10/index.md b/files/fr/web/javascript/reference/global_objects/math/ln10/index.md
index f3818a3665..2dc07d7187 100644
--- a/files/fr/web/javascript/reference/global_objects/math/ln10/index.md
+++ b/files/fr/web/javascript/reference/global_objects/math/ln10/index.md
@@ -9,74 +9,47 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Math/LN10
 original_slug: Web/JavaScript/Reference/Objets_globaux/Math/LN10
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La propriété <code><strong>Math.LN10</strong></code> représente la valeur du logarithme naturel de 10, environ 2.302 :</p>
+La propriété **`Math.LN10`** représente la valeur du logarithme naturel de 10, environ 2.302 :
 
-<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.LN10</mi></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">ln</mo><mo stretchy="false">(</mo><mn>10</mn><mo stretchy="false">)</mo><mo>≈</mo><mn>2.302</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.LN10}} = \ln(10) \approx 2.302</annotation></semantics></math></p>
+<math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.LN10</mi></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">ln</mo><mo stretchy="false">(</mo><mn>10</mn><mo stretchy="false">)</mo><mo>≈</mo><mn>2.302</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.LN10}} = \ln(10) \approx 2.302</annotation></semantics></math>
 
-<div>{{EmbedInteractiveExample("pages/js/math-ln10.html")}}</div>
+{{EmbedInteractiveExample("pages/js/math-ln10.html")}}{{js_property_attributes(0,0,0)}}
 
+## Description
 
+`LN10` est une propriété statique de `Math`, elle doit toujours être utilisée avec la syntaxe `Math.LN10`, et ne pas être appelée comme propriété d'un autre objet qui aurait été créé (`Math` n'est pas un constructeur).
 
-<div>{{js_property_attributes(0,0,0)}}</div>
+## Exemples
 
-<h2 id="Description">Description</h2>
+### Utiliser `Math.LN10`
 
-<p><code>LN10</code> est une propriété statique de <code>Math</code>, elle doit toujours être utilisée avec la syntaxe <code>Math.LN10</code>, et ne pas être appelée comme propriété d'un autre objet qui aurait été créé (<code>Math</code> n'est pas un constructeur).</p>
+La fonction suivante renvoie le logarithme naturel de 10 :
 
-<h2 id="Exemples">Exemples</h2>
+```js
+function getNatLog10() {
+   return Math.LN10;
+}
 
-<h3 id="Utiliser_Math.LN10">Utiliser <code>Math.LN10</code></h3>
+getNatLog10(); // 2.302585092994046
+```
 
-<p>La fonction suivante renvoie le logarithme naturel de 10 :</p>
+## Spécifications
 
-<pre class="brush:js">function getNatLog10() {
-   return Math.LN10;
-}
+| Spécification                                                            | Statut                       | Commentaires                                          |
+| ------------------------------------------------------------------------ | ---------------------------- | ----------------------------------------------------- |
+| {{SpecName('ES1')}}                                                 | {{Spec2('ES1')}}         | Définition initiale. Implémentée avec JavaScript 1.0. |
+| {{SpecName('ES5.1', '#sec-15.8.1.2', 'Math.LN10')}}     | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-math.ln10', 'Math.LN10')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-math.ln10', 'Math.LN10')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Math.LN10")}}
+
+## Voir aussi
 
-getNatLog10(); // 2.302585092994046</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. Implémentée avec JavaScript 1.0.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.8.1.2', 'Math.LN10')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-math.ln10', 'Math.LN10')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-math.ln10', 'Math.LN10')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Math.LN10")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Math.exp()")}}</li>
- <li>{{jsxref("Math.log()")}}</li>
- <li>{{jsxref("Math.log10()")}}</li>
-</ul>
+- {{jsxref("Math.exp()")}}
+- {{jsxref("Math.log()")}}
+- {{jsxref("Math.log10()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/math/ln2/index.md b/files/fr/web/javascript/reference/global_objects/math/ln2/index.md
index 0a7fc56029..25019b09ca 100644
--- a/files/fr/web/javascript/reference/global_objects/math/ln2/index.md
+++ b/files/fr/web/javascript/reference/global_objects/math/ln2/index.md
@@ -9,74 +9,47 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Math/LN2
 original_slug: Web/JavaScript/Reference/Objets_globaux/Math/LN2
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La propriété <code><strong>Math.LN2</strong></code> représente le logarithme naturel de 2, environ 0.693:</p>
+La propriété **`Math.LN2`** représente le logarithme naturel de 2, environ 0.693:
 
-<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.LN2</mi></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">ln</mo><mo stretchy="false">(</mo><mn>2</mn><mo stretchy="false">)</mo><mo>≈</mo><mn>0.693</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.LN2}} = \ln(2) \approx 0.693</annotation></semantics></math></p>
+<math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.LN2</mi></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">ln</mo><mo stretchy="false">(</mo><mn>2</mn><mo stretchy="false">)</mo><mo>≈</mo><mn>0.693</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.LN2}} = \ln(2) \approx 0.693</annotation></semantics></math>
 
-<div>{{EmbedInteractiveExample("pages/js/math-ln2.html")}}</div>
+{{EmbedInteractiveExample("pages/js/math-ln2.html")}}{{js_property_attributes(0,0,0)}}
 
+## Description
 
+`LN2` est une propriété statique de l'objet `Math`, il doit toujours être utilisé avec la syntaxe `Math.LN2`, et non pas être utilisé comme la propriété d'un objet qui aurait été créé (`Math` n'est pas un constructeur).
 
-<div>{{js_property_attributes(0,0,0)}}</div>
+## Exemples
 
-<h2 id="Description">Description</h2>
+### Utiliser `Math.LN2`
 
-<p><code>LN2</code> est une propriété statique de l'objet <code>Math</code>, il doit toujours être utilisé avec la syntaxe <code>Math.LN2</code>, et non pas être utilisé comme la propriété d'un objet qui aurait été créé (<code>Math</code> n'est pas un constructeur).</p>
+La fonction suivante renvoie le logarithme en base 2 d'un nombre en utilisant la valeur de `Math.LN2` :
 
-<h2 id="Exemples">Exemples</h2>
+```js
+function getLog2(x) {
+  return Math.log(x) / Math.LN2;
+}
 
-<h3 id="Utiliser_Math.LN2">Utiliser <code>Math.LN2</code></h3>
+getLog2(256); // 8
+```
 
-<p>La fonction suivante renvoie le logarithme en base 2 d'un nombre en utilisant la valeur de <code>Math.LN2</code> :</p>
+## Spécifications
 
-<pre class="brush:js">function getLog2(x) {
-  return Math.log(x) / Math.LN2;
-}
+| Spécification                                                        | Statut                       | Commentaires                                          |
+| -------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- |
+| {{SpecName('ES1')}}                                             | {{Spec2('ES1')}}         | Définition initiale. Implémentée avec JavaScript 1.0. |
+| {{SpecName('ES5.1', '#sec-15.8.1.3', 'Math.LN2')}} | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-math.ln2', 'Math.LN2')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-math.ln2', 'Math.LN2')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Math.LN2")}}
+
+## Voir aussi
 
-getLog2(256); // 8</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. Implémentée avec JavaScript 1.0.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.8.1.3', 'Math.LN2')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-math.ln2', 'Math.LN2')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-math.ln2', 'Math.LN2')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Math.LN2")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Math.exp()")}}</li>
- <li>{{jsxref("Math.log()")}}</li>
- <li>{{jsxref("Math.log2()")}}</li>
-</ul>
+- {{jsxref("Math.exp()")}}
+- {{jsxref("Math.log()")}}
+- {{jsxref("Math.log2()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/math/log/index.md b/files/fr/web/javascript/reference/global_objects/math/log/index.md
index 25d7a48e8b..14c55bd91d 100644
--- a/files/fr/web/javascript/reference/global_objects/math/log/index.md
+++ b/files/fr/web/javascript/reference/global_objects/math/log/index.md
@@ -9,96 +9,73 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Math/log
 original_slug: Web/JavaScript/Reference/Objets_globaux/Math/log
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La fonction <code><strong>Math.log()</strong></code> renvoie le logarithme naturel (aussi appelé logarithme népérien) d'un nombre, défini par :</p>
+La fonction **`Math.log()`** renvoie le logarithme naturel (aussi appelé logarithme népérien) d'un nombre, défini par :
 
-<p><math display="block"><semantics><mrow><mo>∀</mo><mi>x</mi><mo>&gt;</mo><mn>0</mn><mo>,</mo><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.log</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">ln</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext>le seul </mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mspace width="thickmathspace"></mspace><mtext>tel que</mtext><mspace width="thickmathspace"></mspace><msup><mi>e</mi><mi>y</mi></msup><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\forall x &gt; 0, \mathtt{\operatorname{Math.log}(x)} = \ln(x) = \text{the unique} \; y \; \text{such that} \; e^y = x</annotation></semantics></math></p>
+<math display="block"><semantics><mrow><mo>∀</mo><mi>x</mi><mo>></mo><mn>0</mn><mo>,</mo><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.log</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">ln</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext>le seul </mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mspace width="thickmathspace"></mspace><mtext>tel que</mtext><mspace width="thickmathspace"></mspace><msup><mi>e</mi><mi>y</mi></msup><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\forall x > 0, \mathtt{\operatorname{Math.log}(x)} = \ln(x) = \text{the unique} \; y \; \text{such that} \; e^y = x</annotation></semantics></math>
 
-<div>{{EmbedInteractiveExample("pages/js/math-log.html")}}</div>
+{{EmbedInteractiveExample("pages/js/math-log.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">Math.log(<em>x</em>)</pre>
+    Math.log(x)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>x</code></dt>
- <dd>Un nombre.</dd>
-</dl>
+- `x`
+  - : Un nombre.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Le logarithme naturelle de la valeur passée en argument. Si cette valeur est négative, c'est {{jsxref("NaN")}} qui est renvoyé.</p>
+Le logarithme naturelle de la valeur passée en argument. Si cette valeur est négative, c'est {{jsxref("NaN")}} qui est renvoyé.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Si la valeur de l'argument est négative, la valeur renvoyée sera {{jsxref("NaN")}}. Si la valeur de l'argument est <code>0</code>, la valeur de retour sera {{jsxref("Number.NEGATIVE_INFINITY", "-Infinity")}}.</p>
+Si la valeur de l'argument est négative, la valeur renvoyée sera {{jsxref("NaN")}}. Si la valeur de l'argument est `0`, la valeur de retour sera {{jsxref("Number.NEGATIVE_INFINITY", "-Infinity")}}.
 
-<p><code>log()</code> est une méthode statique de <code>Math</code>, elle doit toujours être utilisée avec la syntaxe <code>Math.log()</code>, elle ne doit pas être utilisée à partir d'un autre objet qui aurait été créé (<code>Math</code> n'est pas un constructeur). Si on veut utiliser les constantes données par les logarithmes naturels de 2 ou 10, on pourra utiliser les constantes {{jsxref("Math.LN2")}} ou {{jsxref("Math.LN10")}}. De même pour les logarithmes en base 2 ou en base 10, on pourra utiliser {{jsxref("Math.log2()")}} or {{jsxref("Math.log10()")}}.</p>
+`log()` est une méthode statique de `Math`, elle doit toujours être utilisée avec la syntaxe `Math.log()`, elle ne doit pas être utilisée à partir d'un autre objet qui aurait été créé (`Math` n'est pas un constructeur). Si on veut utiliser les constantes données par les logarithmes naturels de 2 ou 10, on pourra utiliser les constantes {{jsxref("Math.LN2")}} ou {{jsxref("Math.LN10")}}. De même pour les logarithmes en base 2 ou en base 10, on pourra utiliser {{jsxref("Math.log2()")}} or {{jsxref("Math.log10()")}}.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_Math.log()">Utiliser <code>Math.log()</code></h3>
+### Utiliser `Math.log()`
 
-<pre class="brush:js">Math.log(-1); // NaN, valeur en dehors de l'intervalle de définition
+```js
+Math.log(-1); // NaN, valeur en dehors de l'intervalle de définition
 Math.log(0);  // -Infinity
 Math.log(1);  // 0
-Math.log(10); // 2.302585092994046</pre>
+Math.log(10); // 2.302585092994046
+```
 
-<h3 id="Utiliser_Math.log_pour_construire_un_logarithme_sur_une_autre_base">Utiliser <code>Math.log</code> pour construire un logarithme sur une autre base</h3>
+### Utiliser `Math.log` pour construire un logarithme sur une autre base
 
-<p>La fonction suivante renvoie le logarithme de <code>y</code> en base <code>x</code> (c'est-à-dire log<sub>x</sub> y):</p>
+La fonction suivante renvoie le logarithme de `y` en base `x` (c'est-à-dire log<sub>x</sub> y):
 
-<pre class="brush:js">function getBaseLog(x, y) {
+```js
+function getBaseLog(x, y) {
     return Math.log(y) / Math.log(x);
-}</pre>
-
-<p>Si on exécute <code>getBaseLog(10, 1000)</code>, on obtiendra <code>2.9999999999999996</code> en raison de l'arrondi du à la représentation en nombre flottant (le résultat exact étant 3).</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.0.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.8.2.10', 'Math.log')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-math.log', 'Math.log')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-math.log', 'Math.log')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Math.log")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Math.exp()")}}</li>
- <li>{{jsxref("Math.log1p()")}}</li>
- <li>{{jsxref("Math.log10()")}}</li>
- <li>{{jsxref("Math.log2()")}}</li>
- <li>{{jsxref("Math.pow()")}}</li>
-</ul>
+}
+```
+
+Si on exécute `getBaseLog(10, 1000)`, on obtiendra `2.9999999999999996` en raison de l'arrondi du à la représentation en nombre flottant (le résultat exact étant 3).
+
+## 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.8.2.10', 'Math.log')}} | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-math.log', 'Math.log')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-math.log', 'Math.log')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Math.log")}}
+
+## Voir aussi
+
+- {{jsxref("Math.exp()")}}
+- {{jsxref("Math.log1p()")}}
+- {{jsxref("Math.log10()")}}
+- {{jsxref("Math.log2()")}}
+- {{jsxref("Math.pow()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/math/log10/index.md b/files/fr/web/javascript/reference/global_objects/math/log10/index.md
index d0e65dca47..763738f700 100644
--- a/files/fr/web/javascript/reference/global_objects/math/log10/index.md
+++ b/files/fr/web/javascript/reference/global_objects/math/log10/index.md
@@ -11,87 +11,70 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Math/log10
 original_slug: Web/JavaScript/Reference/Objets_globaux/Math/log10
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La fonction <code><strong>Math.log10()</strong></code> renvoie le logarithme en base 10 d'un nombre, donné par la formule :</p>
+La fonction **`Math.log10()`** renvoie le logarithme en base 10 d'un nombre, donné par la formule :
 
-<p><math><semantics><mrow><mo>∀</mo><mi>x</mi><mo>&gt;</mo><mn>0</mn><mo>,</mo><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.log10</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><msub><mo lspace="0em" rspace="0em">log</mo><mn>10</mn></msub><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext>l'unique  </mtext><mi>y</mi><mspace width="thickmathspace"></mspace><mtext>tel que</mtext><mspace width="thickmathspace"></mspace><msup><mn>10</mn><mi>y</mi></msup><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\forall x &gt; 0, \mathtt{\operatorname{Math.log10}(x)} = \log_10(x) = \text{the unique} \; y \; \text{such that} \; 10^y = x</annotation></semantics></math></p>
+<math><semantics><mrow><mo>∀</mo><mi>x</mi><mo>></mo><mn>0</mn><mo>,</mo><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.log10</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><msub><mo lspace="0em" rspace="0em">log</mo><mn>10</mn></msub><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext>l'unique  </mtext><mi>y</mi><mspace width="thickmathspace"></mspace><mtext>tel que</mtext><mspace width="thickmathspace"></mspace><msup><mn>10</mn><mi>y</mi></msup><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\forall x > 0, \mathtt{\operatorname{Math.log10}(x)} = \log_10(x) = \text{the unique} \; y \; \text{such that} \; 10^y = x</annotation></semantics></math>
 
-<div>{{EmbedInteractiveExample("pages/js/math-log10.html")}}</div>
+{{EmbedInteractiveExample("pages/js/math-log10.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">Math.log10(<var>x</var>)</pre>
+    Math.log10(x)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>x</code></dt>
- <dd>Un nombre.</dd>
-</dl>
+- `x`
+  - : Un nombre.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Le logarithme en base 10 du nombre passé en argument. Si cette valeur est négative, c'est {{jsxref("NaN")}} qui sera renvoyé.</p>
+Le logarithme en base 10 du nombre passé en argument. Si cette valeur est négative, c'est {{jsxref("NaN")}} qui sera renvoyé.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Si la valeur de l'argument est strictement inférieure à 0, la valeur renvoyée à {{jsxref("NaN")}}.</p>
+Si la valeur de l'argument est strictement inférieure à 0, la valeur renvoyée à {{jsxref("NaN")}}.
 
-<p><code>log10()</code> étant une méthode statique de <code>Math</code>, il faut utiliser <code>Math.<code>log10</code>()</code>et non pas la méthode d'un autre objet qui aurait été créé (<code>Math</code> n'est pas un constructeur). Cette fonction est équivalente à la fonction donnée par <code>Math.log(x) / Math.log(10)</code>.</p>
+`log10()` étant une méthode statique de `Math`, il faut utiliser `Math.log10()`et non pas la méthode d'un autre objet qui aurait été créé (`Math` n'est pas un constructeur). Cette fonction est équivalente à la fonction donnée par `Math.log(x) / Math.log(10)`.
 
-<h2 id="Exemple">Exemple</h2>
+## Exemple
 
-<h3 id="Utiliser_Math.log10()">Utiliser <code>Math.log10()</code></h3>
+### Utiliser `Math.log10()`
 
-<pre class="brush:js">Math.log10(2);      // 0.3010299956639812
+```js
+Math.log10(2);      // 0.3010299956639812
 Math.log10(1);      // 0
 Math.log10(0);      // -Infinity
 Math.log10(-2);     // NaN
 Math.log10(100000); // 5
-</pre>
+```
 
-<h2 id="Prothèse_d'émulation_(polyfill)">Prothèse d'émulation (<em>polyfill</em>)</h2>
+## Prothèse d'émulation (_polyfill_)
 
-<p>Il est possible d'avoir un résultat approximatif avec la fonction suivante :</p>
+Il est possible d'avoir un résultat approximatif avec la fonction suivante :
 
-<pre class="brush: js">Math.log10 = Math.log10 || function(x) {
+```js
+Math.log10 = Math.log10 || function(x) {
   return Math.log(x) * Math.LOG10E;
 };
-</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-math.log10', 'Math.log10')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-math.log10', 'Math.log10')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Math.log10")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Math.exp()")}}</li>
- <li>{{jsxref("Math.log()")}}</li>
- <li>{{jsxref("Math.log1p()")}}</li>
- <li>{{jsxref("Math.log2()")}}</li>
- <li>{{jsxref("Math.pow()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                | État                         | Commentaires         |
+| ---------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ES2015', '#sec-math.log10', 'Math.log10')}}     | {{Spec2('ES2015')}}     | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-math.log10', 'Math.log10')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Math.log10")}}
+
+## Voir aussi
+
+- {{jsxref("Math.exp()")}}
+- {{jsxref("Math.log()")}}
+- {{jsxref("Math.log1p()")}}
+- {{jsxref("Math.log2()")}}
+- {{jsxref("Math.pow()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/math/log10e/index.md b/files/fr/web/javascript/reference/global_objects/math/log10e/index.md
index 175018cc26..05f9f01a3a 100644
--- a/files/fr/web/javascript/reference/global_objects/math/log10e/index.md
+++ b/files/fr/web/javascript/reference/global_objects/math/log10e/index.md
@@ -9,74 +9,47 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Math/LOG10E
 original_slug: Web/JavaScript/Reference/Objets_globaux/Math/LOG10E
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La propriété <code><strong>Math.LOG10E</strong></code> fournit la valeur du logarithme en base 10 de e, environ 0.434 :</p>
+La propriété **`Math.LOG10E`** fournit la valeur du logarithme en base 10 de e, environ 0.434 :
 
-<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.LOG10E</mi></mstyle><mo>=</mo><msub><mo lspace="0em" rspace="0em">log</mo><mn>10</mn></msub><mo stretchy="false">(</mo><mi>e</mi><mo stretchy="false">)</mo><mo>≈</mo><mn>0.434</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.LOG10E}} = \log_10(e) \approx 0.434</annotation></semantics></math></p>
+<math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.LOG10E</mi></mstyle><mo>=</mo><msub><mo lspace="0em" rspace="0em">log</mo><mn>10</mn></msub><mo stretchy="false">(</mo><mi>e</mi><mo stretchy="false">)</mo><mo>≈</mo><mn>0.434</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.LOG10E}} = \log_10(e) \approx 0.434</annotation></semantics></math>
 
-<div>{{EmbedInteractiveExample("pages/js/math-log10e.html")}}</div>
+{{EmbedInteractiveExample("pages/js/math-log10e.html")}}{{js_property_attributes(0,0,0)}}
 
+## Description
 
+`LOG10E` étant une propriété statique de `Math`, elle doit toujours être utilisée avec la syntaxe `Math.LOG10E` et ne pas être appelée comme propriété d'un autre objet qui aurait été créé (`Math` n'est pas un constructeur).
 
-<div>{{js_property_attributes(0,0,0)}}</div>
+## Exemples
 
-<h2 id="Description">Description</h2>
+### Utiliser `Math.LOG10E`
 
-<p><code>LOG10E</code> étant une propriété statique de <code>Math</code>, elle doit toujours être utilisée avec la syntaxe <code>Math.LOG10E</code> et ne pas être appelée comme propriété d'un autre objet qui aurait été créé (<code>Math</code> n'est pas un constructeur).</p>
+La fonction suivante renvoie le logarithme en base 10 de e :
 
-<h2 id="Exemples">Exemples</h2>
+```js
+function getLog10e() {
+   return Math.LOG10E;
+}
 
-<h3 id="Utiliser_Math.LOG10E">Utiliser <code>Math.LOG10E</code></h3>
+getLog10e(); // 0.4342944819032518
+```
 
-<p>La fonction suivante renvoie le logarithme en base 10 de e :</p>
+## Spécifications
 
-<pre class="brush:js">function getLog10e() {
-   return Math.LOG10E;
-}
+| Spécification                                                                | État                         | Commentaires                                          |
+| ---------------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- |
+| {{SpecName('ES1')}}                                                     | {{Spec2('ES1')}}         | Définition initiale. Implémentée avec JavaScript 1.0. |
+| {{SpecName('ES5.1', '#sec-15.8.1.5', 'Math.LOG10E')}}     | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-math.log10e', 'Math.LOG10E')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-math.log10e', 'Math.LOG10E')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Math.LOG10E")}}
+
+## Voir aussi
 
-getLog10e(); // 0.4342944819032518</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.0.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.8.1.5', 'Math.LOG10E')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-math.log10e', 'Math.LOG10E')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-math.log10e', 'Math.LOG10E')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Math.LOG10E")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Math.exp()")}}</li>
- <li>{{jsxref("Math.log()")}}</li>
- <li>{{jsxref("Math.log10()")}}</li>
-</ul>
+- {{jsxref("Math.exp()")}}
+- {{jsxref("Math.log()")}}
+- {{jsxref("Math.log10()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/math/log1p/index.md b/files/fr/web/javascript/reference/global_objects/math/log1p/index.md
index 04913b856c..1ca30ae91d 100644
--- a/files/fr/web/javascript/reference/global_objects/math/log1p/index.md
+++ b/files/fr/web/javascript/reference/global_objects/math/log1p/index.md
@@ -11,86 +11,69 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Math/log1p
 original_slug: Web/JavaScript/Reference/Objets_globaux/Math/log1p
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La fonction <code><strong>Math.log1p()</strong></code> renvoie le logarithme népérien (en base {{jsxref("Math/E","e")}}) d'un nombre +1, donné par la formule :</p>
+La fonction **`Math.log1p()`** renvoie le logarithme népérien (en base {{jsxref("Math/E","e")}}) d'un nombre +1, donné par la formule :
 
-<p><math><semantics><mrow><mo>∀</mo><mi>x</mi><mo>&gt;</mo><mo>-</mo><mn>1</mn><mo>,</mo><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.log1p</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">ln</mo><mo stretchy="false">(</mo><mn>1</mn><mo>+</mo><mi>x</mi><mo stretchy="false">)</mo></mrow><annotation encoding="TeX">\forall x &gt; -1, \mathtt{\operatorname{Math.log1p}(x)} = \ln(1 + x)</annotation></semantics></math></p>
+<math><semantics><mrow><mo>∀</mo><mi>x</mi><mo>></mo><mo>-</mo><mn>1</mn><mo>,</mo><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.log1p</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">ln</mo><mo stretchy="false">(</mo><mn>1</mn><mo>+</mo><mi>x</mi><mo stretchy="false">)</mo></mrow><annotation encoding="TeX">\forall x > -1, \mathtt{\operatorname{Math.log1p}(x)} = \ln(1 + x)</annotation></semantics></math>
 
-<div>{{EmbedInteractiveExample("pages/js/math-log1p.html")}}</div>
+{{EmbedInteractiveExample("pages/js/math-log1p.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">Math.log1p(<var>x</var>)</pre>
+    Math.log1p(x)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>x</code></dt>
- <dd>Un nombre.</dd>
-</dl>
+- `x`
+  - : Un nombre.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>La valeur du logarithme naturel de 1 plus l'argument (<code>log(1 + x</code>)). Si l'argument est inférieur à <code>-1</code>, {{jsxref("NaN")}} est renvoyée.</p>
+La valeur du logarithme naturel de 1 plus l'argument (`log(1 + x`)). Si l'argument est inférieur à `-1`, {{jsxref("NaN")}} est renvoyée.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Si <code>x</code> est strictement inférieur à -1, la valeur renvoyée est {{jsxref("NaN")}}.</p>
+Si `x` est strictement inférieur à -1, la valeur renvoyée est {{jsxref("NaN")}}.
 
-<p><code>log1p</code> étant une méthode statique de <code>Math</code>, il faut utiliser <code>Math.<code>log1p</code>()</code> et non pas la méthode d'un autre objet qui aurait été créé (<code>Math</code> n'est pas un constructeur).</p>
+`log1p` étant une méthode statique de `Math`, il faut utiliser `Math.log1p()` et non pas la méthode d'un autre objet qui aurait été créé (`Math` n'est pas un constructeur).
 
-<h2 id="Exemple">Exemple</h2>
+## Exemple
 
-<h3 id="Utiliser_Math.log1p()">Utiliser <code>Math.log1p()</code></h3>
+### Utiliser `Math.log1p()`
 
-<pre class="brush:js">Math.log1p(1);  // 0.6931471805599453
+```js
+Math.log1p(1);  // 0.6931471805599453
 Math.log1p(0);  // 0
 Math.log1p(-1); // -Infinity
 Math.log1p(-2); // NaN
-</pre>
+```
 
-<h2 id="Prothèse_d'émulation_(polyfill)">Prothèse d'émulation (<em>polyfill</em>)</h2>
+## Prothèse d'émulation (_polyfill_)
 
-<p>Si cette fonction n'est pas disponible, elle peut être définie grâce au code suivant :</p>
+Si cette fonction n'est pas disponible, elle peut être définie grâce au code suivant :
 
-<pre class="brush: js">Math.log1p = Math.log1p || function(x) {
+```js
+Math.log1p = Math.log1p || function(x) {
   return Math.log(1 + x);
 };
-</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-math.log1p', 'Math.log1p')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-math.log1p', 'Math.log1p')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Math.log1p")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Math.exp()")}}</li>
- <li>{{jsxref("Math.log()")}}</li>
- <li>{{jsxref("Math.log10()")}}</li>
- <li>{{jsxref("Math.log2()")}}</li>
- <li>{{jsxref("Math.pow()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                | État                         | Commentaires         |
+| ---------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ES2015', '#sec-math.log1p', 'Math.log1p')}}     | {{Spec2('ES2015')}}     | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-math.log1p', 'Math.log1p')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Math.log1p")}}
+
+## Voir aussi
+
+- {{jsxref("Math.exp()")}}
+- {{jsxref("Math.log()")}}
+- {{jsxref("Math.log10()")}}
+- {{jsxref("Math.log2()")}}
+- {{jsxref("Math.pow()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/math/log2/index.md b/files/fr/web/javascript/reference/global_objects/math/log2/index.md
index c1700ae5c1..8d9d91c64b 100644
--- a/files/fr/web/javascript/reference/global_objects/math/log2/index.md
+++ b/files/fr/web/javascript/reference/global_objects/math/log2/index.md
@@ -11,79 +11,61 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Math/log2
 original_slug: Web/JavaScript/Reference/Objets_globaux/Math/log2
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La fonction <code><strong>Math.log2()</strong></code> renvoie le logarithme en base 2 d'un nombre :</p>
+La fonction **`Math.log2()`** renvoie le logarithme en base 2 d'un nombre :
 
-<p><math><semantics><mrow><mo>∀</mo><mi>x</mi><mo>&gt;</mo><mn>0</mn><mo>,</mo><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.log2</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><msub><mo lspace="0em" rspace="0em">log</mo><mn>2</mn></msub><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext>l'unique </mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mspace width="thickmathspace"></mspace><mtext>tel que</mtext><mspace width="thickmathspace"></mspace><msup><mn>2</mn><mi>y</mi></msup><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\forall x &gt; 0, \mathtt{\operatorname{Math.log2}(x)} = \log_2(x) = \text{the unique} \; y \; \text{such that} \; 2^y = x</annotation></semantics></math></p>
+<math><semantics><mrow><mo>∀</mo><mi>x</mi><mo>></mo><mn>0</mn><mo>,</mo><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.log2</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><msub><mo lspace="0em" rspace="0em">log</mo><mn>2</mn></msub><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext>l'unique </mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mspace width="thickmathspace"></mspace><mtext>tel que</mtext><mspace width="thickmathspace"></mspace><msup><mn>2</mn><mi>y</mi></msup><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\forall x > 0, \mathtt{\operatorname{Math.log2}(x)} = \log_2(x) = \text{the unique} \; y \; \text{such that} \; 2^y = x</annotation></semantics></math>
 
-<div>{{EmbedInteractiveExample("pages/js/math-log2.html")}}</div>
+{{EmbedInteractiveExample("pages/js/math-log2.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">Math.log2(<var>x</var>)</pre>
+    Math.log2(x)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>x</code></dt>
- <dd>Un nombre.</dd>
-</dl>
+- `x`
+  - : Un nombre.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Le logarithme en base 2 du nombre passé en argument. Si ce nombre est négatif, c'est {{jsxref("NaN")}} qui sera renvoyé.</p>
+Le logarithme en base 2 du nombre passé en argument. Si ce nombre est négatif, c'est {{jsxref("NaN")}} qui sera renvoyé.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Si <code>x</code> est strictement inférieur à 0, la valeur renvoyée sera {{jsxref("NaN")}}.</p>
+Si `x` est strictement inférieur à 0, la valeur renvoyée sera {{jsxref("NaN")}}.
 
-<p><code>log2()</code> étant une méthode statique de <code>Math</code>, il faut utiliser <code>Math.<code>log2</code>()</code> et non pas la méthode d'un autre objet qui aurait été créé (<code>Math </code>n'est pas un constructeur). Si on souhaite utiliser des constantes, on pourra employer {{jsxref("Math.LOG2E")}} ou {{jsxref("Math.LN2")}}.</p>
+`log2()` étant une méthode statique de `Math`, il faut utiliser `Math.log2()` et non pas la méthode d'un autre objet qui aurait été créé (`Math `n'est pas un constructeur). Si on souhaite utiliser des constantes, on pourra employer {{jsxref("Math.LOG2E")}} ou {{jsxref("Math.LN2")}}.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_Math.log2()">Utiliser <code>Math.log2()</code></h3>
+### Utiliser `Math.log2()`
 
-<pre class="brush:js">Math.log2(3);    // 1.584962500721156
+```js
+Math.log2(3);    // 1.584962500721156
 Math.log2(2);    // 1
 Math.log2(1);    // 0
 Math.log2(0);    // -Infinity
 Math.log2(-2);   // NaN
 Math.log2(1024); // 10
-</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-math.log2', 'Math.log2')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-math.log2', 'Math.log2')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Math.log2")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Math.exp()")}}</li>
- <li>{{jsxref("Math.log()")}}</li>
- <li>{{jsxref("Math.log10()")}}</li>
- <li>{{jsxref("Math.log1p()")}}</li>
- <li>{{jsxref("Math.pow()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                            | État                         | Commentaires         |
+| ------------------------------------------------------------------------ | ---------------------------- | -------------------- |
+| {{SpecName('ES2015', '#sec-math.log2', 'Math.log2')}} | {{Spec2('ES2015')}}     | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-math.log2', 'Math.log2')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Math.log2")}}
+
+## Voir aussi
+
+- {{jsxref("Math.exp()")}}
+- {{jsxref("Math.log()")}}
+- {{jsxref("Math.log10()")}}
+- {{jsxref("Math.log1p()")}}
+- {{jsxref("Math.pow()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/math/log2e/index.md b/files/fr/web/javascript/reference/global_objects/math/log2e/index.md
index ef33a48cf1..6f986e4bf3 100644
--- a/files/fr/web/javascript/reference/global_objects/math/log2e/index.md
+++ b/files/fr/web/javascript/reference/global_objects/math/log2e/index.md
@@ -9,74 +9,47 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Math/LOG2E
 original_slug: Web/JavaScript/Reference/Objets_globaux/Math/LOG2E
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La propriété <code><strong>Math.LOG2E</strong></code> représente la valeur du logarithme en base 2 de e, environ 1.442 :</p>
+La propriété **`Math.LOG2E`** représente la valeur du logarithme en base 2 de e, environ 1.442 :
 
-<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.LOG2E</mi></mstyle><mo>=</mo><msub><mo lspace="0em" rspace="0em">log</mo><mn>2</mn></msub><mo stretchy="false">(</mo><mi>e</mi><mo stretchy="false">)</mo><mo>≈</mo><mn>1.442</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.LOG2E}} = \log_2(e) \approx 1.442</annotation></semantics></math></p>
+<math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.LOG2E</mi></mstyle><mo>=</mo><msub><mo lspace="0em" rspace="0em">log</mo><mn>2</mn></msub><mo stretchy="false">(</mo><mi>e</mi><mo stretchy="false">)</mo><mo>≈</mo><mn>1.442</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.LOG2E}} = \log_2(e) \approx 1.442</annotation></semantics></math>
 
-<div>{{EmbedInteractiveExample("pages/js/math-log2e.html")}}</div>
+{{EmbedInteractiveExample("pages/js/math-log2e.html")}}{{js_property_attributes(0,0,0)}}
 
+## Description
 
+`LOG2E` est une propriété statique de l'objet `Math` et doit toujours être utilisé avec la syntaxe `Math.LOG2E` plutôt que comme la propriété d'un autre objet qui aurait été créé (`Math` n'est pas un constructeur).
 
-<div>{{js_property_attributes(0,0,0)}}</div>
+## Exemples
 
-<h2 id="Description">Description</h2>
+### Utiliser `Math.LOG2E`
 
-<p><code>LOG2E</code> est une propriété statique de l'objet <code>Math</code> et doit toujours être utilisé avec la syntaxe <code>Math.LOG2E</code> plutôt que comme la propriété d'un autre objet qui aurait été créé (<code>Math</code> n'est pas un constructeur).</p>
+La fonction suivante renvoie la valeur du logarithme en base 2 de e :
 
-<h2 id="Exemples">Exemples</h2>
+```js
+function getLog2e() {
+   return Math.LOG2E;
+}
 
-<h3 id="Utiliser_Math.LOG2E">Utiliser <code>Math.LOG2E</code></h3>
+getLog2e(); // 1.4426950408889634
+```
 
-<p>La fonction suivante renvoie la valeur du logarithme en base 2 de e :</p>
+## Spécifications
 
-<pre class="brush:js">function getLog2e() {
-   return Math.LOG2E;
-}
+| Spécification                                                                | Statut                       | Commentaires                                          |
+| ---------------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- |
+| {{SpecName('ES1')}}                                                     | {{Spec2('ES1')}}         | Définition initiale. Implémentée avec JavaScript 1.0. |
+| {{SpecName('ES5.1', '#sec-15.8.1.4', 'Math.LOG2E')}}         | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-math.log2e', 'Math.LOG2E')}}         | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-math.log2e', 'Math.LOG2E')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Math.LOG2E")}}
+
+## Voir aussi
 
-getLog2e(); // 1.4426950408889634</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. Implémentée avec JavaScript 1.0.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.8.1.4', 'Math.LOG2E')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-math.log2e', 'Math.LOG2E')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-math.log2e', 'Math.LOG2E')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Math.LOG2E")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Math.exp()")}}</li>
- <li>{{jsxref("Math.log()")}}</li>
- <li>{{jsxref("Math.log2()")}}</li>
-</ul>
+- {{jsxref("Math.exp()")}}
+- {{jsxref("Math.log()")}}
+- {{jsxref("Math.log2()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/math/max/index.md b/files/fr/web/javascript/reference/global_objects/math/max/index.md
index 78e3810bca..ceae8a1e98 100644
--- a/files/fr/web/javascript/reference/global_objects/math/max/index.md
+++ b/files/fr/web/javascript/reference/global_objects/math/max/index.md
@@ -9,104 +9,84 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Math/max
 original_slug: Web/JavaScript/Reference/Objets_globaux/Math/max
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La fonction <code><strong>Math.max()</strong></code> renvoie le plus grand nombre d'une série de 0 ou plusieurs nombres.</p>
+La fonction **`Math.max()`** renvoie le plus grand nombre d'une série de 0 ou plusieurs nombres.
 
-<div>{{EmbedInteractiveExample("pages/js/math-max.html")}}</div>
+{{EmbedInteractiveExample("pages/js/math-max.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">Math.max([<var>valeur1</var>[,<var>valeur2</var>, ...]]) </pre>
+    Math.max([valeur1[,valeur2, ...]])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>valeur1, valeur2, ...</code></dt>
- <dd>Des nombres.</dd>
-</dl>
+- `valeur1, valeur2, ...`
+  - : Des nombres.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Le plus grand des nombres passés en arguments. S'il existe un des arguments qui ne peut pas être converti en nombre, c'est {{jsxref("NaN")}} qui sera renvoyé.</p>
+Le plus grand des nombres passés en arguments. S'il existe un des arguments qui ne peut pas être converti en nombre, c'est {{jsxref("NaN")}} qui sera renvoyé.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p><code>max()</code> est une méthode statique de <code>Math</code> et doit toujours être utilisée avec la syntaxe <code>Math.max()</code>, elle ne doit pas être appelée comme la méthode d'un autre objet qui aurait été créé (<code>Math</code> n'est pas un constructeur).</p>
+`max()` est une méthode statique de `Math` et doit toujours être utilisée avec la syntaxe `Math.max()`, elle ne doit pas être appelée comme la méthode d'un autre objet qui aurait été créé (`Math` n'est pas un constructeur).
 
-<p>Si aucun argument n'est fourni, le résultat sera -{{jsxref("Infinity")}}.</p>
+Si aucun argument n'est fourni, le résultat sera -{{jsxref("Infinity")}}.
 
-<p>Si au moins un des arguments ne peut pas être converti en un nombre, le résultat sera {{jsxref("NaN")}}.</p>
+Si au moins un des arguments ne peut pas être converti en un nombre, le résultat sera {{jsxref("NaN")}}.
 
-<h2 id="Exemple">Exemple</h2>
+## Exemple
 
-<h3 id="Utiliser_Math.max()">Utiliser <code>Math.max()</code></h3>
+### Utiliser `Math.max()`
 
-<pre class="brush: js">Math.max(10, 20);   //  20
+```js
+Math.max(10, 20);   //  20
 Math.max(-10, -20); // -10
 Math.max(-10, 20);  //  20
-</pre>
+```
 
-<h3 id="Obtenir_l'élément_maximum_d'un_tableau">Obtenir l'élément maximum d'un tableau</h3>
+### Obtenir l'élément maximum d'un tableau
 
-<p>La méthode {{jsxref("Array.prototype.reduce()")}} peut être utilisée pour déterminer la valeur maximale d'un tableau de nombre en comparant les valeurs qui se suivent :</p>
+La méthode {{jsxref("Array.prototype.reduce()")}} peut être utilisée pour déterminer la valeur maximale d'un tableau de nombre en comparant les valeurs qui se suivent :
 
-<pre class="brush: js">var arr = [1, 2, 3];
+```js
+var arr = [1, 2, 3];
 var max = arr.reduce(function(a,b) {
   return Math.max(a, b);
-});</pre>
+});
+```
 
-<p>On peut également utiliser {{jsxref("Function.prototype.apply()")}} afin de trouver le maximum parmi un tableau de nombres. <code>getMaxTableau([1,2,3])</code> sera équivalent à <code>Math.max(1, 2, 3)</code>, mais <code>getMaxTableau</code> pourra être utilisé sur des tableaux de n'importe quelle taille.</p>
+On peut également utiliser {{jsxref("Function.prototype.apply()")}} afin de trouver le maximum parmi un tableau de nombres. `getMaxTableau([1,2,3])` sera équivalent à `Math.max(1, 2, 3)`, mais `getMaxTableau` pourra être utilisé sur des tableaux de n'importe quelle taille.
 
-<pre class="brush:js">function getMaxTableau(tableauNumérique) {
+```js
+function getMaxTableau(tableauNumérique) {
     return Math.max.apply(null, tableauNumérique);
-}</pre>
-
-<p>Avec le nouvel {{jsxref("Opérateurs/Affecter_par_décomposition","opérateur de décomposition","","1")}}, on pourra également utiliser cette syntaxe, plus concise et plus simple :</p>
-
-<pre class="brush: js">var arr = [1, 2, 3];
-var max = Math.max(...arr);</pre>
-
-<p>Attention avec la décomposition et <code>apply()</code> qui pourront échouer s'il y a trop d'éléments dans le tableau (car ceux-ci seront passés en arguments). Pour plus d'informations, consulter <a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Function/apply#Utiliser_apply_et_des_fonctions_natives">Utiliser apply() et les fonctions natives</a>. La méthode proposée avec <code>reduce()</code> n'a pas cette contrainte.</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.0.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.8.2.11', 'Math.max')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-math.max', 'Math.max')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-math.max', 'Math.max')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Math.max")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Math.min()")}}</li>
-</ul>
+}
+```
+
+Avec le nouvel {{jsxref("Opérateurs/Affecter_par_décomposition","opérateur de décomposition","","1")}}, on pourra également utiliser cette syntaxe, plus concise et plus simple :
+
+```js
+var arr = [1, 2, 3];
+var max = Math.max(...arr);
+```
+
+Attention avec la décomposition et `apply()` qui pourront échouer s'il y a trop d'éléments dans le tableau (car ceux-ci seront passés en arguments). Pour plus d'informations, consulter [Utiliser apply() et les fonctions natives](/fr/docs/Web/JavaScript/Reference/Objets_globaux/Function/apply#Utiliser_apply_et_des_fonctions_natives). La méthode proposée avec `reduce()` n'a pas cette contrainte.
+
+## 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.8.2.11', 'Math.max')}} | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-math.max', 'Math.max')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-math.max', 'Math.max')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Math.max")}}
+
+## Voir aussi
+
+- {{jsxref("Math.min()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/math/min/index.md b/files/fr/web/javascript/reference/global_objects/math/min/index.md
index 39cd2d8567..0fa9c67c58 100644
--- a/files/fr/web/javascript/reference/global_objects/math/min/index.md
+++ b/files/fr/web/javascript/reference/global_objects/math/min/index.md
@@ -9,100 +9,77 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Math/min
 original_slug: Web/JavaScript/Reference/Objets_globaux/Math/min
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La fonction <code><strong>Math.min()</strong></code> renvoie le plus petit nombre d'une série de 0 ou plusieurs nombres ou bien {{jsxref("NaN")}} si au moins un des arguments fourni n'est pas un nombre ou ne peut pas être converti en nombre.</p>
+La fonction **`Math.min()`** renvoie le plus petit nombre d'une série de 0 ou plusieurs nombres ou bien {{jsxref("NaN")}} si au moins un des arguments fourni n'est pas un nombre ou ne peut pas être converti en nombre.
 
-<div>{{EmbedInteractiveExample("pages/js/math-min.html")}}</div>
+{{EmbedInteractiveExample("pages/js/math-min.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">Math.min([<var>valeur1</var>[,<var>valeur2</var>, ...]]) </pre>
+    Math.min([valeur1[,valeur2, ...]])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>valeur1, valeur2, ...</code></dt>
- <dd>Des nombres.</dd>
-</dl>
+- `valeur1, valeur2, ...`
+  - : Des nombres.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Le plus petit des nombres passés en arguments. S'il existe un argument qui ne peut pas être converti en nombre, c'est {{jsxref("NaN")}} qui sera renvoyé. Le résultat sera {{jsxref("Infinity")}} si aucun paramètre n'est fourni.</p>
+Le plus petit des nombres passés en arguments. S'il existe un argument qui ne peut pas être converti en nombre, c'est {{jsxref("NaN")}} qui sera renvoyé. Le résultat sera {{jsxref("Infinity")}} si aucun paramètre n'est fourni.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p><code>min()</code> est une méthode statique de <code>Math</code>, elle doit toujours être utilisée avec la syntaxe <code>Math.min()</code> et ne doit pas être utilisée comme la méthode d'un objet qui aurait été créé (<code>Math</code> n'est pas un constructeur).</p>
+`min()` est une méthode statique de `Math`, elle doit toujours être utilisée avec la syntaxe `Math.min()` et ne doit pas être utilisée comme la méthode d'un objet qui aurait été créé (`Math` n'est pas un constructeur).
 
-<p>Si aucun argument n'est fourni, le résultat renvoyé par la fonction sera {{jsxref("Infinity")}}.</p>
+Si aucun argument n'est fourni, le résultat renvoyé par la fonction sera {{jsxref("Infinity")}}.
 
-<p>Si au moins un des arguments ne peut pas être converti en un nombre, le résultat sera {{jsxref("NaN")}}.</p>
+Si au moins un des arguments ne peut pas être converti en un nombre, le résultat sera {{jsxref("NaN")}}.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_Math.min()">Utiliser <code>Math.min()</code></h3>
+### Utiliser `Math.min()`
 
-<p>Dans cet exemple, on trouve le minimum de x et y et on affecte cette valeur à z :</p>
+Dans cet exemple, on trouve le minimum de x et y et on affecte cette valeur à z :
 
-<pre class="brush:js">var x = 10, y = -20;
+```js
+var x = 10, y = -20;
 var z = Math.min(x, y);
-</pre>
+```
 
-<h3 id="Ramener_une_valeur_dans_un_intervalle_(clipping)_avec_Math.min()">Ramener une valeur dans un intervalle (<em>clipping</em>) avec <code>Math.min()</code></h3>
+### Ramener une valeur dans un intervalle (_clipping_) avec `Math.min()`
 
-<p><code>Math.min()</code> est souvent utilisée afin de ramener une certaine valeur dans un intervalle donné. Par exemple :</p>
+`Math.min()` est souvent utilisée afin de ramener une certaine valeur dans un intervalle donné. Par exemple :
 
-<pre class="brush:js">var x = f(toto);
+```js
+var x = f(toto);
 
-if (x &gt; limite) {
+if (x > limite) {
   x = limite;
 }
-</pre>
-
-<p>peut s'écrire</p>
-
-<pre class="brush:js">var x = Math.min(f(toto), limite);</pre>
-
-<div>{{jsxref("Math.max()")}} peut être utilisée de façon semblable pour ramener une valeur vers un minimum d'un intervalle donné.</div>
-
-<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. Implémentée avec JavaScript 1.0.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.8.2.12', 'Math.min')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-math.min', 'Math.min')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-math.min', 'Math.min')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Math.min")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Math.max()")}}</li>
-</ul>
+```
+
+peut s'écrire
+
+```js
+var x = Math.min(f(toto), limite);
+```
+
+{{jsxref("Math.max()")}} peut être utilisée de façon semblable pour ramener une valeur vers un minimum d'un intervalle donné.
+
+## 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.8.2.12', 'Math.min')}} | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-math.min', 'Math.min')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-math.min', 'Math.min')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Math.min")}}
+
+## Voir aussi
+
+- {{jsxref("Math.max()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/math/pi/index.md b/files/fr/web/javascript/reference/global_objects/math/pi/index.md
index d9aa0848db..d8f6d65a4a 100644
--- a/files/fr/web/javascript/reference/global_objects/math/pi/index.md
+++ b/files/fr/web/javascript/reference/global_objects/math/pi/index.md
@@ -9,72 +9,45 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Math/PI
 original_slug: Web/JavaScript/Reference/Objets_globaux/Math/PI
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La propriété <code><strong>Math.PI</strong></code> représente le ratio entre le périmètre d'un cercle et son diamètre. Elle vaut environ 3.14159:</p>
+La propriété **`Math.PI`** représente le ratio entre le périmètre d'un cercle et son diamètre. Elle vaut environ 3.14159:
 
-<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.PI</mi></mstyle><mo>=</mo><mi>π</mi><mo>≈</mo><mn>3.14159</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.PI}} = \pi \approx 3.14159</annotation></semantics></math></p>
+<math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.PI</mi></mstyle><mo>=</mo><mi>π</mi><mo>≈</mo><mn>3.14159</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.PI}} = \pi \approx 3.14159</annotation></semantics></math>
 
-<div>{{EmbedInteractiveExample("pages/js/math-pi.html")}}</div>
+{{EmbedInteractiveExample("pages/js/math-pi.html")}}{{js_property_attributes(0,0,0)}}
 
+## Description
 
+`PI` est une propriété statique de l'objet `Math` et doit toujours être utilisée avec la syntaxe `Math.PI` plutôt que d'être appelée comme la propriété d'un autre objet qui aurait été crée (`Math` n'est pas un constructeur).
 
-<div>{{js_property_attributes(0,0,0)}}</div>
+## Exemples
 
-<h2 id="Description">Description</h2>
+### Utiliser `Math.PI`
 
-<p><code>PI</code> est une propriété statique de l'objet <code>Math</code> et doit toujours être utilisée avec la syntaxe <code>Math.PI</code> plutôt que d'être appelée comme la propriété d'un autre objet qui aurait été crée (<code>Math</code> n'est pas un constructeur).</p>
+La fonction suivante utilise `Math.PI` afin de calculer le périmètre d'un cercle à partir du rayon passé en argument.
 
-<h2 id="Exemples">Exemples</h2>
+```js
+function calculPérimètre(rayon) {
+  return 2 * Math.PI * rayon;
+}
 
-<h3 id="Utiliser_Math.PI">Utiliser <code>Math.PI</code></h3>
+calculPérimètre(1);  // 6.283185307179586
+```
 
-<p>La fonction suivante utilise <code>Math.PI</code> afin de calculer le périmètre d'un cercle à partir du rayon passé en argument.</p>
+## Spécifications
 
-<pre class="brush:js">function calculPérimètre(rayon) {
-  return 2 * Math.PI * rayon;
-}
+| Spécification                                                        | Statut                       | Commentaires                                          |
+| -------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- |
+| {{SpecName('ES1')}}                                             | {{Spec2('ES1')}}         | Définition initiale. Implémentée avec JavaScript 1.0. |
+| {{SpecName('ES5.1', '#sec-15.8.1.6', 'Math.PI')}}     | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-math.pi', 'Math.PI')}}         | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-math.pi', 'Math.PI')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Math.PI")}}
+
+## Voir aussi
 
-calculPérimètre(1);  // 6.283185307179586</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. Implémentée avec JavaScript 1.0.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.8.1.6', 'Math.PI')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-math.pi', 'Math.PI')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-math.pi', 'Math.PI')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Math.PI")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Math")}}</li>
-</ul>
+- {{jsxref("Math")}}
diff --git a/files/fr/web/javascript/reference/global_objects/math/pow/index.md b/files/fr/web/javascript/reference/global_objects/math/pow/index.md
index b12f348e80..e85580ec3d 100644
--- a/files/fr/web/javascript/reference/global_objects/math/pow/index.md
+++ b/files/fr/web/javascript/reference/global_objects/math/pow/index.md
@@ -9,38 +9,37 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Math/pow
 original_slug: Web/JavaScript/Reference/Objets_globaux/Math/pow
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La fonction <code><strong>Math.pow()</strong></code> renvoie un nombre à une certaine puissance, c'est-à-dire <code>base^exposant</code>.</p>
+La fonction **`Math.pow()`** renvoie un nombre à une certaine puissance, c'est-à-dire `base^exposant`.
 
-<div>{{EmbedInteractiveExample("pages/js/math-pow.html")}}</div>
+{{EmbedInteractiveExample("pages/js/math-pow.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">Math.pow(<var>base</var>, <var>exposant</var>);</pre>
+    Math.pow(base, exposant);
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>base</code></dt>
- <dd>Le nombre correspondant à la base.</dd>
- <dt><code>exponent</code></dt>
- <dd>L'exposant auquel on élève le paramètre précédent.</dd>
-</dl>
+- `base`
+  - : Le nombre correspondant à la base.
+- `exponent`
+  - : L'exposant auquel on élève le paramètre précédent.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un nombre qui représente un nombre (premier argument) élevé à une puissance donné (second argument).</p>
+Un nombre qui représente un nombre (premier argument) élevé à une puissance donné (second argument).
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p><code>pow()</code> est une méthode statique de <code>Math</code> et doit toujours être utilisée avec la syntaxe <code>Math.pow()</code>, elle ne doit pas être utilisée comme une méthode d'un autre objet qui aurait été créé (<code>Math</code> n'est pas un constructeur).</p>
+`pow()` est une méthode statique de `Math` et doit toujours être utilisée avec la syntaxe `Math.pow()`, elle ne doit pas être utilisée comme une méthode d'un autre objet qui aurait été créé (`Math` n'est pas un constructeur).
 
-<h2 id="Exemple">Exemple</h2>
+## Exemple
 
-<h3 id="Utiliser_Math.pow()">Utiliser <code>Math.pow()</code></h3>
+### Utiliser `Math.pow()`
 
-<pre class="brush:js">// Utilisation simple
+```js
+// Utilisation simple
 Math.pow(7, 2); // 49
 
 // Exposants négatifs
@@ -54,50 +53,25 @@ Math.pow(-7, 0.5); // NaN
 // (les nombres négatifs n'ont pas de racine carrée)
 Math.pow(-7, 1/3); // NaN
 // Nombre négatif avec une base décimale
-</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.0.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.8.2.13', 'Math.pow')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-math.pow', 'Math.pow')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-math.pow', 'Math.pow')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Math.pow")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Math.cbrt()")}}</li>
- <li>{{jsxref("Math.exp()")}}</li>
- <li>{{jsxref("Math.log()")}}</li>
- <li>{{jsxref("Math.sqrt()")}}</li>
- <li><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_arithmétiques#Exponentiation_(**)">Opérateur d'exponentiation</a> {{experimental_inline}}</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.8.2.13', 'Math.pow')}} | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-math.pow', 'Math.pow')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-math.pow', 'Math.pow')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Math.pow")}}
+
+## Voir aussi
+
+- {{jsxref("Math.cbrt()")}}
+- {{jsxref("Math.exp()")}}
+- {{jsxref("Math.log()")}}
+- {{jsxref("Math.sqrt()")}}
+- [Opérateur d'exponentiation](</fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_arithmétiques#Exponentiation_(**)>) {{experimental_inline}}
diff --git a/files/fr/web/javascript/reference/global_objects/math/random/index.md b/files/fr/web/javascript/reference/global_objects/math/random/index.md
index c5b3df93df..e0ae51c992 100644
--- a/files/fr/web/javascript/reference/global_objects/math/random/index.md
+++ b/files/fr/web/javascript/reference/global_objects/math/random/index.md
@@ -9,46 +9,49 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Math/random
 original_slug: Web/JavaScript/Reference/Objets_globaux/Math/random
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La fonction <code><strong>Math.random()</strong></code> renvoie un nombre flottant pseudo-aléatoire compris dans l'intervalle <code>[0, 1[</code> (ce qui signifie que 0 est compris dans l'intervalle mais que 1 en est exclu) selon une distribution approximativement uniforme sur cet intervalle. Ce nombre peut ensuite être multiplié afin de couvrir un autre intervalle. La graine (<em>seed</em>) du générateur est choisie par l'algorithme et ne peut pas être choisie ou réinitialisée par l'utilisateur.</p>
+La fonction **`Math.random()`** renvoie un nombre flottant pseudo-aléatoire compris dans l'intervalle `[0, 1[` (ce qui signifie que 0 est compris dans l'intervalle mais que 1 en est exclu) selon une distribution approximativement uniforme sur cet intervalle. Ce nombre peut ensuite être multiplié afin de couvrir un autre intervalle. La graine (_seed_) du générateur est choisie par l'algorithme et ne peut pas être choisie ou réinitialisée par l'utilisateur.
 
-<div>{{EmbedInteractiveExample("pages/js/math-random.html")}}</div>
+{{EmbedInteractiveExample("pages/js/math-random.html")}}
 
-<div class="note">
-<p><strong>Note :</strong> <code>Math.random()</code> <strong>ne fournit pas</strong> de nombres aléatoires propres à une cryptographie sécurisée. Les résultats de cette méthode ne doivent pas être utilisées dans des applications liées à la sécurité. À la place, on préfèrera utiliser l'API Web Crypto et plus précisément la méthode {{domxref("RandomSource.getRandomValues()", "window.crypto.getRandomValues()")}}.</p>
-</div>
+> **Note :** `Math.random()` **ne fournit pas** de nombres aléatoires propres à une cryptographie sécurisée. Les résultats de cette méthode ne doivent pas être utilisées dans des applications liées à la sécurité. À la place, on préfèrera utiliser l'API Web Crypto et plus précisément la méthode {{domxref("RandomSource.getRandomValues()", "window.crypto.getRandomValues()")}}.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox notranslate">Math.random()</pre>
+    Math.random()
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un nombre flottant pseudo-aléatoire, généré entre 0 (inclus) et 1 (exclu)</p>
+Un nombre flottant pseudo-aléatoire, généré entre 0 (inclus) et 1 (exclu)
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<p>En JavaScript, les nombres sont représentés comme des nombres flottants selon la norme IEEE 754 et les arrondis sont pris aux plus près. Aussi, les intervalles revendiqués par les fonctions ci-après (en dehors de <code>Math.random()</code>) ne sont pas théoriquement et précisément exacts. Si on utilise des bornes supérieures très grande (2^53 ou plus), il est alors possible, dans de très rares cas, d'obtenir la borne supérieure comme résultat alors que celle-ci devrait être exclue de l'intervalle.</p>
+En JavaScript, les nombres sont représentés comme des nombres flottants selon la norme IEEE 754 et les arrondis sont pris aux plus près. Aussi, les intervalles revendiqués par les fonctions ci-après (en dehors de `Math.random()`) ne sont pas théoriquement et précisément exacts. Si on utilise des bornes supérieures très grande (2^53 ou plus), il est alors possible, dans de très rares cas, d'obtenir la borne supérieure comme résultat alors que celle-ci devrait être exclue de l'intervalle.
 
-<h3 id="Obtenir_un_nombre_aléatoire_entre_0_et_1">Obtenir un nombre aléatoire entre 0 et 1</h3>
+### Obtenir un nombre aléatoire entre 0 et 1
 
-<pre class="brush: js notranslate">// On renvoie un nombre aléatoire entre 0 (inclus) et 1 (exclus)
+```js
+// On renvoie un nombre aléatoire entre 0 (inclus) et 1 (exclus)
 function getRandom() {
   return Math.random();
-}</pre>
+}
+```
 
-<h3 id="Obtenir_un_nombre_aléatoire_dans_un_intervalle">Obtenir un nombre aléatoire dans un intervalle</h3>
+### Obtenir un nombre aléatoire dans un intervalle
 
-<pre class="brush: js notranslate">// On renvoie un nombre aléatoire entre une valeur min (incluse)
+```js
+// On renvoie un nombre aléatoire entre une valeur min (incluse)
 // et une valeur max (exclue)
 function getRandomArbitrary(min, max) {
   return Math.random() * (max - min) + min;
-}</pre>
+}
+```
 
-<h3 id="Obtenir_un_entier_aléatoire_dans_un_intervalle_ouvert_à_droite">Obtenir un entier aléatoire dans un intervalle ouvert à droite</h3>
+### Obtenir un entier aléatoire dans un intervalle ouvert à droite
 
-<pre class="brush: js notranslate">// On renvoie un entier aléatoire entre une valeur min (incluse)
+```js
+// On renvoie un entier aléatoire entre une valeur min (incluse)
 // et une valeur max (exclue).
 // Attention : si on utilisait Math.round(), on aurait une distribution
 // non uniforme !
@@ -57,15 +60,14 @@ function getRandomInt(min, max) {
   max = Math.floor(max);
   return Math.floor(Math.random() * (max - min)) + min;
 }
-</pre>
+```
 
-<div class="warning">
-<p><strong>Attention :</strong> Utiliser <code>Math.round()</code> entraînerait une distribution non-uniforme et réduirait le caractère aléatoire de la méthode.</p>
-</div>
+> **Attention :** Utiliser `Math.round()` entraînerait une distribution non-uniforme et réduirait le caractère aléatoire de la méthode.
 
-<h3 id="Obtenir_un_entier_aléatoire_dans_un_intervalle_fermé">Obtenir un entier aléatoire dans un intervalle fermé</h3>
+### Obtenir un entier aléatoire dans un intervalle fermé
 
-<pre class="brush: js notranslate">// On renvoie un entier aléatoire entre une valeur min (incluse)
+```js
+// On renvoie un entier aléatoire entre une valeur min (incluse)
 // et une valeur max (incluse).
 // Attention : si on utilisait Math.round(), on aurait une distribution
 // non uniforme !
@@ -74,40 +76,17 @@ function getRandomIntInclusive(min, max) {
   max = Math.floor(max);
   return Math.floor(Math.random() * (max - min +1)) + min;
 }
-</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.0 (UNIX) et 1.1 (toutes plateformes).</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.8.2.14', 'Math.random')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-math.random', 'Math.random')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-math.random', 'Math.random')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Math.random")}}</p>
+```
+
+## Spécifications
+
+| Spécification                                                                | État                         | Commentaires                                                                             |
+| ---------------------------------------------------------------------------- | ---------------------------- | ---------------------------------------------------------------------------------------- |
+| {{SpecName('ES1')}}                                                     | {{Spec2('ES1')}}         | Définition initiale. Implémentée avec JavaScript 1.0 (UNIX) et 1.1 (toutes plateformes). |
+| {{SpecName('ES5.1', '#sec-15.8.2.14', 'Math.random')}}     | {{Spec2('ES5.1')}}     |                                                                                          |
+| {{SpecName('ES6', '#sec-math.random', 'Math.random')}}     | {{Spec2('ES6')}}         |                                                                                          |
+| {{SpecName('ESDraft', '#sec-math.random', 'Math.random')}} | {{Spec2('ESDraft')}} |                                                                                          |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Math.random")}}
diff --git a/files/fr/web/javascript/reference/global_objects/math/round/index.md b/files/fr/web/javascript/reference/global_objects/math/round/index.md
index fb671af237..f43dc4f6c5 100644
--- a/files/fr/web/javascript/reference/global_objects/math/round/index.md
+++ b/files/fr/web/javascript/reference/global_objects/math/round/index.md
@@ -9,86 +9,60 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Math/round
 original_slug: Web/JavaScript/Reference/Objets_globaux/Math/round
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La fonction <strong><code>Math.round()</code></strong> retourne la valeur d'un nombre arrondi à l'entier le plus proche.</p>
+La fonction **`Math.round()`** retourne la valeur d'un nombre arrondi à l'entier le plus proche.
 
-<div>{{EmbedInteractiveExample("pages/js/math-round.html")}}</div>
+{{EmbedInteractiveExample("pages/js/math-round.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">Math.round(<var>x</var>)</pre>
+    Math.round(x)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>x</code></dt>
- <dd>Un nombre.</dd>
-</dl>
+- `x`
+  - : Un nombre.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>La valeur de l'entier le plus proche du nombre passé en argument.</p>
+La valeur de l'entier le plus proche du nombre passé en argument.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Si la partie décimale du nombre est plus grande que 0.5, l'argument est arrondi à l'entier le plus proche dont la valeur absolue est plus grande. Si elle est plus petite que 0.5, l'argument est arrondi à l'entier le plus proche dont la valeur absolue est plus petite. Si la partie décimale du nombre vaut exactement 0.5, l'argument est arrondi à l'entier le plus proche en direction de l'infini positif (attention, pour la plupart des langages de programmation, c'est le nombre avec la plus grande valeur absolue qui est renvoyé ; on a donc une différence de comportement pour les nombres négatifs dont la partie décimale vaut exactement 0.5).</p>
+Si la partie décimale du nombre est plus grande que 0.5, l'argument est arrondi à l'entier le plus proche dont la valeur absolue est plus grande. Si elle est plus petite que 0.5, l'argument est arrondi à l'entier le plus proche dont la valeur absolue est plus petite. Si la partie décimale du nombre vaut exactement 0.5, l'argument est arrondi à l'entier le plus proche en direction de l'infini positif (attention, pour la plupart des langages de programmation, c'est le nombre avec la plus grande valeur absolue qui est renvoyé ; on a donc une différence de comportement pour les nombres négatifs dont la partie décimale vaut exactement 0.5).
 
-<p><code>round()</code> étant une méthode statique de <code>Math</code>, elle doit toujours être utilisée avec la syntaxe <code>Math.round()</code>, elle ne doit pas être utilisée comme une méthode d'un objet qui aurait été créé (<code>Math</code> n'est pas un constructeur).</p>
+`round()` étant une méthode statique de `Math`, elle doit toujours être utilisée avec la syntaxe `Math.round()`, elle ne doit pas être utilisée comme une méthode d'un objet qui aurait été créé (`Math` n'est pas un constructeur).
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<pre class="brush: js">Math.round(20.49); //  20
+```js
+Math.round(20.49); //  20
 Math.round(20.5);  //  21
 Math.round(42);    //  42
 Math.round(-20.5); // -20
 Math.round(-20.51);// -21
-</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.0.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.8.2.15', 'Math.round')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-math.round', 'Math.round')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-math.round', 'Math.round')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Math.round")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Number.toPrecision()")}}</li>
- <li>{{jsxref("Number.toFixed()")}}</li>
- <li>{{jsxref("Math.abs()")}}</li>
- <li>{{jsxref("Math.ceil()")}}</li>
- <li>{{jsxref("Math.floor()")}}</li>
- <li>{{jsxref("Math.sign()")}}</li>
- <li>{{jsxref("Math.trunc()")}}</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.8.2.15', 'Math.round')}}     | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-math.round', 'Math.round')}}         | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-math.round', 'Math.round')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Math.round")}}
+
+## Voir aussi
+
+- {{jsxref("Number.toPrecision()")}}
+- {{jsxref("Number.toFixed()")}}
+- {{jsxref("Math.abs()")}}
+- {{jsxref("Math.ceil()")}}
+- {{jsxref("Math.floor()")}}
+- {{jsxref("Math.sign()")}}
+- {{jsxref("Math.trunc()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/math/sign/index.md b/files/fr/web/javascript/reference/global_objects/math/sign/index.md
index c27e808527..44a438171e 100644
--- a/files/fr/web/javascript/reference/global_objects/math/sign/index.md
+++ b/files/fr/web/javascript/reference/global_objects/math/sign/index.md
@@ -11,38 +11,37 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Math/sign
 original_slug: Web/JavaScript/Reference/Objets_globaux/Math/sign
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La fonction <code><strong>Math.sign()</strong></code> renvoie le signe d'un nombre et permet de savoir si un nombre est positif, négatif ou nul.</p>
+La fonction **`Math.sign()`** renvoie le signe d'un nombre et permet de savoir si un nombre est positif, négatif ou nul.
 
-<div>{{EmbedInteractiveExample("pages/js/math-sign.html")}}</div>
+{{EmbedInteractiveExample("pages/js/math-sign.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">Math.sign(<var>x</var>)</pre>
+    Math.sign(x)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>x</code></dt>
- <dd>Un nombre.</dd>
-</dl>
+- `x`
+  - : Un nombre.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un nombre qui représente le signe de l'argument. Si l'argument est un nombre positif, négatif, un zéro positif ou un zéro négatif, la fonction renverra respectivement <code>1</code>, <code>-1</code>, <code>0</code>, <code>-0</code>. Sinon, ce sera {{jsxref("NaN")}} qui sera renvoyé.</p>
+Un nombre qui représente le signe de l'argument. Si l'argument est un nombre positif, négatif, un zéro positif ou un zéro négatif, la fonction renverra respectivement `1`, `-1`, `0`, `-0`. Sinon, ce sera {{jsxref("NaN")}} qui sera renvoyé.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p><code>sign()</code> étant une méthode statique de <code>Math</code>, il faut utiliser <code>Math.<code>sign</code>()</code> et non pas la méthode d'un autre objet qui aurait été créé (<code>Math </code>n'est pas un constructeur).</p>
+`sign()` étant une méthode statique de `Math`, il faut utiliser `Math.sign()` et non pas la méthode d'un autre objet qui aurait été créé (`Math `n'est pas un constructeur).
 
-<p>Cette fonction peut renvoyer 5 valeurs : <code>1, -1, 0, -0, NaN,</code> qui indiquent respectivement que <code>x</code> est un nombre positif, un nombre négatif, zéro, la limite négative de zéro, et n'est pas un nombre pour {{jsxref("NaN")}}.</p>
+Cette fonction peut renvoyer 5 valeurs : `1, -1, 0, -0, NaN,` qui indiquent respectivement que `x` est un nombre positif, un nombre négatif, zéro, la limite négative de zéro, et n'est pas un nombre pour {{jsxref("NaN")}}.
 
-<p>L'argument passé à cette fonction sera implicitement converti au type <code>number</code>.</p>
+L'argument passé à cette fonction sera implicitement converti au type `number`.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<pre class="brush:js">Math.sign(3)     //  1
+```js
+Math.sign(3)     //  1
 Math.sign(-3)    // -1
 Math.sign("-3")  // -1
 Math.sign(0)     //  0
@@ -50,40 +49,23 @@ Math.sign(-0)    // -0
 Math.sign(NaN)   // NaN
 Math.sign("foo") // NaN
 Math.sign()      // NaN
-</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-math.sign', 'Math.sign')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-math.sign', 'Math.sign')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Math.sign")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Math.abs()")}}</li>
- <li>{{jsxref("Math.ceil()")}}</li>
- <li>{{jsxref("Math.floor()")}}</li>
- <li>{{jsxref("Math.round()")}}</li>
- <li>{{jsxref("Math.trunc()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                            | État                         | Commentaires         |
+| ------------------------------------------------------------------------ | ---------------------------- | -------------------- |
+| {{SpecName('ES6', '#sec-math.sign', 'Math.sign')}}     | {{Spec2('ES6')}}         | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-math.sign', 'Math.sign')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Math.sign")}}
+
+## Voir aussi
+
+- {{jsxref("Math.abs()")}}
+- {{jsxref("Math.ceil()")}}
+- {{jsxref("Math.floor()")}}
+- {{jsxref("Math.round()")}}
+- {{jsxref("Math.trunc()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/math/sin/index.md b/files/fr/web/javascript/reference/global_objects/math/sin/index.md
index 3f3ea2afe8..35bb474eef 100644
--- a/files/fr/web/javascript/reference/global_objects/math/sin/index.md
+++ b/files/fr/web/javascript/reference/global_objects/math/sin/index.md
@@ -9,83 +9,58 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Math/sin
 original_slug: Web/JavaScript/Reference/Objets_globaux/Math/sin
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La fonction <code><strong>Math.sin()</strong></code> renvoie le sinus d'un nombre.</p>
+La fonction **`Math.sin()`** renvoie le sinus d'un nombre.
 
-<div>{{EmbedInteractiveExample("pages/js/math-sin.html")}}</div>
+{{EmbedInteractiveExample("pages/js/math-sin.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">Math.sin(<var>x</var>)</pre>
+    Math.sin(x)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>x</code></dt>
- <dd>Un nombre (qui exprime un angle en radians).</dd>
-</dl>
+- `x`
+  - : Un nombre (qui exprime un angle en radians).
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Le sinus de la valeur passée en argument (qui correspond à un angle en radians).</p>
+Le sinus de la valeur passée en argument (qui correspond à un angle en radians).
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La méthode <code>sin()</code> renvoie une valeur numérique comprise (au sens large) entre 1 et -1 et qui représente le sinus d'un angle donné en radians.</p>
+La méthode `sin()` renvoie une valeur numérique comprise (au sens large) entre 1 et -1 et qui représente le sinus d'un angle donné en radians.
 
-<p><code>sin()</code> est une méthode statique de <code>Math</code>, elle doit être utilisée avec la syntaxe <code>Math.sin()</code>, elle ne doit pas être utilisée comme une méthode d'un objet qui aurait été créé (<code>Math</code> n'est pas un constructeur).</p>
+`sin()` est une méthode statique de `Math`, elle doit être utilisée avec la syntaxe `Math.sin()`, elle ne doit pas être utilisée comme une méthode d'un objet qui aurait été créé (`Math` n'est pas un constructeur).
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<pre class="brush:js">Math.sin(0);           // 0
+```js
+Math.sin(0);           // 0
 Math.sin(1);           // 0.8414709848078965
 
-Math.sin(Math.PI / 2); // 1</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. Implémentée avec JavaScript 1.0.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.8.2.16', 'Math.sin')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-math.sin', 'Math.sin')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-math.sin', 'Math.sin')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Math.sin")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Math.acos()")}}</li>
- <li>{{jsxref("Math.asin()")}}</li>
- <li>{{jsxref("Math.atan()")}}</li>
- <li>{{jsxref("Math.atan2()")}}</li>
- <li>{{jsxref("Math.cos()")}}</li>
- <li>{{jsxref("Math.tan()")}}</li>
-</ul>
+Math.sin(Math.PI / 2); // 1
+```
+
+## 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.8.2.16', 'Math.sin')}} | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-math.sin', 'Math.sin')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-math.sin', 'Math.sin')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Math.sin")}}
+
+## Voir aussi
+
+- {{jsxref("Math.acos()")}}
+- {{jsxref("Math.asin()")}}
+- {{jsxref("Math.atan()")}}
+- {{jsxref("Math.atan2()")}}
+- {{jsxref("Math.cos()")}}
+- {{jsxref("Math.tan()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/math/sinh/index.md b/files/fr/web/javascript/reference/global_objects/math/sinh/index.md
index 4edf3a2ad5..9a74084918 100644
--- a/files/fr/web/javascript/reference/global_objects/math/sinh/index.md
+++ b/files/fr/web/javascript/reference/global_objects/math/sinh/index.md
@@ -11,85 +11,72 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Math/sinh
 original_slug: Web/JavaScript/Reference/Objets_globaux/Math/sinh
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La fonction <code><strong>Math.sinh()</strong></code> renvoie le sinus hyperbolique d'un nombre, dont la formule, utilisant la constante {{jsxref("Math.E","e")}}, est :</p>
+La fonction **`Math.sinh()`** renvoie le sinus hyperbolique d'un nombre, dont la formule, utilisant la constante {{jsxref("Math.E","e")}}, est :
 
-<p><math><semantics><mrow><mstyle mathvariant="monospace"><mo lspace="0em" rspace="thinmathspace">Math.sinh(x)</mo></mstyle><mo>=</mo><mfrac><mrow><msup><mi>e</mi><mi>x</mi></msup><mo>-</mo><msup><mi>e</mi><mrow><mo>-</mo><mi>x</mi></mrow></msup></mrow><mn>2</mn></mfrac></mrow><annotation encoding="TeX">\mathtt{\operatorname{Math.sinh(x)}} = \frac{e^x - e^{-x}}{2}</annotation></semantics></math></p>
+<math><semantics><mrow><mstyle mathvariant="monospace"><mo lspace="0em" rspace="thinmathspace">Math.sinh(x)</mo></mstyle><mo>=</mo><mfrac><mrow><msup><mi>e</mi><mi>x</mi></msup><mo>-</mo><msup><mi>e</mi><mrow><mo>-</mo><mi>x</mi></mrow></msup></mrow><mn>2</mn></mfrac></mrow><annotation encoding="TeX">\mathtt{\operatorname{Math.sinh(x)}} = \frac{e^x - e^{-x}}{2}</annotation></semantics></math>
 
-<div>{{EmbedInteractiveExample("pages/js/math-sinh.html")}}</div>
+{{EmbedInteractiveExample("pages/js/math-sinh.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">Math.sinh(<var>x</var>)</pre>
+    Math.sinh(x)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>x</code></dt>
- <dd>Un nombre.</dd>
-</dl>
+- `x`
+  - : Un nombre.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Le sinus hyperbolique de la valeur passée en argument.</p>
+Le sinus hyperbolique de la valeur passée en argument.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p><code>sinh()</code> est une méthode statique de <code>Math</code>, il faut utiliser la syntaxe <code>Math.<code>sinh</code>()</code>. Cette méthode ne doit pas être appelée depuis un autre objet qui aurait été créé (<code>Math </code>n'est pas un constructeur).</p>
+`sinh()` est une méthode statique de `Math`, il faut utiliser la syntaxe `Math.sinh()`. Cette méthode ne doit pas être appelée depuis un autre objet qui aurait été créé (`Math `n'est pas un constructeur).
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<pre class="brush:js">Math.sinh(0) // 0
-Math.sinh(1) // 1.1752011936438014</pre>
+```js
+Math.sinh(0) // 0
+Math.sinh(1) // 1.1752011936438014
+```
 
-<h2 id="Prothèse_d'émulation_(polyfill)">Prothèse d'émulation (<em>polyfill</em>)</h2>
+## Prothèse d'émulation (_polyfill_)
 
-<p>Si cette fonction n'est pas disponible, elle peut être émulée en utilisant la fonction {{jsxref("Math.exp()")}}<code> :</code></p>
+Si cette fonction n'est pas disponible, elle peut être émulée en utilisant la fonction {{jsxref("Math.exp()")}}` :`
 
-<pre class="brush: js">Math.sinh = Math.sinh || function(x){
+```js
+Math.sinh = Math.sinh || function(x){
     return (Math.exp(x) - Math.exp(-x)) / 2;
-};</pre>
+};
+```
 
-<p>ou encore, si on n'utilise qu'une fois {{jsxref("Math.exp()")}}, avec :</p>
+ou encore, si on n'utilise qu'une fois {{jsxref("Math.exp()")}}, avec :
 
-<pre class="brush: js">Math.sinh = Math.sinh || function(x){
+```js
+Math.sinh = Math.sinh || function(x){
     var y = Math.exp(x);
     return (y - 1/y) / 2;
-};</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-math.sinh', 'Math.sinh')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-math.sinh', 'Math.sinh')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Math.sinh")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Math.acosh()")}}</li>
- <li>{{jsxref("Math.asinh()")}}</li>
- <li>{{jsxref("Math.atanh()")}}</li>
- <li>{{jsxref("Math.cosh()")}}</li>
- <li>{{jsxref("Math.tanh()")}}</li>
-</ul>
+};
+```
+
+## Spécifications
+
+| Spécification                                                            | État                         | Commentaires        |
+| ------------------------------------------------------------------------ | ---------------------------- | ------------------- |
+| {{SpecName('ES2015', '#sec-math.sinh', 'Math.sinh')}} | {{Spec2('ES2015')}}     | Définition initiale |
+| {{SpecName('ESDraft', '#sec-math.sinh', 'Math.sinh')}} | {{Spec2('ESDraft')}} |                     |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Math.sinh")}}
+
+## Voir aussi
+
+- {{jsxref("Math.acosh()")}}
+- {{jsxref("Math.asinh()")}}
+- {{jsxref("Math.atanh()")}}
+- {{jsxref("Math.cosh()")}}
+- {{jsxref("Math.tanh()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/math/sqrt/index.md b/files/fr/web/javascript/reference/global_objects/math/sqrt/index.md
index 6b309e4d01..8af569dd19 100644
--- a/files/fr/web/javascript/reference/global_objects/math/sqrt/index.md
+++ b/files/fr/web/javascript/reference/global_objects/math/sqrt/index.md
@@ -9,86 +9,61 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Math/sqrt
 original_slug: Web/JavaScript/Reference/Objets_globaux/Math/sqrt
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La fonction <code><strong>Math.sqrt()</strong></code> renvoie la racine carrée d'un nombre. Cette fonction est définie par :</p>
+La fonction **`Math.sqrt()`** renvoie la racine carrée d'un nombre. Cette fonction est définie par :
 
-<p><math display="block"><semantics><mrow><mo>∀</mo><mi>x</mi><mo>≥</mo><mn>0</mn><mo>,</mo><mstyle mathvariant="monospace"><mrow><mi>M</mi><mi>a</mi><mi>t</mi><mi>h</mi><mo>.</mo><mi>s</mi><mi>q</mi><mi>r</mi><mi>t</mi><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><msqrt><mi>x</mi></msqrt><mo>=</mo><mtext>l'unique</mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mo>≥</mo><mn>0</mn><mspace width="thickmathspace"></mspace><mtext>tel que</mtext><mspace width="thickmathspace"></mspace><msup><mi>y</mi><mn>2</mn></msup><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\forall x \geq 0, \mathtt{Math.sqrt(x)} = \sqrt{x} = \text{the unique} \; y \geq 0 \; \text{such that} \; y^2 = x</annotation></semantics></math></p>
+<math display="block"><semantics><mrow><mo>∀</mo><mi>x</mi><mo>≥</mo><mn>0</mn><mo>,</mo><mstyle mathvariant="monospace"><mrow><mi>M</mi><mi>a</mi><mi>t</mi><mi>h</mi><mo>.</mo><mi>s</mi><mi>q</mi><mi>r</mi><mi>t</mi><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><msqrt><mi>x</mi></msqrt><mo>=</mo><mtext>l'unique</mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mo>≥</mo><mn>0</mn><mspace width="thickmathspace"></mspace><mtext>tel que</mtext><mspace width="thickmathspace"></mspace><msup><mi>y</mi><mn>2</mn></msup><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\forall x \geq 0, \mathtt{Math.sqrt(x)} = \sqrt{x} = \text{the unique} \; y \geq 0 \; \text{such that} \; y^2 = x</annotation></semantics></math>
 
-<div>{{EmbedInteractiveExample("pages/js/math-sqrt.html")}}</div>
+{{EmbedInteractiveExample("pages/js/math-sqrt.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">Math.sqrt(<var>x</var>)</pre>
+    Math.sqrt(x)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>x</code></dt>
- <dd>Un nombre.</dd>
-</dl>
+- `x`
+  - : Un nombre.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>La racine carrée du nombre passé en argument. Si le nombre fourni est négatif, c'est {{jsxref("NaN")}} qui sera renvoyé.</p>
+La racine carrée du nombre passé en argument. Si le nombre fourni est négatif, c'est {{jsxref("NaN")}} qui sera renvoyé.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Si la valeur de <code>x</code> est négative, <code>sqrt</code> renverra {{jsxref("NaN")}}.</p>
+Si la valeur de `x` est négative, `sqrt` renverra {{jsxref("NaN")}}.
 
-<p><code>sqrt()</code> est une méthode statique de <code>Math</code>, elle doit être utilisée avec la syntaxe <code>Math.sqrt()</code>, elle ne doit pas être appelée comme méthode d'un autre objet qui aurait été créé (<code>Math</code> n'est pas un constructeur).</p>
+`sqrt()` est une méthode statique de `Math`, elle doit être utilisée avec la syntaxe `Math.sqrt()`, elle ne doit pas être appelée comme méthode d'un autre objet qui aurait été créé (`Math` n'est pas un constructeur).
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<pre class="brush:js">Math.sqrt(9);  // 3
+```js
+Math.sqrt(9);  // 3
 Math.sqrt(2);  // 1.414213562373095
 
 Math.sqrt(1);  // 1
 Math.sqrt(0);  // 0
 Math.sqrt(-1); // NaN
-Math.sqrt(-0); // -0</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.0.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.8.2.17', 'Math.sqrt')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-math.sqrt', 'Math.sqrt')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-math.sqrt', 'Math.sqrt')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Math.sqrt")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Math.cbrt()")}}</li>
- <li>{{jsxref("Math.exp()")}}</li>
- <li>{{jsxref("Math.log()")}}</li>
- <li>{{jsxref("Math.pow()")}}</li>
-</ul>
+Math.sqrt(-0); // -0
+```
+
+## 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.8.2.17', 'Math.sqrt')}}     | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-math.sqrt', 'Math.sqrt')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-math.sqrt', 'Math.sqrt')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Math.sqrt")}}
+
+## Voir aussi
+
+- {{jsxref("Math.cbrt()")}}
+- {{jsxref("Math.exp()")}}
+- {{jsxref("Math.log()")}}
+- {{jsxref("Math.pow()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/math/sqrt1_2/index.md b/files/fr/web/javascript/reference/global_objects/math/sqrt1_2/index.md
index 7a1037786c..2af49cd3ca 100644
--- a/files/fr/web/javascript/reference/global_objects/math/sqrt1_2/index.md
+++ b/files/fr/web/javascript/reference/global_objects/math/sqrt1_2/index.md
@@ -9,71 +9,44 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Math/SQRT1_2
 original_slug: Web/JavaScript/Reference/Objets_globaux/Math/SQRT1_2
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La propriété <code><strong>Math.SQRT1_2</strong></code> représente la racine carrée d'1/2 et vaut environ 0.707 :</p>
+La propriété **`Math.SQRT1_2`** représente la racine carrée d'1/2 et vaut environ 0.707 :
 
-<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.SQRT1_2</mi></mstyle><mo>=</mo><msqrt><mfrac><mn>1</mn><mn>2</mn></mfrac></msqrt><mo>=</mo><mfrac><mn>1</mn><msqrt><mn>2</mn></msqrt></mfrac><mo>≈</mo><mn>0.707</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.SQRT1_2}} = \sqrt{\frac{1}{2}} = \frac{1}{\sqrt{2}} \approx 0.707</annotation></semantics></math></p>
+<math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.SQRT1_2</mi></mstyle><mo>=</mo><msqrt><mfrac><mn>1</mn><mn>2</mn></mfrac></msqrt><mo>=</mo><mfrac><mn>1</mn><msqrt><mn>2</mn></msqrt></mfrac><mo>≈</mo><mn>0.707</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.SQRT1_2}} = \sqrt{\frac{1}{2}} = \frac{1}{\sqrt{2}} \approx 0.707</annotation></semantics></math>
 
-<div>{{EmbedInteractiveExample("pages/js/math-sqrt1_2.html")}}</div>
+{{EmbedInteractiveExample("pages/js/math-sqrt1_2.html")}}{{js_property_attributes(0,0,0)}}
 
+## Description
 
+`SQRT1_2` est une propriété statique de `Math` et doit toujours être utilisée avec la syntaxe `Math.SQRT1_2`. Elle ne doit pas être obtenue à partir d'un autre objet qui aurait été créé (`Math` n'est pas un constructeur).
 
-<div>{{js_property_attributes(0,0,0)}}</div>
+## Exemples
 
-<h2 id="Description">Description</h2>
+La fonction suivante renvoie la valeur de cette constante :
 
-<p><code>SQRT1_2</code> est une propriété statique de <code>Math</code> et doit toujours être utilisée avec la syntaxe <code>Math.SQRT1_2</code>. Elle ne doit pas être obtenue à partir d'un autre objet qui aurait été créé (<code>Math</code> n'est pas un constructeur).</p>
-
-<h2 id="Exemples">Exemples</h2>
-
-<p>La fonction suivante renvoie la valeur de cette constante :</p>
-
-<pre class="brush:js">function getRoot1_2() {
+```js
+function getRoot1_2() {
    return Math.SQRT1_2;
 }
 
-getRoot1_2(); // 0.7071067811865476</pre>
+getRoot1_2(); // 0.7071067811865476
+```
 
-<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">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.8.1.7', 'Math.SQRT1_2')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-math.sqrt1_2', 'Math.SQRT1_2')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-math.sqrt1_2', 'Math.SQRT1_2')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
+| Spécification                                                                    | Statut                       | Commentaires                                          |
+| -------------------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- |
+| {{SpecName('ES1')}}                                                         | {{Spec2('ES1')}}         | Définition initiale. Implémentée avec JavaScript 1.0. |
+| {{SpecName('ES5.1', '#sec-15.8.1.7', 'Math.SQRT1_2')}}         | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-math.sqrt1_2', 'Math.SQRT1_2')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-math.sqrt1_2', 'Math.SQRT1_2')}} | {{Spec2('ESDraft')}} |                                                       |
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.Math.SQRT1_2")}}</p>
+{{Compat("javascript.builtins.Math.SQRT1_2")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("Math.pow()")}}</li>
- <li>{{jsxref("Math.sqrt()")}}</li>
-</ul>
+- {{jsxref("Math.pow()")}}
+- {{jsxref("Math.sqrt()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/math/sqrt2/index.md b/files/fr/web/javascript/reference/global_objects/math/sqrt2/index.md
index 964c355404..a9ba6b6994 100644
--- a/files/fr/web/javascript/reference/global_objects/math/sqrt2/index.md
+++ b/files/fr/web/javascript/reference/global_objects/math/sqrt2/index.md
@@ -9,71 +9,44 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Math/SQRT2
 original_slug: Web/JavaScript/Reference/Objets_globaux/Math/SQRT2
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La propriété <code><strong>Math.SQRT2</strong></code> représente la racine carrée de 2 et vaut environ 1.414 :</p>
+La propriété **`Math.SQRT2`** représente la racine carrée de 2 et vaut environ 1.414 :
 
-<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.SQRT2</mi></mstyle><mo>=</mo><msqrt><mn>2</mn></msqrt><mo>≈</mo><mn>1.414</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.SQRT2}} = \sqrt{2} \approx 1.414</annotation></semantics></math></p>
+<math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.SQRT2</mi></mstyle><mo>=</mo><msqrt><mn>2</mn></msqrt><mo>≈</mo><mn>1.414</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.SQRT2}} = \sqrt{2} \approx 1.414</annotation></semantics></math>
 
-<div>{{EmbedInteractiveExample("pages/js/math-sqrt2.html")}}</div>
+{{EmbedInteractiveExample("pages/js/math-sqrt2.html")}}{{js_property_attributes(0,0,0)}}
 
+## Description
 
+`SQRT2` est une propriété statique de `Math` et doit toujours être utilisée avec la syntaxe `Math.SQRT2`, elle ne doit pas être appelée comme propriété d'un autre objet qui aurait été créé (`Math` n'est pas un constructeur).
 
-<div>{{js_property_attributes(0,0,0)}}</div>
+## Exemples
 
-<h2 id="Description">Description</h2>
+La fonction suivante renvoie la valeur de la racine carrée de 2 :
 
-<p><code>SQRT2</code> est une propriété statique de <code>Math</code> et doit toujours être utilisée avec la syntaxe <code>Math.SQRT2</code>, elle ne doit pas être appelée comme propriété d'un autre objet qui aurait été créé (<code>Math</code> n'est pas un constructeur).</p>
-
-<h2 id="Exemples">Exemples</h2>
-
-<p>La fonction suivante renvoie la valeur de la racine carrée de 2 :</p>
-
-<pre class="brush:js">function getRoot2() {
+```js
+function getRoot2() {
    return Math.SQRT2;
 }
 
-getRoot2(); // 1.4142135623730951</pre>
+getRoot2(); // 1.4142135623730951
+```
 
-<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">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.8.1.8', 'Math.SQRT2')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-math.sqrt2', 'Math.SQRT2')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-math.sqrt2', 'Math.SQRT2')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
+| Spécification                                                                | Statut                       | Commentaires                                          |
+| ---------------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- |
+| {{SpecName('ES1')}}                                                     | {{Spec2('ES1')}}         | Définition initiale. Implémentée avec JavaScript 1.0. |
+| {{SpecName('ES5.1', '#sec-15.8.1.8', 'Math.SQRT2')}}         | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-math.sqrt2', 'Math.SQRT2')}}         | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-math.sqrt2', 'Math.SQRT2')}} | {{Spec2('ESDraft')}} |                                                       |
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.Math.SQRT2")}}</p>
+{{Compat("javascript.builtins.Math.SQRT2")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("Math.pow()")}}</li>
- <li>{{jsxref("Math.sqrt()")}}</li>
-</ul>
+- {{jsxref("Math.pow()")}}
+- {{jsxref("Math.sqrt()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/math/tan/index.md b/files/fr/web/javascript/reference/global_objects/math/tan/index.md
index 17d938acab..12b35857d3 100644
--- a/files/fr/web/javascript/reference/global_objects/math/tan/index.md
+++ b/files/fr/web/javascript/reference/global_objects/math/tan/index.md
@@ -9,90 +9,66 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Math/tan
 original_slug: Web/JavaScript/Reference/Objets_globaux/Math/tan
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La fonction <code><strong>Math.tan()</strong></code> renvoie la tangente d'un nombre exprimant un angle en radians.</p>
+La fonction **`Math.tan()`** renvoie la tangente d'un nombre exprimant un angle en radians.
 
-<div>{{EmbedInteractiveExample("pages/js/math-tan.html")}}</div>
+{{EmbedInteractiveExample("pages/js/math-tan.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">Math.tan(<var>x</var>)</pre>
+    Math.tan(x)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>x</code></dt>
- <dd>Un nombre qui représente un angle en radians.</dd>
-</dl>
+- `x`
+  - : Un nombre qui représente un angle en radians.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>La tangente de l'angle fourni en argument (exprimé en radians).</p>
+La tangente de l'angle fourni en argument (exprimé en radians).
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La méthode <code>Math.tan()</code> renvoie une valeur numérique qui représente la tangente d'un angle.</p>
+La méthode `Math.tan()` renvoie une valeur numérique qui représente la tangente d'un angle.
 
-<p><code>tan()</code> est une méthode statique de <code>Math</code> et doit toujours être utilisée avec la syntaxe <code>Math.tan()</code>, elle ne doit pas être utilisée comme méthode d'un autre objet qui aurait été créé (<code>Math</code> n'est pas un constructeur).</p>
+`tan()` est une méthode statique de `Math` et doit toujours être utilisée avec la syntaxe `Math.tan()`, elle ne doit pas être utilisée comme méthode d'un autre objet qui aurait été créé (`Math` n'est pas un constructeur).
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_Math.tan()">Utiliser <code>Math.tan()</code></h3>
+### Utiliser `Math.tan()`
 
-<pre class="brush:js">Math.tan(1); // 1.5574077246549023</pre>
+```js
+Math.tan(1); // 1.5574077246549023
+```
 
-<p><code>Math.tan()</code> considère un argument exprimé en radians. Cependant, on peut vouloir travailler avec des valeurs en degrés. Pour cela, on pourra utiliser la fonction suivante qui calcule la tangente après avoir converti l'argument en radians :</p>
+`Math.tan()` considère un argument exprimé en radians. Cependant, on peut vouloir travailler avec des valeurs en degrés. Pour cela, on pourra utiliser la fonction suivante qui calcule la tangente après avoir converti l'argument en radians :
 
-<pre class="brush:js">function getTanDeg(deg) {
+```js
+function getTanDeg(deg) {
    var rad = deg * Math.PI/180;
    return Math.tan(rad);
 }
-</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.0.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.8.2.18', 'Math.tan')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-math.tan', 'Math.tan')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-math.tan', 'Math.tan')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Math.tan")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Math.acos()")}}</li>
- <li>{{jsxref("Math.asin()")}}</li>
- <li>{{jsxref("Math.atan()")}}</li>
- <li>{{jsxref("Math.atan2()")}}</li>
- <li>{{jsxref("Math.cos()")}}</li>
- <li>{{jsxref("Math.sin()")}}</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.8.2.18', 'Math.tan')}} | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-math.tan', 'Math.tan')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-math.tan', 'Math.tan')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Math.tan")}}
+
+## Voir aussi
+
+- {{jsxref("Math.acos()")}}
+- {{jsxref("Math.asin()")}}
+- {{jsxref("Math.atan()")}}
+- {{jsxref("Math.atan2()")}}
+- {{jsxref("Math.cos()")}}
+- {{jsxref("Math.sin()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/math/tanh/index.md b/files/fr/web/javascript/reference/global_objects/math/tanh/index.md
index be6fc10fd0..88505bc59d 100644
--- a/files/fr/web/javascript/reference/global_objects/math/tanh/index.md
+++ b/files/fr/web/javascript/reference/global_objects/math/tanh/index.md
@@ -11,53 +11,56 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Math/tanh
 original_slug: Web/JavaScript/Reference/Objets_globaux/Math/tanh
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La fonction <code><strong>Math.tanh()</strong></code> renvoie la tangente hyperbolique d'un nombre définie par :</p>
+La fonction **`Math.tanh()`** renvoie la tangente hyperbolique d'un nombre définie par :
 
-<p><math><semantics><mrow><mo lspace="0em" rspace="0em">tanh</mo><mi>x</mi><mo>=</mo><mfrac><mrow><mo lspace="0em" rspace="0em">sinh</mo><mi>x</mi></mrow><mrow><mo lspace="0em" rspace="0em">cosh</mo><mi>x</mi></mrow></mfrac><mo>=</mo><mfrac><mrow><msup><mi>e</mi><mi>x</mi></msup><mo>-</mo><msup><mi>e</mi><mrow><mo>-</mo><mi>x</mi></mrow></msup></mrow><mrow><msup><mi>e</mi><mi>x</mi></msup><mo>+</mo><msup><mi>e</mi><mrow><mo>-</mo><mi>x</mi></mrow></msup></mrow></mfrac><mo>=</mo><mfrac><mrow><msup><mi>e</mi><mrow><mn>2</mn><mi>x</mi></mrow></msup><mo>-</mo><mn>1</mn></mrow><mrow><msup><mi>e</mi><mrow><mn>2</mn><mi>x</mi></mrow></msup><mo>+</mo><mn>1</mn></mrow></mfrac></mrow><annotation encoding="TeX">\tanh x = \frac{\sinh x}{\cosh x} = \frac {e^x - e^{-x}} {e^x + e^{-x}} = \frac{e^{2x} - 1}{e^{2x}+1}</annotation></semantics></math></p>
+<math><semantics><mrow><mo lspace="0em" rspace="0em">tanh</mo><mi>x</mi><mo>=</mo><mfrac><mrow><mo lspace="0em" rspace="0em">sinh</mo><mi>x</mi></mrow><mrow><mo lspace="0em" rspace="0em">cosh</mo><mi>x</mi></mrow></mfrac><mo>=</mo><mfrac><mrow><msup><mi>e</mi><mi>x</mi></msup><mo>-</mo><msup><mi>e</mi><mrow><mo>-</mo><mi>x</mi></mrow></msup></mrow><mrow><msup><mi>e</mi><mi>x</mi></msup><mo>+</mo><msup><mi>e</mi><mrow><mo>-</mo><mi>x</mi></mrow></msup></mrow></mfrac><mo>=</mo><mfrac><mrow><msup><mi>e</mi><mrow><mn>2</mn><mi>x</mi></mrow></msup><mo>-</mo><mn>1</mn></mrow><mrow><msup><mi>e</mi><mrow><mn>2</mn><mi>x</mi></mrow></msup><mo>+</mo><mn>1</mn></mrow></mfrac></mrow><annotation encoding="TeX">\tanh x = \frac{\sinh x}{\cosh x} = \frac {e^x - e^{-x}} {e^x + e^{-x}} = \frac{e^{2x} - 1}{e^{2x}+1}</annotation></semantics></math>
 
-<div>{{EmbedInteractiveExample("pages/js/math-tanh.html")}}</div>
+{{EmbedInteractiveExample("pages/js/math-tanh.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">Math.tanh(<var>x</var>)</pre>
+    Math.tanh(x)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>x</code></dt>
- <dd>Un nombre.</dd>
-</dl>
+- `x`
+  - : Un nombre.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>La tangente hyperbolique du nombre fourni en argument.</p>
+La tangente hyperbolique du nombre fourni en argument.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p><code>tanh()</code> est une méthode statique de l'objet <code>Math</code>, elle doit toujours être utilisée avec la syntaxe <code>Math.tanh()</code>, elle ne doit pas être utilisée comme une méthode d'un objet <code>Math</code> qui aurait été instancié (<code>Math</code> n'est pas une constructeur).</p>
+`tanh()` est une méthode statique de l'objet `Math`, elle doit toujours être utilisée avec la syntaxe `Math.tanh()`, elle ne doit pas être utilisée comme une méthode d'un objet `Math` qui aurait été instancié (`Math` n'est pas une constructeur).
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_Math.tanh()">Utiliser <code>Math.tanh()</code></h3>
+### Utiliser `Math.tanh()`
 
-<pre class="brush:js">Math.tanh(0);        // 0
+```js
+Math.tanh(0);        // 0
 Math.tanh(Infinity); // 1
-Math.tanh(1);        // 0.7615941559557649</pre>
+Math.tanh(1);        // 0.7615941559557649
+```
 
-<h2 id="Prothèse_d'émulation_(polyfill)">Prothèse d'émulation (<em>polyfill</em>)</h2>
+## Prothèse d'émulation (_polyfill_)
 
-<p>Cette méthode peut être émulée grâce à la fonction {{jsxref("Objets_globaux/Math/exp", "Math.exp()")}} :</p>
+Cette méthode peut être émulée grâce à la fonction {{jsxref("Objets_globaux/Math/exp", "Math.exp()")}} :
 
-<pre class="brush: js">Math.tanh = Math.tanh || function(x){
+```js
+Math.tanh = Math.tanh || function(x){
   var a = Math.exp(+x), b = Math.exp(-x);
   return a == Infinity ? 1 : b == Infinity ? -1 : (a - b) / (a + b);
-}</pre>
+}
+```
 
-<p>et si on souhaite n'utiliser qu'un seul appel à {{jsxref("Objets_globaux/Math/exp", "Math.exp()")}}<code> :</code></p>
+et si on souhaite n'utiliser qu'un seul appel à {{jsxref("Objets_globaux/Math/exp", "Math.exp()")}}` :`
 
-<pre class="brush: js">Math.tanhx = Math.tanhx || function(x) {
+```js
+Math.tanhx = Math.tanhx || function(x) {
   if(x === Infinity) {
     return 1;
   } else if(x === -Infinity) {
@@ -66,40 +69,24 @@ Math.tanh(1);        // 0.7615941559557649</pre>
     var y = Math.exp(2 * x);
     return (y - 1) / (y + 1);
   }
-};</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-math.tanh', 'Math.tanh')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-math.tanh', 'Math.tanh')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Math.tanh")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Math.acosh()")}}</li>
- <li>{{jsxref("Math.asinh()")}}</li>
- <li>{{jsxref("Math.atanh()")}}</li>
- <li>{{jsxref("Math.cosh()")}}</li>
- <li>{{jsxref("Math.sinh()")}}</li>
-</ul>
+};
+```
+
+## Spécifications
+
+| Spécification                                                            | État                         | Commentaires         |
+| ------------------------------------------------------------------------ | ---------------------------- | -------------------- |
+| {{SpecName('ES2015', '#sec-math.tanh', 'Math.tanh')}} | {{Spec2('ES2015')}}     | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-math.tanh', 'Math.tanh')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Math.tanh")}}
+
+## Voir aussi
+
+- {{jsxref("Math.acosh()")}}
+- {{jsxref("Math.asinh()")}}
+- {{jsxref("Math.atanh()")}}
+- {{jsxref("Math.cosh()")}}
+- {{jsxref("Math.sinh()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/math/trunc/index.md b/files/fr/web/javascript/reference/global_objects/math/trunc/index.md
index c78b0cb6ec..64c918039a 100644
--- a/files/fr/web/javascript/reference/global_objects/math/trunc/index.md
+++ b/files/fr/web/javascript/reference/global_objects/math/trunc/index.md
@@ -11,84 +11,67 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Math/trunc
 original_slug: Web/JavaScript/Reference/Objets_globaux/Math/trunc
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La fonction <code><strong>Math.trunc()</strong></code> retourne la troncature entière d'un nombre en retirant sa partie décimale.</p>
+La fonction **`Math.trunc()`** retourne la troncature entière d'un nombre en retirant sa partie décimale.
 
-<p><math><semantics><mrow><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.trunc</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mrow><mo>{</mo><mtable columnalign="left left"><mtr><mtd><mrow><mo>⌊</mo><mi>x</mi><mo>⌋</mo></mrow></mtd><mtd><mtext>si</mtext></mtd><mtd><mi>x</mi><mo>≥</mo><mn>0</mn></mtd></mtr><mtr><mtd><mrow><mo>⌈</mo><mi>x</mi><mo>⌉</mo></mrow></mtd><mtd><mtext>si</mtext></mtd><mtd><mi>x</mi><mo>&lt;</mo><mn>0</mn></mtd></mtr></mtable></mrow></mrow><annotation encoding="TeX">\mathtt{\operatorname{Math.trunc}(x)} = \begin{cases} \left\lfloor x \right\rfloor &amp; \text{if} &amp; x \geq 0 \\ \left\lceil x \right\rceil &amp; \text{if} &amp;x &lt; 0 \end{cases}</annotation></semantics></math></p>
+<math><semantics><mrow><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.trunc</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mrow><mo>{</mo><mtable columnalign="left left"><mtr><mtd><mrow><mo>⌊</mo><mi>x</mi><mo>⌋</mo></mrow></mtd><mtd><mtext>si</mtext></mtd><mtd><mi>x</mi><mo>≥</mo><mn>0</mn></mtd></mtr><mtr><mtd><mrow><mo>⌈</mo><mi>x</mi><mo>⌉</mo></mrow></mtd><mtd><mtext>si</mtext></mtd><mtd><mi>x</mi><mo>&#x3C;</mo><mn>0</mn></mtd></mtr></mtable></mrow></mrow><annotation encoding="TeX">\mathtt{\operatorname{Math.trunc}(x)} = \begin{cases} \left\lfloor x \right\rfloor &#x26; \text{if} &#x26; x \geq 0 \\ \left\lceil x \right\rceil &#x26; \text{if} &#x26;x &#x3C; 0 \end{cases}</annotation></semantics></math>
 
-<div>{{EmbedInteractiveExample("pages/js/math-trunc.html")}}</div>
+{{EmbedInteractiveExample("pages/js/math-trunc.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">Math.trunc(<var>x</var>)</pre>
+    Math.trunc(x)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>x</code></dt>
- <dd>Un nombre.</dd>
-</dl>
+- `x`
+  - : Un nombre.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>La partie entière du nombre passé en argument.</p>
+La partie entière du nombre passé en argument.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Contrairement aux autres méthodes {{jsxref("Math.floor()")}}, {{jsxref("Math.ceil()")}} et {{jsxref("Math.round()")}}, <code>Math.trunc()</code> fonctionne de façon très simple : la partie décimale du nombre est retirée et on conserve la partie entière (que le nombre soit positif ou négatif).<br>
- <br>
- Ainsi, si l'argument est un nombre positif, <code>Math.trunc()</code> sera équivalent à <code>Math.floor()</code>, sinon <code>Math.trunc()</code> sera équivalent à <code>Math.ceil()</code>.</p>
+Contrairement aux autres méthodes {{jsxref("Math.floor()")}}, {{jsxref("Math.ceil()")}} et {{jsxref("Math.round()")}}, `Math.trunc()` fonctionne de façon très simple : la partie décimale du nombre est retirée et on conserve la partie entière (que le nombre soit positif ou négatif).
 
-<p>On notera que l'argument passé à la méthode est converti en nombre de façon implicite.</p>
+Ainsi, si l'argument est un nombre positif, `Math.trunc()` sera équivalent à `Math.floor()`, sinon `Math.trunc()` sera équivalent à `Math.ceil()`.
 
-<p><code>trunc()</code> est une méthode statique de <code>Math</code>, elle doit toujours être utilisée avec la syntaxe <code>Math.trunc()</code>, elle ne doit pas être utilisée comme la méthode d'un objet qui aurait été instancié (<code>Math</code> n'est pas un constructeur).</p>
+On notera que l'argument passé à la méthode est converti en nombre de façon implicite.
 
-<h2 id="Exemples">Exemples</h2>
+`trunc()` est une méthode statique de `Math`, elle doit toujours être utilisée avec la syntaxe `Math.trunc()`, elle ne doit pas être utilisée comme la méthode d'un objet qui aurait été instancié (`Math` n'est pas un constructeur).
 
-<h3 id="Utiliser_Math.trunc()">Utiliser <code>Math.trunc()</code></h3>
+## Exemples
 
-<pre class="brush:js">Math.trunc(13.37);   // 13
+### Utiliser `Math.trunc()`
+
+```js
+Math.trunc(13.37);   // 13
 Math.trunc(42.84);   // 42
 Math.trunc(0.123);   //  0
 Math.trunc(-0.123);  // -0
 Math.trunc("-1.123");// -1
 Math.trunc(NaN);     // NaN
 Math.trunc("toto");  // NaN
-Math.trunc();        // NaN</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-math.trunc', 'Math.trunc')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Première définition.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-math.trunc', 'Math.trunc')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Math.trunc")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Math.abs()")}}</li>
- <li>{{jsxref("Math.ceil()")}}</li>
- <li>{{jsxref("Math.floor()")}}</li>
- <li>{{jsxref("Math.round()")}}</li>
- <li>{{jsxref("Math.sign()")}}</li>
-</ul>
+Math.trunc();        // NaN
+```
+
+## Spécifications
+
+| Spécification                                                                | État                         | Commentaire          |
+| ---------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ES2015', '#sec-math.trunc', 'Math.trunc')}}     | {{Spec2('ES2015')}}     | Première définition. |
+| {{SpecName('ESDraft', '#sec-math.trunc', 'Math.trunc')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Math.trunc")}}
+
+## Voir aussi
+
+- {{jsxref("Math.abs()")}}
+- {{jsxref("Math.ceil()")}}
+- {{jsxref("Math.floor()")}}
+- {{jsxref("Math.round()")}}
+- {{jsxref("Math.sign()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/nan/index.md b/files/fr/web/javascript/reference/global_objects/nan/index.md
index b2fa6e4105..f6608f929c 100644
--- a/files/fr/web/javascript/reference/global_objects/nan/index.md
+++ b/files/fr/web/javascript/reference/global_objects/nan/index.md
@@ -8,82 +8,60 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/NaN
 original_slug: Web/JavaScript/Reference/Objets_globaux/NaN
 ---
-<div>{{jsSidebar("Objects")}}</div>
+{{jsSidebar("Objects")}}
 
-<p>La propriété globale <code><strong>NaN</strong></code> est une valeur utilisée pour représenter une quantité qui n'est pas un nombre (<em><strong>N</strong>ot <strong>a</strong> <strong>N</strong>umber</em> en anglais).</p>
+La propriété globale **`NaN`** est une valeur utilisée pour représenter une quantité qui n'est pas un nombre (**\*N**ot **a** **N**umber\* en anglais).
 
-<p>{{js_property_attributes(0,0,0)}}</p>
+{{js_property_attributes(0,0,0)}}
 
-<div>{{EmbedInteractiveExample("pages/js/globalprops-nan.html")}}</div>
+{{EmbedInteractiveExample("pages/js/globalprops-nan.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">NaN</pre>
+    NaN
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p><code>NaN</code> est une propriété de <em>l'objet global</em>, c'est-à-dire qu'elle est accessible globalement.</p>
+`NaN` est une propriété de _l'objet global_, c'est-à-dire qu'elle est accessible globalement.
 
-<p>La valeur initiale de <code>NaN</code> est <code>Number.NaN</code>. Dans les navigateurs modernes, <code>NaN</code> est une propriété non-configurable et non-écrivable. Si ce n'est pas le cas, il faut éviter de la modifier et de l'écraser.</p>
+La valeur initiale de `NaN` est `Number.NaN`. Dans les navigateurs modernes, `NaN` est une propriété non-configurable et non-écrivable. Si ce n'est pas le cas, il faut éviter de la modifier et de l'écraser.
 
-<p>Il est rare d'utiliser expressément <code>NaN</code> dans un programme. On récupère généralement <code>NaN</code> comme le résultat d'une fonction mathématique qui échoue (<code>Math.sqrt(-1)</code>) où quand une fonction qui tente d'interpréter un nombre échoue (<code>parseInt("blabla")</code>).</p>
+Il est rare d'utiliser expressément `NaN` dans un programme. On récupère généralement `NaN` comme le résultat d'une fonction mathématique qui échoue (`Math.sqrt(-1)`) où quand une fonction qui tente d'interpréter un nombre échoue (`parseInt("blabla")`).
 
-<h3 id="Tester_NaN">Tester <code>NaN</code></h3>
+### Tester `NaN`
 
-<p>Les <a href="/fr/docs/Web/JavaScript/Les_diff%C3%A9rents_tests_d_%C3%A9galit%C3%A9_comment_les_utiliser">opérateurs d'égalité</a> (<code>==</code> et <code>===</code>) ne peuvent pas être utilisé pour tester une valeur par rapport à <code>NaN</code>. Il faut utiliser {{jsxref("Number.isNaN()")}} ou {{jsxref("isNaN", "isNaN()")}} à la place.</p>
+Les [opérateurs d'égalité](/fr/docs/Web/JavaScript/Les_diff%C3%A9rents_tests_d_%C3%A9galit%C3%A9_comment_les_utiliser) (`==` et `===`) ne peuvent pas être utilisé pour tester une valeur par rapport à `NaN`. Il faut utiliser {{jsxref("Number.isNaN()")}} ou {{jsxref("isNaN", "isNaN()")}} à la place.
 
-<pre class="brush: js">NaN === NaN;        // false
+```js
+NaN === NaN;        // false
 Number.NaN === NaN; // false
 isNaN(NaN);         // true
 isNaN(Number.NaN);  // true
-</pre>
-
-<p>La différence entre <code>isNaN()</code> et <code>Number.isNaN()</code> est la façon dont les valeurs sont, ou non, converties en nombre avant de vérifier si la valeur est <code>NaN</code> : <code>isNaN()</code> convertira l'argument en nombre avant de vérifier alors que <code>Number.isNaN()</code> ne renverra <code>true</code> que si l'opérande vaut <code>NaN</code>.</p>
-
-<pre class="brush: js">isNaN('coucou monde');        // renvoie true
-Number.isNaN('coucou monde'); // renvoie 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('ES1')}}</td>
-   <td>{{Spec2('ES1')}}</td>
-   <td>Définition initiale. Implémentée avec JavaScript 1.3</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.1.1.1', 'NaN')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-value-properties-of-the-global-object-nan', 'NaN')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-value-properties-of-the-global-object-nan', 'NaN')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.NaN")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Number.NaN")}}</li>
- <li>{{jsxref("Number.isNaN()")}}</li>
- <li>{{jsxref("isNaN", "isNaN()")}}</li>
- <li><a href="/fr/docs/Web/JavaScript/Guide/%C3%89galit%C3%A9_en_JavaScript">L'égalité en JavaScript</a></li>
-</ul>
+```
+
+La différence entre `isNaN()` et `Number.isNaN()` est la façon dont les valeurs sont, ou non, converties en nombre avant de vérifier si la valeur est `NaN` : `isNaN()` convertira l'argument en nombre avant de vérifier alors que `Number.isNaN()` ne renverra `true` que si l'opérande vaut `NaN`.
+
+```js
+isNaN('coucou monde');        // renvoie true
+Number.isNaN('coucou monde'); // renvoie false
+```
+
+## Spécifications
+
+| Spécification                                                                                                | État                         | Commentaires                                         |
+| ------------------------------------------------------------------------------------------------------------ | ---------------------------- | ---------------------------------------------------- |
+| {{SpecName('ES1')}}                                                                                     | {{Spec2('ES1')}}         | Définition initiale. Implémentée avec JavaScript 1.3 |
+| {{SpecName('ES5.1', '#sec-15.1.1.1', 'NaN')}}                                                 | {{Spec2('ES5.1')}}     |                                                      |
+| {{SpecName('ES6', '#sec-value-properties-of-the-global-object-nan', 'NaN')}}         | {{Spec2('ES6')}}         |                                                      |
+| {{SpecName('ESDraft', '#sec-value-properties-of-the-global-object-nan', 'NaN')}} | {{Spec2('ESDraft')}} |                                                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.NaN")}}
+
+## Voir aussi
+
+- {{jsxref("Number.NaN")}}
+- {{jsxref("Number.isNaN()")}}
+- {{jsxref("isNaN", "isNaN()")}}
+- [L'égalité en JavaScript](/fr/docs/Web/JavaScript/Guide/%C3%89galit%C3%A9_en_JavaScript)
diff --git a/files/fr/web/javascript/reference/global_objects/null/index.md b/files/fr/web/javascript/reference/global_objects/null/index.md
index fb9a228f19..265e06cd86 100644
--- a/files/fr/web/javascript/reference/global_objects/null/index.md
+++ b/files/fr/web/javascript/reference/global_objects/null/index.md
@@ -9,31 +9,34 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/null
 original_slug: Web/JavaScript/Reference/Objets_globaux/null
 ---
-<div>{{jsSidebar("Objects")}}</div>
+{{jsSidebar("Objects")}}
 
-<p>La valeur <strong><code>null</code></strong> est un littéral JavaScript représentant la nullité au sens où aucune valeur pour l'objet n'est présente. C'est une des valeurs primitives de JavaScript.</p>
+La valeur **`null`** est un littéral JavaScript représentant la nullité au sens où aucune valeur pour l'objet n'est présente. C'est une des valeurs primitives de JavaScript.
 
-<div>{{EmbedInteractiveExample("pages/js/globalprops-null.html")}}</div>
+{{EmbedInteractiveExample("pages/js/globalprops-null.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">null</pre>
+    null
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La valeur <code>null</code> est un littéral (et non pas une propriété de l'objet global telle que {{jsxref("undefined")}}). Dans certaines API, <code>null</code> est souvent utilisé en valeur de retour lorsqu'un objet est attendu mais qu'aucun objet ne convient. Lors de tests d'égalité avec <code>null</code> ou <code>undefined</code>, il faut faire attention aux <a href="/fr/docs/Web/JavaScript/Les_différents_tests_d_égalité_comment_les_utiliser">différences entre les opérateurs d'égalité faible (==) et stricte (===)</a> (on aura une conversion de type avec le premier).</p>
+La valeur `null` est un littéral (et non pas une propriété de l'objet global telle que {{jsxref("undefined")}}). Dans certaines API, `null` est souvent utilisé en valeur de retour lorsqu'un objet est attendu mais qu'aucun objet ne convient. Lors de tests d'égalité avec `null` ou `undefined`, il faut faire attention aux [différences entre les opérateurs d'égalité faible (==) et stricte (===)](/fr/docs/Web/JavaScript/Les_différents_tests_d_égalité_comment_les_utiliser) (on aura une conversion de type avec le premier).
 
-<pre class="brush: js">// toto n'existe pas, n'a pas été défini et n'a jamais été initialisé
+```js
+// toto n'existe pas, n'a pas été défini et n'a jamais été initialisé
 toto;
 "ReferenceError: toto is not defined"
 
 // toto existe mais n'a ni type ni valeur
 var toto = null;
-console.log(toto); // null</pre>
+console.log(toto); // null
+```
 
-<h3 id="Différence_entre_null_et_undefined">Différence entre <code>null</code> et <code>undefined</code></h3>
+### Différence entre `null` et `undefined`
 
-<pre class="brush: js">typeof null;           // "object" (pas null pour des raisons historiques)
+```js
+typeof null;           // "object" (pas null pour des raisons historiques)
 typeof undefined;      // "undefined"
 null === undefined;    // false
 null  == undefined;    // true
@@ -42,47 +45,22 @@ null  == null;         // true
 !null;                 // true
 isNaN(1 + null);       // false
 isNaN(1 + undefined);  // 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('ES1')}}</td>
-   <td>{{Spec2('ES1')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-4.3.11', 'null value')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-null-value', 'null value')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-null-value', 'null value')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.null")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("undefined")}}</li>
- <li>{{jsxref("NaN")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                | État                         | Commentaires         |
+| ---------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ES1')}}                                                     | {{Spec2('ES1')}}         | Définition initiale. |
+| {{SpecName('ES5.1', '#sec-4.3.11', 'null value')}}         | {{Spec2('ES5.1')}}     |                      |
+| {{SpecName('ES6', '#sec-null-value', 'null value')}}         | {{Spec2('ES6')}}         |                      |
+| {{SpecName('ESDraft', '#sec-null-value', 'null value')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.null")}}
+
+## Voir aussi
+
+- {{jsxref("undefined")}}
+- {{jsxref("NaN")}}
diff --git a/files/fr/web/javascript/reference/global_objects/number/epsilon/index.md b/files/fr/web/javascript/reference/global_objects/number/epsilon/index.md
index 88138770c9..cc86d668c0 100644
--- a/files/fr/web/javascript/reference/global_objects/number/epsilon/index.md
+++ b/files/fr/web/javascript/reference/global_objects/number/epsilon/index.md
@@ -11,65 +11,47 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Number/EPSILON
 original_slug: Web/JavaScript/Reference/Objets_globaux/Number/EPSILON
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La propriété <strong><code>Number.EPSILON</code></strong> représente la différence entre le chiffre 1 (un) et la plus petite valeur supérieure à 1 qui peut être représentée par un nombre en JavaScript.</p>
+La propriété **`Number.EPSILON`** représente la différence entre le chiffre 1 (un) et la plus petite valeur supérieure à 1 qui peut être représentée par un nombre en JavaScript.
 
-<p>Il n'est pas nécessaire de créer un objet {{jsxref("Number")}} pour accéder à cette propriété statique, elle est accessible avec <code>Number.EPSILON</code>.</p>
+Il n'est pas nécessaire de créer un objet {{jsxref("Number")}} pour accéder à cette propriété statique, elle est accessible avec `Number.EPSILON`.
 
-<div>{{EmbedInteractiveExample("pages/js/number-epsilon.html")}}</div>
+{{EmbedInteractiveExample("pages/js/number-epsilon.html")}}{{js_property_attributes(0,0,0)}}
 
+## Description
 
+La propriété `EPSILON` vaut environ `2.2204460492503130808472633361816E-16` (ce qui correspond à 2^-52).
 
-<div>{{js_property_attributes(0,0,0)}}</div>
+## Exemple
 
-<h2 id="Description">Description</h2>
+### Tester une égalité mathématique avec un seuil de précision
 
-<p>La propriété <code>EPSILON</code> vaut environ <code>2.2204460492503130808472633361816E-16</code> (ce qui correspond à 2^-52).</p>
-
-<h2 id="Exemple">Exemple</h2>
-
-<h3 id="Tester_une_égalité_mathématique_avec_un_seuil_de_précision">Tester une égalité mathématique avec un seuil de précision</h3>
-
-<pre class="brush: js">x = 0.2;
+```js
+x = 0.2;
 y = 0.3;
-equal = (Math.abs(x - y) &lt; Number.EPSILON);</pre>
+equal = (Math.abs(x - y) < Number.EPSILON);
+```
 
-<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 (Number.EPSILON === undefined) {
+```js
+if (Number.EPSILON === undefined) {
   Number.EPSILON  =  Math.pow(2, -52);
 }
-</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-number.epsilon', 'Number.EPSILON')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-number.epsilon', 'Number.EPSILON')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Number.EPSILON")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>L'objet {{jsxref("Number")}} auquel appartient cette propriété.</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                        | État                         | Commentaires         |
+| ------------------------------------------------------------------------------------ | ---------------------------- | -------------------- |
+| {{SpecName('ES2015', '#sec-number.epsilon', 'Number.EPSILON')}} | {{Spec2('ES2015')}}     | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-number.epsilon', 'Number.EPSILON')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Number.EPSILON")}}
+
+## Voir aussi
+
+- L'objet {{jsxref("Number")}} auquel appartient cette propriété.
diff --git a/files/fr/web/javascript/reference/global_objects/number/index.md b/files/fr/web/javascript/reference/global_objects/number/index.md
index bc4c146cca..67e0253224 100644
--- a/files/fr/web/javascript/reference/global_objects/number/index.md
+++ b/files/fr/web/javascript/reference/global_objects/number/index.md
@@ -8,137 +8,129 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Number
 original_slug: Web/JavaScript/Reference/Objets_globaux/Number
 ---
-<div>{{JSRef}}</div>
-
-<p>L'objet <strong><code>Number</code></strong> est une enveloppe objet (<em>wrapper</em>) autour du <a href="/fr/docs/Web/JavaScript/Structures_de_données#Le_type_nombre">type primitif numérique</a>. Autrement dit, il est utilisé pour manipuler les nombres comme des objets. Pour créer un objet <code>Number</code>, on utilise le constructeur <code>Number()</code>.</p>
-
-<p>Le type JavaScript <code>Number</code> utilise <a href="https://fr.wikipedia.org/wiki/IEEE_754">une représentation binaire à précision double sur 64 bits telle que décrite par le standard IEEE 754</a>. Les implémentations plus récentes offrent un nouveau type : {{jsxref("BigInt")}} qui permet de représenter des entiers avec une précision arbitraire.</p>
-
-<h2 id="Syntaxe">Syntaxe</h2>
-
-<pre class="syntaxbox notranslate">new Number(valeur);
-var a = new Number('123'); // a === 123 donnera false
-var b = Number('123'); // b === 123 donnera true
-a instanceof Number; // donnera true
-b instanceof Number; // donnera false</pre>
-
-<h3 id="Paramètres">Paramètres</h3>
-
-<dl>
- <dt><code>valeur</code></dt>
- <dd>La valeur numérique pour l'objet qu'on souhaite créer.</dd>
-</dl>
-
-<h2 id="Description">Description</h2>
-
-<p>L'objet <code>Number</code> est principalement utilisé dans les cas de figure suivants :</p>
-
-<ul>
- <li>Si l'argument ne peut pas être converti en un nombre, il renverra {{jsxref("NaN")}}.</li>
- <li>Dans un contexte de fonction simple (quand il n'est pas utilisé comme un constructeur avec l'opérateur {{jsxref("Opérateurs/L_opérateur_new", "new")}}), <code>Number</code> peut être utilisé afin d'effectuer des conversions.</li>
-</ul>
-
-<h2 id="Propriétés">Propriétés</h2>
-
-<dl>
- <dt>{{jsxref("Number.EPSILON")}}</dt>
- <dd>Le plus petit intervalle entre deux valeurs qu'il est possible de représenter en JavaScript.</dd>
- <dt>{{jsxref("Number.MAX_SAFE_INTEGER")}}</dt>
- <dd>La valeur entière maximale qu'on peut représenter en JavaScript (<code>2^53 - 1</code>).</dd>
- <dt>{{jsxref("Number.MAX_VALUE")}}</dt>
- <dd>La valeur numérique maximale qu'on peut représenter en JavaScript.</dd>
- <dt>{{jsxref("Number.MIN_SAFE_INTEGER")}}</dt>
- <dd>La valeur entière minimale qu'on peut représenter en JavaScript (<code>-(2^53 - 1)</code>).</dd>
- <dt>{{jsxref("Number.MIN_VALUE")}}</dt>
- <dd>La plus petite valeur qu'on peut représenter en JavaScript, c'est-à-dire le plus petit nombre positif (le nombre le plus près de zéro qui n'est pas égal à zéro et qu'on peut représenter en JavaScript).</dd>
- <dt>{{jsxref("Number.NaN")}}</dt>
- <dd>Une valeur spéciale pour représenter les valeurs non-numériques (<strong>NaN</strong> correspond à « <em><strong>n</strong>ot <strong>a</strong> <strong>n</strong>umber</em> » en anglais, qui signifie « n'est pas un nombre »).</dd>
- <dt>{{jsxref("Number.NEGATIVE_INFINITY")}}</dt>
- <dd>Une valeur spéciale pour représenter l'infini négatif.</dd>
- <dt>{{jsxref("Number.POSITIVE_INFINITY")}}</dt>
- <dd>Une valeur spéciale pour représenter l'infini (positif).</dd>
- <dt>{{jsxref("Number.prototype")}}</dt>
- <dd>Cet objet permet d'ajouter des propriétés aux instances de <code>Number</code>.</dd>
-</dl>
-
-<h2 id="Méthodes">Méthodes</h2>
-
-<dl>
- <dt>{{jsxref("Number.isNaN()")}}</dt>
- <dd>Cette méthode permet de déterminer si la valeur passée en argument vaut <code>NaN</code>.</dd>
- <dt>{{jsxref("Number.isFinite()")}}</dt>
- <dd>Cette méthode permet de déterminer si la valeur numérique passée en argument est un nombre fini.</dd>
- <dt>{{jsxref("Number.isInteger()")}}</dt>
- <dd>Cette méthode permet de déterminer si la valeur passée en argument est un entier.</dd>
- <dt>{{jsxref("Number.isSafeInteger()")}}</dt>
- <dd>Cette méthode permet de déterminer si la valeur passée en argument peut correctement être représentée comme un entier en JavaScript (savoir si elle est comprise entre <code>-(2^53 - 1)</code> et <code>2^53 - 1</code>).</dd>
- <dt>{{jsxref("Number.toInteger()")}} {{obsolete_inline}}</dt>
- <dd>Cette méthode est utilisée afin d'évaluer et de convertir la valeur passée en argument en entier (ou en l'{{jsxref("Infinity", "infini","",1)}}). Cette méthode a été supprimée.</dd>
- <dt>{{jsxref("Number.parseFloat()", "Number.parseFloat(<var>string</var>)")}}</dt>
- <dd>Cette méthode correspond à la méthode {{jsxref("parseFloat", "parseFloat()")}} de l'objet global.</dd>
- <dt>{{jsxref("Number.parseInt()", "Number.parseInt(<var>string</var>, [<var>radix</var>])")}}</dt>
- <dd>Cette méthode correspond à la méthode {{jsxref("parseInt", "parseInt()")}} de l'objet global.</dd>
-</dl>
-
-<h2 id="Les_instances_de_Number">Les instances de <code>Number</code></h2>
-
-<p>Toutes les instances de <code>Number</code> héritent de {{jsxref("Number.prototype")}}. Il est possible de modifier le prototype du constructeur <code>Number</code> pour affecter toutes les instances de <code>Number</code>.</p>
-
-<h3 id="Méthodes_2">Méthodes</h3>
-
-<div>
-<dl>
- <dt>{{jsxref("Number.prototype.toExponential()" ,"Number.prototype.toExponential(<var>fractionDigits</var>)")}}</dt>
- <dd>Retourne une chaîne représentant le nombre en notation exponentielle.</dd>
- <dt>{{jsxref("Number.prototype.toFixed()", "Number.prototype.toFixed(<var>digits</var>)")}}</dt>
- <dd>Retourne une chaîne représentant le nombre avec la notation virgule fixe.</dd>
- <dt>{{jsxref("Number.prototype.toLocaleString()", "Number.prototype.toLocaleString([<var>locales</var> [, <var>options</var>]])")}}</dt>
- <dd>Retourne une chaîne avec une représentation sensible à la langue de ce nombre. Surcharge la méthode {{jsxref("Object.prototype.toLocaleString()")}}.</dd>
- <dt>{{jsxref("Number.prototype.toPrecision()", "Number.prototype.toPrecision(<var>precision</var>)")}}</dt>
- <dd>Retourne une chaîne représentant le nombre avec une précision donnée en notation virgule fixe ou exponentielle.</dd>
- <dt>{{jsxref("Number.prototype.toString()", "Number.prototype.toString([<var>radix</var>])")}}</dt>
- <dd>Retourne une chaîne représentant le nombre dans une base numérique (radix) donnée. Surcharge la méthode {{jsxref("Object.prototype.toString()")}}.</dd>
- <dt>{{jsxref("Number.prototype.valueOf()")}}</dt>
- <dd>Retourne la valeur primitive de l'objet spécifié. Surcharge la méthode {{jsxref("Object.prototype.valueOf()")}}.</dd>
-</dl>
-</div>
-
-<h2 id="Exemples">Exemples</h2>
-
-<h3 id="Utiliser_lobjet_Number_pour_affecter_des_valeurs_numériques_à_des_variables">Utiliser l'objet <code>Number</code> pour affecter des valeurs numériques à des variables</h3>
-
-<p>Dans l'exemple suivant, on utilise les propriétés de l'objet <code>Number</code> pour affecter des valeurs à des variables numériques :</p>
-
-<pre class="brush: js notranslate">var plusGrandNombre = Number.MAX_VALUE;
+{{JSRef}}
+
+L'objet **`Number`** est une enveloppe objet (_wrapper_) autour du [type primitif numérique](/fr/docs/Web/JavaScript/Structures_de_données#Le_type_nombre). Autrement dit, il est utilisé pour manipuler les nombres comme des objets. Pour créer un objet `Number`, on utilise le constructeur `Number()`.
+
+Le type JavaScript `Number` utilise [une représentation binaire à précision double sur 64 bits telle que décrite par le standard IEEE 754](https://fr.wikipedia.org/wiki/IEEE_754). Les implémentations plus récentes offrent un nouveau type : {{jsxref("BigInt")}} qui permet de représenter des entiers avec une précision arbitraire.
+
+## Syntaxe
+
+    new Number(valeur);
+    var a = new Number('123'); // a === 123 donnera false
+    var b = Number('123'); // b === 123 donnera true
+    a instanceof Number; // donnera true
+    b instanceof Number; // donnera false
+
+### Paramètres
+
+- `valeur`
+  - : La valeur numérique pour l'objet qu'on souhaite créer.
+
+## Description
+
+L'objet `Number` est principalement utilisé dans les cas de figure suivants :
+
+- Si l'argument ne peut pas être converti en un nombre, il renverra {{jsxref("NaN")}}.
+- Dans un contexte de fonction simple (quand il n'est pas utilisé comme un constructeur avec l'opérateur {{jsxref("Opérateurs/L_opérateur_new", "new")}}), `Number` peut être utilisé afin d'effectuer des conversions.
+
+## Propriétés
+
+- {{jsxref("Number.EPSILON")}}
+  - : Le plus petit intervalle entre deux valeurs qu'il est possible de représenter en JavaScript.
+- {{jsxref("Number.MAX_SAFE_INTEGER")}}
+  - : La valeur entière maximale qu'on peut représenter en JavaScript (`2^53 - 1`).
+- {{jsxref("Number.MAX_VALUE")}}
+  - : La valeur numérique maximale qu'on peut représenter en JavaScript.
+- {{jsxref("Number.MIN_SAFE_INTEGER")}}
+  - : La valeur entière minimale qu'on peut représenter en JavaScript (`-(2^53 - 1)`).
+- {{jsxref("Number.MIN_VALUE")}}
+  - : La plus petite valeur qu'on peut représenter en JavaScript, c'est-à-dire le plus petit nombre positif (le nombre le plus près de zéro qui n'est pas égal à zéro et qu'on peut représenter en JavaScript).
+- {{jsxref("Number.NaN")}}
+  - : Une valeur spéciale pour représenter les valeurs non-numériques (**NaN** correspond à « **\*n**ot **a** **n**umber\* » en anglais, qui signifie « n'est pas un nombre »).
+- {{jsxref("Number.NEGATIVE_INFINITY")}}
+  - : Une valeur spéciale pour représenter l'infini négatif.
+- {{jsxref("Number.POSITIVE_INFINITY")}}
+  - : Une valeur spéciale pour représenter l'infini (positif).
+- {{jsxref("Number.prototype")}}
+  - : Cet objet permet d'ajouter des propriétés aux instances de `Number`.
+
+## Méthodes
+
+- {{jsxref("Number.isNaN()")}}
+  - : Cette méthode permet de déterminer si la valeur passée en argument vaut `NaN`.
+- {{jsxref("Number.isFinite()")}}
+  - : Cette méthode permet de déterminer si la valeur numérique passée en argument est un nombre fini.
+- {{jsxref("Number.isInteger()")}}
+  - : Cette méthode permet de déterminer si la valeur passée en argument est un entier.
+- {{jsxref("Number.isSafeInteger()")}}
+  - : Cette méthode permet de déterminer si la valeur passée en argument peut correctement être représentée comme un entier en JavaScript (savoir si elle est comprise entre `-(2^53 - 1)` et `2^53 - 1`).
+- {{jsxref("Number.toInteger()")}} {{obsolete_inline}}
+  - : Cette méthode est utilisée afin d'évaluer et de convertir la valeur passée en argument en entier (ou en l'{{jsxref("Infinity", "infini","",1)}}). Cette méthode a été supprimée.
+- {{jsxref("Number.parseFloat()", "Number.parseFloat(<var>string</var>)")}}
+  - : Cette méthode correspond à la méthode {{jsxref("parseFloat", "parseFloat()")}} de l'objet global.
+- {{jsxref("Number.parseInt()", "Number.parseInt(<var>string</var>, [<var>radix</var>])")}}
+  - : Cette méthode correspond à la méthode {{jsxref("parseInt", "parseInt()")}} de l'objet global.
+
+## Les instances de `Number`
+
+Toutes les instances de `Number` héritent de {{jsxref("Number.prototype")}}. Il est possible de modifier le prototype du constructeur `Number` pour affecter toutes les instances de `Number`.
+
+### Méthodes
+
+- {{jsxref("Number.prototype.toExponential()" ,"Number.prototype.toExponential(<var>fractionDigits</var>)")}}
+  - : Retourne une chaîne représentant le nombre en notation exponentielle.
+- {{jsxref("Number.prototype.toFixed()", "Number.prototype.toFixed(<var>digits</var>)")}}
+  - : Retourne une chaîne représentant le nombre avec la notation virgule fixe.
+- {{jsxref("Number.prototype.toLocaleString()", "Number.prototype.toLocaleString([<var>locales</var> [, <var>options</var>]])")}}
+  - : Retourne une chaîne avec une représentation sensible à la langue de ce nombre. Surcharge la méthode {{jsxref("Object.prototype.toLocaleString()")}}.
+- {{jsxref("Number.prototype.toPrecision()", "Number.prototype.toPrecision(<var>precision</var>)")}}
+  - : Retourne une chaîne représentant le nombre avec une précision donnée en notation virgule fixe ou exponentielle.
+- {{jsxref("Number.prototype.toString()", "Number.prototype.toString([<var>radix</var>])")}}
+  - : Retourne une chaîne représentant le nombre dans une base numérique (radix) donnée. Surcharge la méthode {{jsxref("Object.prototype.toString()")}}.
+- {{jsxref("Number.prototype.valueOf()")}}
+  - : Retourne la valeur primitive de l'objet spécifié. Surcharge la méthode {{jsxref("Object.prototype.valueOf()")}}.
+
+## Exemples
+
+### Utiliser l'objet `Number` pour affecter des valeurs numériques à des variables
+
+Dans l'exemple suivant, on utilise les propriétés de l'objet `Number` pour affecter des valeurs à des variables numériques :
+
+```js
+var plusGrandNombre = Number.MAX_VALUE;
 var plusPetitNombre = Number.MIN_VALUE;
 var infini = Number.POSITIVE_INFINITY;
 var infiniNégatif = Number.NEGATIVE_INFINITY;
 var nonNumérique = Number.NaN;
-</pre>
+```
 
-<h3 id="Intervalle_entier_pour_Number">Intervalle entier pour <code>Number</code></h3>
+### Intervalle entier pour `Number`
 
-<p>Dans l'exemple suivant, on illustre les valeurs numériques maximales et minimales (exclues) qu'on peut représenter avec un nombre en JavaScript (pour plus de détails, <a href="https://tc39.github.io/ecma262/#sec-ecmascript-language-types-number-type">voir le chapitre 6.1.6 du standard ECMAScript</a>) :</p>
+Dans l'exemple suivant, on illustre les valeurs numériques maximales et minimales (exclues) qu'on peut représenter avec un nombre en JavaScript (pour plus de détails, [voir le chapitre 6.1.6 du standard ECMAScript](https://tc39.github.io/ecma262/#sec-ecmascript-language-types-number-type)) :
 
-<pre class="brush: js notranslate">var biggestInt = 9007199254740992; //Number.MAX_SAFE_INTEGER+1 (2^53-1)
+```js
+var biggestInt = 9007199254740992; //Number.MAX_SAFE_INTEGER+1 (2^53-1)
 var smallestInt = -9007199254740992; //Number.MIN_SAFE_INTEGER-1 -(2^53-1)
-</pre>
+```
 
-<p>Lorsqu'on analyse et convertit des données JSON, les valeurs en dehors de cet intervalle peuvent entraîner des erreurs ou des corruptions de valeurs lors de leurs conversions. Selon les objets qu'on souhaite représenter, on peut utiliser {{jsxref("String")}} dans certains cas pour représenter certaines valeurs.</p>
+Lorsqu'on analyse et convertit des données JSON, les valeurs en dehors de cet intervalle peuvent entraîner des erreurs ou des corruptions de valeurs lors de leurs conversions. Selon les objets qu'on souhaite représenter, on peut utiliser {{jsxref("String")}} dans certains cas pour représenter certaines valeurs.
 
-<h3 id="Utiliser_Number_pour_convertir_un_objet_Date">Utiliser <code>Number</code> pour convertir un objet <code>Date</code></h3>
+### Utiliser `Number` pour convertir un objet `Date`
 
-<p>Dans l'exemple suivant, on convertit un objet {{jsxref("Date")}} en une valeur numérique grâce à la fonction <code>Number</code> :</p>
+Dans l'exemple suivant, on convertit un objet {{jsxref("Date")}} en une valeur numérique grâce à la fonction `Number` :
 
-<pre class="brush: js notranslate">var d = new Date('December 17, 1995 03:24:00');
+```js
+var d = new Date('December 17, 1995 03:24:00');
 console.log(Number(d));
-</pre>
+```
 
-<p>Ceci affichera "819167040000".</p>
+Ceci affichera "819167040000".
 
-<h3 id="Convertir_une_chaîne_représentant_une_valeur_numérique_en_un_nombre">Convertir une chaîne représentant une valeur numérique en un nombre</h3>
+### Convertir une chaîne représentant une valeur numérique en un nombre
 
-<pre class="brush: js notranslate">Number("123");       // 123
+```js
+Number("123");       // 123
 Number("12.3");      // 12.3
 Number("12.00");     // 12
 Number("123e-1");    // 12.3
@@ -149,54 +141,27 @@ Number("0o11");      // 9
 Number("toto");      // NaN
 Number("100a");      // NaN
 Number("-Infinity";) // -Infinity
-</pre>
-
-<div class="note">
-<p><strong>Note :</strong> On pourra également convertir <code>null</code> en <code>0</code> grâce à <code>Number</code> : <code>Number(null)</code> donnera <code>0</code>.</p>
-</div>
-
-<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.7', 'Number')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-number-objects', 'Number')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Ajout des méthodes et propriétés suivantes : ({{jsxref("Number.EPSILON", "EPSILON")}}, {{jsxref("Number.isFinite", "isFinite")}}, {{jsxref("Number.isInteger", "isInteger")}}, {{jsxref("Number.isNaN", "isNaN")}}, {{jsxref("Number.parseFloat", "parseFloat")}}, {{jsxref("Number.parseInt", "parseInt")}})</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-number-objects', 'Number')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Number")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("NaN")}}</li>
- <li>L'objet global {{jsxref("Math")}}</li>
- <li><a href="/fr/docs/Web/JavaScript/Structures_de_données#Le_type_nombre">Les types de données en JavaScript</a></li>
- <li><a href="https://medium.com/@maximus.koretskyi/javascripts-number-type-8d59199db1b6#.9whwe88tz">Un billet sur le type <code>Number</code> (en anglais)</a></li>
- <li>Représenter de grands entiers avec une précision arbitraire : {{jsxref("BigInt")}}</li>
-</ul>
+```
+
+> **Note :** On pourra également convertir `null` en `0` grâce à `Number` : `Number(null)` donnera `0`.
+
+## 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.7', 'Number')}}                 | {{Spec2('ES5.1')}}     |                                                                                                                                                                                                                                                                                                                                                                                                   |
+| {{SpecName('ES6', '#sec-number-objects', 'Number')}}         | {{Spec2('ES6')}}         | Ajout des méthodes et propriétés suivantes : ({{jsxref("Number.EPSILON", "EPSILON")}}, {{jsxref("Number.isFinite", "isFinite")}}, {{jsxref("Number.isInteger", "isInteger")}}, {{jsxref("Number.isNaN", "isNaN")}}, {{jsxref("Number.parseFloat", "parseFloat")}}, {{jsxref("Number.parseInt", "parseInt")}}) |
+| {{SpecName('ESDraft', '#sec-number-objects', 'Number')}} | {{Spec2('ESDraft')}} |                                                                                                                                                                                                                                                                                                                                                                                                   |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Number")}}
+
+## Voir aussi
+
+- {{jsxref("NaN")}}
+- L'objet global {{jsxref("Math")}}
+- [Les types de données en JavaScript](/fr/docs/Web/JavaScript/Structures_de_données#Le_type_nombre)
+- [Un billet sur le type `Number` (en anglais)](https://medium.com/@maximus.koretskyi/javascripts-number-type-8d59199db1b6#.9whwe88tz)
+- Représenter de grands entiers avec une précision arbitraire : {{jsxref("BigInt")}}
diff --git a/files/fr/web/javascript/reference/global_objects/number/isfinite/index.md b/files/fr/web/javascript/reference/global_objects/number/isfinite/index.md
index 9cf0331fab..bb0af546ce 100644
--- a/files/fr/web/javascript/reference/global_objects/number/isfinite/index.md
+++ b/files/fr/web/javascript/reference/global_objects/number/isfinite/index.md
@@ -11,34 +11,33 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Number/isFinite
 original_slug: Web/JavaScript/Reference/Objets_globaux/Number/isFinite
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>Number.isFinite()</code></strong> permet de déterminer si la valeur fournie est un nombre fini.</p>
+La méthode **`Number.isFinite()`** permet de déterminer si la valeur fournie est un nombre fini.
 
-<div>{{EmbedInteractiveExample("pages/js/number-isfinite.html")}}</div>
+{{EmbedInteractiveExample("pages/js/number-isfinite.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox notranslate">Number.isFinite(valeurÀTester);</pre>
+    Number.isFinite(valeurÀTester);
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>valeurÀTester</code></dt>
- <dd>La valeur dont on souhaite savoir si elle est finie.</dd>
-</dl>
+- `valeurÀTester`
+  - : La valeur dont on souhaite savoir si elle est finie.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un booléen indiquant si la valeur passée en argument est un nombre fini.</p>
+Un booléen indiquant si la valeur passée en argument est un nombre fini.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Par rapport à la fonction de l'objet global {{jsxref("isFinite","isFinite()")}} qui convertit l'argument donné en un nombre, la fonction <code>Number.isFinite </code>ne convertit pas l'argument et ne renvoie pas <code>true</code>.</p>
+Par rapport à la fonction de l'objet global {{jsxref("isFinite","isFinite()")}} qui convertit l'argument donné en un nombre, la fonction `Number.isFinite `ne convertit pas l'argument et ne renvoie pas `true`.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<pre class="brush:js; notranslate">Number.isFinite(Infinity);  // false
+```js
+Number.isFinite(Infinity);  // false
 Number.isFinite(NaN);       // false
 Number.isFinite(-Infinity); // false
 
@@ -50,11 +49,12 @@ Number.isFinite("0");       // false, ce qui aurait
 
 Number.isFinite(null);      // false, ce qui aurait
                             // renvoyé true avc isFinite(null)
-</pre>
+```
 
-<h2 id="Prothèse_démulation_polyfill">Prothèse d'émulation (<em>polyfill</em>)</h2>
+## Prothèse d'émulation (_polyfill_)
 
-<pre class="brush:js; notranslate">// Number.isFinite polyfill
+```js
+// Number.isFinite polyfill
 // http://people.mozilla.org/~jorendorff/es6-draft.html#sec-number.isfinite
 if (typeof Number.isFinite !== 'function') {
     Number.isFinite = function isFinite(value) {
@@ -70,43 +70,28 @@ if (typeof Number.isFinite !== 'function') {
         return true;
     };
 }
-</pre>
-
-<p>Deuxième version plus concise qui utilise la méthode globale <code>isFinite</code></p>
-
-<pre class="brush: js notranslate">if (Number.isFinite === undefined) Number.isFinite = function(value) {
-    return typeof value === "number" &amp;&amp; isFinite(value);
-}</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-number.isfinite', 'Number.isInteger')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-number.isfinite', 'Number.isInteger')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Number.isFinite")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>L'objet {{jsxref("Number")}} auquel appartient cette méthode</li>
- <li>La méthode {{jsxref("isFinite", "isFinite()")}} de l'objet global</li>
-</ul>
+```
+
+Deuxième version plus concise qui utilise la méthode globale `isFinite`
+
+```js
+if (Number.isFinite === undefined) Number.isFinite = function(value) {
+    return typeof value === "number" && isFinite(value);
+}
+```
+
+## Spécifications
+
+| Spécification                                                                            | État                         | Commentaires         |
+| ---------------------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ES6', '#sec-number.isfinite', 'Number.isInteger')}}     | {{Spec2('ES6')}}         | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-number.isfinite', 'Number.isInteger')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Number.isFinite")}}
+
+## Voir aussi
+
+- L'objet {{jsxref("Number")}} auquel appartient cette méthode
+- La méthode {{jsxref("isFinite", "isFinite()")}} de l'objet global
diff --git a/files/fr/web/javascript/reference/global_objects/number/isinteger/index.md b/files/fr/web/javascript/reference/global_objects/number/isinteger/index.md
index a6f1f364e5..f299694e36 100644
--- a/files/fr/web/javascript/reference/global_objects/number/isinteger/index.md
+++ b/files/fr/web/javascript/reference/global_objects/number/isinteger/index.md
@@ -10,34 +10,33 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Number/isInteger
 original_slug: Web/JavaScript/Reference/Objets_globaux/Number/isInteger
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>Number.isInteger()</code></strong> permet de déterminer si l'argument est un nombre entier.</p>
+La méthode **`Number.isInteger()`** permet de déterminer si l'argument est un nombre entier.
 
-<div>{{EmbedInteractiveExample("pages/js/number-isinteger.html")}}</div>
+{{EmbedInteractiveExample("pages/js/number-isinteger.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">Number.isInteger(valeurÀTester)</pre>
+    Number.isInteger(valeurÀTester)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code><var>valeurÀTester</var></code></dt>
- <dd>La valeur dont on souhaite savoir si elle est entière ou non.</dd>
-</dl>
+- `valeurÀTester`
+  - : La valeur dont on souhaite savoir si elle est entière ou non.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un booléen qui indique si la valeur fournie en argument est un entier.</p>
+Un booléen qui indique si la valeur fournie en argument est un entier.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Si la valeur à tester est un entier, cette méthode renvoie <code>true</code>, <code>false</code> sinon. Si la valeur est {{jsxref("NaN")}} ou l'infini ({{jsxref("Infinity")}}), la méthode renverra <code>false</code>. La méthode renverra également <code>true</code> pour les nombres flottants qui peuvent être représentés comme des entiers.</p>
+Si la valeur à tester est un entier, cette méthode renvoie `true`, `false` sinon. Si la valeur est {{jsxref("NaN")}} ou l'infini ({{jsxref("Infinity")}}), la méthode renverra `false`. La méthode renverra également `true` pour les nombres flottants qui peuvent être représentés comme des entiers.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<pre class="brush: js">Number.isInteger(1);         // true
+```js
+Number.isInteger(1);         // true
 Number.isInteger(-100000);   // true
 Number.isInteger(0);         // true
 Number.isInteger(1.000)      // true
@@ -54,46 +53,29 @@ Number.isInteger("10");      // false
 Number.isInteger(5.0);       // true
 Number.isInteger(5.000000000000001);// false
 Number.isInteger(5.0000000000000001); // true
-</pre>
+```
 
-<h2 id="Prothèse_démulation_polyfill">Prothèse d'émulation (<em>polyfill</em>)</h2>
+## Prothèse d'émulation (_polyfill_)
 
-<pre class="brush: js">Number.isInteger = Number.isInteger || function(value) {
-    return typeof value === "number" &amp;&amp;
-           isFinite(value) &amp;&amp;
+```js
+Number.isInteger = Number.isInteger || function(value) {
+    return typeof value === "number" &&
+           isFinite(value) &&
            Math.floor(value) === value;
-};</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('ES6', '#sec-number.isinteger', 'Number.isInteger')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-number.isinteger', 'Number.isInteger')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Number.isInteger")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>L'objet global {{jsxref("Number")}} auquel appartient cette méthode.</li>
-</ul>
+};
+```
+
+## Spécifications
+
+| Spécification                                                                                | État                         | Commentaires         |
+| -------------------------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ES6', '#sec-number.isinteger', 'Number.isInteger')}}         | {{Spec2('ES6')}}         | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-number.isinteger', 'Number.isInteger')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Number.isInteger")}}
+
+## Voir aussi
+
+- L'objet global {{jsxref("Number")}} auquel appartient cette méthode.
diff --git a/files/fr/web/javascript/reference/global_objects/number/isnan/index.md b/files/fr/web/javascript/reference/global_objects/number/isnan/index.md
index 2b7f565807..fef4caa264 100644
--- a/files/fr/web/javascript/reference/global_objects/number/isnan/index.md
+++ b/files/fr/web/javascript/reference/global_objects/number/isnan/index.md
@@ -10,36 +10,35 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Number/isNaN
 original_slug: Web/JavaScript/Reference/Objets_globaux/Number/isNaN
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>Number.isNaN()</code></strong> permet de déterminer si la valeur passée en argument est {{jsxref("NaN")}}, avec un type {{jsxref("Number")}}. Cette version est plus robuste que la méthode de l'objet global {{jsxref("isNaN")}}.</p>
+La méthode **`Number.isNaN()`** permet de déterminer si la valeur passée en argument est {{jsxref("NaN")}}, avec un type {{jsxref("Number")}}. Cette version est plus robuste que la méthode de l'objet global {{jsxref("isNaN")}}.
 
-<div>{{EmbedInteractiveExample("pages/js/number-isnan.html", "taller")}}</div>
+{{EmbedInteractiveExample("pages/js/number-isnan.html", "taller")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">Number.isNaN(<var>valeurÀTester</var>)</pre>
+    Number.isNaN(valeurÀTester)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code><em>valeurÀTester</em></code></dt>
- <dd>La valeur qu'on souhaite comparer à {{jsxref("NaN")}}.</dd>
-</dl>
+- `valeurÀTester`
+  - : La valeur qu'on souhaite comparer à {{jsxref("NaN")}}.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un booléen qui indique si la valeur fournie en argument est {{jsxref("NaN")}}.</p>
+Un booléen qui indique si la valeur fournie en argument est {{jsxref("NaN")}}.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Les deux opérateurs d'égalité, {{jsxref("Opérateurs/Opérateurs_de_comparaison", "==", "#.C3.89galit.C3.A9_simple_(.3D.3D)")}} et {{jsxref("Opérateurs/Opérateurs_de_comparaison", "===", "#.C3.89galit.C3.A9_stricte_(.3D.3D.3D)")}}, renvoient <code>false</code> pour vérifier que {{jsxref("NaN")}} <em>est</em> NaN. La fonction <code>Number.isNaN</code> est nécessaire pour distinguer ce cas. Le résultat de cette comparaison sera différent avec les autres méthodes de comparaisons en JavaScript.</p>
+Les deux opérateurs d'égalité, {{jsxref("Opérateurs/Opérateurs_de_comparaison", "==", "#.C3.89galit.C3.A9_simple_(.3D.3D)")}} et {{jsxref("Opérateurs/Opérateurs_de_comparaison", "===", "#.C3.89galit.C3.A9_stricte_(.3D.3D.3D)")}}, renvoient `false` pour vérifier que {{jsxref("NaN")}} _est_ NaN. La fonction `Number.isNaN` est nécessaire pour distinguer ce cas. Le résultat de cette comparaison sera différent avec les autres méthodes de comparaisons en JavaScript.
 
-<p>En effet, la fonction globale {{jsxref("isNaN")}} convertit l'argument en un nombre.  <code>Number.isNaN</code> ne convertit pas l'argument. Cela signifie qu'on peut passer des valeurs qui, normalement, seraient converties en NaN, mais qui ne sont pas NaN. Cela signifie également que, uniquement lorsque la méthode sera utilisée avec des nombres qui valent <code>NaN</code>, elle renverra <code>true</code>.</p>
+En effet, la fonction globale {{jsxref("isNaN")}} convertit l'argument en un nombre.  `Number.isNaN` ne convertit pas l'argument. Cela signifie qu'on peut passer des valeurs qui, normalement, seraient converties en NaN, mais qui ne sont pas NaN. Cela signifie également que, uniquement lorsque la méthode sera utilisée avec des nombres qui valent `NaN`, elle renverra `true`.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<pre class="brush:js;">Number.isNaN(NaN); // true
+```js
+Number.isNaN(NaN); // true
 Number.isNaN(Number.NaN); // true
 Number.isNaN(0 / 0); // true
 
@@ -56,46 +55,32 @@ Number.isNaN("37.37");
 Number.isNaN("");
 Number.isNaN(" ");
 Number.isNaN("NaN");
-Number.isNaN("blabla"); // ex : cette valeur aurait rendu true avec la méthode isNaN de l'objet global</pre>
-
-<h2 id="Prothèse_d'émulation_(polyfill)">Prothèse d'émulation (<em>polyfill</em>)</h2>
-
-<p>La fonction suivant fonctionne car <code>NaN</code> est la seule valeur JavaScript qui n'est pas égale à elle-même.</p>
-
-<pre class="brush: js">Number.isNaN = Number.isNaN || function(value) {
-    return typeof value === "number" &amp;&amp; isNaN(value);
-}</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-number.isnan', 'Number.isnan')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-number.isnan', 'Number.isnan')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Number.isNaN")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>L'objet {{jsxref("Number")}} auquel appartient cette méthode.</li>
- <li>La méthode {{jsxref("Objets_globaux/Object/is", "Object.is")}} qui permet d'effectuer des comparaisons sur l'égalité de valeur</li>
- <li>La méthode {{jsxref("isNaN")}} de l'objet global</li>
-</ul>
+Number.isNaN("blabla"); // ex : cette valeur aurait rendu true avec la méthode isNaN de l'objet global
+```
+
+## Prothèse d'émulation (_polyfill_)
+
+La fonction suivant fonctionne car `NaN` est la seule valeur JavaScript qui n'est pas égale à elle-même.
+
+```js
+Number.isNaN = Number.isNaN || function(value) {
+    return typeof value === "number" && isNaN(value);
+}
+```
+
+## Spécifications
+
+| Spécification                                                                    | État                         | Commentaires         |
+| -------------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ES2015', '#sec-number.isnan', 'Number.isnan')}} | {{Spec2('ES2015')}}     | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-number.isnan', 'Number.isnan')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Number.isNaN")}}
+
+## Voir aussi
+
+- L'objet {{jsxref("Number")}} auquel appartient cette méthode.
+- La méthode {{jsxref("Objets_globaux/Object/is", "Object.is")}} qui permet d'effectuer des comparaisons sur l'égalité de valeur
+- La méthode {{jsxref("isNaN")}} de l'objet global
diff --git a/files/fr/web/javascript/reference/global_objects/number/issafeinteger/index.md b/files/fr/web/javascript/reference/global_objects/number/issafeinteger/index.md
index c992339e23..4958589300 100644
--- a/files/fr/web/javascript/reference/global_objects/number/issafeinteger/index.md
+++ b/files/fr/web/javascript/reference/global_objects/number/issafeinteger/index.md
@@ -11,49 +11,42 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Number/isSafeInteger
 original_slug: Web/JavaScript/Reference/Objets_globaux/Number/isSafeInteger
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>Number.isSafeInteger()</code></strong> permet de déterminer si la valeur, passée en argument, est un entier représentable correctement en JavaScript (c'est-à-dire un nombre compris entre -(2^53-1) et 2^53-1).</p>
+La méthode **`Number.isSafeInteger()`** permet de déterminer si la valeur, passée en argument, est un entier représentable correctement en JavaScript (c'est-à-dire un nombre compris entre -(2^53-1) et 2^53-1).
 
-<div>{{EmbedInteractiveExample("pages/js/number-issafeinteger.html")}}</div>
+{{EmbedInteractiveExample("pages/js/number-issafeinteger.html")}}
 
+> **Note :** Pour représenter des entiers qui ne sont pas compris dans cet intervalle, on pourra utiliser le type {{jsxref("BigInt")}}.
 
+## Syntaxe
 
-<div class="blockIndicator note">
-<p><strong>Note :</strong> Pour représenter des entiers qui ne sont pas compris dans cet intervalle, on pourra utiliser le type {{jsxref("BigInt")}}.</p>
-</div>
+    Number.isSafeInteger(valeurÀTester)
 
-<h2 id="Syntaxe">Syntaxe</h2>
+### Paramètres
 
-<pre class="syntaxbox">Number.isSafeInteger(valeurÀTester)</pre>
+- `valeurÀTester`
+  - : La valeur dont on souhaite savoir si elle représente un entier représentable correctement en une valeur non signée sur 32 bits. (JavaScript utilise [les nombres au format de virgule flottante à double précision](https://en.wikipedia.org/wiki/Double_precision_floating-point_format) comme spécifié dans [IEEE 754](https://fr.wikipedia.org/wiki/IEEE_754) et ne peut représenter avec certitude un entier qu'entre `-(2^53-1)` et `2^53-1` (c'est-à-dire ± `9007199254740991`).
 
-<h3 id="Paramètres">Paramètres</h3>
+### Valeur de retour
 
-<dl>
- <dt><code><var>valeurÀTester</var></code></dt>
- <dd>La valeur dont on souhaite savoir si elle représente un entier représentable correctement en une valeur non signée sur 32 bits. (JavaScript utilise <a class="external external-icon" href="https://en.wikipedia.org/wiki/Double_precision_floating-point_format">les nombres au format de virgule flottante à double précision</a> comme spécifié dans <a class="external external-icon" href="https://fr.wikipedia.org/wiki/IEEE_754">IEEE 754</a> et ne peut représenter avec certitude un entier qu'entre <code>-(2^53-1)</code> et <code>2^53-1</code> (c'est-à-dire ± <code>9007199254740991</code>).</dd>
-</dl>
+Un booléen qui indique si la valeur fournie en argument est un entier représentable correctement en JavaScript.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+## Description
 
-<p>Un booléen qui indique si la valeur fournie en argument est un entier représentable correctement en JavaScript.</p>
+Un entier correctement représentable en JavaScript :
 
-<h2 id="Description">Description</h2>
+- peut exactement être représenté avec un nombre à précision double selon IEEE-754
+- la réprésentation IEEE-754 du nombre ne permet pas de l'arrondir à un autre entier pouvant être représenté avec le format décrit par IEEE-754.
 
-<p>Un entier correctement représentable en JavaScript :</p>
+Ainsi, par exemple, `2^53 - 1` peut être représenté correctement, aucun autre entier ne peut être arrondi en cette valeur selon IEEE-754. En revanche, `2^53` ne peut pas être représenté correctement car `2^53 + 1` sera arrondi en `2^53` selon les règles IEEE-754 (arrondi à l'entier le plus proche).
 
-<ul>
- <li>peut exactement être représenté avec un nombre à précision double selon IEEE-754</li>
- <li>la réprésentation IEEE-754 du nombre ne permet pas de l'arrondir à un autre entier pouvant être représenté avec le format décrit par IEEE-754.</li>
-</ul>
+L'intervalle des entiers qui peuvent être correctement représentés est `[-(2^53 - 1),2^53 - 1` ].
 
-<p>Ainsi, par exemple, <code>2^53 - 1</code> peut être représenté correctement, aucun autre entier ne peut être arrondi en cette valeur selon IEEE-754. En revanche, <code>2^53</code> ne peut pas être représenté correctement car <code>2^53 + 1</code> sera arrondi en <code>2^53</code> selon les règles IEEE-754 (arrondi à l'entier le plus proche).</p>
+## Exemples
 
-<p>L'intervalle des entiers qui peuvent être correctement représentés est <code>[-(2^53 - 1),2^53 - 1</code> ].</p>
-
-<h2 id="Exemples">Exemples</h2>
-
-<pre class="brush:js">Number.isSafeInteger(3);                    // true
+```js
+Number.isSafeInteger(3);                    // true
 Number.isSafeInteger(Math.pow(2, 53))       // false
 Number.isSafeInteger(Math.pow(2, 53) - 1)   // true
 Number.isSafeInteger(NaN);                  // false
@@ -61,39 +54,22 @@ Number.isSafeInteger(Infinity);             // false
 Number.isSafeInteger("3");                  // false
 Number.isSafeInteger(3.1);                  // false
 Number.isSafeInteger(3.0);                  // 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-number.issafeinteger', 'Number.isSafeInteger')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-number.issafeinteger', 'Number.isSafeInteger')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Number.isSafeInteger")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>L'objet {{jsxref("Number")}} auquel appartient cette méthode</li>
- <li>{{jsxref("Number.MIN_SAFE_INTEGER")}}</li>
- <li>{{jsxref("Number.MAX_SAFE_INTEGER")}}</li>
- <li>{{jsxref("BigInt")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                        | État                         | Commentaires         |
+| ---------------------------------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ES2015', '#sec-number.issafeinteger', 'Number.isSafeInteger')}} | {{Spec2('ES2015')}}     | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-number.issafeinteger', 'Number.isSafeInteger')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Number.isSafeInteger")}}
+
+## Voir aussi
+
+- L'objet {{jsxref("Number")}} auquel appartient cette méthode
+- {{jsxref("Number.MIN_SAFE_INTEGER")}}
+- {{jsxref("Number.MAX_SAFE_INTEGER")}}
+- {{jsxref("BigInt")}}
diff --git a/files/fr/web/javascript/reference/global_objects/number/max_safe_integer/index.md b/files/fr/web/javascript/reference/global_objects/number/max_safe_integer/index.md
index 9b389e3531..a38f9c3695 100644
--- a/files/fr/web/javascript/reference/global_objects/number/max_safe_integer/index.md
+++ b/files/fr/web/javascript/reference/global_objects/number/max_safe_integer/index.md
@@ -10,64 +10,44 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER
 original_slug: Web/JavaScript/Reference/Objets_globaux/Number/MAX_SAFE_INTEGER
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La constante <code><strong>Number.MAX_SAFE_INTEGER </strong></code>représente la valeur (sûre) maximale d’un nombre entier en JavaScript (2^53 -1).</p>
+La constante **`Number.MAX_SAFE_INTEGER `**représente la valeur (sûre) maximale d’un nombre entier en JavaScript (2^53 -1).
 
-<div class="blockIndicator note">
-<p><strong>Note :</strong> Pour représenter des entiers supérieurs à cette valeur, on pourra utiliser le type {{jsxref("BigInt")}}.</p>
-</div>
+> **Note :** Pour représenter des entiers supérieurs à cette valeur, on pourra utiliser le type {{jsxref("BigInt")}}.
 
-<div>{{EmbedInteractiveExample("pages/js/number-maxsafeinteger.html")}}</div>
+{{EmbedInteractiveExample("pages/js/number-maxsafeinteger.html")}}
 
+{{js_property_attributes(0,0,0)}}
 
+## Description
 
-<p>{{js_property_attributes(0,0,0)}}</p>
+La constante `MAX_SAFE_INTEGER` a une valeur de `9007199254740991`. Cette valeur s'explique par le fait que JavaScript utilise [les nombres au format de virgule flottante à double précision](http://en.wikipedia.org/wiki/Double_precision_floating-point_format) comme spécifié dans [IEEE 754](http://fr.wikipedia.org/wiki/IEEE_754) et ne peut représenter avec certitude qu’un nombre entre `-(2^53-1)` et `2^53 -1`.
 
-<h2 id="Description">Description</h2>
+Dans ce contexte, « sûr » fait référence à la capacité à représenter exactement les entiers et à les comparer entre eux. Par exemple, `Number.MAX_SAFE_INTEGER + 1 === Number.MAX_SAFE_INTEGER + 2` vaudra `true` ce qui est mathématiquement incorrect. Pour plus d'informations, voir également {{jsxref("Number.isSafeInteger()")}}.
 
-<p>La constante <code>MAX_SAFE_INTEGER</code> a une valeur de <code>9007199254740991</code>. Cette valeur s'explique par le fait que JavaScript utilise <a href="http://en.wikipedia.org/wiki/Double_precision_floating-point_format">les nombres au format de virgule flottante à double précision</a> comme spécifié dans <a href="http://fr.wikipedia.org/wiki/IEEE_754">IEEE 754</a> et ne peut représenter avec certitude qu’un nombre entre <code>-(2^53-1)</code> et <code>2^53 -1</code>.</p>
+`MAX_SAFE_INTEGER` est une propriété statique de {{jsxref("Number")}}, elle doit toujours être utilisée comme `Number.MAX_SAFE_INTEGER` et non pas comme la propriété d'un objet `Number` qui aurait été instancié.
 
-<p>Dans ce contexte, « sûr » fait référence à la capacité à représenter exactement les entiers et à les comparer entre eux. Par exemple, <code>Number.MAX_SAFE_INTEGER + 1 === Number.MAX_SAFE_INTEGER + 2</code> vaudra <code>true</code> ce qui est mathématiquement incorrect. Pour plus d'informations, voir également {{jsxref("Number.isSafeInteger()")}}.</p>
+## Exemples
 
-<p><code>MAX_SAFE_INTEGER</code> est une propriété statique de {{jsxref("Number")}}, elle doit toujours être utilisée comme <code>Number.MAX_SAFE_INTEGER</code> et non pas comme la propriété d'un objet <code>Number</code> qui aurait été instancié.</p>
+```js
+Number.MAX_SAFE_INTEGER // 9007199254740991
+Math.pow(2, 53) -1      // 9007199254740991
+```
 
-<h2 id="Exemples">Exemples</h2>
+## Spécifications
 
-<pre class="brush: js">Number.MAX_SAFE_INTEGER // 9007199254740991
-Math.pow(2, 53) -1      // 9007199254740991
-</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-number.max_safe_integer', 'Number.MAX_SAFE_INTEGER')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-number.max_safe_integer', 'Number.MAX_SAFE_INTEGER')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Number.MAX_SAFE_INTEGER")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Number.MIN_SAFE_INTEGER")}}</li>
- <li>{{jsxref("Number.isSafeInteger()")}}</li>
- <li>{{jsxref("BigInt")}}</li>
-</ul>
+| Spécification                                                                                                | État                         | Commentaires        |
+| ------------------------------------------------------------------------------------------------------------ | ---------------------------- | ------------------- |
+| {{SpecName('ES2015', '#sec-number.max_safe_integer', 'Number.MAX_SAFE_INTEGER')}} | {{Spec2('ES2015')}}     | Définition initiale |
+| {{SpecName('ESDraft', '#sec-number.max_safe_integer', 'Number.MAX_SAFE_INTEGER')}} | {{Spec2('ESDraft')}} |                     |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Number.MAX_SAFE_INTEGER")}}
+
+## Voir aussi
+
+- {{jsxref("Number.MIN_SAFE_INTEGER")}}
+- {{jsxref("Number.isSafeInteger()")}}
+- {{jsxref("BigInt")}}
diff --git a/files/fr/web/javascript/reference/global_objects/number/max_value/index.md b/files/fr/web/javascript/reference/global_objects/number/max_value/index.md
index a673992a3b..a56ed64592 100644
--- a/files/fr/web/javascript/reference/global_objects/number/max_value/index.md
+++ b/files/fr/web/javascript/reference/global_objects/number/max_value/index.md
@@ -9,71 +9,44 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Number/MAX_VALUE
 original_slug: Web/JavaScript/Reference/Objets_globaux/Number/MAX_VALUE
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La propriété <code><strong>Number.MAX_VALUE</strong></code> représente la valeur maximale qui peut être représentée par un nombre en JavaScript.</p>
+La propriété **`Number.MAX_VALUE`** représente la valeur maximale qui peut être représentée par un nombre en JavaScript.
 
-<div>{{EmbedInteractiveExample("pages/js/number-maxvalue.html")}}</div>
+{{EmbedInteractiveExample("pages/js/number-maxvalue.html")}}{{js_property_attributes(0,0,0)}}
 
+## Description
 
+La propriété statique `MAX_VALUE` vaut environ `1.79E+308` (soit 2^1024). Les valeurs supérieures à `MAX_VALUE` sont représentées par {{jsxref("Infinity")}} (pour l'infini).
 
-<div>{{js_property_attributes(0,0,0)}}</div>
+`MAX_VALUE` est une propriété statique de {{jsxref("Number")}}, il faut donc l'utiliser avec `Number.MAX_VALUE`, plutôt qu'en faisant appel à la propriété d'un objet` Number` qui aurait été instancié (si on appelle cette propriété sur l'objet `Number` créé, on obtiendra {{jsxref("undefined")}}).
 
-<h2 id="Description">Description</h2>
+## Exemples
 
-<p>La propriété statique <code>MAX_VALUE</code> vaut environ <code>1.79E+308</code> (soit 2^1024). Les valeurs supérieures à <code>MAX_VALUE</code> sont représentées par {{jsxref("Infinity")}} (pour l'infini).</p>
+Le code suivant teste si le produit de deux nombres est inférieur ou égal à `MAX_VALUE`, selon le résultat de ce test, soit on utilisera `func1`, soit on utilisera `func2`.
 
-<p><code>MAX_VALUE</code> est une propriété statique de {{jsxref("Number")}}, il faut donc l'utiliser avec <code>Number.MAX_VALUE</code>, plutôt qu'en faisant appel à la propriété d'un objet<code> Number</code> qui aurait été instancié (si on appelle cette propriété sur l'objet <code>Number</code> créé, on obtiendra {{jsxref("undefined")}}).</p>
-
-<h2 id="Exemples">Exemples</h2>
-
-<p>Le code suivant teste si le produit de deux nombres est inférieur ou égal à <code>MAX_VALUE</code>, selon le résultat de ce test, soit on utilisera <code>func1</code>, soit on utilisera <code>func2</code>.</p>
-
-<pre class="brush: js">if (num1 * num2 &lt;= Number.MAX_VALUE) {
+```js
+if (num1 * num2 <= Number.MAX_VALUE) {
    func1();
 } else {
    func2();
-}</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('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.7.3.2', 'Number.MAX_VALUE')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-number.max_value', 'Number.MAX_VALUE')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-number.max_value', 'Number.MAX_VALUE')}}</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.1. |
+| {{SpecName('ES5.1', '#sec-15.7.3.2', 'Number.MAX_VALUE')}}                 | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-number.max_value', 'Number.MAX_VALUE')}}         | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-number.max_value', 'Number.MAX_VALUE')}} | {{Spec2('ESDraft')}} |                                                       |
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.Number.MAX_VALUE")}}</p>
+{{Compat("javascript.builtins.Number.MAX_VALUE")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("Number.MIN_VALUE")}}</li>
- <li>{{jsxref("Number")}}</li>
-</ul>
+- {{jsxref("Number.MIN_VALUE")}}
+- {{jsxref("Number")}}
diff --git a/files/fr/web/javascript/reference/global_objects/number/min_safe_integer/index.md b/files/fr/web/javascript/reference/global_objects/number/min_safe_integer/index.md
index e61fc520fd..befcd40ef6 100644
--- a/files/fr/web/javascript/reference/global_objects/number/min_safe_integer/index.md
+++ b/files/fr/web/javascript/reference/global_objects/number/min_safe_integer/index.md
@@ -10,62 +10,40 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Number/MIN_SAFE_INTEGER
 original_slug: Web/JavaScript/Reference/Objets_globaux/Number/MIN_SAFE_INTEGER
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La constante <code><strong>Number.MIN_SAFE_INTEGER</strong></code> représente le plus petit entier représentable correctement en JavaScript (-(2^53 -1)).</p>
+La constante **`Number.MIN_SAFE_INTEGER`** représente le plus petit entier représentable correctement en JavaScript (-(2^53 -1)).
 
-<div class="blockIndicator note">
-<p><strong>Note :</strong> Pour représenter des entiers inférieurs à cette valeur, on pourra utiliser le type {{jsxref("BigInt")}}.</p>
-</div>
+> **Note :** Pour représenter des entiers inférieurs à cette valeur, on pourra utiliser le type {{jsxref("BigInt")}}.
 
-<div>{{EmbedInteractiveExample("pages/js/number-min-safe-integer.html")}}</div>
+{{EmbedInteractiveExample("pages/js/number-min-safe-integer.html")}}{{js_property_attributes(0,0,0)}}
 
+## Description
 
+La constante `MIN_SAFE_INTEGER` vaut `-9007199254740991`. Cette valeur provient du fait qu'en JavaScript, les nombres sont représentés [en format à double précision](https://en.wikipedia.org/wiki/Double_precision_floating-point_format) selon la norme [IEEE 754](http://fr.wikipedia.org/wiki/IEEE_754) et on ne peut représenter correctement que les nombres compris entre `-(2^53-1)` et `2^53 -1`. Voir {{jsxref("Number.isSafeInteger()")}} pour plus d'informations.
 
-<div>{{js_property_attributes(0,0,0)}}</div>
+`MIN_SAFE_INTEGER` étant une méthode statique de {{jsxref("Number")}}, il faut utiliser `Number.MIN_SAFE_INTEGER()`et non pas la méthode d'un objet `Number` qui aurait été instancié.
 
-<h2 id="Description">Description</h2>
+## Exemples
 
-<p>La constante <code>MIN_SAFE_INTEGER</code> vaut <code>-9007199254740991</code>. Cette valeur provient du fait qu'en JavaScript, les nombres sont représentés <a href="https://en.wikipedia.org/wiki/Double_precision_floating-point_format">en format à double précision</a> selon la norme <a href="http://fr.wikipedia.org/wiki/IEEE_754">IEEE 754</a> et on ne peut représenter correctement que les nombres compris entre <code>-(2^53-1)</code> et <code>2^53 -1</code>. Voir {{jsxref("Number.isSafeInteger()")}} pour plus d'informations.</p>
-
-<p><code>MIN_SAFE_INTEGER</code> étant une méthode statique de {{jsxref("Number")}}, il faut utiliser <code><code>Number</code>.<code>MIN_SAFE_INTEGER</code>()</code>et non pas la méthode d'un objet <code>Number</code> qui aurait été instancié.</p>
-
-<h2 id="Exemples">Exemples</h2>
-
-<pre class="brush: js">Number.MIN_SAFE_INTEGER // -9007199254740991
+```js
+Number.MIN_SAFE_INTEGER // -9007199254740991
 -Math.pow(2, 53) -1     // -9007199254740991
-</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-number.min_safe_integer', 'Number.MIN_SAFE_INTEGER')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-number.min_safe_integer', 'Number.MIN_SAFE_INTEGER')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
+| Spécification                                                                                                | État                         | Commentaires         |
+| ------------------------------------------------------------------------------------------------------------ | ---------------------------- | -------------------- |
+| {{SpecName('ES2015', '#sec-number.min_safe_integer', 'Number.MIN_SAFE_INTEGER')}} | {{Spec2('ES2015')}}     | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-number.min_safe_integer', 'Number.MIN_SAFE_INTEGER')}} | {{Spec2('ESDraft')}} |                      |
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.Number.MIN_SAFE_INTEGER")}}</p>
+{{Compat("javascript.builtins.Number.MIN_SAFE_INTEGER")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("Number.MAX_SAFE_INTEGER")}}</li>
- <li>{{jsxref("Number.isSafeInteger()")}}</li>
- <li>{{jsxref("BigInt")}}</li>
-</ul>
+- {{jsxref("Number.MAX_SAFE_INTEGER")}}
+- {{jsxref("Number.isSafeInteger()")}}
+- {{jsxref("BigInt")}}
diff --git a/files/fr/web/javascript/reference/global_objects/number/min_value/index.md b/files/fr/web/javascript/reference/global_objects/number/min_value/index.md
index 257b17dc9e..6862f18313 100644
--- a/files/fr/web/javascript/reference/global_objects/number/min_value/index.md
+++ b/files/fr/web/javascript/reference/global_objects/number/min_value/index.md
@@ -9,74 +9,45 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Number/MIN_VALUE
 original_slug: Web/JavaScript/Reference/Objets_globaux/Number/MIN_VALUE
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La propriété <code><strong>Number.MIN_VALUE</strong></code> représente la plus petite valeur numérique positive qu'il est possible de représenter en JavaScript.</p>
+La propriété **`Number.MIN_VALUE`** représente la plus petite valeur numérique positive qu'il est possible de représenter en JavaScript.
 
-<div>{{EmbedInteractiveExample("pages/js/number-min-value.html")}}</div>
+{{EmbedInteractiveExample("pages/js/number-min-value.html")}}{{js_property_attributes(0,0,0)}}
 
+## Description
 
+La propriété `MIN_VALUE` représente le nombre positif le plus proche de 0 et non pas le nombre négatif minimal qu'il est possible de représenter en JavaScript.
 
-<div>{{js_property_attributes(0,0,0)}}</div>
+`MIN_VALUE` vaut environ 5e-324. Les valeurs inférieures à `MIN_VALUE` sont converties en 0.
 
-<h2 id="Description">Description</h2>
+`MIN_VALUE` est une propriété statique de {{jsxref("Number")}} et doit donc être utilisée avec la syntaxe `Number.MIN_VALUE`, et non pas via la propriété d'un objet `Number` qui aurait été instancié.
 
-<p>La propriété <code>MIN_VALUE</code> représente le nombre positif le plus proche de 0 et non pas le nombre négatif minimal qu'il est possible de représenter en JavaScript.</p>
+## Exemples
 
-<p><code>MIN_VALUE</code> vaut environ 5e-324. Les valeurs inférieures à <code>MIN_VALUE</code> sont converties en 0.</p>
+Le code qui suit effectue la division de deux nombres. Si le résultat obtenu est supérieur ou égal à `MIN_VALUE`, la fonction `func1` sera appelée, sinon la fonction `func2` sera utilisée.
 
-<p><code>MIN_VALUE</code> est une propriété statique de {{jsxref("Number")}} et doit donc être utilisée avec la syntaxe <code>Number.MIN_VALUE</code>, et non pas via la propriété d'un objet <code>Number</code> qui aurait été instancié.</p>
-
-<h2 id="Exemples">Exemples</h2>
-
-<p>Le code qui suit effectue la division de deux nombres. Si le résultat obtenu est supérieur ou égal à <code>MIN_VALUE</code>, la fonction <code>func1</code> sera appelée, sinon la fonction <code>func2</code> sera utilisée.</p>
-
-<pre class="brush:js">if (num1 / num2 &gt;= Number.MIN_VALUE) {
+```js
+if (num1 / num2 >= Number.MIN_VALUE) {
     func1();
 } else {
     func2();
-}</pre>
+}
+```
 
-<h2 id="Spécifications">Spécifications</h2>
+## Spécifications
 
-<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.1</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.7.3.3', 'Number.MIN_VALUE')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-number.min_value', 'Number.MIN_VALUE')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-number.min_value', 'Number.MIN_VALUE')}}</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.1 |
+| {{SpecName('ES5.1', '#sec-15.7.3.3', 'Number.MIN_VALUE')}}                 | {{Spec2('ES5.1')}}     |                                                      |
+| {{SpecName('ES6', '#sec-number.min_value', 'Number.MIN_VALUE')}}         | {{Spec2('ES6')}}         |                                                      |
+| {{SpecName('ESDraft', '#sec-number.min_value', 'Number.MIN_VALUE')}} | {{Spec2('ESDraft')}} |                                                      |
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.Number.MIN_VALUE")}}</p>
+{{Compat("javascript.builtins.Number.MIN_VALUE")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("Number.MAX_VALUE")}}</li>
-</ul>
+- {{jsxref("Number.MAX_VALUE")}}
diff --git a/files/fr/web/javascript/reference/global_objects/number/nan/index.md b/files/fr/web/javascript/reference/global_objects/number/nan/index.md
index 4f16fd16ae..edd02e3b02 100644
--- a/files/fr/web/javascript/reference/global_objects/number/nan/index.md
+++ b/files/fr/web/javascript/reference/global_objects/number/nan/index.md
@@ -9,55 +9,30 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Number/NaN
 original_slug: Web/JavaScript/Reference/Objets_globaux/Number/NaN
 ---
-<div>{{JSRef}}</div>
-
-<p>La propriété <strong><code>Number.NaN</code></strong> représente une valeur qui n'est pas un nombre (en anglais « <em>Not-A-Number</em> » qui donne NaN). Elle est équivalente à {{jsxref("NaN")}}.</p>
-
-<div>{{EmbedInteractiveExample("pages/js/number-nan.html")}}</div>
-
-<p>Il n'est pas nécessaire de créer un objet {{jsxref("Number")}} pour accéder à cette propriété statique. Il suffit d'utiliser directement <code>Number.NaN</code>.</p>
-
-<p>{{js_property_attributes(0,0,0)}}</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.1.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.7.3.4', 'Number.NaN')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-number.nan', 'Number.NaN')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-number.nan', 'Number.NaN')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Number.NaN")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>L'objet global {{jsxref("NaN")}} ;</li>
- <li>L'objet {{jsxref("Number")}} auquel appartient cette propriété.</li>
-</ul>
+{{JSRef}}
+
+La propriété **`Number.NaN`** représente une valeur qui n'est pas un nombre (en anglais « *Not-A-Number* » qui donne NaN). Elle est équivalente à {{jsxref("NaN")}}.
+
+{{EmbedInteractiveExample("pages/js/number-nan.html")}}
+
+Il n'est pas nécessaire de créer un objet {{jsxref("Number")}} pour accéder à cette propriété statique. Il suffit d'utiliser directement `Number.NaN`.
+
+{{js_property_attributes(0,0,0)}}
+
+## 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.7.3.4', 'Number.NaN')}}         | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-number.nan', 'Number.NaN')}}         | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-number.nan', 'Number.NaN')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Number.NaN")}}
+
+## Voir aussi
+
+- L'objet global {{jsxref("NaN")}} ;
+- L'objet {{jsxref("Number")}} auquel appartient cette propriété.
diff --git a/files/fr/web/javascript/reference/global_objects/number/negative_infinity/index.md b/files/fr/web/javascript/reference/global_objects/number/negative_infinity/index.md
index 634c779d96..0bd45fa9ba 100644
--- a/files/fr/web/javascript/reference/global_objects/number/negative_infinity/index.md
+++ b/files/fr/web/javascript/reference/global_objects/number/negative_infinity/index.md
@@ -9,90 +9,60 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Number/NEGATIVE_INFINITY
 original_slug: Web/JavaScript/Reference/Objets_globaux/Number/NEGATIVE_INFINITY
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La propriété <code><strong>Number.NEGATIVE_INFINITY</strong></code> représente l'infini négatif.</p>
+La propriété **`Number.NEGATIVE_INFINITY`** représente l'infini négatif.
 
-<div>{{EmbedInteractiveExample("pages/js/number-negative-infinity.html")}}</div>
+{{EmbedInteractiveExample("pages/js/number-negative-infinity.html")}}{{js_property_attributes(0,0,0)}}
 
+## Description
 
+La valeur de `Number.NEGATIVE_INFINITY` est égale à l'opposé de la valeur fournie par la propriété {{jsxref("Infinity")}} de l'objet global.
 
-<div>{{js_property_attributes(0,0,0)}}</div>
+Cette valeur se comporte différemment de l'infini mathématique :
 
-<h2 id="Description">Description</h2>
+- Toute valeur positive, y compris {{jsxref("Number.POSITIVE_INFINITY", "POSITIVE_INFINITY")}}, multipliée par `NEGATIVE_INFINITY` sera égale à `NEGATIVE_INFINITY`.
+- Toute valeur négative, y compris `NEGATIVE_INFINITY`, multipliée par `NEGATIVE_INFINITY` sera égale à `POSITIVE_INFINITY`.
+- Zéro multiplié par `NEGATIVE_INFINITY` sera égal à {{jsxref("NaN")}}.
+- NaN multiplié par `NEGATIVE_INFINITY` sera égal à `NaN`.
+- `NEGATIVE_INFINITY`, divisé par n'importe quelle valeur négative, à l'exception de  `NEGATIVE_INFINITY`, sera égal à `POSITIVE_INFINITY`.
+- `NEGATIVE_INFINITY`, divisé par n'importe quelle valeur positive à l'exception de  `POSITIVE_INFINITY`, sera égal à `NEGATIVE_INFINITY`.
+- `NEGATIVE_INFINITY`, divisé par `NEGATIVE_INFINITY` ou `POSITIVE_INFINITY`, sera égal à `NaN`.
+- Tout nombre positif divisé par `NEGATIVE_INFINITY` sera égal au zéro négatif.
+- Tout nombre négatif divisé par `NEGATIVE_INFINITY` sera égal au zéro positif.
 
-<p>La valeur de <code>Number.NEGATIVE_INFINITY</code> est égale à l'opposé de la valeur fournie par la propriété {{jsxref("Infinity")}} de l'objet global.</p>
+La propriété `Number.NEGATIVE_INFINITY` peut être utilisée pour indiquer une erreur sur un test renvoyant normalement un nombre fini. On notera cependant que la méthode {{jsxref("isFinite")}} est plus pertinente dans ce cas.
 
-<p>Cette valeur se comporte différemment de l'infini mathématique :</p>
+`Number.NEGATIVE_INFINITY` est une propriété statique de {{jsxref("Number")}} et on utilisera directement `Number.NEGATIVE_INFINITY` plutôt que comme une propriété d'un objet (instance) {{jsxref("Number")}}.
 
-<ul>
- <li>Toute valeur positive, y compris {{jsxref("Number.POSITIVE_INFINITY", "POSITIVE_INFINITY")}}, multipliée par <code>NEGATIVE_INFINITY</code> sera égale à <code>NEGATIVE_INFINITY</code>.</li>
- <li>Toute valeur négative, y compris <code>NEGATIVE_INFINITY</code>, multipliée par <code>NEGATIVE_INFINITY</code> sera égale à <code>POSITIVE_INFINITY</code>.</li>
- <li>Zéro multiplié par <code>NEGATIVE_INFINITY</code> sera égal à {{jsxref("NaN")}}.</li>
- <li>NaN multiplié par <code>NEGATIVE_INFINITY</code> sera égal à <code>NaN</code>.</li>
- <li><code>NEGATIVE_INFINITY</code>, divisé par n'importe quelle valeur négative, à l'exception de  <code>NEGATIVE_INFINITY</code>, sera égal à <code>POSITIVE_INFINITY</code>.</li>
- <li><code>NEGATIVE_INFINITY</code>, divisé par n'importe quelle valeur positive à l'exception de  <code>POSITIVE_INFINITY</code>, sera égal à <code>NEGATIVE_INFINITY</code>.</li>
- <li><code>NEGATIVE_INFINITY</code>, divisé par <code>NEGATIVE_INFINITY</code> ou <code>POSITIVE_INFINITY</code>, sera égal à <code>NaN</code>.</li>
- <li>Tout nombre positif divisé par <code>NEGATIVE_INFINITY</code> sera égal au zéro négatif.</li>
- <li>Tout nombre négatif divisé par <code>NEGATIVE_INFINITY</code> sera égal au zéro positif.</li>
-</ul>
+## Exemples
 
-<p>La propriété <code>Number.NEGATIVE_INFINITY</code> peut être utilisée pour indiquer une erreur sur un test renvoyant normalement un nombre fini. On notera cependant que la méthode {{jsxref("isFinite")}} est plus pertinente dans ce cas.</p>
+Dans l'exemple qui suit, on affecte une variable inférieure à la valeur numérique minimale à la variable `petitNombre`. Lorsque l'instruction conditionnelle `if` est exécutée, `petitNombre` possède la valeur "`-Infinity`", on modifie donc la valeur de `petitNombre` afin qu'il puisse être géré.
 
-<p><code>Number.NEGATIVE_INFINITY</code> est une propriété statique de {{jsxref("Number")}} et on utilisera directement <code>Number.NEGATIVE_INFINITY</code> plutôt que comme une propriété d'un objet (instance) {{jsxref("Number")}}.</p>
-
-<h2 id="Exemples">Exemples</h2>
-
-<p>Dans l'exemple qui suit, on affecte une variable inférieure à la valeur numérique minimale à la variable <code>petitNombre</code>. Lorsque l'instruction conditionnelle <code>if</code> est exécutée, <code>petitNombre</code> possède la valeur "<code>-Infinity</code>", on modifie donc la valeur de <code>petitNombre</code> afin qu'il puisse être géré.</p>
-
-<pre class="brush:js">var petitNombre = (-Number.MAX_VALUE) * 2
+```js
+var petitNombre = (-Number.MAX_VALUE) * 2
 
 if (petitNombre === Number.NEGATIVE_INFINITY) {
  petitNombre = renvoyerUneValeurFinie();
 }
-</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.7.3.5', 'Number.NEGATIVE_INFINITY')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-number.negative_infinity', 'Number.NEGATIVE_INFINITY')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-number.negative_infinity', 'Number.NEGATIVE_INFINITY')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Number.NEGATIVE_INFINITY")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Number.POSITIVE_INFINITY")}}</li>
- <li>{{jsxref("Number.isFinite()")}}</li>
- <li>{{jsxref("Infinity", "Infinity")}}</li>
- <li>{{jsxref("isFinite", "isFinite()")}}</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.7.3.5', 'Number.NEGATIVE_INFINITY')}}                         | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-number.negative_infinity', 'Number.NEGATIVE_INFINITY')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-number.negative_infinity', 'Number.NEGATIVE_INFINITY')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Number.NEGATIVE_INFINITY")}}
+
+## Voir aussi
+
+- {{jsxref("Number.POSITIVE_INFINITY")}}
+- {{jsxref("Number.isFinite()")}}
+- {{jsxref("Infinity", "Infinity")}}
+- {{jsxref("isFinite", "isFinite()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/number/parsefloat/index.md b/files/fr/web/javascript/reference/global_objects/number/parsefloat/index.md
index e0c630af48..c0b1031793 100644
--- a/files/fr/web/javascript/reference/global_objects/number/parsefloat/index.md
+++ b/files/fr/web/javascript/reference/global_objects/number/parsefloat/index.md
@@ -10,72 +10,53 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Number/parseFloat
 original_slug: Web/JavaScript/Reference/Objets_globaux/Number/parseFloat
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>Number.parseFloat()</code></strong> analyse et convertit une chaîne de caractères en un nombre flottant. Cette méthode possède un comportement identique à {{jsxref("parseFloat")}} et fait partie d'ECMAScript 2015 (dans le but de « modulariser » les méthodes globales).</p>
+La méthode **`Number.parseFloat()`** analyse et convertit une chaîne de caractères en un nombre flottant. Cette méthode possède un comportement identique à {{jsxref("parseFloat")}} et fait partie d'ECMAScript 2015 (dans le but de « modulariser » les méthodes globales).
 
-<div>{{EmbedInteractiveExample("pages/js/number-parsefloat.html")}}</div>
+{{EmbedInteractiveExample("pages/js/number-parsefloat.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">Number.parseFloat(chaîne)</pre>
+    Number.parseFloat(chaîne)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code><var>chaîne</var></code></dt>
- <dd>Une chaîne de caractères qu'on souhaite convertir en nombre flottant.</dd>
-</dl>
+- `chaîne`
+  - : Une chaîne de caractères qu'on souhaite convertir en nombre flottant.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un nombre flottant obtenu à partir de l'analyse de la chaîne de caractères passée en argument. Si le premier caractère de la chaîne ne peut pas être converti en un nombre, la  valeur {{jsxref("NaN")}} sera renvoyée.</p>
+Un nombre flottant obtenu à partir de l'analyse de la chaîne de caractères passée en argument. Si le premier caractère de la chaîne ne peut pas être converti en un nombre, la  valeur {{jsxref("NaN")}} sera renvoyée.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Cette méthode possède les mêmes fonctionnalités que la fonction globale {{jsxref("parseFloat", "parseFloat()")}} :</p>
+Cette méthode possède les mêmes fonctionnalités que la fonction globale {{jsxref("parseFloat", "parseFloat()")}} :
 
-<pre>Number.parseFloat === parseFloat; // true
-</pre>
+    Number.parseFloat === parseFloat; // true
 
-<p>Cette méthode fait partie d'ECMAScript 2015 et notamment de la modularisation de certaines fonctions globales. Pour plus de détails et d'exemples, voir {{jsxref("parseFloat", "parseFloat()")}}.</p>
+Cette méthode fait partie d'ECMAScript 2015 et notamment de la modularisation de certaines fonctions globales. Pour plus de détails et d'exemples, voir {{jsxref("parseFloat", "parseFloat()")}}.
 
-<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 (Number.parseFloat === undefined) {
+```js
+if (Number.parseFloat === undefined) {
     Number.parseFloat = parseFloat;
 }
-</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-number.parsefloat', 'Number.parseFloat')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-number.parsefloat', 'Number.parseFloat')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Number.parseFloat")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>L'objet {{jsxref("Number")}} auquel appartient cette fonction.</li>
- <li>La méthode globale {{jsxref("parseFloat")}}.</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                | État                         | Commentaires         |
+| -------------------------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ES2015', '#sec-number.parsefloat', 'Number.parseFloat')}} | {{Spec2('ES2015')}}     | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-number.parsefloat', 'Number.parseFloat')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Number.parseFloat")}}
+
+## Voir aussi
+
+- L'objet {{jsxref("Number")}} auquel appartient cette fonction.
+- La méthode globale {{jsxref("parseFloat")}}.
diff --git a/files/fr/web/javascript/reference/global_objects/number/parseint/index.md b/files/fr/web/javascript/reference/global_objects/number/parseint/index.md
index 780ba5b85e..e77f8baff6 100644
--- a/files/fr/web/javascript/reference/global_objects/number/parseint/index.md
+++ b/files/fr/web/javascript/reference/global_objects/number/parseint/index.md
@@ -10,72 +10,57 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Number/parseInt
 original_slug: Web/JavaScript/Reference/Objets_globaux/Number/parseInt
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>Number.parseInt()</code></strong> analyse et convertit une chaine de caractères, fournie en argument, en un entier dans la base souhaitée.</p>
+La méthode **`Number.parseInt()`** analyse et convertit une chaine de caractères, fournie en argument, en un entier dans la base souhaitée.
 
-<div>{{EmbedInteractiveExample("pages/js/number-parseint.html")}}</div>
+{{EmbedInteractiveExample("pages/js/number-parseint.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">Number.parseInt(<var>chaîne</var> [,<var> base</var>])</pre>
+    Number.parseInt(chaîne [, base])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>chaîne</code></dt>
- <dd>La valeur à convertir. Si <code>chaine</code> n'est pas une chaîne de caractères, elle sera convertie auparavant. Les blancs qui préfixent la chaîne sont ignorés.</dd>
- <dt><code>base</code> {{optional_inline}}</dt>
- <dd>Paramètre optionnel. Un entier représentant la base dans laquelle est représentée la valeur de la chaîne. <strong>Il faut toujours spécifier ce paramètre.</strong> Cela permet que le code ne soit pas ambigü et permet de garantir un comportement prévisible. En effet les différentes implémentations peuvent fournir des résultats différents lorsque la base n'est pas spécifiée.</dd>
-</dl>
+- `chaîne`
+  - : La valeur à convertir. Si `chaine` n'est pas une chaîne de caractères, elle sera convertie auparavant. Les blancs qui préfixent la chaîne sont ignorés.
+- `base` {{optional_inline}}
+  - : Paramètre optionnel. Un entier représentant la base dans laquelle est représentée la valeur de la chaîne. **Il faut toujours spécifier ce paramètre.** Cela permet que le code ne soit pas ambigü et permet de garantir un comportement prévisible. En effet les différentes implémentations peuvent fournir des résultats différents lorsque la base n'est pas spécifiée.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un entier construit à partir de l'analyse de la chaîne de caractères passée en argument. Si le premier caractère ne permet pas de conversion numérique, c'est la valeur {{jsxref("NaN")}} qui sera renvoyée.</p>
+Un entier construit à partir de l'analyse de la chaîne de caractères passée en argument. Si le premier caractère ne permet pas de conversion numérique, c'est la valeur {{jsxref("NaN")}} qui sera renvoyée.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Voir la page {{jsxref("Objets_globaux/parseInt", "parseInt()")}} pour plus de détails et d'exemples. Cette méthode se comporte de façon identique à la fonction globale {{jsxref("Objets_globaux/parseInt", "parseInt()")}} et fait partie d'ECMAScript 2015 (dans le but de « modulariser » les méthodes globales) et on aura :</p>
+Voir la page {{jsxref("Objets_globaux/parseInt", "parseInt()")}} pour plus de détails et d'exemples. Cette méthode se comporte de façon identique à la fonction globale {{jsxref("Objets_globaux/parseInt", "parseInt()")}} et fait partie d'ECMAScript 2015 (dans le but de « modulariser » les méthodes globales) et on aura :
 
-<pre class="brush: js">Number.parseInt === parseInt; // true</pre>
+```js
+Number.parseInt === parseInt; // true
+```
 
-<h2 id="Prothèse_d'émulation_(polyfill)">Prothèse d'émulation (<em>polyfill</em>)</h2>
+## Prothèse d'émulation (_polyfill_)
 
-<p>Si on souhaite bénéficier de cette fonction dans un environnement qui n'en dispose pas, on pourra donc l'émuler de la façon suivante :</p>
+Si on souhaite bénéficier de cette fonction dans un environnement qui n'en dispose pas, on pourra donc l'émuler de la façon suivante :
 
-<pre class="brush: js">if(Number.parseInt === undefined) {
+```js
+if(Number.parseInt === undefined) {
   Number.parseInt = parseInt;
-}</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-number.parseint', 'Number.parseInt')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-number.parseint', 'Number.parseInt')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Number.parseInt")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>L'objet {{jsxref("Number")}} auquel appartient cette fonction.</li>
- <li>La méthode {{jsxref("Objets_globaux/parseInt","parseInt()")}} de l'objet global.</li>
-</ul>
+}
+```
+
+## Spécifications
+
+| Spécification                                                                            | État                         | Commentaires         |
+| ---------------------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ES2015', '#sec-number.parseint', 'Number.parseInt')}} | {{Spec2('ES2015')}}     | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-number.parseint', 'Number.parseInt')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Number.parseInt")}}
+
+## Voir aussi
+
+- L'objet {{jsxref("Number")}} auquel appartient cette fonction.
+- La méthode {{jsxref("Objets_globaux/parseInt","parseInt()")}} de l'objet global.
diff --git a/files/fr/web/javascript/reference/global_objects/number/positive_infinity/index.md b/files/fr/web/javascript/reference/global_objects/number/positive_infinity/index.md
index 8ee53b1752..066c2ad931 100644
--- a/files/fr/web/javascript/reference/global_objects/number/positive_infinity/index.md
+++ b/files/fr/web/javascript/reference/global_objects/number/positive_infinity/index.md
@@ -9,91 +9,63 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Number/POSITIVE_INFINITY
 original_slug: Web/JavaScript/Reference/Objets_globaux/Number/POSITIVE_INFINITY
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La propriéte <code><strong>Number.POSITIVE_INFINITY</strong></code> représente l'infini (positif).</p>
+La propriéte **`Number.POSITIVE_INFINITY`** représente l'infini (positif).
 
-<div>{{EmbedInteractiveExample("pages/js/number-positive-infinity.html")}}</div>
+{{EmbedInteractiveExample("pages/js/number-positive-infinity.html")}}
 
+{{js_property_attributes(0,0,0)}}
 
+## Description
 
-<p>{{js_property_attributes(0,0,0)}}</p>
+La valeur de `Number.POSITIVE_INFINITY` est identique à la valeur de la propriété de l'objet global {{jsxref("Infinity")}}.
 
-<h2 id="Description">Description</h2>
+Cette valeur possède un comportement légèrement différent de l'infini au sens mathématique :
 
-<p>La valeur de <code>Number.POSITIVE_INFINITY</code> est identique à la valeur de la propriété de l'objet global {{jsxref("Infinity")}}.</p>
+- Tout valeur positive, y compris `POSITIVE_INFINITY,` multipliée par  `POSITIVE_INFINITY` sera égale à `POSITIVE_INFINITY`.
+- Toute valeur négative, y compris {{jsxref("Number.NEGATIVE_INFINITY", "NEGATIVE_INFINITY")}}, multipliée par `POSITIVE_INFINITY` sera égale à `NEGATIVE_INFINITY`.
+- Zéro multiplié par `POSITIVE_INFINITY` sera égal à {{jsxref("NaN")}}.
+- NaN multiplié par `POSITIVE_INFINITY` sera égal à NaN.
+- `POSITIVE_INFINITY`, divisé par n'importe quelle valeur négative, à l'exception de `NEGATIVE_INFINITY`, sera égal à `NEGATIVE_INFINITY`.
+- `POSITIVE_INFINITY`, divisé par n'importe quelle valeur positive, à l'exception de `POSITIVE_INFINITY`, sera égal à `POSITIVE_INFINITY`.
+- `POSITIVE_INFINITY`, divisé par `NEGATIVE_INFINITY` ou `POSITIVE_INFINITY`, sera égal NaN.
+- Tout nombre positif divisé par `POSITIVE_INFINITY` sera égal au zéro positif.
+- Tout nombre négatif divisé par `POSITIVE_INFINITY` sera égal au zéro négatif.
 
-<p>Cette valeur possède un comportement légèrement différent de l'infini au sens mathématique :</p>
+Il est possible d'utiliser la propriété `Number.POSITIVE_INFINITY` pour faire un test d'erreur sur une valeur qu'on attendait finie. Cependant, la méthode {{jsxref("isFinite")}} sera plus appropriée dans ce cas.
 
-<ul>
- <li>Tout valeur positive, y compris <code>POSITIVE_INFINITY,</code> multipliée par  <code>POSITIVE_INFINITY</code> sera égale à <code>POSITIVE_INFINITY</code>.</li>
- <li>Toute valeur négative, y compris {{jsxref("Number.NEGATIVE_INFINITY", "NEGATIVE_INFINITY")}}, multipliée par <code>POSITIVE_INFINITY</code> sera égale à <code>NEGATIVE_INFINITY</code>.</li>
- <li>Zéro multiplié par <code>POSITIVE_INFINITY</code> sera égal à {{jsxref("NaN")}}.</li>
- <li>NaN multiplié par <code>POSITIVE_INFINITY</code> sera égal à NaN.</li>
- <li><code>POSITIVE_INFINITY</code>, divisé par n'importe quelle valeur négative, à l'exception de <code>NEGATIVE_INFINITY</code>, sera égal à <code>NEGATIVE_INFINITY</code>.</li>
- <li><code>POSITIVE_INFINITY</code>, divisé par n'importe quelle valeur positive, à l'exception de <code>POSITIVE_INFINITY</code>, sera égal à <code>POSITIVE_INFINITY</code>.</li>
- <li><code>POSITIVE_INFINITY</code>, divisé par <code>NEGATIVE_INFINITY</code> ou <code>POSITIVE_INFINITY</code>, sera égal NaN.</li>
- <li>Tout nombre positif divisé par <code>POSITIVE_INFINITY</code> sera égal au zéro positif.</li>
- <li>Tout nombre négatif divisé par <code>POSITIVE_INFINITY</code> sera égal au zéro négatif.</li>
-</ul>
+`Number.POSITIVE_INFINITY` est une propriété statique de {{jsxref("Number")}} et il n'est donc pas nécessaire de créer un objet {{jsxref("Number")}} afin d'utiliser cette propriété.
 
-<p>Il est possible d'utiliser la propriété <code>Number.POSITIVE_INFINITY</code> pour faire un test d'erreur sur une valeur qu'on attendait finie. Cependant, la méthode {{jsxref("isFinite")}} sera plus appropriée dans ce cas.</p>
+## Exemple
 
-<p><code>Number.POSITIVE_INFINITY</code> est une propriété statique de {{jsxref("Number")}} et il n'est donc pas nécessaire de créer un objet {{jsxref("Number")}} afin d'utiliser cette propriété.</p>
+### Utiliser `POSITIVE_INFINITY`
 
-<h2 id="Exemple">Exemple</h2>
+Dans l'exemple qui suit, on affecte une valeur plus grande que la valeur maximale à la variable `grosNombre`. Lors de l'exécution de l'instruction `if`, `grosNombre` aura la valeur `Infinity`, pour continuer, on met à jour `grosNombre` avec une valeur plus acceptable.
 
-<h3 id="Utiliser_POSITIVE_INFINITY">Utiliser <code>POSITIVE_INFINITY</code></h3>
-
-<p>Dans l'exemple qui suit, on affecte une valeur plus grande que la valeur maximale à la variable <code>grosNombre</code>. Lors de l'exécution de l'instruction <code>if</code>, <code>grosNombre</code> aura la valeur <code>Infinity</code>, pour continuer, on met à jour <code>grosNombre</code> avec une valeur plus acceptable.</p>
-
-<pre class="brush: js">var grosNombre = Number.MAX_VALUE * 2
+```js
+var grosNombre = Number.MAX_VALUE * 2
 if (grosNombre == Number.POSITIVE_INFINITY) {
  grosNombre = renvoyerUnNombreFini();
 }
-</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. Implémentée avec JavaScript 1.1.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.7.3.6', 'Number.POSITIVE_INFINITY')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-number.positive_infinity', 'Number.POSITIVE_INFINITY')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-number.positive_infinity', 'Number.POSITIVE_INFINITY')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Number.POSITIVE_INFINITY")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Number.NEGATIVE_INFINITY")}}</li>
- <li>{{jsxref("Number.isFinite()")}}</li>
- <li>{{jsxref("Infinity")}}</li>
- <li>{{jsxref("isFinite")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                    | Statut                       | Commentaires                                          |
+| ---------------------------------------------------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- |
+| {{SpecName('ES1')}}                                                                                         | {{Spec2('ES1')}}         | Définition initiale. Implémentée avec JavaScript 1.1. |
+| {{SpecName('ES5.1', '#sec-15.7.3.6', 'Number.POSITIVE_INFINITY')}}                         | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-number.positive_infinity', 'Number.POSITIVE_INFINITY')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-number.positive_infinity', 'Number.POSITIVE_INFINITY')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Number.POSITIVE_INFINITY")}}
+
+## Voir aussi
+
+- {{jsxref("Number.NEGATIVE_INFINITY")}}
+- {{jsxref("Number.isFinite()")}}
+- {{jsxref("Infinity")}}
+- {{jsxref("isFinite")}}
diff --git a/files/fr/web/javascript/reference/global_objects/number/toexponential/index.md b/files/fr/web/javascript/reference/global_objects/number/toexponential/index.md
index 2b3667b776..eb923a599c 100644
--- a/files/fr/web/javascript/reference/global_objects/number/toexponential/index.md
+++ b/files/fr/web/javascript/reference/global_objects/number/toexponential/index.md
@@ -10,97 +10,69 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Number/toExponential
 original_slug: Web/JavaScript/Reference/Objets_globaux/Number/toExponential
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>toExponential()</code></strong> renvoie une chaîne de caractères, représentant l'objet Number en notation exponentielle.</p>
+La méthode **`toExponential()`** renvoie une chaîne de caractères, représentant l'objet Number en notation exponentielle.
 
-<div>{{EmbedInteractiveExample("pages/js/number-toexponential.html")}}</div>
+{{EmbedInteractiveExample("pages/js/number-toexponential.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>numObj</var>.toExponential([nbChiffresDécimaux])</pre>
+    numObj.toExponential([nbChiffresDécimaux])
 
-<h3 id="Paramètre">Paramètre</h3>
+### Paramètre
 
-<dl>
- <dt><code>nbChiffresDécimaux</code></dt>
- <dd>Paramètre optionnel. Un entier donnant le nombre de chiffres qu'on souhaite avoir dans la partie fractionnaire. Le comportement par défaut considèrera autant de chiffres que nécessaire pour représenter le nombre.</dd>
-</dl>
+- `nbChiffresDécimaux`
+  - : Paramètre optionnel. Un entier donnant le nombre de chiffres qu'on souhaite avoir dans la partie fractionnaire. Le comportement par défaut considèrera autant de chiffres que nécessaire pour représenter le nombre.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une chaîne représentant l'objet {{jsxref("Number")}} appelant en notation exponentielle avec un chiffre avant la virgule et arrondi à <code>nbChiffresDécimaux</code> après la virgule.</p>
+Une chaîne représentant l'objet {{jsxref("Number")}} appelant en notation exponentielle avec un chiffre avant la virgule et arrondi à `nbChiffresDécimaux` après la virgule.
 
-<h3 id="Exceptions">Exceptions</h3>
+### Exceptions
 
-<dl>
- <dt>{{jsxref("RangeError")}}</dt>
- <dd>Cette exception est causée si <code>nbChiffresDécimaux</code> est trop petit ou trop grand. Les valeurs comprises, au sens large, entre 0 et 20 ne causeront pas d'exception {{jsxref("RangeError")}}. Les implémentations peuvent également autorisér des valeurs en dehors de ces bornes.</dd>
- <dt>{{jsxref("TypeError")}}</dt>
- <dd>Si cette méthode est invoquée pour un objet qui n'est pas un objet <code>Number</code>.</dd>
-</dl>
+- {{jsxref("RangeError")}}
+  - : Cette exception est causée si `nbChiffresDécimaux` est trop petit ou trop grand. Les valeurs comprises, au sens large, entre 0 et 20 ne causeront pas d'exception {{jsxref("RangeError")}}. Les implémentations peuvent également autorisér des valeurs en dehors de ces bornes.
+- {{jsxref("TypeError")}}
+  - : Si cette méthode est invoquée pour un objet qui n'est pas un objet `Number`.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La valeur renvoyée est une chaîne de caractères correspondant à la représentation du nombre en notation exponentielle. La partie entière est constituée d'un seul chiffre et la partie fractionnaire est composée de <code>nbChiffresDécimaux</code> chiffres. Si l'argument <code>nbChiffresDécimaux </code>est absent, il y aura autant de chiffres dans la partie fractionnaire que nécessaire pour représenter le nombre de façon unique.</p>
+La valeur renvoyée est une chaîne de caractères correspondant à la représentation du nombre en notation exponentielle. La partie entière est constituée d'un seul chiffre et la partie fractionnaire est composée de `nbChiffresDécimaux` chiffres. Si l'argument `nbChiffresDécimaux `est absent, il y aura autant de chiffres dans la partie fractionnaire que nécessaire pour représenter le nombre de façon unique.
 
-<p>Si la méthode <code>toExponential()</code> est utilisée avec un littéral numérique et que celui-ci ne possède aucun exposant ou séparateur décimal ("."), il faut laisser un ou plusieurs espaces entre le littéral et le point indiquant l'appel de la méthode. Cela permet d'éviter que le point, permettant d'accéder à la méthode, soit confondu avec un séparateur décimal.</p>
+Si la méthode `toExponential()` est utilisée avec un littéral numérique et que celui-ci ne possède aucun exposant ou séparateur décimal ("."), il faut laisser un ou plusieurs espaces entre le littéral et le point indiquant l'appel de la méthode. Cela permet d'éviter que le point, permettant d'accéder à la méthode, soit confondu avec un séparateur décimal.
 
-<p>Si un nombre possède plus de chiffres décimaux que <code>nbChiffresDécimaux</code>, le nombre est arrondi au nombre le plus proche, représenté avec <code>nbChiffresDécimaux</code> pour la partie fractionnaire. Voir la discussion sur les arrondis dans la page  de la méthode {{jsxref("Number.toFixed", "toFixed()")}} pour plus de détails, la même méthode est utilisée pour <code>toExponential()</code>.</p>
+Si un nombre possède plus de chiffres décimaux que `nbChiffresDécimaux`, le nombre est arrondi au nombre le plus proche, représenté avec `nbChiffresDécimaux` pour la partie fractionnaire. Voir la discussion sur les arrondis dans la page  de la méthode {{jsxref("Number.toFixed", "toFixed()")}} pour plus de détails, la même méthode est utilisée pour `toExponential()`.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_toExponential">Utiliser <code>toExponential</code></h3>
+### Utiliser `toExponential`
 
-<pre class="brush: js">var numObj = 77.1234;
+```js
+var numObj = 77.1234;
 
 console.log(numObj.toExponential());  // affiche 7.71234e+1
 console.log(numObj.toExponential(4)); // affiche 7.7123e+1
 console.log(numObj.toExponential(2)); // affiche 7.71e+1
 console.log(77.1234.toExponential()); // affiche 7.71234e+1
 console.log(77 .toExponential());     // affiche 7.7e+1
-</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.5.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.7.4.6', 'Number.prototype.toExponential')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-number.prototype.toexponential', 'Number.prototype.toExponential')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-number.prototype.toexponential', 'Number.prototype.toExponential')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Number.toExponential")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Number.prototype.toFixed()")}}</li>
- <li>{{jsxref("Number.prototype.toPrecision()")}}</li>
- <li>{{jsxref("Number.prototype.toString()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                                    | État                         | Commentaires                                          |
+| -------------------------------------------------------------------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- |
+| {{SpecName('ES3')}}                                                                                                         | {{Spec2('ES3')}}         | Définition initiale. Implémentée avec JavaScript 1.5. |
+| {{SpecName('ES5.1', '#sec-15.7.4.6', 'Number.prototype.toExponential')}}                                 | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-number.prototype.toexponential', 'Number.prototype.toExponential')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-number.prototype.toexponential', 'Number.prototype.toExponential')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Number.toExponential")}}
+
+## Voir aussi
+
+- {{jsxref("Number.prototype.toFixed()")}}
+- {{jsxref("Number.prototype.toPrecision()")}}
+- {{jsxref("Number.prototype.toString()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/number/tofixed/index.md b/files/fr/web/javascript/reference/global_objects/number/tofixed/index.md
index 04f3a49458..356025f244 100644
--- a/files/fr/web/javascript/reference/global_objects/number/tofixed/index.md
+++ b/files/fr/web/javascript/reference/global_objects/number/tofixed/index.md
@@ -10,47 +10,42 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Number/toFixed
 original_slug: Web/JavaScript/Reference/Objets_globaux/Number/toFixed
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>toFixed()</strong></code> permet de formater un nombre en notation à point-fixe.</p>
+La méthode **`toFixed()`** permet de formater un nombre en notation à point-fixe.
 
-<div>{{EmbedInteractiveExample("pages/js/number-tofixed.html")}}</div>
+{{EmbedInteractiveExample("pages/js/number-tofixed.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>numObj</var>.toFixed([nbChiffres])</pre>
+    numObj.toFixed([nbChiffres])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>nbChiffres</code> {{optional_inline}}</dt>
- <dd>Le nombre de chiffres qu'on souhaite avoir après le séparateur décimal. Cette valeur peut être comprise, au sens large, entre 0 et 20. Les différentes implémentations peuvent éventuellement supporter des valeurs en dehors de cet intervalle. Si l'argument n'est pas utilisé, la valeur par défaut sera 0.</dd>
-</dl>
+- `nbChiffres` {{optional_inline}}
+  - : Le nombre de chiffres qu'on souhaite avoir après le séparateur décimal. Cette valeur peut être comprise, au sens large, entre 0 et 20. Les différentes implémentations peuvent éventuellement supporter des valeurs en dehors de cet intervalle. Si l'argument n'est pas utilisé, la valeur par défaut sera 0.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une chaîne de caractères qui représente le nombre indiqué avec une notation à point fixe.</p>
+Une chaîne de caractères qui représente le nombre indiqué avec une notation à point fixe.
 
-<h3 id="Exceptions_causées">Exceptions causées</h3>
+### Exceptions causées
 
-<dl>
- <dt>{{jsxref("RangeError")}}</dt>
- <dd>Cette exception est renvoyée si <code>nbChiffres</code> est trop grand ou trop petit. Les valeurs comprises, au sens large, entre 0 et 100, n'entraîneront pas de <code>RangeError</code>. Les différentes implémentations peuvent ou non supporter des valeurs plus petites et/ou plus grandes.</dd>
- <dt>{{jsxref("TypeError")}}</dt>
- <dd>Cette exception est renvoyée si cette méthode est invoquée depuis un objet qui n'est pas de type numérique.</dd>
-</dl>
+- {{jsxref("RangeError")}}
+  - : Cette exception est renvoyée si `nbChiffres` est trop grand ou trop petit. Les valeurs comprises, au sens large, entre 0 et 100, n'entraîneront pas de `RangeError`. Les différentes implémentations peuvent ou non supporter des valeurs plus petites et/ou plus grandes.
+- {{jsxref("TypeError")}}
+  - : Cette exception est renvoyée si cette méthode est invoquée depuis un objet qui n'est pas de type numérique.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p><code>toFixed()</code> renvoie une chaîne de caractères représentant <code>objetNumber</code> sans notation exponentielle et qui possède exactement <code>nbChiffres</code> pour la partie fractionnaire. Le nombre est arrondi si nécessaire et la partie fractionnaire est complétée par des zéros si nécessaire pour obtenir la longueur souhaitée. Si le <code>objetNumber</code> est supérieur ou égal à <code>1e+21</code>, la méthode utilise simplement {{jsxref("Number.prototype.toString()")}} et renvoie une chaîne en notation exponentielle.</p>
+`toFixed()` renvoie une chaîne de caractères représentant `objetNumber` sans notation exponentielle et qui possède exactement `nbChiffres` pour la partie fractionnaire. Le nombre est arrondi si nécessaire et la partie fractionnaire est complétée par des zéros si nécessaire pour obtenir la longueur souhaitée. Si le `objetNumber` est supérieur ou égal à `1e+21`, la méthode utilise simplement {{jsxref("Number.prototype.toString()")}} et renvoie une chaîne en notation exponentielle.
 
-<div class="warning">
-<p><strong>Attention :</strong> En raison du standard <a href="https://fr.wikipedia.org/wiki/IEEE_754">IEEE 754</a> qui est utilisé par JavaScript pour représenter les nombres, tous les nombres décimaux ne sont pas représentés exactement en JavaScript, ce qui peut mener à des résultats inattendus (comme <code>0.1 + 0.2 === 0.3</code> qui renvoie <code>false</code>).</p>
-</div>
+> **Attention :** En raison du standard [IEEE 754](https://fr.wikipedia.org/wiki/IEEE_754) qui est utilisé par JavaScript pour représenter les nombres, tous les nombres décimaux ne sont pas représentés exactement en JavaScript, ce qui peut mener à des résultats inattendus (comme `0.1 + 0.2 === 0.3` qui renvoie `false`).
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<pre class="brush: js">var numObj = 12345.6789;
+```js
+var numObj = 12345.6789;
 
 numObj.toFixed();       // Renvoie '12346' : arrondi, aucune partie fractionnaire
 numObj.toFixed(1);      // Renvoie '12345.7' : arrondi ici aussi
@@ -63,48 +58,23 @@ numObj.toFixed(6);      // Renvoie '12345.678900' : des zéros sont ajoutés
 2.35.toFixed(1);        // Renvoie '2.4' (arrondi supérieur)
 2.55.toFixed(1);        // Renvoie '2.5' (cf. l'avertissement ci-avant)
 (-2.34).toFixed(1);     // Renvoie '-2.3'
-</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.5.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.7.4.5', 'Number.prototype.toFixed')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-number.prototype.tofixed', 'Number.prototype.toFixed')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-number.prototype.tofixed', 'Number.prototype.toFixed')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.Number.toFixed")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Number.prototype.toExponential()")}}</li>
- <li>{{jsxref("Number.prototype.toPrecision()")}}</li>
- <li>{{jsxref("Number.prototype.toString()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                    | État                         | Commentaires                                          |
+| ---------------------------------------------------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- |
+| {{SpecName('ES3')}}                                                                                         | {{Spec2('ES3')}}         | Définition initiale. Implémentée avec JavaScript 1.5. |
+| {{SpecName('ES5.1', '#sec-15.7.4.5', 'Number.prototype.toFixed')}}                         | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-number.prototype.tofixed', 'Number.prototype.toFixed')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-number.prototype.tofixed', 'Number.prototype.toFixed')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Number.toFixed")}}
+
+## Voir aussi
+
+- {{jsxref("Number.prototype.toExponential()")}}
+- {{jsxref("Number.prototype.toPrecision()")}}
+- {{jsxref("Number.prototype.toString()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/number/tolocalestring/index.md b/files/fr/web/javascript/reference/global_objects/number/tolocalestring/index.md
index af7692098a..9ff73fe256 100644
--- a/files/fr/web/javascript/reference/global_objects/number/tolocalestring/index.md
+++ b/files/fr/web/javascript/reference/global_objects/number/tolocalestring/index.md
@@ -12,50 +12,48 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/Number/toLocaleString
 original_slug: Web/JavaScript/Reference/Objets_globaux/Number/toLocaleString
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>toLocaleString()</strong></code> permet de renvoyer une chaîne de caractères représentant un nombre en tenant compte de la locale.</p>
+La méthode **`toLocaleString()`** permet de renvoyer une chaîne de caractères représentant un nombre en tenant compte de la locale.
 
-<div>{{EmbedInteractiveExample("pages/js/number-tolocalestring.html")}}</div>
+{{EmbedInteractiveExample("pages/js/number-tolocalestring.html")}}
 
+Les arguments `locales` et `options` permettent à l'application de spécifier les options de formatage selon la langue utilisée. Ces arguments ont un effet sur le comportement de la fonction. Les implémentations passées, qui ignoraient les arguments `locales` et `options` se basaient uniquement sur l'implémentation pour ce qui concernait la locale et le format.
 
+## Syntaxe
 
-<p>Les arguments <code>locales</code> et <code>options</code> permettent à l'application de spécifier les options de formatage selon la langue utilisée. Ces arguments ont un effet sur le comportement de la fonction. Les implémentations passées, qui ignoraient les arguments <code>locales</code> et <code>options</code> se basaient uniquement sur l'implémentation pour ce qui concernait la locale et le format.</p>
+    objetNumber.toLocaleString([locales [, options]])
 
-<h2 id="Syntaxe">Syntaxe</h2>
+### Paramètres
 
-<pre class="syntaxbox">objetNumber.toLocaleString([locales [, options]])</pre>
+Voir la section [compatibilité des navigateurs](#compat "#Browser_Compatibility") afin de voir quels navigateurs supportent les arguments `locales` et `options`. L'exemple [Vérifier le support des arguments `locales` et `options`](#check) permet de détecter cette fonctionnalité.
 
-<h3 id="Paramètres">Paramètres</h3>
+> **Note :** L'API ECMAScript Internationalization, implémentée avec Firefox 29, a ajouté l'argument `locales` à la méthode [`Number.toLocaleString`](/fr/docs/Web/JavaScript/Reference/Objets_globaux/Number/toLocaleString). Si l'argument vaut `undefined`,cette méthode renvoie les nombres selon la locale du système d'exploitation, les versions antérieures de Firefox renvoyaient un résultat correspondant à la locale anglaise. Ce changement a été rapporté comme une régression, avec un risque de manque de rétrocompatibilité, avant d'être corrigé avec Firefox 55, voir le bug ({{bug(999003)}}).
 
-<p>Voir la section <a href="#compat" title="#Browser_Compatibility">compatibilité des navigateurs</a> afin de voir quels navigateurs supportent les arguments <code>locales</code> et <code>options</code>. L'exemple <a href="#check">Vérifier le support des arguments <code>locales</code> et <code>options</code></a> permet de détecter cette fonctionnalité.</p>
+{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/NumberFormat','Paramètres')}}
 
-<div class="note">
-<p><strong>Note :</strong> L'API ECMAScript Internationalization, implémentée avec Firefox 29, a ajouté l'argument <code>locales</code> à la méthode <a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Number/toLocaleString"><code>Number.toLocaleString</code></a>. Si l'argument vaut <code>undefined</code>,cette méthode renvoie les nombres selon la locale du système d'exploitation, les versions antérieures de Firefox renvoyaient un résultat correspondant à la locale anglaise. Ce changement a été rapporté comme une régression, avec un risque de manque de rétrocompatibilité, avant d'être corrigé avec Firefox 55, voir le bug ({{bug(999003)}}).</p>
-</div>
+### Valeur de retour
 
-<p>{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/NumberFormat','Paramètres')}}</p>
+Une chaîne de caractères qui représente le nombre indiqué en tenant compte de la locale.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+## Exemples
 
-<p>Une chaîne de caractères qui représente le nombre indiqué en tenant compte de la locale.</p>
+### Utiliser `toLocaleString()`
 
-<h2 id="Exemples">Exemples</h2>
+En utilisant la fonction simplement, sans spécifier de locale, la chaîne est formatée dans la locale par défaut et avec des options par défaut.
 
-<h3 id="Utiliser_toLocaleString()">Utiliser <code>toLocaleString()</code></h3>
-
-<p>En utilisant la fonction simplement, sans spécifier de locale, la chaîne est formatée dans la locale par défaut et avec des options par défaut.</p>
-
-<pre class="brush: js">var nombre = 3500;
+```js
+var nombre = 3500;
 
 console.log(nombre.toLocaleString()); // Affichera "3 500" pour la locale française
-</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 arguments <code>locales</code> et <code>options</code> ne sont pas supportés par tous les navigateurs. Afin de vérifier qu'une implémentation les prend en charge, on se base sur le fait que les balises de langues incorrectes renvoient une exception{{jsxref("RangeError")}} :</p>
+Les arguments `locales` et `options` ne sont pas supportés par tous les navigateurs. Afin de vérifier qu'une implémentation les prend en charge, on se base sur le fait que les balises de langues incorrectes renvoient une exception{{jsxref("RangeError")}} :
 
-<pre class="brush: js">function testSupporttoLocaleString() {
+```js
+function testSupporttoLocaleString() {
     var nombre = 0;
     try {
         nombre.toLocaleString("i");
@@ -64,24 +62,26 @@ console.log(nombre.toLocaleString()); // Affichera "3 500" pour la locale franç
     }
     return false;
 }
-</pre>
+```
 
-<p>Avant ES5.1, il n'était pas nécessaire pour les implémentations de provoquer une erreur d'intervalle si <code>toLocaleString</code> était appelé avec des arguments.</p>
+Avant ES5.1, il n'était pas nécessaire pour les implémentations de provoquer une erreur d'intervalle si `toLocaleString` était appelé avec des arguments.
 
-<p>Afin de vérifier le support pour tous les environnements, y compris ceux qui supportent ECMA-262 avant la version 5.1, on peut tester les fonctionnalités définies dans ECMA-402, directement sur <code>Number.prototype.toLocaleString</code> :</p>
+Afin de vérifier le support pour tous les environnements, y compris ceux qui supportent ECMA-262 avant la version 5.1, on peut tester les fonctionnalités définies dans ECMA-402, directement sur `Number.prototype.toLocaleString` :
 
-<pre class="brush: js">function toLocaleStringSupportsOptions() {
-  return !!(typeof Intl == 'object' &amp;&amp; Intl &amp;&amp; typeof Intl.NumberFormat == 'function');
+```js
+function toLocaleStringSupportsOptions() {
+  return !!(typeof Intl == 'object' && Intl && typeof Intl.NumberFormat == 'function');
 }
-</pre>
+```
 
-<p>Cela permet de tester la présence d'un objet global <code>Intl</code>, de vérifier que celui-ci n'est pas <code>null</code> et qu'il a une méthode <code>NumberFormat</code>.</p>
+Cela permet de tester la présence d'un objet global `Intl`, de vérifier que celui-ci n'est pas `null` et qu'il a une méthode `NumberFormat`.
 
-<h3 id="Utiliser_l'argument_locales">Utiliser l'argument <code>locales</code></h3>
+### Utiliser l'argument `locales`
 
-<p>Cet exemple illustre les variations possibles entre les différents formats localisés. Afin que le format de langue utilisé soit celui de votre utilisateur, assurez-vous de fournir la langue utilisée (ainsi que des langues de secours) en utilisant l'argument <code>locales</code> :</p>
+Cet exemple illustre les variations possibles entre les différents formats localisés. Afin que le format de langue utilisé soit celui de votre utilisateur, assurez-vous de fournir la langue utilisée (ainsi que des langues de secours) en utilisant l'argument `locales` :
 
-<pre class="brush: js">var nombre= 123456.789;
+```js
+var nombre= 123456.789;
 
 // Pour la locale allemande, on utilise un point comme séparateur
 // pour les milliers et une virgule comme séparateur décimal
@@ -105,13 +105,14 @@ console.log(nombre.toLocaleString("zh-Hans-CN-u-nu-hanidec"));
 // inclure un langage de secours. Exemple ici avec le balinais et l'indonésien
 console.log(nombre.toLocaleString(["ban", "id"]));
 // → 123.456,789
-</pre>
+```
 
-<h3 id="Utiliser_l'argument_options">Utiliser l'argument <code>options</code></h3>
+### Utiliser l'argument `options`
 
-<p>Les résultats fournis par <code>toLocaleString</code> peuvent être déclinés en utilisant l'argument <code>options</code> :</p>
+Les résultats fournis par `