diff options
Diffstat (limited to 'files/fr/web/javascript/reference/global_objects/number')
22 files changed, 2233 insertions, 0 deletions
diff --git a/files/fr/web/javascript/reference/global_objects/number/epsilon/index.html b/files/fr/web/javascript/reference/global_objects/number/epsilon/index.html new file mode 100644 index 0000000000..75bab809e7 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/number/epsilon/index.html @@ -0,0 +1,76 @@ +--- +title: Number.EPSILON +slug: Web/JavaScript/Reference/Objets_globaux/Number/EPSILON +tags: + - ECMAScript 2015 + - JavaScript + - Number + - Propriété + - Reference + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Number/EPSILON +--- +<div>{{JSRef}}</div> + +<p>La propriété <strong><code>Number.EPSILON</code></strong> 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.</p> + +<p>Il n'est pas nécessaire de créer un objet {{jsxref("Number")}} pour accéder à cette propriété statique, elle est accessible avec <code>Number.EPSILON</code>.</p> + +<div>{{EmbedInteractiveExample("pages/js/number-epsilon.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<div>{{js_property_attributes(0,0,0)}}</div> + +<h2 id="Description">Description</h2> + +<p>La propriété <code>EPSILON</code> vaut environ <code>2.2204460492503130808472633361816E-16</code> (ce qui correspond à 2<sup>-52</sup>).</p> + +<h2 id="Exemple">Exemple</h2> + +<h3 id="Tester_une_égalité_mathématique_avec_un_seuil_de_précision">Tester une égalité mathématique avec un seuil de précision</h3> + +<pre class="brush: js">x = 0.2; +y = 0.3; +equal = (Math.abs(x - y) < Number.EPSILON);</pre> + +<h2 id="Prothèse_d'émulation_(polyfill)">Prothèse d'émulation (<em>polyfill</em>)</h2> + +<pre class="brush: js">if (Number.EPSILON === undefined) { + Number.EPSILON = Math.pow(2, -52); +} +</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-number.epsilon', 'Number.EPSILON')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Définition initiale.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-number.epsilon', 'Number.EPSILON')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.Number.EPSILON")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>L'objet {{jsxref("Number")}} auquel appartient cette propriété.</li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/number/index.html b/files/fr/web/javascript/reference/global_objects/number/index.html new file mode 100644 index 0000000000..c5894cb63a --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/number/index.html @@ -0,0 +1,203 @@ +--- +title: Number +slug: Web/JavaScript/Reference/Objets_globaux/Number +tags: + - JavaScript + - Number + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Number +--- +<div>{{JSRef}}</div> + +<p>L'objet <strong><code>Number</code></strong> est une enveloppe objet (<em>wrapper</em>) autour du <a href="/fr/docs/Web/JavaScript/Structures_de_données#Le_type_nombre">type primitif numérique</a>. Autrement dit, il est utilisé pour manipuler les nombres comme des objets. Pour créer un objet <code>Number</code>, on utilise le constructeur <code>Number()</code>.</p> + +<p>Le type JavaScript <code>Number</code> utilise <a href="https://fr.wikipedia.org/wiki/IEEE_754">une représentation binaire à précision double sur 64 bits telle que décrite par le standard IEEE 754</a>. Les implémentations plus récentes offrent un nouveau type : {{jsxref("BigInt")}} qui permet de représenter des entiers avec une précision arbitraire.</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox notranslate">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</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>valeur</code></dt> + <dd>La valeur numérique pour l'objet qu'on souhaite créer.</dd> +</dl> + +<h2 id="Description">Description</h2> + +<p>L'objet <code>Number</code> est principalement utilisé dans les cas de figure suivants :</p> + +<ul> + <li>Si l'argument ne peut pas être converti en un nombre, il renverra {{jsxref("NaN")}}.</li> + <li>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")}}), <code>Number</code> peut être utilisé afin d'effectuer des conversions.</li> +</ul> + +<h2 id="Propriétés">Propriétés</h2> + +<dl> + <dt>{{jsxref("Number.EPSILON")}}</dt> + <dd>Le plus petit intervalle entre deux valeurs qu'il est possible de représenter en JavaScript.</dd> + <dt>{{jsxref("Number.MAX_SAFE_INTEGER")}}</dt> + <dd>La valeur entière maximale qu'on peut représenter en JavaScript (<code>2<sup>53</sup> - 1</code>).</dd> + <dt>{{jsxref("Number.MAX_VALUE")}}</dt> + <dd>La valeur numérique maximale qu'on peut représenter en JavaScript.</dd> + <dt>{{jsxref("Number.MIN_SAFE_INTEGER")}}</dt> + <dd>La valeur entière minimale qu'on peut représenter en JavaScript (<code>-(2<sup>53</sup> - 1)</code>).</dd> + <dt>{{jsxref("Number.MIN_VALUE")}}</dt> + <dd>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).</dd> + <dt>{{jsxref("Number.NaN")}}</dt> + <dd>Une valeur spéciale pour représenter les valeurs non-numériques (<strong>NaN</strong> correspond à « <em><strong>n</strong>ot <strong>a</strong> <strong>n</strong>umber</em> » en anglais, qui signifie « n'est pas un nombre »).</dd> + <dt>{{jsxref("Number.NEGATIVE_INFINITY")}}</dt> + <dd>Une valeur spéciale pour représenter l'infini négatif.</dd> + <dt>{{jsxref("Number.POSITIVE_INFINITY")}}</dt> + <dd>Une valeur spéciale pour représenter l'infini (positif).</dd> + <dt>{{jsxref("Number.prototype")}}</dt> + <dd>Cet objet permet d'ajouter des propriétés aux instances de <code>Number</code>.</dd> +</dl> + +<h2 id="Méthodes">Méthodes</h2> + +<dl> + <dt>{{jsxref("Number.isNaN()")}}</dt> + <dd>Cette méthode permet de déterminer si la valeur passée en argument vaut <code>NaN</code>.</dd> + <dt>{{jsxref("Number.isFinite()")}}</dt> + <dd>Cette méthode permet de déterminer si la valeur numérique passée en argument est un nombre fini.</dd> + <dt>{{jsxref("Number.isInteger()")}}</dt> + <dd>Cette méthode permet de déterminer si la valeur passée en argument est un entier.</dd> + <dt>{{jsxref("Number.isSafeInteger()")}}</dt> + <dd>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 <code>-(2<sup>53</sup> - 1)</code> et <code>2<sup>53</sup> - 1</code>).</dd> + <dt><s class="obsoleteElement">{{jsxref("Number.toInteger()")}} {{obsolete_inline}}</s></dt> + <dd><s class="obsoleteElement">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.</s></dd> + <dt>{{jsxref("Number.parseFloat()", "Number.parseFloat(<var>string</var>)")}}</dt> + <dd>Cette méthode correspond à la méthode {{jsxref("parseFloat", "parseFloat()")}} de l'objet global.</dd> + <dt>{{jsxref("Number.parseInt()", "Number.parseInt(<var>string</var>, [<var>radix</var>])")}}</dt> + <dd>Cette méthode correspond à la méthode {{jsxref("parseInt", "parseInt()")}} de l'objet global.</dd> +</dl> + +<h2 id="Les_instances_de_Number">Les instances de <code>Number</code></h2> + +<p>Toutes les instances de <code>Number</code> héritent de {{jsxref("Number.prototype")}}. Il est possible de modifier le prototype du constructeur <code>Number</code> pour affecter toutes les instances de <code>Number</code>.</p> + +<h3 id="Méthodes_2">Méthodes</h3> + +<div> +<dl> + <dt>{{jsxref("Number.prototype.toExponential()" ,"Number.prototype.toExponential(<var>fractionDigits</var>)")}}</dt> + <dd>Retourne une chaîne représentant le nombre en notation exponentielle.</dd> + <dt>{{jsxref("Number.prototype.toFixed()", "Number.prototype.toFixed(<var>digits</var>)")}}</dt> + <dd>Retourne une chaîne représentant le nombre avec la notation virgule fixe.</dd> + <dt>{{jsxref("Number.prototype.toLocaleString()", "Number.prototype.toLocaleString([<var>locales</var> [, <var>options</var>]])")}}</dt> + <dd>Retourne une chaîne avec une représentation sensible à la langue de ce nombre. Surcharge la méthode {{jsxref("Object.prototype.toLocaleString()")}}.</dd> + <dt>{{jsxref("Number.prototype.toPrecision()", "Number.prototype.toPrecision(<var>precision</var>)")}}</dt> + <dd>Retourne une chaîne représentant le nombre avec une précision donnée en notation virgule fixe ou exponentielle.</dd> + <dt>{{jsxref("Number.prototype.toString()", "Number.prototype.toString([<var>radix</var>])")}}</dt> + <dd>Retourne une chaîne représentant le nombre dans une base numérique (radix) donnée. Surcharge la méthode {{jsxref("Object.prototype.toString()")}}.</dd> + <dt>{{jsxref("Number.prototype.valueOf()")}}</dt> + <dd>Retourne la valeur primitive de l'objet spécifié. Surcharge la méthode {{jsxref("Object.prototype.valueOf()")}}.</dd> +</dl> +</div> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utiliser_lobjet_Number_pour_affecter_des_valeurs_numériques_à_des_variables">Utiliser l'objet <code>Number</code> pour affecter des valeurs numériques à des variables</h3> + +<p>Dans l'exemple suivant, on utilise les propriétés de l'objet <code>Number</code> pour affecter des valeurs à des variables numériques :</p> + +<pre class="brush: js notranslate">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; +</pre> + +<h3 id="Intervalle_entier_pour_Number">Intervalle entier pour <code>Number</code></h3> + +<p>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, <a href="https://tc39.github.io/ecma262/#sec-ecmascript-language-types-number-type">voir le chapitre 6.1.6 du standard ECMAScript</a>) :</p> + +<pre class="brush: js notranslate">var biggestInt = 9007199254740992; //Number.MAX_SAFE_INTEGER+1 (2<sup>53</sup>-1) +var smallestInt = -9007199254740992; //Number.MIN_SAFE_INTEGER-1 -(2<sup>53</sup>-1) +</pre> + +<p>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.</p> + +<h3 id="Utiliser_Number_pour_convertir_un_objet_Date">Utiliser <code>Number</code> pour convertir un objet <code>Date</code></h3> + +<p>Dans l'exemple suivant, on convertit un objet {{jsxref("Date")}} en une valeur numérique grâce à la fonction <code>Number</code> :</p> + +<pre class="brush: js notranslate">var d = new Date('December 17, 1995 03:24:00'); +console.log(Number(d)); +</pre> + +<p>Ceci affichera "819167040000".</p> + +<h3 id="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</h3> + +<pre class="brush: js notranslate">Number("123"); // 123 +Number("12.3"); // 12.3 +Number("12.00"); // 12 +Number("123e-1"); // 12.3 +Number(""); // 0 +Number("0x11"); // 17 +Number("0b11"); // 3 +Number("0o11"); // 9 +Number("toto"); // NaN +Number("100a"); // NaN +Number("-Infinity";) // -Infinity +</pre> + +<div class="note"> +<p><strong>Note :</strong> On pourra également convertir <code>null</code> en <code>0</code> grâce à <code>Number</code> : <code>Number(null)</code> donnera <code>0</code>.</p> +</div> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Définition initiale. Implémentée avec JavaScript 1.1.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.7', 'Number')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-number-objects', 'Number')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>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")}})</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-number-objects', 'Number')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.Number")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("NaN")}}</li> + <li>L'objet global {{jsxref("Math")}}</li> + <li><a href="/fr/docs/Web/JavaScript/Structures_de_données#Le_type_nombre">Les types de données en JavaScript</a></li> + <li><a href="https://medium.com/@maximus.koretskyi/javascripts-number-type-8d59199db1b6#.9whwe88tz">Un billet sur le type <code>Number</code> (en anglais)</a></li> + <li>Représenter de grands entiers avec une précision arbitraire : {{jsxref("BigInt")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/number/isfinite/index.html b/files/fr/web/javascript/reference/global_objects/number/isfinite/index.html new file mode 100644 index 0000000000..953e9d8958 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/number/isfinite/index.html @@ -0,0 +1,115 @@ +--- +title: Number.isFinite() +slug: Web/JavaScript/Reference/Objets_globaux/Number/isFinite +tags: + - ECMAScript6 + - JavaScript + - Méthode + - Number + - Reference + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Number/isFinite +--- +<div>{{JSRef}}</div> + +<p>La méthode <strong><code>Number.isFinite()</code></strong> permet de déterminer si la valeur fournie est un nombre fini.</p> + +<div>{{EmbedInteractiveExample("pages/js/number-isfinite.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox notranslate">Number.isFinite(valeurÀTester);</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>valeurÀTester</code></dt> + <dd>La valeur dont on souhaite savoir si elle est finie.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Un booléen indiquant si la valeur passée en argument est un nombre fini.</p> + +<h2 id="Description">Description</h2> + +<p>Par rapport à la fonction de l'objet global {{jsxref("isFinite","isFinite()")}} qui convertit l'argument donné en un nombre, la fonction <code>Number.isFinite </code>ne convertit pas l'argument et ne renvoie pas <code>true</code>.</p> + +<h2 id="Exemples">Exemples</h2> + +<pre class="brush:js; notranslate">Number.isFinite(Infinity); // false +Number.isFinite(NaN); // false +Number.isFinite(-Infinity); // false + +Number.isFinite(0); // true +Number.isFinite(2e64); // true + +Number.isFinite("0"); // false, ce qui aurait + // renvoyé true avec isFinite("0") + +Number.isFinite(null); // false, ce qui aurait + // renvoyé true avc isFinite(null) +</pre> + +<h2 id="Prothèse_démulation_polyfill">Prothèse d'émulation (<em>polyfill</em>)</h2> + +<pre class="brush:js; notranslate">// Number.isFinite polyfill +// http://people.mozilla.org/~jorendorff/es6-draft.html#sec-number.isfinite +if (typeof Number.isFinite !== 'function') { + Number.isFinite = function isFinite(value) { + // 1. Si Type(number) n'est pas Number, on renvoie false. + if (typeof value !== 'number') { + return false; + } + // 2. Si le nombre est NaN, +∞, ou −∞, on renvoie false. + if (value !== value || value === Infinity || value === -Infinity) { + return false; + } + // 3. Sinon on renvoie true. + return true; + }; +} +</pre> + +<p>Deuxième version plus concise qui utilise la méthode globale <code>isFinite</code></p> + +<pre class="brush: js notranslate">if (Number.isFinite === undefined) Number.isFinite = function(value) { + return typeof value === "number" && isFinite(value); +}</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-number.isfinite', 'Number.isInteger')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Définition initiale.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-number.isfinite', 'Number.isInteger')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.Number.isFinite")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>L'objet {{jsxref("Number")}} auquel appartient cette méthode</li> + <li>La méthode {{jsxref("isFinite", "isFinite()")}} de l'objet global</li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/number/isinteger/index.html b/files/fr/web/javascript/reference/global_objects/number/isinteger/index.html new file mode 100644 index 0000000000..447c80ede2 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/number/isinteger/index.html @@ -0,0 +1,102 @@ +--- +title: Number.isInteger() +slug: Web/JavaScript/Reference/Objets_globaux/Number/isInteger +tags: + - JavaScript + - Méthode + - Number + - Reference + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Number/isInteger +--- +<div>{{JSRef}}</div> + +<p>La méthode <strong><code>Number.isInteger()</code></strong> permet de déterminer si l'argument est un nombre entier.</p> + +<div>{{EmbedInteractiveExample("pages/js/number-isinteger.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox">Number.isInteger(valeurÀTester)</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code><var>valeurÀTester</var></code></dt> + <dd>La valeur dont on souhaite savoir si elle est entière ou non.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Un booléen qui indique si la valeur fournie en argument est un entier.</p> + +<h2 id="Description">Description</h2> + +<p>Si la valeur à tester est un entier, cette méthode renvoie <code>true</code>, <code>false</code> sinon. Si la valeur est {{jsxref("NaN")}} ou l'infini ({{jsxref("Infinity")}}), la méthode renverra <code>false</code>. La méthode renverra également <code>true</code> pour les nombres flottants qui peuvent être représentés comme des entiers.</p> + +<h2 id="Exemples">Exemples</h2> + +<pre class="brush: js">Number.isInteger(1); // true +Number.isInteger(-100000); // true +Number.isInteger(0); // true +Number.isInteger(1.000) // true +// Number.isInteger(9…9999); // true, même si le nombre dépasse 32 bits + +Number.isInteger(0.1); // false +Number.isInteger(Math.PI); // false + +Number.isInteger(-Infinity); // false +Number.isInteger(true); // false +Number.isInteger(NaN); // false +Number.isInteger("10"); // false + +Number.isInteger(5.0); // true +Number.isInteger(5.000000000000001);// false +Number.isInteger(5.0000000000000001); // true +</pre> + +<h2 id="Prothèse_démulation_polyfill">Prothèse d'émulation (<em>polyfill</em>)</h2> + +<pre class="brush: js">Number.isInteger = Number.isInteger || function(value) { + return typeof value === "number" && + isFinite(value) && + Math.floor(value) === value; +};</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ES6', '#sec-number.isinteger', 'Number.isInteger')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Définition initiale.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-number.isinteger', 'Number.isInteger')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.Number.isInteger")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>L'objet global {{jsxref("Number")}} auquel appartient cette méthode.</li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/number/isnan/index.html b/files/fr/web/javascript/reference/global_objects/number/isnan/index.html new file mode 100644 index 0000000000..5915747056 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/number/isnan/index.html @@ -0,0 +1,104 @@ +--- +title: Number.isNaN() +slug: Web/JavaScript/Reference/Objets_globaux/Number/isNaN +tags: + - ECMAScript 2015 + - JavaScript + - Méthode + - Number + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Number/isNaN +--- +<div>{{JSRef}}</div> + +<p>La méthode <strong><code>Number.isNaN()</code></strong> 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")}}.</p> + +<div>{{EmbedInteractiveExample("pages/js/number-isnan.html", "taller")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox">Number.isNaN(<var>valeurÀTester</var>)</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code><em>valeurÀTester</em></code></dt> + <dd>La valeur qu'on souhaite comparer à {{jsxref("NaN")}}.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Un booléen qui indique si la valeur fournie en argument est {{jsxref("NaN")}}.</p> + +<h2 id="Description">Description</h2> + +<p>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 <code>false</code> pour vérifier que {{jsxref("NaN")}} <em>est</em> NaN. La fonction <code>Number.isNaN</code> 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.</p> + +<p>En effet, la fonction globale {{jsxref("isNaN")}} convertit l'argument en un nombre. <code>Number.isNaN</code> 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 <code>NaN</code>, elle renverra <code>true</code>.</p> + +<h2 id="Exemples">Exemples</h2> + +<pre class="brush:js;">Number.isNaN(NaN); // true +Number.isNaN(Number.NaN); // true +Number.isNaN(0 / 0); // true + +// tout le reste renverra : false +Number.isNaN(undefined); +Number.isNaN({}); + +Number.isNaN(true); +Number.isNaN(null); +Number.isNaN(37); + +Number.isNaN("37"); +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</pre> + +<h2 id="Prothèse_d'émulation_(polyfill)">Prothèse d'émulation (<em>polyfill</em>)</h2> + +<p>La fonction suivant fonctionne car <code>NaN</code> est la seule valeur JavaScript qui n'est pas égale à elle-même.</p> + +<pre class="brush: js">Number.isNaN = Number.isNaN || function(value) { + return typeof value === "number" && isNaN(value); +}</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-number.isnan', 'Number.isnan')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Définition initiale.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-number.isnan', 'Number.isnan')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.Number.isNaN")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>L'objet {{jsxref("Number")}} auquel appartient cette méthode.</li> + <li>La méthode {{jsxref("Objets_globaux/Object/is", "Object.is")}} qui permet d'effectuer des comparaisons sur l'égalité de valeur</li> + <li>La méthode {{jsxref("isNaN")}} de l'objet global</li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/number/issafeinteger/index.html b/files/fr/web/javascript/reference/global_objects/number/issafeinteger/index.html new file mode 100644 index 0000000000..3aa5accb87 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/number/issafeinteger/index.html @@ -0,0 +1,100 @@ +--- +title: Number.isSafeInteger() +slug: Web/JavaScript/Reference/Objets_globaux/Number/isSafeInteger +tags: + - ECMAScript 2015 + - JavaScript + - Méthode + - Number + - Reference + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Number/isSafeInteger +--- +<div>{{JSRef}}</div> + +<p>La méthode <strong><code>Number.isSafeInteger()</code></strong> 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<sup>53</sup> -1) et 2<sup>53</sup> -1).</p> + +<div>{{EmbedInteractiveExample("pages/js/number-issafeinteger.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<div class="blockIndicator note"> +<p><strong>Note :</strong> Pour représenter des entiers qui ne sont pas compris dans cet intervalle, on pourra utiliser le type {{jsxref("BigInt")}}.</p> +</div> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox">Number.isSafeInteger(valeurÀTester)</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code><var>valeurÀTester</var></code></dt> + <dd>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 <a class="external external-icon" href="https://en.wikipedia.org/wiki/Double_precision_floating-point_format">les nombres au format de virgule flottante à double précision</a> comme spécifié dans <a class="external external-icon" href="https://fr.wikipedia.org/wiki/IEEE_754">IEEE 754</a> et ne peut représenter avec certitude un entier qu'entre <code>-(2<sup>53</sup>-1)</code> et <code>2<sup>53</sup> -1</code> (c'est-à-dire ± <code>9007199254740991</code>).</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Un booléen qui indique si la valeur fournie en argument est un entier représentable correctement en JavaScript.</p> + +<h2 id="Description">Description</h2> + +<p>Un entier correctement représentable en JavaScript :</p> + +<ul> + <li>peut exactement être représenté avec un nombre à précision double selon IEEE-754</li> + <li>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.</li> +</ul> + +<p>Ainsi, par exemple, <code>2<sup>53</sup> - 1</code> peut être représenté correctement, aucun autre entier ne peut être arrondi en cette valeur selon IEEE-754. En revanche, <code>2<sup>53</sup></code> ne peut pas être représenté correctement car <code>2<sup>53</sup> + 1</code> sera arrondi en <code>2<sup>53</sup></code> selon les règles IEEE-754 (arrondi à l'entier le plus proche).</p> + +<p>L'intervalle des entiers qui peuvent être correctement représentés est <code>[-(2<sup>53</sup> - 1),2<sup>53</sup> - 1</code> ].</p> + +<h2 id="Exemples">Exemples</h2> + +<pre class="brush:js">Number.isSafeInteger(3); // true +Number.isSafeInteger(Math.pow(2, 53)) // false +Number.isSafeInteger(Math.pow(2, 53) - 1) // true +Number.isSafeInteger(NaN); // false +Number.isSafeInteger(Infinity); // false +Number.isSafeInteger("3"); // false +Number.isSafeInteger(3.1); // false +Number.isSafeInteger(3.0); // true +</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-number.issafeinteger', 'Number.isSafeInteger')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Définition initiale.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-number.issafeinteger', 'Number.isSafeInteger')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.Number.isSafeInteger")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>L'objet {{jsxref("Number")}} auquel appartient cette méthode</li> + <li>{{jsxref("Number.MIN_SAFE_INTEGER")}}</li> + <li>{{jsxref("Number.MAX_SAFE_INTEGER")}}</li> + <li>{{jsxref("BigInt")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/number/max_safe_integer/index.html b/files/fr/web/javascript/reference/global_objects/number/max_safe_integer/index.html new file mode 100644 index 0000000000..7266e8d4ae --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/number/max_safe_integer/index.html @@ -0,0 +1,74 @@ +--- +title: Number.MAX_SAFE_INTEGER +slug: Web/JavaScript/Reference/Objets_globaux/Number/MAX_SAFE_INTEGER +tags: + - ECMAScript 2015 + - JavaScript + - Number + - Propriété + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER +--- +<div>{{JSRef}}</div> + +<p>La constante <code><strong>Number.MAX_SAFE_INTEGER </strong></code>représente la valeur (sûre) maximale d’un nombre entier en JavaScript (2<sup>53</sup> -1).</p> + +<div class="blockIndicator note"> +<p><strong>Note :</strong> Pour représenter des entiers supérieurs à cette valeur, on pourra utiliser le type {{jsxref("BigInt")}}.</p> +</div> + +<div>{{EmbedInteractiveExample("pages/js/number-maxsafeinteger.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<p>{{js_property_attributes(0,0,0)}}</p> + +<h2 id="Description">Description</h2> + +<p>La constante <code>MAX_SAFE_INTEGER</code> a une valeur de <code>9007199254740991</code>. Cette valeur s'explique par le fait que JavaScript utilise <a href="http://en.wikipedia.org/wiki/Double_precision_floating-point_format">les nombres au format de virgule flottante à double précision</a> comme spécifié dans <a href="http://fr.wikipedia.org/wiki/IEEE_754">IEEE 754</a> et ne peut représenter avec certitude qu’un nombre entre <code>-(2<sup>53</sup>-1)</code> et <code>2<sup>53</sup> -1</code>.</p> + +<p>Dans ce contexte, « sûr » fait référence à la capacité à représenter exactement les entiers et à les comparer entre eux. Par exemple, <code>Number.MAX_SAFE_INTEGER + 1 === Number.MAX_SAFE_INTEGER + 2</code> vaudra <code>true</code> ce qui est mathématiquement incorrect. Pour plus d'informations, voir également {{jsxref("Number.isSafeInteger()")}}.</p> + +<p><code>MAX_SAFE_INTEGER</code> est une propriété statique de {{jsxref("Number")}}, elle doit toujours être utilisée comme <code>Number.MAX_SAFE_INTEGER</code> et non pas comme la propriété d'un objet <code>Number</code> qui aurait été instancié.</p> + +<h2 id="Exemples">Exemples</h2> + +<pre class="brush: js">Number.MAX_SAFE_INTEGER // 9007199254740991 +Math.pow(2, 53) -1 // 9007199254740991 +</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-number.max_safe_integer', 'Number.MAX_SAFE_INTEGER')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Définition initiale</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-number.max_safe_integer', 'Number.MAX_SAFE_INTEGER')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.Number.MAX_SAFE_INTEGER")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Number.MIN_SAFE_INTEGER")}}</li> + <li>{{jsxref("Number.isSafeInteger()")}}</li> + <li>{{jsxref("BigInt")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/number/max_value/index.html b/files/fr/web/javascript/reference/global_objects/number/max_value/index.html new file mode 100644 index 0000000000..405b3da898 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/number/max_value/index.html @@ -0,0 +1,80 @@ +--- +title: Number.MAX_VALUE +slug: Web/JavaScript/Reference/Objets_globaux/Number/MAX_VALUE +tags: + - JavaScript + - Number + - Propriété + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Number/MAX_VALUE +--- +<div>{{JSRef}}</div> + +<p>La propriété <code><strong>Number.MAX_VALUE</strong></code> représente la valeur maximale qui peut être représentée par un nombre en JavaScript.</p> + +<div>{{EmbedInteractiveExample("pages/js/number-maxvalue.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<div>{{js_property_attributes(0,0,0)}}</div> + +<h2 id="Description">Description</h2> + +<p>La propriété statique <code>MAX_VALUE</code> vaut environ <code>1.79E+308</code> (soit 2<sup>1024</sup>). Les valeurs supérieures à <code>MAX_VALUE</code> sont représentées par {{jsxref("Infinity")}} (pour l'infini).</p> + +<p><code>MAX_VALUE</code> est une propriété statique de {{jsxref("Number")}}, il faut donc l'utiliser avec <code>Number.MAX_VALUE</code>, plutôt qu'en faisant appel à la propriété d'un objet<code> Number</code> qui aurait été instancié (si on appelle cette propriété sur l'objet <code>Number</code> créé, on obtiendra {{jsxref("undefined")}}).</p> + +<h2 id="Exemples">Exemples</h2> + +<p>Le code suivant teste si le produit de deux nombres est inférieur ou égal à <code>MAX_VALUE</code>, selon le résultat de ce test, soit on utilisera <code>func1</code>, soit on utilisera <code>func2</code>.</p> + +<pre class="brush: js">if (num1 * num2 <= Number.MAX_VALUE) { + func1(); +} else { + func2(); +}</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Définition initiale. Implémentée avec JavaScript 1.1.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.7.3.2', 'Number.MAX_VALUE')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-number.max_value', 'Number.MAX_VALUE')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-number.max_value', 'Number.MAX_VALUE')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.Number.MAX_VALUE")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Number.MIN_VALUE")}}</li> + <li>{{jsxref("Number")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/number/min_safe_integer/index.html b/files/fr/web/javascript/reference/global_objects/number/min_safe_integer/index.html new file mode 100644 index 0000000000..8f19b905d2 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/number/min_safe_integer/index.html @@ -0,0 +1,72 @@ +--- +title: Number.MIN_SAFE_INTEGER +slug: Web/JavaScript/Reference/Objets_globaux/Number/MIN_SAFE_INTEGER +tags: + - ECMAScript 2015 + - JavaScript + - Number + - Propriété + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Number/MIN_SAFE_INTEGER +--- +<div>{{JSRef}}</div> + +<p>La constante <code><strong>Number.MIN_SAFE_INTEGER</strong></code> représente le plus petit entier représentable correctement en JavaScript (-(2<sup>53</sup> -1)).</p> + +<div class="blockIndicator note"> +<p><strong>Note :</strong> Pour représenter des entiers inférieurs à cette valeur, on pourra utiliser le type {{jsxref("BigInt")}}.</p> +</div> + +<div>{{EmbedInteractiveExample("pages/js/number-min-safe-integer.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<div>{{js_property_attributes(0,0,0)}}</div> + +<h2 id="Description">Description</h2> + +<p>La constante <code>MIN_SAFE_INTEGER</code> vaut <code>-9007199254740991</code>. Cette valeur provient du fait qu'en JavaScript, les nombres sont représentés <a href="https://en.wikipedia.org/wiki/Double_precision_floating-point_format">en format à double précision</a> selon la norme <a href="http://fr.wikipedia.org/wiki/IEEE_754">IEEE 754</a> et on ne peut représenter correctement que les nombres compris entre <code>-(2<sup>53</sup>-1)</code> et <code>2<sup>53</sup> -1</code>. Voir {{jsxref("Number.isSafeInteger()")}} pour plus d'informations.</p> + +<p><code>MIN_SAFE_INTEGER</code> étant une méthode statique de {{jsxref("Number")}}, il faut utiliser <code><code>Number</code>.<code>MIN_SAFE_INTEGER</code>()</code>et non pas la méthode d'un objet <code>Number</code> qui aurait été instancié.</p> + +<h2 id="Exemples">Exemples</h2> + +<pre class="brush: js">Number.MIN_SAFE_INTEGER // -9007199254740991 +-Math.pow(2, 53) -1 // -9007199254740991 +</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-number.min_safe_integer', 'Number.MIN_SAFE_INTEGER')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Définition initiale.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-number.min_safe_integer', 'Number.MIN_SAFE_INTEGER')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.Number.MIN_SAFE_INTEGER")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Number.MAX_SAFE_INTEGER")}}</li> + <li>{{jsxref("Number.isSafeInteger()")}}</li> + <li>{{jsxref("BigInt")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/number/min_value/index.html b/files/fr/web/javascript/reference/global_objects/number/min_value/index.html new file mode 100644 index 0000000000..4a70b026d9 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/number/min_value/index.html @@ -0,0 +1,83 @@ +--- +title: Number.MIN_VALUE +slug: Web/JavaScript/Reference/Objets_globaux/Number/MIN_VALUE +tags: + - JavaScript + - Number + - Propriété + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Number/MIN_VALUE +--- +<div>{{JSRef}}</div> + +<p>La propriété <code><strong>Number.MIN_VALUE</strong></code> représente la plus petite valeur numérique positive qu'il est possible de représenter en JavaScript.</p> + +<div>{{EmbedInteractiveExample("pages/js/number-min-value.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<div>{{js_property_attributes(0,0,0)}}</div> + +<h2 id="Description">Description</h2> + +<p>La propriété <code>MIN_VALUE</code> 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.</p> + +<p><code>MIN_VALUE</code> vaut environ 5e-324. Les valeurs inférieures à <code>MIN_VALUE</code> sont converties en 0.</p> + +<p><code>MIN_VALUE</code> est une propriété statique de {{jsxref("Number")}} et doit donc être utilisée avec la syntaxe <code>Number.MIN_VALUE</code>, et non pas via la propriété d'un objet <code>Number</code> qui aurait été instancié.</p> + +<h2 id="Exemples">Exemples</h2> + +<p>Le code qui suit effectue la division de deux nombres. Si le résultat obtenu est supérieur ou égal à <code>MIN_VALUE</code>, la fonction <code>func1</code> sera appelée, sinon la fonction <code>func2</code> sera utilisée.</p> + +<pre class="brush:js">if (num1 / num2 >= Number.MIN_VALUE) { + func1(); +} else { + func2(); +}</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Définition initiale. Implémentée avec JavaScript 1.1</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.7.3.3', 'Number.MIN_VALUE')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-number.min_value', 'Number.MIN_VALUE')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-number.min_value', 'Number.MIN_VALUE')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.Number.MIN_VALUE")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Number.MAX_VALUE")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/number/nan/index.html b/files/fr/web/javascript/reference/global_objects/number/nan/index.html new file mode 100644 index 0000000000..71f705c9cc --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/number/nan/index.html @@ -0,0 +1,64 @@ +--- +title: Number.NaN +slug: Web/JavaScript/Reference/Objets_globaux/Number/NaN +tags: + - JavaScript + - Number + - Propriété + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Number/NaN +--- +<div>{{JSRef}}</div> + +<p>La propriété <strong><code>Number.NaN</code></strong> représente une valeur qui n'est pas un nombre (en anglais « <em>Not-A-Number</em> » qui donne NaN). Elle est équivalente à {{jsxref("NaN")}}.</p> + +<div>{{EmbedInteractiveExample("pages/js/number-nan.html")}}</div> + +<p>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 <code>Number.NaN</code>.</p> + +<p>{{js_property_attributes(0,0,0)}}</p> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Définition initiale. Implémentée avec JavaScript 1.1.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.7.3.4', 'Number.NaN')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-number.nan', 'Number.NaN')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-number.nan', 'Number.NaN')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.Number.NaN")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>L'objet global {{jsxref("NaN")}} ;</li> + <li>L'objet {{jsxref("Number")}} auquel appartient cette propriété.</li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/number/negative_infinity/index.html b/files/fr/web/javascript/reference/global_objects/number/negative_infinity/index.html new file mode 100644 index 0000000000..5676e99d27 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/number/negative_infinity/index.html @@ -0,0 +1,99 @@ +--- +title: Number.NEGATIVE_INFINITY +slug: Web/JavaScript/Reference/Objets_globaux/Number/NEGATIVE_INFINITY +tags: + - JavaScript + - Number + - Propriété + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Number/NEGATIVE_INFINITY +--- +<div>{{JSRef}}</div> + +<p>La propriété <code><strong>Number.NEGATIVE_INFINITY</strong></code> représente l'infini négatif.</p> + +<div>{{EmbedInteractiveExample("pages/js/number-negative-infinity.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<div>{{js_property_attributes(0,0,0)}}</div> + +<h2 id="Description">Description</h2> + +<p>La valeur de <code>Number.NEGATIVE_INFINITY</code> est égale à l'opposé de la valeur fournie par la propriété {{jsxref("Infinity")}} de l'objet global.</p> + +<p>Cette valeur se comporte différemment de l'infini mathématique :</p> + +<ul> + <li>Toute valeur positive, y compris {{jsxref("Number.POSITIVE_INFINITY", "POSITIVE_INFINITY")}}, multipliée par <code>NEGATIVE_INFINITY</code> sera égale à <code>NEGATIVE_INFINITY</code>.</li> + <li>Toute valeur négative, y compris <code>NEGATIVE_INFINITY</code>, multipliée par <code>NEGATIVE_INFINITY</code> sera égale à <code>POSITIVE_INFINITY</code>.</li> + <li>Zéro multiplié par <code>NEGATIVE_INFINITY</code> sera égal à {{jsxref("NaN")}}.</li> + <li>NaN multiplié par <code>NEGATIVE_INFINITY</code> sera égal à <code>NaN</code>.</li> + <li><code>NEGATIVE_INFINITY</code>, divisé par n'importe quelle valeur négative, à l'exception de <code>NEGATIVE_INFINITY</code>, sera égal à <code>POSITIVE_INFINITY</code>.</li> + <li><code>NEGATIVE_INFINITY</code>, divisé par n'importe quelle valeur positive à l'exception de <code>POSITIVE_INFINITY</code>, sera égal à <code>NEGATIVE_INFINITY</code>.</li> + <li><code>NEGATIVE_INFINITY</code>, divisé par <code>NEGATIVE_INFINITY</code> ou <code>POSITIVE_INFINITY</code>, sera égal à <code>NaN</code>.</li> + <li>Tout nombre positif divisé par <code>NEGATIVE_INFINITY</code> sera égal au zéro négatif.</li> + <li>Tout nombre négatif divisé par <code>NEGATIVE_INFINITY</code> sera égal au zéro positif.</li> +</ul> + +<p>La propriété <code>Number.NEGATIVE_INFINITY</code> 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.</p> + +<p><code>Number.NEGATIVE_INFINITY</code> est une propriété statique de {{jsxref("Number")}} et on utilisera directement <code>Number.NEGATIVE_INFINITY</code> plutôt que comme une propriété d'un objet (instance) {{jsxref("Number")}}.</p> + +<h2 id="Exemples">Exemples</h2> + +<p>Dans l'exemple qui suit, on affecte une variable inférieure à la valeur numérique minimale à la variable <code>petitNombre</code>. Lorsque l'instruction conditionnelle <code>if</code> est exécutée, <code>petitNombre</code> possède la valeur "<code>-Infinity</code>", on modifie donc la valeur de <code>petitNombre</code> afin qu'il puisse être géré.</p> + +<pre class="brush:js">var petitNombre = (-Number.MAX_VALUE) * 2 + +if (petitNombre === Number.NEGATIVE_INFINITY) { + petitNombre = renvoyerUneValeurFinie(); +} +</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Définition initiale. Implémentée avec JavaScript 1.1.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.7.3.5', 'Number.NEGATIVE_INFINITY')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-number.negative_infinity', 'Number.NEGATIVE_INFINITY')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-number.negative_infinity', 'Number.NEGATIVE_INFINITY')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.Number.NEGATIVE_INFINITY")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Number.POSITIVE_INFINITY")}}</li> + <li>{{jsxref("Number.isFinite()")}}</li> + <li>{{jsxref("Infinity", "Infinity")}}</li> + <li>{{jsxref("isFinite", "isFinite()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/number/parsefloat/index.html b/files/fr/web/javascript/reference/global_objects/number/parsefloat/index.html new file mode 100644 index 0000000000..85059f92a3 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/number/parsefloat/index.html @@ -0,0 +1,84 @@ +--- +title: Number.parseFloat() +slug: Web/JavaScript/Reference/Objets_globaux/Number/parseFloat +tags: + - ECMAScript 2015 + - JavaScript + - Méthode + - Number + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Number/parseFloat +--- +<div>{{JSRef}}</div> + +<p>La méthode <strong><code>Number.parseFloat()</code></strong> 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).</p> + +<div>{{EmbedInteractiveExample("pages/js/number-parsefloat.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuer à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox">Number.parseFloat(chaîne)</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code><var>chaîne</var></code></dt> + <dd>Une chaîne de caractères qu'on souhaite convertir en nombre flottant.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>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.</p> + +<h2 id="Description">Description</h2> + +<p>Cette méthode possède les mêmes fonctionnalités que la fonction globale {{jsxref("parseFloat", "parseFloat()")}} :</p> + +<pre>Number.parseFloat === parseFloat; // true +</pre> + +<p>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()")}}.</p> + +<h2 id="Prothèse_d'émulation_(polyfill)">Prothèse d'émulation (<em>polyfill</em>)</h2> + +<pre class="brush: js">if (Number.parseFloat === undefined) { + Number.parseFloat = parseFloat; +} +</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-number.parsefloat', 'Number.parseFloat')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Définition initiale.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-number.parsefloat', 'Number.parseFloat')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.Number.parseFloat")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>L'objet {{jsxref("Number")}} auquel appartient cette fonction.</li> + <li>La méthode globale {{jsxref("parseFloat")}}.</li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/number/parseint/index.html b/files/fr/web/javascript/reference/global_objects/number/parseint/index.html new file mode 100644 index 0000000000..60eaae2d48 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/number/parseint/index.html @@ -0,0 +1,84 @@ +--- +title: Number.parseInt() +slug: Web/JavaScript/Reference/Objets_globaux/Number/parseInt +tags: + - ECMAScript 2015 + - JavaScript + - Méthode + - Number + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Number/parseInt +--- +<div>{{JSRef}}</div> + +<p>La méthode <strong><code>Number.parseInt()</code></strong> analyse et convertit une chaine de caractères, fournie en argument, en un entier dans la base souhaitée.</p> + +<div>{{EmbedInteractiveExample("pages/js/number-parseint.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox">Number.parseInt(<var>chaîne</var> [,<var> base</var>])</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>chaîne</code></dt> + <dd>La valeur à convertir. Si <code>chaine</code> n'est pas une chaîne de caractères, elle sera convertie auparavant. Les blancs qui préfixent la chaîne sont ignorés.</dd> + <dt><code>base</code> {{optional_inline}}</dt> + <dd>Paramètre optionnel. Un entier représentant la base dans laquelle est représentée la valeur de la chaîne. <strong>Il faut toujours spécifier ce paramètre.</strong> 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.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>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.</p> + +<h2 id="Description">Description</h2> + +<p>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 :</p> + +<pre class="brush: js">Number.parseInt === parseInt; // true</pre> + +<h2 id="Prothèse_d'émulation_(polyfill)">Prothèse d'émulation (<em>polyfill</em>)</h2> + +<p>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 :</p> + +<pre class="brush: js">if(Number.parseInt === undefined) { + Number.parseInt = parseInt; +}</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-number.parseint', 'Number.parseInt')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Définition initiale.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-number.parseint', 'Number.parseInt')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<div class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</div> + +<p>{{Compat("javascript.builtins.Number.parseInt")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>L'objet {{jsxref("Number")}} auquel appartient cette fonction.</li> + <li>La méthode {{jsxref("Objets_globaux/parseInt","parseInt()")}} de l'objet global.</li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/number/positive_infinity/index.html b/files/fr/web/javascript/reference/global_objects/number/positive_infinity/index.html new file mode 100644 index 0000000000..dd0d9cc01c --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/number/positive_infinity/index.html @@ -0,0 +1,100 @@ +--- +title: Number.POSITIVE_INFINITY +slug: Web/JavaScript/Reference/Objets_globaux/Number/POSITIVE_INFINITY +tags: + - JavaScript + - Number + - Propriété + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Number/POSITIVE_INFINITY +--- +<div>{{JSRef}}</div> + +<p>La propriéte <code><strong>Number.POSITIVE_INFINITY</strong></code> représente l'infini (positif).</p> + +<div>{{EmbedInteractiveExample("pages/js/number-positive-infinity.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<p>{{js_property_attributes(0,0,0)}}</p> + +<h2 id="Description">Description</h2> + +<p>La valeur de <code>Number.POSITIVE_INFINITY</code> est identique à la valeur de la propriété de l'objet global {{jsxref("Infinity")}}.</p> + +<p>Cette valeur possède un comportement légèrement différent de l'infini au sens mathématique :</p> + +<ul> + <li>Tout valeur positive, y compris <code>POSITIVE_INFINITY,</code> multipliée par <code>POSITIVE_INFINITY</code> sera égale à <code>POSITIVE_INFINITY</code>.</li> + <li>Toute valeur négative, y compris {{jsxref("Number.NEGATIVE_INFINITY", "NEGATIVE_INFINITY")}}, multipliée par <code>POSITIVE_INFINITY</code> sera égale à <code>NEGATIVE_INFINITY</code>.</li> + <li>Zéro multiplié par <code>POSITIVE_INFINITY</code> sera égal à {{jsxref("NaN")}}.</li> + <li>NaN multiplié par <code>POSITIVE_INFINITY</code> sera égal à NaN.</li> + <li><code>POSITIVE_INFINITY</code>, divisé par n'importe quelle valeur négative, à l'exception de <code>NEGATIVE_INFINITY</code>, sera égal à <code>NEGATIVE_INFINITY</code>.</li> + <li><code>POSITIVE_INFINITY</code>, divisé par n'importe quelle valeur positive, à l'exception de <code>POSITIVE_INFINITY</code>, sera égal à <code>POSITIVE_INFINITY</code>.</li> + <li><code>POSITIVE_INFINITY</code>, divisé par <code>NEGATIVE_INFINITY</code> ou <code>POSITIVE_INFINITY</code>, sera égal NaN.</li> + <li>Tout nombre positif divisé par <code>POSITIVE_INFINITY</code> sera égal au zéro positif.</li> + <li>Tout nombre négatif divisé par <code>POSITIVE_INFINITY</code> sera égal au zéro négatif.</li> +</ul> + +<p>Il est possible d'utiliser la propriété <code>Number.POSITIVE_INFINITY</code> 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.</p> + +<p><code>Number.POSITIVE_INFINITY</code> 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é.</p> + +<h2 id="Exemple">Exemple</h2> + +<h3 id="Utiliser_POSITIVE_INFINITY">Utiliser <code>POSITIVE_INFINITY</code></h3> + +<p>Dans l'exemple qui suit, on affecte une valeur plus grande que la valeur maximale à la variable <code>grosNombre</code>. Lors de l'exécution de l'instruction <code>if</code>, <code>grosNombre</code> aura la valeur <code>Infinity</code>, pour continuer, on met à jour <code>grosNombre</code> avec une valeur plus acceptable.</p> + +<pre class="brush: js">var grosNombre = Number.MAX_VALUE * 2 +if (grosNombre == Number.POSITIVE_INFINITY) { + grosNombre = renvoyerUnNombreFini(); +} +</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">Statut</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Définition initiale. Implémentée avec JavaScript 1.1.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.7.3.6', 'Number.POSITIVE_INFINITY')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-number.positive_infinity', 'Number.POSITIVE_INFINITY')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-number.positive_infinity', 'Number.POSITIVE_INFINITY')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.Number.POSITIVE_INFINITY")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Number.NEGATIVE_INFINITY")}}</li> + <li>{{jsxref("Number.isFinite()")}}</li> + <li>{{jsxref("Infinity")}}</li> + <li>{{jsxref("isFinite")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/number/toexponential/index.html b/files/fr/web/javascript/reference/global_objects/number/toexponential/index.html new file mode 100644 index 0000000000..c478bb13fd --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/number/toexponential/index.html @@ -0,0 +1,112 @@ +--- +title: Number.prototype.toExponential() +slug: Web/JavaScript/Reference/Objets_globaux/Number/toExponential +tags: + - JavaScript + - Méthode + - Number + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Number/toExponential +--- +<div>{{JSRef}}</div> + +<p>La méthode <strong><code>toExponential()</code></strong> renvoie une chaîne de caractères, représentant l'objet Number en notation exponentielle.</p> + +<div>{{EmbedInteractiveExample("pages/js/number-toexponential.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox"><var>numObj</var>.toExponential([nbChiffresDécimaux])</pre> + +<h3 id="Paramètre">Paramètre</h3> + +<dl> + <dt><code>nbChiffresDécimaux</code></dt> + <dd>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.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Une chaîne représentant l'objet {{jsxref("Number")}} appelant en notation exponentielle avec un chiffre avant la virgule et arrondi à <code>nbChiffresDécimaux</code> après la virgule.</p> + +<h3 id="Exceptions">Exceptions</h3> + +<dl> + <dt>{{jsxref("RangeError")}}</dt> + <dd>Cette exception est causée si <code>nbChiffresDécimaux</code> 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.</dd> +</dl> + +<dl> + <dt>{{jsxref("TypeError")}}</dt> + <dd>Si cette méthode est invoquée pour un objet qui n'est pas un objet <code>Number</code>.</dd> +</dl> + +<h2 id="Description">Description</h2> + +<p>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 <code>nbChiffresDécimaux</code> chiffres. Si l'argument <code>nbChiffresDécimaux </code>est absent, il y aura autant de chiffres dans la partie fractionnaire que nécessaire pour représenter le nombre de façon unique.</p> + +<p>Si la méthode <code>toExponential()</code> 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.</p> + +<p>Si un nombre possède plus de chiffres décimaux que <code>nbChiffresDécimaux</code>, le nombre est arrondi au nombre le plus proche, représenté avec <code>nbChiffresDécimaux</code> 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 <code>toExponential()</code>.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utiliser_toExponential">Utiliser <code>toExponential</code></h3> + +<pre class="brush: 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 +</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Définition initiale. Implémentée avec JavaScript 1.5.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.7.4.6', 'Number.prototype.toExponential')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-number.prototype.toexponential', 'Number.prototype.toExponential')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-number.prototype.toexponential', 'Number.prototype.toExponential')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.Number.toExponential")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Number.prototype.toFixed()")}}</li> + <li>{{jsxref("Number.prototype.toPrecision()")}}</li> + <li>{{jsxref("Number.prototype.toString()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/number/tofixed/index.html b/files/fr/web/javascript/reference/global_objects/number/tofixed/index.html new file mode 100644 index 0000000000..d1f0cd48b2 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/number/tofixed/index.html @@ -0,0 +1,116 @@ +--- +title: Number.prototype.toFixed() +slug: Web/JavaScript/Reference/Objets_globaux/Number/toFixed +tags: + - JavaScript + - Méthode + - Number + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Number/toFixed +--- +<div>{{JSRef}}</div> + +<p>La méthode <code><strong>toFixed()</strong></code> permet de formater un nombre en notation à point-fixe.</p> + +<div>{{EmbedInteractiveExample("pages/js/number-tofixed.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox"><var>numObj</var>.toFixed([nbChiffres])</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>nbChiffres</code> {{optional_inline}}</dt> + <dd>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.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Une chaîne de caractères qui représente le nombre indiqué avec une notation à point fixe.</p> + +<h3 id="Exceptions_causées">Exceptions causées</h3> + +<dl> + <dt>{{jsxref("RangeError")}}</dt> + <dd>Cette exception est renvoyée si <code>nbChiffres</code> est trop grand ou trop petit. Les valeurs comprises, au sens large, entre 0 et 100, n'entraîneront pas de <code>RangeError</code>. Les différentes implémentations peuvent ou non supporter des valeurs plus petites et/ou plus grandes.</dd> +</dl> + +<dl> + <dt>{{jsxref("TypeError")}}</dt> + <dd>Cette exception est renvoyée si cette méthode est invoquée depuis un objet qui n'est pas de type numérique.</dd> +</dl> + +<h2 id="Description">Description</h2> + +<p><code>toFixed()</code> renvoie une chaîne de caractères représentant <code>objetNumber</code> sans notation exponentielle et qui possède exactement <code>nbChiffres</code> 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 <code>objetNumber</code> est supérieur ou égal à <code>1e+21</code>, la méthode utilise simplement {{jsxref("Number.prototype.toString()")}} et renvoie une chaîne en notation exponentielle.</p> + +<div class="warning"> +<p><strong>Attention !</strong> En raison du standard <a href="https://fr.wikipedia.org/wiki/IEEE_754">IEEE 754</a> 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 <code>0.1 + 0.2 === 0.3</code> qui renvoie <code>false</code>).</p> +</div> + +<h2 id="Exemples">Exemples</h2> + +<pre class="brush: js">var numObj = 12345.6789; + +numObj.toFixed(); // Renvoie '12346' : arrondi, aucune partie fractionnaire +numObj.toFixed(1); // Renvoie '12345.7' : arrondi ici aussi +numObj.toFixed(6); // Renvoie '12345.678900' : des zéros sont ajoutés +(1.23e+20).toFixed(2); // Renvoie '123000000000000000000.00' +(1.23e-10).toFixed(2); // Renvoie '0.00' +2.34.toFixed(1); // Renvoie '2.3' +-2.34.toFixed(1); // Renvoie -2.3 (en raison de la précédence des opérateurs, + // les littéraux de nombres négatifs ne renvoient pas de chaînes) +2.35.toFixed(1); // Renvoie '2.4' (arrondi supérieur) +2.55.toFixed(1); // Renvoie '2.5' (cf. l'avertissement ci-avant) +(-2.34).toFixed(1); // Renvoie '-2.3' +</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Définition initiale. Implémentée avec JavaScript 1.5.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.7.4.5', 'Number.prototype.toFixed')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-number.prototype.tofixed', 'Number.prototype.toFixed')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-number.prototype.tofixed', 'Number.prototype.toFixed')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.Number.toFixed")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Number.prototype.toExponential()")}}</li> + <li>{{jsxref("Number.prototype.toPrecision()")}}</li> + <li>{{jsxref("Number.prototype.toString()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/number/tolocalestring/index.html b/files/fr/web/javascript/reference/global_objects/number/tolocalestring/index.html new file mode 100644 index 0000000000..d05294de7a --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/number/tolocalestring/index.html @@ -0,0 +1,197 @@ +--- +title: Number.prototype.toLocaleString() +slug: Web/JavaScript/Reference/Objets_globaux/Number/toLocaleString +tags: + - Internationalisation + - JavaScript + - Méthode + - Number + - Prototype + - Reference + - i18n +translation_of: Web/JavaScript/Reference/Global_Objects/Number/toLocaleString +--- +<div>{{JSRef}}</div> + +<p>La méthode <code><strong>toLocaleString()</strong></code> permet de renvoyer une chaîne de caractères représentant un nombre en tenant compte de la locale.</p> + +<div>{{EmbedInteractiveExample("pages/js/number-tolocalestring.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<p>Les arguments <code>locales</code> et <code>options</code> 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 <code>locales</code> et <code>options</code> se basaient uniquement sur l'implémentation pour ce qui concernait la locale et le format.</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox">objetNumber.toLocaleString([locales [, options]])</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<p>Voir la section <a href="#compat" title="#Browser_Compatibility">compatibilité des navigateurs</a> afin de voir quels navigateurs supportent les arguments <code>locales</code> et <code>options</code>. L'exemple <a href="#check">Vérifier le support des arguments <code>locales</code> et <code>options</code></a> permet de détecter cette fonctionnalité.</p> + +<div class="note"> +<p><strong>Note :</strong> L'API ECMAScript Internationalization, implémentée avec Firefox 29, a ajouté l'argument <code>locales</code> à la méthode <a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Number/toLocaleString"><code>Number.toLocaleString</code></a>. Si l'argument vaut <code>undefined</code>,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)}}).</p> +</div> + +<p>{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/NumberFormat','Paramètres')}}</p> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Une chaîne de caractères qui représente le nombre indiqué en tenant compte de la locale.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utiliser_toLocaleString()">Utiliser <code>toLocaleString()</code></h3> + +<p>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.</p> + +<pre class="brush: js">var nombre = 3500; + +console.log(nombre.toLocaleString()); // Affichera "3 500" pour la locale française +</pre> + +<h3 id="Vérifier_le_support_des_arguments_locales_et_options"><a id="check" name="check">Vérifier le support des arguments <code>locales</code> et <code>options</code></a></h3> + +<p>Les arguments <code>locales</code> et <code>options</code> 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")}} :</p> + +<pre class="brush: js">function testSupporttoLocaleString() { + var nombre = 0; + try { + nombre.toLocaleString("i"); + } catch (e) { + return e.name === "RangeError"; + } + return false; +} +</pre> + +<p>Avant ES5.1, il n'était pas nécessaire pour les implémentations de provoquer une erreur d'intervalle si <code>toLocaleString</code> était appelé avec des arguments.</p> + +<p>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 <code>Number.prototype.toLocaleString</code> :</p> + +<pre class="brush: js">function toLocaleStringSupportsOptions() { + return !!(typeof Intl == 'object' && Intl && typeof Intl.NumberFormat == 'function'); +} +</pre> + +<p>Cela permet de tester la présence d'un objet global <code>Intl</code>, de vérifier que celui-ci n'est pas <code>null</code> et qu'il a une méthode <code>NumberFormat</code>.</p> + +<h3 id="Utiliser_l'argument_locales">Utiliser l'argument <code>locales</code></h3> + +<p>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 <code>locales</code> :</p> + +<pre class="brush: 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 +console.log(nombre.toLocaleString("de-DE")); +// → 123.456,789 + +// Les locales arabes, dans la plupart des pays arabophones, utilisent +// les chiffres arabes +console.log(nombre.toLocaleString("ar-EG")); +// → ١٢٣٤٥٦٫٧٨٩ + +// En Inde, on utilise des séparateurs de milliers/lakh/crore +console.log(nombre.toLocaleString("en-IN")); +// → 1,23,456.789 + +// La clé d'extension nu indique un système numérique, ici le système chinois décimal +console.log(nombre.toLocaleString("zh-Hans-CN-u-nu-hanidec")); +// → 一二三,四五六.七八九 + +// quand on souhaite utiliser un langage qui n'est pas supporté, on peut +// inclure un langage de secours. Exemple ici avec le balinais et l'indonésien +console.log(nombre.toLocaleString(["ban", "id"])); +// → 123.456,789 +</pre> + +<h3 id="Utiliser_l'argument_options">Utiliser l'argument <code>options</code></h3> + +<p>Les résultats fournis par <code>toLocaleString</code> peuvent être déclinés en utilisant l'argument <code>options</code> :</p> + +<pre class="brush: js">var nombre = 123456.789; + +// on formate selon une devise +console.log(nombre.toLocaleString("de-DE", {style: "currency", currency: "EUR"})); +// → 123.456,79 € + +// le yen japonais ne possède pas de centimes +console.log(nombre.toLocaleString("ja-JP", {style: "currency", currency: "JPY"})) +// → ￥123,457 + +// on se limite à trois chiffres significatifs +console.log(nombre.toLocaleString("en-IN", {maximumSignificantDigits: 3})); +// → 1,23,000 + +// on utilise la langue du système pour la mise en +// forme des nombres +var num = 30000.65; +console.log(num.toLocaleString(undefined, {minimumFractionDigits: 2, maximumFractionDigits: 2})); +// → "30,000.65" quand l'anglais est la langue par défaut +// → "30.000,65" quand l'allemand est la langue par défaut +// → "30 000,65" quand le français est la langue par défaut +</pre> + +<h2 id="Performance">Performance</h2> + +<p>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")}}.</p> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Définition initiale. Implémentée avec JavaScript 1.5.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.7.4.3', 'Number.prototype.toLocaleString')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-number.prototype.tolocalestring', 'Number.prototype.toLocaleString')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-number.prototype.tolocalestring', 'Number.prototype.toLocaleString')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES Int 1.0', '#sec-13.2.1', 'Number.prototype.toLocaleString')}}</td> + <td>{{Spec2('ES Int 1.0')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES Int 2.0', '#sec-13.2.1', 'Number.prototype.toLocaleString')}}</td> + <td>{{Spec2('ES Int 2.0')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES Int Draft', '#sec-Number.prototype.toLocaleString', 'Number.prototype.toLocaleString')}}</td> + <td>{{Spec2('ES Int Draft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.Number.toLocaleString")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Number.prototype.toString()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/number/toprecision/index.html b/files/fr/web/javascript/reference/global_objects/number/toprecision/index.html new file mode 100644 index 0000000000..236a7bb51e --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/number/toprecision/index.html @@ -0,0 +1,105 @@ +--- +title: Number.prototype.toPrecision() +slug: Web/JavaScript/Reference/Objets_globaux/Number/toPrecision +tags: + - JavaScript + - Méthode + - Number + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Number/toPrecision +--- +<div>{{JSRef}}</div> + +<p>La méthode <code><strong>toPrecision()</strong></code> renvoie une chaîne de caractères représentant un nombre avec la précision donnée.</p> + +<div>{{EmbedInteractiveExample("pages/js/number-toprecision.html")}}</div> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox"><var>numObj</var>.toPrecision([<var>pré</var><var>cision</var>])</pre> + +<h3 id="Paramètre">Paramètre</h3> + +<dl> + <dt><code>précision</code></dt> + <dd>Paramètre optionnel. Un entier spécifiant le nombre de chiffres significatifs.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>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 à <code>précision</code>. Le principe utilisé pour les arrondis est celui décrit dans la page de la méthode {{jsxref("Number.prototype.toFixed()")}}.</p> + +<p>Si l'argument <code>précision</code> 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.</p> + +<h3 id="Exceptions">Exceptions</h3> + +<dl> + <dt>{{jsxref("RangeError")}}</dt> + <dd>Si <code>précison</code> n'est pas compris, au sens large, entre 1 et 100, on aura une exception <code>RangeError</code>. 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.</dd> +</dl> + +<h2 id="Exemples">Exemples</h2> + +<pre class="brush: 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" +console.log(objetNumber.toPrecision(1)); //affiche "5" + +numObj = 0.000123; + +console.log(numObj.toPrecision()); // affiche "0.000123" +console.log(numObj.toPrecision(5)); // affiche "0.00012300" +console.log(numObj.toPrecision(2)); // affiche "0.00012" +console.log(numObj.toPrecision(1)); // affiche "0.0001" + +// dans certaines circonstances, on peut avoir une notation exponentielle +console.log((1234.5).toPrecision(2)); // "1.2e+3" +</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Définition initiale. Implémentée avec JavaScript 1.5.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.7.4.7', 'Number.prototype.toPrecision')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-number.prototype.toprecision', 'Number.prototype.toPrecision')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-number.prototype.toprecision', 'Number.prototype.toPrecision')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.Number.toPrecision")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Number.prototype.toFixed()")}}</li> + <li>{{jsxref("Number.prototype.toExponential()")}}</li> + <li>{{jsxref("Number.prototype.toString()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/number/tosource/index.html b/files/fr/web/javascript/reference/global_objects/number/tosource/index.html new file mode 100644 index 0000000000..da204d2ea4 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/number/tosource/index.html @@ -0,0 +1,57 @@ +--- +title: Number.prototype.toSource() +slug: Web/JavaScript/Reference/Objets_globaux/Number/toSource +tags: + - JavaScript + - Méthode + - Number + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Number/toSource +--- +<div>{{JSRef}} {{non-standard_header}}</div> + +<p>La méthode <code><strong>toSource()</strong></code> permet de renvoyer une chaîne de caractère représentant le code source de l'objet.</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox">objetNumber.toSource(); +Number.toSource(); +</pre> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Une chaîne de caractères représentant le code source de l'objet.</p> + +<h2 id="Description">Description</h2> + +<p>La méthode <code>toSource()</code> renvoie les valeurs suivantes :</p> + +<ul> + <li>Pour l'objet natif {{jsxref("Number")}}, <code>toSource()</code> renvoie la chaîne suivante, indiquant que le code source n'est pas disponible : + + <pre class="brush: js">function Number() { + [native code] +} +</pre> + </li> + <li>Pour les instances de {{jsxref("Number")}}, <code>toSource()</code> renvoie une chaîne représentant le code source de l'objet.</li> +</ul> + +<p>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.</p> + +<h2 id="Spécifications">Spécifications</h2> + +<p>Cette méthode ne fait partie d'aucun standard. Elle a été implémentée avec JavaScript 1.3.</p> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.Number.toSource")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Object.prototype.toSource()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/number/tostring/index.html b/files/fr/web/javascript/reference/global_objects/number/tostring/index.html new file mode 100644 index 0000000000..d7f9af286e --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/number/tostring/index.html @@ -0,0 +1,120 @@ +--- +title: Number.prototype.toString() +slug: Web/JavaScript/Reference/Objets_globaux/Number/toString +tags: + - JavaScript + - Méthode + - Number + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Number/toString +--- +<div>{{JSRef}}</div> + +<p>La méthode <code><strong>toString()</strong></code> renvoie une chaîne de caractère représentant l'objet Number.</p> + +<div>{{EmbedInteractiveExample("pages/js/number-tostring.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox"><var>numObj</var>.toString([base])</pre> + +<h3 id="Paramètre">Paramètre</h3> + +<dl> + <dt><code>base</code></dt> + <dd>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.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Une chaîne de caractères représentant l'objet {{jsxref("Number")}}.</p> + +<h3 id="Exception">Exception</h3> + +<dl> + <dt>{{jsxref("RangeError")}}</dt> + <dd> + <p>Si <code>toString()</code> reçoit une base qui n'est pas comprise entre 2 et 36, une exception <code>RangeError</code> est levée.</p> + </dd> +</dl> + +<h2 id="Description">Description</h2> + +<p>L'objet {{jsxref("Number")}} surcharge la méthode <code>toString()</code> de {{jsxref("Object")}} et n'hérite donc pas de {{jsxref("Object.prototype.toString()")}}. Pour les objets <code>Number</code>, la méthode <code>toString()</code> renvoie une représentation du nombre, dans une base donnée, en une chaîne de caractères.</p> + +<p>La méthode <code>toString()</code> 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 <code>a</code> à <code>f</code> sont utilisées.</p> + +<p>Si la base n'est pas spécifiée, on utilisera la base 10 par défaut.</p> + +<p>Si l'objet <code>Number</code> 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 <strong>n'est pas</strong> le complément à deux du nombre.</p> + +<p>Si l'objet <code>Number</code> n'est pas un nombre entier, le point (.) sera utilisé pour séparer la partie entière et décimale.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utiliser_toString">Utiliser <code>toString</code></h3> + +<pre class="brush:js">var compte = 10; + +console.log(compte.toString()); // affiche "10" +console.log((17).toString()); // affiche "17" +console.log((17.2).toString()); // affiche "17.2" + +var x = 6; + +console.log(x.toString(2)); // affiche "110" +console.log((254).toString(16)); // affiche "fe" + + +console.log((-10).toString(2)); // affiche "-1010" +console.log((-0xff).toString(2)); // affiche "-11111111" +</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Définition initiale. Implémentée par JavaScript 1.1.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.7.4.2', 'Number.prototype.tostring')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-number.prototype.tostring', 'Number.prototype.tostring')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-number.prototype.tostring', 'Number.prototype.tostring')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.Number.toString")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Number.prototype.toFixed()")}}</li> + <li>{{jsxref("Number.prototype.toExponential()")}}</li> + <li>{{jsxref("Number.prototype.toPrecision()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/global_objects/number/valueof/index.html b/files/fr/web/javascript/reference/global_objects/number/valueof/index.html new file mode 100644 index 0000000000..ad57b1599c --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/number/valueof/index.html @@ -0,0 +1,86 @@ +--- +title: Number.prototype.valueOf() +slug: Web/JavaScript/Reference/Objets_globaux/Number/valueOf +tags: + - JavaScript + - Méthode + - Number + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Number/valueOf +--- +<div>{{JSRef}}</div> + +<p>La méthode <code><strong>valueOf()</strong></code> renvoie la valeur primitive correspondant à celle représentée par l'objet {{jsxref("Number")}}.</p> + +<div>{{EmbedInteractiveExample("pages/js/number-valueof.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox"><var>objetNumber</var>.valueOf()</pre> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Un nombre qui représente la valeur primitive de l'objet {{jsxref("Number")}}.</p> + +<h2 id="Description">Description</h2> + +<p>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.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utiliser_valueOf">Utiliser <code>valueOf</code></h3> + +<pre class="brush:js">var numObj = new Number(10); +console.log(typeof numObj); // object + +var num = numObj.valueOf(); +console.log(num); // 10 +console.log(typeof num); // number +</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Définition initiale. Implémentée avec JavaScript 1.1.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.7.4.4', 'Number.prototype.valueOf')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-number.prototype.valueof', 'Number.prototype.valueOf')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-number.prototype.valueof', 'Number.prototype.valueOf')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.Number.valueOf")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Number.prototype.toSource()")}}</li> +</ul> |