Markdown fixes part 4 (fr/web/js) (#4373)

* Fix MD038, no spaces in code spans * Fix MD037/39, no spaces in emphasis/link text * Missed markdown fixes in code spans * Bold formatting correction
author: Carolyn Wu <87150472+cw118@users.noreply.github.com> 2022-03-03 02:35:24 -0500
committer: GitHub <noreply@github.com> 2022-03-03 08:35:24 +0100
commit: 581e6fb5827a5450e295c91250dd0563a3c9251a (patch)
tree: 801de6432e274e1a53bb3b1f6151e447915ffda8
parent: da1500b5765037b2ec3db0190f3accac453c6d96 (diff)
download: translated-content-581e6fb5827a5450e295c91250dd0563a3c9251a.tar.gz
translated-content-581e6fb5827a5450e295c91250dd0563a3c9251a.tar.bz2
translated-content-581e6fb5827a5450e295c91250dd0563a3c9251a.zip
81 files changed, 117 insertions, 117 deletions
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 962ace144f..f885ef3bcd 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
@@ -272,7 +272,7 @@ x = x + 5;
 
 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.
 
-L'[opérateur `+` ](</fr/docs/conflicting/Web/JavaScript/Reference/Operators#addition_(.2b)>)permet également de concaténer des chaînes :
+L'[opérateur `+`](/fr/docs/conflicting/Web/JavaScript/Reference/Operators#addition_(.2b)) permet également de concaténer des chaînes :
 
 ```js
 "coucou" + " monde"; // "coucou monde"
diff --git a/files/fr/web/javascript/closures/index.md b/files/fr/web/javascript/closures/index.md
index 5480aeb5f1..5a5bf84a15 100644
--- a/files/fr/web/javascript/closures/index.md
+++ b/files/fr/web/javascript/closures/index.md
@@ -166,7 +166,7 @@ Il y a beaucoup de différences par rapport aux exemples précédents. Au lieu d
 
 L'environnement partagé vient du corps de la fonction anonyme qui est exécutée dès sa définition complète (on parle d'expression de fonction immédiatement invoquée, abrégé en anglais en [IIFE](/fr/docs/Glossary/IIFE)). L'environnement en question contient deux éléments privés&nbsp;: une variable `compteurPrive` et une fonction `changeValeur`. Aucun de ces deux éléments ne peut être utilisé en dehors de la fonction anonyme&nbsp;; seules les trois fonctions renvoyées par la fonction anonyme sont publiques.
 
-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`.
+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`.
 
 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.
 
diff --git a/files/fr/web/javascript/data_structures/index.md b/files/fr/web/javascript/data_structures/index.md
index fc7e9c5b42..a72af89b1b 100644
--- a/files/fr/web/javascript/data_structures/index.md
+++ b/files/fr/web/javascript/data_structures/index.md
@@ -62,7 +62,7 @@ Le type `Number` est géré pour représenter les nombres : [les nombres flottan
 
 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 :
+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
@@ -160,7 +160,7 @@ Ces propriétés associent une clé avec une ou deux fonctions accesseur et muta
 
 ### 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).
+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.
 
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 531199cc8a..ac93c75557 100644
--- a/files/fr/web/javascript/guide/expressions_and_operators/index.md
+++ b/files/fr/web/javascript/guide/expressions_and_operators/index.md
@@ -678,7 +678,7 @@ if (3 in arbres) {
 }
 ```
 
-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 :
+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 :
 
 ```js
 var arbres = new Array("sequoia", "laurier", "cèdre", "chêne", "érable");
diff --git a/files/fr/web/javascript/guide/functions/index.md b/files/fr/web/javascript/guide/functions/index.md
index 837cce05f4..7c4322b0f1 100644
--- a/files/fr/web/javascript/guide/functions/index.md
+++ b/files/fr/web/javascript/guide/functions/index.md
@@ -74,11 +74,11 @@ maFonction(mavoiture);
 y = mavoiture.fabricant;     // y reçoit la valeur "Honda"
 ```
 
-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.
+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.
 
 ### Les expressions de fonction
 
-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 :
+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 :
 
 ```js
 var carré = function (nombre) { return nombre * nombre };
@@ -488,7 +488,7 @@ var créerAnimal = function(nom) {  // La fonction externe définit une variable
 }
 ```
 
-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.
+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.
 
 ## Utiliser l'objet `arguments`
 
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 2205e65b20..b0949d9c01 100644
--- a/files/fr/web/javascript/guide/grammar_and_types/index.md
+++ b/files/fr/web/javascript/guide/grammar_and_types/index.md
@@ -409,7 +409,7 @@ Comprendre le fonctionnement des virgules supplémentaires est important. Cepend
 
 Le type booléen possède deux valeurs littérales : `true` et `false`.
 
-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.
+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.
 
 ### Les littéraux numériques
 
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 19d2248042..8bfb4b8ae1 100644
--- a/files/fr/web/javascript/guide/iterators_and_generators/index.md
+++ b/files/fr/web/javascript/guide/iterators_and_generators/index.md
@@ -175,7 +175,7 @@ Il est possible de forcer un générateur à lever une exception en utilisant la
 
 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`.
 
-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`.
+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`.
 
 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.
 
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 c7b999b8b4..8adb3d18af 100644
--- a/files/fr/web/javascript/guide/loops_and_iteration/index.md
+++ b/files/fr/web/javascript/guide/loops_and_iteration/index.md
@@ -10,7 +10,7 @@ original_slug: Web/JavaScript/Guide/Boucles_et_itération
 ---
 {{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/Contr%C3%B4le_du_flux_Gestion_des_erreurs", "Web/JavaScript/Guide/Fonctions")}}
 
-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.
+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.
 
 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 :
 
@@ -48,7 +48,7 @@ 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.
+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**
@@ -97,7 +97,7 @@ L'instruction {{jsxref("statements/do...while", "do...while")}} permet de répé
       instruction
     while (condition);
 
-`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.
+`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.
 
 ### Exemple
 
@@ -118,7 +118,7 @@ Une instruction {{jsxref("statements/while", "while")}} permet d'exécuter une i
     while (condition)
       instruction
 
-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.
+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.
 
 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`.
 
@@ -195,7 +195,7 @@ La première forme permet d'interrompre la boucle la plus imbriquée (ou le `swi
 
 ### Exemple **1**
 
-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 `:
+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`&nbsp;:
 
 ```js
 for (i = 0; i < a.length; i++) {
@@ -238,7 +238,7 @@ L'instruction {{jsxref("statements/continue","continue")}} permet de reprendre u
 L'instruction `continue` s'utilise donc de la façon suivante :
 
 1.  `continue;`
-2.  `continue `_`label;`_
+2.  `continue` _`label;`_
 
 ### Exemple 1
 
diff --git a/files/fr/web/javascript/guide/regular_expressions/index.md b/files/fr/web/javascript/guide/regular_expressions/index.md
index a5314a2a4c..2010b7ff34 100644
--- a/files/fr/web/javascript/guide/regular_expressions/index.md
+++ b/files/fr/web/javascript/guide/regular_expressions/index.md
@@ -35,7 +35,7 @@ Il est possible de construire une expression rationnelle de deux façons :
 
 ## Écrire une expression rationnelle
 
-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).
+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).
 
 ### Utiliser des motifs simples
 
@@ -651,7 +651,7 @@ Pour qu'une partie de la chaîne de caractère corresponde mais que la correspon
 
 ## Utiliser les expressions rationnelles
 
-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).
+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).
 
 | Méthode                                                  | Description                                                                                                                                                                                        |
 | -------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
@@ -663,7 +663,7 @@ Les expresssions régulières sont utilisées avec les méthodes ` test``  `et`
 | {{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.         |
 
-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).
+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).
 
 Dans l'exemple qui suit, le script utilise la méthode `exec` pour trouver une correspondance dans une chaîne de caractères.
 
diff --git a/files/fr/web/javascript/javascript_technologies_overview/index.md b/files/fr/web/javascript/javascript_technologies_overview/index.md
index 95e2f5bcd5..12d00a9077 100644
--- a/files/fr/web/javascript/javascript_technologies_overview/index.md
+++ b/files/fr/web/javascript/javascript_technologies_overview/index.md
@@ -30,7 +30,7 @@ Entre autres choses, ECMAScript définit :
 - 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`...)
+- 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).
 
 ### Support des navigateurs
diff --git a/files/fr/web/javascript/language_resources/index.md b/files/fr/web/javascript/language_resources/index.md
index f992cd5ffe..0ef1ae3fb7 100644
--- a/files/fr/web/javascript/language_resources/index.md
+++ b/files/fr/web/javascript/language_resources/index.md
@@ -238,7 +238,7 @@ ES.Next est un nom dynamique qui fait toujours référence à la prochaine versi
 
 Pour plus d'informations sur l'histoire d'ECMAScript, voir [la page Wikipédia sur ECMAScript](https://fr.wikipedia.org/wiki/ECMAScript).
 
-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).
+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).
 
 ## Implémentations
 
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 f08481d96a..4ec76398d3 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
@@ -28,7 +28,7 @@ Une syntaxe dépréciée a été utilisée pour indiquer une correspondance de s
 
 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.
 
-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.
+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.
 
 ## Exemples
 
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 f2c751c136..800de07226 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
@@ -22,7 +22,7 @@ original_slug: Web/JavaScript/Reference/Erreurs/is_not_iterable
 
 ## Quel est le problème ?
 
-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_»).
+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_»).
 
 ## Exemples
 
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 b9bf2d9afb..e37713d3bc 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
@@ -27,7 +27,7 @@ Il y a une erreur avec la façon dont une fonction est appelée . Cela peut êt
 
 ## Exemple
 
-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. `
+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);
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 bb8c7d6fa3..3f9e24ec08 100644
--- a/files/fr/web/javascript/reference/functions/arguments/callee/index.md
+++ b/files/fr/web/javascript/reference/functions/arguments/callee/index.md
@@ -23,7 +23,7 @@ La propriété **`arguments.callee`** contient la fonction en cours d'exécution
 
 ### Pourquoi `arguments.callee` a-t-il été retiré du mode strict ES5 ?
 
