path: root/files/pl/web/javascript/reference/global_objects/bigint/index.html

---
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>&gt;&gt;&gt;</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 &lt; 2
// ↪ true

2n &gt; 1
// ↪ true

2 &gt; 2
// ↪ false

2n &gt; 2
// ↪ false

2n &gt;= 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>&amp;&amp;</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 &amp;&amp; 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 &lt;= 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 &gt;= 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>

<p>{{Compat("javascript.builtins.BigInt")}}</p>

<h2 id="Zobacz_też">Zobacz też</h2>

<ul>
 <li>{{JSxRef("Number")}}</li>
 <li>{{JSxRef("Number.MAX_SAFE_INTEGER")}}</li>
</ul>