L’expression when dans Kotlin

Dans Kotlin when est le remplacement de l’opérateur switch mais avec une syntaxe plus concise et des fonctionnalités plus avancées qu’un switch. Dans Kotlin, when est une expression ,cela signifie que when peut renvoyer une valeur.

When:Exemple

Voici un exemple de when. utilisé comme instruction.

  var colorPosition=2
  when(colorPosition){
        1 -> println("La couleur définie est Blue")
        2 -> println("La couleur définie est Rouge")
        3 -> println("La couleur définie est Orange")
        else -> println("Pas de couleur définie")
    }
//Affiche: La couleur définie est rouge

When fait correspondre son argument avec toutes les conditions de branche les unes après les autres (de manière séquentielle) jusqu’à ce q’une condition de branche soit trouvée.Il exécute alors la branche correspondante trouvé.La branche else est exécutée si aucune des conditions des autres branches ne correspond.

De plus vous pouvez aussi grouper plusieurs conditions de branche séparées par une virgule pour exécuter une seul branche qui satisfait les conditions regroupées.

var typeCaracter='a'
when(typeCaracter){
        'a', 'o', 'e', 'i'  -> println("Il s'agit d'une voyelle")
        'k' -> println("Il s'agit d'une consonne")
        'j' -> println("Il s'agit d'une consonne")

   }
//Affiche: Il s'agit d'une consonne

D’une part, When s’utilise comme une expression ou comme une instruction.Si when s’utilise comme une expression, la valeur de la branche correspondante devient la valeur de retour de l’expression when. Lorsque when s’utilise comme expression,la branche else est obligatoire.

  var colorPosition=3
  var resultat = when(colorPosition){
        1 -> "La couleur définie est Blue"
        2 -> "La couleur définie est Rouge"
        3 -> "La couleur définie est Orange"
        else -> "Pas de couleur définie"
    }
    println(resultat)
    //Affiche: La couleur définie est Orange

D’autre part, quand when est utilisé comme expression, la branche else peut être aussi omit si le compilateur peut prouver que tous les cas possible sont couvert par les différentes conditions de branche (par exemple comme le cas de tous les valeurs d’une énumération en Kotlin ,le case de toutes les valeurs d’un booléen, ou le case de toutes les sous classes d’une classe sealed).

Cet exemple illustre ce cas

 var loading=true
 var loadingState = when(loading){
        true -> "Le chargement est encours"
        false -> "Le chargement est terminé"
    }
   println(loadingState)

Vous devez constater que when est utilisé comme expression et que la branche else est omit.Puis que tous les cas sont couvert par le booléans qui ne peut avoir que deux valeur:vrai(true) et faux(false).

When s’utilise aussi comme une instruction, dans ce cas les valeurs des branches individuelles sont ignorées et l’instruction ou le bloc d’instruction est exécuté

var colorPosition=2
  when(colorPosition){
        1 -> println("La couleur définie est Blue")
        2 -> println("La couleur définie est Rouge")
        3 -> println("La couleur définie est Orange")
        else -> println("Pas de couleur définie")
    }
//Affiche: La couleur définie est rouge

Comme avec un if, chaque branche peut être un bloc et sa valeur de retour est la valeur de la dernière expression du bloc.Le bloc est délimité par des accolades.

var colorPosition=3

    var resultat = when(colorPosition){
        1 ->{ //Bloc
            println("Passe le feu au vert")
            "La couleur définie est vert"
        }
        2 -> "La couleur définie est Rouge"
        3 -> {
            println("Passe le feu à l'orange")
            "La couleur définie est Orange"
        }
        else -> "Pas de couleur définie"
    }
    println(resultat)
    //Affiche: Passe le feu à l'orange
    //Affiche: La couleur définie est Orange

When peut aussi avoir des conditions de branche arbitraire comme dans l’exemple suivant

 var number=2
 when(number){
        2 -> println("Le nombre est 2")
        in  1..5 -> println("Le nomnbre est compris entre 1 et 5  ")
        4 -> println("Le nombre est 4")
        in  10..20 -> print("Le nomnbre est compris entre 10 et 20  ")
 }
//Affiche: Le nombre est 2

L’ordre d’exécution des branches avec When

Puisque l’expression when fait correspondre son argument a toutes les conditions de branche l’une après l’autre, vous devez mettre en premier la condition de branche que vous souhaitez exécuter en premier si plusieurs conditions de branche ont une correspondance.Si plusieurs conditions de branche ont une correspondance c’est la premier branche correspondante qui s’exécute.

Si vous n’ordonnez pas correctement vos branches, une branche pourra s’exécuter à la place d’une autre ce qui pourra créer un bug dans votre code.

Prenons le cas d’une expression when ou plusieurs conditions de branche correspondent

  var number=4
  when(number){
      in  1..5 -> println("Le nomnbre est compris entre 1 et 5  ")
      4 -> println("Le nombre est 4")
      in  10..20 -> print("Le nomnbre est compris entre 10 et 20  ")
    }
  //Affiche: Le nomnbre est compris entre 1 et 5

Vous devez enfin de compte constater que les deux premières conditions de branche ont une correspondance avec l’argument mais c’est la branche de la première condition de branche qui est exécutée.Vous devez donc faire attention à l’ordre des conditions de branche que vous créez pour éviter des bugs dans votre code.

Vérifier si l’argument de when est dans un intervalle

Vous pouvez aussi utiliser un intervalle (range en kotlin) dans une expression when comme condition de branche.Les intervalles sont créés avec l’opérateur (..).

Je vais créer un tuto sur les intervalles plus tard. Par exemple pour créer un intervalle de 3 9 en kotlin, on écrit 3..9.Vous pouvez donc créer une expression when avec les intervalles grace à l’opérateur in comme suit.

 var number=4
 when(number){
      in  1..5 -> println("Le nomnbre est compris entre 1 et 5  ")
      in  10..20 -> print("Le nomnbre est compris entre 10 et 20  ")
    }
    
  //Affiche: Le nomnbre est compris entre 1 et 5

Utiliser When sans Argument

Vous pouvez aussi utiliser une expression when sans argument.Dans ce cas, Les conditions de branche sont utilisées comme des booléens et donc la branche de la première condition de branche dont la valeur est vrai(true) est exécutée.

var number=12
when{
      number <= 12 -> println("Le nomnbre est inférieur ou égal à 12 ")
      number > 50 -> println("Le nombre est supérieur à 50")
 }
//Affiche: Le nomnbre est inférieur ou égal à 12

Vérification du type de la valeur avec when

D’autre part,vvous pouvez aussi vérifier si une valeur est d’un type spécifique avec when comme suit:

var name: Any ="Joel"
when(name){
        is String -> println("Il s'agit d'une chaine de caractère")
        is  Int -> println("Il s'agit d'un nombre")
        
    }
//Affiche: Il s'agit d'une chaine de caractère

Conclusion

En définitive ,nous sommes à la fin de ce tutoriel dans lequel nous avons aborder l’expression when dans Kotlin. J’espère que ce tutoriel vous aidera. A bientôt pour un nouveau tutoriel.

Autres ressources

https://kotlinlang.org/docs/reference/control-flow.html

Comment utiliser une expression If dans Kotlin