diff options
Diffstat (limited to 'files/pl/web/javascript/reference/global_objects/bigint')
5 files changed, 609 insertions, 0 deletions
diff --git a/files/pl/web/javascript/reference/global_objects/bigint/asintn/index.html b/files/pl/web/javascript/reference/global_objects/bigint/asintn/index.html new file mode 100644 index 0000000000..fca69d7e9c --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/bigint/asintn/index.html @@ -0,0 +1,80 @@ +--- +title: BigInt.asIntN() +slug: Web/JavaScript/Reference/Global_Objects/BigInt/asIntN +tags: + - BigInt + - JavaScript + - Metodă + - Referencja + - asIntN +translation_of: Web/JavaScript/Reference/Global_Objects/BigInt/asIntN +original_slug: Web/JavaScript/Referencje/Obiekty/BigInt/asIntN +--- +<div>{{JSRef}}</div> + +<p>Metoda statyczna <strong><code>BigInt.asIntN</code></strong> jest używana do opakowywania wartości BigInt w wartości całkowite ze znakiem w zakresie od -2<sup>szerokość-1</sup> do 2<sup>szerokość-1</sup>-1.</p> + +<div>{{EmbedInteractiveExample("pages/js/bigint-asintn.html", "taller")}}</div> + +<div class="hidden">The source for this interactive example is stored in a GitHub repository. If you'd like to contribute to the interactive examples project, please clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> and send us a pull request.</div> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox">BigInt.asIntN(<em>szerokość</em>, <var>bigint</var>);</pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt><code><var>szerokość</var></code></dt> + <dd>Liczba bitów dostępnych dla rozmiaru wartości całkowitej (integer).</dd> + <dt><code><var>bigint</var></code></dt> + <dd>Wartość całkowita, którą chcemy wpasować w daną liczbę bitów.</dd> +</dl> + +<h3 id="Wynik">Wynik</h3> + +<p>Wartość <code><var>bigint</var></code> modulo 2<sup><code><var>szerokość</var></code></sup> jako liczba całkowita ze znakiem.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Pozostawanie_w_zakresie_arytmetyki_64-bitowej">Pozostawanie w zakresie arytmetyki 64-bitowej</h3> + +<p>Metoda <code>BigInt.asIntN()</code> może być użyteczna do tego, by pozostać w zakresie obliczeń arytmetyki 64-bitowej.</p> + +<pre class="brush: js">const max = 2n ** (64n - 1n) - 1n; + +BigInt.asIntN(64, max); +// ↪ 9223372036854775807n + +BigInt.asIntN(64, max + 1n); +// ↪ -9223372036854775807n +// wartość ujemna ze względu na przepełnienie +</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Specyfikacja</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ESDraft', '#sec-bigint.asintn', 'BigInt.asIntN()')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2> + + + +<p>{{Compat("javascript.builtins.BigInt.asIntN")}}</p> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li>{{JSxRef("BigInt")}}</li> + <li>{{JSxRef("BigInt.asUintN()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/bigint/asuintn/index.html b/files/pl/web/javascript/reference/global_objects/bigint/asuintn/index.html new file mode 100644 index 0000000000..63ed40473a --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/bigint/asuintn/index.html @@ -0,0 +1,79 @@ +--- +title: BigInt.asUintN() +slug: Web/JavaScript/Reference/Global_Objects/BigInt/asUintN +tags: + - BigInt + - JavaScript + - Metodă + - Referencja + - asUintN +translation_of: Web/JavaScript/Reference/Global_Objects/BigInt/asUintN +original_slug: Web/JavaScript/Referencje/Obiekty/BigInt/asUintN +--- +<div>{{JSRef}}</div> + +<p>Metoda statyczna <strong><code>BigInt.asUintN</code></strong> jest używana do opakowywania wartości BigInt w wartości całkowite bez znaku w zakresie od 0 do 2<sup>szerokość</sup>-1.</p> + +<div>{{EmbedInteractiveExample("pages/js/bigint-asuintn.html", "taller")}}</div> + +<div class="hidden">The source for this interactive example is stored in a GitHub repository. If you'd like to contribute to the interactive examples project, please clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> and send us a pull request.</div> + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox">BigInt.asUintN(<em>szerokość</em>, <var>bigint</var>);</pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt><code><var>szerokość</var></code></dt> + <dd>Liczba bitów dostępnych dla rozmiaru wartości całkowitej (integer).</dd> + <dt><code><var>bigint</var></code></dt> + <dd>Wartość całkowita, którą chcemy wpasować w daną liczbę bitów.</dd> +</dl> + +<h3 id="Wynik">Wynik</h3> + +<p>Wartość <code><var>bigint</var></code> modulo 2<sup><code><var>szerokość</var></code></sup> jako wartość całkowita bez znaku.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Pozostawanie_w_zakresie_arytmetyki_64-bitowej">Pozostawanie w zakresie arytmetyki 64-bitowej</h3> + +<p>Metoda <code>BigInt.asUintN()</code> może być użyteczna do tego, by pozostać w zakresie obliczeń arytmetyki 64-bitowej.</p> + +<pre class="brush: js">const max = 2n ** 64n - 1n; + +BigInt.asUintN(64, max); +// ↪ 18446744073709551615n + +BigInt.asUintN(64, max + 1n); +// ↪ 0n +// zero z powodu przepełnienia</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Specyfikacja</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ESDraft', '#sec-bigint.asuintn', 'BigInt.asUintN()')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2> + + + +<p>{{Compat("javascript.builtins.BigInt.asUintN")}}</p> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li>{{JSxRef("BigInt")}}</li> + <li>{{JSxRef("BigInt.asIntN()")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/bigint/index.html b/files/pl/web/javascript/reference/global_objects/bigint/index.html new file mode 100644 index 0000000000..4f66412f67 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/bigint/index.html @@ -0,0 +1,294 @@ +--- +title: BigInt +slug: Web/JavaScript/Reference/Global_Objects/BigInt +tags: + - BigInt + - JavaScript + - Referencja +translation_of: Web/JavaScript/Reference/Global_Objects/BigInt +original_slug: Web/JavaScript/Referencje/Obiekty/BigInt +--- +<div>{{JSRef}}</div> + +<p><strong><code>BigInt</code></strong> jest wbudowanym obiektem umożliwiającym reprezentowanie całych liczb większch niż 2<sup>53</sup> - 1, ile wynosi największa liczba, którą JavaScript może faktycznie reprezentować przez prymityw {{JSxRef("Number")}}, co jest też reprezentowane przez stałą {{JSxRef("Number.MAX_SAFE_INTEGER")}}. <strong><code>BigInt</code></strong> może być używany do dowolnie dużych liczb całkowitych.</p> + +<dl> +</dl> + +<h2 id="Opis">Opis</h2> + +<p><code>BigInt</code> jest tworzony przez dodanie <code>n</code> na końcu literału liczby — <code>10n</code> — lub przez wywołanie funkcji <code>BigInt()</code>.</p> + +<pre class="brush: js">const najwiekszyInt = 9007199254740991n + +const tezDuzaLiczba = BigInt(9007199254740991) +// ↪ 9007199254740991n + +const duzyString = BigInt("9007199254740991") +// ↪ 9007199254740991n + +const duzyHex = BigInt("0x1fffffffffffff") +// ↪ 9007199254740991n + +const duzyBin = BigInt("0b11111111111111111111111111111111111111111111111111111") +// ↪ 9007199254740991n +</pre> + +<p><code>BigInt</code> jest w pewnym sensie podobny do {{JSxRef("Number")}} ale też różni się od niego w kilku kluczowych sprawach — nie może być używany z metodami wbudowanego obiektu {{JSxRef("Math")}}, a także nie może być mieszany z instancjami <code>Number</code> w żadnych operacjach; konieczne jest wymuszenie tego samego typu operandów. Należy uważać z wymuszaniem typów w jedną i drugą stronę, w szczególności precyzja <code>BigInt</code> może być utracona przy wymuszonej konwersji do typu <code>Number</code>.</p> + +<h3 id="Informacje_o_typie">Informacje o typie</h3> + +<p>Przy sprawdzeniu za pomocą <code>typeof</code>, <code>BigInt</code> zwróci "bigint":</p> + +<pre class="brush: js">typeof 1n === 'bigint' // true +typeof BigInt('1') === 'bigint' // true +</pre> + +<p>Obudowany w <code>Object</code>, <code>BigInt</code> będzie rozważany jako zwykły "obiekt":</p> + +<pre class="brush: js">typeof Object(1n) === 'object' // true +</pre> + +<h3 id="Operatory">Operatory</h3> + +<p>Z <code>BigInt</code>ami (lub <code>BigInt</code>ami obudowanymi w obiekty) mogą być używane następujące operatory: : <code>+</code>, <code>*</code>, <code>-</code>, <code>**</code>, <code>%</code>.</p> + +<p><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators">Operatory bitowe</a> także są wspierane, z wyjątkiem <code>>>></code> (przesunięcie w prawo z dopełnieniem zerami), gdyż wszystkie <code>BigInt</code>y mają znak.</p> + +<p>Niewspierany jest także operator jednoargumentowy (<code>+</code>), <a href="https://github.com/tc39/proposal-bigint/blob/master/ADVANCED.md#dont-break-asmjs">aby nie złamać zasad asm.js</a>.</p> + +<pre class="brush: js">const previousMaxSafe = BigInt(Number.MAX_SAFE_INTEGER) +// ↪ 9007199254740991n + +const maxPlusOne = previousMaxSafe + 1n +// ↪ 9007199254740992n + +const theFuture = previousMaxSafe + 2n +// ↪ 9007199254740993n, this works now! + +const multi = previousMaxSafe * 2n +// ↪ 18014398509481982n + +const subtr = multi – 10n +// ↪ 18014398509481972n + +const mod = multi % 10n +// ↪ 2n + +const bigN = 2n ** 54n +// ↪ 18014398509481984n + +bigN * -1n +// ↪ –18014398509481984n +</pre> + +<p>Operator <code>/</code> także działa zgodnie z założeniami z całymi liczbami.</p> + +<p>Jako że są to <code>BigInt</code>y, a nie <code>BigDecimal</code>, operacja dzielenia będzie zaokroąglała wynik do <code>0</code> (zatem można prościej powiedzieć, że nie zwraca ułamkowej części wyniku).</p> + +<div class="blockIndicator warning"> +<p>Ułamkowy wynik operacji będzie przycięty, kiedy używany jest <code>BigInt</code>.</p> +</div> + +<pre class="brush: js">const expected = 4n / 2n +// ↪ 2n + +const rounded = 5n / 2n +// ↪ 2n, not 2.5n + +</pre> + +<h3 id="Porównania">Porównania</h3> + +<p><code>BigInt</code> nie jest ściśle równy {{JSxRef("Number")}}, ale jest równy w luźnym sensie, zatem:</p> + +<pre class="brush: js">0n === 0 +// ↪ false + +0n == 0 +// ↪ true</pre> + +<p>{{JSxRef("Global_Objects/Number", "Number")}} i <code>BigInt</code> mogą być porównywane w zwyczajny sposób:</p> + +<pre class="brush: js">1n < 2 +// ↪ true + +2n > 1 +// ↪ true + +2 > 2 +// ↪ false + +2n > 2 +// ↪ false + +2n >= 2 +// ↪ true</pre> + +<p>Mogą być też mieszane w tablicach i sortowane:</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, 4n, 4, 6, 10] +</pre> + +<p>Zauważ, że porównania z <code>BigInt</code>ami opakowanymi w obiekty działają jak z innymi obiektami, wskazując równość tylko wtedy, kiedy ta sama instancja obiektu znajduje się po obu stronach porównania:</p> + +<pre class="brush: js">0n === Object(0n) // false +Object(0n) === Object(0n) // false + +const o = Object(0n) +o === o // true +</pre> + +<h3 id="Instrukcje_warunkowe">Instrukcje warunkowe</h3> + +<p><code>BigInt</code> zachowuje się jak {{JSxRef("Global_Objects/Number", "Number")}} w przypadkach, gdy:</p> + +<ul> + <li>jest konwertowany na {{JSxRef("Global_Objects/Boolean", "Boolean")}} za pomocą funkcji {{JSxRef("Global_Objects/Boolean", "Boolean")}};</li> + <li>jest używany z <a href="/pl/docs/Web/JavaScript/Referencje/Operatory/Logical_Operators">operatorami logicznymi</a> <code>||</code>, <code>&&</code> lub <code>!</code>;</li> + <li>w instrukcjach warunkowych {{JSxRef("Statements/if...else", "if")}}.</li> +</ul> + +<pre class="brush: js">if (0n) { + console.log('Hello from the if!') +} else { + console.log('Hello from the else!') +} + +// ↪ "Hello from the else!" + +0n || 12n +// ↪ 12n + +0n && 12n +// ↪ 0n + +Boolean(0n) +// ↪ false + +Boolean(12n) +// ↪ true + +!12n +// ↪ false + +!0n +// ↪ true +</pre> + +<h2 id="Konstruktor">Konstruktor</h2> + +<dl> + <dt><code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt/BigInt">BigInt()</a></code></dt> + <dd>Tworzy obiekty {{jsxref("BigInt")}}.</dd> +</dl> + +<h2 id="Metody_statyczne">Metody statyczne</h2> + +<dl> + <dt>{{JSxRef("BigInt.asIntN()")}}</dt> + <dd>Opakowuje wartość <code>BigInt</code> w liczbę całkowitą ze znakiem o wartości między <code>-2<var><sup>width</sup></var><sup>-1</sup></code> a <code>2<var><sup>width</sup></var><sup>-1</sup> - 1</code>.</dd> + <dt>{{JSxRef("BigInt.asUintN()")}}</dt> + <dd>Opakowuje wartość <code>BigInt</code> w liczbę całkowitą bez znaku o wartości między <code>0</code> a <code>2<var><sup>width</sup></var> - 1</code>.</dd> +</dl> + +<h2 id="Metody_instancyjne">Metody instancyjne</h2> + +<dl> + <dt>{{JSxRef("BigInt.prototype.toLocaleString()")}}</dt> + <dd>Zwraca string z zależną od języka reprezentacją danej liczby. Nadpisuje metodę {{JSxRef("Object.prototype.toLocaleString()")}}.</dd> + <dt>{{JSxRef("BigInt.prototype.toString()")}}</dt> + <dd>Zwraca string reprezentujący dany obiekt w określonym źródle. Nadpisuje metodę {{JSxRef("Object.prototype.toString()")}}.</dd> + <dt>{{JSxRef("BigInt.prototype.valueOf()")}}</dt> + <dd>Zwraca prymitywną wartość danego obiektu. Nadpisuje metodę {{JSxRef("Object.prototype.valueOf()")}}.</dd> +</dl> + +<h2 id="Zalecenia_w_użyciu">Zalecenia w użyciu</h2> + +<h3 id="Wymuszanie_typów">Wymuszanie typów</h3> + +<p>Ponieważ wymuszanie tupów między {{JSxRef("Number")}} a <code>BigInt</code> może prowadzić do utraty precyzji, zaleca się używanie jedynie typu <code>BigInt</code>, gdy można się spodziewać, że pojawią się wartości przekraczające 2<sup>53</sup> i nie należy wówczas przeprowadzać konwersji między tymi typami.</p> + +<h3 id="Kryptografia">Kryptografia</h3> + +<p>Operacje wspierane dla <code>BigInt</code>ów nie są stałe czasowo, dlatego też typ <code>BigInt</code> <a href="https://www.chosenplaintext.ca/articles/beginners-guide-constant-time-cryptography.html">nie nadaje się do użycia w kryptografii</a>.</p> + +<h3 id="Użycie_w_JSON">Użycie w JSON</h3> + +<p>Użycie {{jsxref("JSON.stringify()")}} z dowolną wartością typu <code>BigInt</code> spowoduje błąd <code>TypeError</code>, ponieważ wartości <code>BigInt</code> nie są domyślnie serialozowane w JSONie. Jednakże, jeśli taka operacja jest potrzebna, możesz zaimplemntować własną metodę <code>toJSON</code>:</p> + +<pre class="brush: js">BigInt.prototype.toJSON = function() { return this.toString() }</pre> + +<p>Zamiast wyrzucania wyjątku, <code>JSON.stringify</code> będzie teraz zwracać string:</p> + +<pre class="brush: js">JSON.stringify(BigInt(1)) +// '"1"'</pre> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Obliczanie_liczb_pierwszych">Obliczanie liczb pierwszych</h3> + +<pre class="brush: js">// Zwraca true jeśl dany BigInt jest liczbą pierwszą +function isPrime(p) { + for (let i = 2n; i * i <= p; i++) { + if (p % i === 0n) return false; + } + return true +} + +// Przyjmuje BigInt n jako argument, zwraca n-tą liczbę pierwszą jako BigInt +function nthPrime(nth) { + let maybePrime = 2n + let prime = 0n + + while (nth >= 0n) { + if (isPrime(maybePrime)) { + nth-- + prime = maybePrime + } + maybePrime++ + } + + return prime +} + +nthPrime(20n) +// ↪ 73n</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Specyfikacja</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName("ESDraft", "#sec-bigint-objects", "<code>BigInt</code> objects")}}</td> + </tr> + </tbody> +</table> + +<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2> + +<div class="hidden">The compatibility table on this page is generated from structured data. If you'd like to contribute to the data, please check out <a class="external" href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</div> + +<p>{{Compat("javascript.builtins.BigInt")}}</p> + +<h3 id="Postęp_implementacji">Postęp implementacji</h3> + +<p>Poniższa tabela przedstawia postęp implementacji tej funkcji języka JavaScript, gdyż nie osiągnęła ona jeszcze pełnej stabilności między przeglądarkami. Dane są generowane przez uruchamianie odpowiednich testów tej funkcji w <a href="https://github.com/tc39/test262">Test262</a>,standrardowym zestawie testów JavaScript, „nocnych wersji” (ang. <em>nightly build</em>) lub ostatnich wydań silnika JavaScript w każdej przeglądarce.</p> + +<div>{{EmbedTest262ReportResultsTable("BigInt")}}</div> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li>{{JSxRef("Number")}}</li> + <li>{{JSxRef("Number.MAX_SAFE_INTEGER")}}</li> +</ul> diff --git a/files/pl/web/javascript/reference/global_objects/bigint/tostring/index.html b/files/pl/web/javascript/reference/global_objects/bigint/tostring/index.html new file mode 100644 index 0000000000..8c3cc98381 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/bigint/tostring/index.html @@ -0,0 +1,96 @@ +--- +title: BigInt.prototype.toString() +slug: Web/JavaScript/Reference/Global_Objects/BigInt/toString +tags: + - BigInt + - JavaScript + - Metodă + - Prototyp + - toString() +translation_of: Web/JavaScript/Reference/Global_Objects/BigInt/toString +original_slug: Web/JavaScript/Referencje/Obiekty/BigInt/toString +--- +<div>{{JSRef}}</div> + +<p>Metoda <strong><code>toString()</code></strong> zwraca ciąg znaków (<em>string</em>), reprezentujący dany obiekt {{jsxref("BigInt")}}. Końcowy znak "n" nie jest częścią wynikowego ciągu znaków.</p> + +<div>{{EmbedInteractiveExample("pages/js/bigint-tostring.html")}}</div> + + + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><code><var>bigIntObj</var>.toString([podstawa])</code></pre> + +<h3 id="Parametry">Parametry</h3> + +<dl> + <dt><code>podstawa</code>{{optional_inline}}</dt> + <dd>Argument opcjonalny. Liczba całkowita w zakresie od 2 do 36, reprezentująca bazę systemu liczbowego, w którym ma być przedstawiona dana wartość {{jsxref("BigInt")}}.</dd> +</dl> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<p>Ciąg znaków reprezentujący dany obiekt {{jsxref("BigInt")}}.</p> + +<h3 id="Wyjątki">Wyjątki</h3> + +<dl> + <dt>{{jsxref("RangeError")}}</dt> + <dd>Jeśli do metody <code>toString()</code> przekazana jest podstawa systemu mniejsza niż 2 lub większa niż 36, wyrzucany jest błąd {{jsxref("RangeError")}}.</dd> +</dl> + +<h2 id="Opis">Opis</h2> + +<p>Obiekt {{jsxref("BigInt")}} nadpisuje metodę <code>toString()</code> obiektu {{jsxref("Object")}}; nie dziedziczy metody {{jsxref("Object.prototype.toString()")}}. Dla obiektów {{jsxref( "BigInt")}}, metoda <code>toString()</code> zwraca ciąg znaków reprezentujący daną wartość w systemie pozycyjnym o zadanej bazie.</p> + +<p>Metoda <code>toString()</code> parsuje pierwszy argument i próbuje zwrócić ciąg znaków reprezentujący daną wartość w systemie o zadanej podstawie (bazie). Dla systemów o podstawie większej niż 10, do reprezentacji cyfr większych niż 9 używane są kolejne litery alfabetu łacińskiego. Przykładowo, dla wartości w systemie szesnastkowym (o podstawie równej 16), używane są litery od <code>a</code> do <code>f</code>.</p> + +<p>Jeśli <code>podstawa</code> nie jest podana, zakłada się, że preferowaną bazą systemu jest 10.</p> + +<p>Jeśli wartość <code>bigIntObj</code> jest ujemna, znak jest zachowywany. Dzieje się tak nawet wtedy, gdy podstawą jest 2; zwracany ciąg cyfr jest dodatnią reprezentacją <code>bigIntObj</code>, poprzedzoną znakiem <code>-</code>, <strong>nie</strong> dopełnieniem dwójkowym <code>bigIntObj</code>.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Użycie_toString">Użycie <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="BigInt_z_ujemnym_zerem"><code>BigInt</code> z ujemnym zerem</h3> + +<p>Nie ma obiektów <code>BigInt</code> reprezentujących ujemne zero, tak jak nie ma ujemnych zer wśród liczb całkowitych.. <code>-0.0</code> jest zmiennoprzecinkową koncepcją zmiennoprzecinkową IEEE, która pojawia się w języku JavaScript jedynie w typie {{jsxref("Number")}}.</p> + +<pre class="brush: js">(-0n).toString(); // '0' +BigInt(-0).toString(); // '0'</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-bigint.prototype.tostring', 'BigInt.prototype.toString()')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.BigInt.toString")}}</p> + +<h2 id="Zobacz_też">Zobacz też</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/pl/web/javascript/reference/global_objects/bigint/valueof/index.html b/files/pl/web/javascript/reference/global_objects/bigint/valueof/index.html new file mode 100644 index 0000000000..e1ed582948 --- /dev/null +++ b/files/pl/web/javascript/reference/global_objects/bigint/valueof/index.html @@ -0,0 +1,60 @@ +--- +title: BigInt.prototype.valueOf() +slug: Web/JavaScript/Reference/Global_Objects/BigInt/valueOf +tags: + - BigInt + - JavaScript + - Metodă + - Prototype + - valueOf() +translation_of: Web/JavaScript/Reference/Global_Objects/BigInt/valueOf +original_slug: Web/JavaScript/Referencje/Obiekty/BigInt/valueOf +--- +<div>{{JSRef}}</div> + +<p>Metoda <strong><code>valueOf()</code></strong> zwraca opakowaną wartość prymitywną obiektu {{jsxref("BigInt")}}.</p> + +<div>{{EmbedInteractiveExample("pages/js/bigint-valueof.html","shorter")}}</div> + + + +<h2 id="Składnia">Składnia</h2> + +<pre class="syntaxbox"><var>bigIntObj</var>.valueOf()</pre> + +<h3 id="Zwracana_wartość">Zwracana wartość</h3> + +<p>BigInt reprezentujący wartość prymitywną danego obiektu {{jsxref("BigInt")}}.</p> + +<h2 id="Przykłady">Przykłady</h2> + +<h3 id="Użycie_valueOf">Użycie <code>valueOf</code></h3> + +<pre class="brush: js">typeof Object(1n); // object +typeof Object(1n).valueOf(); // bigint +</pre> + +<h2 id="Specyfikacje">Specyfikacje</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specyfikacja</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-bigint.prototype.valueof', 'BigInt.prototype.valueOf()')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Wsparcie_przeglądarek">Wsparcie przeglądarek</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.BigInt.valueOf")}}</p> + +<h2 id="Zobacz_też">Zobacz też</h2> + +<ul> + <li>{{jsxref("BigInt.prototype.toString()")}}</li> +</ul> |