JavaScript - Opérateurs

Qu'est-ce qu'un opérateur?

Prenons une expression simple 4 + 5 is equal to 9. Ici 4 et 5 sont appelésoperands et '+' est appelé le operator. JavaScript prend en charge les types d'opérateurs suivants.

  • Opérateurs arithmétiques
  • Opérateurs de comparaison
  • Opérateurs logiques (ou relationnels)
  • Opérateurs d'affectation
  • Opérateurs conditionnels (ou ternaires)

Jetons un coup d'œil sur tous les opérateurs un par un.

Opérateurs arithmétiques

JavaScript prend en charge les opérateurs arithmétiques suivants -

Supposons que la variable A vaut 10 et la variable B 20, alors -

N ° Sr. Opérateur et description
1

+ (Addition)

Ajoute deux opérandes

Ex: A + B donnera 30

2

- (Subtraction)

Soustrait le deuxième opérande du premier

Ex: A - B donnera -10

3

* (Multiplication)

Multiplier les deux opérandes

Ex: A * B donnera 200

4

/ (Division)

Divisez le numérateur par le dénominateur

Ex: B / A donnera 2

5

% (Modulus)

Produit le reste d'une division entière

Ex: B% A donnera 0

6

++ (Increment)

Augmente une valeur entière de un

Ex: A ++ donnera 11

sept

-- (Decrement)

Diminue une valeur entière de un

Ex: A-- donnera 9

Note- L'opérateur d'addition (+) fonctionne aussi bien pour les chaînes numériques que pour les chaînes. par exemple "a" + 10 donnera "a10".

Exemple

Le code suivant montre comment utiliser les opérateurs arithmétiques dans JavaScript.

<html>
   <body>
   
      <script type = "text/javascript">
         <!--
            var a = 33;
            var b = 10;
            var c = "Test";
            var linebreak = "<br />";
         
            document.write("a + b = ");
            result = a + b;
            document.write(result);
            document.write(linebreak);
         
            document.write("a - b = ");
            result = a - b;
            document.write(result);
            document.write(linebreak);
         
            document.write("a / b = ");
            result = a / b;
            document.write(result);
            document.write(linebreak);
         
            document.write("a % b = ");
            result = a % b;
            document.write(result);
            document.write(linebreak);
         
            document.write("a + b + c = ");
            result = a + b + c;
            document.write(result);
            document.write(linebreak);
         
            a = ++a;
            document.write("++a = ");
            result = ++a;
            document.write(result);
            document.write(linebreak);
         
            b = --b;
            document.write("--b = ");
            result = --b;
            document.write(result);
            document.write(linebreak);
         //-->
      </script>
      
      Set the variables to different values and then try...
   </body>
</html>

Production

a + b = 43
a - b = 23
a / b = 3.3
a % b = 3
a + b + c = 43Test
++a = 35
--b = 8
Set the variables to different values and then try...

Opérateurs de comparaison

JavaScript prend en charge les opérateurs de comparaison suivants -

Supposons que la variable A vaut 10 et la variable B 20, alors -

N ° Sr. Opérateur et description
1

= = (Equal)

Vérifie si la valeur de deux opérandes est égale ou non, si oui, la condition devient vraie.

Ex: (A == B) n'est pas vrai.

2

!= (Not Equal)

Vérifie si la valeur de deux opérandes est égale ou non, si les valeurs ne sont pas égales, la condition devient vraie.

Ex: (A! = B) est vrai.

3

> (Greater than)

Vérifie si la valeur de l'opérande gauche est supérieure à la valeur de l'opérande droit, si oui, la condition devient vraie.

Ex: (A> B) n'est pas vrai.

4

< (Less than)

Vérifie si la valeur de l'opérande gauche est inférieure à la valeur de l'opérande droit, si oui, la condition devient vraie.

Ex: (A <B) est vrai.

5

>= (Greater than or Equal to)

