Operatory arytmetyczne

Podsumowanie

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.

Dodawanie (+)

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

Składnia

Operator: x + y

Przykłady

// Number + Number -> dodawanie
1 + 2 // 3

// Boolean + Number -> dodawanie
true + 1 // 2

// Boolean + Boolean -> dodawanie
false + false // 0

// Number + String -> konkatenacja
5 + "foo" // "5foo"

// String + Boolean -> konkatenacja
"foo" + false // "foofalse"

// String + String -> konkatenacja
"foo" + "bar" // "foobar"

Odejmowanie (-)

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

Składnia

Operator: x - y

Przykłady

5 - 3 // 2
3 - 5 // -2
5 - true // 4
"foo" - 3 // NaN

Dzielenie (/)

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

Składnia

Operator: x / y

Przykłady

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

Mnożenie (*)

Operotor mnożenia zwraca wynik mnożenia operandów.

Składnia

Operator: x * y

Przykłady

2 * 2 // 4
-2 * 2 // -4
Infinity * 0 // NaN
Infinity * Infinity // Infinity
"foo" * 2 // NaN

Dzielenie modulo (%)

Operator modulo zwraca resztę z dzielenia pierwszego operandu przez drugi.

Składnia

Operator: var1 % var2

Przykłady

12 % 5 // 2
-1 % 2 // -1
NaN % 2 // NaN
1 % 2 // 1
2 % 3 // 2
-4 % 2 // -0
5.5 % 2 // 1.5

Potęgowanie (**)

Operator ten zwraca wynik gdzie pierwszy operand jest podstawą, a drugi wykładnikiem (var1var2). Operator ten jest asocjacyjny co oznacza, że dopuszalne jest użycie w formie a ** b ** c, co jest równe a ** (b ** c).

Składnia

Operator: var1 ** var2

Uwagi

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 -.
W JavaScript niemożliwe jest użycie operatorów jedno argumentowych (+/-/~/!/delete/void/typeof)  bezpośrednio przed podstawą.

-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

Przykłady

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

Aby odwrócić znak zwracanej wartości:

-(2 ** 2) // -4

Sposób na wymuszenie potęgowania ujemnej liczby:

(-2) ** 2 // 4

Inkrementacja (++)

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

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

Składnia

Operator: x++ lub ++x

Examples

// Przyrostek 
var x = 3;
y = x++; // y = 3, x = 4

// Przedrostek
var a = 2;
b = ++a; // a = 3, b = 3

Dekrementacja (--)

Operator dekrementacji zmniejsza o 1 wartość operandu i zwraca taką wartość.

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

Składnia

Operator: x-- lub --x

Przykłady

// Przyrostek 
var x = 3;
y = x--; // y = 3, x = 2

// Przedrostek
var a = 2;
b = --a; // a = 1, b = 1

Negacja (-)

Jednoargumentowy operator negacji zwraca wartość operandu ze zmienionym znakiem.

Składnia

Operator: -x

Przykłady

var x = 3;
y = -x; // y = -3, x = 3

Jednoargumentowy plus (+)

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.

Składnia

Operator: +x

Przykłady

+3     // 3
+"3"   // 3
+true  // 1
+false // 0
+null  // 0

var x = function(val){
 return val
}
+x // NaN