fr: Format /web/javascript using Prettier (part 8) (#14647)

mdn · Jul 28, 2023 · d413f21 · d413f21
1 parent fca90a8
commit d413f21
Show file tree

Hide file tree

Showing 100 changed files with 757 additions and 689 deletions.
diff --git a/files/fr/web/javascript/reference/global_objects/proxy/proxy/ownkeys/index.md b/files/fr/web/javascript/reference/global_objects/proxy/proxy/ownkeys/index.md
@@ -14,8 +14,7 @@ La méthode **`handler.ownKeys()`** est une trappe pour {{jsxref("Object.getOwnP
 
 ```js
 var p = new Proxy(cible, {
-  ownKeys: function(cible) {
-  }
+  ownKeys: function (cible) {},
 });
 ```
 
@@ -57,15 +56,18 @@ Si les invariants suivants ne sont pas respectés, le proxy renverra une excepti
 Dans l'exemple suivant, on intercepte l'action de {{jsxref("Object.getOwnPropertyNames()")}}.
 
 ```js
-var p = new Proxy({}, {
-  ownKeys: function(target) {
-    console.log("appelée");
-    return ["a", "b", "c"];
-  }
-});
+var p = new Proxy(
+  {},
+  {
+    ownKeys: function (target) {
+      console.log("appelée");
+      return ["a", "b", "c"];
+    },
+  },
+);
 
 console.log(Object.getOwnPropertyNames(p)); // "appelée"
-                                            // [ "a", "b", "c"]
+// [ "a", "b", "c"]
 ```
 
 L'exemple suivant ne respecte pas l'ensemble des invariants :
@@ -75,13 +77,13 @@ var obj = {};
 Object.defineProperty(obj, "a", {
   configurable: false,
   enumerable: true,
-  value: 10 }
-);
+  value: 10,
+});
 
 var p = new Proxy(obj, {
-  ownKeys: function(cible) {
+  ownKeys: function (cible) {
     return [123, 12.5, true, false, undefined, null, {}, []];
-  }
+  },
 });
 
 console.log(Object.getOwnPropertyNames(p));

diff --git a/.../web/javascript/reference/global_objects/proxy/proxy/preventextensions/index.md b/.../web/javascript/reference/global_objects/proxy/proxy/preventextensions/index.md
@@ -14,8 +14,7 @@ La méthode **`handler.preventExtensions()`** est une trappe pour {{jsxref("Obje
 
 ```js
 var p = new Proxy(cible, {
-  preventExtensions: function(cible) {
-  }
+  preventExtensions: function (cible) {},
 });
 ```
 
@@ -52,26 +51,32 @@ Si les invariants suivants ne sont pas respectés, le proxy renverra une execpti
 On intercepte l'appel à {{jsxref("Object.preventExtensions()")}} dans l'exemple suivant :
 
 ```js
-var p = new Proxy({}, {
-  preventExtensions: function(cible) {
-    console.log("appelé");
-    Object.preventExtensions(cible);
-    return true;
-  }
-});
+var p = new Proxy(
+  {},
+  {
+    preventExtensions: function (cible) {
+      console.log("appelé");
+      Object.preventExtensions(cible);
+      return true;
+    },
+  },
+);
 
 console.log(Object.preventExtensions(p)); // "appelé"
-                                          // true
+// true
 ```
 
 Le code suivant ne respecte pas l'invariant :
 
 ```js
-var p = new Proxy({}, {
-  preventExtensions: function(cible) {
-    return true;
-  }
-});
+var p = new Proxy(
+  {},
+  {
+    preventExtensions: function (cible) {
+      return true;
+    },
+  },
+);
 
 Object.preventExtensions(p); // TypeError est levée
 ```

diff --git a/files/fr/web/javascript/reference/global_objects/proxy/proxy/set/index.md b/files/fr/web/javascript/reference/global_objects/proxy/proxy/set/index.md
@@ -14,8 +14,7 @@ La méthode **`handler.set()`** est une trappe permettant d'intercepter les opé
 
 ```js
 var p = new Proxy(cible, {
-  set: function(cible, propriété, valeur, récepteur) {
-  }
+  set: function (cible, propriété, valeur, récepteur) {},
 });
 ```
 
@@ -61,19 +60,22 @@ Si les invariants suivants ne sont pas respectés, le proxy renverra une excepti
 Dans l'exemple qui suit, on intercepte la définition d'une nouvelle propriété.
 
 ```js
-var p = new Proxy({}, {
-  set: function(target, prop, value, receiver) {
-    target[prop] = value;
-    console.log('property set: ' + prop + ' = ' + value);
-    return true;
-  }
-});
-
-console.log('a' in p);  // false
-
-p.a = 10;               // "property set: a = 10"
-console.log('a' in p);  // true
-console.log(p.a);       // 10
+var p = new Proxy(
+  {},
+  {
+    set: function (target, prop, value, receiver) {
+      target[prop] = value;
+      console.log("property set: " + prop + " = " + value);
+      return true;
+    },
+  },
+);
+
+console.log("a" in p); // false
+
+p.a = 10; // "property set: a = 10"
+console.log("a" in p); // true
+console.log(p.a); // 10
 ```
 
 ## Spécifications

diff --git a/.../fr/web/javascript/reference/global_objects/proxy/proxy/setprototypeof/index.md b/.../fr/web/javascript/reference/global_objects/proxy/proxy/setprototypeof/index.md
@@ -14,8 +14,7 @@ La méthode **`handler.setPrototypeOf()`** est une trappe pour intercepter {{jsx
 
 ```js
 var p = new Proxy(cible, {
-  setPrototypeOf: function(cible, prototype) {
-  }
+  setPrototypeOf: function (cible, prototype) {},
 });
 ```
 
@@ -57,12 +56,13 @@ Avec cette première approche, toute opération qui voudra modifier le prototype
 
 ```js
 var handlerReturnsFalse = {
-    setPrototypeOf(target, newProto) {
-        return false;
-    }
+  setPrototypeOf(target, newProto) {
+    return false;
+  },
 };
 
-var newProto = {}, target = {};
+var newProto = {},
+  target = {};
 
 var p1 = new Proxy(target, handlerReturnsFalse);
 Object.setPrototypeOf(p1, newProto);
@@ -75,12 +75,13 @@ Avec cette seconde approche, toute tentative de modification génèrera une exce
 
 ```js
 var handlerThrows = {
-    setPrototypeOf(target, newProto) {
-        throw new Error("erreur custom");
-    }
+  setPrototypeOf(target, newProto) {
+    throw new Error("erreur custom");
+  },
 };
 
-var newProto = {}, target = {};
+var newProto = {},
+  target = {};
 
 var p2 = new Proxy(target, handlerThrows);
 Object.setPrototypeOf(p2, newProto);

diff --git a/files/fr/web/javascript/reference/global_objects/proxy/revocable/index.md b/files/fr/web/javascript/reference/global_objects/proxy/revocable/index.md
@@ -41,20 +41,23 @@ Si la fonction `revoke()` est appelée, le proxy devient inutilisable et toutes
 ### Utiliser `Proxy.revocable()`
 
 ```js
-let revocable = Proxy.revocable({}, {
-  get: function(cible, nom) {
-    return "[[" + nom + "]]";
-  }
-});
+let revocable = Proxy.revocable(
+  {},
+  {
+    get: function (cible, nom) {
+      return "[[" + nom + "]]";
+    },
+  },
+);
 let proxy = revocable.proxy;
 console.log(proxy.toto); // "[[toto]]"
 
 revocable.revoke();
 
 console.log(proxy.toto); // TypeError est levée
-proxy.toto = 1;          // TypeError à nouveau
-delete proxy.toto;       // TypeError toujours
-typeof proxy;            // "object", typeof ne déclenche aucune trappe
+proxy.toto = 1; // TypeError à nouveau
+delete proxy.toto; // TypeError toujours
+typeof proxy; // "object", typeof ne déclenche aucune trappe
 ```
 
 ## Spécifications

diff --git a/files/fr/web/javascript/reference/global_objects/rangeerror/index.md b/files/fr/web/javascript/reference/global_objects/rangeerror/index.md
@@ -45,17 +45,18 @@ Par exemple, cela peut être le cas quand&nbsp;:
 ```js
 const MIN = 200;
 const MAX = 300;
-function verifier( num ) {
-  if( num < MIN || num > MAX ) {
-    throw new RangeError( "Le paramètre doit être compris entre " + MIN + " et " + MAX );
+function verifier(num) {
+  if (num < MIN || num > MAX) {
+    throw new RangeError(
+      "Le paramètre doit être compris entre " + MIN + " et " + MAX,
+    );
   }
-};
+}
 
 try {
   verifier(500);
-}
-catch (e) {
-  if (e instanceof RangeError ){
+} catch (e) {
+  if (e instanceof RangeError) {
     // On gère ce qui se passe en cas d'erreur
   }
 }
@@ -64,17 +65,18 @@ catch (e) {
 ### Utiliser `RangeError` avec des valeurs non-numériques
 
 ```js
-function verifier(valeur){
-  if(["pomme", "banane", "carotte"].includes(valeur) === false){
-    throw new RangeError("L'argument n'est pas un fruit parmi pomme / banane ou carotte.");
+function verifier(valeur) {
+  if (["pomme", "banane", "carotte"].includes(valeur) === false) {
+    throw new RangeError(
+      "L'argument n'est pas un fruit parmi pomme / banane ou carotte.",
+    );
   }
 }
 
 try {
   verifier("chou");
-}
-catch(erreur) {
-  if(erreur instanceof RangeError){
+} catch (erreur) {
+  if (erreur instanceof RangeError) {
     //On gère ce qui se passe en cas d'erreur
   }
 }

diff --git a/files/fr/web/javascript/reference/global_objects/rangeerror/rangeerror/index.md b/files/fr/web/javascript/reference/global_objects/rangeerror/rangeerror/index.md
@@ -11,10 +11,10 @@ Le constructeur **`RangeError()`** permet de créer une erreur lorsqu'une valeur
 ## Syntaxe
 
 ```js
-new RangeError()
-new RangeError(message)
-new RangeError(message, nomFichier)
-new RangeError(message, nomFichier, numeroLigne)
+new RangeError();
+new RangeError(message);
+new RangeError(message, nomFichier);
+new RangeError(message, nomFichier, numeroLigne);
 ```
 
 ### Parameters
@@ -32,15 +32,14 @@ new RangeError(message, nomFichier, numeroLigne)
 
 ```js
 function verifier(n) {
-  if( !(n >= -500 && n <= 500) ) {
+  if (!(n >= -500 && n <= 500)) {
     throw new RangeError("L'argument doit être compris entre -500 et 500.");
   }
 }
 
 try {
   verifier(2000);
-}
-catch(error) {
+} catch (error) {
   if (error instanceof RangeError) {
     // Gérer l'erreur
   }
@@ -51,16 +50,17 @@ catch(error) {
 
 ```js
 function verifier(valeur) {
-  if(["pomme", "banane", "carotte"].includes(valeur) === false) {
-    throw new RangeError("L'argument doit valeur 'pomme', 'banane', ou 'carotte'.");
+  if (["pomme", "banane", "carotte"].includes(valeur) === false) {
+    throw new RangeError(
+      "L'argument doit valeur 'pomme', 'banane', ou 'carotte'.",
+    );
   }
 }
 
 try {
   verifier("chou");
-}
-catch(error) {
-  if(error instanceof RangeError) {
+} catch (error) {
+  if (error instanceof RangeError) {
     // Gérer l'erreur
   }
 }

diff --git a/files/fr/web/javascript/reference/global_objects/referenceerror/index.md b/files/fr/web/javascript/reference/global_objects/referenceerror/index.md
@@ -37,28 +37,28 @@ try {
   let a = variableNonDefinie;
 } catch (e) {
   console.log(e instanceof ReferenceError); // true
-  console.log(e.message);                   // "variableNonDefinie is not defined"
-  console.log(e.name);                      // "ReferenceError"
-  console.log(e.fileName);                  // "Scratchpad/1"
-  console.log(e.lineNumber);                // 2
-  console.log(e.columnNumber);              // 6
-  console.log(e.stack);                     // "@Scratchpad/2:2:7\n"
+  console.log(e.message); // "variableNonDefinie is not defined"
+  console.log(e.name); // "ReferenceError"
+  console.log(e.fileName); // "Scratchpad/1"
+  console.log(e.lineNumber); // 2
+  console.log(e.columnNumber); // 6
+  console.log(e.stack); // "@Scratchpad/2:2:7\n"
 }
 ```
 
 ### Créer une exception `ReferenceError`
 
 ```js
 try {
-  throw new ReferenceError('Bonjour', 'unFichier.js', 10);
+  throw new ReferenceError("Bonjour", "unFichier.js", 10);
 } catch (e) {
   console.log(e instanceof ReferenceError); // true
-  console.log(e.message);                   // "Bonjour"
-  console.log(e.name);                      // "ReferenceError"
-  console.log(e.fileName);                  // "unFichier.js"
-  console.log(e.lineNumber);                // 10
-  console.log(e.columnNumber);              // 0
-  console.log(e.stack);                     // "@Scratchpad/2:2:9\n"
+  console.log(e.message); // "Bonjour"
+  console.log(e.name); // "ReferenceError"
+  console.log(e.fileName); // "unFichier.js"
+  console.log(e.lineNumber); // 10
+  console.log(e.columnNumber); // 0
+  console.log(e.stack); // "@Scratchpad/2:2:9\n"
 }
 ```