Vérifie si la valeur de l'opérande gauche est supérieure ou égale à la valeur de l'opérande droit, si oui, la condition devient vraie.

Ex: (A> = B) n'est pas vrai.

6

<= (Less than or Equal to)

Vérifie si la valeur de l'opérande gauche est inférieure ou égale à la valeur de l'opérande droit, si oui, la condition devient vraie.

Ex: (A <= B) est vrai.

Exemple

Le code suivant montre comment utiliser les opérateurs de comparaison dans JavaScript.

<html>
   <body>  
      <script type = "text/javascript">
         <!--
            var a = 10;
            var b = 20;
            var linebreak = "<br />";
      
            document.write("(a == b) => ");
            result = (a == b);
            document.write(result);
            document.write(linebreak);
         
            document.write("(a < b) => ");
            result = (a < b);
            document.write(result);
            document.write(linebreak);
         
            document.write("(a > b) => ");
            result = (a > b);
            document.write(result);
            document.write(linebreak);
         
            document.write("(a != b) => ");
            result = (a != b);
            document.write(result);
            document.write(linebreak);
         
            document.write("(a >= b) => ");
            result = (a >= b);
            document.write(result);
            document.write(linebreak);
         
            document.write("(a <= b) => ");
            result = (a <= b);
            document.write(result);
            document.write(linebreak);
         //-->
      </script>      
      Set the variables to different values and different operators and then try...
   </body>
</html>

Production

(a == b) => false 
(a < b) => true 
(a > b) => false 
(a != b) => true 
(a >= b) => false 
a <= b) => true
Set the variables to different values and different operators and then try...

Opérateurs logiques

JavaScript prend en charge les opérateurs logiques suivants -

Supposons que la variable A vaut 10 et la variable B 20, alors -

N ° Sr. Opérateur et description
1

&& (Logical AND)

Si les deux opérandes sont différents de zéro, la condition devient vraie.

Ex: (A && B) est vrai.

2

|| (Logical OR)

Si l'un des deux opérandes est différent de zéro, la condition devient vraie.

Ex: (A || B) est vrai.

3

! (Logical NOT)

Inverse l'état logique de son opérande. Si une condition est vraie, alors l'opérateur logique NOT la rendra fausse.

Ex:! (A && B) est faux.

Exemple

Essayez le code suivant pour savoir comment implémenter des opérateurs logiques dans JavaScript.

<html>
   <body>   
      <script type = "text/javascript">
         <!--
            var a = true;
            var b = false;
            var linebreak = "<br />";
      
            document.write("(a && b) => ");
            result = (a && b);
            document.write(result);
            document.write(linebreak);
         
            document.write("(a || b) => ");
            result = (a || b);
            document.write(result);
            document.write(linebreak);
         
            document.write("!(a && b) => ");
            result = (!(a && b));
            document.write(result);
            document.write(linebreak);
         //-->
      </script>      
      <p>Set the variables to different values and different operators and then try...</p>
   </body>
</html>

Production

(a && b) => false 
(a || b) => true 
!(a && b) => true
Set the variables to different values and different operators and then try...

Opérateurs au niveau du bit

JavaScript prend en charge les opérateurs binaires suivants -

Supposons que la variable A vaut 2 et la variable B vaut 3, alors -

N ° Sr. Opérateur et description
1

& (Bitwise AND)

Il effectue une opération booléenne AND sur chaque bit de ses arguments entiers.

Ex: (A & B) est égal à 2.

2

| (BitWise OR)

Il effectue une opération booléenne OU sur chaque bit de ses arguments entiers.

Ex: (A | B) vaut 3.

3

^ (Bitwise XOR)

Il effectue une opération OU exclusive booléenne sur chaque bit de ses arguments entiers. OU exclusif signifie que l'opérande un est vrai ou que l'opérande deux est vrai, mais pas les deux.

Ex: (A ^ B) vaut 1.

4

