1.12 Porovnávací operátory

Výuka

Porovnávací operátory slouží k porovnávání hodnot a vracejí boolean (true nebo false).

Typy porovnání

Type Coercion (koerze typů)

Volné porovnání (==, !=):

• JavaScript automaticky převádí typy
• 5 == '5' → true (string '5' se převede na number)
• Může vést k neočekávaným výsledkům

Přísné porovnání (===, !==):

• Porovnává hodnotu i typ
• 5 === '5' → false (number ≠ string)
• Vždy doporučováno!

JavaScript

// Volné porovnání (==) - s type coercion
5 == '5';        // true  ⚠️
0 == false;      // true  ⚠️
null == undefined; // true ⚠️
'' == 0;         // true  ⚠️

// Přísné porovnání (===) - bez type coercion
5 === '5';       // false ✅
0 === false;     // false ✅
null === undefined; // false ✅
'' === 0;        // false ✅

// Negace
5 != '5';        // false (s koerzí)
5 !== '5';       // true  (bez koerze)

// Číselné porovnání
10 > 5;          // true
10 < 5;          // false
10 >= 10;        // true
10 <= 5;         // false

// String porovnání (lexikografické)
'apple' < 'banana';  // true
'10' < '2';          // true (⚠️ string porovnání!)

TypeScript

// TS kontroluje kompatibilitu typů
const num: number = 5;
const str: string = '5';

// num == str;   // ⚠️ TS varuje (ale zkompiluje)
num === str;     // ❌ Error: This condition will always return 'false'

// S explicitními literal types
type Status = 'success' | 'error';
const status: Status = 'success';

if (status === 'success') {  // ✅ TS ví, že je to ok
  console.log('Úspěch!');
}

// if (status === 'pending') {  // ❌ Error: nevyčerpávající check
//   ...
// }

// Narrowing s type guards
function process(value: string | number) {
  if (typeof value === 'string') {
    // TS ví, že zde je value: string
    console.log(value.toUpperCase());
  } else {
    // TS ví, že zde je value: number
    console.log(value.toFixed(2));
  }
}

Rozdíl JS vs TS

JavaScript:

• Porovnání fungují za běhu
• == provádí type coercion
• Chyby odhalíš až při spuštění

TypeScript:

• Kontroluje kompatibilitu typů při kompilaci
• Varuje před nebezpečnými porovnáními
• Některé chyby odchytí už v editoru

Doporučení:

• Vždy používej === a !== (v obou jazycích)
• V TS využívej type guards pro narrowing

Tip

💡 Vždy používej === místo ==:

// ❌ Špatně - neočekávané chování
if (input == 0) { }  // true pro '', false, 0, '0'

// ✅ Dobře - explicitní
if (input === 0) { }  // true jen pro 0

💡 Pozor na NaN:

NaN == NaN;   // false
NaN === NaN;  // false

// Použij Number.isNaN()
Number.isNaN(NaN);  // true

💡 Porovnání objektů:

{} === {};           // false (různé reference)
[] === [];           // false (různé reference)

const obj1 = { a: 1 };
const obj2 = obj1;
obj1 === obj2;       // true (stejná reference)