Operátory

Unárne, binárne a operandy

  • Operand – je to, na čo sú operátori aplikované. Napríklad pri násobení 5 * 2 existujú dva operandy: ľavý operand je 5 a správny operand je 2. Niekedy ľudia nazývajú tieto časti aj ako „argumenty“ namiesto „operandov“.
  • Operátor je unárny, ak má jediný operand. Napríklad unárna negácia – obráti znak určitého čísla:
    let x = 1;
    
    x = -x;
    alert( x ); // -1, aplikovaná unárna negácia
  • Operátor je binárny, ak má dva operandy. Rovnaké mínus existuje aj v binárnej forme:
    let x = 1, y = 3;
    alert( y - x ); // 2, binárne mínus odčíta operandy

Zreťazenie a binárne +

Teraz sa pozrieme na špeciálne funkcie operátorov JavaScript, ktoré neoznačujú aritmetické operácie.

Operátor plus + zvyčajne čísla sčítava.

Ak sa však binárne + aplikuje na reťazce,tak sa reťazce spájajú:

let s = "my" + "string";
alert(s); // mystring

Všimnite si, že ak je jeden z operandov reťazec, druhý je automaticky konvertovaný na reťazec.

Napríklad:

alert( '1' + 2 ); // "12"
alert( 2 + '1' ); // "21"

Pravidlo je jednoduché: ak je jeden operand reťazec, druhý je tiež premenený na reťazec.

Operácie prebiehajú zľava doprava. Ak sú dve čísla nasledované reťazcom, čísla sa sčítajú pred konverziou na reťazec:

alert(2 + 2 + '1' ); // "41" a nie "221"

Reťazcové zlučovanie a konverzia je zabezpečené špeciálnym znakom binárneho plusu +. Ostatné aritmetické operátory pracujú len s číslami a vždy konvertujú svoje operandy na čísla.

Napríklad odčítanie a delenie:

alert( 2 - '1' ); // 1
alert( '6' / '2' ); // 3

Numerická konverzia a unárne +

Plus + existuje v dvoch formách: binárnej forme, ktorú sme použili vyššie a vo forme unárnej.

Unárne plus alebo inými slovami plus operátor + aplikovaný na jednu hodnotu, nerobí s číslom nič. Ale ak operand nie je číslo, unárne plus ho premení na číslo.

Napríklad:

// Žiaden efekt na čísla
let x = 1;
alert( +x ); // 1

let y = -2;
alert( +y ); // -2

// Konvertuje premenné a literály na čísla
alert( +true ); // 1
alert( +"" );   // 0

V skutočnosti robí to isté ako  funkcia Number(...), ale je to kratšie.

Potreba konvertovať reťazce na čísla vzniká veľmi často. Ak napríklad získavame hodnoty z polí formulára HTML, tak sú to zvyčajne reťazce.

Čo ak ich chceme sumarizovať?

Binárny plus by ich pridal tým pádom ako reťazce:

let apples = "2";
let oranges = "3";

alert( apples + oranges ); // "23", binárne plus spojí reťazce

Ak ich chceme považovať za čísla, musíme ich konvertovať a potom ich sčítať:

let apples = "2";
let oranges = "3";

// obydve čísla sú najprv zkonvertované a potom sčítané
alert( +apples + +oranges ); // 5

// dlhšia varianta
// alert( Number(apples) + Number(oranges) ); // 5

Z hľadiska matematiky sa zdá daný zápis zvláštny. Ale z hľadiska programátora nie je nič zvláštne: najprv sa používajú unárne plusy, konvertujú reťazce na čísla a potom ich binárne plus sumarizuje.

Prečo sú unárne plusy aplikované na hodnoty pred binárnymi plusmi? Ako uvidíme, je to kvôli ich vyššej priorite. Priority sú dané nasledovne:

Priorita Názov Symbol
16 unárne plus +
16 unárne mínus -
14 násobenie *
14 delenie /
13 sčítanie +
13 odčítanie -
3 priradenie =

