Opérateurs en Scala

Note : Ce tutoriel est une suite de la Série de Tutoriaux Scala. Si vous n’avez pas lu Guide pour débutants en Scala et IF ELSE dans Scala, veuillez les consulter.

Introduction

Un opérateur est un symbole ou une fonction qui signifie une opération à effectuer sur un ou plusieurs opérandes. Il existe de nombreux types d’opérateurs, tandis qu’un opérande peut être considéré comme une variable. Les opérateurs sont la base de tout langage de programmation. Les opérateurs permettent de réaliser différentes opérations sur les opérandes. Les opérateurs informent le compilateur de réaliser des opérations telles que mathématiques (arithmétiques), logiques, d’affectation, etc., et enfin de produire le résultat.

Il existe différents types d’opérateurs utilisés dans de nombreux langages de programmation ainsi que dans Scala, comme suit :

• Opérateur de relation
• Opérateur arithmétique
• Opérateur d’affectation
• Opérateur logique
• Opérateur bit à bit

Vous apprendrez les opérateurs précités théoriquement et programmable.

Opérateurs de relation

Les opérateurs de relation sont principalement utilisés pour effectuer une comparaison entre deux ou plusieurs variables. Si vous avez lu l’article IF ELSE en Scala, alors vous aurez observé que vous avez exploité le pouvoir des opérateurs de relation dans les conditions IF ELSE.

Ces opérateurs de relation retournent une valeur booléenne, c’est-à-dire Vrai ou Faux.

Les symboles des opérateurs de relation suivants peuvent être utilisés pour les appliquer sur les variables (Source : Opérateurs en Scala) :

• Égal à (==) : Il vérifie si les deux variables ou opérandes données sont égales ou non. Si elles le sont, il retourne vrai, sinon faux.

• Différent de (!=) : Il est l’opposé de l’opérateur égal à, ou vous pouvez dire le complément booléen de l’opérateur égal à. Il vérifie si les deux opérandes données sont égales ou non. Si elles ne le sont pas, il retourne vrai, sinon faux.

• Greater Than(>): Il vérifie si le premier opérande est supérieur au second. Si c’est le cas, il retourne vrai, sinon faux.

• Less than(<): Il est l’opérateur opposé du greater than puisqu’il vérifie si le premier opérande est inférieur au second. Si c’est le cas, il retourne vrai, sinon faux.

• Greater Than Equal To(>=): Cet opérateur vérifie si le premier opérande est supérieur ou égal au second. Si c’est le cas, il retourne vrai, sinon faux.

• Less Than Equal To(<=): L’opérateur opposé du greater than equal to. Il vérifie si le premier opérande est inférieur ou égal au second. Si c’est le cas, il retourne vrai, sinon faux.

Commençons maintenant à comprendre les opérateurs relationnels avec l’aide d’un code.

Pour exécuter le code ci-dessus, tout ce que vous devez faire est de taper scala relation_op.scala et vous devriez voir une sortie telle que présentée ci-dessous.

Ensuite, vous apprendrez les opérateurs logiques.

Opérateurs Logiques

Ils sont surtout utilisés dans les instructions conditionnelles comme une instruction SI SINON ou même dans une boucle tant que. Ils fusionnent deux conditions ou plus ou complètent également la sortie de la condition originale, qui est prise en compte. (Source: Opérateurs en Scala)

• Logique ET : Il renvoie vrai lorsque les deux conditions sont remplies. Sinon, il renvoie faux. Utiliser « and » agit comme un proxy pour l’opérateur &&.

• Logique OU : Il renvoie vrai lorsque l’une (ou les deux) des conditions est remplie. Sinon, il renvoie faux. Utiliser « or » agit comme un proxy pour l’opérateur ||.

• Opérateur NON logique : Il retourne vrai si la condition considérée n’est pas satisfaite. Sinon, il retourne faux. L’utilisation de « non » agit comme une alternative à l’opérateur !.

Opérateurs arithmétiques (mathématiques)

Comme le nom l’indique, les opérateurs arithmétiques sont utilisés pour effectuer des opérations mathématiques sur les opérandes.

Les opérateurs arithmétiques les plus utilisés en Scala sont les suivants (Source : Operateurs en Scala) :

• Addition : Ajoute $(+)$ deux variables/opérandes.

• Soustraction : Soustrait $(-)$ deux opérandes.

• Multiplication : Multiplie $(\times)$ deux opérandes.

• Division : Divise $(/)$ le premier opérande par le second opérande.

•  : Retourne l’exponentiel (puissance) des opérandes. Fondamentalement, quand un opérande est élevé à la puissance du second opérande $(x^y)$ ou $(x**y)$.

•  : Lorsque le premier opérande est divisé par le second, le reste ou le résidu est connu sous le nom de modulo (%).

Faisons rapidement un petit bout de code et analysons les résultats.

Dans cet exemple, vous utiliserez des au lieu de définir simplement des variables. Contrairement à une variable, une Liste peut contenir n valeurs avec différents types de données, elles représentent une liste chaînée en Scala et sont immuables. Vous effectuerez les opérations arithmétiques sur les deux listes au lieu de deux variables.

Opérateurs d’affectation

Pour affecter une valeur à une variable, on utilise des opérateurs d’affectation. Pour cela, l’opérande de droite est considéré comme une valeur, tandis que l’opérande de gauche est généralement une variable à laquelle la valeur est affectée. La valeur peut avoir différents types de données tels que int, float, etc. Le type de données des variable et de la valeur devrait être le même sinon le compilateur émet une erreur. (Source : Operateurs en Scala)

• Affectation simple : Cet opérateur est utilisé pour affecter une valeur à la variable $(=)$.

• Addition et affectation : Il est utilisé pour additionner l’opérande de gauche à l’opérande de droite, puis l’affecter à la variable de gauche $(+=)$.

• Soustraction et affectation : Semblable à l’affectation Addition et. Il est utilisé pour soustraire l’opérande de gauche de l’opérande de droite, puis l’affecter à la variable de gauche $(-=) $.

• Multiplication ET affectation : Il est utilisé pour multiplier l’opérande de gauche par l’opérande de droite puis assigner la valeur à la variable de gauche ($\times =$).

• Division ET affectation : Il est utilisé pour diviser l’opérande de gauche par l’opérande de droite et finalement affecter la valeur à la variable de gauche ($/=$).

De même, il existe beaucoup d’autres opérateurs d’affectation. Finalement, ecrivons du code pour comprendre comment ils fonctionnent programmatiquement.

Conclusion

Félicitations pour avoir terminé ce tutoriel sur Scala.

Si vous avez lu les deux tutoriels précédents, vous avez maintenant couvert trois sujets différents en Scala. Une bonne exercice serait d’utiliser les compétences acquises dans les trois et écrire un seul programme Scala de zéro. Cela ne seulement augmentera votre confiance mais rendra également votre vie plus facile lors de la suivi de sujets plus avancés en Scala.

Références :

• Opérateurs en Scala

N’hésitez pas à poser des questions relatives à ce tutoriel dans la section des commentaires ci-dessous.