-(adapté d'une réponse[ Stack Overflow par olliej](http://stackoverflow.com/a/235760/578288 "http://stackoverflow.com/a/235760/578288"))
+(adapté d'une réponse [Stack Overflow par olliej](http://stackoverflow.com/a/235760/578288 "http://stackoverflow.com/a/235760/578288"))
 
 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.
 
diff --git a/files/fr/web/javascript/reference/functions/get/index.md b/files/fr/web/javascript/reference/functions/get/index.md
index 76fa285ff7..71e025afcd 100644
--- a/files/fr/web/javascript/reference/functions/get/index.md
+++ b/files/fr/web/javascript/reference/functions/get/index.md
@@ -44,7 +44,7 @@ Un _accesseur_ peut être supprimé grâce à l'opérateur {{jsxref("Opérateurs
 
 ### Définir un accesseur avec l'opérateur `get`
 
-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 `:
+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`&nbsp;:
 
 ```js
 var o = {
diff --git a/files/fr/web/javascript/reference/functions/index.md b/files/fr/web/javascript/reference/functions/index.md
index 90e9f5aa72..5e00f3541e 100644
--- a/files/fr/web/javascript/reference/functions/index.md
+++ b/files/fr/web/javascript/reference/functions/index.md
@@ -163,7 +163,7 @@ Une expression de fonction fléchée possède une syntaxe plus courte et est li�
 
 - `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`
+- `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.
 
 ### Le constructeur `Function`
@@ -398,7 +398,7 @@ function externe() {
 resultat = externe()(20); // renvoie 20 et non pas 10
 ```
 
-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`).
+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`).
 
 ## Définition des méthodes
 
@@ -607,7 +607,7 @@ Bien que cette fonction ressemble à une déclaration de fonction, il s'agit en
 
 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.
 
-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/).
+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/).
 
 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.)
 
@@ -756,7 +756,7 @@ resultat = padZeros(5,4);  // renvoie "0005"
 
 ### Déterminer si une fonction existe
 
-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.
+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.
 
 ```js
  if ('function' === typeof window.noFunc) {
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 e28200ab55..7bdac1b5b6 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
@@ -28,9 +28,9 @@ La méthode **`copyWithin()`** effectue une copie superficielle (_shallow copy_)
 
 - `cible`
 
-  - : Indice à partir duquel la séquence sera copiée. Si la valeur est négative, `cible `sera compté à partir de la fin du tableau.
+  - : Indice à partir duquel la séquence sera copiée. Si la valeur est négative, `cible` sera compté à partir de la fin du tableau.
 
-    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`.
+    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`.
 
 - `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).
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 d6f1b51909..33a4181ab3 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
@@ -133,7 +133,7 @@ console.log(filtreTexte(fruits, 'm')); // ['pomme', 'mangue'];
 
 ### Implémentation avec la syntaxe ECMAScript 2015 (ES6)
 
-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.
+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.
 
 ```js
 const fruits = ['pomme', 'banane', 'raisin', 'mangue'];
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 cf80abb37e..4c250a85f6 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
@@ -41,7 +41,7 @@ Une nouvelle instance de {{jsxref("Array")}}.
 - 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")}}).
 
-`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é).
+`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é).
 
 La propriété `length` de la méthode `from()` est 1.
 
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 dbb7001bf8..7c9ea377a9 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
@@ -47,7 +47,7 @@ La valeur obtenue grâce à la fonction de réduction.
 
 ## Description
 
-`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.
+`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.
 
 L'usage de `reduceRight` avec définition d'un `callback` devrait ressembler à ceci :
 
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 e24fc4cf20..7f30c4151c 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
@@ -34,7 +34,7 @@ La méthode **`some()`** teste si au moins un élément du tableau passe le test
       - : 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}}
+    - `array` {{optional_inline}}
       - : Le tableau sur lequel on a appelé la méthode `some`.
 
 - `objetThis` {{optional_inline}}
@@ -74,7 +74,7 @@ passed = [12, 5, 8, 1, 4].some(estAssezGrand);
 
 ### 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.
