Introduction aux opérateurs Scala
Les opérateurs sont utilisés pour effectuer des calculs logiques et mathématiques dans n'importe quel langage de programmation. Scala a également divers opérateurs pour effectuer divers calculs et tâches, mais ils sont implémentés comme des méthodes car Scala est un langage orienté objet, il traite donc chaque symbole comme un objet et une opération comme une méthode. Ils rendent le calcul simple et facile.
Les différents opérateurs présents à Scala sont:
- Opérateurs arithmétiques
- Opérateurs d'affectation
- Opérateurs relationnels
- Opérateurs logiques
- Opérateurs au niveau du bit
Étudions maintenant chaque opérateur en détail.
Opérateurs arithmétiques Scala
Ces opérateurs sont utilisés pour effectuer des calculs ou des calculs mathématiques.
| Opérateur | symbole | Explication | Format |
| Une addition | + | Ajoute les deux opérandes | x + y |
| Soustraction | - | Soustrait l'opérande droit de celui de gauche | x - y |
| Multiplication | * | Multiplie les deux opérandes | x * y |
| Division | / | Diviser le numérateur par le dénominateur | x / y |
| Module | % | Renvoie le reste après la division | x% y |
Exemple: opérateurs arithmétiques à Scala
object Arith (
def main (args: Array (String)) (
var a = 10;
var b = 5;
println (a + b);
println (a – b);
println (a * b);
println (a / b);
println (a % b)
)
)
Production:
scala> Arith.main (null)
15
5
50
2
0
Opérateurs d'affectation Scala
Ces opérateurs sont utilisés pour affecter des valeurs à une variable ou à un objet.
| Opérateur | symbole | Explication | Format |
| Affectation | = | Affecte la valeur de l'opérande droit à l'opérande gauche | x = y + z |
| Une addition | + = | Ajoute les deux opérandes et attribue enfin la valeur à l'opérande de gauche | x + = y |
| Soustraction | - = | Soustrait l'opérande droit de la gauche, puis attribuez la valeur à l'opérande gauche | x - = y |
| Multiplication | * = | Multiplie les deux opérandes et attribue la valeur à l'opérande de gauche | x * = y |
| Division | / = | Divise l'opérande gauche par l'opérande droit et affecte la valeur à l'opérande gauche | x / = y |
| Module | % = | Évalue le module de deux opérandes et attribue la valeur à l'opérande de gauche | x% = y |
| ET au niveau du bit | & = | Compare la valeur binaire de deux opérandes, retourne 1 si les deux opérandes sont 1 sinon retourne 0 et affecte la valeur à l'opérande gauche | x & = 5 |
| OU au niveau du bit | | = | Compare la valeur binaire de deux opérandes, retourne 0 si les deux opérandes sont 0 sinon retourne 1 et affecte la valeur à l'opérande gauche | x | = 5 |
| XOR au niveau du bit | = | Compare la valeur binaire de deux opérandes, retourne 0 si les deux opérandes sont identiques sinon retourne 1 et affecte la valeur à l'opérande gauche | x = 5 |
| Décalage à gauche | << = | Décale les bits vers la gauche et affecte le résultat à l'opérande gauche | x << = 5 |
| Décalage à droite | >> = | Décale les bits vers la droite et affecte le résultat à l'opérande gauche | x >> = 5 |
Exemple: opérateurs d'affectation dans Scalaobject Assign (
def main (args: Array (String)) (
var a = 10;
var b = 5;
println (a += b);
println (a –= b);
println (a *= b);
println (a /= b);
println (a %= b);
a = 20;
b = 15;
println (a &= b);
println (a |= b);
println (a ^= b);
println (a <<= 2);
println (a >>= 2);
)
)
Production:
scala> Assign.main (null)
15
dix
50
dix
0
4
11
4
16
4
Opérateurs relationnels Scala
Ces opérateurs renvoient une valeur booléenne après avoir vérifié les conditions mentionnées.
| Opérateur | symbole | Explication | Format |
| Égal à | == | Renvoie vrai si les deux opérandes sont égaux sinon retourne faux | x == y |
| Pas égal à | ! = | Renvoie vrai si les deux opérandes ne sont pas égaux sinon retourne faux | x! = y |
| Plus grand que | > | Renvoie vrai si l'opérande gauche est supérieur à droite sinon retourne faux | x> y |
| Moins que | < | Renvoie vrai si l'opérande gauche est plus petit que droite sinon retourne faux | x <y |
| Plus grand ou égal à | > = | Renvoie vrai si l'opérande gauche est supérieur ou égal à droite sinon retourne faux | x> = y |
| Inférieur ou égal à | <= | Renvoie vrai si l'opérande gauche est inférieur ou égal à la droite sinon retourne faux | x <= y |
Exemple: opérateurs relationnels dans scala
object Relation (
def main (args: Array (String)) (
var a = 10;
var b = 5;
println (a == b);
println (a != b);
println (a > b);
println (a < b);
println (a >= b);
println (a <= b);
)
)
Production:
scala> Relation.main (null)
faux
vrai
vrai
faux
vrai
faux
Opérateur logique Scala
Ces opérateurs renvoient également une valeur booléenne en fonction des entrées ou des opérandes.
| Opérateur | symbole | Explication | Format |
| ET logique | && | Renvoie vrai si les deux opérandes sont différents de zéro sinon retourne faux | x && y |
| OU logique | || | Renvoie vrai si l'un des opérandes est différent de zéro sinon retourne faux | x || y |
| NON logique | ! | Il inverse l'opérande. Renvoie vrai pour faux et vice versa | !X |
Exemple: opérateurs logiques dans Scala
object Logic (
def main (args: Array (String)) (
var a = true;
var b = false;
println (a && b);
println (a || b);
println !(b);
)
)
Production:
scala> Logic.main (null)
faux
vrai
vrai
Opérateurs Scala Bitwise
Ces opérateurs travaillent sur les bits et renvoient la valeur entière correspondante en sortie.
| Opérateur | symbole | Explication | Format |
| ET binaire | & | Vérifiez les opérandes au niveau du bit et retournez 1 si les deux bits sont à 1 sinon retournez 0 | x & y |
| OU binaire | | | Vérifiez les opérandes au niveau du bit et retournez 0 si les deux bits sont 0 sinon retournez 1 | x | y |
| XOR binaire | ^ | Vérifiez les opérandes au niveau du bit et retournez 0 si les deux bits sont identiques sinon retournez 1 | x y |
| Binaire NON | ~ | Renvoie ceux qui complètent, c'est-à-dire les changements 1 à 0 et vice versa | ~ x |
| Décalage à gauche binaire | << | Les bits de l'opérande de gauche sont décalés du côté gauche du nombre de bits mentionnés par l'opérande de droite | x << 3 |
| Décalage à droite binaire | >> | Les bits de l'opérande de gauche sont décalés vers la droite du nombre de bits mentionnés par l'opérande de droite | x >> 3 |
| Remplissage zéro du décalage à droite binaire | >>> | Les bits de l'opérande de gauche sont décalés du côté droit du nombre de bits mentionnés par l'opérande de droite et les valeurs décalées sont des zéros substitués. | x >>> 3 |
Exemple: opérateurs au niveau du bit dans Scala
object Bit (
def main (args: Array (String)) (
var a = 10;
var b = 5;
println (a & b);
println (a | b);
println (a b);
println ( ~ b);
a = 16;
b = 12;
println (a >> b);
println (a << b);
println (a >>> b);
)
)
Production:
scala> Bit. main (null)
0
15
15
dix
4
64
4
Articles recommandés
Ceci a été un guide pour les opérateurs Scala. Nous discutons ici de différents types d'opérateurs Scala comme les opérateurs arithmétiques, les opérateurs d'affectation, les opérateurs relationnels, les opérateurs logiques et les opérateurs au niveau du bit avec des exemples. Vous pouvez également consulter les articles suivants pour en savoir plus -
- Utilisations de Scala
- Haskell vs Scala
- Scala: l'approche fonctionnelle
- Opérateurs MySQL