From bf8e099b9c8b3c60d60b3712b4fc97b052c39887 Mon Sep 17 00:00:00 2001 From: julieng Date: Tue, 3 Aug 2021 08:03:23 +0200 Subject: convert content to md --- .../global_objects/number/epsilon/index.md | 80 +++--- .../reference/global_objects/number/index.md | 297 +++++++++------------ .../global_objects/number/isfinite/index.md | 103 +++---- .../global_objects/number/isinteger/index.md | 94 +++---- .../reference/global_objects/number/isnan/index.md | 105 ++++---- .../global_objects/number/issafeinteger/index.md | 102 +++---- .../number/max_safe_integer/index.md | 78 ++---- .../global_objects/number/max_value/index.md | 75 ++---- .../number/min_safe_integer/index.md | 66 ++--- .../global_objects/number/min_value/index.md | 77 ++---- .../reference/global_objects/number/nan/index.md | 79 ++---- .../number/negative_infinity/index.md | 114 +++----- .../global_objects/number/parsefloat/index.md | 87 +++--- .../global_objects/number/parseint/index.md | 93 +++---- .../number/positive_infinity/index.md | 116 +++----- .../global_objects/number/toexponential/index.md | 114 +++----- .../global_objects/number/tofixed/index.md | 112 +++----- .../global_objects/number/tolocalestring/index.md | 164 +++++------- .../global_objects/number/toprecision/index.md | 102 +++---- .../global_objects/number/tosource/index.md | 52 ++-- .../global_objects/number/tostring/index.md | 116 +++----- .../global_objects/number/valueof/index.md | 86 +++--- 22 files changed, 896 insertions(+), 1416 deletions(-) (limited to 'files/fr/web/javascript/reference/global_objects/number') 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 88138770c9..cc86d668c0 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 @@ -11,65 +11,47 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Number/EPSILON original_slug: Web/JavaScript/Reference/Objets_globaux/Number/EPSILON --- -
{{JSRef}}
+{{JSRef}} -

La propriété Number.EPSILON représente la différence entre le chiffre 1 (un) et la plus petite valeur supérieure à 1 qui peut être représentée par un nombre en JavaScript.

+La propriété **`Number.EPSILON`** représente la différence entre le chiffre 1 (un) et la plus petite valeur supérieure à 1 qui peut être représentée par un nombre en JavaScript. -

Il n'est pas nécessaire de créer un objet {{jsxref("Number")}} pour accéder à cette propriété statique, elle est accessible avec Number.EPSILON.

+Il n'est pas nécessaire de créer un objet {{jsxref("Number")}} pour accéder à cette propriété statique, elle est accessible avec `Number.EPSILON`. -
{{EmbedInteractiveExample("pages/js/number-epsilon.html")}}
+{{EmbedInteractiveExample("pages/js/number-epsilon.html")}}{{js_property_attributes(0,0,0)}} +## Description +La propriété `EPSILON` vaut environ `2.2204460492503130808472633361816E-16` (ce qui correspond à 2^-52). -
{{js_property_attributes(0,0,0)}}
+## Exemple -

Description

+### Tester une égalité mathématique avec un seuil de précision -

La propriété EPSILON vaut environ 2.2204460492503130808472633361816E-16 (ce qui correspond à 2^-52).

- -

Exemple

- -

Tester une égalité mathématique avec un seuil de précision

- -
x = 0.2;
+```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)

+## Prothèse d'émulation (_polyfill_) -
if (Number.EPSILON === undefined) {
+```js
+if (Number.EPSILON === undefined) {
   Number.EPSILON  =  Math.pow(2, -52);
 }
-
- -

Spécifications

- - - - - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('ES2015', '#sec-number.epsilon', 'Number.EPSILON')}}{{Spec2('ES2015')}}Définition initiale.
{{SpecName('ESDraft', '#sec-number.epsilon', 'Number.EPSILON')}}{{Spec2('ESDraft')}} 
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.Number.EPSILON")}}

- -

Voir aussi

- - +``` + +## Spécifications + +| Spécification | État | Commentaires | +| ------------------------------------------------------------------------------------ | ---------------------------- | -------------------- | +| {{SpecName('ES2015', '#sec-number.epsilon', 'Number.EPSILON')}} | {{Spec2('ES2015')}} | Définition initiale. | +| {{SpecName('ESDraft', '#sec-number.epsilon', 'Number.EPSILON')}} | {{Spec2('ESDraft')}} |   | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Number.EPSILON")}} + +## Voir aussi + +- L'objet {{jsxref("Number")}} auquel appartient cette propriété. 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 bc4c146cca..67e0253224 100644 --- a/files/fr/web/javascript/reference/global_objects/number/index.md +++ b/files/fr/web/javascript/reference/global_objects/number/index.md @@ -8,137 +8,129 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Number original_slug: Web/JavaScript/Reference/Objets_globaux/Number --- -
{{JSRef}}
- -

L'objet Number est une enveloppe objet (wrapper) autour du type primitif numérique. Autrement dit, il est utilisé pour manipuler les nombres comme des objets. Pour créer un objet Number, on utilise le constructeur Number().

- -

Le type JavaScript Number utilise une représentation binaire à précision double sur 64 bits telle que décrite par le standard IEEE 754. Les implémentations plus récentes offrent un nouveau type : {{jsxref("BigInt")}} qui permet de représenter des entiers avec une précision arbitraire.

- -

Syntaxe

- -
new Number(valeur);
-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
- -

Paramètres

- -
-
valeur
-
La valeur numérique pour l'objet qu'on souhaite créer.
-
- -

Description

- -

L'objet Number est principalement utilisé dans les cas de figure suivants :

- - - -

Propriétés

- -
-
{{jsxref("Number.EPSILON")}}
-
Le plus petit intervalle entre deux valeurs qu'il est possible de représenter en JavaScript.
-
{{jsxref("Number.MAX_SAFE_INTEGER")}}
-
La valeur entière maximale qu'on peut représenter en JavaScript (2^53 - 1).
-
{{jsxref("Number.MAX_VALUE")}}
-
La valeur numérique maximale qu'on peut représenter en JavaScript.
-
{{jsxref("Number.MIN_SAFE_INTEGER")}}
-
La valeur entière minimale qu'on peut représenter en JavaScript (-(2^53 - 1)).
-
{{jsxref("Number.MIN_VALUE")}}
-
La plus petite valeur qu'on peut représenter en JavaScript, c'est-à-dire le plus petit nombre positif (le nombre le plus près de zéro qui n'est pas égal à zéro et qu'on peut représenter en JavaScript).
-
{{jsxref("Number.NaN")}}
-
Une valeur spéciale pour représenter les valeurs non-numériques (NaN correspond à « not a number » en anglais, qui signifie « n'est pas un nombre »).
-
{{jsxref("Number.NEGATIVE_INFINITY")}}
-
Une valeur spéciale pour représenter l'infini négatif.
-
{{jsxref("Number.POSITIVE_INFINITY")}}
-
Une valeur spéciale pour représenter l'infini (positif).
-
{{jsxref("Number.prototype")}}
-
Cet objet permet d'ajouter des propriétés aux instances de Number.
-
- -

Méthodes

- -
-
{{jsxref("Number.isNaN()")}}
-
Cette méthode permet de déterminer si la valeur passée en argument vaut NaN.
-
{{jsxref("Number.isFinite()")}}
-
Cette méthode permet de déterminer si la valeur numérique passée en argument est un nombre fini.
-
{{jsxref("Number.isInteger()")}}
-
Cette méthode permet de déterminer si la valeur passée en argument est un entier.
-
{{jsxref("Number.isSafeInteger()")}}
-
Cette méthode permet de déterminer si la valeur passée en argument peut correctement être représentée comme un entier en JavaScript (savoir si elle est comprise entre -(2^53 - 1) et 2^53 - 1).
-
{{jsxref("Number.toInteger()")}} {{obsolete_inline}}
-
Cette méthode est utilisée afin d'évaluer et de convertir la valeur passée en argument en entier (ou en l'{{jsxref("Infinity", "infini","",1)}}). Cette méthode a été supprimée.
-
{{jsxref("Number.parseFloat()", "Number.parseFloat(string)")}}
-
Cette méthode correspond à la méthode {{jsxref("parseFloat", "parseFloat()")}} de l'objet global.
-
{{jsxref("Number.parseInt()", "Number.parseInt(string, [radix])")}}
-
Cette méthode correspond à la méthode {{jsxref("parseInt", "parseInt()")}} de l'objet global.
-
- -

Les instances de Number

- -

Toutes les instances de Number héritent de {{jsxref("Number.prototype")}}. Il est possible de modifier le prototype du constructeur Number pour affecter toutes les instances de Number.

- -

Méthodes

- -
-
-
{{jsxref("Number.prototype.toExponential()" ,"Number.prototype.toExponential(fractionDigits)")}}
-
Retourne une chaîne représentant le nombre en notation exponentielle.
-
{{jsxref("Number.prototype.toFixed()", "Number.prototype.toFixed(digits)")}}
-
Retourne une chaîne représentant le nombre avec la notation virgule fixe.
-
{{jsxref("Number.prototype.toLocaleString()", "Number.prototype.toLocaleString([locales [, options]])")}}
-
Retourne une chaîne avec une représentation sensible à la langue de ce nombre. Surcharge la méthode {{jsxref("Object.prototype.toLocaleString()")}}.
-
{{jsxref("Number.prototype.toPrecision()", "Number.prototype.toPrecision(precision)")}}
-
Retourne une chaîne représentant le nombre avec une précision donnée en notation virgule fixe ou exponentielle.
-
{{jsxref("Number.prototype.toString()", "Number.prototype.toString([radix])")}}
-
Retourne une chaîne représentant le nombre dans une base numérique (radix) donnée. Surcharge la méthode {{jsxref("Object.prototype.toString()")}}.
-
{{jsxref("Number.prototype.valueOf()")}}
-
Retourne la valeur primitive de l'objet spécifié. Surcharge la méthode {{jsxref("Object.prototype.valueOf()")}}.
-
-
- -

Exemples

- -

Utiliser l'objet Number pour affecter des valeurs numériques à des variables

- -

Dans l'exemple suivant, on utilise les propriétés de l'objet Number pour affecter des valeurs à des variables numériques :

- -
var plusGrandNombre = Number.MAX_VALUE;
+{{JSRef}}
+
+L'objet **`Number`** est une enveloppe objet (_wrapper_) autour du [type primitif numérique](/fr/docs/Web/JavaScript/Structures_de_données#Le_type_nombre). Autrement dit, il est utilisé pour manipuler les nombres comme des objets. Pour créer un objet `Number`, on utilise le constructeur `Number()`.
+
+Le type JavaScript `Number` utilise [une représentation binaire à précision double sur 64 bits telle que décrite par le standard IEEE 754](https://fr.wikipedia.org/wiki/IEEE_754). Les implémentations plus récentes offrent un nouveau type : {{jsxref("BigInt")}} qui permet de représenter des entiers avec une précision arbitraire.
+
+## Syntaxe
+
+    new Number(valeur);
+    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
+
+### Paramètres
+
+- `valeur`
+  - : La valeur numérique pour l'objet qu'on souhaite créer.
+
+## Description
+
+L'objet `Number` est principalement utilisé dans les cas de figure suivants :
+
+- Si l'argument ne peut pas être converti en un nombre, il renverra {{jsxref("NaN")}}.
+- Dans un contexte de fonction simple (quand il n'est pas utilisé comme un constructeur avec l'opérateur {{jsxref("Opérateurs/L_opérateur_new", "new")}}), `Number` peut être utilisé afin d'effectuer des conversions.
+
+## Propriétés
+
+- {{jsxref("Number.EPSILON")}}
+  - : Le plus petit intervalle entre deux valeurs qu'il est possible de représenter en JavaScript.
+- {{jsxref("Number.MAX_SAFE_INTEGER")}}
+  - : La valeur entière maximale qu'on peut représenter en JavaScript (`2^53 - 1`).
+- {{jsxref("Number.MAX_VALUE")}}
+  - : La valeur numérique maximale qu'on peut représenter en JavaScript.
+- {{jsxref("Number.MIN_SAFE_INTEGER")}}
+  - : La valeur entière minimale qu'on peut représenter en JavaScript (`-(2^53 - 1)`).
+- {{jsxref("Number.MIN_VALUE")}}
+  - : La plus petite valeur qu'on peut représenter en JavaScript, c'est-à-dire le plus petit nombre positif (le nombre le plus près de zéro qui n'est pas égal à zéro et qu'on peut représenter en JavaScript).
+- {{jsxref("Number.NaN")}}
+  - : Une valeur spéciale pour représenter les valeurs non-numériques (**NaN** correspond à « **\*n**ot **a** **n**umber\* » en anglais, qui signifie « n'est pas un nombre »).
+- {{jsxref("Number.NEGATIVE_INFINITY")}}
+  - : Une valeur spéciale pour représenter l'infini négatif.
+- {{jsxref("Number.POSITIVE_INFINITY")}}
+  - : Une valeur spéciale pour représenter l'infini (positif).
+- {{jsxref("Number.prototype")}}
+  - : Cet objet permet d'ajouter des propriétés aux instances de `Number`.
+
+## Méthodes
+
+- {{jsxref("Number.isNaN()")}}
+  - : Cette méthode permet de déterminer si la valeur passée en argument vaut `NaN`.
+- {{jsxref("Number.isFinite()")}}
+  - : Cette méthode permet de déterminer si la valeur numérique passée en argument est un nombre fini.
+- {{jsxref("Number.isInteger()")}}
+  - : Cette méthode permet de déterminer si la valeur passée en argument est un entier.
+- {{jsxref("Number.isSafeInteger()")}}
+  - : Cette méthode permet de déterminer si la valeur passée en argument peut correctement être représentée comme un entier en JavaScript (savoir si elle est comprise entre `-(2^53 - 1)` et `2^53 - 1`).
+- {{jsxref("Number.toInteger()")}} {{obsolete_inline}}
+  - : Cette méthode est utilisée afin d'évaluer et de convertir la valeur passée en argument en entier (ou en l'{{jsxref("Infinity", "infini","",1)}}). Cette méthode a été supprimée.
+- {{jsxref("Number.parseFloat()", "Number.parseFloat(string)")}}
+  - : Cette méthode correspond à la méthode {{jsxref("parseFloat", "parseFloat()")}} de l'objet global.
+- {{jsxref("Number.parseInt()", "Number.parseInt(string, [radix])")}}
+  - : Cette méthode correspond à la méthode {{jsxref("parseInt", "parseInt()")}} de l'objet global.
+
+## Les instances de `Number`
+
+Toutes les instances de `Number` héritent de {{jsxref("Number.prototype")}}. Il est possible de modifier le prototype du constructeur `Number` pour affecter toutes les instances de `Number`.
+
+### Méthodes
+
+- {{jsxref("Number.prototype.toExponential()" ,"Number.prototype.toExponential(fractionDigits)")}}
+  - : Retourne une chaîne représentant le nombre en notation exponentielle.
+- {{jsxref("Number.prototype.toFixed()", "Number.prototype.toFixed(digits)")}}
+  - : Retourne une chaîne représentant le nombre avec la notation virgule fixe.
+- {{jsxref("Number.prototype.toLocaleString()", "Number.prototype.toLocaleString([locales [, options]])")}}
+  - : Retourne une chaîne avec une représentation sensible à la langue de ce nombre. Surcharge la méthode {{jsxref("Object.prototype.toLocaleString()")}}.
+- {{jsxref("Number.prototype.toPrecision()", "Number.prototype.toPrecision(precision)")}}
+  - : Retourne une chaîne représentant le nombre avec une précision donnée en notation virgule fixe ou exponentielle.
+- {{jsxref("Number.prototype.toString()", "Number.prototype.toString([radix])")}}
+  - : Retourne une chaîne représentant le nombre dans une base numérique (radix) donnée. Surcharge la méthode {{jsxref("Object.prototype.toString()")}}.
+- {{jsxref("Number.prototype.valueOf()")}}
+  - : Retourne la valeur primitive de l'objet spécifié. Surcharge la méthode {{jsxref("Object.prototype.valueOf()")}}.
+
+## Exemples
+
+### Utiliser l'objet `Number` pour affecter des valeurs numériques à des variables
+
+Dans l'exemple suivant, on utilise les propriétés de l'objet `Number` pour affecter des valeurs à des variables numériques :
+
+```js
+var plusGrandNombre = Number.MAX_VALUE;
 var plusPetitNombre = Number.MIN_VALUE;
 var infini = Number.POSITIVE_INFINITY;
 var infiniNégatif = Number.NEGATIVE_INFINITY;
 var nonNumérique = Number.NaN;