+[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
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 df2c70beba..b0e4f84f73 100644
--- a/files/fr/web/javascript/reference/global_objects/arraybuffer/index.md
+++ b/files/fr/web/javascript/reference/global_objects/arraybuffer/index.md
@@ -96,7 +96,7 @@ var vue    = new Int32Array(tampon);
 
 ## Notes de compatibilité
 
-À 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")}}.
+À 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")}}.
 
 ```js example-bad
 var dv = ArrayBuffer(10);
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 e776d858bb..9eeed19b9c 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
@@ -25,7 +25,7 @@ La méthode **`slice()`** renvoie un nouvel `ArrayBuffer` dont le contenu est un
 - `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.
+  - : 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.
 
 ### Valeur de retour
 
@@ -33,7 +33,7 @@ Un nouvel objet `ArrayBuffer`.
 
 ## Description
 
-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.
+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.
 
 ## Exemples
 
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 c9d61aaa85..7c73460000 100644
--- a/files/fr/web/javascript/reference/global_objects/atomics/index.md
+++ b/files/fr/web/javascript/reference/global_objects/atomics/index.md
@@ -80,6 +80,6 @@ Avant Firefox 48 {{geckoRelease(48)}}, les noms les plus récents et la sémanti
 - {{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.
+- [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/dataview/bytelength/index.md b/files/fr/web/javascript/reference/global_objects/dataview/bytelength/index.md
index bd25a6f629..728d7c3820 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
@@ -23,7 +23,7 @@ L'accesseur **`byteLength`** est une propriété représentant la longueur, expr
 
 ## Description
 
-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.
+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.
 
 ## Exemples
 
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 d828888f25..23cfa94e7f 100644
--- a/files/fr/web/javascript/reference/global_objects/dataview/index.md
+++ b/files/fr/web/javascript/reference/global_objects/dataview/index.md
@@ -24,9 +24,9 @@ La vue **`DataView`** fournit une interface de bas niveau pour lire et écrire d
 
 - `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}}
+- `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}}
+- `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.
 
 ### Valeur de retour
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 01ebb5094c..f45a1bf341 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
@@ -31,7 +31,7 @@ Le nombre de millisecondes écoulées entre le premier janvier 1970 00:00:00 UTC
 
 ## Description
 
-Si la `valeurJour` est en dehors des limites du mois courant, `setDate()` mettra à jour l'objet` `{{jsxref("Date")}} en conséquence.
+Si la `valeurJour` est en dehors des limites du mois courant, `setDate()` mettra à jour l'objet {{jsxref("Date")}} en conséquence.
 
 Par exemple, si 0 est fourni pour `valeurJour`, la date sera défini sur le dernier jour du mois précédent.
 
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 fdb9bdb700..39639333d3 100644
--- a/files/fr/web/javascript/reference/global_objects/encodeuricomponent/index.md
+++ b/files/fr/web/javascript/reference/global_objects/encodeuricomponent/index.md
@@ -63,7 +63,7 @@ console.log(encodeURIComponent('\uD800'));
 console.log(encodeURIComponent('\uDFFF'));
 ```
 
-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`.
+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`.
 
 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 "+".
 
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 56be61bf44..e6cec185cf 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
@@ -48,7 +48,7 @@ Une fonction liée possède les propriétés internes suivantes :
 - **`[[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.
 
-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.
+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.
 
 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.
 
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 359031b990..91f954d94e 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
@@ -21,7 +21,7 @@ La propriété **`length`** définit le nombre de paramètres attendus par la fo
 
 ### Propriété du constructeur `Function`
 
-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`.
+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`.
 
 ### Propriété du prototype de `Function`
 
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 e56a999c1c..cd6f0e8443 100644
--- a/files/fr/web/javascript/reference/global_objects/generator/index.md
+++ b/files/fr/web/javascript/reference/global_objects/generator/index.md
@@ -57,7 +57,7 @@ Firefox (SpiderMonkey) implémente également une version antérieure pour les g
 
 ### Méthodes pour les générateurs historiques
 
-- `Generator.prototype.next() `{{non-standard_inline}}
+- `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.
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 ecd15ddbf3..ea66a5b893 100644
--- a/files/fr/web/javascript/reference/global_objects/int16array/index.md
+++ b/files/fr/web/javascript/reference/global_objects/int16array/index.md
@@ -49,7 +49,7 @@ Tous les objets `Int16Array` héritent de {{jsxref("TypedArray.prototype", "%Typ
 ### 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`.
+  - : 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}}
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 04ab728a41..81192d739d 100644
--- a/files/fr/web/javascript/reference/global_objects/int32array/index.md
+++ b/files/fr/web/javascript/reference/global_objects/int32array/index.md
@@ -49,7 +49,7 @@ Tous les objets `Int32Array` héritent de {{jsxref("TypedArray.prototype", "%Typ
 ### 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`.
+  - : 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}}
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 8c1bc5333b..3230687f4d 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
@@ -143,17 +143,17 @@ L'objet **`Intl.DateTimeFormat`** est un constructeur d'objets permettant de for
 - {{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`
+## Instances de `DateTimeFormat`
 
 ### Propriétés
 
-Les instances de` DateTimeFormat()` héritent des propriétés suivantes depuis leur prototype :
+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 :
+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')}}
 
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 b5e2d8d422..b40c758a2d 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
@@ -34,7 +34,7 @@ Cette propriété peut avoir une des 3 valeurs suivantes :
 
 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.
 
-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`) :
+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`) :
 
 ```js
 let caseFirstStr = new Intl.Locale("fr-Latn-FR-u-kf-upper");
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 81d5b8cb36..8cb0561cdd 100644
--- a/files/fr/web/javascript/reference/global_objects/map/index.md
+++ b/files/fr/web/javascript/reference/global_objects/map/index.md
@@ -41,9 +41,9 @@ Dans les versions précédentes des brouillons ECMAScript 2015 (ES6) `-0` et `+0
 
 ### Comparaison entre objets et maps
 
-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 :
+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 :
 
-- 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.
+- 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 ».
@@ -103,7 +103,7 @@ myMap.get(function() {}); // indéfini car fonctionClé !== function () {}
 
 ### Utiliser `NaN` comme clé
 
-{{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 `:
+{{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`&nbsp;:
 
 ```js
 const myMap = new Map();
@@ -117,7 +117,7 @@ myMap.get(otherNaN); // "not a number"
 
 ### Parcourir des objets `Maps` avec `for..of`
 
-Il est possible de parcourir les objets `Map `grâce à des boucles `for..of` :
+Il est possible de parcourir les objets `Map` grâce à des boucles `for..of` :
 
 ```js
 const myMap = new Map();
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 2d8223041f..c2e5287fc2 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
@@ -13,7 +13,7 @@ original_slug: Web/JavaScript/Reference/Objets_globaux/Math/expm1
 ---
 {{JSRef}}
 
-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.
+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.
 
 {{EmbedInteractiveExample("pages/js/math-expm1.html")}}
 
@@ -32,7 +32,7 @@ Un nombre qui représente `e^x- 1` où `x` est la valeur passée en argument et
 
 ## Description
 
-`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).
+`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).
 
 ## Exemple
 
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 77cf804d99..a075f073af 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
@@ -35,7 +35,7 @@ Un moteur JavaScript utilise des nombres flottant à précision simple sur 64 bi
 
 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`.
 
-`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).
+`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).
 
 ## Exemples
 
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 507c94f070..1ac54c7e56 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
@@ -33,7 +33,7 @@ Le résultat de la multiplication sur 32 bits des valeurs passées en argument (
 
 ## Description
 
-`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.
+`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.
 
 ## Exemples
 
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 8d9d91c64b..20cb391a97 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
@@ -36,7 +36,7 @@ Le logarithme en base 2 du nombre passé en argument. Si ce nombre est négatif,
 
 Si `x` est strictement inférieur à 0, la valeur renvoyée sera {{jsxref("NaN")}}.
 
-`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")}}.
+`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")}}.
 
 ## Exemples
 
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 44a438171e..06396cdeb9 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
@@ -32,7 +32,7 @@ Un nombre qui représente le signe de l'argument. Si l'argument est un nombre po
 
 ## Description
 
-`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).
+`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).
 
 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")}}.
 
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 9a74084918..67abde0021 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
@@ -34,7 +34,7 @@ Le sinus hyperbolique de la valeur passée en argument.
 
 ## Description
 
-`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).
+`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).
 
 ## Exemples
 
@@ -45,7 +45,7 @@ Math.sinh(1) // 1.1752011936438014
 
 ## Prothèse d'émulation (_polyfill_)
 
-Si cette fonction n'est pas disponible, elle peut être émulée en utilisant la fonction {{jsxref("Math.exp()")}}` :`
+Si cette fonction n'est pas disponible, elle peut être émulée en utilisant la fonction {{jsxref("Math.exp()")}}&nbsp;:
 
 ```js
 Math.sinh = Math.sinh || function(x){
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 88505bc59d..b6dccc2b4f 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
@@ -57,7 +57,7 @@ Math.tanh = Math.tanh || function(x){
 }
 ```
 
-et si on souhaite n'utiliser qu'un seul appel à {{jsxref("Objets_globaux/Math/exp", "Math.exp()")}}` :`
+et si on souhaite n'utiliser qu'un seul appel à {{jsxref("Objets_globaux/Math/exp", "Math.exp()")}}&nbsp;:
 
 ```js
 Math.tanhx = Math.tanhx || function(x) {
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 bb0af546ce..f348bbf6dc 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
@@ -32,7 +32,7 @@ Un booléen indiquant si la valeur passée en argument est un nombre fini.
 
 ## Description
 
-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`.
+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`.
 
 ## Exemples
 
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 a38f9c3695..893e816edf 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
@@ -12,7 +12,7 @@ original_slug: Web/JavaScript/Reference/Objets_globaux/Number/MAX_SAFE_INTEGER
 ---
 {{JSRef}}
 
-La constante **`Number.MAX_SAFE_INTEGER `**représente la valeur (sûre) maximale d’un nombre entier en JavaScript (2^53 -1).
+La constante **`Number.MAX_SAFE_INTEGER`** représente la valeur (sûre) maximale d’un nombre entier en JavaScript (2^53 -1).
 
 > **Note :** Pour représenter des entiers supérieurs à cette valeur, on pourra utiliser le type {{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 a56ed64592..b910228801 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
@@ -19,7 +19,7 @@ La propriété **`Number.MAX_VALUE`** représente la valeur maximale qui peut ê
 
 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).
 
-`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")}}).
+`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")}}).
 
 ## Exemples
 
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 eb923a599c..e8c2e99bfe 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
@@ -38,7 +38,7 @@ Une chaîne représentant l'objet {{jsxref("Number")}} appelant en notation expo
 
 ## Description
 
-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.
+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.
 
 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.
 
diff --git a/files/fr/web/javascript/reference/global_objects/object/defineproperties/index.md b/files/fr/web/javascript/reference/global_objects/object/defineproperties/index.md
index bc2ed689b9..9fc0554d96 100644
--- a/files/fr/web/javascript/reference/global_objects/object/defineproperties/index.md
+++ b/files/fr/web/javascript/reference/global_objects/object/defineproperties/index.md
@@ -62,7 +62,7 @@ L'objet passé à la fonction, éventuellement modifié.
 
 ## Description
 
-`Object.defineProperties` permet principalement de définir toutes les propriétés  de l'objet `obj `correspondant aux propriétés énumérable de `props`.
+`Object.defineProperties` permet principalement de définir toutes les propriétés  de l'objet `obj` correspondant aux propriétés énumérable de `props`.
 
 ## Exemples
 
diff --git a/files/fr/web/javascript/reference/global_objects/object/defineproperty/index.md b/files/fr/web/javascript/reference/global_objects/object/defineproperty/index.md
index 24ab2e051f..9463de1f68 100644
--- a/files/fr/web/javascript/reference/global_objects/object/defineproperty/index.md
+++ b/files/fr/web/javascript/reference/global_objects/object/defineproperty/index.md
@@ -384,7 +384,7 @@ arc.getArchive(); // [{val: 11}, {val: 13}]
 
 ### Redéfinir la propriété `length` d'un tableau (`Array`)
 
-Il est possible de redéfinir la propriété {{jsxref("Array.length", "length")}} utilisée pour les tableaux, avec les restrictions vues. (La propriété `length` est initialement non-configurable, non-enumérable et accessible en écriture (`writable` vaut `true`)). Ainsi, sur un tableau, si rien n'a été fait, on peut modifier la valeur de la propriété` length` ou la rendre non accessible en écriture. Il n'est pas permis de changer son caractère énumérable ou configurable. Cependant, tous les navigateurs n'autorisent pas cette redéfinition.
+Il est possible de redéfinir la propriété {{jsxref("Array.length", "length")}} utilisée pour les tableaux, avec les restrictions vues. (La propriété `length` est initialement non-configurable, non-enumérable et accessible en écriture (`writable` vaut `true`)). Ainsi, sur un tableau, si rien n'a été fait, on peut modifier la valeur de la propriété `length` ou la rendre non accessible en écriture. Il n'est pas permis de changer son caractère énumérable ou configurable. Cependant, tous les navigateurs n'autorisent pas cette redéfinition.
 
 Les versions de Firefox 4 à 22 renverront une exception {{jsxref("TypeError")}} pour chaque tentative (licite ou non) de modification de la propriété `length` d'un tableau.
 
diff --git a/files/fr/web/javascript/reference/global_objects/promise/index.md b/files/fr/web/javascript/reference/global_objects/promise/index.md
index 64a34a483c..81c5e6f55d 100644
--- a/files/fr/web/javascript/reference/global_objects/promise/index.md
+++ b/files/fr/web/javascript/reference/global_objects/promise/index.md
@@ -345,9 +345,9 @@ Un autre exemple simple utilisant `Promise` et [`XMLHttpRequest`](/fr/docs/Web/A
 
 - [Manipuler les promesses](/fr/docs/Web/JavaScript/Guide/Using_promises)
 - [Promises/A+ specification](https://promisesaplus.com/)
-- [Venkatraman.R - JS Promise (Part 1, Basics) ](https://medium.com/@ramsunvtech/promises-of-promise-part-1-53f769245a53)(en anglais)
-- [Venkatraman.R - JS Promise (Part 2 - Using Q.js, When.js and RSVP.js) ](https://medium.com/@ramsunvtech/js-promise-part-2-q-js-when-js-and-rsvp-js-af596232525c#.dzlqh6ski)(en anglais)
-- [Venkatraman.R - Tools for Promises Unit Testing ](https://tech.io/playgrounds/11107/tools-for-promises-unittesting/introduction)(en anglais)
+- [Venkatraman.R - JS Promise (Part 1, Basics)](https://medium.com/@ramsunvtech/promises-of-promise-part-1-53f769245a53) (en anglais)
+- [Venkatraman.R - JS Promise (Part 2 - Using Q.js, When.js and RSVP.js)](https://medium.com/@ramsunvtech/js-promise-part-2-q-js-when-js-and-rsvp-js-af596232525c#.dzlqh6ski) (en anglais)
+- [Venkatraman.R - Tools for Promises Unit Testing](https://tech.io/playgrounds/11107/tools-for-promises-unittesting/introduction) (en anglais)
 - [Jake Archibald : _JavaScript Promises : There and Back Again_](https://www.html5rocks.com/en/tutorials/es6/promises/) (tutoriel en anglais)
 - [Domenic Denicola : _Callbacks, Promises, and Coroutines – Asynchronous Programming Patterns in JavaScript_](https://de.slideshare.net/domenicdenicola/callbacks-promises-and-coroutines-oh-my-the-evolution-of-asynchronicity-in-javascript) (présentation en anglais sur l'asynchronisme en JavaScript)
 - [Matt Greer : _JavaScript Promises ... In Wicked Detail_](https://www.mattgreer.org/articles/promises-in-wicked-detail/) (en anglais)
diff --git a/files/fr/web/javascript/reference/global_objects/set/entries/index.md b/files/fr/web/javascript/reference/global_objects/set/entries/index.md
index cbd34b24a2..1a50fc616d 100644
--- a/files/fr/web/javascript/reference/global_objects/set/entries/index.md
+++ b/files/fr/web/javascript/reference/global_objects/set/entries/index.md
@@ -14,7 +14,7 @@ original_slug: Web/JavaScript/Reference/Objets_globaux/Set/entries
 ---
 {{JSRef}}
 
-La méthode **`entries()`** renvoie un nouvel objet [`Iterator`](/fr/docs/Web/JavaScript/Guide/iterateurs_et_generateurs#Itérateurs) qui contient un tableau composé de **`[valeur, valeur]`** pour chaque élément de l'objet `Set`, dans leur ordre d'insertion. En raison de leur structure, les objets `Set` n'ont pas de clé (`key`), à la différence des objets `Map`. Pour garder une structure et une API sembables à celle d'un objet `Map`, chaque entrée (_entry_) aura la même valeur pour la _clé_ (_key_) et pour la _valeur_ (_value_), c'est pourquoi un tableau de` [valeur, valeur]` est renvoyé.
+La méthode **`entries()`** renvoie un nouvel objet [`Iterator`](/fr/docs/Web/JavaScript/Guide/iterateurs_et_generateurs#Itérateurs) qui contient un tableau composé de **`[valeur, valeur]`** pour chaque élément de l'objet `Set`, dans leur ordre d'insertion. En raison de leur structure, les objets `Set` n'ont pas de clé (`key`), à la différence des objets `Map`. Pour garder une structure et une API sembables à celle d'un objet `Map`, chaque entrée (_entry_) aura la même valeur pour la _clé_ (_key_) et pour la _valeur_ (_value_), c'est pourquoi un tableau de `[valeur, valeur]` est renvoyé.
 
 {{EmbedInteractiveExample("pages/js/set-prototype-entries.html")}}
 
diff --git a/files/fr/web/javascript/reference/global_objects/set/index.md b/files/fr/web/javascript/reference/global_objects/set/index.md
index 2121c5c404..accdda32a3 100644
--- a/files/fr/web/javascript/reference/global_objects/set/index.md
+++ b/files/fr/web/javascript/reference/global_objects/set/index.md
@@ -22,7 +22,7 @@ L'objet **`Set`** (Ensemble en français) permet de stocker des valeurs _uniques
 ### Paramètres
 
 - `itérable`
-  - : Paramètre optionnel. Si un objet [itérable ](/fr/docs/Web/JavaScript/Reference/Instructions/for...of)est donné comme argument, l'ensemble de ses éléments sera ajouté au nouvel objet Set. Si {{jsxref("null")}} est fourni comme argument ou qu'aucun argument n'est fourni, il sera traité comme {{jsxref("undefined")}}.
+  - : Paramètre optionnel. Si un objet [itérable](/fr/docs/Web/JavaScript/Reference/Instructions/for...of) est donné comme argument, l'ensemble de ses éléments sera ajouté au nouvel objet Set. Si {{jsxref("null")}} est fourni comme argument ou qu'aucun argument n'est fourni, il sera traité comme {{jsxref("undefined")}}.
 
 ### Valeur de retour
 
diff --git a/files/fr/web/javascript/reference/global_objects/sharedarraybuffer/index.md b/files/fr/web/javascript/reference/global_objects/sharedarraybuffer/index.md
index dd3777c120..76dc3ea66f 100644
--- a/files/fr/web/javascript/reference/global_objects/sharedarraybuffer/index.md
+++ b/files/fr/web/javascript/reference/global_objects/sharedarraybuffer/index.md
@@ -105,6 +105,6 @@ Toutes les instances de `SharedArrayBuffer` héritent de {{jsxref("SharedArrayBu
 - {{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 synchroniser et distribuer des tâches
+- [parlib-simple](https://github.com/lars-t-hansen/parlib-simple) – un bibliothèque simple qui fournit des abstractions pour synchroniser 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/string/index.md b/files/fr/web/javascript/reference/global_objects/string/index.md
index e1b7dd21f4..64d251773f 100644
--- a/files/fr/web/javascript/reference/global_objects/string/index.md
+++ b/files/fr/web/javascript/reference/global_objects/string/index.md
@@ -55,7 +55,7 @@ En utilisant la seconde notation, il est impossible de supprimer ou d'affecter u
 
 ### Comparer des chaînes de caractères
 
-Les développeurs C utilisent la fonction `strcmp()` pour comparer des chaînes de caractères. En JavaScript, il est possible d'utiliser [les opérateurs inférieur et supérieur ](/fr/docs/Web/JavaScript/Reference/Operators):
+Les développeurs C utilisent la fonction `strcmp()` pour comparer des chaînes de caractères. En JavaScript, il est possible d'utiliser [les opérateurs inférieur et supérieur](/fr/docs/Web/JavaScript/Reference/Operators)&nbsp;:
 
 ```js
 let a = "a";
diff --git a/files/fr/web/javascript/reference/global_objects/string/indexof/index.md b/files/fr/web/javascript/reference/global_objects/string/indexof/index.md
index f93922e7d7..5f7234c4ee 100644
--- a/files/fr/web/javascript/reference/global_objects/string/indexof/index.md
+++ b/files/fr/web/javascript/reference/global_objects/string/indexof/index.md
@@ -26,7 +26,7 @@ La méthode **`indexOf()`** renvoie l'indice de la première occurence de la val
 ### Paramètres
 
 - `valeurRecherchée`
-  - : Une chaîne représentant la valeur qu'on cherche dans la chaîne courante. Si aucune valeur n'est fournie explicitement,[ `valeurRecherchée` sera convertie en `"undefined"` et c'est cette chaîne qui sera recherchée](https://tc39.github.io/ecma262/#sec-tostring).
+  - : Une chaîne représentant la valeur qu'on cherche dans la chaîne courante. Si aucune valeur n'est fournie explicitement, [`valeurRecherchée` sera convertie en `"undefined"` et c'est cette chaîne qui sera recherchée](https://tc39.github.io/ecma262/#sec-tostring).
 - `indexDébut`
   - : Paramètre optionnel. L'indice à partir duquel commencer la recherche, effectuée du début vers la fin de la liste. Cela peut être n'importe quel entier. La valeur par défaut est 0. Si `indexDébut < 0` la chaîne sera parcourue en entier (ce qui équivaut à utiliser 0). Si `indexDébut >= str.length`, la méthode renverra -1 sauf si `valeurRecherchée` est la chaîne vide, auquel cas, la méthode renverra `str.length`.
 
diff --git a/files/fr/web/javascript/reference/global_objects/string/lastindexof/index.md b/files/fr/web/javascript/reference/global_objects/string/lastindexof/index.md
index cbaef2655e..8aa2008326 100644
--- a/files/fr/web/javascript/reference/global_objects/string/lastindexof/index.md
+++ b/files/fr/web/javascript/reference/global_objects/string/lastindexof/index.md
@@ -24,8 +24,8 @@ La méthode **`lastIndexOf()`** renvoie l'indice, dans la chaîne courante, de l
 
 - `valeurRecherchée`
   - : Une chaîne qu'on recherche dans la chaîne courante. Si ce paramètre n'est pas défini et que `indiceDébut` est utilisé, c'est ce dernier qui sera renvoyé par la fonction.
-- `indiceDébut `{{optional_inline}}
-  - : Paramètre optionnel. L'emplacement, dans la chaîne courante, à partir duquel effectuer la recherche (en partant de la fin de la chaîne et en remontant vers le début). Cela peut être n'importe quel entier. La valeur par défaut est `+Infinity`. Si` indiceDébut > str.length`, toute la chaîne sera parcourue. Si `indiceDébut < 0`,  on aura le même comportement que si `indiceDébut` valait 0.
+- `indiceDébut` {{optional_inline}}
+  - : Paramètre optionnel. L'emplacement, dans la chaîne courante, à partir duquel effectuer la recherche (en partant de la fin de la chaîne et en remontant vers le début). Cela peut être n'importe quel entier. La valeur par défaut est `+Infinity`. Si `indiceDébut > str.length`, toute la chaîne sera parcourue. Si `indiceDébut < 0`,  on aura le même comportement que si `indiceDébut` valait 0.
 
 ### Valeur de retour
 
diff --git a/files/fr/web/javascript/reference/global_objects/string/localecompare/index.md b/files/fr/web/javascript/reference/global_objects/string/localecompare/index.md
index 05df8c7347..0ea80e71db 100644
--- a/files/fr/web/javascript/reference/global_objects/string/localecompare/index.md
+++ b/files/fr/web/javascript/reference/global_objects/string/localecompare/index.md
@@ -131,7 +131,7 @@ Pour comparer un grand nombre de chaînes de caractères, par exemple pour trier
 | {{SpecName('ES5.1', '#sec-15.5.4.9', 'String.prototype.localeCompare')}}                                         | {{Spec2('ES5.1')}}         |                                                      |
 | {{SpecName('ES6', '#sec-string.prototype.localecompare', 'String.prototype.localeCompare')}}             | {{Spec2('ES6')}}             |                                                      |
 | {{SpecName('ESDraft', '#sec-string.prototype.localecompare', 'String.prototype.localeCompare')}}         | {{Spec2('ESDraft')}}     |                                                      |
-| {{SpecName('ES Int 1.0', '#sec-13.1.1', 'String.prototype.localeCompare')}}                                     | {{Spec2('ES Int 1.0')}} | Définition des paramètres` locale` et `option`       |
+| {{SpecName('ES Int 1.0', '#sec-13.1.1', 'String.prototype.localeCompare')}}                                     | {{Spec2('ES Int 1.0')}} | Définition des paramètres `locale` et `option`       |
 | {{SpecName('ES Int 2.0', '#sec-13.1.1', 'String.prototype.localeCompare')}}                                     | {{Spec2('ES Int 2.0')}} |                                                      |
 | {{SpecName('ES Int Draft', '#sec-String.prototype.localeCompare', 'String.prototype.localeCompare')}} | {{Spec2('ES Int Draft')}} |                                                      |
 
diff --git a/files/fr/web/javascript/reference/global_objects/symbol/index.md b/files/fr/web/javascript/reference/global_objects/symbol/index.md
index a4da4d0175..3bc071ea70 100644
--- a/files/fr/web/javascript/reference/global_objects/symbol/index.md
+++ b/files/fr/web/javascript/reference/global_objects/symbol/index.md
@@ -71,7 +71,7 @@ Lorsqu'on utilise des mécanismes de conversion de types avec les symboles, on a
 
 - Lorsqu'on tente de convertir un symbole en un nombre, cela provoquera une exception {{jsxref("TypeError")}} (par exemple avec `+sym` ou `sym | 0`).
 - L'égalité faible permet d'obtenir `true` avec ` Object(sym) == sym``. `
-- `Symbol("toto") + "truc" `lève une exception {{jsxref("TypeError")}} (le symbole ne peut pas être converti en une chaîne de caractères), cela permet par exemple d'éviter de créer (sans s'en rendre compte) des noms de propriétés basés sur des symboles.
+- `Symbol("toto") + "truc"` lève une exception {{jsxref("TypeError")}} (le symbole ne peut pas être converti en une chaîne de caractères), cela permet par exemple d'éviter de créer (sans s'en rendre compte) des noms de propriétés basés sur des symboles.
 - La méthode utilisant la conversion avec {{jsxref("String","String()")}} fonctionnera comme un appel à {{jsxref("Symbol.prototype.toString()")}}. En revanche, `new String(sym)` renverra une erreur.
 
 ## Propriétés
diff --git a/files/fr/web/javascript/reference/global_objects/typedarray/index.md b/files/fr/web/javascript/reference/global_objects/typedarray/index.md
index c932ac7cfb..a3beb0bec7 100644
--- a/files/fr/web/javascript/reference/global_objects/typedarray/index.md
+++ b/files/fr/web/javascript/reference/global_objects/typedarray/index.md
@@ -43,8 +43,8 @@ Un objet **_TypedArray_** décrit une vue organisée à la façon d'un tableau p
   - : Lorsque le constructeur est appelé avec un argument `tableauTypé`, qui peut être un tableau typé de n'importe quel type (par exemple `Int32Array`), le `tableauTypé` est copié dans un nouveau tableau typé. Chaque valeur du `tableauTypé` est convertie dans le type correspondant du nouveau tableau. Enfin, la longueur du tableau typé est fixée avec la longueur de `tableauTypé`.
 - `objet`
   - : Lorsque le constructeur est invoqué avec un argument `objet`, un nouveau tableau typé est créé avec la méthode `TypedArray.from()`.
-- `tampon`,` décalageOctet`, `longueur`
-  - : Lorsque le constructeur est appelé avec un `tampon` (_buffer_) ainsi qu'avec les paramètres optionnels `décalageOctet` et `longueur`, un nouveau tableau typé est créé comme une vue pour l'objet {{jsxref("ArrayBuffer")}}. Les paramètres `décalageOctet` et `longueur` permettent de définir l'intervalle de mémoire du buffer qui est présenté dans la vue qu'est le tableau typé. Si les deux derniers paramètres sont absents, l'ensemble du `tampon` sera considéré. Si `longueur `est absent, on considèrera l'ensemble de `tampon` à partir de l'octet _décalageOctet_.
+- `tampon`, `décalageOctet`, `longueur`
+  - : Lorsque le constructeur est appelé avec un `tampon` (_buffer_) ainsi qu'avec les paramètres optionnels `décalageOctet` et `longueur`, un nouveau tableau typé est créé comme une vue pour l'objet {{jsxref("ArrayBuffer")}}. Les paramètres `décalageOctet` et `longueur` permettent de définir l'intervalle de mémoire du buffer qui est présenté dans la vue qu'est le tableau typé. Si les deux derniers paramètres sont absents, l'ensemble du `tampon` sera considéré. Si `longueur` est absent, on considèrera l'ensemble de `tampon` à partir de l'octet _décalageOctet_.
 
 ## Description
 
diff --git a/files/fr/web/javascript/reference/global_objects/typedarray/subarray/index.md b/files/fr/web/javascript/reference/global_objects/typedarray/subarray/index.md
index bb82c9a1a2..4a12d09d6d 100644
--- a/files/fr/web/javascript/reference/global_objects/typedarray/subarray/index.md
+++ b/files/fr/web/javascript/reference/global_objects/typedarray/subarray/index.md
@@ -33,7 +33,7 @@ Un nouvel objet {{jsxref("TypedArray")}}.
 
 ## Description
 
-L'intervalle défini par `début` et `fin` est redimensionné si besoin pour être un intervalle valide en regard du tableau courant. Si la longueur du nouveau tableau est négative, elle est ramenée à zéro. Si `début `ou `fin `a une valeur négative, on prendra en compte la position à partir de la fin du tableau et non à partir du début de celui-ci.
+L'intervalle défini par `début` et `fin` est redimensionné si besoin pour être un intervalle valide en regard du tableau courant. Si la longueur du nouveau tableau est négative, elle est ramenée à zéro. Si `début` ou `fin` a une valeur négative, on prendra en compte la position à partir de la fin du tableau et non à partir du début de celui-ci.
 
 On notera que cette méthode permet de créer un nouvelle vue sur le tampon (_buffer_) existant, tous les changements apportés via le nouvel objet impacteront le tableau typé initial et vice versa.
 
diff --git a/files/fr/web/javascript/reference/global_objects/weakset/add/index.md b/files/fr/web/javascript/reference/global_objects/weakset/add/index.md
index d4a6d7e8da..e50ed53215 100644
--- a/files/fr/web/javascript/reference/global_objects/weakset/add/index.md
+++ b/files/fr/web/javascript/reference/global_objects/weakset/add/index.md
@@ -24,7 +24,7 @@ La méthode **`add()`** permet d'ajouter un nouvel objet à un objet `WeakSet`.
 ### Paramètres
 
 - `valeur`
-  - : Ce paramètre est obligatoire. Il correspond à l'objet qu'on souhaite ajouter à l'ensemble` WeakSet`.
+  - : Ce paramètre est obligatoire. Il correspond à l'objet qu'on souhaite ajouter à l'ensemble `WeakSet`.
 
 ### Valeur de retour
 
diff --git a/files/fr/web/javascript/reference/global_objects/weakset/has/index.md b/files/fr/web/javascript/reference/global_objects/weakset/has/index.md
index 92a8ffa9af..c93b182bb2 100644
--- a/files/fr/web/javascript/reference/global_objects/weakset/has/index.md
+++ b/files/fr/web/javascript/reference/global_objects/weakset/has/index.md
@@ -13,7 +13,7 @@ original_slug: Web/JavaScript/Reference/Objets_globaux/WeakSet/has
 ---
 {{JSRef}}
 
-La méthode **`has()`** renvoie un booléen indiquant si un objet donné est contenu dans l'ensemble` WeakSet`.
+La méthode **`has()`** renvoie un booléen indiquant si un objet donné est contenu dans l'ensemble `WeakSet`.
 
 {{EmbedInteractiveExample("pages/js/weakset-prototype-has.html")}}
 
@@ -29,7 +29,7 @@ La méthode **`has()`** renvoie un booléen indiquant si un objet donné est con
 ### Valeur renvoyée
 
 - Booléen
-  - : La méthode renvoie `true` si l'objet `WeakSet `contient bien un élément avec la valeur donnée, `false `sinon.
+  - : La méthode renvoie `true` si l'objet `WeakSet` contient bien un élément avec la valeur donnée, `false` sinon.
 
 ## Exemples
 
diff --git a/files/fr/web/javascript/reference/global_objects/webassembly/global/index.md b/files/fr/web/javascript/reference/global_objects/webassembly/global/index.md
index 67133e3992..d521bc7a8a 100644
--- a/files/fr/web/javascript/reference/global_objects/webassembly/global/index.md
+++ b/files/fr/web/javascript/reference/global_objects/webassembly/global/index.md
@@ -38,7 +38,7 @@ Aucune.
 
 ## Instances de `WebAssembly.Global`
 
-Toutes les instances de `Global` héritent du [prototype ](/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Global/prototype)du constructeur `Global()`. Ce prototype peut être modifié afin d'avoir un impact sur l'ensemble des instances de `Global`.
+Toutes les instances de `Global` héritent du [prototype](/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Global/prototype) du constructeur `Global()`. Ce prototype peut être modifié afin d'avoir un impact sur l'ensemble des instances de `Global`.
 
 ### Propriétés des instances
 
@@ -79,7 +79,7 @@ WebAssembly.instantiateStreaming(fetch('global.wasm'), { js: { global } })
 });
 ```
 
-> **Note :** Cet exemple est[ utilisable sur GitHub](https://mdn.github.io/webassembly-examples/js-api-examples/global.html) et [son code source est également disponible](https://github.com/mdn/webassembly-examples/blob/master/js-api-examples/global.html).
+> **Note :** Cet exemple est [utilisable sur GitHub](https://mdn.github.io/webassembly-examples/js-api-examples/global.html) et [son code source est également disponible](https://github.com/mdn/webassembly-examples/blob/master/js-api-examples/global.html).
 
 ## Spécifications
 
diff --git a/files/fr/web/javascript/reference/global_objects/webassembly/module/customsections/index.md b/files/fr/web/javascript/reference/global_objects/webassembly/module/customsections/index.md
index 63877bff3b..f9810e9060 100644
--- a/files/fr/web/javascript/reference/global_objects/webassembly/module/customsections/index.md
+++ b/files/fr/web/javascript/reference/global_objects/webassembly/module/customsections/index.md
@@ -38,7 +38,7 @@ Si le module passé en argument n'est pas une instance de {{jsxref("WebAssembly.
 
 ## Les sections personnalisées
 
-Un module wasm contient une série de **sections**. La plupart de ces sections sont spécifiées et validées par la spécification WebAssembly mais les modules peuvent contenir certaines sections « personnalisées » (_custom sections_) qui sont ignorées lors de la phase de validation. Pour plus d'informations, consulter[ l'article sur les structures de haut niveau](https://github.com/WebAssembly/design/blob/master/BinaryEncoding.md#high-level-structure) qui détaille la structure des sections et les différences entre les sections normales (« connues ») et les sections personnalisées.
+Un module wasm contient une série de **sections**. La plupart de ces sections sont spécifiées et validées par la spécification WebAssembly mais les modules peuvent contenir certaines sections « personnalisées » (_custom sections_) qui sont ignorées lors de la phase de validation. Pour plus d'informations, consulter [l'article sur les structures de haut niveau](https://github.com/WebAssembly/design/blob/master/BinaryEncoding.md#high-level-structure) qui détaille la structure des sections et les différences entre les sections normales (« connues ») et les sections personnalisées.
 
 Cela permet aux développeurs d'inclure des données personnalisées dans un module WebAssembly pour d'autres desseins. Par exemple, on peut avoir [une section personnalisée `name`](https://github.com/WebAssembly/design/blob/master/BinaryEncoding.md#name-section), qui permet aux développeurs de fournir des noms pour les fonctions et les variables locales du module (à la façon des « symboles » utilisé pour les programmes compilés).
 
diff --git a/files/fr/web/javascript/reference/global_objects/webassembly/table/table/index.md b/files/fr/web/javascript/reference/global_objects/webassembly/table/table/index.md
index 55ee827e0e..6d23493ae3 100644
--- a/files/fr/web/javascript/reference/global_objects/webassembly/table/table/index.md
+++ b/files/fr/web/javascript/reference/global_objects/webassembly/table/table/index.md
@@ -36,7 +36,7 @@ new WebAssembly.Table(descripteurTable)
 
 ### Créer une nouvelle instance d'une Table WebAssembly
 
-Dans l'exemple suivant (voir [le code source](https://github.com/mdn/webassembly-examples/blob/master/js-api-examples/table2.html) et [la démo live ](https://mdn.github.io/webassembly-examples/js-api-examples/table2.html) correspondants), on crée une nouvelle instance d'une table WebAssembly avec une taille initiale de 2 éléments. On affiche alors la longueur de la table et son contenu (grâce à [`Table.prototype.get()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Table/get) pour montrer que la longueur vaut 2 et que les deux éléments sont [`null`](/fr/docs/Web/JavaScript/Reference/Global_Objects/null).
+Dans l'exemple suivant (voir [le code source](https://github.com/mdn/webassembly-examples/blob/master/js-api-examples/table2.html) et [la démo live](https://mdn.github.io/webassembly-examples/js-api-examples/table2.html) correspondants), on crée une nouvelle instance d'une table WebAssembly avec une taille initiale de 2 éléments. On affiche alors la longueur de la table et son contenu (grâce à [`Table.prototype.get()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Table/get) pour montrer que la longueur vaut 2 et que les deux éléments sont [`null`](/fr/docs/Web/JavaScript/Reference/Global_Objects/null).
 
 ```js
 var tbl = new WebAssembly.Table({initial:2, element:"anyfunc"});
diff --git a/files/fr/web/javascript/reference/index.md b/files/fr/web/javascript/reference/index.md
index 2ab690bbe3..9833484b6c 100644
--- a/files/fr/web/javascript/reference/index.md
+++ b/files/fr/web/javascript/reference/index.md
@@ -13,7 +13,7 @@ Cette partie de la section JavaScript de MDN regroupe plusieurs notions sur le l
 
 ## Les objets globaux
 
-Ce chapitre documente l'ensemble des [objets natifs standards JavaScript ](/fr/docs/Web/JavaScript/Reference/Objets_globaux)ainsi que leurs méthodes et leurs propriétés.
+Ce chapitre documente l'ensemble des [objets natifs standards JavaScript](/fr/docs/Web/JavaScript/Reference/Objets_globaux) ainsi que leurs méthodes et leurs propriétés.
 
 {{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux', 'Objets_globaux_standards_(par_catégorie)')}}
 
diff --git a/files/fr/web/javascript/reference/lexical_grammar/index.md b/files/fr/web/javascript/reference/lexical_grammar/index.md
index c6b22e90af..b51707fcb1 100644
--- a/files/fr/web/javascript/reference/lexical_grammar/index.md
+++ b/files/fr/web/javascript/reference/lexical_grammar/index.md
@@ -206,7 +206,7 @@ Les mots-clés suivants sont réservés dans les anciennes spécifications ECMAS
 - `transient`
 - `volatile`
 
-Par ailleurs, les littéraux `null`, `true`, et` false` sont réservés dans ECMAScript pour leur usage normal.
+Par ailleurs, les littéraux `null`, `true`, et `false` sont réservés dans ECMAScript pour leur usage normal.
 
 ### Utilisation des mots-clés réservés
 
diff --git a/files/fr/web/javascript/reference/operators/grouping/index.md b/files/fr/web/javascript/reference/operators/grouping/index.md
index 0705c32d1e..9dc960ef06 100644
--- a/files/fr/web/javascript/reference/operators/grouping/index.md
+++ b/files/fr/web/javascript/reference/operators/grouping/index.md
@@ -20,7 +20,7 @@ L'opérateur de groupement `( )` contrôle la précédence de l'évaluation dans
 
 ## Description
 
-L'opérateur de groupement consiste en une paire de parenthèses encadrant une expression et permettant de surcharger la [précédence normale des opérateurs ](/fr/docs/JavaScript/Reference/Operateurs/Précédence_des_opérateurs)afin que les expressions dont la précédence est plus basse soient évaluées avant.
+L'opérateur de groupement consiste en une paire de parenthèses encadrant une expression et permettant de surcharger la [précédence normale des opérateurs](/fr/docs/JavaScript/Reference/Operateurs/Précédence_des_opérateurs) afin que les expressions dont la précédence est plus basse soient évaluées avant.
 
 ## Exemples
 
diff --git a/files/fr/web/javascript/reference/operators/instanceof/index.md b/files/fr/web/javascript/reference/operators/instanceof/index.md
index b6bb3248cd..9140ba2031 100644
--- a/files/fr/web/javascript/reference/operators/instanceof/index.md
+++ b/files/fr/web/javascript/reference/operators/instanceof/index.md
@@ -64,7 +64,7 @@ o3 instanceof C; // true car C.prototype fait partie de la chaîne de o3
 
 ### `instanceof` dans d'autres contextes (frames ou fenêtres)
 
-Différents niveaux d'intégrations ont différents environnements. Cela signifie que les valeurs retournées sont différentes (objet globaux différents, constructeurs différents, etc.). Cela peut engendrer des résultats inattendus. Par exemple, `[] instanceof window.frames[0].Array` renverra `false`, car ` Array !== ``window.frames[0].Array` et que les tableaux héritent de leur constructeur.
+Différents niveaux d'intégrations ont différents environnements. Cela signifie que les valeurs retournées sont différentes (objet globaux différents, constructeurs différents, etc.). Cela peut engendrer des résultats inattendus. Par exemple, `[] instanceof window.frames[0].Array` renverra `false`, car `Array !== window.frames[0].Array` et que les tableaux héritent de leur constructeur.
 
 Cela peut être contre-intuitif au début, mais lorsqu'il est nécessaire de travailler avec plusieurs frames ou fenêtres, et que des objets sont transférés via des fonctions, cela sera un obstacle valide et important. Par contre, il est tout à fait possible d'utiliser `Array.isArray(myObj)` pour vérifier de manière sécurisée qu'un tableau est effectivement un tableau.
 
diff --git a/files/fr/web/javascript/reference/operators/object_initializer/index.md b/files/fr/web/javascript/reference/operators/object_initializer/index.md
index 05f0cabe3f..3c8d5deb28 100644
--- a/files/fr/web/javascript/reference/operators/object_initializer/index.md
+++ b/files/fr/web/javascript/reference/operators/object_initializer/index.md
@@ -11,7 +11,7 @@ original_slug: Web/JavaScript/Reference/Opérateurs/Initialisateur_objet
 ---
 {{JsSidebar("Operators")}}
 
-Il est possible d'initialiser un objet en utilisant les notations [`new Object()`](/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object),` Object.create()`, ou grâce à un littéral (appelée initialisateur). Un initialisateur d'objet est une liste contenant plusieurs (éventuellement 0) propriétés, séparées par des virgules, et leurs valeurs associées, cette liste étant entourée d'accolades (`{}`).
+Il est possible d'initialiser un objet en utilisant les notations [`new Object()`](/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object), `Object.create()`, ou grâce à un littéral (appelée initialisateur). Un initialisateur d'objet est une liste contenant plusieurs (éventuellement 0) propriétés, séparées par des virgules, et leurs valeurs associées, cette liste étant entourée d'accolades (`{}`).
 
 {{EmbedInteractiveExample("pages/js/expressions-objectinitializer.html")}}
 
@@ -184,7 +184,7 @@ var o = {
 };
 ```
 
-Pour plus d'informations et d'exemples sur les méthodes, voir la page concernant les[ définitions de méthode](/fr/docs/Web/JavaScript/Reference/Functions/Method_definitions).
+Pour plus d'informations et d'exemples sur les méthodes, voir la page concernant les [définitions de méthode](/fr/docs/Web/JavaScript/Reference/Functions/Method_definitions).
 
 ### Noms de propriétés calculés
 
@@ -285,7 +285,7 @@ La notation utilisant un littéral objet n'est pas identique à celle utilisée
 | Spécification                                                                                    | État                         | Commentaires                                                                                                                                               |
 | ------------------------------------------------------------------------------------------------ | ---------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | {{SpecName('ES1')}}                                                                         | {{Spec2('ES1')}}         | Définition initiale.                                                                                                                                       |
-| {{SpecName('ES5.1', '#sec-11.1.5', 'Object Initializer')}}                     | {{Spec2('ES5.1')}}     | [Ajout des _getter_ et ](/fr/docs/Web/JavaScript/Reference/Functions/get)_[setter](/fr/docs/Web/JavaScript/Reference/Functions/set)_ (accesseur/mutateur). |
+| {{SpecName('ES5.1', '#sec-11.1.5', 'Object Initializer')}}                     | {{Spec2('ES5.1')}}     | [Ajout des _getter_ et](/fr/docs/Web/JavaScript/Reference/Functions/get) _[setter](/fr/docs/Web/JavaScript/Reference/Functions/set)_ (accesseur/mutateur). |
 | {{SpecName('ES2015', '#sec-object-initializer', 'Object Initializer')}} | {{Spec2('ES2015')}}     | Ajout des raccourcis pour les noms de méthodes et propriétés et des noms de propriétés calculés.                                                           |
 | {{SpecName('ESDraft', '#sec-object-initializer', 'Object Initializer')}} | {{Spec2('ESDraft')}} |                                                                                                                                                            |
 
diff --git a/files/fr/web/javascript/reference/operators/optional_chaining/index.md b/files/fr/web/javascript/reference/operators/optional_chaining/index.md
index f7f2379ba4..5a6d39da9b 100644
--- a/files/fr/web/javascript/reference/operators/optional_chaining/index.md
+++ b/files/fr/web/javascript/reference/operators/optional_chaining/index.md
@@ -66,7 +66,7 @@ Utiliser le chaînage optionnel avec les appels de fonction entraîne le retour
 let result = uneInterface.uneMéthode?.();
 ```
 
-> **Note :** S'il est une propriété qui porte ce nom et qui n'est pas une fonction, utiliser `?.` jètera aussi une exception {{jsxref("TypeError")}} (` x.y`` is not a function  `).
+> **Note :** S'il est une propriété qui porte ce nom et qui n'est pas une fonction, utiliser `?.` jètera aussi une exception {{jsxref("TypeError")}} (`x.y is not a function`).
 
 #### Réaliser des fonctions de rappel optionnelles ou des écouteurs d'évènements
 
diff --git a/files/fr/web/javascript/reference/operators/this/index.md b/files/fr/web/javascript/reference/operators/this/index.md
index f1d09c2d32..ef563b523c 100644
--- a/files/fr/web/javascript/reference/operators/this/index.md
+++ b/files/fr/web/javascript/reference/operators/this/index.md
@@ -383,7 +383,7 @@ montrera le texte `button` lorsqu'on cliquera dessus. Attention, seul le code ex
 </button>
 ```
 
-Ici, on utilise `this `à l'intérieur d'une fonction et il n'est pas défini en amont. Il renvoie donc l'objet global (l'objet `window` pour un navigateur avec du code non-strict).
+Ici, on utilise `this` à l'intérieur d'une fonction et il n'est pas défini en amont. Il renvoie donc l'objet global (l'objet `window` pour un navigateur avec du code non-strict).
 
 ## Spécifications
 
diff --git a/files/fr/web/javascript/reference/operators/typeof/index.md b/files/fr/web/javascript/reference/operators/typeof/index.md
index 646f753ef8..0e849c25ca 100644
--- a/files/fr/web/javascript/reference/operators/typeof/index.md
+++ b/files/fr/web/javascript/reference/operators/typeof/index.md
@@ -32,7 +32,7 @@ Le tableau qui suit liste les résultats possibles de l'opérateur `typeof`. Pou
 | Type                                                                                              | Résultat                   |
 | ------------------------------------------------------------------------------------------------- | -------------------------- |
 | [indéfini](/fr/docs/Glossary/undefined)                                                           | `"undefined"`              |
-| [nul](/fr/docs/Glossary/Null)                                                                     | `"object" `(voir ci-après) |
+| [nul](/fr/docs/Glossary/Null)                                                                     | `"object"` (voir ci-après) |
 | [booléen](/fr/docs/Glossary/Boolean)                                                              | `"boolean"`                |
 | [nombre](/fr/docs/Glossary/Number)                                                                | `"number"`                 |
 | [grand entier (nouveauté d'ECMAScript 2020)](/fr/docs/Glossary/BigInt)                            | `"bigint"`                 |
@@ -161,7 +161,7 @@ typeof /s/ === 'object';   // À partir de Firefox 5 : Conforme à ECMAScript 5.
 
 Avant ECMAScript 2015 (ES6), `typeof` retournait toujours une chaîne de caractères, quel que soit l'opérande utilisé. On ne pouvait pas avoir d'erreur en utilisant `typeof`.
 
-Avec l'apparition des opérateurs [`let`](/fr/docs/Web/JavaScript/Reference/Statements/let) et [`const`](/fr/docs/Web/JavaScript/Reference/Statements/const), si on utilise `typeof` sur des variables déclarées avec ces opérateurs (ou avec une classe) avant leur déclaration, cela déclenchera une erreur [`ReferenceError`](/fr/docs/Web/JavaScript/Reference/Global_Objects/ReferenceError). Si on utilise `typeof` sur une variable déclarée avec `var` avant la déclaration, cela renverra `undefined`. Les variables déclarées avec `let` et `const` sont en fait placées dans une *[zone morte temporaire ](/fr/docs/Web/JavaScript/Reference/Statements/let)*entre le début du bloc et leur initialisation et dans cette zone, tout accès à la variable produit une erreur.
+Avec l'apparition des opérateurs [`let`](/fr/docs/Web/JavaScript/Reference/Statements/let) et [`const`](/fr/docs/Web/JavaScript/Reference/Statements/const), si on utilise `typeof` sur des variables déclarées avec ces opérateurs (ou avec une classe) avant leur déclaration, cela déclenchera une erreur [`ReferenceError`](/fr/docs/Web/JavaScript/Reference/Global_Objects/ReferenceError). Si on utilise `typeof` sur une variable déclarée avec `var` avant la déclaration, cela renverra `undefined`. Les variables déclarées avec `let` et `const` sont en fait placées dans une *[zone morte temporaire](/fr/docs/Web/JavaScript/Reference/Statements/let)* entre le début du bloc et leur initialisation et dans cette zone, tout accès à la variable produit une erreur.
 
 ```js
 typeof variableGlobaleNonDeclaree === "undefined";
diff --git a/files/fr/web/javascript/reference/statements/async_function/index.md b/files/fr/web/javascript/reference/statements/async_function/index.md
index eac4ac9ce7..f60c23b0e2 100644
--- a/files/fr/web/javascript/reference/statements/async_function/index.md
+++ b/files/fr/web/javascript/reference/statements/async_function/index.md
@@ -156,7 +156,7 @@ Avec `concurrentStart`, si l'un des deux appels échoue, l'exception sera imméd
 Pour obtenir les mêmes sécurités avec les promesses, il faut s'assurer que la fonction renvoie une promesse qui gère ce cas d'échec. Pour `concurrentPromise` cela signifie qu'il faut renvoyer la promesse de `Promise.all([]).then()`.
 
 Bien entendu, il est toutefois possible d'avoir des fonctions asynchrones (avec `async`) qui gobent des erreurs involontairement. Si on considère la fonction `parallel` ci-avant, s'il n'y avait eu aucun `await` ou `return` pour le résultat de `Promise.all([])`, aucune erreur n'aurait été propagée.
-Bien que l'exemple `parallelPromise` paraisse simple, il ne gère aucune erreur du tout. Il aurait fallu utiliser un ` return ``Promise.all([])` analogue.
+Bien que l'exemple `parallelPromise` paraisse simple, il ne gère aucune erreur du tout. Il aurait fallu utiliser un `return Promise.all([])` analogue.
 
 ### Réécrire une chaîne de promesses avec une fonction asynchrone
 
diff --git a/files/fr/web/javascript/reference/statements/for-await...of/index.md b/files/fr/web/javascript/reference/statements/for-await...of/index.md
index cf6c423365..fe24c37c2e 100644
--- a/files/fr/web/javascript/reference/statements/for-await...of/index.md
+++ b/files/fr/web/javascript/reference/statements/for-await...of/index.md
@@ -10,7 +10,7 @@ original_slug: Web/JavaScript/Reference/Instructions/for-await...of
 ---
 {{jsSidebar("Statements")}}
 
-L'instruction **`for await...of` **permet de créer une boucle qui parcourt les objets itérables asynchrones de la même façon qu'on parcourt les itérables synchrones (tels que les chaînes de caractères ({{jsxref("String")}}), les tableaux {{jsxref("Array")}}, les objets semblables aux tableaux comme {{jsxref("Fonctions/arguments", "arguments")}} ou {{domxref("NodeList")}}), {{jsxref("TypedArray")}}, {{jsxref("Map")}}, {{jsxref("Set")}}. Cette instruction invoque un mécanisme d'itération spécifique et les instructions à exécuter pour chaque propriété de l'objet.
+L'instruction **`for await…of`** permet de créer une boucle qui parcourt les objets itérables asynchrones de la même façon qu'on parcourt les itérables synchrones (tels que les chaînes de caractères ({{jsxref("String")}}), les tableaux {{jsxref("Array")}}, les objets semblables aux tableaux comme {{jsxref("Fonctions/arguments", "arguments")}} ou {{domxref("NodeList")}}), {{jsxref("TypedArray")}}, {{jsxref("Map")}}, {{jsxref("Set")}}. Cette instruction invoque un mécanisme d'itération spécifique et les instructions à exécuter pour chaque propriété de l'objet.
 
 ## Syntaxe
 
diff --git a/files/fr/web/javascript/reference/statements/for/index.md b/files/fr/web/javascript/reference/statements/for/index.md
index 977a80baff..beb5a287b3 100644
--- a/files/fr/web/javascript/reference/statements/for/index.md
+++ b/files/fr/web/javascript/reference/statements/for/index.md
@@ -24,7 +24,7 @@ L'instruction **`for`** crée une boucle composée de trois expressions optionne
 - `initialisation`
   - : Une expression (pouvant être une expression d'affectation) ou une déclaration de variable. Cette expression est évaluée une fois avant que la boucle démarre. On utilise généralement une variable qui agit comme un compteur. Cette expression peut éventuellement déclarer de nouvelles variables avec le mot-clé `var` ou `let`. Les variables déclarées avec `var` se situent dans la même portée que la boucle `for` (elles ne sont pas locales au sein de la boucle), les variables déclarées avec `let` sont locales à la boucle. Le résultat de l'expression n'est pas utilisé.
 - `condition`
-  - : Une expression qui est évaluée avant chaque itération de la boucle. Si cette expression est vérifiée, l'`instruction `est exécutée. Ce test est optionnel. S'il n'est pas présent, la condition sera toujours vérifiée. Si l'expression n'est pas vérifiée (i.e. vaut `false`), l'exécution se poursuivra à la première expression qui suit la boucle `for`.
+  - : Une expression qui est évaluée avant chaque itération de la boucle. Si cette expression est vérifiée, l'`instruction` est exécutée. Ce test est optionnel. S'il n'est pas présent, la condition sera toujours vérifiée. Si l'expression n'est pas vérifiée (i.e. vaut `false`), l'exécution se poursuivra à la première expression qui suit la boucle `for`.
 - `expression_finale`
   - : Une expression qui est évaluée à la fin de chaque itération. Cela se produit avant l'évaluation de l'expression `condition`. Cette expression est généralement utilisée pour mettre à jour ou incrémenter le compteur qu'est la variable d'initialisation.
 - `instruction`
diff --git a/files/fr/web/javascript/reference/statements/switch/index.md b/files/fr/web/javascript/reference/statements/switch/index.md
index 98c11927bf..e478726ba6 100644
--- a/files/fr/web/javascript/reference/statements/switch/index.md
+++ b/files/fr/web/javascript/reference/statements/switch/index.md
@@ -42,9 +42,9 @@ L'instruction **`switch`** évalue une expression et, selon le résultat obtenu
 
 - `expression`
   - : Une expression à comparer avec chacune des clause `case`.
-- `case expressionN `{{optional_inline}}
+- `case expressionN` {{optional_inline}}
   - : Une clause qu'on compare avec `expression`.
-- `default `{{optional_inline}}
+- `default` {{optional_inline}}
   - : Une clause exécutée si aucune correspondance n'est trouvée avec les clause `case` (et/ou s'il n'y a pas de `break` pour les clauses `case` précédentes).
 - `instructionsN`
   - : Les instructions à exécuter lorsque l'`expression` correspond au cas présenté pour cette clause.
diff --git a/files/fr/web/javascript/reference/statements/with/index.md b/files/fr/web/javascript/reference/statements/with/index.md
index 07e848ad28..13fcf99f4e 100644
--- a/files/fr/web/javascript/reference/statements/with/index.md
+++ b/files/fr/web/javascript/reference/statements/with/index.md
@@ -48,7 +48,7 @@ Dès qu'un nom non-qualifié est utilisé, JavaScript cherche dans la chaîne de
     }
     ```
 
-  ce n'est que quand `f` est appelée que `x` est trouvé ou non, s'il est trouvé à partir de `o` ou (si o n'a pas de telle propriété) dans l'objet d'activation de `f `où `x` représente le premier argument de la fonction. Si `x` n'est pas défini dans l'objet passé en second argument, il n'y aura pas d'erreur renvoyée, juste des résultats imprévus.
+  ce n'est que quand `f` est appelée que `x` est trouvé ou non, s'il est trouvé à partir de `o` ou (si o n'a pas de telle propriété) dans l'objet d'activation de `f` où `x` représente le premier argument de la fonction. Si `x` n'est pas défini dans l'objet passé en second argument, il n'y aura pas d'erreur renvoyée, juste des résultats imprévus.
 
 - **Inconvénient :** Du code utilisant l'instruction `with` pourrait ne pas être compatible dans le futur, en particulier lorsqu'il est utilisé avec autre chose qu'un objet simple. Par exemple :
 
diff --git a/files/fr/web/javascript/reference/strict_mode/transitioning_to_strict_mode/index.md b/files/fr/web/javascript/reference/strict_mode/transitioning_to_strict_mode/index.md
index 8369472b37..b6dc3c6040 100644
--- a/files/fr/web/javascript/reference/strict_mode/transitioning_to_strict_mode/index.md
+++ b/files/fr/web/javascript/reference/strict_mode/transitioning_to_strict_mode/index.md
@@ -31,8 +31,8 @@ En utilisant `"use strict";`, certaines instructions ou fragments de code lancer
 - La déclaration de fonctions dans des blocs `if(a<b){ function f(){} }`
 - Les erreurs évidentes
 
-  - Déclarer deux fois le nom d'une propriété dans un littéral objet` {a: 1, b: 3, a: 7}`. Ceci n'est plus le cas pour ECMAScript 2015 (ES6) : {{bug(1041128)}}
-  - Déclarer deux arguments de fonction avec le même nom` function f(a, b, b){}`
+  - Déclarer deux fois le nom d'une propriété dans un littéral objet `{a: 1, b: 3, a: 7}`. Ceci n'est plus le cas pour ECMAScript 2015 (ES6) : {{bug(1041128)}}
+  - Déclarer deux arguments de fonction avec le même nom `function f(a, b, b){}`
 
 Ces erreurs sont bienvenues car elles révèlent des mauvaises pratiques et certaines erreurs claires. Elles apparaissent avant l'exécution du code.
 
@@ -128,7 +128,7 @@ Un des aspects négatifs de cette migration est la sémantique : le sens du code
 1.  Écrivez votre code « strictement » et assurez vous de lancer des exceptions dans le cadre d'erreurs liées au mode non-strict (voir la section « Erreurs à l'exécution » ci-avant)
 2.  Minimisez l'utilisation des éléments dont la sémantique pourrait changer :
 
-    1.  `eval `: n'utilisez cette fonction uniquement si vous êtes certains que c'est l'unique solution
+    1.  `eval`&nbsp;: n'utilisez cette fonction uniquement si vous êtes certains que c'est l'unique solution
     2.  `arguments` : utilisez les arguments d'une fonction via leur nom ou faites une copie de l'objet en utilisant :
         `var args = Array.prototype.slice.call(arguments)`
         au tout début de votre fonction
diff --git a/files/fr/web/javascript/the_performance_hazards_of_prototype_mutation/index.md b/files/fr/web/javascript/the_performance_hazards_of_prototype_mutation/index.md
index 93b4752f87..eaa9f7bd04 100644
--- a/files/fr/web/javascript/the_performance_hazards_of_prototype_mutation/index.md
+++ b/files/fr/web/javascript/the_performance_hazards_of_prototype_mutation/index.md
@@ -73,7 +73,7 @@ Dans la plupart des cas, les moteurs utilisent cette approche rapide. Toutefois,
 
 ## L'optimisation intelligente des propriétés héritées
 
-Lors des accès prédictibles, on trouve _généralement_ la propriété en un nombre constant de sauts le long de la chaîne. Les objets de chaîne n'acquièrent _généralement_ pas de nouvelle propriétés et l'objet final n'est _généralement_ pas affecté par une [suppression](Opérateurs/L_opérateur_delete) de propriétés. Enfin, **la modification de **`[[Prototype]]` est** rare**.  Ces hypothèses sont nécessaires pour éviter de « sauter » sur chacun des prototypes. Les différents moteurs optent pour différentes approches afin d'optimiser les propriétés héritées de façon intelligente.
+Lors des accès prédictibles, on trouve _généralement_ la propriété en un nombre constant de sauts le long de la chaîne. Les objets de chaîne n'acquièrent _généralement_ pas de nouvelle propriétés et l'objet final n'est _généralement_ pas affecté par une [suppression](Opérateurs/L_opérateur_delete) de propriétés. Enfin, **la modification de `[[Prototype]]` est rare**. Ces hypothèses sont nécessaires pour éviter de « sauter » sur chacun des prototypes. Les différents moteurs optent pour différentes approches afin d'optimiser les propriétés héritées de façon intelligente.
 
 - La forme de l'objet _final_ qui contient la propriété héritée peut être vérifiée.
author	Carolyn Wu <87150472+cw118@users.noreply.github.com>	2022-03-03 02:35:24 -0500
committer	GitHub <noreply@github.com>	2022-03-03 08:35:24 +0100
commit	581e6fb5827a5450e295c91250dd0563a3c9251a (patch)
tree	801de6432e274e1a53bb3b1f6151e447915ffda8
parent	da1500b5765037b2ec3db0190f3accac453c6d96 (diff)
download	translated-content-581e6fb5827a5450e295c91250dd0563a3c9251a.tar.gz translated-content-581e6fb5827a5450e295c91250dd0563a3c9251a.tar.bz2 translated-content-581e6fb5827a5450e295c91250dd0563a3c9251a.zip