~ (Bitwise Not)

C'est un opérateur unaire et fonctionne en inversant tous les bits de l'opérande.

Ex: (~ B) est -4.

5

<< (Left Shift)

Il déplace tous les bits de son premier opérande vers la gauche du nombre de places spécifié dans le deuxième opérande. Les nouveaux bits sont remplis de zéros. Décaler une valeur vers la gauche d'une position équivaut à la multiplier par 2, déplacer deux positions équivaut à multiplier par 4, et ainsi de suite.

Ex: (A << 1) vaut 4.

6

>> (Right Shift)

Opérateur de décalage binaire vers la droite. La valeur de l'opérande gauche est déplacée vers la droite du nombre de bits spécifié par l'opérande droit.

Ex: (A >> 1) vaut 1.

sept

>>> (Right shift with Zero)

Cet opérateur est exactement comme l'opérateur >>, sauf que les bits décalés à gauche sont toujours nuls.

Ex: (A >>> 1) vaut 1.

Exemple

Essayez le code suivant pour implémenter l'opérateur Bitwise dans JavaScript.

<html>
   <body>   
      <script type = "text/javascript">
         <!--
            var a = 2; // Bit presentation 10
            var b = 3; // Bit presentation 11
            var linebreak = "<br />";
         
            document.write("(a & b) => ");
            result = (a & b);
            document.write(result);
            document.write(linebreak);
         
            document.write("(a | b) => ");
            result = (a | b);
            document.write(result);
            document.write(linebreak);
         
            document.write("(a ^ b) => ");
            result = (a ^ b);
            document.write(result);
            document.write(linebreak);
         
            document.write("(~b) => ");
            result = (~b);
            document.write(result);
            document.write(linebreak);
         
            document.write("(a << b) => ");
            result = (a << b);
            document.write(result);
            document.write(linebreak);
         
            document.write("(a >> b) => ");
            result = (a >> b);
            document.write(result);
            document.write(linebreak);
         //-->
      </script>      
      <p>Set the variables to different values and different operators and then try...</p>
   </body>
</html>
(a & b) => 2 
(a | b) => 3 
(a ^ b) => 1 
(~b) => -4 
(a << b) => 16 
(a >> b) => 0
Set the variables to different values and different operators and then try...

Opérateurs d'affectation

JavaScript prend en charge les opérateurs d'affectation suivants -

N ° Sr. Opérateur et description
1

= (Simple Assignment )

Attribue des valeurs de l'opérande du côté droit à l'opérande du côté gauche

Ex: C = A + B attribuera la valeur de A + B à C

2

+= (Add and Assignment)

Il ajoute l'opérande droit à l'opérande gauche et affecte le résultat à l'opérande gauche.

Ex: C + = A équivaut à C = C + A

3

−= (Subtract and Assignment)

Il soustrait l'opérande droit de l'opérande gauche et affecte le résultat à l'opérande gauche.

Ex: C - = A équivaut à C = C - A

4

*= (Multiply and Assignment)

Il multiplie l'opérande droit par l'opérande gauche et affecte le résultat à l'opérande gauche.

Ex: C * = A équivaut à C = C * A

5

/= (Divide and Assignment)

Il divise l'opérande de gauche par l'opérande de droite et affecte le résultat à l'opérande de gauche.

Ex: C / = A équivaut à C = C / A

6

%= (Modules and Assignment)

Il prend le module en utilisant deux opérandes et affecte le résultat à l'opérande de gauche.

Ex: C% = A équivaut à C = C% A

Note - La même logique s'applique aux opérateurs au niveau du bit afin qu'ils deviennent comme << =, >> =, >> =, & =, | = et ^ =.

Exemple

Essayez le code suivant pour implémenter l'opérateur d'affectation dans JavaScript.