Ako môžeme vidieť, unárne plus má prioritu 16, ktorá je vyššia ako 13 pre sčítanie. Preto vo výraze "+apples + +oranges" sa najprv aplikujú unárne plusy a potom klasické sčítavanie.

Celá tabuľka je rozpísaná na https://developer.mozilla.org.

Priradenie =

Priradenie je taktiež vyobrazené ako operátor =. Podľa tabuľky priorít má prioritu veľmi nízku a to číslo 3.

Preto keď priraďujeme premennú, ako x = 2 * 2 + 1, výpočty sa vykonajú najprv a potom sa vyhodnotí =, pričom výsledok sa uloží do x.

let x = 2 * 2 + 1;

alert( x ); // 5

Taktiež je možné zreťazenie priradení ako:

let a, b, c;

a = b = c = 2 + 2;

alert( a ); // 4
alert( b ); // 4
alert( c ); // 4

Zreťazené priradenia sa hodnotia sprava doľava. Najprv sa vyhodnotí pravý výraz 2 + 2 a potom sa priradí k premenným vľavo: c, b a a. Na konci všetky premenné zdieľajú jednu hodnotu.

Modulo %

Operátor modulo % napriek svojmu vzhľadu nesúvisí s percentami.

Výsledkom a% b je zvyšok celočíselného delenia a a b.

Napríklad:

alert( 5 % 2 ); // 1
alert( 8 % 3 ); // 2
alert( 6 % 3 ); // 0

Umocňovanie **

Pre číslo b, výsledok a ** b je a násobené samo sebou b krát.

Napríklad:

alert( 2 ** 2 ); // 4  (2 * 2)
alert( 2 ** 3 ); // 8  (2 * 2 * 2)
alert( 2 ** 4 ); // 16 (2 * 2 * 2 * 2)

Operátor funguje aj na necelých čísel:

alert( 4 ** (1/2) ); // 2 (mocnina 1/2 je rovnaká ako druhá odmocnina)
alert( 8 ** (1/3) ); // 2 (mocnina 1/3 je rovnaká ako tretia odmocnina)

Inkrement / dekrement

Zvyšovanie alebo zníženie čísla o jedno patrí medzi najbežnejšie číselné operácie.

Existujú preto špeciálne operátory:

  • Inkrement – navýšenie hodnotu premennej o 1
    let counter = 2;
    counter++;      // skrátený zápis pre counter = counter + 1
    alert( counter ); // 3
  • Dekrement – zniženie hodnoty premennej o 1
    let counter = 2;
    counter--;      // skrátený zápis pre counter = counter - 1
    alert( counter ); // 1

Operátory ++ a -- môžu byť umiestnené pred alebo po premennej:

  • Keď operátor prejde za premennú, je vo forme „postfix“: counter++.
  • „prefix“ je, keď sa operátor nachádza pred premennou: ++counter.

Rozdiel medzi prefixom a postfixom je v poradí vykonávania operácií s nimi spojenými.

let counter = 1;
let a = ++counter;

alert(a); // 2

Ak je použitý prefix, tak sa číslo najprv inkrementuje a potom inkrementované číslo sa priradí k premennej a.

let counter = 1;
let a = counter++;

alert(a); // 1

Ak je použitý postfix, tak premenná counter je síce inkrementovaná, ale do premennej a sa uloží predošlá hodnota.

Úprava na mieste

Častokrát budeme potrebovať pridanie operátora k premennej a uložiť nový výsledok do tej istej premennej.

Napríklad:

let n = 2;
n = n + 5;
n = n * 2;

Táto asociácia môže byť aj skrátene použitá pomocou operátorov += a *=:

let n = 2;
n += 5; // now n = 7 (same as n = n + 5)
n *= 2; // now n = 14 (same as n = n * 2)

alert( n ); // 14

Takéto operátory priradenia majú rovnakú dôležitosť ako obyčajné priradenie.

let n = 2;

n *= 3 + 5;

alert( n ); // 16  (najprv je vyhodnotená pravá časť, rovnako ako n *= 8)