In deze zelfstudie leert u met behulp van voorbeelden over de vergelijkingsoperatoren en logische operatoren.
JavaScript-vergelijkingsoperatoren
Vergelijkingsoperatoren vergelijken twee waarden en geven een booleaanse waarde terug: ofwel true
of false
. Vergelijkingsoperatoren worden gebruikt bij besluitvorming en loops.
Operator | Omschrijving | Voorbeeld |
---|---|---|
== | Gelijk aan : true als de operanden gelijk zijn | 5==5; //true |
!= | Niet gelijk aan : true als de operanden niet gelijk zijn | 5!=5; //false |
=== | Strikt gelijk aan : true als de operanden gelijk zijn en van hetzelfde type | 5==='5'; //false |
!== | Strikt niet gelijk aan : true als de operanden gelijk zijn maar van een ander type of helemaal niet gelijk | 5!=='5'; //true |
> | Groter dan : true als de linker operand groter is dan de rechter operand | 3>2; //true |
>= | Groter dan of gelijk aan : true als de linker operand groter is dan of gelijk is aan de rechter operand | 3>=3; //true |
< | Minder dan : true als de linker operand kleiner is dan de rechter operand | 3<2; //false |
<= | Kleiner dan of gelijk aan : true als de linker operand kleiner is dan of gelijk is aan de rechter operand | 2<=2; //true |
Voorbeeld 1: gelijk aan operator
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
==
evalueert true
of de operanden gelijk zijn.
Opmerking : in JavaScript ==
is het een vergelijkingsoperator, terwijl het =
een toewijzingsoperator is. Als u per ongeluk in =
plaats van gebruikt ==
, krijgt u mogelijk een ongewenst resultaat.
Voorbeeld 2: niet gelijk aan operator
const a = 3, b = 'hello'; // not equal operator console.log(a != 2); // true console.log(b != 'Hello'); // true
!=
evalueert true
of de operanden niet gelijk zijn.
Voorbeeld 3: Strikt gelijk aan operator
const a = 2; // strict equal operator console.log(a === 2); // true console.log(a === '2'); // false
===
evalueert true
of de operanden gelijk zijn en van hetzelfde type. Hier zijn 2 en '2' dezelfde nummers, maar het datatype is anders. En ===
controleert ook het gegevenstype tijdens het vergelijken.
Opmerking : het verschil tussen ==
en ===
is dat:
==
evalueert naar true
of de operanden gelijk zijn, ===
evalueert echter true
alleen naar als de operanden gelijk en van hetzelfde type zijn
Voorbeeld 4: Strikt niet gelijk aan operator
const a = 2, b = 'hello'; // strict not equal operator console.log(a !== 2); // false console.log(a !== '2'); // true console.log(b !== 'Hello'); // true
!==
evalueert true
of de operanden strikt niet gelijk zijn. Het is het tegenovergestelde van strikt gelijk ===
.
In het bovenstaande voorbeeld 2 != '2'
geeft true
. Het is omdat hun typen verschillen, ook al hebben ze dezelfde waarde.
Voorbeeld 5: Groter dan operator
const a = 3; // greater than operator console.log(a> 2); // true
>
evalueert true
of de linker operand groter is dan de rechter operand.
Voorbeeld 6: groter dan of gelijk aan operator
const a = 3; // greater than or equal operator console.log(a>= 3); //true
>=
evalueert true
of de linker operand groter is dan of gelijk is aan de rechter operand.
Voorbeeld 7: Minder dan operator
const a = 3, b = 2; // less than operator console.log(a < 2); // false console.log(b < 3); // true
<
evalueert true
of de linker operand kleiner is dan de rechter operand.
Voorbeeld 8: kleiner dan of gelijk aan operator
const a = 2; // less than or equal operator console.log(a <= 3) // true console.log(a <= 2); // true
<=
evalueert true
of de linker operand kleiner is dan of gelijk is aan de rechter operand.
Logische JavaScript-operators
Logische operators voeren logische bewerkingen uit: AND , OR en NOT .
Operator | Omschrijving | Voorbeeld |
---|---|---|
&& | Logische AND : true als beide operanden / booleaanse waarden waar zijn, evalueert else naarfalse | true && false; // false |
|| | Logische OF : true als een van de operanden / booleaanse waarden true . evalueert false of beide zijnfalse | true || false; // true |
! | Logisch NIET : true als de operand is false en vice versa. | !true; // false |
Voorbeeld 9: Logische EN-operator
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
&&
evalueert true
of beide operanden zijn true
, else evalueert naar false
.
Opmerking: u kunt ook logische operatoren gebruiken met getallen. In JavaScript is 0 false
en alle niet-nulwaarden zijn true
.
Voorbeeld 10: Logische OF-operator
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
||
evalueert true
of een van de operanden is true
. Als beide operanden zijn false
, is het resultaat false
.
Voorbeeld 11: Logische NOT-operator
const a = true, b = false; // logical NOT console.log(!a); // false console.log(!b); // true
!
evalueert true
of de operand is false
en vice versa.