Porovnávání

Z matematiky známe mnoho porovnávacích operátorů.

V JavaScriptu se píší následovně:

• VÄ›tší/menší než: a > b, a < b.
• VÄ›tší/menší nebo rovno: a >= b, a <= b.
• Rovno: a == b. Prosíme vÅ¡imnÄ›te si, že znak dvou rovnítek za sebou == znamená test rovnosti, zatímco jediné rovnítko a = b znamená pÅ™iÅ™azení.
• Nerovno: v matematice se používá znak ≠, ale v JavaScriptu se píše a != b.

V tomto článku se dozvíme víc o různých druzích porovnání a o tom, jak s nimi JavaScript zachází, včetně důležitých zvláštností.

Na konci najdete recept, jak se vyhnout různým problémům způsobeným JavaScriptovými „vtípky“.

Výsledkem je typ boolean

Všechny porovnávací operátory vracejí hodnotu typu boolean:

• true – znamená „ano“, „správně“ nebo „pravda“.
• false – znamená „ne“, „nesprávně“ nebo „nepravda“.

Příklad:

alert( 2 > 1 );  // true (správně)
alert( 2 == 1 ); // false (nesprávně)
alert( 2 != 1 ); // true (správně)

Výsledek porovnání můžeme přiřadit do proměnné, stejně jako každou jinou hodnotu:

let výsledek = 5 > 4; // přiřadíme výsledek porovnání
alert( výsledek ); // true

Porovnávání řetězců

Ke zjištění, zda je jeden řetězec větší než jiný, JavaScript používá tzv. „slovníkové“ neboli „lexikografické“ pořadí.

Jinými slovy, řetězce se porovnávají znak po znaku.

Příklad:

alert( 'Z' > 'A' ); // true
alert( 'Glow' > 'Glee' ); // true
alert( 'Bee' > 'Be' ); // true

Algoritmus pro porovnání dvou řetězců je jednoduchý:

1. Porovnej první znak obou řetězců.
2. Je-li první znak prvního řetězce větší (nebo menší) než první znak druhého řetězce, je první řetězec větší (nebo menší) než druhý. Tím jsme hotovi.
3. V opačném případě, tedy jsou-li první znaky obou řetězců stejné, porovnej stejným způsobem druhé znaky.
4. Tento proces opakuj, dokud nedojdeš na konec některého z řetězců.
5. Mají-li oba řetězce stejnou délku, jsou si rovny. V opačném případě je delší řetězec větší.

Ve výše uvedených příkladech porovnání 'Z' > 'A' dojde k výsledku hned v prvním kroku.

Porovnání Å™etÄ›zců "Glow" a "Glee" vÅ¡ak vyžaduje více kroků, jelikož Å™etÄ›zce se porovnávají znak po znaku:

1. G je stejné jako G.
2. l je stejné jako l.
3. o je vÄ›tší než e. Tady se zastavíme. První Å™etÄ›zec je vÄ›tší.

Porovnávání rozdílných typů

Když JavaScript porovnává hodnoty různých typů, převádí je na čísla.

Příklad:

alert( '2' > 1 ); // true, řetězec '2' se převede na číslo 2
alert( '01' == 1 ); // true, řetězec '01' se převede na číslo 1

U hodnot typu boolean se true pÅ™evede na 1 a false na 0.

Příklad:

alert( true == 1 ); // true
alert( false == 0 ); // true

let a = 0;
alert( Boolean(a) ); // false

let b = "0";
alert( Boolean(b) ); // true

alert(a == b); // true!

Striktní rovnost

Běžné ověření rovnosti == má problém. Nedokáže rozliÅ¡it 0 od false:

alert( 0 == false ); // true

Totéž platí pro prázdný řetězec:

alert( '' == false ); // true

To se dÄ›je proto, že operátor rovnosti == pÅ™evádí operandy různých typů na čísla. Prázdný Å™etÄ›zec, stejnÄ› jako false, se pÅ™evede na nulu.

Co máme dÄ›lat, jestliže chceme rozliÅ¡it 0 od false?

Operátor striktní rovnosti === zkontroluje rovnost bez typové konverze.

Jinými slovy, jsou-li a a b různých typů, pak a === b okamžitÄ› vrátí false, aniž by se je pokusil konvertovat.

