Opérateurs en JavaScript

Dans la vraie vie, vous avez vu comment nous ajouterons, soustrayez deux valeurs. De même, dans un langage de programmation, cette action est effectuée par l'aide de les opérateurs. En mots simples, mathématique ou logique Les opérations peuvent être effectuées grâce à l'utilisation des opérateurs. Les opérateurs remplissent ces fonctions sur une seule ou multiple opérandes pour produire des résultats. Ici, les opérandes sont les valeurs de données sur lesquelles les opérations sont effectuées.

Comme tout autre langage de programmation, JavaScript utilise également divers opérateurs. Il est utile car cela facilite la comparaison et la manipulation des valeurs pour l'utilisateur.

Dans cet article, nous discuterons de divers opérateurs en JavaScript ainsi que leur utilisation et leurs exemples.

Type d'opérateurs en javascript

Il existe divers opérateurs disponibles en JavaScript, certains sont répertoriés ci-dessous:

1. Opérateurs arithmétiques
2. Opérateurs d'affectation
3. Opérateurs de comparaison
4. Opérateurs logiques
5. Opérateurs de cordes

Comprenons ces opérateurs un par un avec des exemples pour une meilleure compréhension.

Opérateurs arithmétiques

Les opérateurs arithmétiques aident à effectuer tous les calculs de base mathématiques comme l'addition, la soustraction, la multiplication et la division. Voici divers opérateurs arithmétiques:

Les opérateurs	Nom
+	Ajout
-	Soustraction
/ /	Division
*	Multiplication
%	Reste
++	Augmenter de 1
-	Diminuer de 1
**	Exponentiel (puissance)

Exemple d'opérateurs arithmétiques

Soit x = 3;
Soit y = 2;
// ajout
console.log ('x + y =', x + y); // 5
// soustraction
console.log ('x - y =', x - y); // 1
// Multiplication
console.log ('x * y =', x * y); // 6
// Division
console.log ('x / y =', x / y); // 1.5
// reste de 3/2 sera 1
console.log ('x% y =', x% y); // 1
// augmenter de 1
console.log ('++ x =', ++ x); // x sera 4
console.log ('x ++ =', x ++); // imprime 4 puis augmenté à 5
console.log ('x =', x); // 5
// diminuer de 1
console.log ('- x =', --x); // x sera 4
console.log ('x-- =', x--); // imprime 4 puis diminué à 3
console.log ('x =', x); // 3
// Exponentiation
console.log ('x ** y =', x ** y); // 3 La puissance de 2 est 9

Opérateurs d'affectation

En JavaScript, les opérateurs d'affectation sont utilisés pour attribuer certaines valeurs à une variable. Par exemple:

Soit x = 3;
const y = 5;

Ici, X et Y sont des variables qui sont assignées les valeurs 3 et 5 respectivement. Voici quelques opérateurs d'affectation:

Les opérateurs	Nom
=	Mission
+=	Affectation supplémentaire
-=	Affectation de soustraction
* =	Affectation de multiplication
/ =	Affectation de division
% =	Affectation restante
** =	Affectation d'exponentiation

Exemple d'opérateurs d'affectation

Soit x = 3; // attribuer une valeur à l'aide de l'opérateur d'affectation
// affectation d'ajout
console.log ('x + = 3', x + = 3); // 6, maintenant x = 6
// Affectation de soustraction
console.log ('x - = 2', x - = 2); // 4, maintenant x = 4
// Affectation de multiplication
console.log ('x * = 2', x * = 2); // 8, maintenant x = 8
// Affectation de division
console.log ('x / = 2', x / = 2); // 4
// Affectation reste
console.log ('x% = 2', x% = 2); // 0
// Affectation d'exponenation
Soit x = 5;
console.log ('x ** = 2', x ** = 2); // 25

Opérateurs de comparaison

Les opérateurs de comparaison fonctionnent en comparant deux valeurs et en renvoyant True et False:

Les opérateurs	Nom
==	Égal à
!=	Pas égal à
===	Strict est égal à
!==	Strict pas égal à
>	Plus grand que
<	Moins que
> =	Supérieur ou égal à
<=	Moins ou égal à

Exemple d'opérateurs de comparaison:

// Opérateur égal
console.log (3 == 2); // FAUX
console.log (3 == '3'); // vrai
// pas d'opérateur égal
console.journal (3 != 4); // vrai
console.journal («monde» != 'world'); // FAUX
// Opérateur égal strict
console.log (7 === '7'); // FAUX
console.log (6 === 6); // vrai
// Opérateur strict et non égal
console.journal (8 !== '8'); // vrai
console.journal (3 !== 3); // FAUX

Opérateurs logiques

Les opérateurs logiques sont utilisés pour gérer les opérations logiques sur les valeurs de données, en conséquence, ils renvoient une valeur booléenne:

Les opérateurs	Nom
&&	Logique et
||	Logique ou
!	Logique pas

Exemple d'opérateurs logiques:

// logique et
console.log (7 == 7 && 7 == 7); // vrai, et l'opérateur fonctionne lorsque les deux instructions données sont vraies
console.log (7 == 7 && 7 == 87!= 7); // faux, l'une des déclarations n'est pas vraie
// logique ou
console.journal (7 == 7 || 7!= 7); // vrai, ou l'opérateur fonctionne lorsque l'une des deux déclarations données est vraie
// logique pas
console.enregistrer(!7 == 7); // faux, aurait été vrai si l'expression n'était pas vraie.

Opérateurs de cordes

Les opérateurs de chaîne sont utilisés pour rejoindre deux chaînes ou plus ou un nombre et une chaîne.

Exemple d'opérateurs de chaîne:

Soit x = 5 + 25; // 30
Soit y = "5" + 5; // 55
Soit z = "world" + 5; // World5

Conclusion

Les opérateurs de type OF en JavaScript sont utilisés pour raconter au programme quel fonctionnement mathématique doit être effectué. Dans cet article, nous avons appris divers opérateurs en JavaScript, comment ils sont utilisés et leur fonctionnalité. Les opérateurs aident les utilisateurs à effectuer des tâches difficiles avec facilité et logiquement.

Chaque opérateur spécifique est disponible pour l'utilisateur pour implémenter une fonctionnalité particulière dans son programme. J'espère que cela vous aide avec une meilleure compréhension des opérateurs en JavaScript, et en général, car les concepts principaux de chaque langage de programmation sont interconnectés.