path: root/files/pl/conflicting/web/javascript/reference/operators_1f6634ff6e3ccef661281d6e50002147/index.html

---
title: Operatory arytmetyczne
slug: Web/JavaScript/Referencje/Operatory/Operatory_arytmetyczne
tags:
  - JavaScript
  - Operator
translation_of: Web/JavaScript/Reference/Operators
translation_of_original: Web/JavaScript/Reference/Operators/Arithmetic_Operators
---
<div>
<div>{{jsSidebar("Operators")}}</div>
</div>

<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>

<p>Operatory arytmetyczne pobierają wartości liczbowe (w postaci bezpośredniej lub zmiennej) jako ich operandy i zwracają jedna, wynikową wartość liczbową. Typowymi operatorami arytmetycznymi są dodawanie (+), odejmowanie (-), mnożenie (*), i dzielenie (/). Operatory te działają tak samo jak w innych językach programowania, z wyjątkiem operatora dzielenia /, który w JavaScripcie zwraca wynik będący liczbą zmiennoprzecinkową, nie obcinając części ułamkowej, jak to się dzieje w C lub Javie.</p>

<h2 id="Dodawanie_()">Dodawanie (+)</h2>

<p>Operator dodawania zwraca sume operandów lub jeśli chociaż jeden operand był łańcuchem znaków, ich konkatenacje.</p>

<h3 id="Składnia">Składnia</h3>

<pre class="syntaxbox"><strong>Operator:</strong> x + y</pre>

<h3 class="syntaxbox" id="Przykłady">Przykłady</h3>

<pre><code>// Number + Number -&gt; dodawanie
1 + 2 // 3

// Boolean + Number -&gt; dodawanie
true + 1 // 2

// Boolean + Boolean -&gt; dodawanie
false + false // 0

// Number + String -&gt; konkatenacja
5 + "foo" // "5foo"

// String + Boolean -&gt; konkatenacja
"foo" + false // "foofalse"

// String + String -&gt; konkatenacja
"foo" + "bar" // "foobar"</code></pre>

<h2 id="sect1"> </h2>

<h2 id="Odejmowanie_(-)">Odejmowanie (-)</h2>

<p>Operator odejmowania zwraca różnicę między pierwszym, a drugim operandem.</p>

<h3 id="Składnia_2">Składnia</h3>

<pre><strong>Operator:</strong> x - y
</pre>

<h3 id="Przykłady_2">Przykłady</h3>

<pre><code>5 - 3 // 2
3 - 5 // -2
5 - true // 4
"foo" - 3 // NaN</code></pre>

<p> </p>

<h2 id="Dzielenie_()">Dzielenie (/)</h2>

<p>Operator dzielenia zwraca iloraz operandów gdzie ten po lewej stronie jest dzielną, a ten po prawej dzielnikiem.</p>

<h3 id="Składnia_3">Składnia</h3>

<pre><strong>Operator:</strong> x / y
</pre>

<h3 id="Przykłady_3">Przykłady</h3>

<pre><code>1 / 2      // zwraca 0.5 w JavaScript
1 / 2      // zwraca 0 w Java

1.0 / 2.0  // zwraca 0.5 zarówno w JavaScript i Java

2.0 / 0    // zwraca Infinity w JavaScript
2.0 / 0.0  // zwraca także Infinity
2.0 / -0.0 // zwraca -Infinity in JavaScript</code></pre>

<p> </p>

<h2 id="Mnożenie_(*)">Mnożenie (*)</h2>

<p>Operotor mnożenia zwraca wynik mnożenia operandów.</p>

<h3 id="Składnia_4">Składnia</h3>

<pre><strong>Operator:</strong> x * y
</pre>

<h3 id="Przykłady_4">Przykłady</h3>

<pre><code>2 * 2 // 4
-2 * 2 // -4
Infinity * 0 // NaN
Infinity * Infinity // Infinity
"foo" * 2 // NaN</code>
</pre>

<h2 id="Modulo" name="Modulo"> </h2>

<h2 id="Modulo" name="Modulo">Dzielenie modulo (%)</h2>

<p>Operator modulo zwraca resztę z dzielenia pierwszego operandu przez drugi.</p>

<h3 id="Składnia_5">Składnia</h3>

<pre><strong>Operator:</strong> var1 % var2
</pre>

<h3 id="Przykłady_5">Przykłady</h3>

<pre><code>12 % 5 // 2
-1 % 2 // -1
NaN % 2 // NaN
1 % 2 // 1
2 % 3 // 2
-4 % 2 // -0
5.5 % 2 // 1.5</code></pre>

<p> </p>

<h2 id="Potęgowanie_(**)">Potęgowanie (**)</h2>

<div class="overheadIndicator" style="background: #9CF49C;">
<p><strong>Ta eksperymentalna własnośc, jest częścią propozycji specyfikacji ECMAScript 2016 (ES7).</strong><br>
 Ponieważ specyfikacja tej własność i nie została oficjalnie wdrożona, przed użyciem zapoznaj się z tabelą kompatybilności dla różnych przeglądarek. Warto wspomnieć, że składnia jak i zachowanie eksperymentalnych własności mogą zmieniać się wraz ze zmianami w specyfikacji.</p>
