Les opérateurs dans Kotlin

Les opérateurs sont des caractères spéciaux qui effectuent des opérations sur les opérandes (variables,valeurs).

Dans kotlin tout est objet, même les types de donné de base tel que Int, Boolean, Char dans le sens ou vous pouvez appeler des fonctions et des propriétés membres sur n’importe quel variable.

Puisque ces types de donnée de base sont des objets, les opérations que vous effectuez sur ces types sont représentées en interne par des appels de fonction.

Par exemple l’opération de soustraction a-b de deux nombre a et b est représentée en interne par l’appel de la fonction a.minus(b). Dans kotlin, on appelle le système de transformation d’une expression en appelle de fonction operator overloading. Nous parlerons des operators overloading dans un prochain tutoriel.

Vous savez à présent comment fonctionne les opérations en interne.

Il existe dans kotlin, plusieurs opérateurs organisés dans plusieurs catégories .

Les opérateurs mathématiques ou numériques

Les opérations d’addition, de soustraction, de multiplication etc, sont appelées opérations binaires

Opération	Description	Expression	Fonction Appelée
+	Addition	a + b	a.plus(b)
–	Soustraction	a – b	a.minus(b)
/	Division	a / b	a.div(b)
*	Multiplication	a * b	a.times(b)
%	Modulo	a % b	a.rem(b)

 val a = 20
 val b = 4
 println("L'addition de $a et $b est ${a+b}")    
 println("La soustraction de $a et $b est ${a-b}")    
 println("La division de $a par $b est ${a/b}")   
 println("La multiplication de $a et  $b est ${a*b}")   
 println("$a modulo $b est ${a%b}")

Les opérateurs d’assignation

L’un des opérateurs les plus utilisés en programmation est l’opérateur d’assignation représenté par le caractère = . Il assigne une valeur à une variable.Voir l’exemple suivant

val a = 5
val b = 2

Les opérateurs d’affectation augmentée

L’opérateur d’affectation augmentée est une combinaison d’un opérateur binaire(+, -, /, %) et de l’opérateur d’assignation(=).

Opérateur	Exemple	Équivalent
+=	a += 2	a = a +2
-=	b -= 3	b = b -3
*=	c *= 2	c = c * 2
/=	d /= 3	d = d / 3
%=	e %= 5	e = e % 5

 var a = 20
 var b = 5
 var c =15
 var d = 18
 var e = 25
 a += 2
 a = a +2
 b -= 3
 b = b -3
c *= 2
c = c * 2
d /= 3
d = d / 3
e %= 5
e = e % 5

Les opérateurs d’incrémentation et de décrémentation

Vous pouvez augmenter ou diminuer une variable par 1 avec respectivement l’opérateur d’incrémentation ++ et l’opérateur de décrémentation —..

var a  = 20
var b = 5
a = a++ // la valeur de a est 21
b = b-- // la valeur de b est 4

Vous pouvez passez l’opérateur d’incrémentation ou de décrémentation après la variable

var a = 20
var b = 5
a = ++a
b = --b

Concaténation de chaîne de caractère

L’opérateur + est aussi utilisé pour concaténer deux chaînes de caractère

 val nom: String ="VIGAN"
 val prenom: String ="Noé" 
 println(nom+" "+prenom)   

Les opérateurs logiques sur le type Booléen

Kotlin fournit plusieurs opérateurs logiques pour effectuer des opérations sur le type booléens .Les opérateurs logique sont:

Opérateur	Nom
||	OU logique
&&	ET logique
!	Non Logique

Voir l’exemple suivant

val a = 10
val b=3
a==b && b>5 //faux
a==10 || b >2 //Vrai
a!=5 && b!=2 //Vrai   

Les opérateurs d’égalité et d’inégalité

Les opérateurs d’égalité et d’inégalité sont représentés respectivement par les symbole == et != permettent de compare deux variables ou les valeurs référencées par deux variables.

Il ne faut pas confondre ces opérateurs d’égalité ou d’inégalité avec ceux de Java qui eux compare les références pour déterminer si deux variables font références au même objet.

Pour fournir une implémentation de contrôle d’égalité personnalisée par exemple lorsque vous créez vos propres classes , vous devez redéfinir cette méthode equals.

val a = 3 
val b=3
println(a==b) //true
println(a.equals(b))  //true

Les opérateurs d’égalités et d’inégalité de référence

Les opérateurs d’égalité et d’inégalité de référence sont respectivement représentés par les symboles === !==.Ces opérateurs permet de vérifier si deux variables font référence au même objet.

val a = 3
val b=3
println(a===b) //true

Vous devez constater que le résultat est true, car pour les types primitifs, Kotlin vérifie seulement si les deux valeurs sont égales.

Pour les objets, Kotlin vérifie s’il s’agit du même objet ou si les variables font référence au même objet. Dans un prochain tutoriel nous allons aborder les classes dans kotlin et comment comparer les références de deux objets.

Les opérateurs de comparaison

Voici ci-dessous la liste des opérateurs de comparaison

Opérateur	Description	Expression	Fonction appelée
>	supérieur que	a > b	a.compareTo(b) > 0
<	Inférieur que	a < b	a.compareTo(b) < 0
>=	supérieur ou égale à	a >= b	a.compareTo(b) >= 0
<=	Inférieur ou égale à	a <= b	a.compareTo(b) <= 0
==	Est égale à	a == b	a?.equals(b) ?: (b === null)
!=	Pas égale à	a != b	!(a?.equals(b) ?: (b === null))

val a = 3
val b=10
println(a == 3) //true
println(a != 3)  //false
println(a > b)   //false
println(a >= b)  //false
println(a < b)   //true
println(a <= b)  //true

Conclusion

Dans ce tutoriel, nous avons appris plusieurs types d’opérateur tel que les opérateur numérique, les opérateurs logique etc. J’espère que ce tutoriel vous aura aidé.A bientôt pour un autre tutoriel