Scala - Opérateurs
Un opérateur est un symbole qui indique au compilateur d'effectuer des manipulations mathématiques ou logiques spécifiques. Scala est riche en opérateurs intégrés et fournit les types d'opérateurs suivants -
- Opérateurs arithmétiques
- Opérateurs relationnels
- Opérateurs logiques
- Opérateurs au niveau du bit
- Opérateurs d'affectation
Ce chapitre examinera les opérateurs arithmétique, relationnel, logique, binaire, d'affectation et autres un par un.
Opérateurs arithmétiques
Les opérateurs arithmétiques suivants sont pris en charge par le langage Scala. Par exemple, supposons que la variable A vaut 10 et la variable B 20, alors -
Afficher des exemples
| Opérateur | La description | Exemple |
|---|---|---|
| + | Ajoute deux opérandes | A + B donnera 30 |
| - | Soustrait le deuxième opérande du premier | A - B donnera -10 |
| * | Multiplie les deux opérandes | A * B donnera 200 |
| / | Divise le numérateur par le dénumérateur | B / A donnera 2 |
| % | L'opérateur de module trouve le reste après la division d'un nombre par un autre | B% A donnera 0 |
Opérateurs relationnels
Les opérateurs relationnels suivants sont pris en charge par le langage Scala. Par exemple, supposons que la variable A vaut 10 et la variable B 20, alors -
Afficher des exemples
| Opérateur | La description | Exemple |
|---|---|---|
| == | Vérifie si les valeurs de deux opérandes sont égales ou non, si oui, la condition devient vraie. | (A == B) n'est pas vrai. |
| ! = | Vérifie si les valeurs de deux opérandes sont égales ou non, si les valeurs ne sont pas égales, la condition devient vraie. | (A! = B) est vrai. |
| > | 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. | (A> B) n'est pas vrai. |
| < | 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. | (A <B) est vrai. |
| > = | 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. | (A> = B) n'est pas vrai. |
| <= | 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. | (A <= B) est vrai. |
Opérateurs logiques
Les opérateurs logiques suivants sont pris en charge par le langage Scala. Par exemple, supposons que la variable A vaut 1 et la variable B vaut 0, alors -
Afficher des exemples
| Opérateur | La description | Exemple |
|---|---|---|
| && | Il est appelé opérateur ET logique. Si les deux opérandes sont différents de zéro, la condition devient vraie. | (A && B) est faux. |
| || | Il est appelé Opérateur OR logique. Si l'un des deux opérandes est différent de zéro, la condition devient vraie. | (A || B) est vrai. |
| ! | Il est appelé Opérateur NON logique. Utilisez pour inverser l'état logique de son opérande. Si une condition est vraie, l'opérateur logique NOT rendra faux. | ! (A && B) est vrai. |
Opérateurs au niveau du bit
L'opérateur au niveau du bit fonctionne sur les bits et effectue des opérations bit par bit. Les tables de vérité pour &, | et ^ sont les suivantes:
| p | q | p & q | p | q | p ^ q |
|---|---|---|---|---|
| 0 | 0 | 0 | 0 | 0 |
| 0 | 1 | 0 | 1 | 1 |
| 1 | 1 | 1 | 1 | 0 |
| 1 | 0 | 0 | 1 | 1 |
Supposons que A = 60; et B = 13; maintenant au format binaire, ils seront comme suit -
A = 0011 1100
B = 0000 1101
-----------------------
A&B = 0000 1100
A|B = 0011 1101
A^B = 0011 0001
~A = 1100 0011Les opérateurs Bitwise pris en charge par le langage Scala sont répertoriés dans le tableau suivant. Supposons que la variable A a 60 et la variable B 13, alors -
Afficher des exemples
| Opérateur | La description | Exemple |
|---|---|---|
| & | L'opérateur binaire AND copie un bit dans le résultat s'il existe dans les deux opérandes. | (A & B) donnera 12, soit 0000 1100 |
| | | L'opérateur OR binaire copie un bit s'il existe dans l'un ou l'autre des opérandes. | (A | B) donnera 61, soit 0011 1101 |
| ^ | L'opérateur XOR binaire copie le bit s'il est défini dans un opérande mais pas dans les deux. | (A ^ B) donnera 49, soit 0011 0001 |
| ~ | L'opérateur de complément Binary Ones est unaire et a pour effet de «retourner» les bits. | (~ A) donnera -61, qui est 1100 0011 en forme de complément à 2 en raison d'un nombre binaire signé. |
| << | Opérateur de décalage binaire gauche. Les positions binaires de la valeur des opérandes de gauche sont déplacées vers la gauche du nombre de bits spécifié par l'opérande de droite. | Un << 2 donnera 240, soit 1111 0000 |
| >> | Opérateur de décalage binaire vers la droite. Les positions de bits de la valeur d'opérande de gauche sont déplacées vers la droite du nombre de bits spécifié par l'opérande de droite. | Un >> 2 donnera 15, soit 1111 |
| >>> | Décaler l'opérateur de remplissage zéro vers la droite. La valeur des opérandes de gauche est déplacée vers la droite du nombre de bits spécifié par l'opérande de droite et les valeurs décalées sont remplies de zéros. | Un >>> 2 donnera 15 qui est 0000 1111 |
Opérateurs d'affectation
Les opérateurs d'affectation suivants sont pris en charge par le langage Scala -
Afficher des exemples
| Opérateur | La description | Exemple |
|---|---|---|
| = | Opérateur d'affectation simple, attribue des valeurs des opérandes du côté droit à l'opérande du côté gauche | C = A + B attribuera la valeur de A + B à C |
| + = | Ajouter l'opérateur d'affectation ET, il ajoute l'opérande droit à l'opérande gauche et attribue le résultat à l'opérande gauche | C + = A équivaut à C = C + A |
| - = | Soustraire l'opérateur d'affectation ET, il soustrait l'opérande droit de l'opérande gauche et attribuer le résultat à l'opérande gauche | C - = A équivaut à C = C - A |
| * = | Multiplier l'opérateur d'affectation ET, il multiplie l'opérande droit par l'opérande gauche et attribue le résultat à l'opérande gauche | C * = A équivaut à C = C * A |
| / = | Opérateur d'affectation de division ET, il divise l'opérande gauche avec l'opérande droit et affecte le résultat à l'opérande gauche | C / = A équivaut à C = C / A |
| % = | Opérateur d'assignation de module ET, il prend le module en utilisant deux opérandes et affecte le résultat à l'opérande de gauche | C% = A équivaut à C = C% A |
| << = | Opérateur de décalage ET d'affectation à gauche | C << = 2 est identique à C = C << 2 |
| >> = | Opérateur de décalage ET d'affectation à droite | C >> = 2 est identique à C = C >> 2 |
| & = | Opérateur d'affectation AND au niveau du bit | C & = 2 est identique à C = C & 2 |
| ^ = | Opérateur OU exclusif et d'affectation au niveau du bit | C ^ = 2 est identique à C = C ^ 2 |
| | = | OR inclusif au niveau du bit et opérateur d'affectation | C | = 2 est identique à C = C | 2 |
Priorité des opérateurs dans Scala
La priorité des opérateurs détermine le regroupement des termes dans une expression. Cela affecte la manière dont une expression est évaluée. Certains opérateurs ont une priorité plus élevée que d'autres; par exemple, l'opérateur de multiplication a une priorité plus élevée que l'opérateur d'addition -
Par exemple, x = 7 + 3 * 2; ici, x est attribué à 13, et non à 20 car l'opérateur * a une priorité plus élevée que +, il est donc d'abord multiplié par 3 * 2, puis ajouté en 7.
Jetez un œil au tableau suivant. Les opérateurs ayant la priorité la plus élevée apparaissent en haut du tableau et ceux ayant la priorité la plus faible apparaissent en bas. Dans une expression, les opérateurs de priorité supérieure seront évalués en premier.
| Catégorie | Opérateur | Associativité |
|---|---|---|
| Postfix | () [] | De gauche à droite |
| Unaire | ! ~ | De droite à gauche |
| Multiplicatif | * /% | De gauche à droite |
| Additif | + - | De gauche à droite |
| Décalage | >> >>> << | De gauche à droite |
| Relationnel | >> = <<= | De gauche à droite |
| Égalité | ==! = | De gauche à droite |
| ET au niveau du bit | & | De gauche à droite |
| XOR au niveau du bit | ^ | De gauche à droite |
| OU au niveau du bit | | | De gauche à droite |
| ET logique | && | De gauche à droite |
| OU logique | || | De gauche à droite |
| Affectation | = + = - = * = / =% = >> = << = & = ^ = | = | De droite à gauche |
| Virgule | , | De gauche à droite |