Dans ce didacticiel, vous découvrirez les opérateurs de comparaison et les opérateurs logiques à l'aide d'exemples.
Opérateurs de comparaison JavaScript
Les opérateurs de comparaison comparent deux valeurs et renvoient une valeur booléenne: soit trueou false. Les opérateurs de comparaison sont utilisés dans la prise de décision et les boucles.
| Opérateur | La description | Exemple |
|---|---|---|
== | Égal à : truesi les opérandes sont égaux | 5==5; //true |
!= | Différent de : truesi les opérandes ne sont pas égaux | 5!=5; //false |
=== | Strict égal à : truesi les opérandes sont égaux et de même type | 5==='5'; //false |
!== | Strict pas égal à : truesi les opérandes sont égaux mais de type différent ou pas du tout égaux | 5!=='5'; //true |
> | Supérieur à : truesi l'opérande gauche est supérieur à l'opérande droit | 3>2; //true |
>= | Supérieur ou égal à : truesi l'opérande gauche est supérieur ou égal à l'opérande droit | 3>=3; //true |
< | Inférieur à : truesi l'opérande gauche est inférieur à l'opérande droit | 3<2; //false |
<= | Inférieur ou égal à : truesi l'opérande gauche est inférieur ou égal à l'opérande droit | 2<=2; //true |
Exemple 1: égal à l'opérateur
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
==évalue truesi les opérandes sont égaux.
Remarque : En JavaScript, ==est un opérateur de comparaison, alors que =c'est un opérateur d'affectation. Si vous utilisez par erreur à la =place de ==, vous pourriez obtenir des résultats indésirables.
Exemple 2: différent de l'opérateur
const a = 3, b = 'hello'; // not equal operator console.log(a != 2); // true console.log(b != 'Hello'); // true
!=évalue truesi les opérandes ne sont pas égaux.
Exemple 3: Strict égal à l'opérateur
const a = 2; // strict equal operator console.log(a === 2); // true console.log(a === '2'); // false
===évalue truesi les opérandes sont égaux et du même type. Ici, 2 et «2» sont les mêmes nombres mais le type de données est différent. Et ===vérifie également le type de données lors de la comparaison.
Remarque : la différence entre ==et ===est que:
==évalue truesi les opérandes sont égaux, cependant, ===évalue trueuniquement si les opérandes sont égaux et du même type
Exemple 4: Strict pas égal à l'opérateur
const a = 2, b = 'hello'; // strict not equal operator console.log(a !== 2); // false console.log(a !== '2'); // true console.log(b !== 'Hello'); // true
!==évalue truesi les opérandes ne sont strictement pas égaux. C'est tout le contraire de strictement égal ===.
Dans l'exemple ci-dessus, 2 != '2'donne true. C'est parce que leurs types sont différents même s'ils ont la même valeur.
Exemple 5: Opérateur Supérieur à
const a = 3; // greater than operator console.log(a> 2); // true
>évalue truesi l'opérande gauche est supérieur à l'opérande droit.
Exemple 6: Opérateur supérieur ou égal à
const a = 3; // greater than or equal operator console.log(a>= 3); //true
>=évalue truesi l'opérande gauche est supérieur ou égal à l'opérande droit.
Exemple 7: Opérateur Inférieur à
const a = 3, b = 2; // less than operator console.log(a < 2); // false console.log(b < 3); // true
<évalue truesi l'opérande gauche est inférieur à l'opérande droit.
Exemple 8: Opérateur inférieur ou égal à
const a = 2; // less than or equal operator console.log(a <= 3) // true console.log(a <= 2); // true
<=évalue truesi l'opérande gauche est inférieur ou égal à l'opérande droit.
Opérateurs logiques JavaScript
Les opérateurs logiques effectuent des opérations logiques: ET , OU et NON .
| Opérateur | La description | Exemple |
|---|---|---|
&& | ET logique : truesi les deux opérandes / valeurs booléennes sont vraies, sinon s'évalue àfalse | true && false; // false |
|| | OU logique : truesi l'une des opérandes / valeurs booléennes est true. évalue falsesi les deux sontfalse | true || false; // true |
! | NON logique : truesi l'opérande est falseet vice-versa. | !true; // false |
Exemple 9: opérateur AND logique
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
&&évalue truesi les deux opérandes sont true, sinon évalue à false.
Remarque: vous pouvez également utiliser des opérateurs logiques avec des nombres. En JavaScript, 0 est falseet toutes les valeurs non nulles le sont true.
Exemple 10: Opérateur OR logique
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
||évalue truesi l'un des opérandes est true. Si les deux opérandes sont false, le résultat est false.
Exemple 11: opérateur NOT logique
const a = true, b = false; // logical NOT console.log(!a); // false console.log(!b); // true
!évalue truesi l'opérande est falseet vice-versa.