</div>

<p>Operator ten zwraca wynik gdzie pierwszy operand jest podstawą, a drugi wykładnikiem (<code>var1</code><sup><code>var2</code></sup>). Operator ten jest asocjacyjny co oznacza, że dopuszalne jest użycie w formie <code>a ** b ** c, co jest równe a ** (b ** c)</code>.</p>

<h3 id="Składnia_6">Składnia</h3>

<pre><strong>Operator:</strong> var1 ** var2
</pre>

<h3 id="Uwagi">Uwagi</h3>

<p>W większości języków programowania które posiadają operator potęgowania (zwykle jako ^ lub **) jak np. PHP czy Python, ma on wyższy priorytet niż operatory jedno argumentowe (oznaczające liczbę dodatnią lub ujemną) + czy -, ale istnieją wyjątki. Np. w Bash ten operator posiada niższy priorytet niż wspomniane wcześniej + czy -.<br>
 W JavaScript niemożliwe jest użycie operatorów jedno argumentowych (<code>+/-/~/!/delete/void/typeof</code>)  bezpośrednio przed podstawą.</p>

<pre><code>-2 ** 2;
// 4 w Bash, -4 w innych językach.
// W JavaScript jest to nieprawidłowa próba użycia operatora potęgowania.


-(2 ** 2); // -4
5 ** -2 // 0.04</code>
</pre>

<h3 id="Przykłady_6">Przykłady</h3>

<pre><code>2 ** 3 // 8
3 ** 2 // 9
3 ** 2.5 // 15.588457268119896
10 ** -1 // 0.1
NaN ** 2 // NaN

2 ** 3 ** 2 // 512
2 ** (3 ** 2) // 512
(2 ** 3) ** 2 // 64</code></pre>

<p>Aby odwrócić znak zwracanej wartości:</p>

<pre><code>-(2 ** 2) // -4</code></pre>

<p>Sposób na wymuszenie potęgowania ujemnej liczby:</p>

<pre><code>(-2) ** 2 // 4</code></pre>

<h2 id="Inkrementacja" name="Inkrementacja"> </h2>

<h2 id="Inkrementacja" name="Inkrementacja">Inkrementacja (++)</h2>

<p>Operator inkrementacji zwiększa o 1 wartość operandu i zwraca taką wartość. </p>

<ul>
 <li>Jeśli uzyty jako przyrostek (x++), będzie działał jako postinkrementacja, czyli zwracana wartość nie będzie powiększona.</li>
 <li>Jeśli użyty jako przedrostek (++x), będzie działał jako preinkrementacja, czyli zwracana wartość będzie już powiększona. </li>
</ul>

<h3 id="Składnia_7">Składnia</h3>

<pre><strong>Operator:</strong> x++ lub ++x
</pre>

<h3 id="Examples">Examples</h3>

<pre><code>// Przyrostek
var x = 3;
y = x++; // y = 3, x = 4

// Przedrostek
var a = 2;
b = ++a; // a = 3, b = 3</code></pre>

<p> </p>

<h2 id="Dekrementacja_(--)">Dekrementacja (--)</h2>

<p>Operator dekrementacji zmniejsza o 1 wartość operandu i zwraca taką wartość.</p>

<ul>
 <li>Jeśli uzyty jako przyrostek (x--), będzie działał jako postdekrementacja, czyli zwracana wartość nie będzie pomniejszona.</li>
 <li>Jeśli użyty jako przedrostek (--x), będzie działał jako predekrementacja, czyli zwracana wartość będzie już pomniejszona. </li>
</ul>

<h3 id="Składnia_8">Składnia</h3>

<pre><strong>Operator:</strong> x-- lub --x
</pre>

<h3 id="Przykłady_7">Przykłady</h3>

<pre><code>// Przyrostek
var x = 3;
y = x--; // y = 3, x = 2

// Przedrostek
var a = 2;
b = --a; // a = 1, b = 1</code></pre>

<p> </p>

<h2 id="Inkrementacja" name="Inkrementacja">Negacja (-)</h2>

<p>Jednoargumentowy operator negacji zwraca wartość operandu ze zmienionym znakiem.</p>

<h3 id="Składnia_9">Składnia</h3>

<pre><strong>Operator:</strong> -x
</pre>

<h3 id="Przykłady_8">Przykłady</h3>

<pre><code>var x = 3;
y = -x; // y = -3, x = 3</code></pre>

<p> </p>

<h2 id="Inkrementacja" name="Inkrementacja">Jednoargumentowy plus (+)</h2>

<p>Jest to jednoargumentowy operator, który transformuje inne typy zmiennych do typu Number. Jeśli dana wartość nie może zostać przetransformowana, zwracany jest typ NaN.</p>

<h3 id="Składnia_10">Składnia</h3>

<pre><strong>Operator:</strong> +x
</pre>

<h3 id="Przykłady_9">Przykłady</h3>

<pre><code>+3     // 3
+"3"   // 3
+true  // 1
+false // 0
+null  // 0

var x = function(val){
 return val
}
</code>+x // NaN
</pre>