Kotlin : Les opérateurs
Les opérateurs sont des caractères spéciaux qui effectuent des opérations sur les opérandes (valeurs ou variables). Il existe plusieurs types d'opérateurs en Kotlin.
Opérateur arithmétique, Opérateur de relation, Opérateur d'assignation, Opérateur unaire, Opérateur binaire, Opérateur logique, in Opérator, Opérateur d'accès à l'index, range Opérator.
Opérateur arithmétique
Les opérateurs arithmétiques sont utilisés pour effectuer des opérations mathématiques de base telles que l'addition (+), la soustraction (-), la multiplication (*), la division (/), etc.
Exemple d'opérateur arithmétique
fun 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) ;
}
Opérateur de relation
L'opérateur relationnel montre la relation et compare les opérandes. Voici les différents opérateurs relationnels :
Sortie :
fun main(args : Array<String>) {
val a = 5
val b = 10
val max = if (a > b) {
println("a est plus grand que b.")
a
} else{
println("b est supérieur à a.")
b
}
println("max = $max")
}
Opérateur d'assignation
L'opérateur d'affectation "=" est utilisé pour affecter une valeur à une autre variable. L'affectation de la valeur se fait de droite à gauche.
Exemple d'opérateur d'assignation
fun main(args : Array<String>) {
var a =20;var b=5
a+=b
println("a+=b : "+ a)
a-=b
println("a-=b : "+ a)
a*=b
println("a*=b : "+ a)
a/=b
println("a/=b : "+ a)
a%=b
println("a%=b : "+ a)
}
Sortie :
Opérateur unaire
L'opérateur unaire est utilisé avec un seul opérande. Vous trouverez ci-dessous quelques opérateurs unaires.
Exemple d'opérateur unaire
fun main(args : Array<String>){
var a=10
var b=5
var flag = true
println("+a : "+ +a)
println("-b : "+ -b)
println("++a : "+ ++a)
println("--b : "+ --b)
println("!flag : "+ !flag)
}
Sortie :
Opérateur logique
Les opérateurs logiques sont utilisés pour vérifier les conditions entre les opérandes. La liste des opérateurs logiques est donnée ci-dessous.
Opérateur Description Exp. Traduire
&& renvoie vrai si
toutes les expressions sont vraies (a>b) && (a>c) (a>b) and(a>c)
| | renvoie vrai si l'une des
expression est vraie (a>b) || (a>c) (a>b) or(a>c)
! retourne le complément
de l'expression !a a.not()
Exemple d'opérateur logique
fun main(args : Array<String>){
var a=10
var b=5
var c=15
var flag = false
var result : Booléen
result = (a>b) && (a>c)
println("(a>b) && (a>c) : "+ résultat)
result = (a>b) || (a>c)
println("(a>b) || (a>c) : "+ result)
résultat = !drapeau
println("!flag : "+ result)
}
KotlinCopy
Sortie :
(a>b) && (a>c) :false
(a>b) || (a>c) :true
!flag :true
Opération par binaire
En Kotlin, il n'y a pas d'opérateur bitwise spécial. L'opération binaire est effectuée à l'aide d'une fonction nommée.
Fonction Expression Description
shl (bits) a.shl(b) décalage signé vers la gauche
shr (bits) a.shr(b) décalage signé vers la droite
ushr (bits) a.ushr(b) décalage non signé vers la droite
and (bits) a.and(b) Déplacement vers le bit et
or (bits) a.or(b) bit à bit ou
xor (bits) a.xor(b) xor au niveau du bit
inv() a.inv(b) inverse au sens du bit
Exemple d'opération bitwise
fun main(args : Array<String>){
var a=10
var b=2
println("a.shl(b) : "+a.shl(b))
println("a.shr(b) : "+a.shr(b))
println("a.ushr(b :) "+a.ushr(b))
println("a.and(b) : "+a.and(b))
println("a.or(b) : "+a.or(b))
println("a.xor(b) : "+a.xor(b))
println("a.inv() : "+a.inv())
}
Sortie :
a.shl(b) : 40
a.shr(b) : 2
a.ushr(b :) 2
a.and(b) : 2
a.or(b) : 10
a.xor(b) : 8
a.inv() : -11
in Opérator
L'opérateur in est utilisé pour vérifier si un objet appartient à une collection.
Expression de l'opérateur Traduire en
dans a dans b b.contient(a)
!in a !in b !b.contains(a)
fun main(args : Array<String>) {
val nombres = intArrayOf(1, 4, 42, -3)
if (4 in nombres) {
println("le tableau des nombres contient 4.")
}
}
Sortie :
le tableau de nombres contient 4.
Opérateur d'accès à l'index
Voici quelques expressions utilisant l'opérateur d'accès à l'index avec les fonctions correspondantes en Kotlin.
Opérateur Traduire en
a[i] a.get(i)
a[i, n] a.get(i, n)
a[i1, i2, ..., in] a.get(i1, i2, ..., in)
a[i] = b a.set(i, b)
a[i, n] = b a.set(i, n, b)
a[i1, i2, ..., in] = b a.set(i1, i2, ..., in, b)
Exemple :
fun main(args : Array<String>) {
val a = intArrayOf(1, 2, 3, 4, - 1)
println(a[1])
a[1]= 12
println(a[1])
}
KotlinCopy
Sortie :
2
12
range Opérator:
Le range Kotlin est définie comme un intervalle entre la valeur de départ et la valeur d'arrivée. Les expressions d'intervalle sont créées avec l'opérateur (. .) qui est complété par in et !in. La valeur qui est égale ou supérieure à la valeur de début et inférieure ou égale à la valeur de fin se trouve à l'intérieur de la plage définie.
valaToZ = 'a'...'z'.
valoneToNine = 1..9
KotlinCopy
Exemple de gamme Kotlin
fun main(args : Array<String>) {
pour (a dans 1..5){
print(a )
}
println()
for(x in 'a'...'f'){
print(x )
}
println()
val range = 1.0..5.0
println(plage)
println("3.14 in range is ${3.14 in range}")
}
sortie :
12345
abcdef
1.0..5.0
3.14 dans l'intervalle est vrai
KotlinCopy
nous apprendrons plus sur l'opérateur range dans la section avancée.