Základní operátory, matematika

Mnoho operátorů známe ze Å¡koly. Jsou mezi nimi sčítání +, násobení *, odčítání - a podobnÄ›.

V této kapitole začneme jednoduchými operátory a pak se budeme soustředit na prvky specifické pro JavaScript, které školní aritmetika nepokrývá.

Pojmy: „unární“, „binární“, „operand“

Než budeme pokračovat, ujasníme si základní terminologii.

• Operand je to, na co se aplikují operátory. Například pÅ™i násobení 5 * 2 máme dva operandy: levý operand je 5 a pravý operand je 2. NÄ›kdy se jim místo „operandy“ říká „argumenty“.

• Operátor je unární, jestliže má jediný operand. Například unární negace -, která obrací znaménko čísla:

  let x = 1;
  
  x = -x;
  alert( x ); // -1, byla aplikována unární negace

• Operátor je binární, jestliže má dva operandy. Stejné minus existuje i v binární podobÄ›:

  let x = 1, y = 3;
  alert( y - x ); // 2, binární minus odečítá hodnoty

Formálně mají výše uvedené příklady dva různé operátory, které mají stejný symbol: operátor negace, což je unární operátor měnící znaménko, a operátor odčítání, což je binární operátor odečítající jedno číslo od druhého.

Matematika

JavaScript podporuje následující matematické operace:

• sčítání +,
• odčítání -,
• násobení *,
• dÄ›lení /,
• zbytek po dÄ›lení %,
• umocňování **.

První čtyÅ™i jsou jasné, % a ** potÅ™ebují trochu vysvÄ›tlení.

Zbytek po dělení %

Operátor zbytku po dÄ›lení % nemá navzdory svému symbolu nic společného s procenty.

Výsledkem a % b je zbytek pÅ™i celočíselném dÄ›lení čísla a číslem b.

Příklad:

alert( 5 % 2 ); // 1, zbytek po dělení 5 děleno 2
alert( 8 % 3 ); // 2, zbytek po dělení 8 děleno 3
alert( 8 % 4 ); // 0, zbytek po dělení 8 děleno 4

Umocňování **

Operátor umocňování a ** b umocní a na b-tou.

Ve školní matematice to zapisujeme a^b.

Příklad:

alert( 2 ** 2 ); // 2² = 4
alert( 2 ** 3 ); // 2³ = 8
alert( 2 ** 4 ); // 2⁴ = 16

Stejně jako v matematice je operátor umocňování definován i pro necelá čísla.

Například odmocnina je umocnění na ½:

alert( 4 ** (1/2) ); // 2 (umocnění na 1/2 je totéž jako druhá odmocnina)
alert( 8 ** (1/3) ); // 2 (umocnění na 1/3 je totéž jako třetí odmocnina)

Spojení řetězců pomocí binárního +

Přejděme nyní k vlastnostem JavaScriptu, které jsou za hranicemi školní aritmetiky.

Operátor plus + obvykle sčítá čísla.

Pokud je vÅ¡ak binární + použito na Å™etÄ›zce, spojí je (zÅ™etÄ›zí):

let s = "můj" + "řetězec";
alert(s); // můjřetězec

Všimněte si, že jestliže je kterýkoli z operandů řetězec, bude na řetězec převeden i druhý operand.

Příklad:

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

Vidíme, že nezáleží na tom, zda je řetězec první nebo druhý operand.

Složitější příklad:

alert(2 + 2 + '1' ); // "41", ne "221"

Tady operátory fungují jeden za druhým. První + sečte dvÄ› čísla, takže vrátí 4, pak druhé + k nÄ›mu pÅ™idá Å™etÄ›zec 1, takže je to jako 4 + '1' = 41.

alert('1' + 2 + 2); // "122" a ne "14"

První operand je zde Å™etÄ›zec, takže kompilátor zachází i s ostatními dvÄ›ma operandy jako s Å™etÄ›zci. 2 se zÅ™etÄ›zí s '1', takže to bude jako '1' + 2 = "12" a "12" + 2 = "122".