-
+``` -

Intervalle entier pour Number

+### Intervalle entier pour `Number` -

Dans l'exemple suivant, on illustre les valeurs numériques maximales et minimales (exclues) qu'on peut représenter avec un nombre en JavaScript (pour plus de détails, voir le chapitre 6.1.6 du standard ECMAScript) :

+Dans l'exemple suivant, on illustre les valeurs numériques maximales et minimales (exclues) qu'on peut représenter avec un nombre en JavaScript (pour plus de détails, [voir le chapitre 6.1.6 du standard ECMAScript](https://tc39.github.io/ecma262/#sec-ecmascript-language-types-number-type)) : -
var biggestInt = 9007199254740992; //Number.MAX_SAFE_INTEGER+1 (2^53-1)
+```js
+var biggestInt = 9007199254740992; //Number.MAX_SAFE_INTEGER+1 (2^53-1)
 var smallestInt = -9007199254740992; //Number.MIN_SAFE_INTEGER-1 -(2^53-1)
-
+``` -

Lorsqu'on analyse et convertit des données JSON, les valeurs en dehors de cet intervalle peuvent entraîner des erreurs ou des corruptions de valeurs lors de leurs conversions. Selon les objets qu'on souhaite représenter, on peut utiliser {{jsxref("String")}} dans certains cas pour représenter certaines valeurs.

+Lorsqu'on analyse et convertit des données JSON, les valeurs en dehors de cet intervalle peuvent entraîner des erreurs ou des corruptions de valeurs lors de leurs conversions. Selon les objets qu'on souhaite représenter, on peut utiliser {{jsxref("String")}} dans certains cas pour représenter certaines valeurs. -

Utiliser Number pour convertir un objet Date

+### Utiliser `Number` pour convertir un objet `Date` -

Dans l'exemple suivant, on convertit un objet {{jsxref("Date")}} en une valeur numérique grâce à la fonction Number :

+Dans l'exemple suivant, on convertit un objet {{jsxref("Date")}} en une valeur numérique grâce à la fonction `Number` : -
var d = new Date('December 17, 1995 03:24:00');
+```js
+var d = new Date('December 17, 1995 03:24:00');
 console.log(Number(d));
-
+``` -

Ceci affichera "819167040000".

+Ceci affichera "819167040000". -

Convertir une chaîne représentant une valeur numérique en un nombre

+### Convertir une chaîne représentant une valeur numérique en un nombre -
Number("123");       // 123
+```js
+Number("123");       // 123
 Number("12.3");      // 12.3
 Number("12.00");     // 12
 Number("123e-1");    // 12.3
@@ -149,54 +141,27 @@ Number("0o11");      // 9
 Number("toto");      // NaN
 Number("100a");      // NaN
 Number("-Infinity";) // -Infinity
-
- -
-

Note : On pourra également convertir null en 0 grâce à Number : Number(null) donnera 0.

-
- -

Spécifications

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('ES1')}}{{Spec2('ES1')}}Définition initiale. Implémentée avec JavaScript 1.1.
{{SpecName('ES5.1', '#sec-15.7', 'Number')}}{{Spec2('ES5.1')}}
{{SpecName('ES6', '#sec-number-objects', 'Number')}}{{Spec2('ES6')}}Ajout des méthodes et propriétés suivantes : ({{jsxref("Number.EPSILON", "EPSILON")}}, {{jsxref("Number.isFinite", "isFinite")}}, {{jsxref("Number.isInteger", "isInteger")}}, {{jsxref("Number.isNaN", "isNaN")}}, {{jsxref("Number.parseFloat", "parseFloat")}}, {{jsxref("Number.parseInt", "parseInt")}})
{{SpecName('ESDraft', '#sec-number-objects', 'Number')}}{{Spec2('ESDraft')}}
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.Number")}}

- -

Voir aussi

- - +``` + +> **Note :** On pourra également convertir `null` en `0` grâce à `Number` : `Number(null)` donnera `0`. + +## Spécifications + +| Spécification | État | Commentaires | +| ---------------------------------------------------------------------------- | ---------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| {{SpecName('ES1')}} | {{Spec2('ES1')}} | Définition initiale. Implémentée avec JavaScript 1.1. | +| {{SpecName('ES5.1', '#sec-15.7', 'Number')}} | {{Spec2('ES5.1')}} | | +| {{SpecName('ES6', '#sec-number-objects', 'Number')}} | {{Spec2('ES6')}} | Ajout des méthodes et propriétés suivantes : ({{jsxref("Number.EPSILON", "EPSILON")}}, {{jsxref("Number.isFinite", "isFinite")}}, {{jsxref("Number.isInteger", "isInteger")}}, {{jsxref("Number.isNaN", "isNaN")}}, {{jsxref("Number.parseFloat", "parseFloat")}}, {{jsxref("Number.parseInt", "parseInt")}}) | +| {{SpecName('ESDraft', '#sec-number-objects', 'Number')}} | {{Spec2('ESDraft')}} | | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Number")}} + +## Voir aussi + +- {{jsxref("NaN")}} +- L'objet global {{jsxref("Math")}} +- [Les types de données en JavaScript](/fr/docs/Web/JavaScript/Structures_de_données#Le_type_nombre) +- [Un billet sur le type `Number` (en anglais)](https://medium.com/@maximus.koretskyi/javascripts-number-type-8d59199db1b6#.9whwe88tz) +- Représenter de grands entiers avec une précision arbitraire : {{jsxref("BigInt")}} 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 9cf0331fab..bb0af546ce 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 @@ -11,34 +11,33 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Number/isFinite original_slug: Web/JavaScript/Reference/Objets_globaux/Number/isFinite --- -
{{JSRef}}
+{{JSRef}} -

La méthode Number.isFinite() permet de déterminer si la valeur fournie est un nombre fini.

+La méthode **`Number.isFinite()`** permet de déterminer si la valeur fournie est un nombre fini. -
{{EmbedInteractiveExample("pages/js/number-isfinite.html")}}
+{{EmbedInteractiveExample("pages/js/number-isfinite.html")}} -

Syntaxe

+## Syntaxe -
Number.isFinite(valeurÀTester);
+ Number.isFinite(valeurÀTester); -

Paramètres

+### Paramètres -
-
valeurÀTester
-
La valeur dont on souhaite savoir si elle est finie.
-
+- `valeurÀTester` + - : La valeur dont on souhaite savoir si elle est finie. -

Valeur de retour

+### Valeur de retour -

Un booléen indiquant si la valeur passée en argument est un nombre fini.

+Un booléen indiquant si la valeur passée en argument est un nombre fini. -

Description

+## Description -

Par rapport à la fonction de l'objet global {{jsxref("isFinite","isFinite()")}} qui convertit l'argument donné en un nombre, la fonction Number.isFinite ne convertit pas l'argument et ne renvoie pas true.

+Par rapport à la fonction de l'objet global {{jsxref("isFinite","isFinite()")}} qui convertit l'argument donné en un nombre, la fonction `Number.isFinite `ne convertit pas l'argument et ne renvoie pas `true`. -

Exemples

+## Exemples -
Number.isFinite(Infinity);  // false
+```js
+Number.isFinite(Infinity);  // false
 Number.isFinite(NaN);       // false
 Number.isFinite(-Infinity); // false
 
@@ -50,11 +49,12 @@ Number.isFinite("0");       // false, ce qui aurait
 
 Number.isFinite(null);      // false, ce qui aurait
                             // renvoyé true avc isFinite(null)
-
+``` -

Prothèse d'émulation (polyfill)

+## Prothèse d'émulation (_polyfill_) -
// Number.isFinite polyfill
+```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) {
@@ -70,43 +70,28 @@ if (typeof Number.isFinite !== 'function') {
         return true;
     };
 }
-
- -

Deuxième version plus concise qui utilise la méthode globale isFinite

- -
if (Number.isFinite === undefined) Number.isFinite = function(value) {
-    return typeof value === "number" && isFinite(value);
-}
- -

Spécifications

- - - - - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('ES6', '#sec-number.isfinite', 'Number.isInteger')}}{{Spec2('ES6')}}Définition initiale.
{{SpecName('ESDraft', '#sec-number.isfinite', 'Number.isInteger')}}{{Spec2('ESDraft')}}
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.Number.isFinite")}}

- -

Voir aussi

- - +``` + +Deuxième version plus concise qui utilise la méthode globale `isFinite` + +```js +if (Number.isFinite === undefined) Number.isFinite = function(value) { +    return typeof value === "number" && isFinite(value); +} +``` + +## Spécifications + +| Spécification | État | Commentaires | +| ---------------------------------------------------------------------------------------- | ---------------------------- | -------------------- | +| {{SpecName('ES6', '#sec-number.isfinite', 'Number.isInteger')}} | {{Spec2('ES6')}} | Définition initiale. | +| {{SpecName('ESDraft', '#sec-number.isfinite', 'Number.isInteger')}} | {{Spec2('ESDraft')}} | | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Number.isFinite")}} + +## Voir aussi + +- L'objet {{jsxref("Number")}} auquel appartient cette méthode +- La méthode {{jsxref("isFinite", "isFinite()")}} de l'objet global 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 a6f1f364e5..f299694e36 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 @@ -10,34 +10,33 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Number/isInteger original_slug: Web/JavaScript/Reference/Objets_globaux/Number/isInteger --- -
{{JSRef}}
+{{JSRef}} -

La méthode Number.isInteger() permet de déterminer si l'argument est un nombre entier.

+La méthode **`Number.isInteger()`** permet de déterminer si l'argument est un nombre entier. -
{{EmbedInteractiveExample("pages/js/number-isinteger.html")}}
+{{EmbedInteractiveExample("pages/js/number-isinteger.html")}} -

Syntaxe

+## Syntaxe -
Number.isInteger(valeurÀTester)
+ Number.isInteger(valeurÀTester) -

Paramètres

+### Paramètres -
-
valeurÀTester
-
La valeur dont on souhaite savoir si elle est entière ou non.
-
+- `valeurÀTester` + - : La valeur dont on souhaite savoir si elle est entière ou non. -

Valeur de retour

+### Valeur de retour -

Un booléen qui indique si la valeur fournie en argument est un entier.

+Un booléen qui indique si la valeur fournie en argument est un entier. -

Description

+## Description -

Si la valeur à tester est un entier, cette méthode renvoie true, false sinon. Si la valeur est {{jsxref("NaN")}} ou l'infini ({{jsxref("Infinity")}}), la méthode renverra false. La méthode renverra également true pour les nombres flottants qui peuvent être représentés comme des entiers.

+Si la valeur à tester est un entier, cette méthode renvoie `true`, `false` sinon. Si la valeur est {{jsxref("NaN")}} ou l'infini ({{jsxref("Infinity")}}), la méthode renverra `false`. La méthode renverra également `true` pour les nombres flottants qui peuvent être représentés comme des entiers. -

Exemples

+## Exemples -
Number.isInteger(1);         // true
+```js
+Number.isInteger(1);         // true
 Number.isInteger(-100000);   // true
 Number.isInteger(0);         // true
 Number.isInteger(1.000)      // true
@@ -54,46 +53,29 @@ Number.isInteger("10");      // false
 Number.isInteger(5.0);       // true
 Number.isInteger(5.000000000000001);// false
 Number.isInteger(5.0000000000000001); // true
-
+``` -

Prothèse d'émulation (polyfill)

+## Prothèse d'émulation (_polyfill_) -
Number.isInteger = Number.isInteger || function(value) {
-    return typeof value === "number" &&
-           isFinite(value) &&
+```js
+Number.isInteger = Number.isInteger || function(value) {
+    return typeof value === "number" &&
+           isFinite(value) &&
            Math.floor(value) === value;
-};
- -

Spécifications

- - - - - - - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('ES6', '#sec-number.isinteger', 'Number.isInteger')}}{{Spec2('ES6')}}Définition initiale.
{{SpecName('ESDraft', '#sec-number.isinteger', 'Number.isInteger')}}{{Spec2('ESDraft')}}
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.Number.isInteger")}}

- -

Voir aussi