<html>
   <body>   
      <script type = "text/javascript">
         <!--
            var a = 33;
            var b = 10;
            var linebreak = "<br />";
         
            document.write("Value of a => (a = b) => ");
            result = (a = b);
            document.write(result);
            document.write(linebreak);
         
            document.write("Value of a => (a += b) => ");
            result = (a += b);
            document.write(result);
            document.write(linebreak);
         
            document.write("Value of a => (a -= b) => ");
            result = (a -= b);
            document.write(result);
            document.write(linebreak);
         
            document.write("Value of a => (a *= b) => ");
            result = (a *= b);
            document.write(result);
            document.write(linebreak);
         
            document.write("Value of a => (a /= b) => ");
            result = (a /= b);
            document.write(result);
            document.write(linebreak);
         
            document.write("Value of a => (a %= b) => ");
            result = (a %= b);
            document.write(result);
            document.write(linebreak);
         //-->
      </script>      
      <p>Set the variables to different values and different operators and then try...</p>
   </body>
</html>

Production

Value of a => (a = b) => 10
Value of a => (a += b) => 20 
Value of a => (a -= b) => 10 
Value of a => (a *= b) => 100 
Value of a => (a /= b) => 10
Value of a => (a %= b) => 0
Set the variables to different values and different operators and then try...

Opérateur divers

Nous aborderons ici deux opérateurs très utiles en JavaScript: le conditional operator (? :) et le typeof operator.

Opérateur conditionnel (? :)

L'opérateur conditionnel évalue d'abord une expression pour une valeur vraie ou fausse, puis exécute l'une des deux instructions données en fonction du résultat de l'évaluation.

N ° Sr. Opérateur et description
1

? : (Conditional )

Si la condition est vraie? Alors valeur X: Sinon valeur Y

Exemple

Essayez le code suivant pour comprendre le fonctionnement de l'opérateur conditionnel en JavaScript.

<html>
   <body>   
      <script type = "text/javascript">
         <!--
            var a = 10;
            var b = 20;
            var linebreak = "<br />";
         
            document.write ("((a > b) ? 100 : 200) => ");
            result = (a > b) ? 100 : 200;
            document.write(result);
            document.write(linebreak);
         
            document.write ("((a < b) ? 100 : 200) => ");
            result = (a < b) ? 100 : 200;
            document.write(result);
            document.write(linebreak);
         //-->
      </script>      
      <p>Set the variables to different values and different operators and then try...</p>
   </body>
</html>

Production

((a > b) ? 100 : 200) => 200 
((a < b) ? 100 : 200) => 100
Set the variables to different values and different operators and then try...

type d'opérateur

le typeofL'opérateur est un opérateur unaire qui est placé avant son unique opérande, qui peut être de n'importe quel type. Sa valeur est une chaîne indiquant le type de données de l'opérande.

L' opérateur typeof évalue en "nombre", "chaîne" ou "booléen" si son opérande est un nombre, une chaîne ou une valeur booléenne et renvoie vrai ou faux en fonction de l'évaluation.

Voici une liste des valeurs de retour pour le typeof Opérateur.

Type Chaîne renvoyée par typeof
Nombre "nombre"
Chaîne "chaîne"
Booléen "booléen"
Objet "objet"
Fonction "fonction"
Indéfini "indéfini"
Nul "objet"

Exemple

Le code suivant montre comment implémenter typeof opérateur.

<html>
   <body>      
      <script type = "text/javascript">
         <!--
            var a = 10;
            var b = "String";
            var linebreak = "<br />";
         
            result = (typeof b == "string" ? "B is String" : "B is Numeric");
            document.write("Result => ");
            document.write(result);
            document.write(linebreak);
         
            result = (typeof a == "string" ? "A is String" : "A is Numeric");
            document.write("Result => ");
            document.write(result);
            document.write(linebreak);
         //-->
      </script>      
      <p>Set the variables to different values and different operators and then try...</p>
   </body>
</html>

Production

Result => B is String 
Result => A is Numeric
Set the variables to different values and different operators and then try...