Zkusme to:

alert( 0 === false ); // false, protože typy jsou různé

Existuje i operátor „striktní nerovnosti“ !==, který je analogický s !=.

Operátor striktní rovnosti se píše trošičku déle, ale díky němu je hned zřejmé, o co tady jde, a ponechává méně prostoru k chybám.

Porovnávání s null a undefined

Chování pÅ™i porovnávání null nebo undefined s jinými hodnotami není zcela intuitivní.

U operátoru striktní rovnosti ===

Tyto hodnoty jsou různé, protože každá z nich je jiného typu.

alert( null === undefined ); // false

U operátoru nestriktní rovnosti ==

Platí zvláštní pravidlo. Tyto dvÄ› hodnoty tvoří „zamilovanou dvojici“: jsou si navzájem rovny (ve smyslu ==), ale nejsou rovny žádné jiné hodnotÄ›.

alert( null == undefined ); // true

U matematických a jiných porovnání < > <= >=

null/undefined se pÅ™evádÄ›jí na čísla: null se pÅ™evede na 0, zatímco undefined se pÅ™evede na NaN.

Nyní se podívejme na některé legrační jevy, k nimž dochází při použití těchto pravidel. A, což je důležitější, jak se s nimi nechytit do pasti.

Podivný výsledek: null vs 0

Porovnejme null s nulou:

alert( null > 0 );  // (1) false
alert( null == 0 ); // (2) false
alert( null >= 0 ); // (3) true

Matematicky je to zvláštní. Poslední uvedený výsledek tvrdí, že „null je vÄ›tší nebo rovno nule“, takže jedno z výše uvedených porovnání musí být true, ale obÄ› jsou false.

Důvodem je, že test rovnosti == a porovnání > < >= <= fungují odliÅ¡nÄ›. Porovnání pÅ™evedou null na číslo a zacházejí s ním jako s 0. Proto (3) null >= 0 platí a (1) null > 0 neplatí.

Naproti tomu rovnost == pro undefined a null je definována tak, že se bez jakýchkoli konverzí rovnají navzájem a nerovnají se ničemu jinému. Proto (2) null == 0 neplatí.

Neporovnatelné undefined

Hodnota undefined by nemÄ›la být porovnávána s jinými hodnotami:

alert( undefined > 0 ); // false (1)
alert( undefined < 0 ); // false (2)
alert( undefined == 0 ); // false (3)

Proč ji porovnávání nemá tak rádo? Vždycky vyjde false!

Tyto výsledky jsme získali, protože:

• Porovnání (1) a (2) vracejí false, protože undefined se pÅ™evede na NaN a NaN je speciální číselná hodnota, která pÅ™i vÅ¡ech porovnáních vrátí false.
• Test rovnosti (3) vrací false, protože undefined se rovná jedinÄ› null a undefined, žádné jiné hodnotÄ›.

Jak se vyhnout problémům

Jak se přes tyto příklady přenést? Měli bychom si tyto zvláštnosti neustále pamatovat? Vlastně ani ne. Ve skutečnosti se s těmito triky postupem času sžijete, ale existuje solidní způsob, jak se vyhnout problémům, které způsobují:

• Zacházejte s každým porovnáním s undefined/null kromÄ› striktní rovnosti === výjimečnÄ› opatrnÄ›.
• Nepoužívejte porovnání >= > < <= na promÄ›nnou, která by mohla být null/undefined, pokud si opravdu nejste jisti tím, co dÄ›láte. Může-li promÄ›nná obsahovat tyto hodnoty, ověřte je zvlášť.

Shrnutí

• Porovnávací operátory vracejí hodnotu typu boolean.
• ŘetÄ›zce se porovnávají znak po znaku podle „slovníkového“ poÅ™adí.
• Když se porovnávají hodnoty různých typů, pÅ™evedou se na čísla (s výjimkou operátoru striktní rovnosti).
• Hodnoty null a undefined se rovnají == sobÄ› navzájem, ale nerovnají se žádné jiné hodnotÄ›.
• Buďte opatrní pÅ™i používání porovnávání jako < nebo > na promÄ›nné, které mohou být null/undefined. Dobrý nápad je oddÄ›lenÄ› ověřit, zda opravdu jsou null/undefined.