- - +}; +``` + +## Spécifications + +| Spécification | État | Commentaires | +| -------------------------------------------------------------------------------------------- | ---------------------------- | -------------------- | +| {{SpecName('ES6', '#sec-number.isinteger', 'Number.isInteger')}} | {{Spec2('ES6')}} | Définition initiale. | +| {{SpecName('ESDraft', '#sec-number.isinteger', 'Number.isInteger')}} | {{Spec2('ESDraft')}} | | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Number.isInteger")}} + +## Voir aussi + +- L'objet global {{jsxref("Number")}} auquel appartient cette méthode. 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 2b7f565807..fef4caa264 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 @@ -10,36 +10,35 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Number/isNaN original_slug: Web/JavaScript/Reference/Objets_globaux/Number/isNaN --- -
{{JSRef}}
+{{JSRef}} -

La méthode Number.isNaN() permet de déterminer si la valeur passée en argument est {{jsxref("NaN")}}, avec un type {{jsxref("Number")}}. Cette version est plus robuste que la méthode de l'objet global {{jsxref("isNaN")}}.

+La méthode **`Number.isNaN()`** permet de déterminer si la valeur passée en argument est {{jsxref("NaN")}}, avec un type {{jsxref("Number")}}. Cette version est plus robuste que la méthode de l'objet global {{jsxref("isNaN")}}. -
{{EmbedInteractiveExample("pages/js/number-isnan.html", "taller")}}
+{{EmbedInteractiveExample("pages/js/number-isnan.html", "taller")}} -

Syntaxe

+## Syntaxe -
Number.isNaN(valeurÀTester)
+ Number.isNaN(valeurÀTester) -

Paramètres

+### Paramètres -
-
valeurÀTester
-
La valeur qu'on souhaite comparer à {{jsxref("NaN")}}.
-
+- `valeurÀTester` + - : La valeur qu'on souhaite comparer à {{jsxref("NaN")}}. -

Valeur de retour

+### Valeur de retour -

Un booléen qui indique si la valeur fournie en argument est {{jsxref("NaN")}}.

+Un booléen qui indique si la valeur fournie en argument est {{jsxref("NaN")}}. -

Description

+## Description -

Les deux opérateurs d'égalité, {{jsxref("Opérateurs/Opérateurs_de_comparaison", "==", "#.C3.89galit.C3.A9_simple_(.3D.3D)")}} et {{jsxref("Opérateurs/Opérateurs_de_comparaison", "===", "#.C3.89galit.C3.A9_stricte_(.3D.3D.3D)")}}, renvoient false pour vérifier que {{jsxref("NaN")}} est NaN. La fonction Number.isNaN est nécessaire pour distinguer ce cas. Le résultat de cette comparaison sera différent avec les autres méthodes de comparaisons en JavaScript.

+Les deux opérateurs d'égalité, {{jsxref("Opérateurs/Opérateurs_de_comparaison", "==", "#.C3.89galit.C3.A9_simple_(.3D.3D)")}} et {{jsxref("Opérateurs/Opérateurs_de_comparaison", "===", "#.C3.89galit.C3.A9_stricte_(.3D.3D.3D)")}}, renvoient `false` pour vérifier que {{jsxref("NaN")}} _est_ NaN. La fonction `Number.isNaN` est nécessaire pour distinguer ce cas. Le résultat de cette comparaison sera différent avec les autres méthodes de comparaisons en JavaScript. -

En effet, la fonction globale {{jsxref("isNaN")}} convertit l'argument en un nombre.  Number.isNaN ne convertit pas l'argument. Cela signifie qu'on peut passer des valeurs qui, normalement, seraient converties en NaN, mais qui ne sont pas NaN. Cela signifie également que, uniquement lorsque la méthode sera utilisée avec des nombres qui valent NaN, elle renverra true.

+En effet, la fonction globale {{jsxref("isNaN")}} convertit l'argument en un nombre.  `Number.isNaN` ne convertit pas l'argument. Cela signifie qu'on peut passer des valeurs qui, normalement, seraient converties en NaN, mais qui ne sont pas NaN. Cela signifie également que, uniquement lorsque la méthode sera utilisée avec des nombres qui valent `NaN`, elle renverra `true`. -

Exemples

+## Exemples -
Number.isNaN(NaN); // true
+```js
+Number.isNaN(NaN); // true
 Number.isNaN(Number.NaN); // true
 Number.isNaN(0 / 0); // true
 
@@ -56,46 +55,32 @@ Number.isNaN("37.37");
 Number.isNaN("");
 Number.isNaN(" ");
 Number.isNaN("NaN");
-Number.isNaN("blabla"); // ex : cette valeur aurait rendu true avec la méthode isNaN de l'objet global
- -

Prothèse d'émulation (polyfill)

- -

La fonction suivant fonctionne car NaN est la seule valeur JavaScript qui n'est pas égale à elle-même.

- -
Number.isNaN = Number.isNaN || function(value) {
-    return typeof value === "number" && isNaN(value);
-}
- -

Spécifications

- - - - - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('ES2015', '#sec-number.isnan', 'Number.isnan')}}{{Spec2('ES2015')}}Définition initiale.
{{SpecName('ESDraft', '#sec-number.isnan', 'Number.isnan')}}{{Spec2('ESDraft')}} 
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.Number.isNaN")}}

- -

Voir aussi

- - +Number.isNaN("blabla"); // ex : cette valeur aurait rendu true avec la méthode isNaN de l'objet global +``` + +## Prothèse d'émulation (_polyfill_) + +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) { + return typeof value === "number" && isNaN(value); +} +``` + +## Spécifications + +| Spécification | État | Commentaires | +| -------------------------------------------------------------------------------- | ---------------------------- | -------------------- | +| {{SpecName('ES2015', '#sec-number.isnan', 'Number.isnan')}} | {{Spec2('ES2015')}} | Définition initiale. | +| {{SpecName('ESDraft', '#sec-number.isnan', 'Number.isnan')}} | {{Spec2('ESDraft')}} |   | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Number.isNaN")}} + +## Voir aussi + +- L'objet {{jsxref("Number")}} auquel appartient cette méthode. +- La méthode {{jsxref("Objets_globaux/Object/is", "Object.is")}} qui permet d'effectuer des comparaisons sur l'égalité de valeur +- La méthode {{jsxref("isNaN")}} de l'objet global 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 c992339e23..4958589300 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 @@ -11,49 +11,42 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Number/isSafeInteger original_slug: Web/JavaScript/Reference/Objets_globaux/Number/isSafeInteger --- -
{{JSRef}}
+{{JSRef}} -