Binární + je jediný operátor, který takovýmto způsobem podporuje Å™etÄ›zce. Ostatní aritmetické operátory fungují jen s čísly a své operandy pÅ™evádÄ›jí vždy na čísla.

Ukázka odčítání a dělení:

alert( 6 - '2' ); // 4, převede '2' na číslo
alert( '6' / '2' ); // 3, převede oba operandy na čísla

Konverze na číslo a unární +

Plus + existuje ve dvou podobách: binární, kterou jsme používali výše, a unární.

Unární plus, jinými slovy operátor + aplikovaný na jedinou hodnotu, neprovádí s čísly nic. Jestliže vÅ¡ak operand není číslo, unární plus jej pÅ™evede na číslo.

Příklad:

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

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

// Převádí hodnoty, které nejsou čísla
alert( +true ); // 1
alert( +"" );   // 0

DÄ›lá tedy ve skutečnosti totéž jako Number(...), ale je kratší.

Potřeba převádět řetězce na čísla se objevuje velmi často. Například jestliže načítáme hodnoty z polí HTML formulářů, jsou to obvykle řetězce. Co když je chceme sečíst?

Binární plus by je spojilo jako řetězce:

let jablka = "2";
let pomeranče = "3";

alert( jablka + pomeranče ); // "23", binární plus spojuje řetězce

Pokud s nimi chceme zacházet jako s čísly, musíme je napřed konvertovat a teprve pak sečíst:

let jablka = "2";
let pomeranče = "3";

// obě hodnoty převedeme na čísla před binárním plus
alert( +jablka + +pomeranče ); // 5

// delší varianta
// alert( Number(jablka) + Number(pomeranče) ); // 5

Z pohledu matematika může přemíra plusů vypadat podivně, ale z pohledu programátora na tom nic zvláštního není: nejprve se aplikují unární plusy, které převedou řetězce na čísla, a pak je binární plus sečte.

Proč se unární plusy aplikují na hodnoty dříve než binární? Jak uvidíme, je to důsledkem jejich vyšší priority.

Priorita operátorů

Obsahuje-li výraz více než jeden operátor, je pořadí jejich výkonu definováno jejich prioritou, nebo jinými slovy standardním pořadím operátorů.

Ze Å¡koly jistÄ› vÅ¡ichni víme, že ve výrazu 1 + 2 * 2 by násobení mÄ›lo být vyhodnoceno pÅ™ed sčítáním. To je pÅ™esnÄ› otázkou priority. Říkáme, že násobení má vyšší prioritu než sčítání.

Závorky mají pÅ™ednost pÅ™ed veÅ¡kerou prioritou, takže nejsme-li spokojeni se standardním poÅ™adím, můžeme je s jejich pomocí zmÄ›nit. Například zapíšeme (1 + 2) * 2.

JavaScript obsahuje mnoho operátorů. Každému z nich odpovídá hodnota jeho priority. Dříve se vykoná ten, jehož priorita je vyšší. Je-li priorita více operátorů stejná, vykonávají se v pořadí zleva doprava.

Následuje výtažek z tabulky priorit (nemusíte si ji celou pamatovat, ale všimněte si, že unární operátory mají vyšší prioritu než odpovídající binární):

Jak vidíme, „unární plus“ má prioritu 14, která je vyšší než priorita 11 „sčítání“ (binární plus). To je důvod, proč se ve výrazu "+jablka + +pomeranče" unární plusy vyhodnotí pÅ™ed sčítáním.

Přiřazení

VÅ¡imnÄ›te si, že pÅ™iÅ™azení = je také operátor. V tabulce priorit je uveden s velmi nízkou prioritou 2.

To je důvod, proč pÅ™i pÅ™iÅ™azení promÄ›nné, napÅ™. x = 2 * 2 + 1, se nejprve provedou výpočty a až potom se vyhodnotí =, které uloží výsledek do x.

let x = 2 * 2 + 1;

alert( x ); // 5

Přiřazení = vrátí hodnotu

