diff options
Diffstat (limited to 'files/fr/web/javascript/reference/objets_globaux/bigint')
7 files changed, 789 insertions, 0 deletions
diff --git a/files/fr/web/javascript/reference/objets_globaux/bigint/asintn/index.html b/files/fr/web/javascript/reference/objets_globaux/bigint/asintn/index.html new file mode 100644 index 0000000000..8e51d25642 --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/bigint/asintn/index.html @@ -0,0 +1,76 @@ +--- +title: BigInt.asIntN() +slug: Web/JavaScript/Reference/Objets_globaux/BigInt/asIntN +tags: + - BigInt + - JavaScript + - Méthode + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/BigInt/asIntN +--- +<p>{{JSRef}}</p> + +<p>La méthode statique <strong><code>BigInt.asIntN()</code></strong> permet d'écréter un nombre <code>BigInt</code> pour obtenir un entier signé entre 2<sup>largeur-1</sup> et 2<sup>largeur-1</sup>-1.</p> + +<div>{{EmbedInteractiveExample("pages/js/bigint-asintn.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">var <var>resultat</var> = BigInt.asIntN(<var>largeur</var>, <var>bigint</var>);</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>largeur</code></dt> + <dd>La quantité de bits disponible pour stocker l'entier.</dd> + <dt><code>bigint</code></dt> + <dd>L'entier qu'on souhaite stocker sur le nombre de bits indiqués.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>La valeur de <code>bigint</code> modulo 2<sup><code>largeur</code></sup> comme entier signé.</p> + +<h2 id="Exemples">Exemples</h2> + +<p>La méthode <code>BigInt.asIntN()</code> peut être utile pour rester dans une arithmétique sur 64 bits :</p> + +<pre class="brush: js">const max = 2n ** (64n - 1n) - 1n; + +BigInt.asIntN(64, max); +// ↪ 9223372036854775807n + +BigInt.asIntN(64, max + 1n); +// ↪ -9223372036854775807n +// négatif car dépassement sur le nombre de bits +</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> + </tr> + <tr> + <td><a href="https://tc39.github.io/proposal-bigint/#sec-bigint.asintn">BigInt proposal</a></td> + <td>Proposition de niveau 3.</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 à consulter <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> et à nous envoyer une <em>pull request</em>.</div> + +<p>{{Compat("javascript.builtins.BigInt.asIntN")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{JSxRef("BigInt")}}</li> + <li>{{JSxRef("BigInt.asUintN()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/bigint/asuintn/index.html b/files/fr/web/javascript/reference/objets_globaux/bigint/asuintn/index.html new file mode 100644 index 0000000000..742792d5e6 --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/bigint/asuintn/index.html @@ -0,0 +1,76 @@ +--- +title: BigInt.asUintN() +slug: Web/JavaScript/Reference/Objets_globaux/BigInt/asUintN +tags: + - BigInt + - Experimental + - JavaScript + - Méthode + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/BigInt/asUintN +--- +<p>{{JSRef}}</p> + +<p>La méthode statique <strong><code>BigInt.asUintN()</code></strong> permet d'écréter un <code>BigInt</code> pour ramener sa valeur sur un entier non-signé entre 0 et 2<sup>largeur</sup>-1.</p> + +<div>{{EmbedInteractiveExample("pages/js/bigint-asuintn.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">var <var>résultat</var> = BigInt.asUintN(<var>largeur</var>, <var>bigint</var>);</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>largeur</code></dt> + <dd>Le nombre de bits disponible pour stocker l'entier.</dd> + <dt><code>bigint</code></dt> + <dd>L'entier qu'on souhaite stocker sur le nombre de bits indiqués.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>La valeur de <code>bigint</code> modulo 2<sup><code>largeur</code></sup> comme un entier non signé.</p> + +<h2 id="Exemples">Exemples</h2> + +<p>La méthode <code>BigInt.asUintN()</code> peut s'avérer utile pour rester dans une arithmétique exprimée sur 64 bits .</p> + +<pre class="brush: js">const max = 2n ** 64n - 1n; + +BigInt.asUintN(64, max); +// ↪ 18446744073709551615n + +BigInt.asUintN(64, max + 1n); +// ↪ 0n +// zéro en raison du dépassement</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> + </tr> + <tr> + <td><a href="https://tc39.github.io/proposal-bigint/#sec-bigint.asuintn">Proposition pour BigInt</a></td> + <td>Proposition de niveau 3</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 à consulter <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> et à nous envoyer une <em>pull request</em>.</div> + +<p>{{Compat("javascript.builtins.BigInt.asUintN")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{JSxRef("BigInt")}}</li> + <li>{{JSxRef("BigInt.asIntN()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/bigint/index.html b/files/fr/web/javascript/reference/objets_globaux/bigint/index.html new file mode 100644 index 0000000000..1310b8c442 --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/bigint/index.html @@ -0,0 +1,283 @@ +--- +title: BigInt +slug: Web/JavaScript/Reference/Objets_globaux/BigInt +tags: + - BigInt + - Experimental + - JavaScript + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/BigInt +--- +<div>{{JSRef}}</div> + +<p><strong><code>BigInt</code></strong> est un objet natif qui permet de représenter des nombres entiers supérieurs à 2<sup>53</sup> (la plus grande valeur entière qui puisse être représentée par le type primitif {{jsxref("Number")}}). <code>BigInt</code> peut être utilisé afin de représenter de grands entiers de n'importe quelle taille.</p> + +<div class="blockIndicator note"> +<p><strong>Note :</strong> BigInt est actuellement une <strong>proposition de niveau 3</strong> pour la <a href="#Spécifications">spécification</a> ECMAScript.</p> + +<p>Lorsque cette proposition atteindra le niveau 4 (soit la spécification finale), BigInt sera le deuxième type natif disponible en JavaScript pour représenter des valeurs numériques.</p> + +<p><strong><code>BigInt</code></strong> sera ainsi le prochain type primitif ajouté à JavaScript depuis {{JSxRef("Symbol")}} avec ES2015</p> +</div> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox">BigInt(valeur); +</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>valeur</code></dt> + <dd>La valeur numérique de l'objet qu'on souhaite créer. Cet argument peut être une chaîne de caractères ou un entier.</dd> +</dl> + +<div class="blockIndicator note"> +<p><strong>Note :</strong> <code>BigInt()</code> n'est pas censé être utilisé avec l'opérateur {{jsxref("Opérateurs/L_opérateur_new", "new")}}.</p> +</div> + +<dl> +</dl> + +<h2 id="Description">Description</h2> + +<p>Un objet <code>BigInt</code> est créé en ajoutant un <code>n</code> à la fin d'un littéral d'entier — <code>10n</code> par exemple — ou en appelant la fonction <code>BigInt()</code>.</p> + +<pre class="brush: js">const plusGrandEntier = 9007199254740991n; + +const grandNombre = BigInt(9007199254740991); +// ↪ 9007199254740991n + +const grandNombreEnChaîne = BigInt('9007199254740991'); +// ↪ 9007199254740991n + +const grandeNombreHexa = BigInt("0x1fffffffffffff"); +// ↪ 9007199254740991n + +const grandeNombreBinaire = BigInt("<code class="language-js"><span class="string token">0b11111111111111111111111111111111111111111111111111111</span></code>"); +// ↪ 9007199254740991n</pre> + +<p>Les objets <code>BigInt</code> sont semblables aux objets {{jsxref("Number")}} selon certains aspects mais avec quelques différences clés. Les objets <code>BigInt</code> ne peuvent pas êre utilisés avec l'objet {{jsxref("Math")}} et ne peuvent pas être manipulés avec des opérations qui impliquent des objets {{jsxref("Number")}}.</p> + +<div class="blockIndicator warning"> +<p><strong>Attention !</strong> Il est nécessaire de convertir des valeurs {{jsxref("Number")}} ou <code>BigInt</code> dans les opérations qui les combinent.</p> + +<p>Attention lors de ces conversions car la précision d'une valeur <code>BigInt</code> peut être perdue lorsque ce dernier est converti en {{jsxref("Number")}}.</p> +</div> + +<h3 id="Type">Type</h3> + +<p>Lorsqu'on utilise <code>typeof</code> sur une valeur <code>BigInt</code>, cet opérateur renverra <code>"bigint"</code> :</p> + +<pre class="brush: js">typeof 1n === "bigint"; // true +typeof BigInt("1") === "bigint"; // true</pre> + +<p>Lorsqu'on « enveloppe » la valeur dans un objet, on aura alors un type <code>"object"</code> (comme pour les autres valeurs primitives lorsqu'on les enveloppe dans le constructeur objet) :</p> + +<pre class="brush: js">typeof Object(1n) === "object"; // true</pre> + +<h3 id="Opérateurs">Opérateurs</h3> + +<p>On peut utiliser les opérateurs suivants avec les objets <code>BigInt</code> : <code>+</code>, `<code>*</code>`, `<code>-</code>`, `<code>**</code>`, `<code>%</code>` , <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_binaires">les opérateurs binaires</a> (à l'exception de <code>>>></code> / décalage à droite avec des zéros) car les grands entiers sont signés. Le <code>+</code> unaire n'est pas non plus pris en charge (afin de <a href="https://github.com/tc39/proposal-bigint/blob/master/ADVANCED.md#dont-break-asmjs">ne pas casser asm.js</a>).</p> + +<pre class="brush: js">const nombreSain = BigInt(Number.MAX_SAFE_INTEGER); +// ↪ 9007199254740991 + +const maxPlusUn = nombreSain + 1n; +// ↪ 9007199254740992n + +const leFutur = nombreSain + 2n; +// ↪ 9007199254740993n, cela fonctionne désormais ! + +const multi = nombreSain * 2n; +// ↪ 18014398509481982n + +const subtr = multi – 10n; +// ↪ 18014398509481972n + +const mod = multi % 10n; +// ↪ 2n + +const bigN = 2n ** 54n; +// ↪ 18014398509481984n + +bigN * -1n +// ↪ –18014398509481984n +</pre> + +<p>L'opérateur <code>/</code> fonctionne de façon analogue aux nombres classiques. Toutefois, les objets <code>BigInt</code> permettent uniquement de représenter des entiers et non des nombres décimaux. Aussi, la division ne produira pas de partie décimale pour les <code>BigInt</code>.</p> + +<pre class="brush: js">const attendu = 4n / 2n; +// ↪ 2n + +const tronque = 5n / 2n; +// ↪ 2n et pas 2.5n + +</pre> + +<h3 id="Comparaisons">Comparaisons</h3> + +<p>Un objet <code>BigInt</code> n'est pas strictement égal à {{jsxref( "Number")}} mais peut l'être au sens de l'égalité faible.</p> + +<pre class="brush: js">0n === 0 +// ↪ false + +0n == 0 +// ↪ true</pre> + +<p>On peut toutefois comparer des objets {{jsxref("Number")}} et <code>BigInt</code> :</p> + +<pre class="brush: js">1n < 2 +// ↪ true + +2n > 1 +// ↪ true + +2 > 2 +// ↪ false + +2n > 2 +// ↪ false + +2n >= 2 +// ↪ true</pre> + +<p>On peut également mélanger ces valeurs au sein de tableaux :</p> + +<pre class="brush: js">const mixed = [4n, 6, -12n, 10, 4, 0, 0n]; +// ↪ [4n, 6, -12n, 10, 4, 0, 0n] + +mixed.sort(); +// ↪ [-12n, 0, 0n, 10, 4n, 4, 6]</pre> + +<p>On notera que les comparaisons entre les valeurs <code>BigInt</code> et les mêmes valeurs, passées dans le constructeur <code>Object()</code> ne seront pas équivalentes au sens strict :</p> + +<pre class="brush: js">0n === Object(0n); // false +Object(0n) === Object(0n); // false + +const o = Object(0n); +o === o; // true</pre> + +<h3 id="Opérations_conditionnelles">Opérations conditionnelles</h3> + +<p>Un objet <code>BigInt</code> se comporte comme un objet {{jsxref("Number")}} lorsqu'il est utilisé dans un contexte booléen : comme argument pour le constructeur {{jsxref("Boolean")}}, comme opérandes pour les opérateurs logiques <code>||</code>, `<code>&&</code>` et <code>!</code> ou avec les instructions conditonnelles telles que <code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/if...else">if</a></code>.</p> + +<pre class="brush: js">if (0n) { + console.log('Nous voici dans le if !'); +} else { + console.log('Et nous voilà dans le else !'); +} + +// ↪ "Et nous voilà dans le else !" + +0n || 12n +// ↪ 12n + +0n && 12n +// ↪ 0n + +Boolean(0n) +// ↪ false + +Boolean(12n) +// ↪ true + +!12n +// ↪ false + +!0n +// ↪ true +</pre> + +<h2 id="Méthodes">Méthodes</h2> + +<dl> + <dt><strong><code>BigInt.asIntN()</code></strong></dt> + <dd>Écrète un objet <code>BigInt</code> pour obtenir un entier signé entre -2<sup>largeur-1</sup> et 2<sup>largeur-1</sup>-1</dd> + <dt><code>BigInt.asUintN()</code></dt> + <dd>Écrète un objet <code>BigInt</code> pour obtenir un entier non-signé entre 0 et 2<sup>largeur</sup>-1</dd> +</dl> + +<h2 id="Propriétés">Propriétés</h2> + +<dl> + <dt>{{jsxref("BigInt.prototype")}}</dt> + <dd><span style="letter-spacing: -0.00278rem;">Cette propriété permet d'ajouter des propriétés aux objets </span><code style="letter-spacing: -0.00278rem;">BigInt</code><span style="letter-spacing: -0.00278rem;">.</span></dd> +</dl> + +<h2 id="Instances_de_BigInt">Instances de <code>BigInt</code></h2> + +<p>L'ensemble des instances de <code>BigInt</code> héritent de <font face="consolas, Liberation Mono, courier, monospace"><span style="background-color: rgba(220, 220, 220, 0.5);">BigInt.prototype</span></font>. Le prototype du constructeur <font face="consolas, Liberation Mono, courier, monospace"><span style="background-color: rgba(220, 220, 220, 0.5);">BigInt</span></font> peut être modifié afin de modifier l'ensemble des instances de <code>BigInt</code>.</p> + +<h3 id="Méthodes_2">Méthodes</h3> + +<p>{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/BigInt/prototype', 'Méthodes')}}</p> + +<h2 id="Recommandations">Recommandations</h2> + +<h3 id="Coercition_en_Number">Coercition en <code>Number</code></h3> + +<p>Lorsqu'on convertit une valeur <code>BigInt</code> en {{jsxref("Objets_globaux/Number","Number")}}, on perd en précision. Si on effectue des allers-retours entre ces deux types, on ne conservera pas la même valeur. Aussi, il est recommandé d'utiliser uniquement <code>BigInt</code> lorsque les valeurs qu'on manipule seront supérieures à 2<sup>53</sup> et qu'il ne sera pas nécessaire de passer d'un type à l'autre.</p> + +<h3 id="Cryptographie">Cryptographie</h3> + +<p>Les opérations prises en charge pour les valeurs <code>BigInt</code> ne s'effectuent pas à temps constant. Aussi, <code>BigInt</code> ne serait être utilisé à <a href="https://www.chosenplaintext.ca/articles/beginners-guide-constant-time-cryptography.html">des fins cryptographiques</a>.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Calculer_des_nombres_premiers">Calculer des nombres premiers</h3> + +<pre class="brush: js">function isPrime(p) { + for (let i = 2n; i * i <= p; i++) { + if (p % i === 0n) return false; + } + return true; +} + +// Takes a BigInt as an argument and returns a BigInt +function nthPrime(nth) { + let maybePrime = 2n; + let prime = 0n; + + while (nth >= 0n) { + if (isPrime(maybePrime)) { + nth -= 1n; + prime = maybePrime; + } + maybePrime += 1n; + } + + return prime; +} + +nthPrime(20n) +// ↪ 73n</pre> + +<h2 id="Spécifications_2"><a id="Spécifications" name="Spécifications">Spécifications</a></h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + </tr> + </thead> + <tbody> + <tr> + <td><code><a href="https://tc39.es/proposal-bigint/#sec-bigint-objects">BigInt</a></code></td> + <td>Brouillon de niveau 3</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 à consulter <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> et à nous envoyer une <em>pull request</em>.</div> + +<p>{{Compat("javascript.builtins.BigInt")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Number")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/bigint/prototype/index.html b/files/fr/web/javascript/reference/objets_globaux/bigint/prototype/index.html new file mode 100644 index 0000000000..e746754e5e --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/bigint/prototype/index.html @@ -0,0 +1,63 @@ +--- +title: BigInt.prototype +slug: Web/JavaScript/Reference/Objets_globaux/BigInt/prototype +tags: + - BigInt + - JavaScript + - Propriété + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/BigInt/prototype +--- +<div>{{JSRef}}</div> + +<p>La propriété <strong><code>BigInt.prototype</code></strong> représente le prototype du constructeur {{jsxref("BigInt")}}.</p> + +<p>{{js_property_attributes(0, 0, 0)}}</p> + +<h2 id="Description">Description</h2> + +<p>L'ensemble des instances de {{jsxref("BigInt")}} héritent de <code>BigInt.prototype</code>. Le prototype du constructeur {{jsxref("BigInt")}} peut être modifié afin de modifier l'ensemble des instances de {{jsxref( "BigInt")}}.</p> + +<h2 id="Propriétés">Propriétés</h2> + +<dl> + <dt><code>BigInt.prototype.constructor</code></dt> + <dd>Cette propriété renvoie la fonction qui a crée cette instance. Par défaut, c'est l'objet {{jsxref("BigInt")}}.</dd> +</dl> + +<h2 id="Méthodes">Méthodes</h2> + +<dl> + <dt>{{jsxref("BigInt.prototype.toLocaleString()")}}</dt> + <dd>Cette méthode renvoie une chaîne de caractères représentant le nombre et adaptée à la locale choisie. Cette méthode surcharge la méthode {{jsxref("Object.prototype.toLocaleString()")}}.</dd> + <dt>{{jsxref("BigInt.prototype.toString()")}}</dt> + <dd>Cette méthode renvoie une chaîne de caractères représentant l'objet selon la base indiquée. Cette méthode surcharge la méthode {{jsxref("Object.prototype.toString()")}}.</dd> + <dt>{{jsxref("BigInt.prototype.valueOf()")}}</dt> + <dd>Cette méthode renvoie la valeur primitive de l'objet indiqué. Cette méthode surcharge la méthode {{jsxref("Object.prototype.valueOf()")}}.</dd> +</dl> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Spécification</th> + <th scope="col">Etat</th> + <th scope="col">Commentaires</th> + </tr> + </thead> + <tbody> + <tr> + <td><a href="https://tc39.github.io/proposal-bigint/#sec-bigint.prototype">BigInt.prototype</a></td> + <td>Brouillon de niveau 3</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 à consulter <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> et à nous envoyer une <em>pull request</em>.</div> + +<p>{{Compat("javascript.builtins.BigInt.prototype")}}</p> diff --git a/files/fr/web/javascript/reference/objets_globaux/bigint/tolocalestring/index.html b/files/fr/web/javascript/reference/objets_globaux/bigint/tolocalestring/index.html new file mode 100644 index 0000000000..652cd723aa --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/bigint/tolocalestring/index.html @@ -0,0 +1,132 @@ +--- +title: BigInt.prototype.toLocaleString() +slug: Web/JavaScript/Reference/Objets_globaux/BigInt/toLocaleString +tags: + - BigInt + - Internationalisation + - Intl + - JavaScript + - Méthode + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/BigInt/toLocaleString +--- +<div>{{JSRef}}</div> + +<p>La méthode <strong><code>toLocaleString()</code></strong> renvoie une chaîne de caractères représentant le grand entier pour la ou les locale(s) indiquée(s).</p> + +<div>{{EmbedInteractiveExample("pages/js/bigint-tolocalestring.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"><code><em>bigIntObj</em>.toLocaleString(</code><code>[locales [, options]])</code></pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>locales</code> {{optional_inline}}</dt> + <dd>Une chaine de caractères avec un identifiant de langue BCP 47, ou un tableau de ce type de chaine de caractères. Pour le format général et l'interprétation de l'argument <code>locales</code>. Pour plus de détails quant à la forme et l'interprétation de l'argument <code>locales</code>, on consultera la page {{jsxref("Intl")}}.</dd> + <dt><code>options</code> {{optional_inline}}</dt> + <dd>Un objet qui contient des propriétés de configuration. Pour les nombres, consulter {{jsxref("Number.prototype.toLocaleString()")}}, pour les dates, consulter {{jsxref("Date.prototype.toLocaleString()")}}.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Une chaîne de caractères qui représente le grand entier selon la ou les locales et les options indiquées.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utiliser_toLocaleString()">Utiliser <code>toLocaleString()</code></h3> + +<p>Voici un exemple d'utilisation simple, sans indiquer de locale ni d'options.</p> + +<pre class="brush: js">var bigint = 3500n; + +bigint.toLocaleString(); +// Affichera "3500" en français +</pre> + +<h3 id="Utiliser_locales">Utiliser <code>locales</code></h3> + +<p>Cet exemple illustre certaines variations pour la représentation d'une même valeur en fonction des différentes locales. En fonction de la langue utilisée par l'utilisateur et par votre interface, vous pourrez utiliser <code>locales</code> pour indiquer la locale ciblée :</p> + +<pre class="brush: js">var bigint = 123456789123456789n; + +// En allemand, on utilise les points pour séparer +// les milliers +console.log(bigint.toLocaleString('de-DE')); +// → 123.456.789.123.456.789 + +// La plupart des pays arabes utilise +// des chiffres <a href="https://en.wikipedia.org/wiki/Eastern_Arabic_numerals">hindoux-arabes</a> +console.log(bigint.toLocaleString('ar-EG')); +// → ١٢٣٬٤٥٦٬٧٨٩٬١٢٣٬٤٥٦٬٧٨٩ + +// India utilise des séparateurs pour +// les milliers/lakh/crore +console.log(bigint.toLocaleString('en-IN')); +// → 1,23,45,67,89,12,34,56,789 + +// La clé d'extension requiert un système de numérotation +// par exemple, le système décimal chinois +console.log(bigint.toLocaleString('zh-Hans-CN-u-nu-hanidec')); +// → 一二三,四五六,七八九,一二三,四五六,七八九 + +// Lorsqu'on demande une langue qui peut ne pas être prise +// en charge (ici le balinais), on peut ajouter une autre +// locale qui sera utilisée en recours (ici l'indonésien) +console.log(bigint.toLocaleString(['ban', 'id'])); +// → 123.456.789.123.456.789 +</pre> + +<h3 id="Utiliser_options">Utiliser <code>options</code></h3> + +<p>Ici, on personnalise le résultat fourni par <code>toLocaleString()</code> grâce à l'argument <code>options</code> :</p> + +<pre class="brush: js">var bigint = 123456789123456789n; + +// On utilise un format avec une devise +console.log(bigint.toLocaleString('de-DE', { style: 'currency', currency: 'EUR' })); +// → 123.456.789.123.456.789,00 € + +// Le yen japonais n'utilise pas de sous-unité +console.log(bigint.toLocaleString('ja-JP', { style: 'currency', currency: 'JPY' })) +// → ￥123,456,789,123,456,789 + +// On limite l'écriture aux trois premiers chiffres significatifs +console.log(bigint.toLocaleString('en-IN', { maximumSignificantDigits: 3 })); +// → 1,23,00,00,00,00,00,00,000 +</pre> + +<h2 id="Performance">Performance</h2> + +<p>Lorsqu'on souhaite mettre en forme une grande quantité de nombres, mieux vaudra créer un objet {{jsxref("NumberFormat")}} et utiliser la fonction fournie par sa propriété {{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> + </tr> + <tr> + <td><code><a href="https://tc39.es/ecma402/#sup-bigint.prototype.tolocalestring">BigInt</a></code></td> + <td>Proposition de niveau 3.</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 à consulter <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> et à nous envoyer une <em>pull request</em>.</div> + +<p>{{Compat("javascript.builtins.BigInt.toLocaleString")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("BigInt.toString()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/bigint/tostring/index.html b/files/fr/web/javascript/reference/objets_globaux/bigint/tostring/index.html new file mode 100644 index 0000000000..9718891da1 --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/bigint/tostring/index.html @@ -0,0 +1,97 @@ +--- +title: BigInt.prototype.toString() +slug: Web/JavaScript/Reference/Objets_globaux/BigInt/toString +tags: + - BigInt + - JavaScript + - Méthode + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/BigInt/toString +--- +<div>{{JSRef}}</div> + +<p>The <strong><code>toString()</code></strong> method returns a string representing the specified {{jsxref("BigInt")}} object. The trailing "n" is not part of the string.</p> + +<div>{{EmbedInteractiveExample("pages/js/bigint-tostring.html")}}</div> + + + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox"><code><var>bigIntObj</var>.toString([<var>base</var>])</code></pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>base</code>{{optional_inline}}</dt> + <dd>Ce paramètre optionnel est compris entre 2 et 36 et indique la base à utiliser pour représenter les valeurs numériques.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Une chaîne de caractères représentant l'objet {{jsxref("BigInt")}} courant.</p> + +<h3 id="Exceptions">Exceptions</h3> + +<dl> + <dt>{{jsxref("RangeError")}}</dt> + <dd>Si la base fournie comme argument <code>toString()</code> est inférieure à 2 ou supérieure à 36, cela déclenchera une exception {{jsxref("RangeError")}}.</dd> +</dl> + +<h2 id="Description">Description</h2> + +<p>L'objet {{jsxref("BigInt")}} surcharge la méthode <code>toString()</code> de {{jsxref("Object")}}. Il n'hérite pas ou n'utilise pas {{jsxref("Object.prototype.toString()")}}. Pour les objets {{jsxref( "BigInt")}}, la méthode <code>toString()</code> renvoie une représentation textuelle de l'objet dans la base indiquée.</p> + +<p>La méthode <code>toString()</code> analyse le premier argument qui lui est passé et tente de renvoyer une représentation textuelle dans cette base. Pour les bases supérieures à 10, ce seront les lettres de l'alphabet pour indiquer les chiffres supérieurs à 9. Pour les nombres hexadécimaux (base 16), les lettres <code>a</code> à <code>f</code> sont utilisées par exemple.</p> + +<p>Si l'argument <code>base</code> n'est pas indiquée, ce sera la base 10 qui sera considérée par défaut.</p> + +<p>Si <code>bigIntObj</code> est négatif, le signe est conservé, y compris lorsque la base est 2 (dans ce cas, la chaîne renvoyée sera la représentation binaire précédée par un signe <code>-</code> et <strong>non</strong> le complément à deux de <code>bigIntObj</code>).</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utiliser_toString()">Utiliser <code>toString()</code></h3> + +<pre class="brush: js">17n.toString(); // '17' +66n.toString(2); // '1000010' +254n.toString(16); // 'fe' +-10n.toString(2); // -1010' +-0xffn.toString(2); // '-11111111' +</pre> + +<h3 id="Gestion_du_zéro_négatif_en_BigInt">Gestion du zéro négatif en <code>BigInt</code></h3> + +<p>Il n'existe pas de zéro négatif pour <code>BigInt</code> car les entiers ne gèrent pas de concept de zéro négatif. <code>-0.0</code> est un concept relatif à la représentation flottante IEEE et n'est présent que pour le type {{jsxref("Number")}}.</p> + +<pre class="brush: js">(-0n).toString(); // '0' +BigInt(-0).toString(); // '0'</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> + </tr> + <tr> + <td><a href="https://tc39.github.io/proposal-bigint/#sec-bigint.prototype.tostring">Proposition pour <code>BigInt</code></a></td> + <td>Proposition de niveau 3</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 à consulter <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> et à nous envoyer une <em>pull request</em>.</div> + +<p>{{Compat("javascript.builtins.BigInt.toString")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("BigInt.prototype.toLocaleString()")}}</li> + <li>{{jsxref("BigInt.prototype.valueOf()")}}</li> + <li>{{jsxref("Number.prototype.toString()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/bigint/valueof/index.html b/files/fr/web/javascript/reference/objets_globaux/bigint/valueof/index.html new file mode 100644 index 0000000000..924a9ce5e2 --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/bigint/valueof/index.html @@ -0,0 +1,62 @@ +--- +title: BigInt.prototype.valueOf() +slug: Web/JavaScript/Reference/Objets_globaux/BigInt/valueOf +tags: + - BigInt + - JavaScript + - Method + - Prototype + - Reference + - valueOf() +translation_of: Web/JavaScript/Reference/Global_Objects/BigInt/valueOf +--- +<div>{{JSRef}}</div> + +<p>La méthode <strong><code>valueOf()</code></strong> renvoie la valeur primitive encapsulée dans un objet {{jsxref("BigInt")}}.</p> + +<div>{{EmbedInteractiveExample("pages/js/bigint-valueof.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"><var>bigIntObj</var>.valueOf()</pre> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Un grand entier (<em>big int</em>) représentant la valeur primitive de l'objet {{jsxref("BigInt")}} courant.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utiliser_valueOf()">Utiliser <code>valueOf()</code></h3> + +<pre class="brush: js">typeof Object(1n); // object +typeof Object(1n).valueOf(); // bigint +</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> + </tr> + <tr> + <td><a href="https://tc39.github.io/proposal-bigint/#sec-bigint.prototype.valueof">Proposition pour <code>BigInt</code></a></td> + <td>Proposition de niveau 3</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 à consulter <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> et à nous envoyer une <em>pull request</em>.</div> + +<p>{{Compat("javascript.builtins.BigInt.valueOf")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("BigInt.prototype.toString()")}}</li> +</ul> |