mdn · SphinxKnight · Jul 28, 2023 · Jul 28, 2023
diff --git a/.prettierignore b/.prettierignore
@@ -25,6 +25,7 @@ build/
 /files/fr/web/css/place-items/index.md
 /files/fr/web/css/place-self/index.md
 /files/fr/web/javascript/reference/global_objects/array/includes/index.md
+/files/fr/web/javascript/reference/global_objects/intl/displaynames/of/index.md
 /files/pt-br/learn/server-side/django/forms/index.md
 /files/ru/learn/server-side/django/forms/index.md
 /files/ru/learn/server-side/django/introduction/index.md
@@ -39,9 +40,6 @@ build/
 /files/es/web/css/**/*.md
 /files/es/web/javascript/reference/**/*.md
 
-# fr
-/files/fr/web/javascript/**/*.md
-
 # ja
 /files/ja/learn/javascript/**/*.md
 /files/ja/mozilla/**/*.md

@@ -247,7 +247,7 @@ Voici une liste (non exhaustive) d'opérateurs et de méthodes natives qui peuve
   - : Si on prend l'opposé de `0`, on aura, bien entendu, `-0`. Cependant, avec les expressions, cela peut faire que la valeur `-0` se glisse dans les variables sans qu'on s'en rende compte. Par exemple :
 
     ```js
-    let forceArrêt = obj.masse * -obj.vitesse
+    let forceArrêt = obj.masse * -obj.vitesse;
     ```
 
     Si `obj.vitesse` vaut `0` (ou est évalué à `0`), un `-0` sera introduit, ce qui fera que `forceArrêt` pourra être négative.

@@ -955,7 +955,7 @@ On peut appeler `valider()` pour un élément de formulaire sur le gestionnaire
 
 L'opérateur de groupement, `( )`, contrôle la précédence de l'évaluation dans une expression. On peut ainsi prioriser certaines opérations par rapport à d'autres et passer outre la précédence par défaut. Dans l'exemple qui suit, on utilise les parenthèses pour que l'addition ait lieu avant la multiplication.
 
-```js
+```js-nolint
 const a = 1;
 const b = 2;
 const c = 3;

@@ -565,7 +565,7 @@ Avec ECMAScript 2015, on peut également utiliser des littéraux sous forme de _
 
 ```js
 // Littéral simple pour une chaîne
-`Un saut de ligne '\n' en JavaScript.`// On peut écrire une chaîne sur plusieurs
+`Un saut de ligne '\n' en JavaScript.` // On peut écrire une chaîne sur plusieurs
 // lignes
 `Dans les gabarits, on peut écrire
   sur plusieurs lignes. `;

@@ -23,7 +23,7 @@ Les différents navigateurs définissent cette valeur à différents instants. P
 Le code HTML suivant démontre l'utilisation de la propriété `stack`.
 
 ```html
-<!DOCTYPE html>
+<!doctype html>
 <meta charset="UTF-8" />
 <title>Exemple de Trace de Pile</title>
 <body>

@@ -43,14 +43,9 @@ Une nouvelle chaîne de caractères composée du nombre indiqué de copies de la
 "abc".repeat(1); // "abc"
 "abc".repeat(2); // "abcabc"
 "abc".repeat(3.5); // "abcabcabc" (le compteur est converti en un nombre entier)
-"abc"
-  .repeat(1 / 0)
-  (
-    // RangeError
-
-    { toString: () => "abc", repeat: String.prototype.repeat },
-  )
-  .repeat(2);
+"abc".repeat(1 / 0); // RangeError
+
+({ toString: () => "abc", repeat: String.prototype.repeat }).repeat(2);
 // "abcabc" (repeat() est une méthode générique)
 ```
 

@@ -48,7 +48,7 @@ NaN ** 2; // NaN
 
 ### Associativité
 
-```js
+```js-nolint
 2 ** 3 ** 2; // 512
 2 ** (3 ** 2); // 512
 (2 ** 3) ** 2; // 64

@@ -24,7 +24,7 @@ L'opérateur de groupement consiste en une paire de parenthèses encadrant une e
 
 Normalement, la multiplication et la division sont prises en compte avant l'addition et la soustraction. On peut changer ce comportement avec l'opérateur de groupement.
 
-```js
+```js-nolint
 var a = 1;
 var b = 2;
 var c = 3;

@@ -60,7 +60,7 @@ console.log(A() && B());
 
 Les expressions suivantes peuvent sembler équivalentes mais ne le sont pas. En effet, l'opérateur `&&` est exécuté avant l'opérateur `||` (voir [l'article sur la précédence des opérateurs](/fr/docs/Web/JavaScript/Reference/Operators/Operator_Precedence)).
 
-```js
+```js-nolint
 true || false && false; // renvoie true, car && est exécuté en premier
 (true || false) && false; // renvoie false, car la précédence par défaut ne s'applique pas avec les parenthèses
 ```

@@ -60,7 +60,7 @@ console.log(B() || A());
 
 Les expressions suivantes peuvent sembler équivalentes mais ne le sont pas. En effet, l'opérateur `&&` est exécuté avant l'opérateur `||` (voir [l'article sur la précédence des opérateurs](/fr/docs/Web/JavaScript/Reference/Operators/Operator_Precedence)).
 
-```js
+```js-nolint
 true || false && false; // renvoie true, car && est exécuté en premier
 (true || false) && false; // renvoie false, car la précédence par défaut ne s'applique pas avec les parenthèses
 ```

@@ -37,11 +37,13 @@ console.log(+y);
 ### Avec des valeurs non-numériques
 
 ```js
-+true;  // 1
++true; // 1
 +false; // 0
-+null;  // 0
-+function(val) { return val }; // NaN
-+1n;    // throws TypeError: Cannot convert BigInt value to number
++null; // 0
++function (val) {
+  return val;
+}; // NaN
++1n; // throws TypeError: Cannot convert BigInt value to number
 ```
 
 ## Spécifications

@@ -172,7 +172,8 @@ Premièrement, le mode strict interdit l'utilisation de `with`. Le problème ave
 ```js
 "use strict";
 var x = 17;
-with (obj) { // !!! erreur de syntaxe
+with (obj) {
+  // !!! erreur de syntaxe
   // Si on n'était pas en mode strict, serait-ce var x,
   // ou serait-ce plutôt obj.x?  Il est impossible en général
   // de le dire sans faire tourner le code, donc