Összehasonlítás ebben a kurzusban:

A(z) Összehasonlítás fogalomról

Számok összehasonlítása

JavaScriptben a számokat az alábbi relációs és egyenlőségoperátorokkal lehet összehasonlítani.

Az összehasonlítás eredménye mindig egy Boolean érték, tehát vagy true, vagy false.

1 < 3;
// => true

2 !== 2;
// => false

1 === 1.0;
// => true
// All numbers are floating-points, so this is different syntax
// for the exact same value.

Stringek összehasonlítása

JavaScriptben a fenti összehasonlító operátorokkal stringeket is össze lehet hasonlítani. Ilyenkor szótári (lexikográfiai) sorrend érvényesül. Az összes karakter pontos sorrendjének listáját itt találod.

'Apple' > 'Pear';
// => false

'a' < 'above';
// => true

'a' === 'A';
// => false

Legyél óvatos, amikor két olyan változót hasonlítasz össze, amelyek numerikus értékeket látszanak tartalmazni, de string típusúak. A szótári sorrend miatt az eredmény nem ugyanaz lesz, mint a Number típusú értékek összehasonlításakor.

10 < 2;
// => false

'10' < '2';
// => true (because "1" comes before "2")

A stringek összehasonlításának másik módja a localeCompare metódus. Ezzel különféle opciókat állíthatsz be, amelyekkel az összehasonlítás módját szabályozhatod.

Szigorú egyenlőség

Talán elgondolkodsz azon, miért három egyenlőségjel szolgál az egyenlőség ellenőrzésére JavaScriptben. A === a szigorú egyenlőség ellenőrzését jelenti, ami azt jelenti, hogy nem történik típuskonverzió, és a különböző típusú értékek mindig egyenlőtlenek.

'3' === 3;
// => false
// The value on the left has type string, the value on the right
// has type number.

1 === 1n;
// => false
// The value on the left has type number, the value on the right
// has type bigint.

JavaScriptben az egyenlőség ellenőrzésére a === és a !== használata ajánlott.

Az implicit típuskonverzió elkerülése

Létezik a == és a != is, amelyek a megengedő egyenlőség ellenőrzését jelentik. Ezeket kerülni érdemes, mert az összehasonlítás előtt implicit típuskonverziót alkalmaznak. Az ilyen esetek kimenetele nehezen megjósolható, és néha nem az, amire számítanál. Erről bővebben itt olvashatsz.

0 == false;
// => true

Elméletben különböző típusú értékeket is összehasonlíthatsz (pl. "1" < 2). Ilyenkor az értékek implicit módon átalakulnak, hogy eldőljön, igaz-e vagy hamis az eredmény. Ahogy a megengedő egyenlőség ellenőrzését, ezt sem ajánlott használni, ugyanazon okból, amit fentebb említettünk.

Mit tegyél helyette? Alkalmazhatsz explicit típuskonverziót. Ezzel biztosíthatod, hogy az értékek a helyes típussal rendelkezzenek, mielőtt elvégzed az összehasonlítást. Így a kódod könnyebben érthető lesz és kevésbé hajlamos a hibákra.