Ebben az oktatóanyagban megismerheti az összehasonlítás és a logikai operátorok példáinak segítségével.
JavaScript összehasonlító operátorok
Az összehasonlító operátorok két értéket hasonlítanak össze, és logikai értéket adnak vissza: true
vagy false
. Az összehasonlító operátorokat használják a döntéshozatalban és a ciklusokban.
Operátor | Leírás | Példa |
---|---|---|
== | Egyenlő : true ha az operandusok egyenlőek | 5==5; //true |
!= | Nem egyenlő : true ha az operandusok nem egyenlőek | 5!=5; //false |
=== | Szigorúan egyenlő : true ha az operandusok egyenlőek és azonos típusúak | 5==='5'; //false |
!== | Szigorú, nem egyenlő : true ha az operandusok egyenlőek, de különböző típusúak, vagy egyáltalán nem egyenlőek | 5!=='5'; //true |
> | Nagyobb, mint : true ha a bal operandus nagyobb, mint a jobb operandus | 3>2; //true |
>= | Nagyobb vagy egyenlő : true ha a bal operandus nagyobb vagy egyenlő a jobb operandussal | 3>=3; //true |
< | Kevesebb mint : true ha a bal operandus kisebb, mint a jobb operandus | 3<2; //false |
<= | Kevesebb vagy egyenlő : true ha a bal operandus kisebb vagy egyenlő a jobb operandussal | 2<=2; //true |
1. példa: Egyenlő a kezelővel
const a = 5, b = 2, c = 'hello'; // equal to operator console.log(a == 5); // true console.log(b == '2'); // true console.log(c == 'Hello'); // false
==
kiértékeli, true
hogy az operandusok egyenlőek-e.
Megjegyzés : A JavaScript-ben ==
összehasonlító operátor, míg =
hozzárendelési operátor. Ha tévesen használ =
helyett ==
, nem kívánt eredményt érhet el.
2. példa: Nem egyenlő a kezelővel
const a = 3, b = 'hello'; // not equal operator console.log(a != 2); // true console.log(b != 'Hello'); // true
!=
kiértékeli, true
hogy az operandusok nem egyenlőek-e.
3. példa: Szigorú egyenlő a kezelővel
const a = 2; // strict equal operator console.log(a === 2); // true console.log(a === '2'); // false
===
kiértékeli, true
hogy az operandusok azonosak-e és azonos típusúak-e. Itt a 2 és a „2” azonos szám, de az adattípus eltér. És ===
összehasonlítás közben ellenőrzi az adattípust is.
Megjegyzés : A ==
és ===
a különbség az, hogy:
==
értékeli, true
hogy az operandusok megegyeznek-e, azonban csak akkor ===
értékeli, true
ha az operandusok azonosak és azonos típusúak
4. példa: Szigorú, nem egyenlő az üzemeltetővel
const a = 2, b = 'hello'; // strict not equal operator console.log(a !== 2); // false console.log(a !== '2'); // true console.log(b !== 'Hello'); // true
!==
értékeli, true
hogy az operandusok szigorúan nem egyenlőek-e. Ez teljesen ellentéte a szigorúan egyenlőnek ===
.
A fenti példában 2 != '2'
ad true
. Ez azért van, mert típusaik eltérőek, annak ellenére, hogy ugyanaz az értékük.
5. példa: Nagyobb, mint a kezelő
const a = 3; // greater than operator console.log(a> 2); // true
>
kiértékeli, true
hogy a bal operandus nagyobb-e, mint a jobb operandus.
6. példa: Nagyobb vagy egyenlő a kezelővel
const a = 3; // greater than or equal operator console.log(a>= 3); //true
>=
kiértékeli, true
hogy a bal operandus nagyobb-e vagy egyenlő-e a jobb operandussal.
7. példa: Kevesebb, mint operátor
const a = 3, b = 2; // less than operator console.log(a < 2); // false console.log(b < 3); // true
<
kiértékeli, true
hogy a bal operandus kisebb-e, mint a jobb operandus.
8. példa: Kevesebb vagy egyenlő a kezelővel
const a = 2; // less than or equal operator console.log(a <= 3) // true console.log(a <= 2); // true
<=
kiértékeli, true
hogy a bal operandus kisebb vagy egyenlő-e a jobb operandussal.
JavaScript logikai operátorok
A logikai operátorok logikai műveleteket hajtanak végre: AND , OR és NOT .
Operátor | Leírás | Példa |
---|---|---|
&& | Logikai ÉS : true ha mindkét operandus / logikai érték igaz, akkor a másik az értéket értékelifalse | true && false; // false |
|| | Logikai VAGY : true ha az operandusok / logikai értékek bármelyike az true . értékeli, false ha mindkettő igenfalse | true || false; // true |
! | Logikai NEM : true ha az operandus false és fordítva. | !true; // false |
9. példa: Logikai ÉS Operátor
const a = true, b = false; const c = 4; // logical AND console.log(a && a); // true console.log(a && b); // false console.log((c> 2) && (c < 2)); // false
&&
értékeli, true
ha mindkét operandus true
, másképpen értékeli false
.
Megjegyzés: Logikus operátorokat is használhat számokkal. A JavaScriptben a 0 értéke false
és az összes nem nulla érték az true
.
10. példa: Logikai VAGY Operátor
const a = true, b = false, c = 4; // logical OR console.log(a || b); // true console.log(b || b); // false console.log((c>2) || (c<2)); // true
||
kiértékeli, true
hogy bármelyik operandus-e true
. Ha mindkét operandus false
, az eredmény az false
.
11. példa: Logikai NEM operátor
const a = true, b = false; // logical NOT console.log(!a); // false console.log(!b); // true
!
értékeli, true
hogy az operandus-e, false
és fordítva.