La méthode Number.isSafeInteger() permet de déterminer si la valeur, passée en argument, est un entier représentable correctement en JavaScript (c'est-à-dire un nombre compris entre -(2^53-1) et 2^53-1).

+La méthode **`Number.isSafeInteger()`** permet de déterminer si la valeur, passée en argument, est un entier représentable correctement en JavaScript (c'est-à-dire un nombre compris entre -(2^53-1) et 2^53-1). -
{{EmbedInteractiveExample("pages/js/number-issafeinteger.html")}}
+{{EmbedInteractiveExample("pages/js/number-issafeinteger.html")}} +> **Note :** Pour représenter des entiers qui ne sont pas compris dans cet intervalle, on pourra utiliser le type {{jsxref("BigInt")}}. +## Syntaxe -
-

Note : Pour représenter des entiers qui ne sont pas compris dans cet intervalle, on pourra utiliser le type {{jsxref("BigInt")}}.

-
+ Number.isSafeInteger(valeurÀTester) -

Syntaxe

+### Paramètres -
Number.isSafeInteger(valeurÀTester)
+- `valeurÀTester` + - : La valeur dont on souhaite savoir si elle représente un entier représentable correctement en une valeur non signée sur 32 bits. (JavaScript utilise [les nombres au format de virgule flottante à double précision](https://en.wikipedia.org/wiki/Double_precision_floating-point_format) comme spécifié dans [IEEE 754](https://fr.wikipedia.org/wiki/IEEE_754) et ne peut représenter avec certitude un entier qu'entre `-(2^53-1)` et `2^53-1` (c'est-à-dire ± `9007199254740991`). -

Paramètres

+### Valeur de retour -
-
valeurÀTester
-
La valeur dont on souhaite savoir si elle représente un entier représentable correctement en une valeur non signée sur 32 bits. (JavaScript utilise les nombres au format de virgule flottante à double précision comme spécifié dans IEEE 754 et ne peut représenter avec certitude un entier qu'entre -(2^53-1) et 2^53-1 (c'est-à-dire ± 9007199254740991).
-
+Un booléen qui indique si la valeur fournie en argument est un entier représentable correctement en JavaScript. -

Valeur de retour

+## Description -

Un booléen qui indique si la valeur fournie en argument est un entier représentable correctement en JavaScript.

+Un entier correctement représentable en JavaScript : -

Description

+- peut exactement être représenté avec un nombre à précision double selon IEEE-754 +- la réprésentation IEEE-754 du nombre ne permet pas de l'arrondir à un autre entier pouvant être représenté avec le format décrit par IEEE-754. -

Un entier correctement représentable en JavaScript :

+Ainsi, par exemple, `2^53 - 1` peut être représenté correctement, aucun autre entier ne peut être arrondi en cette valeur selon IEEE-754. En revanche, `2^53` ne peut pas être représenté correctement car `2^53 + 1` sera arrondi en `2^53` selon les règles IEEE-754 (arrondi à l'entier le plus proche). - +L'intervalle des entiers qui peuvent être correctement représentés est `[-(2^53 - 1),2^53 - 1` ]. -

Ainsi, par exemple, 2^53 - 1 peut être représenté correctement, aucun autre entier ne peut être arrondi en cette valeur selon IEEE-754. En revanche, 2^53 ne peut pas être représenté correctement car 2^53 + 1 sera arrondi en 2^53 selon les règles IEEE-754 (arrondi à l'entier le plus proche).

+## Exemples -

L'intervalle des entiers qui peuvent être correctement représentés est [-(2^53 - 1),2^53 - 1 ].

- -

Exemples

- -
Number.isSafeInteger(3);                    // true
+```js
+Number.isSafeInteger(3);                    // true
 Number.isSafeInteger(Math.pow(2, 53))       // false
 Number.isSafeInteger(Math.pow(2, 53) - 1)   // true
 Number.isSafeInteger(NaN);                  // false
@@ -61,39 +54,22 @@ Number.isSafeInteger(Infinity);             // false
 Number.isSafeInteger("3");                  // false
 Number.isSafeInteger(3.1);                  // false
 Number.isSafeInteger(3.0);                  // true
-
- -

Spécifications

- - - - - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('ES2015', '#sec-number.issafeinteger', 'Number.isSafeInteger')}}{{Spec2('ES2015')}}Définition initiale.
{{SpecName('ESDraft', '#sec-number.issafeinteger', 'Number.isSafeInteger')}}{{Spec2('ESDraft')}}
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.Number.isSafeInteger")}}

- -

Voir aussi

- - +``` + +## Spécifications + +| Spécification | État | Commentaires | +| ---------------------------------------------------------------------------------------------------- | ---------------------------- | -------------------- | +| {{SpecName('ES2015', '#sec-number.issafeinteger', 'Number.isSafeInteger')}} | {{Spec2('ES2015')}} | Définition initiale. | +| {{SpecName('ESDraft', '#sec-number.issafeinteger', 'Number.isSafeInteger')}} | {{Spec2('ESDraft')}} | | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Number.isSafeInteger")}} + +## Voir aussi + +- L'objet {{jsxref("Number")}} auquel appartient cette méthode +- {{jsxref("Number.MIN_SAFE_INTEGER")}} +- {{jsxref("Number.MAX_SAFE_INTEGER")}} +- {{jsxref("BigInt")}} 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 9b389e3531..a38f9c3695 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 @@ -10,64 +10,44 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER original_slug: Web/JavaScript/Reference/Objets_globaux/Number/MAX_SAFE_INTEGER --- -
{{JSRef}}
+{{JSRef}} -

La constante Number.MAX_SAFE_INTEGER représente la valeur (sûre) maximale d’un nombre entier en JavaScript (2^53 -1).

+La constante **`Number.MAX_SAFE_INTEGER `**représente la valeur (sûre) maximale d’un nombre entier en JavaScript (2^53 -1). -
-

Note : Pour représenter des entiers supérieurs à cette valeur, on pourra utiliser le type {{jsxref("BigInt")}}.

-
+> **Note :** Pour représenter des entiers supérieurs à cette valeur, on pourra utiliser le type {{jsxref("BigInt")}}. -
{{EmbedInteractiveExample("pages/js/number-maxsafeinteger.html")}}
+{{EmbedInteractiveExample("pages/js/number-maxsafeinteger.html")}} +{{js_property_attributes(0,0,0)}} +## Description -

{{js_property_attributes(0,0,0)}}

+La constante `MAX_SAFE_INTEGER` a une valeur de `9007199254740991`. Cette valeur s'explique par le fait que JavaScript utilise [les nombres au format de virgule flottante à double précision](http://en.wikipedia.org/wiki/Double_precision_floating-point_format) comme spécifié dans [IEEE 754](http://fr.wikipedia.org/wiki/IEEE_754) et ne peut représenter avec certitude qu’un nombre entre `-(2^53-1)` et `2^53 -1`. -

Description

+Dans ce contexte, « sûr » fait référence à la capacité à représenter exactement les entiers et à les comparer entre eux. Par exemple, `Number.MAX_SAFE_INTEGER + 1 === Number.MAX_SAFE_INTEGER + 2` vaudra `true` ce qui est mathématiquement incorrect. Pour plus d'informations, voir également {{jsxref("Number.isSafeInteger()")}}. -

La constante MAX_SAFE_INTEGER a une valeur de 9007199254740991. Cette valeur s'explique par le fait que JavaScript utilise les nombres au format de virgule flottante à double précision comme spécifié dans IEEE 754 et ne peut représenter avec certitude qu’un nombre entre -(2^53-1) et 2^53 -1.

+`MAX_SAFE_INTEGER` est une propriété statique de {{jsxref("Number")}}, elle doit toujours être utilisée comme `Number.MAX_SAFE_INTEGER` et non pas comme la propriété d'un objet `Number` qui aurait été instancié. -

Dans ce contexte, « sûr » fait référence à la capacité à représenter exactement les entiers et à les comparer entre eux. Par exemple, Number.MAX_SAFE_INTEGER + 1 === Number.MAX_SAFE_INTEGER + 2 vaudra true ce qui est mathématiquement incorrect. Pour plus d'informations, voir également {{jsxref("Number.isSafeInteger()")}}.

+## Exemples -

MAX_SAFE_INTEGER est une propriété statique de {{jsxref("Number")}}, elle doit toujours être utilisée comme Number.MAX_SAFE_INTEGER et non pas comme la propriété d'un objet Number qui aurait été instancié.

+```js +Number.MAX_SAFE_INTEGER // 9007199254740991 +Math.pow(2, 53) -1 // 9007199254740991 +``` -

Exemples

+## Spécifications -
Number.MAX_SAFE_INTEGER // 9007199254740991
-Math.pow(2, 53) -1      // 9007199254740991
-
- -

Spécifications

- - - - - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('ES2015', '#sec-number.max_safe_integer', 'Number.MAX_SAFE_INTEGER')}}{{Spec2('ES2015')}}Définition initiale
{{SpecName('ESDraft', '#sec-number.max_safe_integer', 'Number.MAX_SAFE_INTEGER')}}{{Spec2('ESDraft')}}
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.Number.MAX_SAFE_INTEGER")}}

- -

Voir aussi

- - +| Spécification | État | Commentaires | +| ------------------------------------------------------------------------------------------------------------ | ---------------------------- | ------------------- | +| {{SpecName('ES2015', '#sec-number.max_safe_integer', 'Number.MAX_SAFE_INTEGER')}} | {{Spec2('ES2015')}} | Définition initiale | +| {{SpecName('ESDraft', '#sec-number.max_safe_integer', 'Number.MAX_SAFE_INTEGER')}} | {{Spec2('ESDraft')}} | | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Number.MAX_SAFE_INTEGER")}} + +## Voir aussi + +- {{jsxref("Number.MIN_SAFE_INTEGER")}} +- {{jsxref("Number.isSafeInteger()")}} +- {{jsxref("BigInt")}} diff --git a/files/fr/web/javascript/reference/global_objects/number/max_value/index.md b/files/fr/web/javascript/reference/global_objects/number/max_value/index.md index a673992a3b..a56ed64592 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 @@ -9,71 +9,44 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Number/MAX_VALUE original_slug: Web/JavaScript/Reference/Objets_globaux/Number/MAX_VALUE --- -
{{JSRef}}
+{{JSRef}} -

La propriété Number.MAX_VALUE représente la valeur maximale qui peut être représentée par un nombre en JavaScript.

+La propriété **`Number.MAX_VALUE`** représente la valeur maximale qui peut être représentée par un nombre en JavaScript. -
{{EmbedInteractiveExample("pages/js/number-maxvalue.html")}}
+{{EmbedInteractiveExample("pages/js/number-maxvalue.html")}}{{js_property_attributes(0,0,0)}} +## Description +La propriété statique `MAX_VALUE` vaut environ `1.79E+308` (soit 2^1024). Les valeurs supérieures à `MAX_VALUE` sont représentées par {{jsxref("Infinity")}} (pour l'infini). -
{{js_property_attributes(0,0,0)}}
+`MAX_VALUE` est une propriété statique de {{jsxref("Number")}}, il faut donc l'utiliser avec `Number.MAX_VALUE`, plutôt qu'en faisant appel à la propriété d'un objet` Number` qui aurait été instancié (si on appelle cette propriété sur l'objet `Number` créé, on obtiendra {{jsxref("undefined")}}). -

Description

+## Exemples -

La propriété statique MAX_VALUE vaut environ 1.79E+308 (soit 2^1024). Les valeurs supérieures à MAX_VALUE sont représentées par {{jsxref("Infinity")}} (pour l'infini).

+Le code suivant teste si le produit de deux nombres est inférieur ou égal à `MAX_VALUE`, selon le résultat de ce test, soit on utilisera `func1`, soit on utilisera `func2`. -

MAX_VALUE est une propriété statique de {{jsxref("Number")}}, il faut donc l'utiliser avec Number.MAX_VALUE, plutôt qu'en faisant appel à la propriété d'un objet Number qui aurait été instancié (si on appelle cette propriété sur l'objet Number créé, on obtiendra {{jsxref("undefined")}}).

- -

Exemples

- -

Le code suivant teste si le produit de deux nombres est inférieur ou égal à MAX_VALUE, selon le résultat de ce test, soit on utilisera func1, soit on utilisera func2.

- -
if (num1 * num2 <= Number.MAX_VALUE) {
+```js
+if (num1 * num2 <= Number.MAX_VALUE) {
    func1();
 } else {
    func2();
-}
+} +``` -

Spécifications

+## Spécifications - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('ES1')}}{{Spec2('ES1')}}Définition initiale. Implémentée avec JavaScript 1.1.
{{SpecName('ES5.1', '#sec-15.7.3.2', 'Number.MAX_VALUE')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-number.max_value', 'Number.MAX_VALUE')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-number.max_value', 'Number.MAX_VALUE')}}{{Spec2('ESDraft')}} 
+| Spécification | État | Commentaires | +| -------------------------------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- | +| {{SpecName('ES1')}} | {{Spec2('ES1')}} | Définition initiale. Implémentée avec JavaScript 1.1. | +| {{SpecName('ES5.1', '#sec-15.7.3.2', 'Number.MAX_VALUE')}} | {{Spec2('ES5.1')}} |   | +| {{SpecName('ES6', '#sec-number.max_value', 'Number.MAX_VALUE')}} | {{Spec2('ES6')}} |   | +| {{SpecName('ESDraft', '#sec-number.max_value', 'Number.MAX_VALUE')}} | {{Spec2('ESDraft')}} |   | -

Compatibilité des navigateurs

+## Compatibilité des navigateurs -

{{Compat("javascript.builtins.Number.MAX_VALUE")}}

+{{Compat("javascript.builtins.Number.MAX_VALUE")}} -

Voir aussi

+## Voir aussi - +- {{jsxref("Number.MIN_VALUE")}} +- {{jsxref("Number")}} 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 e61fc520fd..befcd40ef6 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 @@ -10,62 +10,40 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Number/MIN_SAFE_INTEGER original_slug: Web/JavaScript/Reference/Objets_globaux/Number/MIN_SAFE_INTEGER --- -
{{JSRef}}
+{{JSRef}} -

La constante Number.MIN_SAFE_INTEGER représente le plus petit entier représentable correctement en JavaScript (-(2^53 -1)).

+La constante **`Number.MIN_SAFE_INTEGER`** représente le plus petit entier représentable correctement en JavaScript (-(2^53 -1)). -
-

Note : Pour représenter des entiers inférieurs à cette valeur, on pourra utiliser le type {{jsxref("BigInt")}}.

-
+> **Note :** Pour représenter des entiers inférieurs à cette valeur, on pourra utiliser le type {{jsxref("BigInt")}}. -
{{EmbedInteractiveExample("pages/js/number-min-safe-integer.html")}}
+{{EmbedInteractiveExample("pages/js/number-min-safe-integer.html")}}{{js_property_attributes(0,0,0)}} +## Description +La constante `MIN_SAFE_INTEGER` vaut `-9007199254740991`. Cette valeur provient du fait qu'en JavaScript, les nombres sont représentés [en format à double précision](https://en.wikipedia.org/wiki/Double_precision_floating-point_format) selon la norme [IEEE 754](http://fr.wikipedia.org/wiki/IEEE_754) et on ne peut représenter correctement que les nombres compris entre `-(2^53-1)` et `2^53 -1`. Voir {{jsxref("Number.isSafeInteger()")}} pour plus d'informations. -
{{js_property_attributes(0,0,0)}}
+`MIN_SAFE_INTEGER` étant une méthode statique de {{jsxref("Number")}}, il faut utiliser `Number.MIN_SAFE_INTEGER()`et non pas la méthode d'un objet `Number` qui aurait été instancié. -

Description

+## Exemples -

La constante MIN_SAFE_INTEGER vaut -9007199254740991. Cette valeur provient du fait qu'en JavaScript, les nombres sont représentés en format à double précision selon la norme IEEE 754 et on ne peut représenter correctement que les nombres compris entre -(2^53-1) et 2^53 -1. Voir {{jsxref("Number.isSafeInteger()")}} pour plus d'informations.

- -

MIN_SAFE_INTEGER étant une méthode statique de {{jsxref("Number")}}, il faut utiliser Number.MIN_SAFE_INTEGER()et non pas la méthode d'un objet Number qui aurait été instancié.

- -

Exemples

- -
Number.MIN_SAFE_INTEGER // -9007199254740991
+```js
+Number.MIN_SAFE_INTEGER // -9007199254740991
 -Math.pow(2, 53) -1     // -9007199254740991
-
+``` -

Spécifications

+## Spécifications - - - - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('ES2015', '#sec-number.min_safe_integer', 'Number.MIN_SAFE_INTEGER')}}{{Spec2('ES2015')}}Définition initiale.
{{SpecName('ESDraft', '#sec-number.min_safe_integer', 'Number.MIN_SAFE_INTEGER')}}{{Spec2('ESDraft')}}
+| Spécification | État | Commentaires | +| ------------------------------------------------------------------------------------------------------------ | ---------------------------- | -------------------- | +| {{SpecName('ES2015', '#sec-number.min_safe_integer', 'Number.MIN_SAFE_INTEGER')}} | {{Spec2('ES2015')}} | Définition initiale. | +| {{SpecName('ESDraft', '#sec-number.min_safe_integer', 'Number.MIN_SAFE_INTEGER')}} | {{Spec2('ESDraft')}} | | -

Compatibilité des navigateurs

+## Compatibilité des navigateurs -

{{Compat("javascript.builtins.Number.MIN_SAFE_INTEGER")}}

+{{Compat("javascript.builtins.Number.MIN_SAFE_INTEGER")}} -

Voir aussi

+## Voir aussi - +- {{jsxref("Number.MAX_SAFE_INTEGER")}} +- {{jsxref("Number.isSafeInteger()")}} +- {{jsxref("BigInt")}} 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 257b17dc9e..6862f18313 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 @@ -9,74 +9,45 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Number/MIN_VALUE original_slug: Web/JavaScript/Reference/Objets_globaux/Number/MIN_VALUE --- -
{{JSRef}}
+{{JSRef}} -

La propriété Number.MIN_VALUE représente la plus petite valeur numérique positive qu'il est possible de représenter en JavaScript.

+La propriété **`Number.MIN_VALUE`** représente la plus petite valeur numérique positive qu'il est possible de représenter en JavaScript. -
{{EmbedInteractiveExample("pages/js/number-min-value.html")}}
+{{EmbedInteractiveExample("pages/js/number-min-value.html")}}{{js_property_attributes(0,0,0)}} +## Description +La propriété `MIN_VALUE` représente le nombre positif le plus proche de 0 et non pas le nombre négatif minimal qu'il est possible de représenter en JavaScript. -
{{js_property_attributes(0,0,0)}}
+`MIN_VALUE` vaut environ 5e-324. Les valeurs inférieures à `MIN_VALUE` sont converties en 0. -

Description

+`MIN_VALUE` est une propriété statique de {{jsxref("Number")}} et doit donc être utilisée avec la syntaxe `Number.MIN_VALUE`, et non pas via la propriété d'un objet `Number` qui aurait été instancié. -

La propriété MIN_VALUE représente le nombre positif le plus proche de 0 et non pas le nombre négatif minimal qu'il est possible de représenter en JavaScript.

+## Exemples -

MIN_VALUE vaut environ 5e-324. Les valeurs inférieures à MIN_VALUE sont converties en 0.

+Le code qui suit effectue la division de deux nombres. Si le résultat obtenu est supérieur ou égal à `MIN_VALUE`, la fonction `func1` sera appelée, sinon la fonction `func2` sera utilisée. -

MIN_VALUE est une propriété statique de {{jsxref("Number")}} et doit donc être utilisée avec la syntaxe Number.MIN_VALUE, et non pas via la propriété d'un objet Number qui aurait été instancié.

- -

Exemples

- -

Le code qui suit effectue la division de deux nombres. Si le résultat obtenu est supérieur ou égal à MIN_VALUE, la fonction func1 sera appelée, sinon la fonction func2 sera utilisée.

- -
if (num1 / num2 >= Number.MIN_VALUE) {
+```js
+if (num1 / num2 >= Number.MIN_VALUE) {
     func1();
 } else {
     func2();
-}
+} +``` -

Spécifications

+## Spécifications - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('ES1')}}{{Spec2('ES1')}}Définition initiale. Implémentée avec JavaScript 1.1
{{SpecName('ES5.1', '#sec-15.7.3.3', 'Number.MIN_VALUE')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-number.min_value', 'Number.MIN_VALUE')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-number.min_value', 'Number.MIN_VALUE')}}{{Spec2('ESDraft')}} 
+| Spécification | État | Commentaires | +| -------------------------------------------------------------------------------------------- | ---------------------------- | ---------------------------------------------------- | +| {{SpecName('ES1')}} | {{Spec2('ES1')}} | Définition initiale. Implémentée avec JavaScript 1.1 | +| {{SpecName('ES5.1', '#sec-15.7.3.3', 'Number.MIN_VALUE')}} | {{Spec2('ES5.1')}} |   | +| {{SpecName('ES6', '#sec-number.min_value', 'Number.MIN_VALUE')}} | {{Spec2('ES6')}} |   | +| {{SpecName('ESDraft', '#sec-number.min_value', 'Number.MIN_VALUE')}} | {{Spec2('ESDraft')}} |   | -

Compatibilité des navigateurs

+## Compatibilité des navigateurs -

{{Compat("javascript.builtins.Number.MIN_VALUE")}}

+{{Compat("javascript.builtins.Number.MIN_VALUE")}} -

Voir aussi

+## Voir aussi - +- {{jsxref("Number.MAX_VALUE")}} 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 4f16fd16ae..edd02e3b02 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 @@ -9,55 +9,30 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Number/NaN original_slug: Web/JavaScript/Reference/Objets_globaux/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")}}.

- -
{{EmbedInteractiveExample("pages/js/number-nan.html")}}
- -

Il n'est pas nécessaire de créer un objet {{jsxref("Number")}} pour accéder à cette propriété statique. Il suffit d'utiliser directement Number.NaN.

- -

{{js_property_attributes(0,0,0)}}

- -

Spécifications

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('ES1')}}{{Spec2('ES1')}}Définition initiale. Implémentée avec JavaScript 1.1.
{{SpecName('ES5.1', '#sec-15.7.3.4', 'Number.NaN')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-number.nan', 'Number.NaN')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-number.nan', 'Number.NaN')}}{{Spec2('ESDraft')}} 
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.Number.NaN")}}

- -

Voir aussi

