Dans ce didacticiel, vous découvrirez les différents opérateurs disponibles en JavaScript et comment les utiliser à l'aide d'exemples.
Qu'est-ce qu'un opérateur?
En JavaScript, un opérateur est un symbole spécial utilisé pour effectuer des opérations sur des opérandes (valeurs et variables). Par exemple,
2 + 3; // 5
Voici +un opérateur qui effectue l'addition, et 2et 3sont des opérandes.
Types d'opérateurs JavaScript
Voici une liste des différents opérateurs que vous apprendrez dans ce tutoriel.
- Opérateurs d'affectation
- Opérateurs arithmétiques
- Opérateurs de comparaison
- Opérateurs logiques
- Opérateurs au niveau du bit
- Opérateurs de chaîne
- Autres opérateurs
Opérateurs d'affectation JavaScript
Les opérateurs d'affectation sont utilisés pour affecter des valeurs aux variables. Par exemple,
const x = 5;
Ici, l' =opérateur est utilisé pour affecter une valeur 5à la variable x.
Voici une liste des opérateurs d'affectation couramment utilisés:
| Opérateur | Nom | Exemple |
|---|---|---|
= | Opérateur d'assignation | a = 7; // 7 |
+= | Affectation d'addition | a += 5; // a = a + 5 |
-= | Affectation de soustraction | a -= 2; // a = a - 2 |
*= | Affectation de multiplication | a *= 3; // a = a * 3 |
/= | Affectation de division | a /= 2; // a = a / 2 |
%= | Affectation du reste | a %= 2; // a = a % 2 |
**= | Affectation d'exponentiation | a **= 2; // a = a**2 |
Remarque: l' opérateur d'affectation couramment utilisé est =. Vous comprendrez d' autres opérateurs d'affectation tels que +=, -=, *=etc. une fois que nous apprenons des opérateurs arithmétiques.
Opérateurs arithmétiques JavaScript
Les opérateurs arithmétiques sont utilisés pour effectuer des calculs arithmétiques . Par exemple,
const number = 3 + 5; // 8
Ici, l' +opérateur est utilisé pour ajouter deux opérandes.
| Opérateur | Nom | Exemple |
|---|---|---|
+ | Une addition | x + y |
- | Soustraction | x - y |
* | Multiplication | x * y |
/ | Division | x / y |
% | Reste | x % y |
++ | Incrément (incrément de 1) | ++x ou x++ |
-- | Décrémenter (décrémente de 1) | --x ou x-- |
** | Exponentiation (puissance) | x ** y |
Exemple 1: opérateurs arithmétiques en JavaScript
let x = 5; let y = 3; // addition console.log('x + y = ', x + y); // subtraction console.log('x - y = ', x - y); // multiplication console.log('x * y = ', x * y); // division console.log('x / y = ', x / y); // remainder console.log('x % y = ', x % y); // increment console.log('++x = ', ++x); // x is now 6 console.log('x++ = ', x++); // x returns 6 and then increases by 1 console.log('x = ', x); // decrement console.log('--x = ', --x); // x is now 6 console.log('x-- = ', x--); // x returns 6 and then increases by 1 console.log('x = ', x); //exponentiation console.log('x ** y =', x ** y);
Visitez ++ et - opérateur pour en savoir plus.
Production
x + y = 8 x - y = 2 x * y = 15 x / y = 1,6666666666666667 x% y = 2 ++ x = 6 x ++ = 6 x = 7 --x = 6 x-- = 6 x = 5 x ** y = 125
Remarque : L'opérateur ** a été introduit dans EcmaScript 2016 et certains navigateurs peuvent ne pas les prendre en charge. Pour en savoir plus, consultez la page de support du navigateur d'exponentiation JavaScript.
Opérateurs de comparaison JavaScript
Les opérateurs de comparaison comparent deux valeurs et renvoient une valeur booléenne, soit trueou false. Par exemple,
const a = 3, b = 2; console.log(a> b); // true
Ici, l'opérateur de comparaison >est utilisé pour comparer si a est supérieur à b.
| Opérateur | La description | Exemple |
|---|---|---|
== | Égal à : retourne truesi les opérandes sont égaux | x == y |
!= | Non égal à : retourne truesi les opérandes ne sont pas égaux | x != y |
=== | Strict égal à : truesi les opérandes sont égaux et de même type | x === y |
!== | Strict pas égal à : truesi les opérandes sont égaux mais de type différent ou pas du tout égaux | x !== y |
> | Supérieur à : truesi l'opérande gauche est supérieur à l'opérande droit | x> y |
>= | Supérieur ou égal à : truesi l'opérande gauche est supérieur ou égal à l'opérande droit | x>= y |
< | Inférieur à : truesi l'opérande gauche est inférieur à l'opérande droit | x < y |
<= | Inférieur ou égal à : truesi l'opérande gauche est inférieur ou égal à l'opérande droit | x <= y |
Exemple 2: opérateurs de comparaison en JavaScript
// equal operator console.log(2 == 2); // true console.log(2 == '2'); // true // not equal operator console.log(3 != 2); // true console.log('hello' != 'Hello'); // true // strict equal operator console.log(2 === 2); // true console.log(2 === '2'); // false // strict not equal operator console.log(2 !== '2'); // true console.log(2 !== '2'); // false
Output
true true true true true false false true
Comparison operators are used in decision making and loops. You will learn about the use of comparison operators in detail in later tutorials.
JavaScript Logical Operators
Logical operators perform logical operations and return a boolean value, either true or false. For example,
const x = 5, y = 3; (x < 6) && (y < 5); // true
Here, && is the logical operator AND. Since both x < 6 and y < 5 are true, the result is true.
| Operator | Description | Example |
|---|---|---|
&& | Logical AND: true if both the operands are true, else returns false | x && y |
|| | Logical OR: true if either of the operands is true; returns false if both are false | x || y |
! | Logical NOT: true if the operand is false and vice-versa. | !x |
Example 3: Logical Operators in JavaScript
// logical AND console.log(true && true); // true console.log(true && false); // false // logical OR console.log(true || false); // true // logical NOT console.log(!true); // false
Output
true false true false
Logical operators are used in decision making and loops. You will learn about the use of logical operators in detail in later tutorials.
JavaScript Bitwise Operators
Bitwise operators perform operations on binary representations of numbers.
| Operator | Description |
|---|---|
& | Bitwise AND |
| | Bitwise OR |
^ | Bitwise XOR |
~ | Bitwise NOT |
<< | Left shift |
>> | Sign-propagating right shift |
>>> | Zero-fill right shift |
Bitwise operators are rarely used in everyday programming. If you are interested, visit JavaScript Bitwise Operators to learn more.
JavaScript String Operators
In JavaScript, you can also use the + operator to concatenate (join) two or more strings.
Example 4: String operators in JavaScript
// concatenation operator console.log('hello' + 'world'); let a = 'JavaScript'; a += ' tutorial'; // a = a + ' tutorial'; console.log(a);
Output
helloworld JavaScript tutorial
Remarque: lorsque +est utilisé avec des chaînes, il effectue une concaténation. Cependant, lorsqu'il +est utilisé avec des nombres, il effectue une addition.
Autres opérateurs JavaScript
Voici une liste d'autres opérateurs disponibles en JavaScript. Vous découvrirez ces opérateurs dans des didacticiels ultérieurs.
| Opérateur | La description | Exemple |
|---|---|---|
, | évalue plusieurs opérandes et renvoie la valeur du dernier opérande. | let a = (1, 3 , 4); // 4 |
?: | renvoie une valeur basée sur la condition | (5> 3) ? 'success' : 'error'; // "success" |
delete | supprime la propriété d'un objet ou un élément d'un tableau | delete x |
typeof | renvoie une chaîne indiquant le type de données | typeof 3; // "number" |
void | ignore la valeur de retour de l'expression | void(x) |
in | retourne truesi la propriété spécifiée est dans l'objet | prop in object |
instanceof | renvoie truesi l'objet spécifié est du type d'objet spécifié | object instanceof object_type |
