Opérateurs en Scala

Découvrez les différents opérateurs utilisés dans le langage de programmation Scala.

Actualisé 19 sept. 2026 · 6 min lire

Explorer avec l’IA

Remarque : Ce tutoriel s’inscrit dans la continuité de la série Scala. Si vous n’avez pas lu Beginners Guide to Scala et IF ELSE in Scala, nous vous invitons à le faire.

Introduction

Un opérateur est un symbole ou une fonction qui indique une opération à effectuer avec un ou plusieurs opérandes. Il existe de nombreux types d’opérateurs, et un opérande peut être vu comme une variable. Les opérateurs sont à la base de tout langage de programmation. Ils permettent d’effectuer divers traitements sur des opérandes. Ils informent le compilateur d’exécuter des opérations telles que mathématiques (arithmétiques), logiques, d’affectation, etc., puis de produire le résultat.

On retrouve, en Scala comme dans de nombreux langages, plusieurs familles d’opérateurs :

Opérateurs relationnels
Opérateurs arithmétiques
Opérateurs d’affectation
Opérateurs logiques
Opérateurs bit à bit

Vous allez découvrir ces opérateurs à la fois sur le plan théorique et à travers du code.

Opérateurs relationnels

Les opérateurs relationnels servent principalement à comparer deux variables (ou plus). Si vous avez lu le tutoriel IF ELSE in Scala, vous avez déjà utilisé des opérateurs relationnels dans des conditions IF ELSE.

Ces opérateurs relationnels renvoient une valeur booléenne, c’est-à-dire true ou false.

Voici les symboles d’opérateurs relationnels utilisés sur des variables (Source : Operators in Scala) :

Égal à (==) : vérifie si deux variables ou opérandes sont égaux. Si oui, renvoie true, sinon false.
Différent de (!=) : c’est l’inverse de l’opérateur égal à, autrement dit son complément booléen. Il vérifie si les opérandes ne sont pas égaux. S’ils ne le sont pas, il renvoie true, sinon false.
Supérieur à (>) : vérifie si le premier opérande est strictement supérieur au second. Si c’est le cas, renvoie true, sinon false.
Inférieur à (<) : inverse de supérieur à ; vérifie si le premier opérande est strictement inférieur au second. Si oui, renvoie true, sinon false.
Supérieur ou égal à (>=) : vérifie si le premier opérande est supérieur ou égal au second. Si oui, renvoie true, sinon false.
Inférieur ou égal à (<=) : inverse de supérieur ou égal à. Vérifie si le premier opérande est inférieur ou égal au second. Si oui, renvoie true, sinon false.

Passons maintenant à un exemple de code pour illustrer ces opérateurs relationnels.

Pour exécuter le code ci-dessus, saisissez simplement scala relation_op.scala et vous obtiendrez un résultat similaire à celui ci-dessous.

Ensuite, vous allez découvrir les opérateurs logiques.

Opérateurs logiques

Ils sont surtout utilisés dans des instructions conditionnelles comme IF ELSE ou dans une boucle while. Ils combinent deux conditions (ou plus) ou complètent le résultat d’une condition donnée. (Source : Operators in Scala)

ET logique : renvoie true lorsque les deux conditions sont remplies. Sinon, renvoie false. L’utilisation de « and » agit comme un alias de l’opérateur &&.
OU logique : renvoie true lorsqu’au moins une des conditions est satisfaite. Sinon, renvoie false. L’utilisation de « or » agit comme un alias de l’opérateur ||.
NON logique : renvoie true si la condition considérée n’est pas remplie. Sinon, renvoie false. L’utilisation de « not » équivaut à l’opérateur !.

Opérateurs arithmétiques (mathématiques)

Comme leur nom l’indique, les opérateurs arithmétiques servent à effectuer des opérations mathématiques entre opérandes.

Voici les opérateurs arithmétiques les plus utilisés en Scala (Source : Operators in Scala) :

Addition : additionne $(+)$ deux variables/opérandes.
Soustraction : soustrait $(-)$ deux opérandes.
Multiplication : multiplie $(\times)$ deux opérandes.
Division : divise $(/)$ le premier opérande par le second.
Exposant : renvoie la puissance des opérandes, c’est-à-dire lorsque un opérande est élevé à la puissance du second $(x^y)$ ou $(x**y)$.
Modulo : lorsque le premier opérande est divisé par le second, le reste de la division est le modulo (%).

Écrivons rapidement un petit bout de code et analysons le résultat.

Dans cet exemple, vous utiliserez des List plutôt que de simples variables. Contrairement à une variable, une List peut contenir un nombre n de valeurs de types variés ; elle représente une liste chaînée en Scala et est immuable. Vous effectuerez des opérations arithmétiques sur deux listes plutôt que sur deux variables.

Opérateurs d’affectation

Les opérateurs d’affectation servent à attribuer une valeur à une variable. Pour cela, l’opérande de droite est la valeur, tandis que l’opérande de gauche est généralement la variable à laquelle la valeur est affectée. La valeur peut avoir différents types, comme int, float, etc. Le type de la variable et celui de la valeur doivent correspondre, sinon le compilateur génère une erreur. (Source : Operators in Scala)

Affectation simple : permet d’attribuer une valeur à une variable $(=)$.
Addition et affectation : additionne l’opérande de gauche et celui de droite, puis affecte le résultat à la variable de gauche $(+=)$.
Soustraction et affectation : sur le même principe que l’addition et affectation, soustrait l’opérande de droite de celui de gauche, puis affecte le résultat à la variable de gauche $(-=)$.
Multiplication et affectation : multiplie l’opérande de gauche par celui de droite, puis affecte le résultat à la variable de gauche $(\times =)$.
Division et affectation : divise l’opérande de gauche par celui de droite, puis affecte le résultat à la variable de gauche $(/=)$.

De nombreux autres opérateurs d’affectation existent sur le même modèle. Terminons par un exemple de code pour voir leur fonctionnement en pratique.

Conclusion

Félicitations pour avoir mené à bien ce tutoriel sur Scala.

Si vous avez suivi les deux précédents tutoriels, vous avez désormais couvert trois thèmes différents en Scala. Un excellent exercice consiste à mobiliser les compétences acquises dans ces trois volets pour écrire, depuis zéro, un programme Scala complet. Cela renforcera votre confiance et vous facilitera la suite, lorsque vous aborderez des sujets Scala plus avancés.

Références :