fr: Format /web/javascript using Prettier (part 2) (#14640)

.prettierignore

@@ -24,6 +24,7 @@ build/
 /files/fr/web/css/justify-content/index.md
 /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/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

files/fr/web/javascript/reference/errors/unexpected_token/index.md

@@ -1,5 +1,5 @@
 ---
-title: 'SyntaxError: Unexpected token'
+title: "SyntaxError: Unexpected token"
 slug: Web/JavaScript/Reference/Errors/Unexpected_token
 translation_of: Web/JavaScript/Reference/Errors/Unexpected_token
 ---
@@ -66,12 +66,19 @@ Si on compte les parenthèses ouvrantes et fermantes, c'est correct mais on peut
 Pour corriger ce problème, il suffit d'ajouter une paire de parenthèses englobante :
 
 ```js example-good
-function round(n, upperBound, lowerBound){
-  if((n > upperBound) || (n < lowerBound)){
-    throw 'Number ' + String(n) + ' is more than ' + String(upperBound) + ' or less than ' + String(lowerBound);
-  }else if(n < ((upperBound + lowerBound)/2)){
+function round(n, upperBound, lowerBound) {
+  if (n > upperBound || n < lowerBound) {
+    throw (
+      "Number " +
+      String(n) +
+      " is more than " +
+      String(upperBound) +
+      " or less than " +
+      String(lowerBound)
+    );
+  } else if (n < (upperBound + lowerBound) / 2) {
     return lowerBound;
-  }else{
+  } else {
     return upperBound;
   }
 }

files/fr/web/javascript/reference/errors/unexpected_type/index.md

@@ -47,13 +47,12 @@ toto.substring(1); // TypeError: toto is undefined
 var toto = null;
 toto.substring(1); // TypeError: toto is null
 
-
 // Certaines méthodes nécessitent une valeur
 // d'un type spécifique
-var toto = {}
+var toto = {};
 Symbol.keyFor(toto); // TypeError: toto is not a symbol
 
-var toto = "truc"
+var toto = "truc";
 Object.create(toto); // TypeError: "toto" is not an object or null
 ```
 
@@ -62,7 +61,7 @@ Object.create(toto); // TypeError: "toto" is not an object or null
 Pour résoudre ce problème et écarter les cas où la valeur vaut `undefined`, on peut par exemple utiliser l'opérateur [`typeof`](/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_typeof).
 
 ```js
-if (typeof toto !== 'undefined') {
+if (typeof toto !== "undefined") {
   // Désormais, on sait que toto est bien
   // défini et on peut poursuivre.
 }

files/fr/web/javascript/reference/errors/unnamed_function_statement/index.md

@@ -1,5 +1,5 @@
 ---
-title: 'SyntaxError: function statement requires a name'
+title: "SyntaxError: function statement requires a name"
 slug: Web/JavaScript/Reference/Errors/Unnamed_function_statement
 translation_of: Web/JavaScript/Reference/Errors/Unnamed_function_statement
 ---
@@ -38,17 +38,15 @@ function () {
 On peut utiliser [une expression de fonction](/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_function) à la place :
 
 ```js example-good
-var salutations = function() {
-  return 'Coucou monde :)';
+var salutations = function () {
+  return "Coucou monde :)";
 };
 ```
 
 Si la fonction devait être appelé immédiatement, il suffit d'ajouter des parenthèses autour :
 
 ```js example-good
-(function () {
-
-})();
+(function () {})();
 ```
 
 ### Fonctions étiquetées
@@ -82,7 +80,7 @@ Si vous souhaitez construire une méthode d'un objet, il faudra d'abord créer l
 var greeter = {
   german: function () {
     return "Moin";
-  }
+  },
 };
 ```
 

files/fr/web/javascript/reference/errors/unparenthesized_unary_expr_lhs_exponentiation/index.md

@@ -31,18 +31,18 @@ Cela provient vraisemblablement d'une écriture comme celle-ci :
 
 Ici, l'expression est ambigüe et on ne sait pas si elle devrait être évaluée comme `(-a) ** b` ou comme `-(a ** b)`. En mathématiques, l'écriture -x<sup>2</sup> signifie `-(x ** 2)`, et c'est ainsi que de nombreux langages de programmation, comme Python, Haskell, et PHP, gèrent cette évaluation. Mais si la précédence de l'opérateur unaire moins l'emporte sur `**`, cela casse la symétrie avec `a ** -b`, qui s'évalue sans ambigüité comme `a ** (-b)`. Aussi, le langage interdit cette syntaxe et impose d'utiliser des parenthèses d'un côté ou de l'autre pour résoudre l'ambigüité.
 
-```js example-good
-(-a) ** b
--(a ** b)
+```js-nolint example-good
+(-a) ** b;
+-(a ** b);
 ```
 
 D'autres opérateurs unaires ne peuvent pas être utilisés sur l'opérande gauche non plus.
 
 ```js example-bad
-await a ** b
-!a ** b
-+a ** b
-~a ** b
+await a ** b;
+!a ** b;
++a ** b;
+~a ** b;
 ```
 
 ## Exemples
@@ -60,7 +60,7 @@ Toutefois, le fragment `-1 ** n` est illégal en JavaScript. À la place, on uti
 
 ```js example-good
 function taylorSin(x) {
-  return (n) => (-1) ** n * x ** (2 * n + 1) / factorial(2 * n + 1);
+  return (n) => ((-1) ** n * x ** (2 * n + 1)) / factorial(2 * n + 1);
 }
 ```
 

files/fr/web/javascript/reference/errors/unterminated_string_literal/index.md

@@ -1,5 +1,5 @@
 ---
-title: 'SyntaxError: unterminated string literal'
+title: "SyntaxError: unterminated string literal"
 slug: Web/JavaScript/Reference/Errors/Unterminated_string_literal
 translation_of: Web/JavaScript/Reference/Errors/Unterminated_string_literal
 ---
@@ -47,15 +47,17 @@ Pour écrire une chaîne sur plusieurs lignes, on pourra utiliser :
 Voici la première variante avec l'opérateur de concaténation :
 
 ```js example-good
-var longString = "This is a very long string which needs " +
-                 "to wrap across multiple lines because " +
-                 "otherwise my code is unreadable.";
+var longString =
+  "This is a very long string which needs " +
+  "to wrap across multiple lines because " +
+  "otherwise my code is unreadable.";
 ```
 
 Sinon, on peut utiliser une barre oblique inversée à la fin de chaque ligne pour indiquer qu'elle continue sur la ligne suivante. Attention, il faudra qu'il n'y ait aucun espace ou autre caractère après la barre oblique (il peut bien entendu y avoir un saut de ligne) :
 
 ```js example-good
-var longString = "This is a very long string which needs \
+var longString =
+  "This is a very long string which needs \
 to wrap across multiple lines because \
 otherwise my code is unreadable.";
 ```

files/fr/web/javascript/reference/functions/arguments/@@iterator/index.md

@@ -11,7 +11,7 @@ La valeur initiale de la propriété **`@@iterator`** est le même objet que la
 ## Syntaxe
 
 ```js
-arguments[Symbol.iterator]()
+arguments[Symbol.iterator]();
 ```
 
 ## Exemples
@@ -27,7 +27,7 @@ function f() {
     console.log(letter);
   }
 }
-f('w', 'y', 'k', 'o', 'p');
+f("w", "y", "k", "o", "p");
 ```
 
 ## Spécifications

files/fr/web/javascript/reference/functions/arguments/callee/index.md

@@ -23,26 +23,26 @@ Aux débuts de JavaScript, il n'était pas possible d'utiliser des expressions d
 Cette syntaxe produisait le résultat escompté :
 
 ```js
-function factorielle (n) {
-    return !(n > 1) ? 1 : factorielle(n - 1) * n;
+function factorielle(n) {
+  return !(n > 1) ? 1 : factorielle(n - 1) * n;
 }
 
-[1,2,3,4,5].map(factorielle);
+[1, 2, 3, 4, 5].map(factorielle);
 ```
 
 mais :
 
 ```js
-[1,2,3,4,5].map(function (n) {
-    return !(n > 1) ? 1 : /* que met-on ici ? */ (n - 1) * n;
+[1, 2, 3, 4, 5].map(function (n) {
+  return !(n > 1) ? 1 : /* que met-on ici ? */ (n - 1) * n;
 });
 ```
 
 ne fonctionnait pas. Pour que cela puisse fonctionner, on ajouta `arguments.callee` :
 
 ```js
-[1,2,3,4,5].map(function (n) {
-    return !(n > 1) ? 1 : arguments.callee(n - 1) * n;
+[1, 2, 3, 4, 5].map(function (n) {
+  return !(n > 1) ? 1 : arguments.callee(n - 1) * n;
 });
 ```
 
@@ -52,22 +52,24 @@ Cependant, ce fut une mauvaise solution (avec `caller` également) car elle rend
 var global = this;
 
 var fonctionTruc = function (recursed) {
-    if (!recursed) { return arguments.callee(true); }
-    if (this !== global) {
-        console.log("this est : " + this);
-    } else {
-        console.log("this est la variable globale");
-    }
-}
+  if (!recursed) {
+    return arguments.callee(true);
+  }
+  if (this !== global) {
+    console.log("this est : " + this);
+  } else {
+    console.log("this est la variable globale");
+  }
+};
 
 fonctionTruc();
 ```
 
 ECMAScript 3 a introduit les expressions de fonctions nommées pour résoudre le problème. On peut désormais utiliser :
 
 ```js
-[1,2,3,4,5].map(function factorielle (n) {
-    return !(n > 1) ? 1 : factorielle(n - 1)*n;
+[1, 2, 3, 4, 5].map(function factorielle(n) {
+  return !(n > 1) ? 1 : factorielle(n - 1) * n;
 });
 ```
 
@@ -80,7 +82,9 @@ Cette méthode possède plusieurs avantages :
 Une autre fonctionnalité qui a été déprécié est : `arguments.callee.caller`, ou plus précisément `Function.caller`. Pourquoi cela ? Parce que ça permet d'avoir accès à tout moment à la fonction appelante la plus loin dans la pile d'appels. Or, comme évoqué ci-avant, cela a un effet de bord considérable : ça rend beaucoup plus complexes voire impossibles certaines optimisations. Ainsi, on ne peut pas garantir qu'une fonction `f` n'appellera pas une autre fonction inconnue, ce qui signifie qu'on ne peut pas utiliser l'extension inline. En résumé, cela signifie que n'importe quel site d'appel de fonction (_call site_) qui aurait pu être développé inline très simplement devra subir de nombreux tests :
 
 ```js
-function f (a, b, c, d, e) { return a ? b * c : d * e; }
+function f(a, b, c, d, e) {
+  return a ? b * c : d * e;
+}
 ```
 
 Si l'interpréteur JavaScript ne peut pas garantir que l'ensemble des arguments fournis ici sont des nombres à l'instant de l'appel de la fonction, il devra insérer des vérifications pour chaque argument avant le code inline, sinon il ne pourra pas développer la fonction inline. On notera que, dans ce cas, un interpréteur intelligent devrait pouvoir réarranger les vérifications à faire afin qu'elles soient optimales et de se débarrasser des valeurs inutiles. Malgré tout, une telle optimisation ne sera pas possible dans d'autres cas, ce qui signifie que le développement inline n'est pas possible.
@@ -95,11 +99,10 @@ L'exemple qui suit illustre une fonction qui définit et renvoie une fonction fa
 
 ```js
 function créer() {
-   return function(n) {
-      if (n <= 1)
-         return 1;
-      return n * arguments.callee(n - 1);
-   };
+  return function (n) {
+    if (n <= 1) return 1;
+    return n * arguments.callee(n - 1);
+  };
 }
 
 var résultat = create()(5); // renvoie 120 (5 * 4 * 3 * 2 * 1)
@@ -110,10 +113,10 @@ var résultat = create()(5); // renvoie 120 (5 * 4 * 3 * 2 * 1)
 Malgré tout, dans un cas comme le suivant, il n'existe pas d'équivalent pour `arguments.callee`, c'est pourquoi sa déprécation pourrait être un bug (voir [bug Firefox 725398](https://bugzil.la/725398)):
 
 ```js
-function créerPersonne (sIdentité) {
-    var oPersonne = new Function("alert(arguments.callee.identité);");
-    oPersonne.identité = sIdentité;
-    return oPersonne;
+function créerPersonne(sIdentité) {
+  var oPersonne = new Function("alert(arguments.callee.identité);");
+  oPersonne.identité = sIdentité;
+  return oPersonne;
 }
 
 var jean = créerPersonne("Jean Biche");

files/fr/web/javascript/reference/functions/arguments/index.md

@@ -19,7 +19,7 @@ L'objet **`arguments`** est un objet, **semblable** à un tableau, correspondant
 ## Syntaxe
 
 ```js
-arguments
+arguments;
 ```
 
 ## Description
@@ -29,15 +29,15 @@ L'objet `arguments` est une variable locale (intrinsèque et inhérente aux fonc
 Vous pouvez accéder aux arguments d'une fonction à l'intérieur de celle-ci en utilisant l'objet `arguments`. Cet objet contient une entrée pour chaque argument passé à la fonction, l'indice de la première entrée commençant à 0. Par exemple, si une fonction est appelée avec trois arguments, on accède à ceux-ci comme suit :
 
 ```js
-arguments[0]
-arguments[1]
-arguments[2]
+arguments[0];
+arguments[1];
+arguments[2];
 ```
 
 Les arguments peuvent aussi être modifiés :
 
 ```js
-arguments[1] = 'nouvelle valeur';
+arguments[1] = "nouvelle valeur";
 ```
 
 ### Type de l'objet `arguments` et liens avec `Array`
@@ -64,7 +64,8 @@ var args = [...arguments];
 > **Attention :** Il est déconseillé d'utiliser `slice` sur les arguments car cela peut empêcher certaines optimisations des moteurs JavaScript. Pour ce scénario, on peut par exemple construire un nouveau tableau en parcourant l'objet arguments (à ce sujet, voir [cette page](https://github.com/petkaantonov/bluebird/wiki/Optimization-killers#3-managing-arguments) sur les contraintes d'optimisations liées à V8). Pour cet exemple, on pourra utiliser `Array.apply` :
 >
 > ```js
-> var args = (arguments.length === 1 ? [arguments[0]] : Array.apply(null, arguments));
+> var args =
+>   arguments.length === 1 ? [arguments[0]] : Array.apply(null, arguments);
 > ```
 
 L'objet `arguments` est disponible uniquement dans le corps d'une fonction. Tenter d'accéder à l'objet `arguments` en dehors de la déclaration d'une fonction renvoie une erreur.
@@ -160,7 +161,7 @@ toto(1, 2, 3); // [1, 2, 3]
 Toutefois, pour les fonctions utilisées en mode non-strict, un **objet `arguments`** n'est fourni à l'intérieur de la fonction uniquement si celle-ci n'utilise pas de [paramètres du reste](/fr/docs/Web/JavaScript/Reference/Fonctions/paramètres_du_reste), pas de [paramètres par défaut](/fr/docs/Web/JavaScript/Reference/Fonctions/Valeurs_par_défaut_des_arguments) ou de [paramètre décomposé](/fr/docs/Web/JavaScript/Reference/Opérateurs/Affecter_par_décomposition). Par exemple, dans la fonction suivante, qui utilise un paramètre par défaut, ce sera 10 qui sera renvoyé (et non 100) :
 
 ```js
-function truc(a=1) {
+function truc(a = 1) {
   arguments[0] = 100;
   return a;
 }
@@ -183,7 +184,7 @@ En fait, lorsqu'il n'y a aucun paramètre du reste, paramètre par défaut ou au
 function func(a, b) {
   arguments[0] = 99;
   arguments[1] = 99;
-  console.log(a + " " +b);
+  console.log(a + " " + b);
 }
 
 func(1, 2); // 99 99

files/fr/web/javascript/reference/functions/arguments/length/index.md

@@ -11,7 +11,7 @@ La propriété **`arguments.length`** contient le nombre d'arguments passés à
 ## Syntaxe
 
 ```js
-arguments.length
+arguments.length;
 ```
 
 ## Description
@@ -26,18 +26,18 @@ Dans cet exemple, on définit une fonction qui permet d'additionner plusieurs no
 
 ```js
 function somme(x /*, y, z, ...*/) {
-   x = Number(x);
-   for (var i = 1; i < arguments.length; i++) {
-      x += Number(arguments[i]);
-   }
-   return x;
+  x = Number(x);
+  for (var i = 1; i < arguments.length; i++) {
+    x += Number(arguments[i]);
+  }
+  return x;
 }
 ```
 
 ```js
-résultat = somme(3, 4, 5);        // renvoie 12
-résultat = somme(3, 4);           // renvoie 7
-résultat = somme(103, 104, 105);  // renvoie 312
+résultat = somme(3, 4, 5); // renvoie 12
+résultat = somme(3, 4); // renvoie 7
+résultat = somme(103, 104, 105); // renvoie 312
 ```
 
 > **Note :** `arguments.length` ne doit pas être confondu avec {{jsxref("Function.length")}}.