Skutečnost, že = je operátor a ne nÄ›jaký „magický“ jazykový konstrukt, má zajímavý důsledek.

VÅ¡echny operátory v JavaScriptu vracejí nÄ›jakou hodnotu. Pro + a - je to samozÅ™ejmé, ale platí to i pro =.

Volání x = hodnota zapíše hodnotu hodnota do x a pak ji vrátí.

Následuje ukázka, v níž je přiřazení využito jako součást složitějšího výrazu:

let a = 1;
let b = 2;

let c = 3 - (a = b + 1);

alert( a ); // 3
alert( c ); // 0

V uvedeném příkladu je výsledkem výrazu (a = b + 1) hodnota, která je pÅ™iÅ™azena do a (což je 3). Ta se pak použije pro další výpočty.

Legrační kód, že? Měli bychom porozumět, jak funguje, protože v knihovnách JavaScriptu bývá občas k vidění.

Přesto vás prosíme, abyste takový kód nepsali. Takové triky zcela jistě nepřispívají k jeho jasnosti a čitelnosti.

Zřetězení přiřazení

Další zajímavá vlastnost je možnost zřetězit přiřazení za sebou:

let a, b, c;

a = b = c = 2 + 2;

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

ZÅ™etÄ›zená pÅ™iÅ™azení se vyhodnocují zprava doleva. Nejprve se vyhodnotí výraz 2 + 2 nejvíce vpravo a jeho hodnota se pak pÅ™iÅ™adí do promÄ›nných vlevo: c, b a a. Nakonec tedy budou mít vÅ¡echny promÄ›nné stejnou hodnotu.

Opět je pro účely čitelnosti lepší rozdělit takový kód do více řádků:

c = 2 + 2;
b = c;
a = c;

Snadněji se to čte, zejména když kód rychle projíždíte očima.

Modifikace na místě

Často potřebujeme aplikovat operátor na nějakou proměnnou a uložit nový výsledek do této proměnné.

Příklad:

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

Tento zápis lze zkrátit pomocí operátorů += a *=:

let n = 2;
n += 5; // nyní n = 7 (totéž jako n = n + 5)
n *= 2; // nyní n = 14 (totéž jako n = n * 2)

alert( n ); // 14

Takové „modifikační“ operátory existují pro vÅ¡echny aritmetické a bitové operátory: /=, -=, apod.

Tyto operátory mají stejnou prioritu jako běžné přiřazení, takže se provedou až po většině ostatních výpočtů:

let n = 2;

n *= 3 + 5; // napřed se provede část vpravo, totéž jako n *= 8

alert( n ); // 16

Inkrementace a dekrementace

Jednou z nejběžnějších číselných operací je zvýšení nebo snížení čísla o 1 (inkrementace, dekrementace).

Proto pro ně existují speciální operátory:

• Inkrementace ++ zvýší promÄ›nnou o 1:

  let čítač = 2;
  čítač++;        // funguje stejně jako čítač = čítač + 1, ale je to kratší
  alert( čítač ); // 3

• Dekrementace -- sníží promÄ›nnou o 1:

  let čítač = 2;
  čítač--;        // funguje stejně jako čítač = čítač - 1, ale je to kratší
  alert( čítač ); // 1

Operátory ++ a -- lze umístit pÅ™ed i za promÄ›nnou.

• Je-li operátor umístÄ›n za promÄ›nnou, nazývá se to „postfixová notace“: čítač++.
• „Prefixová notace“ je umístÄ›ní operátoru pÅ™ed promÄ›nnou: ++čítač.

Oba tyto příkazy vykonají totéž: zvýší čítač o 1.

Je v nich tedy nÄ›jaký rozdíl? Ano, ale uvidíme ho jen tehdy, když použijeme hodnotu, kterou operátor ++/-- vrátí.

Ujasněme si to. Jak víme, všechny operátory vracejí nějakou hodnotu. Inkrementace a dekrementace nejsou výjimkou. Prefixová notace vrací novou hodnotu, zatímco postfixová notace vrací starou hodnotu (tu před zvýšením nebo snížením).