- - +{{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")}}. + +{{EmbedInteractiveExample("pages/js/number-nan.html")}} + +Il n'est pas nécessaire de créer un objet {{jsxref("Number")}} pour accéder à cette propriété statique. Il suffit d'utiliser directement `Number.NaN`. + +{{js_property_attributes(0,0,0)}} + +## Spécifications + +| Spécification | État | Commentaires | +| ---------------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- | +| {{SpecName('ES1')}} | {{Spec2('ES1')}} | Définition initiale. Implémentée avec JavaScript 1.1. | +| {{SpecName('ES5.1', '#sec-15.7.3.4', 'Number.NaN')}} | {{Spec2('ES5.1')}} |   | +| {{SpecName('ES6', '#sec-number.nan', 'Number.NaN')}} | {{Spec2('ES6')}} |   | +| {{SpecName('ESDraft', '#sec-number.nan', 'Number.NaN')}} | {{Spec2('ESDraft')}} |   | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Number.NaN")}} + +## Voir aussi + +- L'objet global {{jsxref("NaN")}} ; +- L'objet {{jsxref("Number")}} auquel appartient cette propriété. 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 634c779d96..0bd45fa9ba 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 @@ -9,90 +9,60 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Number/NEGATIVE_INFINITY original_slug: Web/JavaScript/Reference/Objets_globaux/Number/NEGATIVE_INFINITY --- -
{{JSRef}}
+{{JSRef}} -

La propriété Number.NEGATIVE_INFINITY représente l'infini négatif.

+La propriété **`Number.NEGATIVE_INFINITY`** représente l'infini négatif. -
{{EmbedInteractiveExample("pages/js/number-negative-infinity.html")}}
+{{EmbedInteractiveExample("pages/js/number-negative-infinity.html")}}{{js_property_attributes(0,0,0)}} +## Description +La valeur de `Number.NEGATIVE_INFINITY` est égale à l'opposé de la valeur fournie par la propriété {{jsxref("Infinity")}} de l'objet global. -
{{js_property_attributes(0,0,0)}}
+Cette valeur se comporte différemment de l'infini mathématique : -

Description

+- Toute valeur positive, y compris {{jsxref("Number.POSITIVE_INFINITY", "POSITIVE_INFINITY")}}, multipliée par `NEGATIVE_INFINITY` sera égale à `NEGATIVE_INFINITY`. +- Toute valeur négative, y compris `NEGATIVE_INFINITY`, multipliée par `NEGATIVE_INFINITY` sera égale à `POSITIVE_INFINITY`. +- Zéro multiplié par `NEGATIVE_INFINITY` sera égal à {{jsxref("NaN")}}. +- NaN multiplié par `NEGATIVE_INFINITY` sera égal à `NaN`. +- `NEGATIVE_INFINITY`, divisé par n'importe quelle valeur négative, à l'exception de  `NEGATIVE_INFINITY`, sera égal à `POSITIVE_INFINITY`. +- `NEGATIVE_INFINITY`, divisé par n'importe quelle valeur positive à l'exception de  `POSITIVE_INFINITY`, sera égal à `NEGATIVE_INFINITY`. +- `NEGATIVE_INFINITY`, divisé par `NEGATIVE_INFINITY` ou `POSITIVE_INFINITY`, sera égal à `NaN`. +- Tout nombre positif divisé par `NEGATIVE_INFINITY` sera égal au zéro négatif. +- Tout nombre négatif divisé par `NEGATIVE_INFINITY` sera égal au zéro positif. -

La valeur de Number.NEGATIVE_INFINITY est égale à l'opposé de la valeur fournie par la propriété {{jsxref("Infinity")}} de l'objet global.

+La propriété `Number.NEGATIVE_INFINITY` peut être utilisée pour indiquer une erreur sur un test renvoyant normalement un nombre fini. On notera cependant que la méthode {{jsxref("isFinite")}} est plus pertinente dans ce cas. -

Cette valeur se comporte différemment de l'infini mathématique :

+`Number.NEGATIVE_INFINITY` est une propriété statique de {{jsxref("Number")}} et on utilisera directement `Number.NEGATIVE_INFINITY` plutôt que comme une propriété d'un objet (instance) {{jsxref("Number")}}. - +## Exemples -

La propriété Number.NEGATIVE_INFINITY peut être utilisée pour indiquer une erreur sur un test renvoyant normalement un nombre fini. On notera cependant que la méthode {{jsxref("isFinite")}} est plus pertinente dans ce cas.

+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é. -

Number.NEGATIVE_INFINITY est une propriété statique de {{jsxref("Number")}} et on utilisera directement Number.NEGATIVE_INFINITY plutôt que comme une propriété d'un objet (instance) {{jsxref("Number")}}.

- -

Exemples

- -

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é.

- -
var petitNombre = (-Number.MAX_VALUE) * 2
+```js
+var petitNombre = (-Number.MAX_VALUE) * 2
 
 if (petitNombre === Number.NEGATIVE_INFINITY) {
  petitNombre = renvoyerUneValeurFinie();
 }
-
- -

Spécifications

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('ES1')}}{{Spec2('ES1')}}Définition initiale. Implémentée avec JavaScript 1.1.
{{SpecName('ES5.1', '#sec-15.7.3.5', 'Number.NEGATIVE_INFINITY')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-number.negative_infinity', 'Number.NEGATIVE_INFINITY')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-number.negative_infinity', 'Number.NEGATIVE_INFINITY')}}{{Spec2('ESDraft')}} 
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.Number.NEGATIVE_INFINITY")}}

- -

Voir aussi

- - +``` + +## Spécifications + +| Spécification | État | Commentaires | +| ---------------------------------------------------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- | +| {{SpecName('ES1')}} | {{Spec2('ES1')}} | Définition initiale. Implémentée avec JavaScript 1.1. | +| {{SpecName('ES5.1', '#sec-15.7.3.5', 'Number.NEGATIVE_INFINITY')}} | {{Spec2('ES5.1')}} |   | +| {{SpecName('ES6', '#sec-number.negative_infinity', 'Number.NEGATIVE_INFINITY')}} | {{Spec2('ES6')}} |   | +| {{SpecName('ESDraft', '#sec-number.negative_infinity', 'Number.NEGATIVE_INFINITY')}} | {{Spec2('ESDraft')}} |   | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Number.NEGATIVE_INFINITY")}} + +## Voir aussi + +- {{jsxref("Number.POSITIVE_INFINITY")}} +- {{jsxref("Number.isFinite()")}} +- {{jsxref("Infinity", "Infinity")}} +- {{jsxref("isFinite", "isFinite()")}} 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 e0c630af48..c0b1031793 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 @@ -10,72 +10,53 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Number/parseFloat original_slug: Web/JavaScript/Reference/Objets_globaux/Number/parseFloat --- -
{{JSRef}}
+{{JSRef}} -

La méthode Number.parseFloat() analyse et convertit une chaîne de caractères en un nombre flottant. Cette méthode possède un comportement identique à {{jsxref("parseFloat")}} et fait partie d'ECMAScript 2015 (dans le but de « modulariser » les méthodes globales).

+La méthode **`Number.parseFloat()`** analyse et convertit une chaîne de caractères en un nombre flottant. Cette méthode possède un comportement identique à {{jsxref("parseFloat")}} et fait partie d'ECMAScript 2015 (dans le but de « modulariser » les méthodes globales). -
{{EmbedInteractiveExample("pages/js/number-parsefloat.html")}}
+{{EmbedInteractiveExample("pages/js/number-parsefloat.html")}} -

Syntaxe

+## Syntaxe -
Number.parseFloat(chaîne)
+ Number.parseFloat(chaîne) -

Paramètres

+### Paramètres -
-
chaîne
-
Une chaîne de caractères qu'on souhaite convertir en nombre flottant.
-
+- `chaîne` + - : Une chaîne de caractères qu'on souhaite convertir en nombre flottant. -

Valeur de retour

+### Valeur de retour -

Un nombre flottant obtenu à partir de l'analyse de la chaîne de caractères passée en argument. Si le premier caractère de la chaîne ne peut pas être converti en un nombre, la  valeur {{jsxref("NaN")}} sera renvoyée.

+Un nombre flottant obtenu à partir de l'analyse de la chaîne de caractères passée en argument. Si le premier caractère de la chaîne ne peut pas être converti en un nombre, la  valeur {{jsxref("NaN")}} sera renvoyée. -

Description

+## Description -

Cette méthode possède les mêmes fonctionnalités que la fonction globale {{jsxref("parseFloat", "parseFloat()")}} :

+Cette méthode possède les mêmes fonctionnalités que la fonction globale {{jsxref("parseFloat", "parseFloat()")}} : -
Number.parseFloat === parseFloat; // true
-
+ Number.parseFloat === parseFloat; // true -

Cette méthode fait partie d'ECMAScript 2015 et notamment de la modularisation de certaines fonctions globales. Pour plus de détails et d'exemples, voir {{jsxref("parseFloat", "parseFloat()")}}.

+Cette méthode fait partie d'ECMAScript 2015 et notamment de la modularisation de certaines fonctions globales. Pour plus de détails et d'exemples, voir {{jsxref("parseFloat", "parseFloat()")}}. -

Prothèse d'émulation (polyfill)

