From fca90a8dfe2408df46ccb8c7ce5abbc1d255cba8 Mon Sep 17 00:00:00 2001 From: "Queen Vinyl Da.i'gyu-Kazotetsu" Date: Fri, 28 Jul 2023 01:46:33 -0700 Subject: [PATCH] fr: Format /web/javascript using Prettier (part 7) (#14645) --- .../global_objects/math/log10/index.md | 18 +- .../global_objects/math/log10e/index.md | 2 +- .../global_objects/math/log1p/index.md | 14 +- .../global_objects/math/log2/index.md | 12 +- .../global_objects/math/log2e/index.md | 2 +- .../global_objects/math/min/index.md | 3 +- .../reference/global_objects/math/pi/index.md | 2 +- .../global_objects/math/pow/index.md | 4 +- .../global_objects/math/random/index.md | 4 +- .../global_objects/math/round/index.md | 8 +- .../global_objects/math/sign/index.md | 18 +- .../global_objects/math/sin/index.md | 6 +- .../global_objects/math/sinh/index.md | 20 +- .../global_objects/math/sqrt/index.md | 10 +- .../global_objects/math/sqrt1_2/index.md | 2 +- .../global_objects/math/sqrt2/index.md | 2 +- .../global_objects/math/tan/index.md | 6 +- .../global_objects/math/tanh/index.md | 39 ++- .../global_objects/math/trunc/index.md | 18 +- .../reference/global_objects/nan/index.md | 12 +- .../global_objects/number/epsilon/index.md | 4 +- .../reference/global_objects/number/index.md | 26 +- .../global_objects/number/isfinite/index.md | 47 +-- .../global_objects/number/isinteger/index.md | 38 ++- .../global_objects/number/isnan/index.md | 8 +- .../number/issafeinteger/index.md | 18 +- .../number/max_safe_integer/index.md | 4 +- .../global_objects/number/max_value/index.md | 4 +- .../number/min_safe_integer/index.md | 5 +- .../global_objects/number/min_value/index.md | 4 +- .../global_objects/number/nan/index.md | 2 +- .../number/negative_infinity/index.md | 4 +- .../global_objects/number/number/index.md | 10 +- .../global_objects/number/parsefloat/index.md | 4 +- .../global_objects/number/parseint/index.md | 2 +- .../number/positive_infinity/index.md | 4 +- .../number/toexponential/index.md | 8 +- .../global_objects/number/tofixed/index.md | 24 +- .../number/tolocalestring/index.md | 29 +- .../number/toprecision/index.md | 12 +- .../global_objects/number/tostring/index.md | 15 +- .../global_objects/number/valueof/index.md | 6 +- .../object/__definegetter__/index.md | 19 +- .../object/__definesetter__/index.md | 23 +- .../object/__lookupgetter__/index.md | 10 +- .../object/__lookupsetter__/index.md | 8 +- .../global_objects/object/assign/index.md | 53 ++-- .../object/constructor/index.md | 53 ++-- .../global_objects/object/create/index.md | 53 ++-- .../object/defineproperties/index.md | 31 +- .../object/defineproperty/index.md | 193 +++++++----- .../global_objects/object/entries/index.md | 40 ++- .../global_objects/object/freeze/index.md | 42 ++- .../object/fromentries/index.md | 14 +- .../object/getownpropertydescriptor/index.md | 15 +- .../object/getownpropertydescriptors/index.md | 15 +- .../object/getownpropertynames/index.md | 39 +-- .../object/getownpropertysymbols/index.md | 6 +- .../object/getprototypeof/index.md | 2 +- .../global_objects/object/hasown/index.md | 44 +-- .../object/hasownproperty/index.md | 46 ++- .../reference/global_objects/object/index.md | 2 +- .../global_objects/object/is/index.md | 29 +- .../object/isextensible/index.md | 2 +- .../global_objects/object/isfrozen/index.md | 2 +- .../object/isprototypeof/index.md | 2 +- .../global_objects/object/issealed/index.md | 10 +- .../global_objects/object/keys/index.md | 22 +- .../global_objects/object/object/index.md | 4 +- .../object/preventextensions/index.md | 2 +- .../object/propertyisenumerable/index.md | 50 +-- .../global_objects/object/proto/index.md | 21 +- .../global_objects/object/seal/index.md | 14 +- .../object/setprototypeof/index.md | 86 ++--- .../object/tolocalestring/index.md | 2 +- .../global_objects/object/tostring/index.md | 28 +- .../global_objects/object/valueof/index.md | 14 +- .../global_objects/object/values/index.md | 17 +- .../global_objects/parsefloat/index.md | 31 +- .../global_objects/parseint/index.md | 31 +- .../global_objects/promise/all/index.md | 75 +++-- .../global_objects/promise/any/index.md | 37 ++- .../global_objects/promise/catch/index.md | 85 ++--- .../global_objects/promise/finally/index.md | 22 +- .../reference/global_objects/promise/index.md | 167 ++++++---- .../global_objects/promise/promise/index.md | 2 +- .../global_objects/promise/race/index.md | 78 ++--- .../global_objects/promise/reject/index.md | 13 +- .../global_objects/promise/resolve/index.md | 80 +++-- .../global_objects/promise/then/index.md | 20 +- .../reference/global_objects/proxy/index.md | 297 +++++++++--------- .../global_objects/proxy/proxy/apply/index.md | 11 +- .../proxy/proxy/construct/index.md | 30 +- .../proxy/proxy/defineproperty/index.md | 16 +- .../proxy/proxy/deleteproperty/index.md | 18 +- .../global_objects/proxy/proxy/get/index.md | 26 +- .../proxy/getownpropertydescriptor/index.md | 24 +- .../proxy/proxy/getprototypeof/index.md | 40 +-- .../global_objects/proxy/proxy/has/index.md | 24 +- .../proxy/proxy/isextensible/index.md | 33 +- 100 files changed, 1455 insertions(+), 1198 deletions(-) diff --git a/files/fr/web/javascript/reference/global_objects/math/log10/index.md b/files/fr/web/javascript/reference/global_objects/math/log10/index.md index a9c5f3901523ff..f0b406e6475ae1 100644 --- a/files/fr/web/javascript/reference/global_objects/math/log10/index.md +++ b/files/fr/web/javascript/reference/global_objects/math/log10/index.md @@ -15,7 +15,7 @@ La fonction **`Math.log10()`** renvoie le logarithme en base 10 d'un nombre, don ## Syntaxe ```js -Math.log10(x) +Math.log10(x); ``` ### Paramètres @@ -38,10 +38,10 @@ Si la valeur de l'argument est strictement inférieure à 0, la valeur renvoyée ### Utiliser `Math.log10()` ```js -Math.log10(2); // 0.3010299956639812 -Math.log10(1); // 0 -Math.log10(0); // -Infinity -Math.log10(-2); // NaN +Math.log10(2); // 0.3010299956639812 +Math.log10(1); // 0 +Math.log10(0); // -Infinity +Math.log10(-2); // NaN Math.log10(100000); // 5 ``` @@ -50,9 +50,11 @@ Math.log10(100000); // 5 Il est possible d'avoir un résultat approximatif avec la fonction suivante : ```js -Math.log10 = Math.log10 || function(x) { - return Math.log(x) * Math.LOG10E; -}; +Math.log10 = + Math.log10 || + function (x) { + return Math.log(x) * Math.LOG10E; + }; ``` ## Spécifications diff --git a/files/fr/web/javascript/reference/global_objects/math/log10e/index.md b/files/fr/web/javascript/reference/global_objects/math/log10e/index.md index 0456dd9d3d985e..95c415f05f586d 100644 --- a/files/fr/web/javascript/reference/global_objects/math/log10e/index.md +++ b/files/fr/web/javascript/reference/global_objects/math/log10e/index.md @@ -24,7 +24,7 @@ La fonction suivante renvoie le logarithme en base 10 de e : ```js function getLog10e() { - return Math.LOG10E; + return Math.LOG10E; } getLog10e(); // 0.4342944819032518 diff --git a/files/fr/web/javascript/reference/global_objects/math/log1p/index.md b/files/fr/web/javascript/reference/global_objects/math/log1p/index.md index a9bb67b65480dd..3cdc5ac368834b 100644 --- a/files/fr/web/javascript/reference/global_objects/math/log1p/index.md +++ b/files/fr/web/javascript/reference/global_objects/math/log1p/index.md @@ -15,7 +15,7 @@ La fonction **`Math.log1p()`** renvoie le logarithme népérien (en base {{jsxre ## Syntaxe ```js -Math.log1p(x) +Math.log1p(x); ``` ### Paramètres @@ -38,8 +38,8 @@ Si `x` est strictement inférieur à -1, la valeur renvoyée est {{jsxref("NaN") ### Utiliser `Math.log1p()` ```js -Math.log1p(1); // 0.6931471805599453 -Math.log1p(0); // 0 +Math.log1p(1); // 0.6931471805599453 +Math.log1p(0); // 0 Math.log1p(-1); // -Infinity Math.log1p(-2); // NaN ``` @@ -49,9 +49,11 @@ Math.log1p(-2); // NaN Si cette fonction n'est pas disponible, elle peut être définie grâce au code suivant : ```js -Math.log1p = Math.log1p || function(x) { - return Math.log(1 + x); -}; +Math.log1p = + Math.log1p || + function (x) { + return Math.log(1 + x); + }; ``` ## Spécifications 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 b895cf0ffddb92..681ef2abd49ae8 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 @@ -15,7 +15,7 @@ La fonction **`Math.log2()`** renvoie le logarithme en base 2 d'un nombre : ## Syntaxe ```js -Math.log2(x) +Math.log2(x); ``` ### Paramètres @@ -38,11 +38,11 @@ Si `x` est strictement inférieur à 0, la valeur renvoyée sera {{jsxref("NaN") ### Utiliser `Math.log2()` ```js -Math.log2(3); // 1.584962500721156 -Math.log2(2); // 1 -Math.log2(1); // 0 -Math.log2(0); // -Infinity -Math.log2(-2); // NaN +Math.log2(3); // 1.584962500721156 +Math.log2(2); // 1 +Math.log2(1); // 0 +Math.log2(0); // -Infinity +Math.log2(-2); // NaN Math.log2(1024); // 10 ``` diff --git a/files/fr/web/javascript/reference/global_objects/math/log2e/index.md b/files/fr/web/javascript/reference/global_objects/math/log2e/index.md index 92321754c5525b..c1e56c2ea4e242 100644 --- a/files/fr/web/javascript/reference/global_objects/math/log2e/index.md +++ b/files/fr/web/javascript/reference/global_objects/math/log2e/index.md @@ -24,7 +24,7 @@ La fonction suivante renvoie la valeur du logarithme en base 2 de e : ```js function getLog2e() { - return Math.LOG2E; + return Math.LOG2E; } getLog2e(); // 1.4426950408889634 diff --git a/files/fr/web/javascript/reference/global_objects/math/min/index.md b/files/fr/web/javascript/reference/global_objects/math/min/index.md index c3927c55aa604b..55c86e3db603ca 100644 --- a/files/fr/web/javascript/reference/global_objects/math/min/index.md +++ b/files/fr/web/javascript/reference/global_objects/math/min/index.md @@ -40,7 +40,8 @@ Si au moins un des arguments ne peut pas être converti en un nombre, le résult Dans cet exemple, on trouve le minimum de x et y et on affecte cette valeur à z : ```js -var x = 10, y = -20; +var x = 10, + y = -20; var z = Math.min(x, y); ``` diff --git a/files/fr/web/javascript/reference/global_objects/math/pi/index.md b/files/fr/web/javascript/reference/global_objects/math/pi/index.md index d8c8535905e636..487377bbc09c7a 100644 --- a/files/fr/web/javascript/reference/global_objects/math/pi/index.md +++ b/files/fr/web/javascript/reference/global_objects/math/pi/index.md @@ -27,7 +27,7 @@ function calculPérimètre(rayon) { return 2 * Math.PI * rayon; } -calculPérimètre(1); // 6.283185307179586 +calculPérimètre(1); // 6.283185307179586 ``` ## Spécifications diff --git a/files/fr/web/javascript/reference/global_objects/math/pow/index.md b/files/fr/web/javascript/reference/global_objects/math/pow/index.md index a7331eeab2e4a6..3e3430f7372d4b 100644 --- a/files/fr/web/javascript/reference/global_objects/math/pow/index.md +++ b/files/fr/web/javascript/reference/global_objects/math/pow/index.md @@ -43,12 +43,12 @@ Math.pow(7, 2); // 49 Math.pow(7, -2); // 0.02040816326530612 (1/49) // Exposants fractionnaires -Math.pow(2, 1/2); // 1.4142135623730951 (racine carrée de 2) +Math.pow(2, 1 / 2); // 1.4142135623730951 (racine carrée de 2) // Cas aux limites Math.pow(-7, 0.5); // NaN // (les nombres négatifs n'ont pas de racine carrée) -Math.pow(-7, 1/3); // NaN +Math.pow(-7, 1 / 3); // NaN // Nombre négatif avec une base décimale ``` diff --git a/files/fr/web/javascript/reference/global_objects/math/random/index.md b/files/fr/web/javascript/reference/global_objects/math/random/index.md index fe084f9aa242b4..fa70b7efe7a217 100644 --- a/files/fr/web/javascript/reference/global_objects/math/random/index.md +++ b/files/fr/web/javascript/reference/global_objects/math/random/index.md @@ -15,7 +15,7 @@ La fonction **`Math.random()`** renvoie un nombre flottant pseudo-aléatoire com ## Syntaxe ```js -Math.random() +Math.random(); ``` ### Valeur de retour @@ -71,7 +71,7 @@ function getRandomInt(min, max) { function getRandomIntInclusive(min, max) { min = Math.ceil(min); max = Math.floor(max); - return Math.floor(Math.random() * (max - min +1)) + min; + return Math.floor(Math.random() * (max - min + 1)) + min; } ``` diff --git a/files/fr/web/javascript/reference/global_objects/math/round/index.md b/files/fr/web/javascript/reference/global_objects/math/round/index.md index 9ce761734d3029..a57253225fab04 100644 --- a/files/fr/web/javascript/reference/global_objects/math/round/index.md +++ b/files/fr/web/javascript/reference/global_objects/math/round/index.md @@ -13,7 +13,7 @@ La fonction **`Math.round()`** retourne la valeur d'un nombre arrondi à l'entie ## Syntaxe ```js -Math.round(x) +Math.round(x); ``` ### Paramètres @@ -35,10 +35,10 @@ Si la partie décimale du nombre est plus grande que 0.5, l'argument est arrondi ```js Math.round(20.49); // 20 -Math.round(20.5); // 21 -Math.round(42); // 42 +Math.round(20.5); // 21 +Math.round(42); // 42 Math.round(-20.5); // -20 -Math.round(-20.51);// -21 +Math.round(-20.51); // -21 ``` ## Spécifications 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 c56848eea1a340..31139df4cb27b9 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 @@ -13,7 +13,7 @@ La fonction **`Math.sign()`** renvoie le signe d'un nombre et permet de savoir s ## Syntaxe ```js -Math.sign(x) +Math.sign(x); ``` ### Paramètres @@ -36,14 +36,14 @@ L'argument passé à cette fonction sera implicitement converti au type `number` ## Exemples ```js -Math.sign(3) // 1 -Math.sign(-3) // -1 -Math.sign("-3") // -1 -Math.sign(0) // 0 -Math.sign(-0) // -0 -Math.sign(NaN) // NaN -Math.sign("foo") // NaN -Math.sign() // NaN +Math.sign(3); // 1 +Math.sign(-3); // -1 +Math.sign("-3"); // -1 +Math.sign(0); // 0 +Math.sign(-0); // -0 +Math.sign(NaN); // NaN +Math.sign("foo"); // NaN +Math.sign(); // NaN ``` ## Spécifications diff --git a/files/fr/web/javascript/reference/global_objects/math/sin/index.md b/files/fr/web/javascript/reference/global_objects/math/sin/index.md index e948186ac70c70..4a0a16a817f6a4 100644 --- a/files/fr/web/javascript/reference/global_objects/math/sin/index.md +++ b/files/fr/web/javascript/reference/global_objects/math/sin/index.md @@ -13,7 +13,7 @@ La fonction **`Math.sin()`** renvoie le sinus d'un nombre. ## Syntaxe ```js -Math.sin(x) +Math.sin(x); ``` ### Paramètres @@ -34,8 +34,8 @@ La méthode `sin()` renvoie une valeur numérique comprise (au sens large) entre ## Exemples ```js -Math.sin(0); // 0 -Math.sin(1); // 0.8414709848078965 +Math.sin(0); // 0 +Math.sin(1); // 0.8414709848078965 Math.sin(Math.PI / 2); // 1 ``` 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 1524b4e44d7d21..5ec0bff22d8a69 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 @@ -15,7 +15,7 @@ La fonction **`Math.sinh()`** renvoie le sinus hyperbolique d'un nombre, dont la ## Syntaxe ```js -Math.sinh(x) +Math.sinh(x); ``` ### Paramètres @@ -34,8 +34,8 @@ Le sinus hyperbolique de la valeur passée en argument. ## Exemples ```js -Math.sinh(0) // 0 -Math.sinh(1) // 1.1752011936438014 +Math.sinh(0); // 0 +Math.sinh(1); // 1.1752011936438014 ``` ## Prothèse d'émulation (_polyfill_) @@ -43,18 +43,22 @@ Math.sinh(1) // 1.1752011936438014 Si cette fonction n'est pas disponible, elle peut être émulée en utilisant la fonction {{jsxref("Math.exp()")}} : ```js -Math.sinh = Math.sinh || function(x){ +Math.sinh = + Math.sinh || + function (x) { return (Math.exp(x) - Math.exp(-x)) / 2; -}; + }; ``` ou encore, si on n'utilise qu'une fois {{jsxref("Math.exp()")}}, avec : ```js -Math.sinh = Math.sinh || function(x){ +Math.sinh = + Math.sinh || + function (x) { var y = Math.exp(x); - return (y - 1/y) / 2; -}; + return (y - 1 / y) / 2; + }; ``` ## Spécifications diff --git a/files/fr/web/javascript/reference/global_objects/math/sqrt/index.md b/files/fr/web/javascript/reference/global_objects/math/sqrt/index.md index 3806d072afc9ed..37791e181aa1c1 100644 --- a/files/fr/web/javascript/reference/global_objects/math/sqrt/index.md +++ b/files/fr/web/javascript/reference/global_objects/math/sqrt/index.md @@ -15,7 +15,7 @@ La fonction **`Math.sqrt()`** renvoie la racine carrée d'un nombre. Cette fonct ## Syntaxe ```js -Math.sqrt(x) +Math.sqrt(x); ``` ### Paramètres @@ -36,11 +36,11 @@ Si la valeur de `x` est négative, `sqrt` renverra {{jsxref("NaN")}}. ## Exemples ```js -Math.sqrt(9); // 3 -Math.sqrt(2); // 1.414213562373095 +Math.sqrt(9); // 3 +Math.sqrt(2); // 1.414213562373095 -Math.sqrt(1); // 1 -Math.sqrt(0); // 0 +Math.sqrt(1); // 1 +Math.sqrt(0); // 0 Math.sqrt(-1); // NaN Math.sqrt(-0); // -0 ``` diff --git a/files/fr/web/javascript/reference/global_objects/math/sqrt1_2/index.md b/files/fr/web/javascript/reference/global_objects/math/sqrt1_2/index.md index 2cfcc1448d2732..c2e81737ff2f26 100644 --- a/files/fr/web/javascript/reference/global_objects/math/sqrt1_2/index.md +++ b/files/fr/web/javascript/reference/global_objects/math/sqrt1_2/index.md @@ -22,7 +22,7 @@ La fonction suivante renvoie la valeur de cette constante : ```js function getRoot1_2() { - return Math.SQRT1_2; + return Math.SQRT1_2; } getRoot1_2(); // 0.7071067811865476 diff --git a/files/fr/web/javascript/reference/global_objects/math/sqrt2/index.md b/files/fr/web/javascript/reference/global_objects/math/sqrt2/index.md index 6cc3ffc189e8ab..b64763679ea920 100644 --- a/files/fr/web/javascript/reference/global_objects/math/sqrt2/index.md +++ b/files/fr/web/javascript/reference/global_objects/math/sqrt2/index.md @@ -22,7 +22,7 @@ La fonction suivante renvoie la valeur de la racine carrée de 2 : ```js function getRoot2() { - return Math.SQRT2; + return Math.SQRT2; } getRoot2(); // 1.4142135623730951 diff --git a/files/fr/web/javascript/reference/global_objects/math/tan/index.md b/files/fr/web/javascript/reference/global_objects/math/tan/index.md index 7b261b4bb548d8..5ff8d3ee401f52 100644 --- a/files/fr/web/javascript/reference/global_objects/math/tan/index.md +++ b/files/fr/web/javascript/reference/global_objects/math/tan/index.md @@ -13,7 +13,7 @@ La fonction **`Math.tan()`** renvoie la tangente d'un nombre exprimant un angle ## Syntaxe ```js -Math.tan(x) +Math.tan(x); ``` ### Paramètres @@ -43,8 +43,8 @@ Math.tan(1); // 1.5574077246549023 ```js function getTanDeg(deg) { - var rad = deg * Math.PI/180; - return Math.tan(rad); + var rad = (deg * Math.PI) / 180; + return Math.tan(rad); } ``` 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 cbf3994befbe5e..56cd4e356d7861 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 @@ -15,7 +15,7 @@ La fonction **`Math.tanh()`** renvoie la tangente hyperbolique d'un nombre défi ## Syntaxe ```js -Math.tanh(x) +Math.tanh(x); ``` ### Paramètres @@ -36,9 +36,9 @@ La tangente hyperbolique du nombre fourni en argument. ### Utiliser `Math.tanh()` ```js -Math.tanh(0); // 0 +Math.tanh(0); // 0 Math.tanh(Infinity); // 1 -Math.tanh(1); // 0.7615941559557649 +Math.tanh(1); // 0.7615941559557649 ``` ## Prothèse d'émulation (_polyfill_) @@ -46,25 +46,30 @@ Math.tanh(1); // 0.7615941559557649 Cette méthode peut être émulée grâce à la fonction {{jsxref("Objets_globaux/Math/exp", "Math.exp()")}} : ```js -Math.tanh = Math.tanh || function(x){ - var a = Math.exp(+x), b = Math.exp(-x); - return a == Infinity ? 1 : b == Infinity ? -1 : (a - b) / (a + b); -} +Math.tanh = + Math.tanh || + function (x) { + var a = Math.exp(+x), + b = Math.exp(-x); + return a == Infinity ? 1 : b == Infinity ? -1 : (a - b) / (a + b); + }; ``` et si on souhaite n'utiliser qu'un seul appel à {{jsxref("Objets_globaux/Math/exp", "Math.exp()")}} : ```js -Math.tanhx = Math.tanhx || function(x) { - if(x === Infinity) { - return 1; - } else if(x === -Infinity) { - return -1; - } else { - var y = Math.exp(2 * x); - return (y - 1) / (y + 1); - } -}; +Math.tanhx = + Math.tanhx || + function (x) { + if (x === Infinity) { + return 1; + } else if (x === -Infinity) { + return -1; + } else { + var y = Math.exp(2 * x); + return (y - 1) / (y + 1); + } + }; ``` ## Spécifications diff --git a/files/fr/web/javascript/reference/global_objects/math/trunc/index.md b/files/fr/web/javascript/reference/global_objects/math/trunc/index.md index 54246d80e085fc..647218a0142d48 100644 --- a/files/fr/web/javascript/reference/global_objects/math/trunc/index.md +++ b/files/fr/web/javascript/reference/global_objects/math/trunc/index.md @@ -15,7 +15,7 @@ La fonction **`Math.trunc()`** retourne la troncature entière d'un nombre en re ## Syntaxe ```js -Math.trunc(x) +Math.trunc(x); ``` ### Paramètres @@ -42,14 +42,14 @@ On notera que l'argument passé à la méthode est converti en nombre de façon ### Utiliser `Math.trunc()` ```js -Math.trunc(13.37); // 13 -Math.trunc(42.84); // 42 -Math.trunc(0.123); // 0 -Math.trunc(-0.123); // -0 -Math.trunc("-1.123");// -1 -Math.trunc(NaN); // NaN -Math.trunc("toto"); // NaN -Math.trunc(); // NaN +Math.trunc(13.37); // 13 +Math.trunc(42.84); // 42 +Math.trunc(0.123); // 0 +Math.trunc(-0.123); // -0 +Math.trunc("-1.123"); // -1 +Math.trunc(NaN); // NaN +Math.trunc("toto"); // NaN +Math.trunc(); // NaN ``` ## Spécifications diff --git a/files/fr/web/javascript/reference/global_objects/nan/index.md b/files/fr/web/javascript/reference/global_objects/nan/index.md index 157202d88fe26b..f7ac7369586616 100644 --- a/files/fr/web/javascript/reference/global_objects/nan/index.md +++ b/files/fr/web/javascript/reference/global_objects/nan/index.md @@ -15,7 +15,7 @@ La propriété globale **`NaN`** est une valeur utilisée pour représenter une ## Syntaxe ```js -NaN +NaN; ``` ## Description @@ -31,17 +31,17 @@ Il est rare d'utiliser expressément `NaN` dans un programme. On récupère gén Les [opérateurs d'égalité](/fr/docs/Web/JavaScript/Les_différents_tests_d_égalité_comment_les_utiliser) (`==` et `===`) ne peuvent pas être utilisé pour tester une valeur par rapport à `NaN`. Il faut utiliser {{jsxref("Number.isNaN()")}} ou {{jsxref("isNaN", "isNaN()")}} à la place. ```js -NaN === NaN; // false +NaN === NaN; // false Number.NaN === NaN; // false -isNaN(NaN); // true -isNaN(Number.NaN); // true +isNaN(NaN); // true +isNaN(Number.NaN); // true ``` La différence entre `isNaN()` et `Number.isNaN()` est la façon dont les valeurs sont, ou non, converties en nombre avant de vérifier si la valeur est `NaN` : `isNaN()` convertira l'argument en nombre avant de vérifier alors que `Number.isNaN()` ne renverra `true` que si l'opérande vaut `NaN`. ```js -isNaN('coucou monde'); // renvoie true -Number.isNaN('coucou monde'); // renvoie false +isNaN("coucou monde"); // renvoie true +Number.isNaN("coucou monde"); // renvoie false ``` ## Spécifications diff --git a/files/fr/web/javascript/reference/global_objects/number/epsilon/index.md b/files/fr/web/javascript/reference/global_objects/number/epsilon/index.md index 6139ccfa2cc7e6..781d19e955eee0 100644 --- a/files/fr/web/javascript/reference/global_objects/number/epsilon/index.md +++ b/files/fr/web/javascript/reference/global_objects/number/epsilon/index.md @@ -23,14 +23,14 @@ La propriété `EPSILON` vaut environ `2.2204460492503130808472633361816E-16` (c ```js x = 0.2; y = 0.3; -equal = (Math.abs(x - y) < Number.EPSILON); +equal = Math.abs(x - y) < Number.EPSILON; ``` ## Prothèse d'émulation (_polyfill_) ```js if (Number.EPSILON === undefined) { - Number.EPSILON = Math.pow(2, -52); + Number.EPSILON = Math.pow(2, -52); } ``` diff --git a/files/fr/web/javascript/reference/global_objects/number/index.md b/files/fr/web/javascript/reference/global_objects/number/index.md index a80e01618c817c..7949d1522c3a07 100644 --- a/files/fr/web/javascript/reference/global_objects/number/index.md +++ b/files/fr/web/javascript/reference/global_objects/number/index.md @@ -14,8 +14,8 @@ Le type JavaScript `Number` utilise [une représentation binaire à précision d ```js new Number(valeur); -var a = new Number('123'); // a === 123 donnera false -var b = Number('123'); // b === 123 donnera true +var a = new Number("123"); // a === 123 donnera false +var b = Number("123"); // b === 123 donnera true a instanceof Number; // donnera true b instanceof Number; // donnera false ``` @@ -119,7 +119,7 @@ Lorsqu'on analyse et convertit des données JSON, les valeurs en dehors de cet i Dans l'exemple suivant, on convertit un objet {{jsxref("Date")}} en une valeur numérique grâce à la fonction `Number` : ```js -var d = new Date('December 17, 1995 03:24:00'); +var d = new Date("December 17, 1995 03:24:00"); console.log(Number(d)); ``` @@ -128,16 +128,16 @@ Ceci affichera "819167040000". ### Convertir une chaîne représentant une valeur numérique en un nombre ```js -Number("123"); // 123 -Number("12.3"); // 12.3 -Number("12.00"); // 12 -Number("123e-1"); // 12.3 -Number(""); // 0 -Number("0x11"); // 17 -Number("0b11"); // 3 -Number("0o11"); // 9 -Number("toto"); // NaN -Number("100a"); // NaN +Number("123"); // 123 +Number("12.3"); // 12.3 +Number("12.00"); // 12 +Number("123e-1"); // 12.3 +Number(""); // 0 +Number("0x11"); // 17 +Number("0b11"); // 3 +Number("0o11"); // 9 +Number("toto"); // NaN +Number("100a"); // NaN Number("-Infinity"); // -Infinity ``` 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 23a5d743097d85..02a5b349aa1936 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,18 +32,18 @@ Par rapport à la fonction de l'objet global {{jsxref("isFinite","isFinite()")}} ## Exemples ```js -Number.isFinite(Infinity); // false -Number.isFinite(NaN); // false +Number.isFinite(Infinity); // false +Number.isFinite(NaN); // false Number.isFinite(-Infinity); // false -Number.isFinite(0); // true -Number.isFinite(2e64); // true +Number.isFinite(0); // true +Number.isFinite(2e64); // true -Number.isFinite("0"); // false, ce qui aurait - // renvoyé true avec isFinite("0") +Number.isFinite("0"); // false, ce qui aurait +// renvoyé true avec isFinite("0") -Number.isFinite(null); // false, ce qui aurait - // renvoyé true avc isFinite(null) +Number.isFinite(null); // false, ce qui aurait +// renvoyé true avc isFinite(null) ``` ## Prothèse d'émulation (_polyfill_) @@ -51,28 +51,29 @@ Number.isFinite(null); // false, ce qui aurait ```js // Number.isFinite polyfill // http://people.mozilla.org/~jorendorff/es6-draft.html#sec-number.isfinite -if (typeof Number.isFinite !== 'function') { - Number.isFinite = function isFinite(value) { - // 1. Si Type(number) n'est pas Number, on renvoie false. - if (typeof value !== 'number') { - return false; - } - // 2. Si le nombre est NaN, +∞, ou −∞, on renvoie false. - if (value !== value || value === Infinity || value === -Infinity) { - return false; - } - // 3. Sinon on renvoie true. - return true; - }; +if (typeof Number.isFinite !== "function") { + Number.isFinite = function isFinite(value) { + // 1. Si Type(number) n'est pas Number, on renvoie false. + if (typeof value !== "number") { + return false; + } + // 2. Si le nombre est NaN, +∞, ou −∞, on renvoie false. + if (value !== value || value === Infinity || value === -Infinity) { + return false; + } + // 3. Sinon on renvoie true. + return true; + }; } ``` Deuxième version plus concise qui utilise la méthode globale `isFinite` ```js -if (Number.isFinite === undefined) Number.isFinite = function(value) { +if (Number.isFinite === undefined) + Number.isFinite = function (value) { return typeof value === "number" && isFinite(value); -} + }; ``` ## Spécifications diff --git a/files/fr/web/javascript/reference/global_objects/number/isinteger/index.md b/files/fr/web/javascript/reference/global_objects/number/isinteger/index.md index 6512cf17f0fb02..a42b8423eb2e0a 100644 --- a/files/fr/web/javascript/reference/global_objects/number/isinteger/index.md +++ b/files/fr/web/javascript/reference/global_objects/number/isinteger/index.md @@ -13,7 +13,7 @@ La méthode **`Number.isInteger()`** permet de déterminer si l'argument est un ## Syntaxe ```js -Number.isInteger(valeurÀTester) +Number.isInteger(valeurÀTester); ``` ### Paramètres @@ -32,33 +32,37 @@ Si la valeur à tester est un entier, cette méthode renvoie `true`, `false` sin ## Exemples ```js -Number.isInteger(1); // true -Number.isInteger(-100000); // true -Number.isInteger(0); // true -Number.isInteger(1.000) // true +Number.isInteger(1); // true +Number.isInteger(-100000); // true +Number.isInteger(0); // true +Number.isInteger(1.0); // true // Number.isInteger(9…9999); // true, même si le nombre dépasse 32 bits -Number.isInteger(0.1); // false -Number.isInteger(Math.PI); // false +Number.isInteger(0.1); // false +Number.isInteger(Math.PI); // false Number.isInteger(-Infinity); // false -Number.isInteger(true); // false -Number.isInteger(NaN); // false -Number.isInteger("10"); // false +Number.isInteger(true); // false +Number.isInteger(NaN); // false +Number.isInteger("10"); // false -Number.isInteger(5.0); // true -Number.isInteger(5.000000000000001);// false +Number.isInteger(5.0); // true +Number.isInteger(5.000000000000001); // false Number.isInteger(5.0000000000000001); // true ``` ## Prothèse d'émulation (_polyfill_) ```js -Number.isInteger = Number.isInteger || function(value) { - return typeof value === "number" && - isFinite(value) && - Math.floor(value) === value; -}; +Number.isInteger = + Number.isInteger || + function (value) { + return ( + typeof value === "number" && + isFinite(value) && + Math.floor(value) === value + ); + }; ``` ## Spécifications diff --git a/files/fr/web/javascript/reference/global_objects/number/isnan/index.md b/files/fr/web/javascript/reference/global_objects/number/isnan/index.md index 1ad8ba34a16154..9324d615dc1c79 100644 --- a/files/fr/web/javascript/reference/global_objects/number/isnan/index.md +++ b/files/fr/web/javascript/reference/global_objects/number/isnan/index.md @@ -13,7 +13,7 @@ La méthode **`Number.isNaN()`** permet de déterminer si la valeur passée en a ## Syntaxe ```js -Number.isNaN(valeurÀTester) +Number.isNaN(valeurÀTester); ``` ### Paramètres @@ -59,9 +59,11 @@ Number.isNaN("blabla"); // ex : cette valeur aurait rendu true avec la méthode La fonction suivant fonctionne car `NaN` est la seule valeur JavaScript qui n'est pas égale à elle-même. ```js -Number.isNaN = Number.isNaN || function(value) { +Number.isNaN = + Number.isNaN || + function (value) { return typeof value === "number" && isNaN(value); -} + }; ``` ## Spécifications diff --git a/files/fr/web/javascript/reference/global_objects/number/issafeinteger/index.md b/files/fr/web/javascript/reference/global_objects/number/issafeinteger/index.md index 36480757502652..e96c9624dcb0b4 100644 --- a/files/fr/web/javascript/reference/global_objects/number/issafeinteger/index.md +++ b/files/fr/web/javascript/reference/global_objects/number/issafeinteger/index.md @@ -15,7 +15,7 @@ La méthode **`Number.isSafeInteger()`** permet de déterminer si la valeur, pas ## Syntaxe ```js -Number.isSafeInteger(valeurÀTester) +Number.isSafeInteger(valeurÀTester); ``` ### Paramètres @@ -41,14 +41,14 @@ L'intervalle des entiers qui peuvent être correctement représentés est `[-(2^ ## Exemples ```js -Number.isSafeInteger(3); // true -Number.isSafeInteger(Math.pow(2, 53)) // false -Number.isSafeInteger(Math.pow(2, 53) - 1) // true -Number.isSafeInteger(NaN); // false -Number.isSafeInteger(Infinity); // false -Number.isSafeInteger("3"); // false -Number.isSafeInteger(3.1); // false -Number.isSafeInteger(3.0); // true +Number.isSafeInteger(3); // true +Number.isSafeInteger(Math.pow(2, 53)); // false +Number.isSafeInteger(Math.pow(2, 53) - 1); // true +Number.isSafeInteger(NaN); // false +Number.isSafeInteger(Infinity); // false +Number.isSafeInteger("3"); // false +Number.isSafeInteger(3.1); // false +Number.isSafeInteger(3.0); // true ``` ## Spécifications 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 043fdc0c6f22e6..b3d4c7b0b4e332 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 @@ -25,8 +25,8 @@ Dans ce contexte, « sûr » fait référence à la capacité à représenter ex ## Exemples ```js -Number.MAX_SAFE_INTEGER // 9007199254740991 -Math.pow(2, 53) -1 // 9007199254740991 +Number.MAX_SAFE_INTEGER; // 9007199254740991 +Math.pow(2, 53) - 1; // 9007199254740991 ``` ## Spécifications 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 9b1b8da13a2658..834384334788f0 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 @@ -22,9 +22,9 @@ Le code suivant teste si le produit de deux nombres est inférieur ou égal à ` ```js if (num1 * num2 <= Number.MAX_VALUE) { - func1(); + func1(); } else { - func2(); + func2(); } ``` diff --git a/files/fr/web/javascript/reference/global_objects/number/min_safe_integer/index.md b/files/fr/web/javascript/reference/global_objects/number/min_safe_integer/index.md index df9e90636b983a..0a113f9e004dac 100644 --- a/files/fr/web/javascript/reference/global_objects/number/min_safe_integer/index.md +++ b/files/fr/web/javascript/reference/global_objects/number/min_safe_integer/index.md @@ -21,8 +21,9 @@ La constante `MIN_SAFE_INTEGER` vaut `-9007199254740991`. Cette valeur provient ## Exemples ```js -Number.MIN_SAFE_INTEGER // -9007199254740991 --Math.pow(2, 53) -1 // -9007199254740991 +Number.MIN_SAFE_INTEGER - // -9007199254740991 + Math.pow(2, 53) - + 1; // -9007199254740991 ``` ## Spécifications diff --git a/files/fr/web/javascript/reference/global_objects/number/min_value/index.md b/files/fr/web/javascript/reference/global_objects/number/min_value/index.md index f04dae6fead7af..082a0e04450cdc 100644 --- a/files/fr/web/javascript/reference/global_objects/number/min_value/index.md +++ b/files/fr/web/javascript/reference/global_objects/number/min_value/index.md @@ -24,9 +24,9 @@ Le code qui suit effectue la division de deux nombres. Si le résultat obtenu es ```js if (num1 / num2 >= Number.MIN_VALUE) { - func1(); + func1(); } else { - func2(); + func2(); } ``` diff --git a/files/fr/web/javascript/reference/global_objects/number/nan/index.md b/files/fr/web/javascript/reference/global_objects/number/nan/index.md index 91739a2f4d762d..96fca95e2fc9d3 100644 --- a/files/fr/web/javascript/reference/global_objects/number/nan/index.md +++ b/files/fr/web/javascript/reference/global_objects/number/nan/index.md @@ -6,7 +6,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Number/NaN {{JSRef}} -La propriété **`Number.NaN`** représente une valeur qui n'est pas un nombre (en anglais « *Not-A-Number* » qui donne NaN). Elle est équivalente à {{jsxref("NaN")}}. +La propriété **`Number.NaN`** représente une valeur qui n'est pas un nombre (en anglais « _Not-A-Number_ » qui donne NaN). Elle est équivalente à {{jsxref("NaN")}}. {{EmbedInteractiveExample("pages/js/number-nan.html")}} diff --git a/files/fr/web/javascript/reference/global_objects/number/negative_infinity/index.md b/files/fr/web/javascript/reference/global_objects/number/negative_infinity/index.md index 4752c6249e65ae..eea997c31737fd 100644 --- a/files/fr/web/javascript/reference/global_objects/number/negative_infinity/index.md +++ b/files/fr/web/javascript/reference/global_objects/number/negative_infinity/index.md @@ -35,10 +35,10 @@ La propriété `Number.NEGATIVE_INFINITY` peut être utilisée pour indiquer une Dans l'exemple qui suit, on affecte une variable inférieure à la valeur numérique minimale à la variable `petitNombre`. Lorsque l'instruction conditionnelle `if` est exécutée, `petitNombre` possède la valeur "`-Infinity`", on modifie donc la valeur de `petitNombre` afin qu'il puisse être géré. ```js -var petitNombre = (-Number.MAX_VALUE) * 2 +var petitNombre = -Number.MAX_VALUE * 2; if (petitNombre === Number.NEGATIVE_INFINITY) { - petitNombre = renvoyerUneValeurFinie(); + petitNombre = renvoyerUneValeurFinie(); } ``` diff --git a/files/fr/web/javascript/reference/global_objects/number/number/index.md b/files/fr/web/javascript/reference/global_objects/number/number/index.md index 6d0128b02595f2..c7248341f19acd 100644 --- a/files/fr/web/javascript/reference/global_objects/number/number/index.md +++ b/files/fr/web/javascript/reference/global_objects/number/number/index.md @@ -11,7 +11,7 @@ Le **constructeur `Number()`** permet de créer un objet [`Number`](/fr/docs/Web ## Syntaxe ```js -new Number(valeur) +new Number(valeur); ``` ### Paramètres @@ -24,10 +24,10 @@ new Number(valeur) ### Créer des objets `Number` ```js -const a = new Number('123'); // a === 123 vaut false -const b = Number('123'); // b === 123 vaut true -a instanceof Number; // true -b instanceof Number; // false +const a = new Number("123"); // a === 123 vaut false +const b = Number("123"); // b === 123 vaut true +a instanceof Number; // true +b instanceof Number; // false ``` ## Spécifications diff --git a/files/fr/web/javascript/reference/global_objects/number/parsefloat/index.md b/files/fr/web/javascript/reference/global_objects/number/parsefloat/index.md index 86af8ff4996c09..8370c1400a998e 100644 --- a/files/fr/web/javascript/reference/global_objects/number/parsefloat/index.md +++ b/files/fr/web/javascript/reference/global_objects/number/parsefloat/index.md @@ -13,7 +13,7 @@ La méthode **`Number.parseFloat()`** analyse et convertit une chaîne de caract ## Syntaxe ```js -Number.parseFloat(chaîne) +Number.parseFloat(chaîne); ``` ### Paramètres @@ -39,7 +39,7 @@ Cette méthode fait partie d'ECMAScript 2015 et notamment de la modularisation d ```js if (Number.parseFloat === undefined) { - Number.parseFloat = parseFloat; + Number.parseFloat = parseFloat; } ``` diff --git a/files/fr/web/javascript/reference/global_objects/number/parseint/index.md b/files/fr/web/javascript/reference/global_objects/number/parseint/index.md index 3a7166a95f7942..6607b4cba06308 100644 --- a/files/fr/web/javascript/reference/global_objects/number/parseint/index.md +++ b/files/fr/web/javascript/reference/global_objects/number/parseint/index.md @@ -40,7 +40,7 @@ Number.parseInt === parseInt; // true Si on souhaite bénéficier de cette fonction dans un environnement qui n'en dispose pas, on pourra donc l'émuler de la façon suivante : ```js -if(Number.parseInt === undefined) { +if (Number.parseInt === undefined) { Number.parseInt = parseInt; } ``` diff --git a/files/fr/web/javascript/reference/global_objects/number/positive_infinity/index.md b/files/fr/web/javascript/reference/global_objects/number/positive_infinity/index.md index 3719dc9acac25a..f1e8ef168c8da3 100644 --- a/files/fr/web/javascript/reference/global_objects/number/positive_infinity/index.md +++ b/files/fr/web/javascript/reference/global_objects/number/positive_infinity/index.md @@ -39,9 +39,9 @@ Il est possible d'utiliser la propriété `Number.POSITIVE_INFINITY` pour faire Dans l'exemple qui suit, on affecte une valeur plus grande que la valeur maximale à la variable `grosNombre`. Lors de l'exécution de l'instruction `if`, `grosNombre` aura la valeur `Infinity`, pour continuer, on met à jour `grosNombre` avec une valeur plus acceptable. ```js -var grosNombre = Number.MAX_VALUE * 2 +var grosNombre = Number.MAX_VALUE * 2; if (grosNombre == Number.POSITIVE_INFINITY) { - grosNombre = renvoyerUnNombreFini(); + grosNombre = renvoyerUnNombreFini(); } ``` 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 1a96aacb393060..71d033cd7523c3 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 @@ -13,7 +13,7 @@ La méthode **`toExponential()`** renvoie une chaîne de caractères, représent ## Syntaxe ```js -numObj.toExponential([nbChiffresDécimaux]) +numObj.toExponential([nbChiffresDécimaux]); ``` ### Paramètre @@ -47,11 +47,11 @@ Si un nombre possède plus de chiffres décimaux que `nbChiffresDécimaux`, le n ```js var numObj = 77.1234; -console.log(numObj.toExponential()); // affiche 7.71234e+1 +console.log(numObj.toExponential()); // affiche 7.71234e+1 console.log(numObj.toExponential(4)); // affiche 7.7123e+1 console.log(numObj.toExponential(2)); // affiche 7.71e+1 -console.log(77.1234.toExponential()); // affiche 7.71234e+1 -console.log(77 .toExponential()); // affiche 7.7e+1 +console.log((77.1234).toExponential()); // affiche 7.71234e+1 +console.log((77).toExponential()); // affiche 7.7e+1 ``` ## Spécifications diff --git a/files/fr/web/javascript/reference/global_objects/number/tofixed/index.md b/files/fr/web/javascript/reference/global_objects/number/tofixed/index.md index 662d8e147c29dd..05876433d03b28 100644 --- a/files/fr/web/javascript/reference/global_objects/number/tofixed/index.md +++ b/files/fr/web/javascript/reference/global_objects/number/tofixed/index.md @@ -13,7 +13,7 @@ La méthode **`toFixed()`** permet de formater un nombre en notation à point-fi ## Syntaxe ```js -numObj.toFixed([nbChiffres]) +numObj.toFixed([nbChiffres]); ``` ### Paramètres @@ -43,17 +43,17 @@ Une chaîne de caractères qui représente le nombre indiqué avec une notation ```js var numObj = 12345.6789; -numObj.toFixed(); // Renvoie '12346' : arrondi, aucune partie fractionnaire -numObj.toFixed(1); // Renvoie '12345.7' : arrondi ici aussi -numObj.toFixed(6); // Renvoie '12345.678900' : des zéros sont ajoutés -(1.23e+20).toFixed(2); // Renvoie '123000000000000000000.00' -(1.23e-10).toFixed(2); // Renvoie '0.00' -2.34.toFixed(1); // Renvoie '2.3' --2.34.toFixed(1); // Renvoie -2.3 (en raison de la précédence des opérateurs, - // les littéraux de nombres négatifs ne renvoient pas de chaînes) -2.35.toFixed(1); // Renvoie '2.4' (arrondi supérieur) -2.55.toFixed(1); // Renvoie '2.5' (cf. l'avertissement ci-avant) -(-2.34).toFixed(1); // Renvoie '-2.3' +numObj.toFixed(); // Renvoie '12346' : arrondi, aucune partie fractionnaire +numObj.toFixed(1); // Renvoie '12345.7' : arrondi ici aussi +numObj.toFixed(6); // Renvoie '12345.678900' : des zéros sont ajoutés +(1.23e20).toFixed(2); // Renvoie '123000000000000000000.00' +(1.23e-10).toFixed(2); // Renvoie '0.00' +(2.34).toFixed(1); // Renvoie '2.3' +-(2.34).toFixed(1); // Renvoie -2.3 (en raison de la précédence des opérateurs, +// les littéraux de nombres négatifs ne renvoient pas de chaînes) +(2.35).toFixed(1); // Renvoie '2.4' (arrondi supérieur) +(2.55).toFixed(1); // Renvoie '2.5' (cf. l'avertissement ci-avant) +(-2.34).toFixed(1); // Renvoie '-2.3' ``` ## Spécifications diff --git a/files/fr/web/javascript/reference/global_objects/number/tolocalestring/index.md b/files/fr/web/javascript/reference/global_objects/number/tolocalestring/index.md index 81a3b5d2c1bb61..cb6a5abca9c0db 100644 --- a/files/fr/web/javascript/reference/global_objects/number/tolocalestring/index.md +++ b/files/fr/web/javascript/reference/global_objects/number/tolocalestring/index.md @@ -13,9 +13,9 @@ La méthode **`toLocaleString()`** permet de renvoyer une chaîne de caractères ## Syntaxe ```js -toLocaleString() -toLocaleString(locales) -toLocaleString(locales, options) +toLocaleString(); +toLocaleString(locales); +toLocaleString(locales, options); ``` ### Paramètres @@ -66,7 +66,11 @@ Afin de vérifier la prise en charge pour tous les environnements, y compris ceu ```js function toLocaleStringSupportsOptions() { - return !!(typeof Intl == 'object' && Intl && typeof Intl.NumberFormat == 'function'); + return !!( + typeof Intl == "object" && + Intl && + typeof Intl.NumberFormat == "function" + ); } ``` @@ -111,21 +115,30 @@ Les résultats fournis par `toLocaleString` peuvent être adaptés en utilisant const nombre = 123456.789; // on formate selon une devise -console.log(nombre.toLocaleString("de-DE", {style: "currency", currency: "EUR"})); +console.log( + nombre.toLocaleString("de-DE", { style: "currency", currency: "EUR" }), +); // → 123.456,79 € // le yen japonais ne possède pas de centimes -console.log(nombre.toLocaleString("ja-JP", {style: "currency", currency: "JPY"})) +console.log( + nombre.toLocaleString("ja-JP", { style: "currency", currency: "JPY" }), +); // → ￥123,457 // on se limite à trois chiffres significatifs -console.log(nombre.toLocaleString("en-IN", {maximumSignificantDigits: 3})); +console.log(nombre.toLocaleString("en-IN", { maximumSignificantDigits: 3 })); // → 1,23,000 // on utilise la langue du système pour la mise en // forme des nombres const num = 30000.65; -console.log(num.toLocaleString(undefined, {minimumFractionDigits: 2, maximumFractionDigits: 2})); +console.log( + num.toLocaleString(undefined, { + minimumFractionDigits: 2, + maximumFractionDigits: 2, + }), +); // → "30,000.65" quand l'anglais est la langue par défaut // → "30.000,65" quand l'allemand est la langue par défaut // → "30 000,65" quand le français est la langue par défaut diff --git a/files/fr/web/javascript/reference/global_objects/number/toprecision/index.md b/files/fr/web/javascript/reference/global_objects/number/toprecision/index.md index d17959ac07c28e..3352694dac29b8 100644 --- a/files/fr/web/javascript/reference/global_objects/number/toprecision/index.md +++ b/files/fr/web/javascript/reference/global_objects/number/toprecision/index.md @@ -13,7 +13,7 @@ La méthode **`toPrecision()`** renvoie une chaîne de caractères représentant ## Syntaxe ```js -numObj.toPrecision([précision]) +numObj.toPrecision([précision]); ``` ### Paramètre @@ -36,17 +36,17 @@ Si l'argument `précision` n'est pas utilisé, la méthode aura le même effet q ```js var objetNumber = 5.123456; -console.log(objetNumber.toPrecision()); //affiche "5.123456" +console.log(objetNumber.toPrecision()); //affiche "5.123456" console.log(objetNumber.toPrecision(5)); //affiche "5.1235" console.log(objetNumber.toPrecision(2)); //affiche "5.1" console.log(objetNumber.toPrecision(1)); //affiche "5" numObj = 0.000123; -console.log(numObj.toPrecision()); // affiche "0.000123" -console.log(numObj.toPrecision(5)); // affiche "0.00012300" -console.log(numObj.toPrecision(2)); // affiche "0.00012" -console.log(numObj.toPrecision(1)); // affiche "0.0001" +console.log(numObj.toPrecision()); // affiche "0.000123" +console.log(numObj.toPrecision(5)); // affiche "0.00012300" +console.log(numObj.toPrecision(2)); // affiche "0.00012" +console.log(numObj.toPrecision(1)); // affiche "0.0001" // dans certaines circonstances, on peut avoir une notation exponentielle console.log((1234.5).toPrecision(2)); // "1.2e+3" diff --git a/files/fr/web/javascript/reference/global_objects/number/tostring/index.md b/files/fr/web/javascript/reference/global_objects/number/tostring/index.md index cfb40c47ff38fc..15e45e281738ca 100644 --- a/files/fr/web/javascript/reference/global_objects/number/tostring/index.md +++ b/files/fr/web/javascript/reference/global_objects/number/tostring/index.md @@ -13,7 +13,7 @@ La méthode **`toString()`** renvoie une chaîne de caractère représentant l'o ## Syntaxe ```js -numObj.toString([base]) +numObj.toString([base]); ``` ### Paramètre @@ -49,17 +49,16 @@ Si l'objet `Number` n'est pas un nombre entier, le point (.) sera utilisé pour ```js var compte = 10; -console.log(compte.toString()); // affiche "10" -console.log((17).toString()); // affiche "17" -console.log((17.2).toString()); // affiche "17.2" +console.log(compte.toString()); // affiche "10" +console.log((17).toString()); // affiche "17" +console.log((17.2).toString()); // affiche "17.2" var x = 6; -console.log(x.toString(2)); // affiche "110" -console.log((254).toString(16)); // affiche "fe" +console.log(x.toString(2)); // affiche "110" +console.log((254).toString(16)); // affiche "fe" - -console.log((-10).toString(2)); // affiche "-1010" +console.log((-10).toString(2)); // affiche "-1010" console.log((-0xff).toString(2)); // affiche "-11111111" ``` diff --git a/files/fr/web/javascript/reference/global_objects/number/valueof/index.md b/files/fr/web/javascript/reference/global_objects/number/valueof/index.md index 81df525f2b38bd..8e33bb0e793605 100644 --- a/files/fr/web/javascript/reference/global_objects/number/valueof/index.md +++ b/files/fr/web/javascript/reference/global_objects/number/valueof/index.md @@ -13,7 +13,7 @@ La méthode **`valueOf()`** renvoie la valeur primitive correspondant à celle r ## Syntaxe ```js -objetNumber.valueOf() +objetNumber.valueOf(); ``` ### Valeur de retour @@ -33,8 +33,8 @@ var numObj = new Number(10); console.log(typeof numObj); // object var num = numObj.valueOf(); -console.log(num); // 10 -console.log(typeof num); // number +console.log(num); // 10 +console.log(typeof num); // number ``` ## Spécifications diff --git a/files/fr/web/javascript/reference/global_objects/object/__definegetter__/index.md b/files/fr/web/javascript/reference/global_objects/object/__definegetter__/index.md index 7cccb852b35991..eb145836146981 100644 --- a/files/fr/web/javascript/reference/global_objects/object/__definegetter__/index.md +++ b/files/fr/web/javascript/reference/global_objects/object/__definegetter__/index.md @@ -13,7 +13,7 @@ La méthode **`__defineGetter__`** permet de lier une propriété d'un objet à ## Syntaxe ```js -obj.__defineGetter__(prop, func) +obj.__defineGetter__(prop, func); ``` ### Paramètres @@ -37,22 +37,27 @@ La méthode `__defineGetter__` permet de définir un {{jsxref("Opérateurs/L_op // Méthode non-standard et dépréciée var o = {}; -o.__defineGetter__('gimmeFive', function() { return 5; }); +o.__defineGetter__("gimmeFive", function () { + return 5; +}); console.log(o.gimmeFive); // 5 - // Façon standard // En utilisant l'opérateur get -var o = { get gimmeFive() { return 5; } }; +var o = { + get gimmeFive() { + return 5; + }, +}; console.log(o.gimmeFive); // 5 // En utilisant Object.defineProperty var o = {}; -Object.defineProperty(o, 'gimmeFive', { - get: function() { +Object.defineProperty(o, "gimmeFive", { + get: function () { return 5; - } + }, }); console.log(o.gimmeFive); // 5 ``` diff --git a/files/fr/web/javascript/reference/global_objects/object/__definesetter__/index.md b/files/fr/web/javascript/reference/global_objects/object/__definesetter__/index.md index 8ce519a7aaefcb..71b09e6fab0a4a 100644 --- a/files/fr/web/javascript/reference/global_objects/object/__definesetter__/index.md +++ b/files/fr/web/javascript/reference/global_objects/object/__definesetter__/index.md @@ -13,7 +13,7 @@ La méthode **`__defineSetter__`** permet de lier une propriété d'un objet à ## Syntaxe ```js -obj.__defineSetter__(prop, fun) +obj.__defineSetter__(prop, fun); ``` ### Paramètres @@ -25,8 +25,8 @@ obj.__defineSetter__(prop, fun) - : Une fonction à appeler pour chaque modification de la propriété. Cette fonction prend la forme suivante : ```js - function(val) { . . . } - ``` + function(val) { . . . } + ``` - `val` - : Un alias pour la variable contenant la nouvelle valeur qu'on souhaite affecter à `prop`. @@ -45,26 +45,31 @@ La méthode `__defineSetter__` permet de définir un {{jsxref("Opérateurs/L_op // Méthode non-standard et dépréciée var o = {}; -o.__defineSetter__('valeur', function(val) { this.uneAutreValeur = val; }); +o.__defineSetter__("valeur", function (val) { + this.uneAutreValeur = val; +}); o.valeur = 5; console.log(o.valeur); // undefined console.log(o.uneAutreValeur); // 5 - // Façons standard // En utilisant l'opérateur set -var o = { set valeur(val) { this.uneAutreValeur = val; } }; +var o = { + set valeur(val) { + this.uneAutreValeur = val; + }, +}; o.valeur = 5; console.log(o.valeur); // undefined console.log(o.uneAutreValeur); // 5 // En utilisant Object.defineProperty var o = {}; -Object.defineProperty(o, 'valeur', { - set: function(val) { +Object.defineProperty(o, "valeur", { + set: function (val) { this.uneAutreValeur = val; - } + }, }); o.valeur = 5; console.log(o.valeur); // undefined diff --git a/files/fr/web/javascript/reference/global_objects/object/__lookupgetter__/index.md b/files/fr/web/javascript/reference/global_objects/object/__lookupgetter__/index.md index 315f88d53c304e..969381e0040687 100644 --- a/files/fr/web/javascript/reference/global_objects/object/__lookupgetter__/index.md +++ b/files/fr/web/javascript/reference/global_objects/object/__lookupgetter__/index.md @@ -11,7 +11,7 @@ La méthode **`__lookupGetter__`** renvoie la fonction liée comme accesseur d'u ## Syntaxe ```js -obj.__lookupGetter__(sprop) +obj.__lookupGetter__(sprop); ``` ### Paramètres @@ -34,16 +34,14 @@ Cette méthode ne doit plus être utilisée et il est possible de la remplacer d ```js var obj = { get toto() { - return Math.random() > 0.5 ? 'toto' : 'truc'; - } + return Math.random() > 0.5 ? "toto" : "truc"; + }, }; - // Méthode non-standard et dépréciée -obj.__lookupGetter__('toto'); +obj.__lookupGetter__("toto"); // (function() { return Math.random() > 0.5 ? 'toto' : 'truc'; }) - // Méthode standard Object.getOwnPropertyDescriptor(obj, "toto").get; // (function() { return Math.random() > 0.5 ? 'toto' : 'truc'; }) diff --git a/files/fr/web/javascript/reference/global_objects/object/__lookupsetter__/index.md b/files/fr/web/javascript/reference/global_objects/object/__lookupsetter__/index.md index 167063216be79f..15a9e3b915a191 100644 --- a/files/fr/web/javascript/reference/global_objects/object/__lookupsetter__/index.md +++ b/files/fr/web/javascript/reference/global_objects/object/__lookupsetter__/index.md @@ -11,7 +11,7 @@ La méthode **`__lookupSetter__`** renvoie la fonction définie comme mutateur p ## Syntaxe ```js -obj.__lookupSetter__(sprop) +obj.__lookupSetter__(sprop); ``` ### Paramètres @@ -35,15 +35,13 @@ Cette méthode ne doit plus être utilisée et peut être remplacée avec la mé var obj = { set toto(valeur) { this.truc = value; - } + }, }; - // Méthode non-standard et dépréciée -obj.__lookupSetter__('toto') +obj.__lookupSetter__("toto"); // (function(valeur) { this.truc = valeur; }) - // Méthode standard Object.getOwnPropertyDescriptor(obj, "toto").set; // (function(valeur) { this.truc = valeur; }) diff --git a/files/fr/web/javascript/reference/global_objects/object/assign/index.md b/files/fr/web/javascript/reference/global_objects/object/assign/index.md index 93c215fd015894..b4d59841fd80b6 100644 --- a/files/fr/web/javascript/reference/global_objects/object/assign/index.md +++ b/files/fr/web/javascript/reference/global_objects/object/assign/index.md @@ -13,7 +13,7 @@ La méthode **`Object.assign()`** est utilisée afin de copier les valeurs de to ## Syntaxe ```js -Object.assign(cible, ...sources) +Object.assign(cible, ...sources); ``` ### Paramètres @@ -58,7 +58,7 @@ var o3 = { c: 3 }; var obj = Object.assign(o1, o2, o3); console.log(obj); // { a: 1, b: 2, c: 3 } -console.log(o1); // { a: 1, b: 2, c: 3 }, l'objet cible est aussi modifié +console.log(o1); // { a: 1, b: 2, c: 3 }, l'objet cible est aussi modifié ``` ### Fusionner des objets partageant des propriétés @@ -78,7 +78,7 @@ Les propriétés communes sont surchargées selon l'ordre des paramètres. ```js var o1 = { a: 1 }; -var o2 = { [Symbol('toto')]: 2 }; +var o2 = { [Symbol("toto")]: 2 }; var obj = Object.assign({}, o1, o2); console.log(obj); // { a: 1, [Symbol("toto")]: 2 } @@ -90,15 +90,19 @@ console.log(Object.getOwnPropertySymbols(obj)); // [Symbol(toto)] ### Les propriétés héritées et les propriétés non-énumérables ne peuvent être copiées ```js -var obj = Object.create({ toto: 1 }, { // toto est héritée - truc: { - value: 2 // truc est non-enumerable (par défaut) +var obj = Object.create( + { toto: 1 }, + { + // toto est héritée + truc: { + value: 2, // truc est non-enumerable (par défaut) + }, + bidule: { + value: 3, + enumerable: true, // bidule est une propriété propre et énumérable + }, }, - bidule: { - value: 3, - enumerable: true // bidule est une propriété propre et énumérable - } -}); +); var copie = Object.assign({}, obj); console.log(copie); // { bidule: 3 } @@ -107,10 +111,10 @@ console.log(copie); // { bidule: 3 } ### Les types primitifs seront passés en objets ```js -var v1 = 'abc'; +var v1 = "abc"; var v2 = true; var v3 = 10; -var v4 = Symbol('toto') +var v4 = Symbol("toto"); var obj = Object.assign({}, v1, null, v2, undefined, v3, v4); // Les valeurs primitives seront converties, null et undefined seront ignorés. @@ -121,20 +125,25 @@ console.log(obj); // { "0": "a", "1": "b", "2": "c" } ### Les exceptions interrompent la copie ```js -var target = Object.defineProperty({}, 'toto', { +var target = Object.defineProperty({}, "toto", { value: 1, - writable: false + writable: false, }); // target.toto est en lecture seule -Object.assign(target, { truc: 2 }, { toto2: 3, toto: 3, toto3: 3 }, { bidule: 4 }); +Object.assign( + target, + { truc: 2 }, + { toto2: 3, toto: 3, toto3: 3 }, + { bidule: 4 }, +); // TypeError: "toto" est en lecture seule // L'exception est levée lorsqu'on affecte target.toto -console.log(target.truc); // 2, le premier objet source est bien copié +console.log(target.truc); // 2, le premier objet source est bien copié console.log(target.toto2); // 3, la première propriété du deuxième objet source est bien copiée -console.log(target.toto); // 1, on a une exception ici +console.log(target.toto); // 1, on a une exception ici console.log(target.toto3); // undefined, assign est terminé toto3 ne sera pas copié -console.log(target.bidule);// undefined, le troisième objet source ne sera pas copié non plus. +console.log(target.bidule); // undefined, le troisième objet source ne sera pas copié non plus. ``` ### Copier des accesseurs @@ -144,7 +153,7 @@ var obj = { toto: 1, get truc() { return 2; - } + }, }; var copie = Object.assign({}, obj); @@ -155,14 +164,14 @@ console.log(copie); // Voici une fonction qui copie les descripteurs // dans leur intégralité function completeAssign(target, ...sources) { - sources.forEach(source => { + sources.forEach((source) => { let descriptors = Object.keys(source).reduce((descriptors, key) => { descriptors[key] = Object.getOwnPropertyDescriptor(source, key); return descriptors; }, {}); // Par défaut, Object.assign copie également // les symboles énumérables - Object.getOwnPropertySymbols(source).forEach(sym => { + Object.getOwnPropertySymbols(source).forEach((sym) => { let descriptor = Object.getOwnPropertyDescriptor(source, sym); if (descriptor.enumerable) { descriptors[sym] = descriptor; diff --git a/files/fr/web/javascript/reference/global_objects/object/constructor/index.md b/files/fr/web/javascript/reference/global_objects/object/constructor/index.md index 112972aeadc1dd..113b8d252cfd1c 100644 --- a/files/fr/web/javascript/reference/global_objects/object/constructor/index.md +++ b/files/fr/web/javascript/reference/global_objects/object/constructor/index.md @@ -19,7 +19,7 @@ o.constructor === Object; // true var a = []; a.constructor === Array; // true -var n = new Number(3) +var n = new Number(3); n.constructor === Number; // true ``` @@ -31,11 +31,11 @@ L'exemple ci-dessous crée un constructeur `Arbre`, et un objet de ce type, `mon ```js function Arbre(nom) { - this.nom = nom; + this.nom = nom; } var monArbre = new Arbre("Sequoia"); -console.log( "monArbre.constructor vaut " + monArbre.constructor ); +console.log("monArbre.constructor vaut " + monArbre.constructor); ``` Cet exemple produira le résultat suivant : @@ -51,34 +51,38 @@ monArbre.constructor vaut function Arbre(nom) { Dans l'exemple suivant, on illustre comment modifier la valeur d'un constructeur pour les objets génériques. Dans l'exemple suivant, seules les valeurs `true`, `1` et `"test"` ne seront pas affectées car leurs constructeurs sont en lecture seule uniquement. Cet exemple montre qu'il ne faut pas se reposer de façon aveugle sur la propriété `constructor` d'un objet. ```js -function Type () {} +function Type() {} var types = [ new Array(), [], new Boolean(), - true, // restera tel quel + true, // restera tel quel new Date(), new Error(), new Function(), function () {}, Math, new Number(), - 1, // restera tel quel + 1, // restera tel quel new Object(), {}, new RegExp(), /(?:)/, new String(), - 'test' // restera tel quel + "test", // restera tel quel ]; for (var i = 0; i < types.length; i++) { types[i].constructor = Type; - types[i] = [types[i].constructor, types[i] instanceof Type, types[i].toString()]; + types[i] = [ + types[i].constructor, + types[i] instanceof Type, + types[i].toString(), + ]; } -console.log(types.join('\n')); +console.log(types.join("\n")); ``` L'exemple produira le résultat suivant : @@ -133,14 +137,14 @@ Essayons de définir les cas où il est nécessaire de réaffecter le constructe Imaginons que l'objet possède une méthode `create()` qui lui permette de créer un autre exemplaire : ```js -function Parent() {}; +function Parent() {} function CreatedConstructor() {} CreatedConstructor.prototype = Object.create(Parent.prototype); CreatedConstructor.prototype.create = function create() { return new this.constructor(); -} +}; new CreatedConstructor().create().create(); // error undefined is not a function car constructor === Parent @@ -151,7 +155,7 @@ Dans l'exemple précédent, on a une exception car le constructeur pointe vers ` Pour éviter cet écueil, il suffit d'affecter le bon constructeur (celui qui sera utilisé ensuite) : ```js -function Parent() {}; +function Parent() {} function CreatedConstructor() {} CreatedConstructor.prototype = Object.create(Parent.prototype); @@ -160,7 +164,7 @@ CreatedConstructor.prototype.constructor = CreatedConstructor; CreatedConstructor.prototype.create = function create() { return new this.constructor(); -} +}; new CreatedConstructor().create().create(); // pas d'exception cette fois-ci @@ -171,30 +175,31 @@ Prenons un autre exemple : ```js function ParentWithStatic() {} -ParentWithStatic.startPosition = { x: 0, y:0 }; +ParentWithStatic.startPosition = { x: 0, y: 0 }; ParentWithStatic.getStartPosition = function getStartPosition() { return this.startPosition; -} +}; function Child(x, y) { this.position = { x: x, - y: y + y: y, }; } Child.prototype = Object.create(ParentWithStatic.prototype); Child.prototype.constructor = Child; -Child.prototype.getOffsetByInitialPosition = function getOffsetByInitialPosition() { - var position = this.position; - var startPosition = this.constructor.getStartPosition(); // error undefined is not a function, since the constructor is Child +Child.prototype.getOffsetByInitialPosition = + function getOffsetByInitialPosition() { + var position = this.position; + var startPosition = this.constructor.getStartPosition(); // error undefined is not a function, since the constructor is Child - return { - offsetX: startPosition.x - position.x, - offsetY: startPosition.y - position.y - } -}; + return { + offsetX: startPosition.x - position.x, + offsetY: startPosition.y - position.y, + }; + }; ``` Ici, il faudra conserverr le constructeur parent si on veut que le code fonctionne correctement. diff --git a/files/fr/web/javascript/reference/global_objects/object/create/index.md b/files/fr/web/javascript/reference/global_objects/object/create/index.md index 61a01b3fb55d51..c86ce4baa033b2 100644 --- a/files/fr/web/javascript/reference/global_objects/object/create/index.md +++ b/files/fr/web/javascript/reference/global_objects/object/create/index.md @@ -13,8 +13,8 @@ La méthode **`Object.create()`** crée un nouvel objet avec un prototype donné ## Syntaxe ```js -Object.create(proto) -Object.create(proto, objetPropriétés) +Object.create(proto); +Object.create(proto, objetPropriétés); ``` ### Paramètres @@ -46,10 +46,10 @@ function Forme() { } // Méthode de la classe parente -Forme.prototype.déplacer = function(x, y) { +Forme.prototype.déplacer = function (x, y) { this.x += x; this.y += y; - console.info('Forme déplacée.'); + console.info("Forme déplacée."); }; // Rectangle - classe fille @@ -67,10 +67,10 @@ Rectangle.prototype.constructor = Rectangle; var rect = new Rectangle(); -console.log('instance de Rectangle ? ', (rect instanceof Rectangle)); +console.log("instance de Rectangle ? ", rect instanceof Rectangle); +// true +console.log("une instance de Forme ? ", rect instanceof Forme); // true -console.log('une instance de Forme ? ', (rect instanceof Forme)); - // true rect.déplacer(1, 1); // Affiche 'Forme déplacée.' ``` @@ -87,7 +87,7 @@ MaClasse.prototype = Object.create(ClasseParente1.prototype); // héritage d'une Object.assign(MaClasse.prototype, ClasseParente2.prototype); // mixin pour une autre MaClasse.prototype.constructor = MaClasse; // On réaffecte le constructeur -MaClasse.prototype.maMéthode = function() { +MaClasse.prototype.maMéthode = function () { // faire quelque chose }; ``` @@ -103,30 +103,31 @@ var o; // comme prototype o = Object.create(null); - o = {}; // est équivalent à : o = Object.create(Object.prototype); - // Exemple où on crée un objet avec quelques propriétés // (On voit ici que le second paramètres fait correspondre les clés // avec des descripteurs de propriétés.) o = Object.create(Object.prototype, { // toto est une propriété de donnée - toto: { writable: true, configurable: true, value: 'hello' }, + toto: { writable: true, configurable: true, value: "hello" }, // truc est une propriété d'accesseur/mutateur truc: { configurable: false, - get: function() { return 10; }, - set: function(value) { console.log('Définir `o.truc` à', value); } -/* avec les accesseurs ES2015 on aura : + get: function () { + return 10; + }, + set: function (value) { + console.log("Définir `o.truc` à", value); + }, + /* avec les accesseurs ES2015 on aura : get() { return 10; }, set(value) { console.log('Définir `o.truc` à', value); } */ - } + }, }); - function Constructeur() {} o = new Constructeur(); // est équivalent à : @@ -135,7 +136,6 @@ o = Object.create(Constructeur.prototype); // possède des instructions pour l'initialisation, // Object.create() ne pourra pas le reproduire - // on crée un nouvel objet dont le prototype est // un nouvel objet vide et on y ajoute une propriété // 'p' qui vaut 42 @@ -157,14 +157,17 @@ delete o.p; // false // Pour définir une propriété selon ES3 -o2 = Object.create({}, { - p: { - value: 42, - writable: true, - enumerable: true, - configurable: true - } -}); +o2 = Object.create( + {}, + { + p: { + value: 42, + writable: true, + enumerable: true, + configurable: true, + }, + }, +); // Équivalent à // o2 = Object.create({p: 42}); 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 8b8cbee498c035..ad696179692bae 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 @@ -13,7 +13,7 @@ La méthode **`Object.defineProperties()`** permet de définir ou de modifier le ## Syntaxe ```js -Object.defineProperties(obj, props) +Object.defineProperties(obj, props); ``` ### Paramètres @@ -64,14 +64,14 @@ L'objet passé à la fonction, éventuellement modifié. ```js var obj = {}; Object.defineProperties(obj, { - "propriété1": { + propriété1: { value: true, - writable: true + writable: true, }, - "propriété2": { + propriété2: { value: "Coucou", - writable: false - } + writable: false, + }, // etc. }); ``` @@ -99,22 +99,18 @@ function defineProperties(obj, properties) { var d = {}; - if (hasProperty(desc, "enumerable")) - d.enumerable = !!desc.enumerable; - if (hasProperty(desc, "configurable")) - d.configurable = !!desc.configurable; - if (hasProperty(desc, "value")) - d.value = desc.value; - if (hasProperty(desc, "writable")) - d.writable = !!desc.writable; - if ( hasProperty(desc, "get") ) { + if (hasProperty(desc, "enumerable")) d.enumerable = !!desc.enumerable; + if (hasProperty(desc, "configurable")) d.configurable = !!desc.configurable; + if (hasProperty(desc, "value")) d.value = desc.value; + if (hasProperty(desc, "writable")) d.writable = !!desc.writable; + if (hasProperty(desc, "get")) { var g = desc.get; if (!isCallable(g) && typeof g !== "undefined") throw new TypeError("bad get"); d.get = g; } - if ( hasProperty(desc, "set") ) { + if (hasProperty(desc, "set")) { var s = desc.set; if (!isCallable(s) && typeof s !== "undefined") throw new TypeError("bad set"); @@ -127,8 +123,7 @@ function defineProperties(obj, properties) { return d; } - if (typeof obj !== "object" || obj === null) - throw new TypeError("bad obj"); + if (typeof obj !== "object" || obj === null) throw new TypeError("bad obj"); properties = Object(properties); 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 17449759463e0e..d41eacfe5ded67 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 @@ -15,7 +15,7 @@ La méthode statique **`Object.defineProperty()`** permet de définir une nouvel ## Syntaxe ```js -Object.defineProperty(obj, prop, descripteur) +Object.defineProperty(obj, prop, descripteur); ``` ### Paramètres @@ -70,10 +70,10 @@ var obj = {}; // en utilisant __proto__ Object.defineProperty(obj, "clé", { __proto__: null, // aucune propriété héritée - value: "static" // non énumérable - // non configurable - // non accessible en écriture - // par défaut + value: "static", // non énumérable + // non configurable + // non accessible en écriture + // par défaut }); // en étant explicite @@ -81,20 +81,20 @@ Object.defineProperty(obj, "clé", { enumerable: false, configurable: false, writable: false, - value: "static" + value: "static", }); // en recyclant un objet function avecValeur(valeur) { - var d = avecValeur.d || ( - avecValeur.d = { + var d = + avecValeur.d || + (avecValeur.d = { enumerable: false, writable: false, configurable: false, - value: null - } - ); - if(d.value !== valeur){ + value: null, + }); + if (d.value !== valeur) { d.value = valeur; } return d; @@ -106,7 +106,7 @@ Object.defineProperty(obj, "clé", avecValeur("static")); // on peut empêcher que du code ajoute des // propriétés (valeur, get, set, enumerable, // writable, configurable) au prototype d'Object -(Object.freeze||Object)(Object.prototype); +(Object.freeze || Object)(Object.prototype); ``` ## Exemples @@ -122,21 +122,27 @@ var o = {}; // on crée un nouvel objet // Exemple d'une propriété ajoutée via defineProperty // avec un descripteur de données -Object.defineProperty(o, "a", {value : 37, - writable : true, - enumerable : true, - configurable : true}); +Object.defineProperty(o, "a", { + value: 37, + writable: true, + enumerable: true, + configurable: true, +}); // la propriété 'a' existe pour l'objet o et vaut 37 // Exemple d'une propriété ajoutée via defineProperty // avec un descripteur d'accesseur var valeurB = 38; -Object.defineProperty(o, "b", {get : function(){ return valeurB; }, - set : function(nouvelleValeur){ - valeurB = nouvelleValeur; - }, - enumerable : true, - configurable : true}); +Object.defineProperty(o, "b", { + get: function () { + return valeurB; + }, + set: function (nouvelleValeur) { + valeurB = nouvelleValeur; + }, + enumerable: true, + configurable: true, +}); o.b; // 38 // la propriété 'b' existe pour l'objet o // et vaut 38 @@ -144,11 +150,12 @@ o.b; // 38 // identique à valeurB, sauf si o.b est redéfini // On ne peut pas mélanger les deux : -Object.defineProperty(o, "conflit", { value: 0x9f91102, - get: function() { - return 0xdeadbeef; - } - }); +Object.defineProperty(o, "conflit", { + value: 0x9f91102, + get: function () { + return 0xdeadbeef; + }, +}); // une exception TypeError sera lancée : value n'apparaît // que dans les descripteurs de données // get n'apparait que dans les descripteurs d'accesseur @@ -169,29 +176,28 @@ Lorsque l'attribut `writable` vaut `false` pour la propriété, cette dernière ```js var o = {}; // On crée un nouvel objet -Object.defineProperty(o, "a", { value : 37, - writable : false }); +Object.defineProperty(o, "a", { value: 37, writable: false }); console.log(o.a); // inscrit 37 dans les journaux (logs) o.a = 25; // Aucune exception n'est lancée (on aurait une - // exception en mode strict, y compris si la - // valeur souhaitée avait été la même) +// exception en mode strict, y compris si la +// valeur souhaitée avait été la même) console.log(o.a); // inscrit toujours 37. - //L'affectation n'a pas fonctionné. +//L'affectation n'a pas fonctionné. ``` ```js // En mode strict -(function() { - 'use strict'; +(function () { + "use strict"; var o = {}; - Object.defineProperty(o, 'b', { + Object.defineProperty(o, "b", { value: 2, - writable: false + writable: false, }); o.b = 3; // déclenche une TypeError: "b" est en lecture seule return o.b; // renvoie 2 sans la ligne précédente -}()); +})(); ``` Comme on l'a vu dans l'exemple, essayer de modifier une propriété non accessible en écriture ne la modifie pas. Cela ne rend pas d'erreur non plus (en mode non-strict). @@ -202,27 +208,27 @@ L'attribut de propriété `enumerable` permet de définir si la propriété est ```js var o = {}; -Object.defineProperty(o, 'a', { +Object.defineProperty(o, "a", { value: 1, - enumerable: true + enumerable: true, }); -Object.defineProperty(o, 'b', { +Object.defineProperty(o, "b", { value: 2, - enumerable: false + enumerable: false, }); -Object.defineProperty(o, 'c', { - value: 3 +Object.defineProperty(o, "c", { + value: 3, }); // enumerable vaut false par défaut o.d = 4; // enumerable vaut true par défaut - // lorsqu'on crée une propriété - // en la définissant -Object.defineProperty(o, Symbol.for('e'), { +// lorsqu'on crée une propriété +// en la définissant +Object.defineProperty(o, Symbol.for("e"), { value: 5, - enumerable: true + enumerable: true, }); -Object.defineProperty(o, Symbol.for('f'), { +Object.defineProperty(o, Symbol.for("f"), { value: 6, - enumerable: false + enumerable: false, }); for (var i in o) { @@ -232,20 +238,20 @@ for (var i in o) { Object.keys(o); // ['a', 'd'] -o.propertyIsEnumerable('a'); // true -o.propertyIsEnumerable('b'); // false -o.propertyIsEnumerable('c'); // false -o.propertyIsEnumerable('d'); // true -o.propertyIsEnumerable(Symbol.for('e')); // true -o.propertyIsEnumerable(Symbol.for('f')); // false - -var p = { ...o } -p.a // 1 -p.b // undefined -p.c // undefined -p.d // 4 -p[Symbol.for('e')] // 5 -p[Symbol.for('f')] // undefined +o.propertyIsEnumerable("a"); // true +o.propertyIsEnumerable("b"); // false +o.propertyIsEnumerable("c"); // false +o.propertyIsEnumerable("d"); // true +o.propertyIsEnumerable(Symbol.for("e")); // true +o.propertyIsEnumerable(Symbol.for("f")); // false + +var p = { ...o }; +p.a; // 1 +p.b; // undefined +p.c; // undefined +p.d; // 4 +p[Symbol.for("e")]; // 5 +p[Symbol.for("f")]; // undefined ``` #### Attribut `configurable` @@ -254,23 +260,31 @@ L'attribut `configurable` permet de contrôler si la propriété peut être supp ```js var o = {}; -Object.defineProperty(o, "a", { get : function(){return 1;}, - configurable : false } ); +Object.defineProperty(o, "a", { + get: function () { + return 1; + }, + configurable: false, +}); -Object.defineProperty(o, "a", {configurable : true}); +Object.defineProperty(o, "a", { configurable: true }); // renvoie une TypeError -Object.defineProperty(o, "a", {enumerable : true}); +Object.defineProperty(o, "a", { enumerable: true }); // renvoie une TypeError -Object.defineProperty(o, "a", {set : function(){}}); +Object.defineProperty(o, "a", { set: function () {} }); // renvoie une TypeError (set était non défini avant) -Object.defineProperty(o, "a", {get : function(){return 1;}}); +Object.defineProperty(o, "a", { + get: function () { + return 1; + }, +}); // renvoie une TypeError // (bien que le nouveau get soit identique au précédent) -Object.defineProperty(o, "a", {value : 12}); +Object.defineProperty(o, "a", { value: 12 }); // renvoie une TypeError console.log(o.a); // log 1 @@ -289,19 +303,22 @@ var o = {}; o.a = 1; // est équivalent à : -Object.defineProperty(o, "a", {value : 1, - writable : true, - configurable : true, - enumerable : true}); - +Object.defineProperty(o, "a", { + value: 1, + writable: true, + configurable: true, + enumerable: true, +}); // D'un autre côté, -Object.defineProperty(o, "a", {value : 1}); +Object.defineProperty(o, "a", { value: 1 }); // sera équivalent à : -Object.defineProperty(o, "a", {value : 1, - writable : false, - configurable : false, - enumerable : false}); +Object.defineProperty(o, "a", { + value: 1, + writable: false, + configurable: false, + enumerable: false, +}); ``` ### Accesseurs et mutateurs adaptés @@ -313,18 +330,20 @@ function Archiviste() { var température = null; var archive = []; - Object.defineProperty(this, "température",{ - get: function() { + Object.defineProperty(this, "température", { + get: function () { console.log("accès !"); return température; }, - set: function(value) { + set: function (value) { température = value; - archive.push({val: température}); - } + archive.push({ val: température }); + }, }); - this.getArchive = function() {return archive;}; + this.getArchive = function () { + return archive; + }; } var arc = new Archiviste(); diff --git a/files/fr/web/javascript/reference/global_objects/object/entries/index.md b/files/fr/web/javascript/reference/global_objects/object/entries/index.md index a68f66c63953bb..86affad5b2f265 100644 --- a/files/fr/web/javascript/reference/global_objects/object/entries/index.md +++ b/files/fr/web/javascript/reference/global_objects/object/entries/index.md @@ -15,7 +15,7 @@ L'ordre du tableau renvoyé par cette méthode ne dépend pas de la façon dont ## Syntaxe ```js -Object.entries(obj) +Object.entries(obj); ``` ### Paramètres @@ -38,16 +38,25 @@ var obj = { toto: "truc", machin: 42 }; console.log(Object.entries(obj)); // [ ['toto', 'truc'], ['machin', 42] ] // Un objet semblable à un tableau -var obj = { 0: 'a', 1: 'b', 2: 'c' }; +var obj = { 0: "a", 1: "b", 2: "c" }; console.log(Object.entries(obj)); // [ ['0', 'a'], ['1', 'b'], ['2', 'c'] ] // Un objet semblable à un tableau // dont les clés sont aléatoirement ordonnées -var un_obj = { 100: 'a', 2: 'b', 7: 'c' }; +var un_obj = { 100: "a", 2: "b", 7: "c" }; console.log(Object.entries(un_obj)); // [ ['2', 'b'], ['7', 'c'], ['100', 'a'] ] // getToto est une propriété non énumérable -var mon_obj = Object.create({}, { getToto: { value: function() { return this.toto; } } }); +var mon_obj = Object.create( + {}, + { + getToto: { + value: function () { + return this.toto; + }, + }, + }, +); mon_obj.toto = "truc"; console.log(Object.entries(mon_obj)); // [ ['toto', 'truc'] ] @@ -59,15 +68,15 @@ console.log(Object.entries("toto")); // [ ['0', 't'], ['1', 'o'], ['2', 't'], [ console.log(Object.entries(100)); // [ ] // parcourir les clés-valeurs -var autreObjet = {a:5, b:7, c:9}; +var autreObjet = { a: 5, b: 7, c: 9 }; -for (var [cle, valeur] of Object.entries(autreObjet)){ - console.log(cle + ' ' + valeur); +for (var [cle, valeur] of Object.entries(autreObjet)) { + console.log(cle + " " + valeur); } // Ou encore, en utilisant les méthodes génériques Object.entries(autreObjet).forEach(([clé, valeur]) => { - console.log(clé + ' ' + valeur); + console.log(clé + " " + valeur); }); ``` @@ -87,8 +96,8 @@ En utilisant [la décomposition des tableaux](/fr/docs/Web/JavaScript/Reference/ ```js const obj = { toto: "truc", bidule: 42 }; -Object.entries(obj).forEach( - ([clé, valeur]) => console.log(`${clé}: ${valeur}`) +Object.entries(obj).forEach(([clé, valeur]) => + console.log(`${clé}: ${valeur}`), ); // "toto: truc" // "bidule: 42" @@ -102,12 +111,11 @@ Vous pouvez également utiliser la prothèse suivante (qui nécessitera la proth ```js if (!Object.entries) { - Object.entries = function( obj ){ - var ownProps = Object.keys( obj ), - i = ownProps.length, - resArray = new Array(i); - while (i--) - resArray[i] = [ownProps[i], obj[ownProps[i]]]; + Object.entries = function (obj) { + var ownProps = Object.keys(obj), + i = ownProps.length, + resArray = new Array(i); + while (i--) resArray[i] = [ownProps[i], obj[ownProps[i]]]; return resArray; }; diff --git a/files/fr/web/javascript/reference/global_objects/object/freeze/index.md b/files/fr/web/javascript/reference/global_objects/object/freeze/index.md index acf711a362d326..5d9ce02b93284c 100644 --- a/files/fr/web/javascript/reference/global_objects/object/freeze/index.md +++ b/files/fr/web/javascript/reference/global_objects/object/freeze/index.md @@ -13,7 +13,7 @@ La méthode **`Object.freeze()`** permet de geler un objet, c'est-à-dire qu'on ## Syntaxe ```js -Object.freeze(obj) +Object.freeze(obj); ``` ### Paramètres @@ -39,8 +39,8 @@ La fonction renvoie l'objet passé en argument, elle ne crée pas une copie « g ```js var obj = { - prop: function (){}, - toto: "truc" + prop: function () {}, + toto: "truc", }; // On peut ajouter de nouvelles propriétés, @@ -61,15 +61,15 @@ Object.isFrozen(obj); // true // Maintenant que l'objet est gelé, les changements échoueront obj.toto = "eheh"; // échoue silencieusement obj.roxor = "ga bu zo meu"; // échoue silencieusement et n'ajoute - // pas la propriété +// pas la propriété // ...en mode strict, l'échec se traduira par une exception TypeErrors -function echec(){ +function echec() { "use strict"; obj.toto = "bipbip"; // renvoie une TypeError - delete obj.toto; // renvoie une TypeError - delete obj.roxor; // renvoie true car l'attribut n' a pas été ajouté - obj.bipbip = "arf"; // renvoie une TypeError + delete obj.toto; // renvoie une TypeError + delete obj.roxor; // renvoie true car l'attribut n' a pas été ajouté + obj.bipbip = "arf"; // renvoie une TypeError } echec(); @@ -93,13 +93,13 @@ let a = [0]; Object.freeze(a); // Le tableau ne peut plus être modifié -a[0] = 1; // échoue silencieusement +a[0] = 1; // échoue silencieusement a.push(2); // échoue silencieusement // en mode strict, de telles tentatives // déclencheront des exceptions TypeError function echec() { - "use strict" + "use strict"; a[0] = 1; a.push(2); } @@ -111,13 +111,13 @@ L'exemple qui suit illustre comment les propriétés qui sont des objets peuvent ```js obj1 = { - internal: {} + internal: {}, }; Object.freeze(obj1); -obj1.internal.a = 'valeurA'; +obj1.internal.a = "valeurA"; -obj1.internal.a // 'valeurA' +obj1.internal.a; // 'valeurA' ``` L'objet qui est gelé est immuable mais ce n'est pas nécessairement une constante. Pour obtenir une constante, il faut que l'ensemble des références (directes et indirectes) pointe vers des objets immuables. Les chaînes de caractères, les nombres et les booléens sont toujours immuables. La plupart du temps, on aura besoin de créer des constantes au cas par cas (et non de façon générale). @@ -132,8 +132,8 @@ var employé = { designation: "Développeur", adresse: { cp: "72000", - ville: "Le Mans" - } + ville: "Le Mans", + }, }; Object.freeze(employé); @@ -148,15 +148,13 @@ Pour rendre l'objet complètement immuable, on gèle chacun des objets qu'il con ```js function deepFreeze(obj) { - // On récupère les noms des propriétés définies sur obj var propNames = Object.getOwnPropertyNames(obj); // On gèle les propriétés avant de geler l'objet - for(let name of propNames){ + for (let name of propNames) { let value = obj[name]; - obj[name] = value && typeof value === "object" ? - deepFreeze(value) : value; + obj[name] = value && typeof value === "object" ? deepFreeze(value) : value; } // On gèle l'objet initial @@ -165,12 +163,12 @@ function deepFreeze(obj) { obj2 = { internal: { - a: null - } + a: null, + }, }; deepFreeze(obj2); -obj2.internal.a = 'valeurB'; // échouera silencieusement en mode non-strict +obj2.internal.a = "valeurB"; // échouera silencieusement en mode non-strict obj2.internal.a; // null ``` diff --git a/files/fr/web/javascript/reference/global_objects/object/fromentries/index.md b/files/fr/web/javascript/reference/global_objects/object/fromentries/index.md index e763f68d54fa67..61dd50cf243066 100644 --- a/files/fr/web/javascript/reference/global_objects/object/fromentries/index.md +++ b/files/fr/web/javascript/reference/global_objects/object/fromentries/index.md @@ -38,7 +38,10 @@ La méthode `Object.fromEntries()` prend comme argument une liste de paires de c Grâce à `Object.fromEntries`, on peut convertir des objets {{jsxref("Map")}} en {{jsxref("Object")}} : ```js -const map = new Map([ ['toto', 'truc'], ['machin', 42] ]); +const map = new Map([ + ["toto", "truc"], + ["machin", 42], +]); const obj = Object.fromEntries(map); console.log(obj); // { toto: "truc", machin: 42 } ``` @@ -48,7 +51,11 @@ console.log(obj); // { toto: "truc", machin: 42 } Grâce à `Object.fromEntries`, on peut convertir des objets {{jsxref("Array")}} en {{jsxref("Object")}} : ```js -const arr = [ ['0', 'a'], ['1', 'b'], ['2', 'c'] ]; +const arr = [ + ["0", "a"], + ["1", "b"], + ["2", "c"], +]; const obj = Object.fromEntries(arr); console.log(obj); // { 0: "a", 1: "b", 2: "c" } ``` @@ -61,8 +68,7 @@ Avec `Object.fromEntries` et la méthode réciproque {{jsxref("Object.entries()" const object1 = { a: 1, b: 2, c: 3 }; const object2 = Object.fromEntries( - Object.entries(object1) - .map(([ key, val ]) => [ key, val * 2 ]) + Object.entries(object1).map(([key, val]) => [key, val * 2]), ); console.log(object2); diff --git a/files/fr/web/javascript/reference/global_objects/object/getownpropertydescriptor/index.md b/files/fr/web/javascript/reference/global_objects/object/getownpropertydescriptor/index.md index 2ebd482039425f..63d9701d111e63 100644 --- a/files/fr/web/javascript/reference/global_objects/object/getownpropertydescriptor/index.md +++ b/files/fr/web/javascript/reference/global_objects/object/getownpropertydescriptor/index.md @@ -13,7 +13,7 @@ La méthode **`Object.getOwnPropertyDescriptor()`** renvoie un descripteur de la ## Syntaxe ```js -Object.getOwnPropertyDescriptor(obj, prop) +Object.getOwnPropertyDescriptor(obj, prop); ``` ### Paramètres @@ -51,7 +51,11 @@ Un descripteur de propriété est un enregistrement qui dispose des attributs su ```js var o, d; -o = { get toto() { return 17; } }; +o = { + get toto() { + return 17; + }, +}; d = Object.getOwnPropertyDescriptor(o, "toto"); // d : { // configurable: true, @@ -71,9 +75,10 @@ d = Object.getOwnPropertyDescriptor(o, "truc"); o = {}; Object.defineProperty(o, "machin", { - value: 8675309, - writable: false, - enumerable: false }); + value: 8675309, + writable: false, + enumerable: false, +}); d = Object.getOwnPropertyDescriptor(o, "machin"); // d : { // value: 8675309, diff --git a/files/fr/web/javascript/reference/global_objects/object/getownpropertydescriptors/index.md b/files/fr/web/javascript/reference/global_objects/object/getownpropertydescriptors/index.md index bed48a0ca10ae0..f387e68f60ee57 100644 --- a/files/fr/web/javascript/reference/global_objects/object/getownpropertydescriptors/index.md +++ b/files/fr/web/javascript/reference/global_objects/object/getownpropertydescriptors/index.md @@ -13,7 +13,7 @@ La méthode **`Object.getOwnPropertyDescriptors()`** renvoie l'ensemble des desc ## Syntaxe ```js -Object.getOwnPropertyDescriptors(obj) +Object.getOwnPropertyDescriptors(obj); ``` ### Paramètres @@ -53,7 +53,7 @@ La méthode {{jsxref("Object.assign()")}} ne copiera que les propriétés propre ```js Object.create( Object.getPrototypeOf(obj), - Object.getOwnPropertyDescriptors(obj) + Object.getOwnPropertyDescriptors(obj), ); ``` @@ -62,19 +62,20 @@ Object.create( Pour créer une sous-classe, généralement, on définit la sous-classe et on définit son prototype comme étant une instance de la classe parente. Enfin on définit les propriétés de cette nouvelle sous-classe. ```js -function superclass() {}; +function superclass() {} superclass.prototype = { // on définit les méthodes et propriétés // de la classe parente }; -function subclass() {}; +function subclass() {} subclass.prototype = Object.create( superclass.prototype, Object.getOwnPropertyDescriptors({ - // on définit les méthodes et propriétés - // de la sous-classe -})); + // on définit les méthodes et propriétés + // de la sous-classe + }), +); ``` ## Spécifications diff --git a/files/fr/web/javascript/reference/global_objects/object/getownpropertynames/index.md b/files/fr/web/javascript/reference/global_objects/object/getownpropertynames/index.md index c13b516c31dfce..5df063f89623e6 100644 --- a/files/fr/web/javascript/reference/global_objects/object/getownpropertynames/index.md +++ b/files/fr/web/javascript/reference/global_objects/object/getownpropertynames/index.md @@ -13,7 +13,7 @@ La méthode **`Object.getOwnPropertyNames()`** renvoie un tableau de toutes les ## Syntaxe ```js -Object.getOwnPropertyNames(obj) +Object.getOwnPropertyNames(obj); ``` ### Paramètres @@ -39,16 +39,14 @@ console.log(Object.getOwnPropertyNames(arr).sort()); // ["0", "1", "2", "length"] // Objet semblable à un tableau (array-like) -var obj = { 0: "a", 1: "b", 2: "c"}; +var obj = { 0: "a", 1: "b", 2: "c" }; console.log(Object.getOwnPropertyNames(obj).sort()); // ["0", "1", "2"] - // On affiche les noms et les valeurs // des propriétés avec Array.forEach -Object.getOwnPropertyNames(obj).forEach( - function(val, idx, array) { - console.log(val + " -> " + obj[val]); +Object.getOwnPropertyNames(obj).forEach(function (val, idx, array) { + console.log(val + " -> " + obj[val]); }); // affiche // 0 -> a @@ -56,12 +54,17 @@ Object.getOwnPropertyNames(obj).forEach( // 2 -> c // propriété non-énumérable -var mon_obj = Object.create({}, { - getToto: { - value: function() { return this.toto; }, - enumerable: false - } -}); +var mon_obj = Object.create( + {}, + { + getToto: { + value: function () { + return this.toto; + }, + enumerable: false, + }, + }, +); mon_obj.toto = 1; console.log(Object.getOwnPropertyNames(mon_obj).sort()); @@ -76,7 +79,7 @@ Les propriétés héritées via la chaîne de prototype ne sont pas listées : function ClasseParente() {} ClasseParente.prototype.inheritedMethod = function () {}; -function ClasseFille () { +function ClasseFille() { this.prop = 5; this.method = function () {}; } @@ -85,9 +88,9 @@ ClasseFille.prototype.prototypeMethod = function () {}; console.log( Object.getOwnPropertyNames( - new ClasseFille() // ["prop", "method"] - ) -) + new ClasseFille(), // ["prop", "method"] + ), +); ``` ### Obtenir uniquement les propriétés non-énumérables @@ -98,8 +101,8 @@ On utilise ici la fonction {{jsxref("Array.prototype.filter()")}} pour retirer l var target = myObject; var enum_et_nonenum = Object.getOwnPropertyNames(target); var enum_uniquement = Object.keys(target); -var nonenum_uniquement = enum_et_nonenum.filter(function(key) { - var indexInEnum = enum_uniquement.indexOf(key) +var nonenum_uniquement = enum_et_nonenum.filter(function (key) { + var indexInEnum = enum_uniquement.indexOf(key); if (indexInEnum == -1) { // non trouvée dans enum_uniquement indique // que la clé est non-énumérable, on la diff --git a/files/fr/web/javascript/reference/global_objects/object/getownpropertysymbols/index.md b/files/fr/web/javascript/reference/global_objects/object/getownpropertysymbols/index.md index 49a8ccc5554585..0c7ef6fa133665 100644 --- a/files/fr/web/javascript/reference/global_objects/object/getownpropertysymbols/index.md +++ b/files/fr/web/javascript/reference/global_objects/object/getownpropertysymbols/index.md @@ -13,7 +13,7 @@ La méthode **`Object.getOwnPropertySymbols()`** renvoie un tableau contenant to ## Syntaxe ```js -Object.getOwnPropertySymbols(obj) +Object.getOwnPropertySymbols(obj); ``` ### Paramètres @@ -44,8 +44,8 @@ obj[b] = "symboleGlobal"; var objectSymboles = Object.getOwnPropertySymbols(obj); console.log(objectSymboles.length); // 2 -console.log(objectSymboles) // [Symbol(a), Symbol(b)] -console.log(objectSymboles[0]) // Symbol(a) +console.log(objectSymboles); // [Symbol(a), Symbol(b)] +console.log(objectSymboles[0]); // Symbol(a) ``` ## Spécifications diff --git a/files/fr/web/javascript/reference/global_objects/object/getprototypeof/index.md b/files/fr/web/javascript/reference/global_objects/object/getprototypeof/index.md index 2b4a1b7f532a94..6ae05d0604d6e3 100644 --- a/files/fr/web/javascript/reference/global_objects/object/getprototypeof/index.md +++ b/files/fr/web/javascript/reference/global_objects/object/getprototypeof/index.md @@ -13,7 +13,7 @@ La méthode **`Object.getPrototypeOf()`** renvoie le prototype d'un objet donné ## Syntaxe ```js -Object.getPrototypeOf(obj) +Object.getPrototypeOf(obj); ``` ### Paramètres diff --git a/files/fr/web/javascript/reference/global_objects/object/hasown/index.md b/files/fr/web/javascript/reference/global_objects/object/hasown/index.md index 1e0428ea633ca0..d6c36cd7f24d9e 100644 --- a/files/fr/web/javascript/reference/global_objects/object/hasown/index.md +++ b/files/fr/web/javascript/reference/global_objects/object/hasown/index.md @@ -15,7 +15,7 @@ La méthode statique **`Object.hasOwn()`** renvoie `true` si l'objet indiqué po ## Syntaxe ```js -Object.hasOwn(instance,prop) +Object.hasOwn(instance, prop); ``` ### Paramètres @@ -43,16 +43,16 @@ Le code suivant illustre comment déterminer si l'objet `exemple` contient une p ```js let exemple = {}; -Object.hasOwn(exemple, 'prop'); // false : 'prop' n'a pas été définie +Object.hasOwn(exemple, "prop"); // false : 'prop' n'a pas été définie -exemple.prop = 'existe'; -Object.hasOwn(exemple, 'prop'); // true : 'prop' a été définie +exemple.prop = "existe"; +Object.hasOwn(exemple, "prop"); // true : 'prop' a été définie exemple.prop = null; -Object.hasOwn(exemple, 'prop'); // true : la propriété existe malgré sa valeur null +Object.hasOwn(exemple, "prop"); // true : la propriété existe malgré sa valeur null exemple.prop = undefined; -Object.hasOwn(exemple, 'prop'); // true : la propriété existe malgré sa valeur undefined +Object.hasOwn(exemple, "prop"); // true : la propriété existe malgré sa valeur undefined ``` ### Propriétés propres et propriétés héritées @@ -60,18 +60,18 @@ Object.hasOwn(exemple, 'prop'); // true : la propriété existe malgré sa val Dans l'exemple suivant, on distingue les propriétés propres/directes et celles qui sont héritées via la chaîne de prototypes : ```js -let exemple = {} -exemple.prop = 'existe'; +let exemple = {}; +exemple.prop = "existe"; // `Objet.hasOwn()` renverra true seulement pour les propriétés propres -Object.hasOwn(exemple, 'prop'); // renvoie true -Object.hasOwn(exemple, 'toString'); // renvoie false -Object.hasOwn(exemple, 'hasOwnProperty'); // renvoie false +Object.hasOwn(exemple, "prop"); // renvoie true +Object.hasOwn(exemple, "toString"); // renvoie false +Object.hasOwn(exemple, "hasOwnProperty"); // renvoie false // L'opérateur `in` renverra true pour les propriétés propres et héritées -'prop' in exemple; // renvoie true -'toString' in exemple; // renvoie true -'hasOwnProperty' in exemple; // renvoie true +"prop" in exemple; // renvoie true +"toString" in exemple; // renvoie true +"hasOwnProperty" in exemple; // renvoie true ``` ### Parcourir les propriétés d'un objet= @@ -101,9 +101,9 @@ for (let nom in exemple) { Les éléments d'un tableau ([`Array`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Array)) sont définis comme propriétés propres. Ainsi, `Object.hasOwn()` pourra être utilisé pour vérifier si un indice donné existe : ```js -let fruits = ['Pomme', 'Banane', 'Melon', 'Orange']; -Object.hasOwn(fruits, 3); // true ('Orange') -Object.hasOwn(fruits, 4); // false, non défini +let fruits = ["Pomme", "Banane", "Melon", "Orange"]; +Object.hasOwn(fruits, 3); // true ('Orange') +Object.hasOwn(fruits, 4); // false, non défini ``` ### Cas problématiques pour hasOwnProperty() @@ -112,13 +112,13 @@ Cette section illustre l'immunité de `Object.hasOwn()` concernant des problème ```js let toto = { - hasOwnProperty: function() { + hasOwnProperty: function () { return false; }, - truc: 'Ga bu zo meu' + truc: "Ga bu zo meu", }; -if (Object.hasOwn(toto, 'truc')) { +if (Object.hasOwn(toto, "truc")) { console.log(toto.truc); //true - la surcharge de hasOwnProperty() n'a pas d'impact } ``` @@ -127,8 +127,8 @@ On peut également l'utiliser pour tester des objets créés avec [`Object.creat ```js let toto = Object.create(null); -toto.prop = 'existe'; -if (Object.hasOwn(toto, 'prop')) { +toto.prop = "existe"; +if (Object.hasOwn(toto, "prop")) { console.log(toto.prop); // true. } ``` diff --git a/files/fr/web/javascript/reference/global_objects/object/hasownproperty/index.md b/files/fr/web/javascript/reference/global_objects/object/hasownproperty/index.md index a71a37c093840c..47243adca37b69 100644 --- a/files/fr/web/javascript/reference/global_objects/object/hasownproperty/index.md +++ b/files/fr/web/javascript/reference/global_objects/object/hasownproperty/index.md @@ -13,7 +13,7 @@ La méthode **`hasOwnProperty()`** retourne un booléen indiquant si l'objet pos ## Syntaxe ```js -obj.hasOwnProperty(prop) +obj.hasOwnProperty(prop); ``` ### Paramètres @@ -37,9 +37,9 @@ L'exemple suivant détermine si l'objet `o` contient une propriété appelée `p ```js o = new Object(); -o.hasOwnProperty('prop'); // false -o.prop = 'exists'; -o.hasOwnProperty('prop'); // true +o.hasOwnProperty("prop"); // false +o.prop = "exists"; +o.hasOwnProperty("prop"); // true ``` ### Propriétés directes et propriétés héritées @@ -48,15 +48,15 @@ L'exemple suivant illustre la différence entre les propriétés directes et les ```js o = new Object(); -o.prop = 'exists'; +o.prop = "exists"; -o.hasOwnProperty('prop'); +o.hasOwnProperty("prop"); // retourne true -o.hasOwnProperty('toString'); +o.hasOwnProperty("toString"); // retourne false -o.hasOwnProperty('hasOwnProperty'); +o.hasOwnProperty("hasOwnProperty"); // retourne false ``` @@ -66,20 +66,18 @@ L'exemple suivant montre comment parcourir les propriétés d'un objet sans trai ```js var bidule = { - truc: 'stack' + truc: "stack", }; for (var nom in bidule) { - if (bidule.hasOwnProperty(nom)) { - console.log("C'est bien la propriété (" + - nom + - "), sa valeur : " + bidule[nom] - ); - } - else { - console.log(nom); - // toString ou autre - } + if (bidule.hasOwnProperty(nom)) { + console.log( + "C'est bien la propriété (" + nom + "), sa valeur : " + bidule[nom], + ); + } else { + console.log(nom); + // toString ou autre + } } ``` @@ -89,20 +87,20 @@ JavaScript ne protège pas le nom de propriété `hasOwnProperty`, ainsi il est ```js var toto = { - hasOwnProperty: function() { + hasOwnProperty: function () { return false; }, - truc: 'Voici les dragons' + truc: "Voici les dragons", }; -toto.hasOwnProperty('truc'); // renvoie toujours false +toto.hasOwnProperty("truc"); // renvoie toujours false // On utilise une méthode d'un autre objet // et on l'appelle avec this qui vaut toto -({}).hasOwnProperty.call(toto, 'truc'); // true +({}).hasOwnProperty.call(toto, "truc"); // true // On peut aussi utiliser la propriété hasOwnProperty de Object prototype -Object.prototype.hasOwnProperty.call(toto, 'truc'); // true +Object.prototype.hasOwnProperty.call(toto, "truc"); // true ``` La dernière version utilisée permet de ne pas créer d'objet supplémentaire. diff --git a/files/fr/web/javascript/reference/global_objects/object/index.md b/files/fr/web/javascript/reference/global_objects/object/index.md index 887c9f7b675fe9..811a601b08b5e6 100644 --- a/files/fr/web/javascript/reference/global_objects/object/index.md +++ b/files/fr/web/javascript/reference/global_objects/object/index.md @@ -60,7 +60,7 @@ Il n'existe pas de méthode pour `Object` qui permette de supprimer une proprié - [`Object.getPrototypeOf()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Object/getPrototypeOf) - : Retourne le prototype de l'objet indiqué. - [`Object.is()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Object/is) - - : Détermine si deux valeurs sont la même valeur. Considère comme égales toutes les valeurs NaN (ce qui diffère à la fois de la *comparaison d'égalité abstraite* et de la *comparaison d'égalité stricte*). + - : Détermine si deux valeurs sont la même valeur. Considère comme égales toutes les valeurs NaN (ce qui diffère à la fois de la _comparaison d'égalité abstraite_ et de la _comparaison d'égalité stricte_). - [`Object.isExtensible()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Object/isExtensible) - : Détermine si l'extension d'un objet est permise. - [`Object.isFrozen()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Object/isFrozen) diff --git a/files/fr/web/javascript/reference/global_objects/object/is/index.md b/files/fr/web/javascript/reference/global_objects/object/is/index.md index 6608cda48fad65..2347ad9204ee51 100644 --- a/files/fr/web/javascript/reference/global_objects/object/is/index.md +++ b/files/fr/web/javascript/reference/global_objects/object/is/index.md @@ -48,32 +48,33 @@ Cette égalité est également différente de l'égalité stricte qu'on peut avo ## Exemples ```js -Object.is("toto", "toto"); // true -Object.is(window, window); // true +Object.is("toto", "toto"); // true +Object.is(window, window); // true -Object.is("toto", "truc"); // false -Object.is([], []); // false +Object.is("toto", "truc"); // false +Object.is([], []); // false -var toto = {a: 1}; -var truc = {a: 1}; -Object.is(toto, toto); // true -Object.is(toto, truc); // false +var toto = { a: 1 }; +var truc = { a: 1 }; +Object.is(toto, toto); // true +Object.is(toto, truc); // false -Object.is(null, null); // true +Object.is(null, null); // true // Cas aux limites (cas spéciaux) -Object.is(0, -0); // false -Object.is(-0, -0); // true -Object.is(NaN, 0/0); // true +Object.is(0, -0); // false +Object.is(-0, -0); // true +Object.is(NaN, 0 / 0); // true ``` ## Prothèse d'émulation (_polyfill_) ```js if (!Object.is) { - Object.is = function(v1, v2) { + Object.is = function (v1, v2) { // Algorithme SameValue - if (v1 === v2) { //Étapes 1-5, 7-10 + if (v1 === v2) { + //Étapes 1-5, 7-10 //Étapes 6.b-6.b +0 !=-0 return v1 !== 0 || 1 / v1 === 1 / v2; } else { diff --git a/files/fr/web/javascript/reference/global_objects/object/isextensible/index.md b/files/fr/web/javascript/reference/global_objects/object/isextensible/index.md index de8a886d33af24..b4b9bfe00a1d90 100644 --- a/files/fr/web/javascript/reference/global_objects/object/isextensible/index.md +++ b/files/fr/web/javascript/reference/global_objects/object/isextensible/index.md @@ -13,7 +13,7 @@ La méthode **`Object.isExtensible()`** permet de déterminer si un objet est ex ## Syntaxe ```js -Object.isExtensible(obj) +Object.isExtensible(obj); ``` ### Paramètres diff --git a/files/fr/web/javascript/reference/global_objects/object/isfrozen/index.md b/files/fr/web/javascript/reference/global_objects/object/isfrozen/index.md index 10b236c1e8ba6b..54a753f6054a53 100644 --- a/files/fr/web/javascript/reference/global_objects/object/isfrozen/index.md +++ b/files/fr/web/javascript/reference/global_objects/object/isfrozen/index.md @@ -13,7 +13,7 @@ La méthode **`Object.isFrozen()`** permet de déterminer si un objet est {{jsxr ## Syntaxe ```js -Object.isFrozen(obj) +Object.isFrozen(obj); ``` ### Paramètres diff --git a/files/fr/web/javascript/reference/global_objects/object/isprototypeof/index.md b/files/fr/web/javascript/reference/global_objects/object/isprototypeof/index.md index 99db201dfe30c2..e65d99932db42a 100644 --- a/files/fr/web/javascript/reference/global_objects/object/isprototypeof/index.md +++ b/files/fr/web/javascript/reference/global_objects/object/isprototypeof/index.md @@ -15,7 +15,7 @@ La méthode **`isPrototypeOf()`** permet de tester si un objet existe dans la ch ## Syntaxe ```js -prototypeObj.isPrototypeOf(objet) +prototypeObj.isPrototypeOf(objet); ``` ### Paramètres diff --git a/files/fr/web/javascript/reference/global_objects/object/issealed/index.md b/files/fr/web/javascript/reference/global_objects/object/issealed/index.md index 4b2b16ff68ea59..894775136eeb3f 100644 --- a/files/fr/web/javascript/reference/global_objects/object/issealed/index.md +++ b/files/fr/web/javascript/reference/global_objects/object/issealed/index.md @@ -13,7 +13,7 @@ La méthode **`Object.isSealed()`** permet de déterminer si un objet est scell ## Syntaxe ```js -Object.isSealed(obj) +Object.isSealed(obj); ``` ### Paramètres @@ -68,10 +68,14 @@ Object.isFrozen(scellé); // true var s2 = Object.seal({ p: 3 }); Object.isFrozen(s2); // false ("p" est toujours modifiable) -var s3 = Object.seal({ get p() { return 0; } }); +var s3 = Object.seal({ + get p() { + return 0; + }, +}); // pour les accesseurs, seule l'accès en // configuration est important -Object.isFrozen(s3); // true +Object.isFrozen(s3); // true ``` ## Notes diff --git a/files/fr/web/javascript/reference/global_objects/object/keys/index.md b/files/fr/web/javascript/reference/global_objects/object/keys/index.md index 0d164ff488ea28..dd839274fa2260 100644 --- a/files/fr/web/javascript/reference/global_objects/object/keys/index.md +++ b/files/fr/web/javascript/reference/global_objects/object/keys/index.md @@ -13,7 +13,7 @@ La méthode **`Object.keys()`** renvoie un tableau contenant les noms des propri ## Syntaxe ```js -Object.keys(obj) +Object.keys(obj); ``` ### Paramètres @@ -37,23 +37,27 @@ console.log(Object.keys(arr)); // affichera ['0', '1', '2'] // un objet semblable à un tableau -var obj = { 0 : "a", 1 : "b", 2 : "c"}; +var obj = { 0: "a", 1: "b", 2: "c" }; console.log(Object.keys(obj)); // affichera ['0', '1', '2'] // un objet semblable à un tableau avec // un ordre de clé aléatoire -var an_obj = { 100: "a", 2: "b", 7: "c"}; +var an_obj = { 100: "a", 2: "b", 7: "c" }; console.log(Object.keys(an_obj)); // affichera ['2', '7', '100'] // getToto est une propriété non énumérable -var monObjet = Object.create({}, { - getToto : { - value : function () { - return this.toto } - } - }); +var monObjet = Object.create( + {}, + { + getToto: { + value: function () { + return this.toto; + }, + }, + }, +); monObjet.toto = 1; console.log(Object.keys(monObjet)); diff --git a/files/fr/web/javascript/reference/global_objects/object/object/index.md b/files/fr/web/javascript/reference/global_objects/object/object/index.md index e1577aa862c6b1..85c048da6822e7 100644 --- a/files/fr/web/javascript/reference/global_objects/object/object/index.md +++ b/files/fr/web/javascript/reference/global_objects/object/object/index.md @@ -17,8 +17,8 @@ Lorsqu'il est appelé comme une fonction plutôt que comme un constructeur (c'es ## Syntaxe ```js -new Object() -new Object(valeur) +new Object(); +new Object(valeur); ``` ### Paramètres diff --git a/files/fr/web/javascript/reference/global_objects/object/preventextensions/index.md b/files/fr/web/javascript/reference/global_objects/object/preventextensions/index.md index 98df4de609f973..7b6d9078680292 100644 --- a/files/fr/web/javascript/reference/global_objects/object/preventextensions/index.md +++ b/files/fr/web/javascript/reference/global_objects/object/preventextensions/index.md @@ -13,7 +13,7 @@ La méthode **`Object.preventExtensions()`** permet d'empêcher l'ajout de nouve ## Syntaxe ```js -Object.preventExtensions(obj) +Object.preventExtensions(obj); ``` ### Paramètres diff --git a/files/fr/web/javascript/reference/global_objects/object/propertyisenumerable/index.md b/files/fr/web/javascript/reference/global_objects/object/propertyisenumerable/index.md index b935bbd62ae9fd..731f2ec3162cf8 100644 --- a/files/fr/web/javascript/reference/global_objects/object/propertyisenumerable/index.md +++ b/files/fr/web/javascript/reference/global_objects/object/propertyisenumerable/index.md @@ -13,7 +13,7 @@ La méthode **`propertyIsEnumerable()`** renvoie un booléen qui indique si la p ## Syntaxe ```js -obj.propertyIsEnumerable(prop) +obj.propertyIsEnumerable(prop); ``` ### Paramètres @@ -38,11 +38,11 @@ Dans l'exemple qui suit, on illustre comment utiliser `propertyIsEnumerable` sur ```js var o = {}; var a = []; -o.prop = 'est énumérable'; -a[0] = 'est énumérable'; +o.prop = "est énumérable"; +a[0] = "est énumérable"; -o.propertyIsEnumerable('prop'); // renvoie true -a.propertyIsEnumerable(0); // renvoie true +o.propertyIsEnumerable("prop"); // renvoie true +a.propertyIsEnumerable(0); // renvoie true ``` ### Objets natifs et objets définis par l'utilisateur @@ -50,50 +50,52 @@ a.propertyIsEnumerable(0); // renvoie true Dans l'exemple ci-dessous, on illustre l'énumérabilité des propriétés des objets natifs et celle des objets tiers, définis dans les scripts : ```js -var a = ['est énumérable']; +var a = ["est énumérable"]; -a.propertyIsEnumerable(0); // renvoie true -a.propertyIsEnumerable('length'); // renvoie false +a.propertyIsEnumerable(0); // renvoie true +a.propertyIsEnumerable("length"); // renvoie false -Math.propertyIsEnumerable('random'); // renvoie false -this.propertyIsEnumerable('Math'); // renvoie false +Math.propertyIsEnumerable("random"); // renvoie false +this.propertyIsEnumerable("Math"); // renvoie false ``` ### Propriétés héritées et propriétés propres ```js var a = []; -a.propertyIsEnumerable('constructor'); // renvoie false +a.propertyIsEnumerable("constructor"); // renvoie false function premierConstructeur() { - this.propriete = 'non énumérable'; + this.propriete = "non énumérable"; } -premierConstructeur.prototype.premiereMethode = function() {}; +premierConstructeur.prototype.premiereMethode = function () {}; function secondConstructeur() { - this.methode = function methode() { return 'énumérable'; }; + this.methode = function methode() { + return "énumérable"; + }; } -secondConstructeur.prototype = new premierConstructeur; +secondConstructeur.prototype = new premierConstructeur(); secondConstructeur.prototype.constructor = secondConstructeur; var o = new secondConstructeur(); -o.propArbitraire = 'is enumerable'; +o.propArbitraire = "is enumerable"; -o.propertyIsEnumerable('propArbitraire'); // renvoie true -o.propertyIsEnumerable('méthode'); // renvoie true -o.propertyIsEnumerable('propriété'); // renvoie false +o.propertyIsEnumerable("propArbitraire"); // renvoie true +o.propertyIsEnumerable("méthode"); // renvoie true +o.propertyIsEnumerable("propriété"); // renvoie false -o.propriete = 'énumérable'; +o.propriete = "énumérable"; -o.propertyIsEnumerable('propriété'); // renvoie true +o.propertyIsEnumerable("propriété"); // renvoie true // Ces instructions renvoient false car propertyIsEnumerable // ne prend pas en compte la chaîne de prototypes -o.propertyIsEnumerable('prototype'); // renvoie false -o.propertyIsEnumerable('constructor'); // renvoie false -o.propertyIsEnumerable('premièreMéthode'); // renvoie false +o.propertyIsEnumerable("prototype"); // renvoie false +o.propertyIsEnumerable("constructor"); // renvoie false +o.propertyIsEnumerable("premièreMéthode"); // renvoie false ``` ## Spécifications diff --git a/files/fr/web/javascript/reference/global_objects/object/proto/index.md b/files/fr/web/javascript/reference/global_objects/object/proto/index.md index cef3267be619a9..930c56679e84b2 100644 --- a/files/fr/web/javascript/reference/global_objects/object/proto/index.md +++ b/files/fr/web/javascript/reference/global_objects/object/proto/index.md @@ -52,8 +52,12 @@ console.log(aucunProto.__proto__); // 17 console.log(Object.getPrototypeOf(aucunProto)); // null var protoCaché = {}; -Object.defineProperty(protoCaché, "__proto__", - { value: 42, writable: true, configurable: true, enumerable: true }); +Object.defineProperty(protoCaché, "__proto__", { + value: 42, + writable: true, + configurable: true, + enumerable: true, +}); console.log(protoCaché.__proto__); // 42 console.log(Object.getPrototypeOf(protoCaché) === Object.prototype); // true @@ -101,9 +105,16 @@ On notera que même la propriété `__proto__` de `Object.prototype` peut être ```js var b = {}; -Object.prototype.__proto__ = - Object.create(null, //[[Prototype]] - { salut: { value: function () {console.log('salut');}}}); +Object.prototype.__proto__ = Object.create( + null, //[[Prototype]] + { + salut: { + value: function () { + console.log("salut"); + }, + }, + }, +); b.salut(); ``` diff --git a/files/fr/web/javascript/reference/global_objects/object/seal/index.md b/files/fr/web/javascript/reference/global_objects/object/seal/index.md index 27f5c5edb25060..ec8ef00f3a1a03 100644 --- a/files/fr/web/javascript/reference/global_objects/object/seal/index.md +++ b/files/fr/web/javascript/reference/global_objects/object/seal/index.md @@ -13,7 +13,7 @@ La méthode **`Object.seal()`** scelle un objet afin d'empêcher l'ajout de nouv ## Syntaxe ```js -Object.seal(obj) +Object.seal(obj); ``` ### Paramètres @@ -35,9 +35,9 @@ La chaîne de prototypes reste la même. Cependant, la propriété [`Object.prot ```js var obj = { - prop: function () {}, - toto: "truc" - }; + prop: function () {}, + toto: "truc", +}; // On peut ajouter de nouvelles propriétés // Les propriétés existantes peuvent être @@ -57,7 +57,11 @@ obj.toto = "moh"; // Mais on ne peut pas convertir les données // en accesseurs (ou vice versa) -Object.defineProperty(obj, "toto", { get: function() { return "g"; } }); +Object.defineProperty(obj, "toto", { + get: function () { + return "g"; + }, +}); // lancera une TypeError // Tout autre changement que celui d'une valeur diff --git a/files/fr/web/javascript/reference/global_objects/object/setprototypeof/index.md b/files/fr/web/javascript/reference/global_objects/object/setprototypeof/index.md index d13ad09d8b4915..eaebeff9b2a22c 100644 --- a/files/fr/web/javascript/reference/global_objects/object/setprototypeof/index.md +++ b/files/fr/web/javascript/reference/global_objects/object/setprototypeof/index.md @@ -13,7 +13,7 @@ La méthode **`Object.setPrototypeOf()`** définit le prototype (autrement dit l ## Syntaxe ```js -Object.setPrototypeOf(obj, prototype) +Object.setPrototypeOf(obj, prototype); ``` ### Paramètres @@ -45,10 +45,12 @@ En utilisant la propriété [`Object.prototype.__proto__`](/fr/docs/Web/JavaScri ```js // Cette prothèse ne fonctionne pas pour IE -Object.setPrototypeOf = Object.setPrototypeOf || function (obj, proto) { - obj.__proto__ = proto; - return obj; -} +Object.setPrototypeOf = + Object.setPrototypeOf || + function (obj, proto) { + obj.__proto__ = proto; + return obj; + }; ``` ## Ajouter une chaîne de prototypes à un objet @@ -57,10 +59,10 @@ En combinant `Object.getPrototypeOf()` et [`Object.prototype.__proto__`](/fr/doc ```js /** -*** Object.setPrototypeOf(@object, @prototype) -* Change le prototype d'une instance -* -**/ + *** Object.setPrototypeOf(@object, @prototype) + * Change le prototype d'une instance + * + **/ Object.setPrototypeOf = function (oInstance, oProto) { oInstance.__proto__ = oProto; @@ -68,32 +70,42 @@ Object.setPrototypeOf = function (oInstance, oProto) { }; /** -*** Object.appendChain(@object, @prototype) -* -* Ajoute le premier prototype non-natif d'une chaîne au nouveau prototype. -* Renvoie @object (si c'est une valeur primitive, elle sera transformée -* en objet). -* -*** Object.appendChain(@object [, "@arg_name_1", "@arg_name_2", "@arg_name_3", "..."], "@function_body") -*** Object.appendChain(@object [, "@arg_name_1, @arg_name_2, @arg_name_3, ..."], "@function_body") -* -* Ajoute le premier prototype non-natif d'une chaîne à l'objet Function.prototype -* puis ajoute new Function(["@arg"(s)], "@function_body") à cette chaîne. -* Renvoie la fonction. -* -**/ + *** Object.appendChain(@object, @prototype) + * + * Ajoute le premier prototype non-natif d'une chaîne au nouveau prototype. + * Renvoie @object (si c'est une valeur primitive, elle sera transformée + * en objet). + * + *** Object.appendChain(@object [, "@arg_name_1", "@arg_name_2", "@arg_name_3", "..."], "@function_body") + *** Object.appendChain(@object [, "@arg_name_1, @arg_name_2, @arg_name_3, ..."], "@function_body") + * + * Ajoute le premier prototype non-natif d'une chaîne à l'objet Function.prototype + * puis ajoute new Function(["@arg"(s)], "@function_body") à cette chaîne. + * Renvoie la fonction. + * + **/ Object.appendChain = function (oChain, oProto) { if (arguments.length < 2) { throw new TypeError("Object.appendChain - Pas suffisamment d'arguments"); } - if (typeof oProto !== 'object' && typeof oProto !== 'string') { - throw new TypeError("le deuxième argument de Object.appendChain doit être un objet ou une chaîne"); + if (typeof oProto !== "object" && typeof oProto !== "string") { + throw new TypeError( + "le deuxième argument de Object.appendChain doit être un objet ou une chaîne", + ); } - var oNewProto = oProto, oReturn = o2nd = oLast = oChain instanceof this ? oChain : new oChain.constructor(oChain); - - for (var o1st = this.getPrototypeOf(o2nd); o1st !== Object.prototype && o1st !== Function.prototype; o1st = this.getPrototypeOf(o2nd)) { + var oNewProto = oProto, + oReturn = + (o2nd = + oLast = + oChain instanceof this ? oChain : new oChain.constructor(oChain)); + + for ( + var o1st = this.getPrototypeOf(o2nd); + o1st !== Object.prototype && o1st !== Function.prototype; + o1st = this.getPrototypeOf(o2nd) + ) { o2nd = o1st; } @@ -105,7 +117,7 @@ Object.appendChain = function (oChain, oProto) { this.setPrototypeOf(o2nd, oNewProto); return oReturn; -} +}; ``` ### Utilisation @@ -113,11 +125,11 @@ Object.appendChain = function (oChain, oProto) { #### Ajouter une chaîne de prototypes à un prototype ```js -function Mammifère () { +function Mammifère() { this.isMammifère = "oui"; } -function EspèceMammifère (sEspèceMammifère) { +function EspèceMammifère(sEspèceMammifère) { this.espèce = sEspèceMammifère; } @@ -128,7 +140,7 @@ var oChat = new EspèceMammifère("Felis"); console.log(oChat.isMammifère); // "oui" -function Animal () { +function Animal() { this.respire = "oui"; } @@ -140,7 +152,7 @@ console.log(oChat.respire); // "oui" #### Deuxième exemple : Transformer une valeur primitive en une instance de son constructeur et ajouter sa chaîne à un prototype ```js -function MySymbol () { +function MySymbol() { this.isSymbol = "yes"; } @@ -158,12 +170,14 @@ console.log(typeof oPrime); // "object" #### Troisième exemple : Ajouter une chaîne de prototypes à l'objet Function.prototype object et ajouter une nouvelle fonction à cette chaîne ```js -function Personne (sNom) { +function Personne(sNom) { this.identité = sNom; } -var george = Object.appendChain(new Person("George"), - "console.log(\"Salut !!\");"); +var george = Object.appendChain( + new Person("George"), + 'console.log("Salut !!");', +); console.log(george.identité); // "George" george(); // "Salut !!" diff --git a/files/fr/web/javascript/reference/global_objects/object/tolocalestring/index.md b/files/fr/web/javascript/reference/global_objects/object/tolocalestring/index.md index 0bc845fb21c25e..970f35c1aa3d5e 100644 --- a/files/fr/web/javascript/reference/global_objects/object/tolocalestring/index.md +++ b/files/fr/web/javascript/reference/global_objects/object/tolocalestring/index.md @@ -13,7 +13,7 @@ La méthode **`toLocaleString()`** renvoie une chaine de caractères représenta ## Syntaxe ```js -obj.toLocaleString() +obj.toLocaleString(); ``` ### Valeur de retour diff --git a/files/fr/web/javascript/reference/global_objects/object/tostring/index.md b/files/fr/web/javascript/reference/global_objects/object/tostring/index.md index 8ef6b90b6df900..e23257c39b7907 100644 --- a/files/fr/web/javascript/reference/global_objects/object/tostring/index.md +++ b/files/fr/web/javascript/reference/global_objects/object/tostring/index.md @@ -13,7 +13,7 @@ La méthode **`toString()`** renvoie une chaîne de caractères représentant l' ## Syntaxe ```js -obj.toString() +obj.toString(); ``` ### Valeur de retour @@ -26,7 +26,7 @@ Chaque object possède une méthode `toString()` qui est appelée de façon auto ```js var o = new Object(); -o.toString(); // renvoie [object Object] +o.toString(); // renvoie [object Object] ``` > **Note :** À partir de JavaScript 1.8.5 `toString()`, lorsqu'elle est appelée sur {{jsxref("null")}} renvoie `[object Null]`, et lorsqu'elle est appelée sur {{jsxref("undefined")}} renvoie `[object Undefined]`, ce qui est conforme à ECMAScript 5 et aux errata qui ont suivis. Voir l'exemple ci-après [Utiliser `toString` pour détecter le type d'un objet](#detect). @@ -47,7 +47,7 @@ function Chien(nom, race, couleur, sexe) { this.sexe = sexe; } -monChien = new Chien('Gabby', 'Labrador', 'chocolat', 'femelle'); +monChien = new Chien("Gabby", "Labrador", "chocolat", "femelle"); ``` Si on appelle la méthode `toString()` sur cet objet, on aura le résultat suivant (provenant de la méthode originale, héritée d'{{jsxref("Object")}}) : @@ -60,9 +60,17 @@ Dans le code qui suit, on surcharge la méthode `toString()` avec `chienToString ```js Chien.prototype.toString = function chienToString() { - var ret = 'Le chien ' + this.nom + ' est un ' + this.race + ' ' + this.sexe + ' ' + this.couleur; + var ret = + "Le chien " + + this.nom + + " est un " + + this.race + + " " + + this.sexe + + " " + + this.couleur; return ret; -} +}; ``` En utilisant la fonction ci-avant, à chaque fois que `monChien` sera utilisé là où on attend une chaîne, le moteur JavaScript appellera automatique la fonction `chienToString()` qui renverra la chaîne suivante : @@ -78,13 +86,13 @@ Le chien Gabby est un labrador femelle chocolat. ```js var toString = Object.prototype.toString; -toString.call(new Date); // [object Date] -toString.call(new String); // [object String] -toString.call(Math); // [object Math] +toString.call(new Date()); // [object Date] +toString.call(new String()); // [object String] +toString.call(Math); // [object Math] // Depuis JavaScript 1.8.5 -toString.call(undefined); // [object Undefined] -toString.call(null); // [object Null] +toString.call(undefined); // [object Undefined] +toString.call(null); // [object Null] ``` ## Spécifications diff --git a/files/fr/web/javascript/reference/global_objects/object/valueof/index.md b/files/fr/web/javascript/reference/global_objects/object/valueof/index.md index fa5dd7e59a7b0e..4d773fa6890d44 100644 --- a/files/fr/web/javascript/reference/global_objects/object/valueof/index.md +++ b/files/fr/web/javascript/reference/global_objects/object/valueof/index.md @@ -13,7 +13,7 @@ La méthode **`valueOf()`** renvoie la valeur primitive d'un objet donné. ## Syntaxe ```js -object.valueOf() +object.valueOf(); ``` ### Valeur de retour @@ -39,7 +39,9 @@ Il est possible de créer une fonction à appeler à la place de la méthode `va Supposons qu'on ait un type d'objet `monTypeDeNombre` et qu'on désire lui ajouter une méthode `valueOf` spécifique, on pourra utiliser le code suivant : ```js -monTypeDeNombre.prototype.valueOf = function(){ return valeurPrimitive;}; +monTypeDeNombre.prototype.valueOf = function () { + return valeurPrimitive; +}; ``` En utilisant ce code, chaque fois qu'un objet de type `monTypeDeNombre` sera utilisé dans un contexte où il doit être représenté comme une valeur primitive, JavaScript appellera automatiquement la fonction qui y est définie. @@ -47,7 +49,7 @@ En utilisant ce code, chaque fois qu'un objet de type `monTypeDeNombre` sera uti C'est habituellement JavaScript qui invoquera la méthode `valueOf`, mais il est aussi possible de l'appeler soi-même : ```js -monNombre.valueOf() +monNombre.valueOf(); ``` > **Note :** Les objets à utiliser dans un contexte textuel sont convertis avec la méthode {{jsxref("Object.toString", "toString()")}} ce qui est différent de la conversion d'objets {{jsxref("String")}} en valeurs primitives avec `valueOf`. Tous les objets peuvent être convertis en chaînes de caractères (la façon la plus générique étant "`[object type]`"). En revanche, la plupart des objets ne peut pas être convertie en nombre ou booléen par exemple. @@ -58,12 +60,12 @@ monNombre.valueOf() ```js function MonTypeDeNombre(n) { - this.nombre = n; + this.nombre = n; } -MonTypeDeNombre.prototype.valueOf = function(){ +MonTypeDeNombre.prototype.valueOf = function () { return this.nombre; -} +}; var monObj = new MonTypeDeNombre(4); console.log(monObj + 3); // 7 car l'opération a implicitement utilisé valueOf diff --git a/files/fr/web/javascript/reference/global_objects/object/values/index.md b/files/fr/web/javascript/reference/global_objects/object/values/index.md index e1e478efe8ddd9..d008cef25b3e90 100644 --- a/files/fr/web/javascript/reference/global_objects/object/values/index.md +++ b/files/fr/web/javascript/reference/global_objects/object/values/index.md @@ -13,7 +13,7 @@ La méthode **`Object.values()`** renvoie un tableau contenant les valeurs des p ## Syntaxe ```js -Object.values(obj) +Object.values(obj); ``` ### Paramètres @@ -36,19 +36,28 @@ var obj = { toto: "truc", machin: 42 }; console.log(Object.values(obj)); // ['truc', 42] // un objet semblable à un tableau -var obj = { 0: 'a', 1: 'b', 2: 'c' }; +var obj = { 0: "a", 1: "b", 2: "c" }; console.log(Object.values(obj)); // ['a', 'b', 'c'] // un objet semblable à un tableau // dont les clés sont ordonnées aléatoirement // lorsque des clés numériques sont utilisées, les valeurs sont // renvoyées selon l'ordre numérique des clés -var un_obj = { 100: 'a', 2: 'b', 7: 'c' }; +var un_obj = { 100: "a", 2: "b", 7: "c" }; console.log(Object.values(un_obj)); // ['b', 'c', 'a'] // getToto est une propriété qui // n'est pas énumérable -var mon_obj = Object.create({}, { getToto: { value: function() { return this.toto; } } }); +var mon_obj = Object.create( + {}, + { + getToto: { + value: function () { + return this.toto; + }, + }, + }, +); mon_obj.toto = "truc"; console.log(Object.values(mon_obj)); // ['truc'] diff --git a/files/fr/web/javascript/reference/global_objects/parsefloat/index.md b/files/fr/web/javascript/reference/global_objects/parsefloat/index.md index 9341a628687765..4ac4fb230dee1e 100644 --- a/files/fr/web/javascript/reference/global_objects/parsefloat/index.md +++ b/files/fr/web/javascript/reference/global_objects/parsefloat/index.md @@ -13,7 +13,7 @@ La fonction **`parseFloat()`** permet de transformer une chaîne de caractères ## Syntaxe ```js -parseFloat(string) +parseFloat(string); ``` ### Paramètres @@ -56,7 +56,9 @@ parseFloat("0.0314E+2"); parseFloat("3.14d'autres caractères non numériques"); var titi = Object.create(null); -titi.valueOf = function () { return "3.14"; }; +titi.valueOf = function () { + return "3.14"; +}; parseFloat(titi); ``` @@ -81,20 +83,19 @@ Si on souhaite éviter de convertir des chaînes qui contiennent des caractères ```js var filterFloat = function (value) { - if (/^(\-|\+)?([0-9]+(\.[0-9]+)?|Infinity)$/ - .test(value)) - return Number(value); + if (/^(\-|\+)?([0-9]+(\.[0-9]+)?|Infinity)$/.test(value)) + return Number(value); return NaN; -} - -console.log(filterFloat('421')); // 421 -console.log(filterFloat('-421')); // -421 -console.log(filterFloat('+421')); // 421 -console.log(filterFloat('Infinity')); // Infinity -console.log(filterFloat('1.61803398875')); // 1.61803398875 -console.log(filterFloat('421e+0')); // NaN -console.log(filterFloat('421hop')); // NaN -console.log(filterFloat('hop1.61803398875')); // NaN +}; + +console.log(filterFloat("421")); // 421 +console.log(filterFloat("-421")); // -421 +console.log(filterFloat("+421")); // 421 +console.log(filterFloat("Infinity")); // Infinity +console.log(filterFloat("1.61803398875")); // 1.61803398875 +console.log(filterFloat("421e+0")); // NaN +console.log(filterFloat("421hop")); // NaN +console.log(filterFloat("hop1.61803398875")); // NaN ``` Attention : ce code n'est qu'un exemple et renverra `NaN` pour des valeurs pourtant valides comme `1.` ou `.5`. diff --git a/files/fr/web/javascript/reference/global_objects/parseint/index.md b/files/fr/web/javascript/reference/global_objects/parseint/index.md index 3c7c89da5cbdfc..1976e8b2c68552 100644 --- a/files/fr/web/javascript/reference/global_objects/parseint/index.md +++ b/files/fr/web/javascript/reference/global_objects/parseint/index.md @@ -78,8 +78,8 @@ Les exemples suivants renvoient **`NaN`** : ```js parseInt("Coucou", 8); // Ce sont des lettres et pas des chiffres -parseInt("546", 2); // Ces chiffres ne sont pas valides pour une représentation - // binaire +parseInt("546", 2); // Ces chiffres ne sont pas valides pour une représentation +// binaire ``` Les exemples suivants renvoient tous **`-15`** : @@ -88,7 +88,7 @@ Les exemples suivants renvoient tous **`-15`** : parseInt("-F", 16); parseInt("-0F", 16); parseInt("-0XF", 16); -parseInt(-15.1, 10) +parseInt(-15.1, 10); parseInt("-17", 8); parseInt("-15", 10); parseInt("-1111", 2); @@ -121,7 +121,7 @@ Bien que cela soit fortement déconseillé par ECMAScript 3 et que cela soit int ```js parseInt("0e0"); // 0 -parseInt("08"); // 0, '8' n'est pas un chiffre octal. +parseInt("08"); // 0, '8' n'est pas un chiffre octal. ``` ### ECMAScript 5 supprime l'interprétation octale @@ -140,19 +140,18 @@ Il est parfois utile d'avoir une fonction de conversion plus stricte. Pour cela, ```js filterInt = function (value) { - if (/^(-|\+)?(\d+|Infinity)$/.test(value)) - return Number(value); + if (/^(-|\+)?(\d+|Infinity)$/.test(value)) return Number(value); return NaN; -} - -console.log(filterInt('421')); // 421 -console.log(filterInt('-421')); // -421 -console.log(filterInt('+421')); // 421 -console.log(filterInt('Infinity')); // Infinity -console.log(filterInt('421e+0')); // NaN -console.log(filterInt('421hop')); // NaN -console.log(filterInt('hop1.61803398875')); // NaN -console.log(filterInt('1.61803398875')); // NaN +}; + +console.log(filterInt("421")); // 421 +console.log(filterInt("-421")); // -421 +console.log(filterInt("+421")); // 421 +console.log(filterInt("Infinity")); // Infinity +console.log(filterInt("421e+0")); // NaN +console.log(filterInt("421hop")); // NaN +console.log(filterInt("hop1.61803398875")); // NaN +console.log(filterInt("1.61803398875")); // NaN ``` ## Spécifications diff --git a/files/fr/web/javascript/reference/global_objects/promise/all/index.md b/files/fr/web/javascript/reference/global_objects/promise/all/index.md index 4520ef8ed59ef6..dfb98d2e2fb415 100644 --- a/files/fr/web/javascript/reference/global_objects/promise/all/index.md +++ b/files/fr/web/javascript/reference/global_objects/promise/all/index.md @@ -48,10 +48,10 @@ Cette méthode peut être utile lorsqu'on souhaite agréger le résultat de plus var p1 = Promise.resolve(3); var p2 = 1337; var p3 = new Promise((resolve, reject) => { - setTimeout(resolve, 100, 'foo'); + setTimeout(resolve, 100, "foo"); }); -Promise.all([p1, p2, p3]).then(values => { +Promise.all([p1, p2, p3]).then((values) => { console.log(values); // [3, 1337, "foo"] }); ``` @@ -62,36 +62,41 @@ La promesse créée par `Promise.all()` échoue immédiatement si l'une des prom ```js var p1 = new Promise((resolve, reject) => { - setTimeout(resolve, 1000, 'un'); + setTimeout(resolve, 1000, "un"); }); var p2 = new Promise((resolve, reject) => { - setTimeout(resolve, 2000, 'deux'); + setTimeout(resolve, 2000, "deux"); }); var p3 = new Promise((resolve, reject) => { - setTimeout(resolve, 3000, 'trois'); + setTimeout(resolve, 3000, "trois"); }); var p4 = new Promise((resolve, reject) => { - setTimeout(resolve, 4000, 'quatre'); + setTimeout(resolve, 4000, "quatre"); }); var p5 = new Promise((resolve, reject) => { - reject('rejet'); + reject("rejet"); }); -Promise.all([p1, p2, p3, p4, p5]).then(values => { - console.log(values); -}, reason => { - console.log(reason) -}); +Promise.all([p1, p2, p3, p4, p5]).then( + (values) => { + console.log(values); + }, + (reason) => { + console.log(reason); + }, +); // Dans la console : // "rejet" //On peut aussi employer .catch -Promise.all([p1, p2, p3, p4, p5]).then(values => { - console.log(values); -}).catch(reason => { - console.log(reason) -}); +Promise.all([p1, p2, p3, p4, p5]) + .then((values) => { + console.log(values); + }) + .catch((reason) => { + console.log(reason); + }); // Dans la console : // "rejet" @@ -101,20 +106,24 @@ Il est possible de modifier ce comportement en gérant les éventuels échecs : ```js var p1 = new Promise((resolve, reject) => { - setTimeout(resolve, 1000, 'p1_resolution_retardee'); + setTimeout(resolve, 1000, "p1_resolution_retardee"); }); var p2 = new Promise((resolve, reject) => { - reject(new Error('p2_rejet_immediat')); + reject(new Error("p2_rejet_immediat")); }); Promise.all([ - p1.catch(error => { return error }), - p2.catch(error => { return error }), -]).then(values => { + p1.catch((error) => { + return error; + }), + p2.catch((error) => { + return error; + }), +]).then((values) => { console.log(values[0]); // "p1_resolution_retardee" console.log(values[1]); // "Error: p2_rejet_immediat" -}) +}); ``` ### Caractère asynchrone de `Promise.all()` @@ -132,9 +141,9 @@ console.log(p); // on utilise la méthode setTimeout pour exécuter // du code dès que la pile est vide -setTimeout(function() { - console.log('La pile est vide'); - console.log(p); +setTimeout(function () { + console.log("La pile est vide"); + console.log(p); }); // Cela affichera dans la console (et dans cet ordre) : @@ -149,9 +158,9 @@ On aura le même comportement si `Promise.all` produit une promesse rompue : var mixedPromisesArray = [Promise.resolve(33), Promise.reject(44)]; var p = Promise.all(mixedPromisesArray); console.log(p); -setTimeout(function() { - console.log('La pile est vide'); - console.log(p); +setTimeout(function () { + console.log("La pile est vide"); + console.log(p); }); // Affichera : @@ -170,10 +179,10 @@ var p = Promise.all([]); // immédiatement résolue // de façon asynchrone var p2 = Promise.all([1337, "hi"]); console.log(p); -console.log(p2) -setTimeout(function() { - console.log('La pile est vide'); - console.log(p2); +console.log(p2); +setTimeout(function () { + console.log("La pile est vide"); + console.log(p2); }); // Affichera : diff --git a/files/fr/web/javascript/reference/global_objects/promise/any/index.md b/files/fr/web/javascript/reference/global_objects/promise/any/index.md index 7429d3cab1d392..bac59c6fb108dd 100644 --- a/files/fr/web/javascript/reference/global_objects/promise/any/index.md +++ b/files/fr/web/javascript/reference/global_objects/promise/any/index.md @@ -82,7 +82,7 @@ const pErr = new Promise((resolve, reject) => { Promise.any([pErr]).catch((err) => { console.log(err); -}) +}); // résultat attendu : "AggregateError: No Promise in Promise.any was resolved" ``` @@ -92,26 +92,25 @@ Dans cet exemple, nous avons une fonction qui requête une image et retourne un ```js function fetchAndDecode(url) { - return fetch(url).then(réponse => { - if (!réponse.ok) - throw new Error(`Erreur HTTP ! état : ${response.status}`); - else - return réponse.blob(); - }) + return fetch(url).then((réponse) => { + if (!réponse.ok) throw new Error(`Erreur HTTP ! état : ${response.status}`); + else return réponse.blob(); + }); } -let café = fetchAndDecode('coffee.jpg'); -let thé = fetchAndDecode('tea.jpg'); - -Promise.any([café, thé]).then(valeur => { - let URLobjet = URL.createObjectURL(valeur); - let image = document.createElement('img'); - image.src = URLobjet; - document.body.appendChild(image); -}) -.catch(e => { - console.log(e.message); -}); +let café = fetchAndDecode("coffee.jpg"); +let thé = fetchAndDecode("tea.jpg"); + +Promise.any([café, thé]) + .then((valeur) => { + let URLobjet = URL.createObjectURL(valeur); + let image = document.createElement("img"); + image.src = URLobjet; + document.body.appendChild(image); + }) + .catch((e) => { + console.log(e.message); + }); ``` ## Spécifications diff --git a/files/fr/web/javascript/reference/global_objects/promise/catch/index.md b/files/fr/web/javascript/reference/global_objects/promise/catch/index.md index 0df1f5092183d1..53882118898b10 100644 --- a/files/fr/web/javascript/reference/global_objects/promise/catch/index.md +++ b/files/fr/web/javascript/reference/global_objects/promise/catch/index.md @@ -15,7 +15,7 @@ La méthode **`catch()`** renvoie un objet {{jsxref("Promise")}} et ne traite qu ```js p.catch(siRejetée); -p.catch(function(raison) { +p.catch(function (raison) { // rejet }); ``` @@ -44,48 +44,52 @@ La méthode `catch()` est utile pour gérer les cas d'erreur en cas de compositi ### Utilisation de la méthode `catch` ```js -var p1 = new Promise(function(resolve, reject) { +var p1 = new Promise(function (resolve, reject) { resolve("Succès"); }); -p1.then(function(value) { +p1.then(function (value) { console.log(value); // "Succès!" throw new Error("zut !"); -}).catch(function(e) { - console.error(e.message); // "zut !" -}).then(function(e) { - console.log('après le catch, la chaîne est restaurée'); -}); +}) + .catch(function (e) { + console.error(e.message); // "zut !" + }) + .then(function (e) { + console.log("après le catch, la chaîne est restaurée"); + }); // Le code qui suit est équivalent : -p1.then(function(value) { +p1.then(function (value) { console.log(value); // "Succès!" - return Promise.reject('zut !'); -}).catch(function(e) { - console.log(e); // "zut !" -}).then(function(e){ - console.log('après le catch, la chaîne est restaurée'); -}); + return Promise.reject("zut !"); +}) + .catch(function (e) { + console.log(e); // "zut !" + }) + .then(function (e) { + console.log("après le catch, la chaîne est restaurée"); + }); ``` ### Les promesses n'interceptent pas les exceptions levées de façon asynchrone ```js -var p1 = new Promise(function(resolve, reject) { - throw new Error('Oh oh!'); +var p1 = new Promise(function (resolve, reject) { + throw new Error("Oh oh!"); }); -p1.catch(function(e) { +p1.catch(function (e) { console.log(e.message); // "Oh oh!" }); -var p2 = new Promise(function(resolve, reject) { - setTimeout(function() { - throw new Error('Exception invisible !'); +var p2 = new Promise(function (resolve, reject) { + setTimeout(function () { + throw new Error("Exception invisible !"); }, 1000); }); -p2.catch(function(e) { +p2.catch(function (e) { console.log(e.message); // Cela n'est jamais appelé }); ``` @@ -95,25 +99,30 @@ p2.catch(function(e) { ```js // On surcharge Promise.prototype.then/catch // pour y ajouter des logs -(function(Promise){ - var originalThen = Promise.prototype.then; - var originalCatch = Promise.prototype.catch; - - Promise.prototype.then = function(){ - console.log('> > > > > > appel de .then sur %o avec les arguments: %o', this, arguments); - return originalThen.apply(this, arguments); - }; - Promise.prototype.catch = function(){ - console.log('> > > > > > appel de .catch sur %o avec les arguments: %o', this, arguments); - return originalCatch.apply(this, arguments); - }; - +(function (Promise) { + var originalThen = Promise.prototype.then; + var originalCatch = Promise.prototype.catch; + + Promise.prototype.then = function () { + console.log( + "> > > > > > appel de .then sur %o avec les arguments: %o", + this, + arguments, + ); + return originalThen.apply(this, arguments); + }; + Promise.prototype.catch = function () { + console.log( + "> > > > > > appel de .catch sur %o avec les arguments: %o", + this, + arguments, + ); + return originalCatch.apply(this, arguments); + }; })(this.Promise); - - // On appelle catch sur une promesse déjà résolue -Promise.resolve().catch(function XXX(){}); +Promise.resolve().catch(function XXX() {}); // Dans la console, on aura : // > > > > > > appel de .catch sur Promise{} avec les arguments: Arguments{1} [0: function XXX()] diff --git a/files/fr/web/javascript/reference/global_objects/promise/finally/index.md b/files/fr/web/javascript/reference/global_objects/promise/finally/index.md index 549fb63a4b653e..ec3bae34de0fc4 100644 --- a/files/fr/web/javascript/reference/global_objects/promise/finally/index.md +++ b/files/fr/web/javascript/reference/global_objects/promise/finally/index.md @@ -13,7 +13,7 @@ La méthode **`finally()`** renvoie un objet `Promise` et accepte en argument un ```js p.finally(onFinally); -p.finally(function() { +p.finally(function () { // appelée dans tous les // cas de terminaison }); @@ -47,19 +47,25 @@ La méthode `finally` est similaire à l'utilisation de la forme `.then(onFinall ```js let isLoading = true; -fetch(myRequest).then(function(response) { +fetch(myRequest) + .then(function (response) { var contentType = response.headers.get("content-type"); - if(contentType && contentType.includes("application/json")) { + if (contentType && contentType.includes("application/json")) { return response.json(); } throw new TypeError("Oups, ceci n'est pas du JSON !"); }) - .then(function(json) { /* traiter le JSON */ }) - .catch(function(error) { console.log(error); - /* La ligne précédent peut aussi déclencher une + .then(function (json) { + /* traiter le JSON */ + }) + .catch(function (error) { + console.log(error); + /* La ligne précédent peut aussi déclencher une erreur (si console vaut {} par exemple) */ - }) - .finally(function() { isLoading = false; }); + }) + .finally(function () { + isLoading = false; + }); ``` ## Spécifications 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 63e349b1f79f98..f49c7553f05488 100644 --- a/files/fr/web/javascript/reference/global_objects/promise/index.md +++ b/files/fr/web/javascript/reference/global_objects/promise/index.md @@ -41,7 +41,7 @@ La méthode `.then()` prend deux arguments : le premier est une fonction de ```js const maPromesse = new Promise((resolve, reject) => { setTimeout(() => { - resolve('toto'); + resolve("toto"); }, 300); }); @@ -57,22 +57,34 @@ La gestion d'une promesse rompue dans chaque `.then()` a des conséquences plus ```js maPromesse -.then(gestionnaireSuccesA) -.then(gestionnaireSuccesB) -.then(gestionnaireSuccesC) -.catch(gestionnaireToutEchec); + .then(gestionnaireSuccesA) + .then(gestionnaireSuccesB) + .then(gestionnaireSuccesC) + .catch(gestionnaireToutEchec); ``` On peut utiliser les [expressions de fonctions fléchées](/fr/docs/Web/JavaScript/Reference/Functions/Arrow_functions) pour les fonctions de rappel. Un enchaînement avec cette forme pourra alors ressembler à : ```js promesse1 -.then(valeur => { return valeur + ' et truc'; }) -.then(valeur => { return valeur + ' et truc bla'; }) -.then(valeur => { return valeur + ' et blabla'; }) -.then(valeur => { return valeur + ' et blabla'; }) -.then(valeur => { console.log(valeur) }) -.catch(err => { console.log(err) }); + .then((valeur) => { + return valeur + " et truc"; + }) + .then((valeur) => { + return valeur + " et truc bla"; + }) + .then((valeur) => { + return valeur + " et blabla"; + }) + .then((valeur) => { + return valeur + " et blabla"; + }) + .then((valeur) => { + console.log(valeur); + }) + .catch((err) => { + console.log(err); + }); ``` La condition de terminaison d'une promesse détermine son état d'acquittement pour la prochaine promesse de la chaîne. Une promesse tenue indique un succès tandis qu'une promesse rompue indique un échec. La valeur de retour pour chaque promesse résolue de la chaîne est passée à la suivante avec `.then()`, alors que la raison de l'échec est passée au prochain gestionnaire d'échec dans la chaîne. @@ -100,11 +112,13 @@ const promesseC = promesseA.then(gestionSucces2, gestionEchec2); Il est possible d'affecter une action à une promesse qui est déjà acquittée. Dans ce cas, l'action (le cas échéant), sera réalisé à la première opportunité asynchrone, c'est-à-dire lorsque la pile d'appel aura été nettoyée et qu'un battement d'horloge se sera écoulé. On aura autrement dit un effet similaire à celui d'un `setTimeout(action,10)`. ```js -const promesseA = new Promise( (resolutionFunc,rejectionFunc) => { - resolutionFunc(777); +const promesseA = new Promise((resolutionFunc, rejectionFunc) => { + resolutionFunc(777); }); // Ici, "promesseA" est déjà acquittée. -promesseA.then( (val) => console.log("journalisation asynchrone / val vaut :",val) ); +promesseA.then((val) => + console.log("journalisation asynchrone / val vaut :", val), +); console.log("journalisation immédiate"); // On aura alors, dans la console, la suite de messages suivante : @@ -141,7 +155,7 @@ console.log("journalisation immédiate"); - [`Promise.prototype.finally()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Promise/finally) - : Ajoute un gestionnaire à la promesse et renvoie une nouvelle promesse qui est résolue lors de la résolution de la première promesse. Le gestionnaire est appelé quand la première promesse est acquittée, qu'elle ait réussi ou non. ->**Note :** Voir [le guide sur les micro-tâches](/fr/docs/Web/API/HTML_DOM_API/Microtask_guide) pour en savoir plus sur la façon dont ces méthodes utilisent la queue et les services de micro-tâches. +> **Note :** Voir [le guide sur les micro-tâches](/fr/docs/Web/API/HTML_DOM_API/Microtask_guide) pour en savoir plus sur la façon dont ces méthodes utilisent la queue et les services de micro-tâches. ## Exemples @@ -154,15 +168,15 @@ let maPremierePromesse = new Promise((resolve, reject) => { // Dans cet exemple, on utilise setTimeout(...) pour simuler // du code asynchrone. En situation réelle, on utiliserait // plutôt XHR ou une API Web asynchrone. - setTimeout( function() { - resolve("Succès !") // Tout s'est bien passé ! - }, 250) -}) + setTimeout(function () { + resolve("Succès !"); // Tout s'est bien passé ! + }, 250); +}); maPremierePromesse.then((messageReussite) => { - // messageReussite correspond à ce qui a été passé à + // messageReussite correspond à ce qui a été passé à // la fonction resolve(...) ci-avant. - console.log("Youpi ! " + messageReussite) + console.log("Youpi ! " + messageReussite); }); ``` @@ -187,30 +201,29 @@ const SEUIL_A = 8; // Abaissez ce seuil à 0 pour forcer les erreurs function tetheredGetNumber(resolve, reject) { try { - setTimeout( - function() { - const randomInt = Date.now(); - const value = randomInt % 10; - try { - if(value >= SEUIL_A) { - throw new Error(`Trop grand : ${value}`); - } - } catch(msg) { - reject(`Erreur dans le callback ${msg}`); + setTimeout(function () { + const randomInt = Date.now(); + const value = randomInt % 10; + try { + if (value >= SEUIL_A) { + throw new Error(`Trop grand : ${value}`); } + } catch (msg) { + reject(`Erreur dans le callback ${msg}`); + } resolve(value); return; }, 500); // Vous pouvez expérimenter en décommentant le 'throw' // qui suit - } catch(err) { + } catch (err) { reject(`Erreur à l'initialisation : ${err}`); } return; } function determineParity(value) { - const isOdd = value % 2 ? true : false ; + const isOdd = value % 2 ? true : false; const parityInfo = { theNumber: value, isOdd: isOdd }; return parityInfo; } @@ -221,36 +234,34 @@ function troubleWithGetNumber(reason) { } function promiseGetWord(parityInfo) { - - const tetheredGetWord = function(resolve,reject) { + const tetheredGetWord = function (resolve, reject) { const theNumber = parityInfo.theNumber; const seuil_B = SEUIL_A - 1; - if(theNumber >= seuil_B) { + if (theNumber >= seuil_B) { reject(`Toujours trop grand : ${theNumber}`); } else { - parityInfo.wordEvenOdd = parityInfo.isOdd ? 'impair' : 'pair'; + parityInfo.wordEvenOdd = parityInfo.isOdd ? "impair" : "pair"; resolve(parityInfo); } return; - } + }; return new Promise(tetheredGetWord); } -(new Promise(tetheredGetNumber)) - .then(determineParity,troubleWithGetNumber) +new Promise(tetheredGetNumber) + .then(determineParity, troubleWithGetNumber) .then(promiseGetWord) .then((info) => { - console.log("On a eu : ",info.theNumber," , ", info.wordEvenOdd); + console.log("On a eu : ", info.theNumber, " , ", info.wordEvenOdd); return info; }) .catch((reason) => { - if(reason === -999) { + if (reason === -999) { console.error("Erreur précédemment gérée"); - } - else { + } else { console.error(`Problème avec promiseGetWord(): ${reason}`); } - }) + }) .finally((info) => console.log("C'est fini.")); ``` @@ -270,31 +281,40 @@ Le fait que la promesse soit tenue est simplement enregistré via un _callback_ #### JavaScript ```js -'use strict'; +"use strict"; let comptePromesse = 0; function testPromise() { let thisComptePromesse = ++comptePromesse; - let log = document.getElementById('log'); - log.insertAdjacentHTML('beforeend', thisComptePromesse + - ') Started (Début du code synchrone)
'); + let log = document.getElementById("log"); + log.insertAdjacentHTML( + "beforeend", + thisComptePromesse + + ") Started (Début du code synchrone)
", + ); // on crée une nouvelle promesse : let p1 = new Promise( // La fonction de résolution est appelée avec la capacité de // tenir ou de rompre la promesse - function(resolve, reject) { - log.insertAdjacentHTML('beforeend', thisComptePromesse + - ') Promise started (Début du code asynchrone)
'); + function (resolve, reject) { + log.insertAdjacentHTML( + "beforeend", + thisComptePromesse + + ") Promise started (Début du code asynchrone)
", + ); // Voici un exemple simple pour créer un code asynchrone window.setTimeout( - function() { + function () { // On tient la promesse ! resolve(thisComptePromesse); - }, Math.random() * 2000 + 1000); - }); + }, + Math.random() * 2000 + 1000, + ); + }, + ); // On définit ce qui se passe quand la promesse est tenue // et ce qu'on appelle (uniquement) dans ce cas @@ -302,25 +322,34 @@ function testPromise() { // quand la promesse est rompue. p1.then( // On affiche un message avec la valeur - function(val) { - log.insertAdjacentHTML('beforeend', val + - ') Promise fulfilled (Fin du code asynchrone)
'); - }).catch( - // Promesse rejetée - function() { - console.log("promesse rompue"); - }); - - log.insertAdjacentHTML('beforeend', thisComptePromesse + - ') Promise made (Fin du code synchrone)
'); + function (val) { + log.insertAdjacentHTML( + "beforeend", + val + + ") Promise fulfilled (Fin du code asynchrone)
", + ); + }, + ).catch( + // Promesse rejetée + function () { + console.log("promesse rompue"); + }, + ); + + log.insertAdjacentHTML( + "beforeend", + thisComptePromesse + + ") Promise made (Fin du code synchrone)
", + ); } if ("Promise" in window) { let btn = document.getElementById("btn"); btn.addEventListener("click", testPromise); - } else { - log = document.getElementById('log'); - log.innerHTML = "L'exemple live n'est pas disponible pour votre navigateur car celui-ci ne supporte pas l'interface Promise."; +} else { + log = document.getElementById("log"); + log.innerHTML = + "L'exemple live n'est pas disponible pour votre navigateur car celui-ci ne supporte pas l'interface Promise."; } ``` diff --git a/files/fr/web/javascript/reference/global_objects/promise/promise/index.md b/files/fr/web/javascript/reference/global_objects/promise/promise/index.md index c9fc86eb902a3a..adfdd59775a1b7 100644 --- a/files/fr/web/javascript/reference/global_objects/promise/promise/index.md +++ b/files/fr/web/javascript/reference/global_objects/promise/promise/index.md @@ -13,7 +13,7 @@ Le constructeur **`Promise()`** est principalement utilisé afin d'envelopper de ## Syntaxe ```js -new Promise(executeur) +new Promise(executeur); ``` ### Paramètres diff --git a/files/fr/web/javascript/reference/global_objects/promise/race/index.md b/files/fr/web/javascript/reference/global_objects/promise/race/index.md index 701b7f55c3539d..e36c1762f4728d 100644 --- a/files/fr/web/javascript/reference/global_objects/promise/race/index.md +++ b/files/fr/web/javascript/reference/global_objects/promise/race/index.md @@ -51,9 +51,9 @@ console.log(p); // Avec setTimeout on peut exécuter du code // une fois que la pile est vide -setTimeout(function(){ - console.log('La pile est désormais vide'); - console.log(p); +setTimeout(function () { + console.log("La pile est désormais vide"); + console.log(p); }); // affichera, dans cet ordre : @@ -67,9 +67,9 @@ Un itérable vide renverra une promesse qui restera en attente : ```js var foreverPendingPromise = Promise.race([]); console.log(foreverPendingPromise); -setTimeout(function(){ - console.log('La pile est désormais vide'); - console.log(foreverPendingPromise); +setTimeout(function () { + console.log("La pile est désormais vide"); + console.log(foreverPendingPromise); }); // affichera, dans cet ordre : @@ -91,10 +91,10 @@ var p2 = Promise.race(arr2); console.log(p); console.log(p2); -setTimeout(function(){ - console.log('the stack is now empty'); - console.log(p); - console.log(p2); +setTimeout(function () { + console.log("the stack is now empty"); + console.log(p); + console.log(p2); }); // affichera dans l'ordre : @@ -108,45 +108,51 @@ setTimeout(function(){ ### Utilisation de `Promise.race` – exemples avec `setTimeout` ```js -var p1 = new Promise(function(resolve, reject) { - setTimeout(resolve, 500, "un"); +var p1 = new Promise(function (resolve, reject) { + setTimeout(resolve, 500, "un"); }); -var p2 = new Promise(function(resolve, reject) { - setTimeout(resolve, 100, "deux"); +var p2 = new Promise(function (resolve, reject) { + setTimeout(resolve, 100, "deux"); }); -Promise.race([p1, p2]).then(function(value) { +Promise.race([p1, p2]).then(function (value) { console.log(value); // "deux" // Les deux promesses sont résolues mais p2 est plus rapide }); -var p3 = new Promise(function(resolve, reject) { - setTimeout(resolve, 100, "trois"); +var p3 = new Promise(function (resolve, reject) { + setTimeout(resolve, 100, "trois"); }); -var p4 = new Promise(function(resolve, reject) { - setTimeout(reject, 500, "quatre"); +var p4 = new Promise(function (resolve, reject) { + setTimeout(reject, 500, "quatre"); }); -Promise.race([p3, p4]).then(function(value) { - console.log(value); // "trois" - // p3 est plus rapide et entraîne la résolution de la promesse de compétition -}, function(reason) { - // N'est pas appelée +Promise.race([p3, p4]).then( + function (value) { + console.log(value); // "trois" + // p3 est plus rapide et entraîne la résolution de la promesse de compétition + }, + function (reason) { + // N'est pas appelée + }, +); + +var p5 = new Promise(function (resolve, reject) { + setTimeout(resolve, 500, "cinq"); }); - -var p5 = new Promise(function(resolve, reject) { - setTimeout(resolve, 500, "cinq"); -}); -var p6 = new Promise(function(resolve, reject) { - setTimeout(reject, 100, "six"); +var p6 = new Promise(function (resolve, reject) { + setTimeout(reject, 100, "six"); }); -Promise.race([p5, p6]).then(function(value) { - // N'est pas appelée -}, function(reason) { - console.log(reason); // "six" - // p6 est plus rapide et rejète la promesse de compétition -}); +Promise.race([p5, p6]).then( + function (value) { + // N'est pas appelée + }, + function (reason) { + console.log(reason); // "six" + // p6 est plus rapide et rejète la promesse de compétition + }, +); ``` > **Note :** voir la documentation sur [`setTimeout`.](/fr/docs/Web/API/WindowTimers/setTimeout) diff --git a/files/fr/web/javascript/reference/global_objects/promise/reject/index.md b/files/fr/web/javascript/reference/global_objects/promise/reject/index.md index 63c5d3f4678345..29c6206b5852dd 100644 --- a/files/fr/web/javascript/reference/global_objects/promise/reject/index.md +++ b/files/fr/web/javascript/reference/global_objects/promise/reject/index.md @@ -32,11 +32,14 @@ La fonction statique `Promise.reject` renvoie une `Promise` qui est rejetée. Po ## Exemples ```js -Promise.reject(new Error("échec")).then(function() { - // n'est pas appelée -}, function(erreur) { - console.log(erreur); // Analyse de la pile d'appels -}); +Promise.reject(new Error("échec")).then( + function () { + // n'est pas appelée + }, + function (erreur) { + console.log(erreur); // Analyse de la pile d'appels + }, +); ``` ## Spécifications diff --git a/files/fr/web/javascript/reference/global_objects/promise/resolve/index.md b/files/fr/web/javascript/reference/global_objects/promise/resolve/index.md index 96fd24f76a10c8..14ef3ff8ea30ca 100644 --- a/files/fr/web/javascript/reference/global_objects/promise/resolve/index.md +++ b/files/fr/web/javascript/reference/global_objects/promise/resolve/index.md @@ -38,18 +38,21 @@ La fonction statique `Promise.resolve` renvoie un objet `Promise` qui est résol ### Utilisation de la méthode statique `Promise.resolve` ```js -Promise.resolve("Succès").then(function(valeur) { - console.log(valeur); // "Succès" -}, function(valeur) { - // n'est pas appelée -}); +Promise.resolve("Succès").then( + function (valeur) { + console.log(valeur); // "Succès" + }, + function (valeur) { + // n'est pas appelée + }, +); ``` ### Résoudre un tableau ```js -var p = Promise.resolve([1,2,3]); -p.then(function(v) { +var p = Promise.resolve([1, 2, 3]); +p.then(function (v) { console.log(v[0]); // 1 }); ``` @@ -59,7 +62,7 @@ p.then(function(v) { ```js var original = Promise.resolve(33); var cast = Promise.resolve(original); -cast.then(function(value) { +cast.then(function (value) { console.log("value: " + value); }); console.log("original === cast ? " + (original === cast)); @@ -76,43 +79,58 @@ L'ordre des traces dans la console est dû au fait que les gestionnaires `then() ```js // Résoudre un objet avec then var p1 = Promise.resolve({ - then: function(onFulfill, onReject) { onFulfill("tenue !"); } + then: function (onFulfill, onReject) { + onFulfill("tenue !"); + }, }); -console.log(p1 instanceof Promise) // true, l'objet est transformée en une Promise +console.log(p1 instanceof Promise); // true, l'objet est transformée en une Promise -p1.then(function(v) { +p1.then( + function (v) { console.log(v); // "tenue !" - }, function(e) { + }, + function (e) { // n'est pas appelée -}); + }, +); // L'objet avec then renvoie une erreur avant le callback // La promesse n'est pas tenue -var thenable = { then: function(resolve) { - throw new TypeError("Renvoi d'erreur"); - resolve("Résolution "); -}}; +var thenable = { + then: function (resolve) { + throw new TypeError("Renvoi d'erreur"); + resolve("Résolution "); + }, +}; var p2 = Promise.resolve(thenable); -p2.then(function(v) { - // n'est pas appelée -}, function(e) { - console.log(e); // TypeError : Renvoi d'erreur -}); +p2.then( + function (v) { + // n'est pas appelée + }, + function (e) { + console.log(e); // TypeError : Renvoi d'erreur + }, +); // L'objet avec then renvoie une erreur après le callback // La promesse est tenue -var thenable = { then: function(resolve) { - resolve("Résolue"); - throw new TypeError("Erreur"); -}}; +var thenable = { + then: function (resolve) { + resolve("Résolue"); + throw new TypeError("Erreur"); + }, +}; var p3 = Promise.resolve(thenable); -p3.then(function(v) { - console.log(v); // "Résolue" -}, function(e) { - // n'est pas appelée -}); +p3.then( + function (v) { + console.log(v); // "Résolue" + }, + function (e) { + // n'est pas appelée + }, +); ``` ## Spécifications diff --git a/files/fr/web/javascript/reference/global_objects/promise/then/index.md b/files/fr/web/javascript/reference/global_objects/promise/then/index.md index 8b0da28cc956f6..1589f4dbaf0c82 100644 --- a/files/fr/web/javascript/reference/global_objects/promise/then/index.md +++ b/files/fr/web/javascript/reference/global_objects/promise/then/index.md @@ -24,12 +24,12 @@ then(siTenue, siRejetée) - : Une fonction à exécuter de façon asynchrone quand la promesse est tenue. La valeur de retour de cette fonction devient la valeur de réussite de la promesse renvoyée par `then()`. Cette fonction de rappel est appelée avec les arguments suivants : - `valeur` - : La valeur avec laquelle la promesse a été tenue. - Si cet argument n'est pas une fonction, il est remplacé en interne par la fonction _identité_ (`(x) => x`) qui passe la valeur de réussite. + Si cet argument n'est pas une fonction, il est remplacé en interne par la fonction _identité_ (`(x) => x`) qui passe la valeur de réussite. - `siRejetée` {{optional_inline}} - : Une fonction à exécuter de façon asynchrone quand la promesse est rompue. Sa valeur de retour devient la valeur de réussite de la promesse renvoyée par `catch()`. Cette fonction de rappel est appelée avec les arguments suivants : - `raison` - : La valeur avec laquelle la promesse a été rompue. - Si cet argument n'est pas une fonction, il est remplacé en interne par une fonction de _rejet_ (`(x) => { throw x; }`) qui renvoie la raison d'échec qui a été reçue en amont. + Si cet argument n'est pas une fonction, il est remplacé en interne par une fonction de _rejet_ (`(x) => { throw x; }`) qui renvoie la raison d'échec qui a été reçue en amont. ### Valeur de retour @@ -117,7 +117,7 @@ Promise.resolve("toto") // avant le traitement de la chaîne dans le bloc then() précédent. .then((chaine) => { console.log( - "Dernier then(). Oups, on n'a pas pris la peine d'instancier et de renvoyer une promesse dans l'appel then() précédent. L'ordre de la séquence pourrait être surprenant." + "Dernier then(). Oups, on n'a pas pris la peine d'instancier et de renvoyer une promesse dans l'appel then() précédent. L'ordre de la séquence pourrait être surprenant.", ); // On notera qu'ici `chaine` n'a pas le suffixe 'machin'. En effet, nous avons @@ -182,7 +182,9 @@ Promise.resolve() console.error(`Fonction siRejetée() appelée : ${erreur.message}`); }) .then(() => { - console.log("Je suis toujours appelée, même si la promesse du then() précédent échoue."); + console.log( + "Je suis toujours appelée, même si la promesse du then() précédent échoue.", + ); }); ``` @@ -256,7 +258,7 @@ function obtenirDonnees() { const j = response.json(); // faire quelque chose avec j - // La valeur de réussite fournie lorsqu'on + // La valeur de réussite fournie lorsqu'on // appelle obtenirDonnees().then() return j; }); @@ -268,11 +270,11 @@ function obtenirDonnees() { Dans l'exemple qui suit, on illustre le caractère asynchrone de la méthode `then()`. ```js -// Prenons une promesse résolue comme 'promResolue', l'appel à +// Prenons une promesse résolue comme 'promResolue', l'appel à // 'promResolue.then(…)' renvoie immédiatement une nouvelle promesse, // mais la fonction de rappel '(value) => {…}' sera appelée de // façon asynchrone, comme on peut le voir dans la console. -// La nouvelle promesse est affectée à 'promSuivante', cette +// La nouvelle promesse est affectée à 'promSuivante', cette // dernière est résolue avec la valeur renvoyée par le gestionnaire. const promResolue = Promise.resolve(33); console.log(promResolue); @@ -280,9 +282,7 @@ console.log(promResolue); const promSuivante = promResolue.then((valeur) => { console.log( `Ceci est appelé après la fin de la pile principale. ` + - `La valeur reçue est : ${valeur}, la valeur renvoyée est : ${ - valeur + 1 - }`, + `La valeur reçue est : ${valeur}, la valeur renvoyée est : ${valeur + 1}`, ); return valeur + 1; }); diff --git a/files/fr/web/javascript/reference/global_objects/proxy/index.md b/files/fr/web/javascript/reference/global_objects/proxy/index.md index 3224019fa6f4cf..6f00c7e86bf0bd 100644 --- a/files/fr/web/javascript/reference/global_objects/proxy/index.md +++ b/files/fr/web/javascript/reference/global_objects/proxy/index.md @@ -24,7 +24,7 @@ Dans l'exemple qui suit, on a une cible simple avec deux propriétés et un gest ```js const cible = { message1: "coucou", - message2: "tout le monde" + message2: "tout le monde", }; const gestionnaire1 = {}; @@ -44,13 +44,13 @@ Pour adapter le proxy, on définit des fonctions sur le gestionnaire : ```js const cible = { message1: "coucou", - message2: "tout le monde" + message2: "tout le monde", }; const gestionnaire2 = { get(cible, prop, recepteur) { return "le monde"; - } + }, }; const proxy2 = new Proxy(cible, gestionnaire2); @@ -70,7 +70,7 @@ Avec [`Reflect`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Reflect), on p ```js const cible = { message1: "coucou", - message2: "tout le monde" + message2: "tout le monde", }; const gestionnaire3 = { @@ -107,10 +107,8 @@ Dans ce court exemple, on renvoie le nombre `37` comme valeur par défaut lorsqu ```js const handler = { get(obj, prop) { - return prop in obj ? - obj[prop] : - 37; - } + return prop in obj ? obj[prop] : 37; + }, }; const p = new Proxy({}, handler); @@ -120,7 +118,7 @@ p.b = undefined; console.log(p.a, p.b); // 1, undefined -console.log('c' in p, p.c); +console.log("c" in p, p.c); // false, 37 ``` @@ -135,7 +133,6 @@ const p = new Proxy(target, {}); p.a = 37; // L'opération est transmise à la cible par le proxy - console.log(target.a); // 37 // L'opération a bien été transmise @@ -149,13 +146,13 @@ En utilisant un `Proxy`, on peut simplement valider les valeurs passées à un o ```js let validateur = { - set: function(obj, prop, valeur) { - if (prop === 'age') { + set: function (obj, prop, valeur) { + if (prop === "age") { if (!Number.isInteger(valeur)) { throw new TypeError("Cet a n'est pas un entier."); } if (valeur > 200) { - throw new RangeError('Cet âge semble invalide.'); + throw new RangeError("Cet âge semble invalide."); } } @@ -164,15 +161,15 @@ let validateur = { // On indique le succès de l'opération return true; - } + }, }; const personne = new Proxy({}, validateur); personne.age = 100; console.log(personne.age); // 100 -personne.age = 'jeune'; // lève une exception -personne.age = 300; // lève une exception +personne.age = "jeune"; // lève une exception +personne.age = 300; // lève une exception ``` ### Étendre un constructeur @@ -180,33 +177,34 @@ personne.age = 300; // lève une exception En utilisant une fonction proxy, on peut étendre un constructeur avec un nouveau constructeur. Dans cet exemple, on utilise les gestionnaires correspondants à [`construct()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler/construct) et [`apply()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler/apply). ```js -function etendre(sup,base) { +function etendre(sup, base) { var descripteur = Object.getOwnPropertyDescriptor( - base.prototype, "constructor" + base.prototype, + "constructor", ); base.prototype = Object.create(sup.prototype); var gestionnaire = { - construct: function(cible, args) { + construct: function (cible, args) { var obj = Object.create(base.prototype); - this.apply(cible,obj,args); + this.apply(cible, obj, args); return obj; }, - apply: function(cible, that, args) { - sup.apply(that,args); - base.apply(that,args); - } + apply: function (cible, that, args) { + sup.apply(that, args); + base.apply(that, args); + }, }; - var proxy = new Proxy(base,gestionnaire); + var proxy = new Proxy(base, gestionnaire); descripteur.value = proxy; Object.defineProperty(base.prototype, "constructor", descripteur); return proxy; } -var Personne = function(nom){ +var Personne = function (nom) { this.nom = nom; }; -var Garcon = etendre(Personne, function(nom, âge) { +var Garcon = etendre(Personne, function (nom, âge) { this.âge = âge; }); @@ -214,8 +212,8 @@ Garcon.prototype.genre = "M"; var Pierre = new Garcon("Pierre", 13); console.log(Pierre.genre); // "M" -console.log(Pierre.nom); // "Pierre" -console.log(Pierre.âge); // 13 +console.log(Pierre.nom); // "Pierre" +console.log(Pierre.âge); // 13 ``` ### Manipuler les nœuds DOM @@ -227,47 +225,49 @@ On crée un objet `vue` qui est un proxy pour l'objet avec une `selected`. Le ge Lorsqu'on affecte un élément HTML à `vue.selected`, l'attribut `'aria-selected'` de l'élément est placé à `true`. Si on affecte ensuite un autre élément à `vue.selected`, ce nouvel élément aura l'attribut `'aria-selected'` défini à `true` et l'élément précédent verra son attribut `'aria-selected'` automatiquement défini à `false`. ```js -let vue = new Proxy({ - selected: null -}, -{ - set(obj, prop, nouvelleValeur) { - let ancienneValeur = obj[prop]; - - if (prop === 'selected') { - if (ancienneValeur) { - ancienneValeur.setAttribute('aria-selected', 'false'); - } - if (nouvelleValeur) { - nouvelleValeur.setAttribute('aria-selected', 'true'); +let vue = new Proxy( + { + selected: null, + }, + { + set(obj, prop, nouvelleValeur) { + let ancienneValeur = obj[prop]; + + if (prop === "selected") { + if (ancienneValeur) { + ancienneValeur.setAttribute("aria-selected", "false"); + } + if (nouvelleValeur) { + nouvelleValeur.setAttribute("aria-selected", "true"); + } } - } - // Le comportement par défaut : enregistrer la valeur - obj[prop] = nouvelleValeur; + // Le comportement par défaut : enregistrer la valeur + obj[prop] = nouvelleValeur; - // On indique le succès de l'opération - return true; - } -}); + // On indique le succès de l'opération + return true; + }, + }, +); -const element1 = document.getElementById('elem-1'); -const element2 = document.getElementById('elem-2'); +const element1 = document.getElementById("elem-1"); +const element2 = document.getElementById("elem-2"); // on sélectionne element1 vue.selected = element1; -console.log(`element1 : ${element1.getAttribute('aria-selected')}`); +console.log(`element1 : ${element1.getAttribute("aria-selected")}`); // element1 : true // on sélectionne element2 et cela entraîne // la déselection automatique de element1 vue.selected = element2; -console.log(`element1 : ${element1.getAttribute('aria-selected')}`); +console.log(`element1 : ${element1.getAttribute("aria-selected")}`); // element1 : false -console.log(`element2 : ${element2.getAttribute('aria-selected')}`); +console.log(`element2 : ${element2.getAttribute("aria-selected")}`); // element2 : true ``` @@ -276,48 +276,50 @@ console.log(`element2 : ${element2.getAttribute('aria-selected')}`); Dans l'exemple qui suit, le proxy `produits` évalue la valeur passée et la convertit en tableau si besoin. L'objet prend également en charge la propriété supplémentaire `dernierNavigateur` à la fois comme accesseur et mutateur. ```js -let produits = new Proxy({ - navigateurs: ['Internet Explorer', 'Netscape'] -}, -{ - get(obj, prop) { - // Une propriété supplémentaire - if (prop === 'dernierNavigateur') { - return obj.navigateurs[obj.navigateurs.length - 1]; - } - - // Le comportement par défaut : renvoyer la valeur - return obj[prop]; +let produits = new Proxy( + { + navigateurs: ["Internet Explorer", "Netscape"], }, - set(obj, prop, valeur) { - // Une propriété supplémentaire - if (prop === 'dernierNavigateur') { - obj.navigateurs.push(valeur); - return true; - } + { + get(obj, prop) { + // Une propriété supplémentaire + if (prop === "dernierNavigateur") { + return obj.navigateurs[obj.navigateurs.length - 1]; + } - // on convertit la valeur si ce n'est pas un tableau - if (typeof valeur === 'string') { - valeur = [valeur]; - } + // Le comportement par défaut : renvoyer la valeur + return obj[prop]; + }, + set(obj, prop, valeur) { + // Une propriété supplémentaire + if (prop === "dernierNavigateur") { + obj.navigateurs.push(valeur); + return true; + } - // Le comportement par défaut : enregistrer la valeur - obj[prop] = valeur; + // on convertit la valeur si ce n'est pas un tableau + if (typeof valeur === "string") { + valeur = [valeur]; + } - // On indique le succès de l'opération - return true; - } -}); + // Le comportement par défaut : enregistrer la valeur + obj[prop] = valeur; + + // On indique le succès de l'opération + return true; + }, + }, +); console.log(produits.navigateurs); // ['Internet Explorer', 'Netscape'] -produits.navigateurs = 'Firefox'; +produits.navigateurs = "Firefox"; // on passe une chaîne console.log(produits.navigateurs); // ['Firefox'] <- pas de problème, elle est convertie en tableau -produits.dernierNavigateur = 'Chrome'; +produits.dernierNavigateur = "Chrome"; console.log(produits.navigateurs); // ['Firefox', 'Chrome'] @@ -331,64 +333,67 @@ console.log(produits.dernierNavigateur); Dans cet exemple, ce proxy étend le tableau avec des fonctionnalités supplémentaires. Ici, on définit des propriétés sans utiliser [`Object.defineProperties()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperties). Cet exemple pourrait être adapté pour trouver la ligne d'un tableau à partir d'une de ces cellules (la cible serait alors [`table.rows`](/fr/docs/Web/API/HTMLTableElement.rows)). ```js -let produits = new Proxy([ - { nom: 'Firefox', type: 'navigateur' }, - { nom: 'SeaMonkey', type: 'navigateur' }, - { nom: 'Thunderbird', type: 'client mail' } -], -{ - get(obj, prop) { - // Le comportement par défaut : on renvoie la valeur - // prop est généralement un entier - if (prop in obj) { - return obj[prop]; - } - - // On obtient le nombre de produits - // un alias pour products.length - if (prop === 'nombre') { - return obj.length; - } - - let resultat, types = {}; +let produits = new Proxy( + [ + { nom: "Firefox", type: "navigateur" }, + { nom: "SeaMonkey", type: "navigateur" }, + { nom: "Thunderbird", type: "client mail" }, + ], + { + get(obj, prop) { + // Le comportement par défaut : on renvoie la valeur + // prop est généralement un entier + if (prop in obj) { + return obj[prop]; + } - for (let produit of obj) { - if (produit.nom === prop) { - resultat = produit; + // On obtient le nombre de produits + // un alias pour products.length + if (prop === "nombre") { + return obj.length; } - if (types[produit.type]) { - types[produit.type].push(produit); - } else { - types[produit.type] = [produit]; + + let resultat, + types = {}; + + for (let produit of obj) { + if (produit.nom === prop) { + resultat = produit; + } + if (types[produit.type]) { + types[produit.type].push(produit); + } else { + types[produit.type] = [produit]; + } } - } - // Obtenir un produit grâce à un nom - if (resultat) { - return resultat; - } + // Obtenir un produit grâce à un nom + if (resultat) { + return resultat; + } - // Obtenir un produit par type - if (prop in types) { - return types[prop]; - } + // Obtenir un produit par type + if (prop in types) { + return types[prop]; + } - // Obtenir les types de produits - if (prop === 'types') { - return Object.keys(types); - } + // Obtenir les types de produits + if (prop === "types") { + return Object.keys(types); + } - return undefined; - } -}); + return undefined; + }, + }, +); console.log(produits[0]); // { nom: 'Firefox', type: 'navigateur' } -console.log(produits['Firefox']); +console.log(produits["Firefox"]); // { nom: 'Firefox', type: 'navigateur' } -console.log(produits['Chrome']); +console.log(produits["Chrome"]); // undefined console.log(produits.navigateur); @@ -412,15 +417,19 @@ Pour illustrer l'ensemble des trappes, on tente de « proxifier » un */ var docCookies = new Proxy(docCookies, { - get (oTarget, sKey) { + get(oTarget, sKey) { return oTarget[sKey] || oTarget.getItem(sKey) || undefined; }, set: function (oTarget, sKey, vValue) { - if (sKey in oTarget) { return false; } + if (sKey in oTarget) { + return false; + } return oTarget.setItem(sKey, vValue); }, deleteProperty: function (oTarget, sKey) { - if (!sKey in oTarget) { return false; } + if (!sKey in oTarget) { + return false; + } return oTarget.removeItem(sKey); }, ownKeys: function (oTarget, sKey) { @@ -430,26 +439,30 @@ var docCookies = new Proxy(docCookies, { return sKey in oTarget || oTarget.hasItem(sKey); }, defineProperty: function (oTarget, sKey, oDesc) { - if (oDesc && 'value' in oDesc) { oTarget.setItem(sKey, oDesc.value); } + if (oDesc && "value" in oDesc) { + oTarget.setItem(sKey, oDesc.value); + } return oTarget; }, getOwnPropertyDescriptor: function (oTarget, sKey) { var vValue = oTarget.getItem(sKey); - return vValue ? { - value: vValue, - writable: true, - enumerable: true, - configurable: false - } : undefined; + return vValue + ? { + value: vValue, + writable: true, + enumerable: true, + configurable: false, + } + : undefined; }, }); /* Test */ -console.log(docCookies.monCookie1 = 'Première valeur'); -console.log(docCookies.getItem('monCookie1')); +console.log((docCookies.monCookie1 = "Première valeur")); +console.log(docCookies.getItem("monCookie1")); -docCookies.setItem('monCookie1', 'Valeur modifiée'); +docCookies.setItem("monCookie1", "Valeur modifiée"); console.log(docCookies.monCookie1); ``` diff --git a/files/fr/web/javascript/reference/global_objects/proxy/proxy/apply/index.md b/files/fr/web/javascript/reference/global_objects/proxy/proxy/apply/index.md index ef9cc6854b37f6..fa2cea82a49c9e 100644 --- a/files/fr/web/javascript/reference/global_objects/proxy/proxy/apply/index.md +++ b/files/fr/web/javascript/reference/global_objects/proxy/proxy/apply/index.md @@ -14,8 +14,7 @@ La méthode **`handler.apply()`** représente une trappe pour un appel de foncti ```js var p = new Proxy(cible, { - apply: function(cible, thisArg, listeArguments) { - } + apply: function (cible, thisArg, listeArguments) {}, }); ``` @@ -57,15 +56,15 @@ Si les invariants suivants ne sont pas respectés, le proxy lèvera une exceptio Dans l'exemple ci-dessous, on piège un appel de fonction. ```js -var p = new Proxy(function() {}, { - apply: function(target, thisArg, argumentsList) { +var p = new Proxy(function () {}, { + apply: function (target, thisArg, argumentsList) { console.log("called: " + argumentsList.join(", ")); return argumentsList[0] + argumentsList[1] + argumentsList[2]; - } + }, }); console.log(p(1, 2, 3)); // "called: 1, 2, 3" - // 6 +// 6 ``` ## Spécifications diff --git a/files/fr/web/javascript/reference/global_objects/proxy/proxy/construct/index.md b/files/fr/web/javascript/reference/global_objects/proxy/proxy/construct/index.md index 3d2c10f79d757f..77c24379e351f5 100644 --- a/files/fr/web/javascript/reference/global_objects/proxy/proxy/construct/index.md +++ b/files/fr/web/javascript/reference/global_objects/proxy/proxy/construct/index.md @@ -14,8 +14,7 @@ La méthode **`handler.construct()`** est une trappe pour l'opérateur {{jsxref( ```js var p = new Proxy(cible, { - construct: function(cible, listeArguments, newTarget) { - } + construct: function (cible, listeArguments, newTarget) {}, }); ``` @@ -56,24 +55,24 @@ Si les invariants suivants ne sont pas respectés, le proxy renverra une excepti Dans l'exemple qui suit, on piège l'opérateur {{jsxref("Opérateurs/L_opérateur_new", "new")}}. ```js -var p = new Proxy(function() {}, { - construct: function(target, argumentsList) { +var p = new Proxy(function () {}, { + construct: function (target, argumentsList) { console.log("called: " + argumentsList.join(", ")); return { value: argumentsList[0] * 10 }; - } + }, }); console.log(new p(1).value); // "appel sur : 1" - // 10 +// 10 ``` Dans cette version, on ne respecte pas la contrainte d'invariance : ```js -var p = new Proxy(function() {}, { - construct: function(target, argumentsList) { +var p = new Proxy(function () {}, { + construct: function (target, argumentsList) { return 1; - } + }, }); new p(); // Une exception TypeError est levée @@ -82,11 +81,14 @@ new p(); // Une exception TypeError est levée Dans le code qui suit, le proxy n'est pas correctement initialisé. La cible du proxy doit être un constructeur valide qui puisse être utilisé avec `new`. ```js -var p = new Proxy({}, { - construct: function(target, argumentsList, newTarget){ - return {}; - } -}); +var p = new Proxy( + {}, + { + construct: function (target, argumentsList, newTarget) { + return {}; + }, + }, +); new p(); // TypeError: p is not a constructor ``` diff --git a/files/fr/web/javascript/reference/global_objects/proxy/proxy/defineproperty/index.md b/files/fr/web/javascript/reference/global_objects/proxy/proxy/defineproperty/index.md index 33bc685a2ecf60..736d6e4530790b 100644 --- a/files/fr/web/javascript/reference/global_objects/proxy/proxy/defineproperty/index.md +++ b/files/fr/web/javascript/reference/global_objects/proxy/proxy/defineproperty/index.md @@ -14,8 +14,7 @@ La méthode **`handler.defineProperty()`** est une trappe pour {{jsxref("Object. ```js var p = new Proxy(cible, { - defineProperty: function(cible, propriété, descripteur) { - } + defineProperty: function (cible, propriété, descripteur) {}, }); ``` @@ -60,11 +59,14 @@ Si les contraintes d'invariances suivantes ne sont pas respectées, le proxy ren Dans le code suivant, on piège l'appel à {{jsxref("Object.defineProperty()")}}. ```js -var p = new Proxy({}, { - defineProperty: function(target, prop, descriptor) { - console.log("appelé avec : " + prop); - } -}); +var p = new Proxy( + {}, + { + defineProperty: function (target, prop, descriptor) { + console.log("appelé avec : " + prop); + }, + }, +); var desc = { configurable: true, enumerable: true, value: 10 }; Object.defineProperty(p, "a", desc); // "appelé avec : a" diff --git a/files/fr/web/javascript/reference/global_objects/proxy/proxy/deleteproperty/index.md b/files/fr/web/javascript/reference/global_objects/proxy/proxy/deleteproperty/index.md index 4ae2470f94842c..61096b2e3aede0 100644 --- a/files/fr/web/javascript/reference/global_objects/proxy/proxy/deleteproperty/index.md +++ b/files/fr/web/javascript/reference/global_objects/proxy/proxy/deleteproperty/index.md @@ -14,8 +14,7 @@ La méthode **`handler.deleteProperty()`** est une trappe pour l'opérateur {{js ```js var p = new Proxy(cible, { - deleteProperty: function(cible, propriété) { - } + deleteProperty: function (cible, propriété) {}, }); ``` @@ -54,12 +53,15 @@ Si les invarians suivants ne sont pas respectés, le proxy renverra une exceptio Dans l'exemple qui suit, on intercepte les opérations de {{jsxref("Opérateurs/L_opérateur_delete", "delete")}}. ```js -var p = new Proxy({}, { - deleteProperty: function(cible, prop) { - console.log("appelée sur : " + prop); - return true; - } -}); +var p = new Proxy( + {}, + { + deleteProperty: function (cible, prop) { + console.log("appelée sur : " + prop); + return true; + }, + }, +); delete p.a; // "appelée sur : a" ``` diff --git a/files/fr/web/javascript/reference/global_objects/proxy/proxy/get/index.md b/files/fr/web/javascript/reference/global_objects/proxy/proxy/get/index.md index 17415b2f141554..170d73cc1c442c 100644 --- a/files/fr/web/javascript/reference/global_objects/proxy/proxy/get/index.md +++ b/files/fr/web/javascript/reference/global_objects/proxy/proxy/get/index.md @@ -14,8 +14,7 @@ La méthode **`handler.get()`** est une trappe pour intercepter l'accès à la v ```js var p = new Proxy(cible, { - get: function(cible, propriété, récepteur) { - } + get: function (cible, propriété, récepteur) {}, }); ``` @@ -58,15 +57,18 @@ Si les invariants suivants ne sont pas respectés, le proxy renverra une excepti Dans l'exemple suivant, on intercepte les accès aux propriétés : ```js -var p = new Proxy({}, { - get: function(cible, propriété, récepteur) { - console.log("appelée : " + propriété); - return 10; - } -}); +var p = new Proxy( + {}, + { + get: function (cible, propriété, récepteur) { + console.log("appelée : " + propriété); + return 10; + }, + }, +); console.log(p.a); // "appelée : a" - // 10 +// 10 ``` Le code suivant ne respecte pas l'invariant : @@ -77,13 +79,13 @@ Object.defineProperty(obj, "a", { configurable: false, enumerable: false, value: 10, - writable: false + writable: false, }); var p = new Proxy(obj, { - get: function(cible, propriété) { + get: function (cible, propriété) { return 20; - } + }, }); p.a; // exception TypeError levée diff --git a/files/fr/web/javascript/reference/global_objects/proxy/proxy/getownpropertydescriptor/index.md b/files/fr/web/javascript/reference/global_objects/proxy/proxy/getownpropertydescriptor/index.md index 209982c7004f16..7e5eaaaf52aa19 100644 --- a/files/fr/web/javascript/reference/global_objects/proxy/proxy/getownpropertydescriptor/index.md +++ b/files/fr/web/javascript/reference/global_objects/proxy/proxy/getownpropertydescriptor/index.md @@ -14,8 +14,7 @@ La méthode **`handler.getOwnPropertyDescriptor()`** est une trappe pour interce ```js var p = new Proxy(cible, { - getOwnPropertyDescriptor: function(cible, prop) { - } + getOwnPropertyDescriptor: function (cible, prop) {}, }); ``` @@ -59,15 +58,18 @@ Si les invariants suivants ne sont pas respectés, le proxy lèvera une exceptio Dans l'exemple qui suit, on intercepte {{jsxref("Object.getOwnPropertyDescriptor()")}}. ```js -var p = new Proxy({ a: 20 }, { - getOwnPropertyDescriptor: function(cible, prop) { - console.log("appelée : " + prop); - return { configurable: true, enumerable: true, value: 10 }; - } -}); +var p = new Proxy( + { a: 20 }, + { + getOwnPropertyDescriptor: function (cible, prop) { + console.log("appelée : " + prop); + return { configurable: true, enumerable: true, value: 10 }; + }, + }, +); console.log(Object.getOwnPropertyDescriptor(p, "a").value); // "appelée : a" - // 10 +// 10 ``` L'exemple suivant ne respecte pas un invariant : @@ -76,9 +78,9 @@ L'exemple suivant ne respecte pas un invariant : var obj = { a: 10 }; Object.preventExtensions(obj); var p = new Proxy(obj, { - getOwnPropertyDescriptor: function(cible, prop) { + getOwnPropertyDescriptor: function (cible, prop) { return undefined; - } + }, }); Object.getOwnPropertyDescriptor(p, "a"); // Une exception TypeError est renvoyée diff --git a/files/fr/web/javascript/reference/global_objects/proxy/proxy/getprototypeof/index.md b/files/fr/web/javascript/reference/global_objects/proxy/proxy/getprototypeof/index.md index 43096f60c8c097..232e32bbc1c004 100644 --- a/files/fr/web/javascript/reference/global_objects/proxy/proxy/getprototypeof/index.md +++ b/files/fr/web/javascript/reference/global_objects/proxy/proxy/getprototypeof/index.md @@ -58,15 +58,15 @@ Si les invariants suivant ne sont pas respectés, le proxy renverra une exceptio var obj = {}; var proto = {}; var gestionnaire = { - getPrototypeOf(cible) { - console.log(cible === obj); // true - console.log(this === gestionnaire); // true - return proto; - } + getPrototypeOf(cible) { + console.log(cible === obj); // true + console.log(this === gestionnaire); // true + return proto; + }, }; var p = new Proxy(obj, gestionnaire); -console.log(Object.getPrototypeOf(p) === proto); // true +console.log(Object.getPrototypeOf(p) === proto); // true ``` ### Cinq façons de déclencher la trappe `getPrototypeOf` @@ -74,16 +74,16 @@ console.log(Object.getPrototypeOf(p) === proto); // true ```js var obj = {}; var p = new Proxy(obj, { - getPrototypeOf(cible) { - return Array.prototype; - } + getPrototypeOf(cible) { + return Array.prototype; + }, }); console.log( - Object.getPrototypeOf(p) === Array.prototype, // true - Reflect.getPrototypeOf(p) === Array.prototype, // true - p.__proto__ === Array.prototype, // true - Array.prototype.isPrototypeOf(p), // true - p instanceof Array // true + Object.getPrototypeOf(p) === Array.prototype, // true + Reflect.getPrototypeOf(p) === Array.prototype, // true + p.__proto__ === Array.prototype, // true + Array.prototype.isPrototypeOf(p), // true + p instanceof Array, // true ); ``` @@ -92,17 +92,17 @@ console.log( ```js var obj = {}; var p = new Proxy(obj, { - getPrototypeOf(cible) { - return "toto"; - } + getPrototypeOf(cible) { + return "toto"; + }, }); Object.getPrototypeOf(p); // TypeError : "toto" n'est pas un objet ou null var obj = Object.preventExtensions({}); var p = new Proxy(obj, { - getPrototypeOf(cible) { - return {}; - } + getPrototypeOf(cible) { + return {}; + }, }); Object.getPrototypeOf(p); // TypeError : on attend la même valeur pour le prototype ``` diff --git a/files/fr/web/javascript/reference/global_objects/proxy/proxy/has/index.md b/files/fr/web/javascript/reference/global_objects/proxy/proxy/has/index.md index 3c9f2509def3e0..67054a7b884753 100644 --- a/files/fr/web/javascript/reference/global_objects/proxy/proxy/has/index.md +++ b/files/fr/web/javascript/reference/global_objects/proxy/proxy/has/index.md @@ -14,8 +14,7 @@ La méthode **`handler.has()`** est une trappe pour l'opérateur {{jsxref("Opér ```js var p = new Proxy(cible, { - has: function(cible, prop) { - } + has: function (cible, prop) {}, }); ``` @@ -57,15 +56,18 @@ Si les invariants suivants ne sont pas respectés, le proxy lèvera une exceptio Dans l'exemple qui suit, on intercepte l'opérateur {{jsxref("Opérateurs/L_opérateur_in", "in")}} : ```js -var p = new Proxy({}, { - has: function(cible, prop) { - console.log("appelée : " + prop); - return true; - } -}); +var p = new Proxy( + {}, + { + has: function (cible, prop) { + console.log("appelée : " + prop); + return true; + }, + }, +); console.log("a" in p); // "appelée : a" - // true +// true ``` L'exemple suivant ne respecte pas un invariant : @@ -74,9 +76,9 @@ L'exemple suivant ne respecte pas un invariant : var obj = { a: 10 }; Object.preventExtensions(obj); var p = new Proxy(obj, { - has: function(cible, prop) { + has: function (cible, prop) { return false; - } + }, }); "a" in p; // TypeError levée diff --git a/files/fr/web/javascript/reference/global_objects/proxy/proxy/isextensible/index.md b/files/fr/web/javascript/reference/global_objects/proxy/proxy/isextensible/index.md index 672c0eea129c46..cb94d50abb50ba 100644 --- a/files/fr/web/javascript/reference/global_objects/proxy/proxy/isextensible/index.md +++ b/files/fr/web/javascript/reference/global_objects/proxy/proxy/isextensible/index.md @@ -14,8 +14,7 @@ La méthode **`handler.isExtensible()`** est une trappe pour intercepter les op ```js var p = new Proxy(cible, { - isExtensible: function(cible) { - } + isExtensible: function (cible) {}, }); ``` @@ -52,25 +51,31 @@ Si les invariants suivants ne sont pas respectés, le proxy renverra une excepti Dans l'exemple qui suit, on intercepte {{jsxref("Object.isExtensible()")}}. ```js -var p = new Proxy({}, { - isExtensible: function(cible) { - console.log("appelée"); - return true; - } -}); +var p = new Proxy( + {}, + { + isExtensible: function (cible) { + console.log("appelée"); + return true; + }, + }, +); console.log(Object.isExtensible(p)); // "appelée" - // true +// true ``` Le code suivante ne respecte pas l'invariant et entraîne donc une exception. ```js -var p = new Proxy({}, { - isExtensible: function(cible) { - return false; - } -}); +var p = new Proxy( + {}, + { + isExtensible: function (cible) { + return false; + }, + }, +); Object.isExtensible(p); // TypeError est levée ```