Abychom viděli rozdíl, uvedeme příklad:

let čítač = 1;
let a = ++čítač; // (*)

alert(a); // 2

Na řádku (*) prefixová notace ++čítač zvýšila čítač a vrátila novou hodnotu, 2. Proto alert zobrazila 2.

Nyní použijeme postfixovou notaci:

let čítač = 1;
let a = čítač++; // (*) změnili jsme ++čítač na čítač++

alert(a); // 1

Na řádku (*) postfixová notace čítač++ rovněž zvýšila čítač, ale vrátila starou hodnotu (tu pÅ™ed zvýšením). Proto alert zobrazil 1.

Shrneme to:

• Pokud výsledek zvýšení nebo snížení nepoužijeme, není rozdíl v tom, kterou notaci použijeme:

  let čítač = 0;
  čítač++;
  ++čítač;
  alert( čítač ); // 2, oba výše uvedené řádky dělají totéž

• Pokud chceme zvýšit hodnotu a výsledek operátoru ihned použít, potÅ™ebujeme prefixovou notaci:

  let čítač = 0;
  alert( ++čítač ); // 1

• Pokud chceme zvýšit hodnotu, ale použít pÅ™edchozí hodnotu, potÅ™ebujeme postfixovou notaci:

  let čítač = 0;
  alert( čítač++ ); // 0

let čítač = 1;
alert( 2 * ++čítač ); // 4

let čítač = 1;
alert( 2 * čítač++ ); // 2, protože čítač++ vrací „starou“ hodnotu

let čítač = 1;
alert( 2 * čítač );
čítač++;

Bitové operátory

Bitové operátory zacházejí s argumenty jako s 32-bitovými celými čísly a pracují na úrovni jejich binární reprezentace.

Tyto operátory nejsou specifické pro JavaScript. Podporuje je většina programovacích jazyků.

Seznam operátorů:

• AND ( & )
• OR ( | )
• XOR ( ^ )
• NOT ( ~ )
• LEFT SHIFT (posun doleva) ( << )
• RIGHT SHIFT (posun doprava) ( >> )
• ZERO-FILL RIGHT SHIFT (posun doprava s doplnÄ›ním nul) ( >>> )

Tyto operátory se používají jen velmi zřídka, když potřebujeme pracovat s čísly na naprosto nejnižší (bitové) úrovni. Nebudeme je v dohledné době potřebovat, jelikož při vývoji webů se využívají jen málokdy, ale jsou užitečné v některých speciálních oblastech, například v kryptografii. Až je budete potřebovat, můžete si o nich přečíst článek na MDN.

Čárka

Operátor čárky , je jeden z nejvzácnÄ›jších a nejneobvyklejších operátorů. NÄ›kdy se používá k psaní kratšího kódu, takže jej potÅ™ebujeme znát, abychom pochopili, o co tady jde.

Operátor čárky nám umožňuje vyhodnotit nÄ›kolik výrazů za sebou, oddÄ›lených čárkou ,. Vyhodnotí se každý z nich, ale vrátí se jen výsledek posledního.

Příklad:

let a = (1 + 2, 3 + 4);

alert( a ); // 7 (výsledek 3 + 4)

Zde se napÅ™ed vyhodnotí první výraz 1 + 2 a jeho výsledek se zahodí. Pak se vyhodnotí 3 + 4 a jeho výsledek je vrácen.

K čemu potřebujeme operátor, který zahodí všechno kromě posledního výrazu?

Někdy jej lidé používají ve složitějších konstrukcích, aby umístili několik akcí na jeden řádek.

Příklad:

// tři operace na jednom řádku
for (a = 1, b = 3, c = a * b; a < 10; a++) {
 ...
}

Takové triky se používají v mnoha rámcích JavaScriptu, a proto se o nich zmiňujeme. Obvykle však zrovna nezlepšují čitelnost kódu, a proto byste si jejich používání měli dobře rozmyslet.