+## Prothèse d'émulation (_polyfill_) -
if (Number.parseFloat === undefined) {
+```js
+if (Number.parseFloat === undefined) {
     Number.parseFloat = parseFloat;
 }
-
- -

Spécifications

- - - - - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('ES2015', '#sec-number.parsefloat', 'Number.parseFloat')}}{{Spec2('ES2015')}}Définition initiale.
{{SpecName('ESDraft', '#sec-number.parsefloat', 'Number.parseFloat')}}{{Spec2('ESDraft')}} 
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.Number.parseFloat")}}

- -

Voir aussi

- - +``` + +## Spécifications + +| Spécification | État | Commentaires | +| -------------------------------------------------------------------------------------------- | ---------------------------- | -------------------- | +| {{SpecName('ES2015', '#sec-number.parsefloat', 'Number.parseFloat')}} | {{Spec2('ES2015')}} | Définition initiale. | +| {{SpecName('ESDraft', '#sec-number.parsefloat', 'Number.parseFloat')}} | {{Spec2('ESDraft')}} |   | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Number.parseFloat")}} + +## Voir aussi + +- L'objet {{jsxref("Number")}} auquel appartient cette fonction. +- La méthode globale {{jsxref("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 780ba5b85e..e77f8baff6 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 @@ -10,72 +10,57 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Number/parseInt original_slug: Web/JavaScript/Reference/Objets_globaux/Number/parseInt --- -
{{JSRef}}
+{{JSRef}} -

La méthode Number.parseInt() analyse et convertit une chaine de caractères, fournie en argument, en un entier dans la base souhaitée.

+La méthode **`Number.parseInt()`** analyse et convertit une chaine de caractères, fournie en argument, en un entier dans la base souhaitée. -
{{EmbedInteractiveExample("pages/js/number-parseint.html")}}
+{{EmbedInteractiveExample("pages/js/number-parseint.html")}} -

Syntaxe

+## Syntaxe -
Number.parseInt(chaîne [, base])
+ Number.parseInt(chaîne [, base]) -

Paramètres

+### Paramètres -
-
chaîne
-
La valeur à convertir. Si chaine n'est pas une chaîne de caractères, elle sera convertie auparavant. Les blancs qui préfixent la chaîne sont ignorés.
-
base {{optional_inline}}
-
Paramètre optionnel. Un entier représentant la base dans laquelle est représentée la valeur de la chaîne. Il faut toujours spécifier ce paramètre. Cela permet que le code ne soit pas ambigü et permet de garantir un comportement prévisible. En effet les différentes implémentations peuvent fournir des résultats différents lorsque la base n'est pas spécifiée.
-
+- `chaîne` + - : La valeur à convertir. Si `chaine` n'est pas une chaîne de caractères, elle sera convertie auparavant. Les blancs qui préfixent la chaîne sont ignorés. +- `base` {{optional_inline}} + - : Paramètre optionnel. Un entier représentant la base dans laquelle est représentée la valeur de la chaîne. **Il faut toujours spécifier ce paramètre.** Cela permet que le code ne soit pas ambigü et permet de garantir un comportement prévisible. En effet les différentes implémentations peuvent fournir des résultats différents lorsque la base n'est pas spécifiée. -

Valeur de retour

+### Valeur de retour -

Un entier construit à partir de l'analyse de la chaîne de caractères passée en argument. Si le premier caractère ne permet pas de conversion numérique, c'est la valeur {{jsxref("NaN")}} qui sera renvoyée.

+Un entier construit à partir de l'analyse de la chaîne de caractères passée en argument. Si le premier caractère ne permet pas de conversion numérique, c'est la valeur {{jsxref("NaN")}} qui sera renvoyée. -

Description

+## Description -

Voir la page {{jsxref("Objets_globaux/parseInt", "parseInt()")}} pour plus de détails et d'exemples. Cette méthode se comporte de façon identique à la fonction globale {{jsxref("Objets_globaux/parseInt", "parseInt()")}} et fait partie d'ECMAScript 2015 (dans le but de « modulariser » les méthodes globales) et on aura :

+Voir la page {{jsxref("Objets_globaux/parseInt", "parseInt()")}} pour plus de détails et d'exemples. Cette méthode se comporte de façon identique à la fonction globale {{jsxref("Objets_globaux/parseInt", "parseInt()")}} et fait partie d'ECMAScript 2015 (dans le but de « modulariser » les méthodes globales) et on aura : -
Number.parseInt === parseInt; // true
+```js +Number.parseInt === parseInt; // true +``` -

Prothèse d'émulation (polyfill)

+## Prothèse d'émulation (_polyfill_) -

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 :

+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 : -
if(Number.parseInt === undefined) {
+```js
+if(Number.parseInt === undefined) {
   Number.parseInt = parseInt;
-}
- -

Spécifications

- - - - - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('ES2015', '#sec-number.parseint', 'Number.parseInt')}}{{Spec2('ES2015')}}Définition initiale.
{{SpecName('ESDraft', '#sec-number.parseint', 'Number.parseInt')}}{{Spec2('ESDraft')}} 
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.Number.parseInt")}}

- -

Voir aussi

- - +} +``` + +## Spécifications + +| Spécification | État | Commentaires | +| ---------------------------------------------------------------------------------------- | ---------------------------- | -------------------- | +| {{SpecName('ES2015', '#sec-number.parseint', 'Number.parseInt')}} | {{Spec2('ES2015')}} | Définition initiale. | +| {{SpecName('ESDraft', '#sec-number.parseint', 'Number.parseInt')}} | {{Spec2('ESDraft')}} |   | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Number.parseInt")}} + +## Voir aussi + +- L'objet {{jsxref("Number")}} auquel appartient cette fonction. +- La méthode {{jsxref("Objets_globaux/parseInt","parseInt()")}} de l'objet global. 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 8ee53b1752..066c2ad931 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 @@ -9,91 +9,63 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Number/POSITIVE_INFINITY original_slug: Web/JavaScript/Reference/Objets_globaux/Number/POSITIVE_INFINITY --- -
{{JSRef}}
+{{JSRef}} -

La propriéte Number.POSITIVE_INFINITY représente l'infini (positif).

+La propriéte **`Number.POSITIVE_INFINITY`** représente l'infini (positif). -
{{EmbedInteractiveExample("pages/js/number-positive-infinity.html")}}
+{{EmbedInteractiveExample("pages/js/number-positive-infinity.html")}} +{{js_property_attributes(0,0,0)}} +## Description -

{{js_property_attributes(0,0,0)}}

+La valeur de `Number.POSITIVE_INFINITY` est identique à la valeur de la propriété de l'objet global {{jsxref("Infinity")}}. -

Description

+Cette valeur possède un comportement légèrement différent de l'infini au sens mathématique : -

La valeur de Number.POSITIVE_INFINITY est identique à la valeur de la propriété de l'objet global {{jsxref("Infinity")}}.

+- Tout valeur positive, y compris `POSITIVE_INFINITY,` multipliée par  `POSITIVE_INFINITY` sera égale à `POSITIVE_INFINITY`. +- Toute valeur négative, y compris {{jsxref("Number.NEGATIVE_INFINITY", "NEGATIVE_INFINITY")}}, multipliée par `POSITIVE_INFINITY` sera égale à `NEGATIVE_INFINITY`. +- Zéro multiplié par `POSITIVE_INFINITY` sera égal à {{jsxref("NaN")}}. +- NaN multiplié par `POSITIVE_INFINITY` sera égal à NaN. +- `POSITIVE_INFINITY`, divisé par n'importe quelle valeur négative, à l'exception de `NEGATIVE_INFINITY`, sera égal à `NEGATIVE_INFINITY`. +- `POSITIVE_INFINITY`, divisé par n'importe quelle valeur positive, à l'exception de `POSITIVE_INFINITY`, sera égal à `POSITIVE_INFINITY`. +- `POSITIVE_INFINITY`, divisé par `NEGATIVE_INFINITY` ou `POSITIVE_INFINITY`, sera égal NaN. +- Tout nombre positif divisé par `POSITIVE_INFINITY` sera égal au zéro positif. +- Tout nombre négatif divisé par `POSITIVE_INFINITY` sera égal au zéro négatif. -

Cette valeur possède un comportement légèrement différent de l'infini au sens mathématique :

+Il est possible d'utiliser la propriété `Number.POSITIVE_INFINITY` pour faire un test d'erreur sur une valeur qu'on attendait finie. Cependant, la méthode {{jsxref("isFinite")}} sera plus appropriée dans ce cas. - +`Number.POSITIVE_INFINITY` est une propriété statique de {{jsxref("Number")}} et il n'est donc pas nécessaire de créer un objet {{jsxref("Number")}} afin d'utiliser cette propriété. -

Il est possible d'utiliser la propriété Number.POSITIVE_INFINITY pour faire un test d'erreur sur une valeur qu'on attendait finie. Cependant, la méthode {{jsxref("isFinite")}} sera plus appropriée dans ce cas.

+## Exemple -

Number.POSITIVE_INFINITY est une propriété statique de {{jsxref("Number")}} et il n'est donc pas nécessaire de créer un objet {{jsxref("Number")}} afin d'utiliser cette propriété.

+### Utiliser `POSITIVE_INFINITY` -

Exemple

+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. -

Utiliser POSITIVE_INFINITY

- -

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.

- -
var grosNombre = Number.MAX_VALUE * 2
+```js
+var grosNombre = Number.MAX_VALUE * 2
 if (grosNombre == Number.POSITIVE_INFINITY) {
  grosNombre = renvoyerUnNombreFini();
 }
-
- -

Spécifications

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
SpécificationStatutCommentaires
{{SpecName('ES1')}}{{Spec2('ES1')}}Définition initiale. Implémentée avec JavaScript 1.1.
{{SpecName('ES5.1', '#sec-15.7.3.6', 'Number.POSITIVE_INFINITY')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-number.positive_infinity', 'Number.POSITIVE_INFINITY')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-number.positive_infinity', 'Number.POSITIVE_INFINITY')}}{{Spec2('ESDraft')}} 
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.Number.POSITIVE_INFINITY")}}

- -

Voir aussi

- - +``` + +## Spécifications + +| Spécification | Statut | Commentaires | +| ---------------------------------------------------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- | +| {{SpecName('ES1')}} | {{Spec2('ES1')}} | Définition initiale. Implémentée avec JavaScript 1.1. | +| {{SpecName('ES5.1', '#sec-15.7.3.6', 'Number.POSITIVE_INFINITY')}} | {{Spec2('ES5.1')}} |   | +| {{SpecName('ES6', '#sec-number.positive_infinity', 'Number.POSITIVE_INFINITY')}} | {{Spec2('ES6')}} |   | +| {{SpecName('ESDraft', '#sec-number.positive_infinity', 'Number.POSITIVE_INFINITY')}} | {{Spec2('ESDraft')}} |   | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Number.POSITIVE_INFINITY")}} + +## Voir aussi + +- {{jsxref("Number.NEGATIVE_INFINITY")}} +- {{jsxref("Number.isFinite()")}} +- {{jsxref("Infinity")}} +- {{jsxref("isFinite")}} 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 2b3667b776..eb923a599c 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 @@ -10,97 +10,69 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Number/toExponential original_slug: Web/JavaScript/Reference/Objets_globaux/Number/toExponential --- -
{{JSRef}}
+{{JSRef}} -

La méthode toExponential() renvoie une chaîne de caractères, représentant l'objet Number en notation exponentielle.

+La méthode **`toExponential()`** renvoie une chaîne de caractères, représentant l'objet Number en notation exponentielle. -
{{EmbedInteractiveExample("pages/js/number-toexponential.html")}}
+{{EmbedInteractiveExample("pages/js/number-toexponential.html")}} -

Syntaxe

+## Syntaxe -
numObj.toExponential([nbChiffresDécimaux])
+ numObj.toExponential([nbChiffresDécimaux]) -

Paramètre

+### Paramètre -
-
nbChiffresDécimaux
-
Paramètre optionnel. Un entier donnant le nombre de chiffres qu'on souhaite avoir dans la partie fractionnaire. Le comportement par défaut considèrera autant de chiffres que nécessaire pour représenter le nombre.
-
+- `nbChiffresDécimaux` + - : Paramètre optionnel. Un entier donnant le nombre de chiffres qu'on souhaite avoir dans la partie fractionnaire. Le comportement par défaut considèrera autant de chiffres que nécessaire pour représenter le nombre. -

Valeur de retour

+### Valeur de retour -

Une chaîne représentant l'objet {{jsxref("Number")}} appelant en notation exponentielle avec un chiffre avant la virgule et arrondi à nbChiffresDécimaux après la virgule.

+Une chaîne représentant l'objet {{jsxref("Number")}} appelant en notation exponentielle avec un chiffre avant la virgule et arrondi à `nbChiffresDécimaux` après la virgule. -

Exceptions

+### Exceptions -
-
{{jsxref("RangeError")}}
-
Cette exception est causée si nbChiffresDécimaux est trop petit ou trop grand. Les valeurs comprises, au sens large, entre 0 et 20 ne causeront pas d'exception {{jsxref("RangeError")}}. Les implémentations peuvent également autorisér des valeurs en dehors de ces bornes.
-
{{jsxref("TypeError")}}
-
Si cette méthode est invoquée pour un objet qui n'est pas un objet Number.
-
+- {{jsxref("RangeError")}} + - : Cette exception est causée si `nbChiffresDécimaux` est trop petit ou trop grand. Les valeurs comprises, au sens large, entre 0 et 20 ne causeront pas d'exception {{jsxref("RangeError")}}. Les implémentations peuvent également autorisér des valeurs en dehors de ces bornes. +- {{jsxref("TypeError")}} + - : Si cette méthode est invoquée pour un objet qui n'est pas un objet `Number`. -

Description

+## Description -

La valeur renvoyée est une chaîne de caractères correspondant à la représentation du nombre en notation exponentielle. La partie entière est constituée d'un seul chiffre et la partie fractionnaire est composée de nbChiffresDécimaux chiffres. Si l'argument nbChiffresDécimaux est absent, il y aura autant de chiffres dans la partie fractionnaire que nécessaire pour représenter le nombre de façon unique.

+La valeur renvoyée est une chaîne de caractères correspondant à la représentation du nombre en notation exponentielle. La partie entière est constituée d'un seul chiffre et la partie fractionnaire est composée de `nbChiffresDécimaux` chiffres. Si l'argument `nbChiffresDécimaux `est absent, il y aura autant de chiffres dans la partie fractionnaire que nécessaire pour représenter le nombre de façon unique. -

Si la méthode toExponential() est utilisée avec un littéral numérique et que celui-ci ne possède aucun exposant ou séparateur décimal ("."), il faut laisser un ou plusieurs espaces entre le littéral et le point indiquant l'appel de la méthode. Cela permet d'éviter que le point, permettant d'accéder à la méthode, soit confondu avec un séparateur décimal.

+Si la méthode `toExponential()` est utilisée avec un littéral numérique et que celui-ci ne possède aucun exposant ou séparateur décimal ("."), il faut laisser un ou plusieurs espaces entre le littéral et le point indiquant l'appel de la méthode. Cela permet d'éviter que le point, permettant d'accéder à la méthode, soit confondu avec un séparateur décimal. -

Si un nombre possède plus de chiffres décimaux que nbChiffresDécimaux, le nombre est arrondi au nombre le plus proche, représenté avec nbChiffresDécimaux pour la partie fractionnaire. Voir la discussion sur les arrondis dans la page  de la méthode {{jsxref("Number.toFixed", "toFixed()")}} pour plus de détails, la même méthode est utilisée pour toExponential().

+Si un nombre possède plus de chiffres décimaux que `nbChiffresDécimaux`, le nombre est arrondi au nombre le plus proche, représenté avec `nbChiffresDécimaux` pour la partie fractionnaire. Voir la discussion sur les arrondis dans la page  de la méthode {{jsxref("Number.toFixed", "toFixed()")}} pour plus de détails, la même méthode est utilisée pour `toExponential()`. -

Exemples

+## Exemples -

Utiliser toExponential

+### Utiliser `toExponential` -
var numObj = 77.1234;
+```js
+var numObj = 77.1234;
 
 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
-
- -

Spécifications

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('ES3')}}{{Spec2('ES3')}}Définition initiale. Implémentée avec JavaScript 1.5.
{{SpecName('ES5.1', '#sec-15.7.4.6', 'Number.prototype.toExponential')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-number.prototype.toexponential', 'Number.prototype.toExponential')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-number.prototype.toexponential', 'Number.prototype.toExponential')}}{{Spec2('ESDraft')}} 
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.Number.toExponential")}}

- -

Voir aussi

- - +``` + +## Spécifications + +| Spécification | État | Commentaires | +| -------------------------------------------------------------------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- | +| {{SpecName('ES3')}} | {{Spec2('ES3')}} | Définition initiale. Implémentée avec JavaScript 1.5. | +| {{SpecName('ES5.1', '#sec-15.7.4.6', 'Number.prototype.toExponential')}} | {{Spec2('ES5.1')}} |   | +| {{SpecName('ES6', '#sec-number.prototype.toexponential', 'Number.prototype.toExponential')}} | {{Spec2('ES6')}} |   | +| {{SpecName('ESDraft', '#sec-number.prototype.toexponential', 'Number.prototype.toExponential')}} | {{Spec2('ESDraft')}} |   | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Number.toExponential")}} + +## Voir aussi + +- {{jsxref("Number.prototype.toFixed()")}} +- {{jsxref("Number.prototype.toPrecision()")}} +- {{jsxref("Number.prototype.toString()")}} 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 04f3a49458..356025f244 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 @@ -10,47 +10,42 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Number/toFixed original_slug: Web/JavaScript/Reference/Objets_globaux/Number/toFixed --- -
{{JSRef}}
+{{JSRef}} -

La méthode toFixed() permet de formater un nombre en notation à point-fixe.

+La méthode **`toFixed()`** permet de formater un nombre en notation à point-fixe. -
{{EmbedInteractiveExample("pages/js/number-tofixed.html")}}
+{{EmbedInteractiveExample("pages/js/number-tofixed.html")}} -

Syntaxe

+## Syntaxe -
numObj.toFixed([nbChiffres])
+ numObj.toFixed([nbChiffres]) -

Paramètres

+### Paramètres -
-
nbChiffres {{optional_inline}}
-
Le nombre de chiffres qu'on souhaite avoir après le séparateur décimal. Cette valeur peut être comprise, au sens large, entre 0 et 20. Les différentes implémentations peuvent éventuellement supporter des valeurs en dehors de cet intervalle. Si l'argument n'est pas utilisé, la valeur par défaut sera 0.
-
+- `nbChiffres` {{optional_inline}} + - : Le nombre de chiffres qu'on souhaite avoir après le séparateur décimal. Cette valeur peut être comprise, au sens large, entre 0 et 20. Les différentes implémentations peuvent éventuellement supporter des valeurs en dehors de cet intervalle. Si l'argument n'est pas utilisé, la valeur par défaut sera 0. -

Valeur de retour

+### Valeur de retour -

Une chaîne de caractères qui représente le nombre indiqué avec une notation à point fixe.

+Une chaîne de caractères qui représente le nombre indiqué avec une notation à point fixe. -

Exceptions causées

+### Exceptions causées -
-
{{jsxref("RangeError")}}
-
Cette exception est renvoyée si nbChiffres est trop grand ou trop petit. Les valeurs comprises, au sens large, entre 0 et 100, n'entraîneront pas de RangeError. Les différentes implémentations peuvent ou non supporter des valeurs plus petites et/ou plus grandes.
-
{{jsxref("TypeError")}}
-
Cette exception est renvoyée si cette méthode est invoquée depuis un objet qui n'est pas de type numérique.
-
+- {{jsxref("RangeError")}} + - : Cette exception est renvoyée si `nbChiffres` est trop grand ou trop petit. Les valeurs comprises, au sens large, entre 0 et 100, n'entraîneront pas de `RangeError`. Les différentes implémentations peuvent ou non supporter des valeurs plus petites et/ou plus grandes. +- {{jsxref("TypeError")}} + - : Cette exception est renvoyée si cette méthode est invoquée depuis un objet qui n'est pas de type numérique. -

Description

+## Description -

toFixed() renvoie une chaîne de caractères représentant objetNumber sans notation exponentielle et qui possède exactement nbChiffres pour la partie fractionnaire. Le nombre est arrondi si nécessaire et la partie fractionnaire est complétée par des zéros si nécessaire pour obtenir la longueur souhaitée. Si le objetNumber est supérieur ou égal à 1e+21, la méthode utilise simplement {{jsxref("Number.prototype.toString()")}} et renvoie une chaîne en notation exponentielle.

+`toFixed()` renvoie une chaîne de caractères représentant `objetNumber` sans notation exponentielle et qui possède exactement `nbChiffres` pour la partie fractionnaire. Le nombre est arrondi si nécessaire et la partie fractionnaire est complétée par des zéros si nécessaire pour obtenir la longueur souhaitée. Si le `objetNumber` est supérieur ou égal à `1e+21`, la méthode utilise simplement {{jsxref("Number.prototype.toString()")}} et renvoie une chaîne en notation exponentielle. -
-

Attention : En raison du standard IEEE 754 qui est utilisé par JavaScript pour représenter les nombres, tous les nombres décimaux ne sont pas représentés exactement en JavaScript, ce qui peut mener à des résultats inattendus (comme 0.1 + 0.2 === 0.3 qui renvoie false).

-
+> **Attention :** En raison du standard [IEEE 754](https://fr.wikipedia.org/wiki/IEEE_754) qui est utilisé par JavaScript pour représenter les nombres, tous les nombres décimaux ne sont pas représentés exactement en JavaScript, ce qui peut mener à des résultats inattendus (comme `0.1 + 0.2 === 0.3` qui renvoie `false`). -

Exemples

+## Exemples -
var numObj = 12345.6789;
+```js
+var numObj = 12345.6789;
 
 numObj.toFixed();       // Renvoie '12346' : arrondi, aucune partie fractionnaire
 numObj.toFixed(1);      // Renvoie '12345.7' : arrondi ici aussi
@@ -63,48 +58,23 @@ numObj.toFixed(6);      // Renvoie '12345.678900' : des zéros sont ajoutés
 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

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('ES3')}}{{Spec2('ES3')}}Définition initiale. Implémentée avec JavaScript 1.5.
{{SpecName('ES5.1', '#sec-15.7.4.5', 'Number.prototype.toFixed')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-number.prototype.tofixed', 'Number.prototype.toFixed')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-number.prototype.tofixed', 'Number.prototype.toFixed')}}{{Spec2('ESDraft')}} 
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.Number.toFixed")}}

- -

Voir aussi

- - +``` + +## Spécifications + +| Spécification | État | Commentaires | +| ---------------------------------------------------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- | +| {{SpecName('ES3')}} | {{Spec2('ES3')}} | Définition initiale. Implémentée avec JavaScript 1.5. | +| {{SpecName('ES5.1', '#sec-15.7.4.5', 'Number.prototype.toFixed')}} | {{Spec2('ES5.1')}} |   | +| {{SpecName('ES6', '#sec-number.prototype.tofixed', 'Number.prototype.toFixed')}} | {{Spec2('ES6')}} |   | +| {{SpecName('ESDraft', '#sec-number.prototype.tofixed', 'Number.prototype.toFixed')}} | {{Spec2('ESDraft')}} |   | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Number.toFixed")}} + +## Voir aussi + +- {{jsxref("Number.prototype.toExponential()")}} +- {{jsxref("Number.prototype.toPrecision()")}} +- {{jsxref("Number.prototype.toString()")}} 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 af7692098a..9ff73fe256 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 @@ -12,50 +12,48 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Number/toLocaleString original_slug: Web/JavaScript/Reference/Objets_globaux/Number/toLocaleString --- -
{{JSRef}}
+{{JSRef}} -

La méthode toLocaleString() permet de renvoyer une chaîne de caractères représentant un nombre en tenant compte de la locale.

+La méthode **`toLocaleString()`** permet de renvoyer une chaîne de caractères représentant un nombre en tenant compte de la locale. -
{{EmbedInteractiveExample("pages/js/number-tolocalestring.html")}}
+{{EmbedInteractiveExample("pages/js/number-tolocalestring.html")}} +Les arguments `locales` et `options` permettent à l'application de spécifier les options de formatage selon la langue utilisée. Ces arguments ont un effet sur le comportement de la fonction. Les implémentations passées, qui ignoraient les arguments `locales` et `options` se basaient uniquement sur l'implémentation pour ce qui concernait la locale et le format. +## Syntaxe -

Les arguments locales et options permettent à l'application de spécifier les options de formatage selon la langue utilisée. Ces arguments ont un effet sur le comportement de la fonction. Les implémentations passées, qui ignoraient les arguments locales et options se basaient uniquement sur l'implémentation pour ce qui concernait la locale et le format.

+ objetNumber.toLocaleString([locales [, options]]) -

Syntaxe

+### Paramètres -
objetNumber.toLocaleString([locales [, options]])
+Voir la section [compatibilité des navigateurs](#compat "#Browser_Compatibility") afin de voir quels navigateurs supportent les arguments `locales` et `options`. L'exemple [Vérifier le support des arguments `locales` et `options`](#check) permet de détecter cette fonctionnalité. -

Paramètres

+> **Note :** L'API ECMAScript Internationalization, implémentée avec Firefox 29, a ajouté l'argument `locales` à la méthode [`Number.toLocaleString`](/fr/docs/Web/JavaScript/Reference/Objets_globaux/Number/toLocaleString). Si l'argument vaut `undefined`,cette méthode renvoie les nombres selon la locale du système d'exploitation, les versions antérieures de Firefox renvoyaient un résultat correspondant à la locale anglaise. Ce changement a été rapporté comme une régression, avec un risque de manque de rétrocompatibilité, avant d'être corrigé avec Firefox 55, voir le bug ({{bug(999003)}}). -

Voir la section compatibilité des navigateurs afin de voir quels navigateurs supportent les arguments locales et options. L'exemple Vérifier le support des arguments locales et options permet de détecter cette fonctionnalité.

+{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/NumberFormat','Paramètres')}} -
-

Note : L'API ECMAScript Internationalization, implémentée avec Firefox 29, a ajouté l'argument locales à la méthode Number.toLocaleString. Si l'argument vaut undefined,cette méthode renvoie les nombres selon la locale du système d'exploitation, les versions antérieures de Firefox renvoyaient un résultat correspondant à la locale anglaise. Ce changement a été rapporté comme une régression, avec un risque de manque de rétrocompatibilité, avant d'être corrigé avec Firefox 55, voir le bug ({{bug(999003)}}).

-
+### Valeur de retour -

{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/NumberFormat','Paramètres')}}

+Une chaîne de caractères qui représente le nombre indiqué en tenant compte de la locale. -

Valeur de retour

+## Exemples -

Une chaîne de caractères qui représente le nombre indiqué en tenant compte de la locale.

+### Utiliser `toLocaleString()` -

Exemples

+En utilisant la fonction simplement, sans spécifier de locale, la chaîne est formatée dans la locale par défaut et avec des options par défaut. -

Utiliser toLocaleString()

- -

En utilisant la fonction simplement, sans spécifier de locale, la chaîne est formatée dans la locale par défaut et avec des options par défaut.

- -
var nombre = 3500;
+```js
+var nombre = 3500;
 
 console.log(nombre.toLocaleString()); // Affichera "3 500" pour la locale française
-
+``` -

Vérifier le support des arguments locales et options

+### Vérifier le support des arguments `locales` et `options` -

Les arguments locales et options ne sont pas supportés par tous les navigateurs. Afin de vérifier qu'une implémentation les prend en charge, on se base sur le fait que les balises de langues incorrectes renvoient une exception{{jsxref("RangeError")}} :

+Les arguments `locales` et `options` ne sont pas supportés par tous les navigateurs. Afin de vérifier qu'une implémentation les prend en charge, on se base sur le fait que les balises de langues incorrectes renvoient une exception{{jsxref("RangeError")}} : -
function testSupporttoLocaleString() {
+```js
+function testSupporttoLocaleString() {
     var nombre = 0;
     try {
         nombre.toLocaleString("i");
@@ -64,24 +62,26 @@ console.log(nombre.toLocaleString()); // Affichera "3 500" pour la locale franç
     }
     return false;
 }
-
+``` -

Avant ES5.1, il n'était pas nécessaire pour les implémentations de provoquer une erreur d'intervalle si toLocaleString était appelé avec des arguments.

+Avant ES5.1, il n'était pas nécessaire pour les implémentations de provoquer une erreur d'intervalle si `toLocaleString` était appelé avec des arguments. -

Afin de vérifier le support pour tous les environnements, y compris ceux qui supportent ECMA-262 avant la version 5.1, on peut tester les fonctionnalités définies dans ECMA-402, directement sur Number.prototype.toLocaleString :

+Afin de vérifier le support pour tous les environnements, y compris ceux qui supportent ECMA-262 avant la version 5.1, on peut tester les fonctionnalités définies dans ECMA-402, directement sur `Number.prototype.toLocaleString` : -
function toLocaleStringSupportsOptions() {
-  return !!(typeof Intl == 'object' && Intl && typeof Intl.NumberFormat == 'function');
+```js
+function toLocaleStringSupportsOptions() {
+  return !!(typeof Intl == 'object' && Intl && typeof Intl.NumberFormat == 'function');
 }
-
+``` -

Cela permet de tester la présence d'un objet global Intl, de vérifier que celui-ci n'est pas null et qu'il a une méthode NumberFormat.

+Cela permet de tester la présence d'un objet global `Intl`, de vérifier que celui-ci n'est pas `null` et qu'il a une méthode `NumberFormat`. -

Utiliser l'argument locales

+### Utiliser l'argument `locales` -

Cet exemple illustre les variations possibles entre les différents formats localisés. Afin que le format de langue utilisé soit celui de votre utilisateur, assurez-vous de fournir la langue utilisée (ainsi que des langues de secours) en utilisant l'argument locales :

+Cet exemple illustre les variations possibles entre les différents formats localisés. Afin que le format de langue utilisé soit celui de votre utilisateur, assurez-vous de fournir la langue utilisée (ainsi que des langues de secours) en utilisant l'argument `locales` : -
var nombre= 123456.789;
+```js
+var nombre= 123456.789;
 
 // Pour la locale allemande, on utilise un point comme séparateur
 // pour les milliers et une virgule comme séparateur décimal
@@ -105,13 +105,14 @@ console.log(nombre.toLocaleString("zh-Hans-CN-u-nu-hanidec"));
 // inclure un langage de secours. Exemple ici avec le balinais et l'indonésien
 console.log(nombre.toLocaleString(["ban", "id"]));
 // → 123.456,789
-
+``` -

Utiliser l'argument options

+### Utiliser l'argument `options` -

Les résultats fournis par toLocaleString peuvent être déclinés en utilisant l'argument options :

+Les résultats fournis par `toLocaleString` peuvent être déclinés en utilisant l'argument `options` : -
var nombre = 123456.789;
+```js
+var nombre = 123456.789;
 
 // on formate selon une devise
 console.log(nombre.toLocaleString("de-DE", {style: "currency", currency: "EUR"}));
@@ -132,65 +133,28 @@ console.log(num.toLocaleString(undefined, {minimumFractionDigits: 2, maximumFrac
 // → "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
-
- -

Performance

- -

Lors du formatage de beaucoup de nombres, il est préférable de créer un objet {{jsxref("NumberFormat")}} et d'utiliser sa méthode {{jsxref("NumberFormat.format")}}.

- -

Spécifications

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('ES3')}}{{Spec2('ES3')}}Définition initiale. Implémentée avec JavaScript 1.5.
{{SpecName('ES5.1', '#sec-15.7.4.3', 'Number.prototype.toLocaleString')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-number.prototype.tolocalestring', 'Number.prototype.toLocaleString')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-number.prototype.tolocalestring', 'Number.prototype.toLocaleString')}}{{Spec2('ESDraft')}} 
{{SpecName('ES Int 1.0', '#sec-13.2.1', 'Number.prototype.toLocaleString')}}{{Spec2('ES Int 1.0')}} 
{{SpecName('ES Int 2.0', '#sec-13.2.1', 'Number.prototype.toLocaleString')}}{{Spec2('ES Int 2.0')}} 
{{SpecName('ES Int Draft', '#sec-Number.prototype.toLocaleString', 'Number.prototype.toLocaleString')}}{{Spec2('ES Int Draft')}} 
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.Number.toLocaleString")}}

- -

Voir aussi

- - +``` + +## Performance + +Lors du formatage de beaucoup de nombres, il est préférable de créer un objet {{jsxref("NumberFormat")}} et d'utiliser sa méthode {{jsxref("NumberFormat.format")}}. + +## Spécifications + +| Spécification | État | Commentaires | +| ---------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------- | ----------------------------------------------------- | +| {{SpecName('ES3')}} | {{Spec2('ES3')}} | Définition initiale. Implémentée avec JavaScript 1.5. | +| {{SpecName('ES5.1', '#sec-15.7.4.3', 'Number.prototype.toLocaleString')}} | {{Spec2('ES5.1')}} |   | +| {{SpecName('ES6', '#sec-number.prototype.tolocalestring', 'Number.prototype.toLocaleString')}} | {{Spec2('ES6')}} |   | +| {{SpecName('ESDraft', '#sec-number.prototype.tolocalestring', 'Number.prototype.toLocaleString')}} | {{Spec2('ESDraft')}} |   | +| {{SpecName('ES Int 1.0', '#sec-13.2.1', 'Number.prototype.toLocaleString')}} | {{Spec2('ES Int 1.0')}} |   | +| {{SpecName('ES Int 2.0', '#sec-13.2.1', 'Number.prototype.toLocaleString')}} | {{Spec2('ES Int 2.0')}} |   | +| {{SpecName('ES Int Draft', '#sec-Number.prototype.toLocaleString', 'Number.prototype.toLocaleString')}} | {{Spec2('ES Int Draft')}} |   | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Number.toLocaleString")}} + +## Voir aussi + +- {{jsxref("Number.prototype.toString()")}} 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 3071e0dafc..fc528fd945 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 @@ -10,39 +10,36 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Number/toPrecision original_slug: Web/JavaScript/Reference/Objets_globaux/Number/toPrecision --- -
{{JSRef}}
+{{JSRef}} -

La méthode toPrecision() renvoie une chaîne de caractères représentant un nombre avec la précision donnée.

+La méthode **`toPrecision()`** renvoie une chaîne de caractères représentant un nombre avec la précision donnée. -
{{EmbedInteractiveExample("pages/js/number-toprecision.html")}}
+{{EmbedInteractiveExample("pages/js/number-toprecision.html")}} -

Syntaxe

+## Syntaxe -
numObj.toPrecision([précision])
+ numObj.toPrecision([précision]) -

Paramètre

+### Paramètre -
-
précision
-
Paramètre optionnel. Un entier spécifiant le nombre de chiffres significatifs.
-
+- `précision` + - : Paramètre optionnel. Un entier spécifiant le nombre de chiffres significatifs. -

Valeur de retour

+### Valeur de retour -

Cette méthode renvoie une chaîne de caractères représentant l'objet {{jsxref("Number")}} en notation à point fixe ou en notation exponentielle, arrondi avec un nombre de chiffres significatifs égal à précision. Le principe utilisé pour les arrondis est celui décrit dans la page de la méthode {{jsxref("Number.prototype.toFixed()")}}.

+Cette méthode renvoie une chaîne de caractères représentant l'objet {{jsxref("Number")}} en notation à point fixe ou en notation exponentielle, arrondi avec un nombre de chiffres significatifs égal à `précision`. Le principe utilisé pour les arrondis est celui décrit dans la page de la méthode {{jsxref("Number.prototype.toFixed()")}}. -

Si l'argument précision n'est pas utilisé, la méthode aura le même effet que {{jsxref("Number.prototype.toString()")}}. Si cet argument n'est pas un nombre entier, on prendra le nombre entier le plus proche.

+Si l'argument `précision` n'est pas utilisé, la méthode aura le même effet que {{jsxref("Number.prototype.toString()")}}. Si cet argument n'est pas un nombre entier, on prendra le nombre entier le plus proche. -

Exceptions

+### Exceptions -
-
{{jsxref("RangeError")}}
-
Si précison n'est pas compris, au sens large, entre 1 et 100, on aura une exception RangeError. Les implémentations peuvent supporter des valeurs supérieures et/ou inférieures. Le standard ECMA-262 ne nécessite qu'une précision allant jusqu'à 21 chiffres significatifs.
-
+- {{jsxref("RangeError")}} + - : Si `précison` n'est pas compris, au sens large, entre 1 et 100, on aura une exception `RangeError`. Les implémentations peuvent supporter des valeurs supérieures et/ou inférieures. Le standard ECMA-262 ne nécessite qu'une précision allant jusqu'à 21 chiffres significatifs. -

Exemples

+## Exemples -
var objetNumber = 5.123456;
+```js
+var objetNumber = 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"
@@ -57,48 +54,23 @@ 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"
-
- -

Spécifications

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('ES3')}}{{Spec2('ES3')}}Définition initiale. Implémentée avec JavaScript 1.5.
{{SpecName('ES5.1', '#sec-15.7.4.7', 'Number.prototype.toPrecision')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-number.prototype.toprecision', 'Number.prototype.toPrecision')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-number.prototype.toprecision', 'Number.prototype.toPrecision')}}{{Spec2('ESDraft')}} 
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.Number.toPrecision")}}

- -

Voir aussi

- - +``` + +## Spécifications + +| Spécification | État | Commentaires | +| ---------------------------------------------------------------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- | +| {{SpecName('ES3')}} | {{Spec2('ES3')}} | Définition initiale. Implémentée avec JavaScript 1.5. | +| {{SpecName('ES5.1', '#sec-15.7.4.7', 'Number.prototype.toPrecision')}} | {{Spec2('ES5.1')}} |   | +| {{SpecName('ES6', '#sec-number.prototype.toprecision', 'Number.prototype.toPrecision')}} | {{Spec2('ES6')}} |   | +| {{SpecName('ESDraft', '#sec-number.prototype.toprecision', 'Number.prototype.toPrecision')}} | {{Spec2('ESDraft')}} |   | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Number.toPrecision")}} + +## Voir aussi + +- {{jsxref("Number.prototype.toFixed()")}} +- {{jsxref("Number.prototype.toExponential()")}} +- {{jsxref("Number.prototype.toString()")}} diff --git a/files/fr/web/javascript/reference/global_objects/number/tosource/index.md b/files/fr/web/javascript/reference/global_objects/number/tosource/index.md index 4573bdfacf..abf22f9a15 100644 --- a/files/fr/web/javascript/reference/global_objects/number/tosource/index.md +++ b/files/fr/web/javascript/reference/global_objects/number/tosource/index.md @@ -10,47 +10,43 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Number/toSource original_slug: Web/JavaScript/Reference/Objets_globaux/Number/toSource --- -
{{JSRef}} {{non-standard_header}}
+{{JSRef}} {{non-standard_header}} -

La méthode toSource() permet de renvoyer une chaîne de caractère représentant le code source de l'objet.

+La méthode **`toSource()`** permet de renvoyer une chaîne de caractère représentant le code source de l'objet. -

Syntaxe

+## Syntaxe -
objetNumber.toSource();
-Number.toSource();
-
+ objetNumber.toSource(); + Number.toSource(); -

Valeur de retour

+### Valeur de retour -

Une chaîne de caractères représentant le code source de l'objet.

+Une chaîne de caractères représentant le code source de l'objet. -

Description

+## Description -

La méthode toSource() renvoie les valeurs suivantes :

+La méthode `toSource()` renvoie les valeurs suivantes : - + ```js + function Number() { + [native code] + } + ``` -

Cette méthode est généralement appelée par du code interne au moteur JavaScript et n'est pas utilisée dans des scripts JavaScript.

+- Pour les instances de {{jsxref("Number")}}, `toSource()` renvoie une chaîne représentant le code source de l'objet. -

Spécifications

+Cette méthode est généralement appelée par du code interne au moteur JavaScript et n'est pas utilisée dans des scripts JavaScript. -

Cette méthode ne fait partie d'aucun standard. Elle a été implémentée avec JavaScript 1.3.

+## Spécifications -

Compatibilité des navigateurs

+Cette méthode ne fait partie d'aucun standard. Elle a été implémentée avec JavaScript 1.3. -

{{Compat("javascript.builtins.Number.toSource")}}

+## Compatibilité des navigateurs -

Voir aussi

+{{Compat("javascript.builtins.Number.toSource")}} - +## Voir aussi + +- {{jsxref("Object.prototype.toSource()")}} 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 b7b615f01d..bf6933e12c 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 @@ -10,53 +10,48 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Number/toString original_slug: Web/JavaScript/Reference/Objets_globaux/Number/toString --- -
{{JSRef}}
+{{JSRef}} -

La méthode toString() renvoie une chaîne de caractère représentant l'objet Number.

+La méthode **`toString()`** renvoie une chaîne de caractère représentant l'objet Number. -
{{EmbedInteractiveExample("pages/js/number-tostring.html")}}
+{{EmbedInteractiveExample("pages/js/number-tostring.html")}} -

Syntaxe

+## Syntaxe -
numObj.toString([base])
+ numObj.toString([base]) -

Paramètre

+### Paramètre -
-
base
-
Paramètre optionnel. Un entier compris entre 2 et 36 qui indique la base du système numérique à utiliser pour représenter la valeur.
-
+- `base` + - : Paramètre optionnel. Un entier compris entre 2 et 36 qui indique la base du système numérique à utiliser pour représenter la valeur. -

Valeur de retour

+### Valeur de retour -

Une chaîne de caractères représentant l'objet {{jsxref("Number")}}.

+Une chaîne de caractères représentant l'objet {{jsxref("Number")}}. -

Exception

+### Exception -
-
{{jsxref("RangeError")}}
-
-

Si toString() reçoit une base qui n'est pas comprise entre 2 et 36, une exception RangeError est levée.

-
-
+- {{jsxref("RangeError")}} + - : Si `toString()` reçoit une base qui n'est pas comprise entre 2 et 36, une exception `RangeError` est levée. -

Description

+## Description -

L'objet {{jsxref("Number")}} surcharge la méthode toString() de {{jsxref("Object")}} et n'hérite donc pas de {{jsxref("Object.prototype.toString()")}}. Pour les objets Number, la méthode toString() renvoie une représentation du nombre, dans une base donnée, en une chaîne de caractères.

+L'objet {{jsxref("Number")}} surcharge la méthode `toString()` de {{jsxref("Object")}} et n'hérite donc pas de {{jsxref("Object.prototype.toString()")}}. Pour les objets `Number`, la méthode `toString()` renvoie une représentation du nombre, dans une base donnée, en une chaîne de caractères. -

La méthode toString() analyse son premier argument et tente de renvoyer une chaîne de caractères représentant le nombre en une base donnée. Pour les bases supérieures à 10, les lettres de l'alphabet sont utilisées pour représenter les numéraux supérieurs à 9. Par exemple, pour les nombres hexadécimaux (en base 16), les lettres a à f sont utilisées.

+La méthode `toString()` analyse son premier argument et tente de renvoyer une chaîne de caractères représentant le nombre en une base donnée. Pour les bases supérieures à 10, les lettres de l'alphabet sont utilisées pour représenter les numéraux supérieurs à 9. Par exemple, pour les nombres hexadécimaux (en base 16), les lettres `a` à `f` sont utilisées. -

Si la base n'est pas spécifiée, on utilisera la base 10 par défaut.

+Si la base n'est pas spécifiée, on utilisera la base 10 par défaut. -

Si l'objet Number est négatif, le signe sera conservé. Ceci, même si la base utilisée est la base 2 : la chaîne de caractères rendue sera la représentation binaire du nombre positif précédée par un signe -. La représentation n'est pas le complément à deux du nombre.

+Si l'objet `Number` est négatif, le signe sera conservé. Ceci, même si la base utilisée est la base 2 : la chaîne de caractères rendue sera la représentation binaire du nombre positif précédée par un signe -. La représentation **n'est pas** le complément à deux du nombre. -

Si l'objet Number n'est pas un nombre entier, le point (.) sera utilisé pour séparer la partie entière et décimale.

+Si l'objet `Number` n'est pas un nombre entier, le point (.) sera utilisé pour séparer la partie entière et décimale. -

Exemples

+## Exemples -

Utiliser toString

+### Utiliser `toString` -
var compte = 10;
+```js
+var compte = 10;
 
 console.log(compte.toString());   // affiche "10"
 console.log((17).toString());     // affiche "17"
@@ -70,48 +65,23 @@ console.log((254).toString(16));  // affiche "fe"
 
 console.log((-10).toString(2));   // affiche "-1010"
 console.log((-0xff).toString(2)); // affiche "-11111111"
-
- -

Spécifications

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('ES1')}}{{Spec2('ES1')}}Définition initiale. Implémentée par JavaScript 1.1.
{{SpecName('ES5.1', '#sec-15.7.4.2', 'Number.prototype.tostring')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-number.prototype.tostring', 'Number.prototype.tostring')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-number.prototype.tostring', 'Number.prototype.tostring')}}{{Spec2('ESDraft')}} 
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.Number.toString")}}

- -

Voir aussi

- - +``` + +## Spécifications + +| Spécification | État | Commentaires | +| -------------------------------------------------------------------------------------------------------------------- | ---------------------------- | ---------------------------------------------------- | +| {{SpecName('ES1')}} | {{Spec2('ES1')}} | Définition initiale. Implémentée par JavaScript 1.1. | +| {{SpecName('ES5.1', '#sec-15.7.4.2', 'Number.prototype.tostring')}} | {{Spec2('ES5.1')}} |   | +| {{SpecName('ES6', '#sec-number.prototype.tostring', 'Number.prototype.tostring')}} | {{Spec2('ES6')}} |   | +| {{SpecName('ESDraft', '#sec-number.prototype.tostring', 'Number.prototype.tostring')}} | {{Spec2('ESDraft')}} |   | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Number.toString")}} + +## Voir aussi + +- {{jsxref("Number.prototype.toFixed()")}} +- {{jsxref("Number.prototype.toExponential()")}} +- {{jsxref("Number.prototype.toPrecision()")}} 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 b90f4c4d93..66b710fdce 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 @@ -10,74 +10,50 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Number/valueOf original_slug: Web/JavaScript/Reference/Objets_globaux/Number/valueOf --- -
{{JSRef}}
+{{JSRef}} -

La méthode valueOf() renvoie la valeur primitive correspondant à celle représentée par l'objet {{jsxref("Number")}}.

+La méthode **`valueOf()`** renvoie la valeur primitive correspondant à celle représentée par l'objet {{jsxref("Number")}}. -
{{EmbedInteractiveExample("pages/js/number-valueof.html")}}
+{{EmbedInteractiveExample("pages/js/number-valueof.html")}} -

Syntaxe

+## Syntaxe -
objetNumber.valueOf()
+ objetNumber.valueOf() -

Valeur de retour

+### Valeur de retour -

Un nombre qui représente la valeur primitive de l'objet {{jsxref("Number")}}.

+Un nombre qui représente la valeur primitive de l'objet {{jsxref("Number")}}. -

Description

+## Description -

Cette méthode est généralement utilisée de façon interne au moteur JavaScript et n'est pas utilisée de façon explicite dans du code JavaScript.

+Cette méthode est généralement utilisée de façon interne au moteur JavaScript et n'est pas utilisée de façon explicite dans du code JavaScript. -

Exemples

+## Exemples -

Utiliser valueOf

+### Utiliser `valueOf` -
var numObj = new Number(10);
+```js
+var numObj = new Number(10);
 console.log(typeof numObj); // object
 
 var num = numObj.valueOf();
 console.log(num);           // 10
 console.log(typeof num);    // number
-
- -

Spécifications

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('ES1')}}{{Spec2('ES1')}}Définition initiale. Implémentée avec JavaScript 1.1.
{{SpecName('ES5.1', '#sec-15.7.4.4', 'Number.prototype.valueOf')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-number.prototype.valueof', 'Number.prototype.valueOf')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-number.prototype.valueof', 'Number.prototype.valueOf')}}{{Spec2('ESDraft')}} 
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.Number.valueOf")}}

- -

Voir aussi

- - +``` + +## Spécifications + +| Spécification | État | Commentaires | +| ---------------------------------------------------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- | +| {{SpecName('ES1')}} | {{Spec2('ES1')}} | Définition initiale. Implémentée avec JavaScript 1.1. | +| {{SpecName('ES5.1', '#sec-15.7.4.4', 'Number.prototype.valueOf')}} | {{Spec2('ES5.1')}} |   | +| {{SpecName('ES6', '#sec-number.prototype.valueof', 'Number.prototype.valueOf')}} | {{Spec2('ES6')}} |   | +| {{SpecName('ESDraft', '#sec-number.prototype.valueof', 'Number.prototype.valueOf')}} | {{Spec2('ESDraft')}} |   | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Number.valueOf")}} + +## Voir aussi + +- {{jsxref("Number.prototype.toSource()")}} -- cgit v1.2.3-54-g00ecf