Écrire des instructions conditionnelles en langage Kotlin

1. Avant de commencer

Les instructions conditionnelles constituent l'un des aspects les plus importants de la programmation. Dans les langages de programmation, ces instructions sont des commandes qui gèrent les décisions. Avec les instructions conditionnelles, le code est dynamique, ce qui signifie qu'il peut se comporter différemment suivant les conditions.

Cet atelier de programmation vous explique comment utiliser les instructions et expressions if/else et when pour écrire des instructions conditionnelles en langage Kotlin.

Conditions préalables

• Vous connaissez les bases de la programmation en Kotlin, y compris les variables, et les fonctions println() et main().

Points abordés

• Comment écrire des expressions booléennes.
• Comment écrire des instructions if/else.
• Comment écrire des instructions when.
• Comment écrire des expressions if/else.
• Comment écrire des expressions when.
• Comment utiliser des virgules pour définir le comportement commun à plusieurs branches dans les instructions conditionnelles when.
• Comment utiliser la plage in pour définir le comportement commun à une plage de branches dans les instructions conditionnelles when.
• Comment utiliser le mot clé is pour écrire des instructions conditionnelles when.

Ce dont vous avez besoin

• Un navigateur Web ayant accès à Kotlin Playground.

2. Utiliser des instructions if/else pour exprimer des conditions

Dans la vie de tous les jours, il est courant d'agir différemment selon la situation à laquelle vous êtes confronté. Par exemple, s'il fait froid, vous porterez une veste, alors que s'il fait chaud, vous n'en porterez pas.

La prise de décision est également un concept fondamental en programmation. Vous écrivez des instructions sur le comportement que doit adopter un programme dans une situation donnée, afin qu'il puisse agir ou réagir en conséquence. En langage Kotlin, si vous souhaitez que le programme effectue différentes actions en fonction d'une condition, vous pouvez utiliser une instruction if/else. Dans la section suivante, vous allez écrire une instruction if.

Écrire des conditions if avec des expressions booléennes

Imaginons que vous conceviez un programme qui indique aux conducteurs ce qu'ils doivent faire lorsqu'ils arrivent à un feu. Concentrez-vous sur la première condition : un feu rouge. Que faites-vous à un feu rouge ? Vous vous arrêtez.

En langage Kotlin, vous pouvez exprimer cette condition avec une instruction if. Examinons l'anatomie d'une instruction if :

Pour utiliser des instructions if, vous devez utiliser le mot clé if, suivi de la condition à évaluer. Vous devez exprimer la condition avec une expression booléenne. Les expressions combinent des valeurs, des variables et des opérateurs qui renvoient une valeur. Les expressions booléennes renvoient une valeur booléenne.

Dans une leçon précédente, vous avez étudié les opérateurs d'affectation, comme :

val number = 1

L'opérateur d'affectation = attribue une valeur 1 à la variable number.

Les expressions booléennes sont, quant à elles, construites avec des opérateurs de comparaison, qui comparent les valeurs ou variables des deux côtés de l'équation. Examinons un opérateur de comparaison.

1 == 1

L'opérateur de comparaison == compare les valeurs les unes aux autres. Selon vous, quelle valeur booléenne cette expression renvoie-t-elle ?

Recherchez la valeur booléenne de cette expression :

1. Utilisez Kotlin Playground pour exécuter votre code.
2. Dans le corps de la fonction, ajoutez une fonction println(), puis transmettez-lui l'expression 1 == 1 en tant qu'argument :

fun main() {
    println(1 == 1)
}

3. Exécutez le programme, puis affichez la sortie :

true

La première valeur 1 est égale à la deuxième valeur 1. L'expression booléenne renvoie donc une valeur true, qui est une valeur booléenne.

À vous de jouer

Outre ==, il existe d'autres opérateurs de comparaison que vous pouvez utiliser pour créer des expressions booléennes :

• Inférieur à : <
• Supérieur à : >
• Inférieur ou égal à : <=
• Supérieur ou égal à : >=
• Différent de : !=

Entraînez-vous à utiliser des opérateurs de comparaison avec des expressions simples :

1. Dans l'argument, remplacez l'opérateur de comparaison == par < :

fun main() {
    println(1 < 1)
}

2. Exécutez le programme, puis affichez la sortie :

La sortie affiche une valeur false, car la première valeur 1 n'est pas inférieure à la deuxième valeur 1.

false

3. Répétez les deux premières étapes avec les autres nombres et opérateurs de comparaison.

Écrire une instruction if simple

Maintenant que vous avez vu comment écrire des expressions booléennes, vous pouvez écrire votre première instruction if. La syntaxe d'une instruction if est la suivante :

Une instruction if commence par le mot clé if suivi d'une condition, qui est une expression booléenne entre parenthèses, et d'une paire d'accolades. Le corps est une série d'instructions ou d'expressions que vous placez entre accolades après la condition. Ces instructions ou expressions ne sont exécutées que lorsque la condition est remplie. En d'autres termes, les instructions entre accolades ne sont exécutées que lorsqu'une expression booléenne de la branche if renvoie une valeur true.

Écrivez une instruction if pour la condition de feu rouge :

1. À l'intérieur de la fonction main(), créez une variable trafficLightColor et affectez-lui une valeur "Red" :

fun main() {
    val trafficLightColor = "Red"
}

2. Ajoutez une instruction if pour la condition de feu rouge, puis transmettez-lui une expression trafficLightColor == "Red" :

fun main() {
    val trafficLightColor = "Red"

    if (trafficLightColor == "Red") {

    }
}

3. Dans le corps de l'instruction if, ajoutez une fonction println(), puis transmettez-lui un argument "Stop" :

fun main() {
    val trafficLightColor = "Red"

    if (trafficLightColor == "Red") {
        println("Stop")
    }
}

4. Exécutez le programme, puis affichez la sortie :

Stop

L'expression trafficLightColor == "Red" renvoie une valeur true. L'instruction println("Stop") est donc exécutée, ce qui imprime le message Stop.

Ajouter une branche else

Vous pouvez maintenant étendre le programme pour qu'il indique aux conducteurs d'avancer lorsque le feu n'est pas rouge.

Vous devez ajouter une branche else pour créer une instruction if/else. Une branche est une partie de code incomplète que vous pouvez joindre pour former des instructions ou des expressions. Une branche else doit suivre une branche if.

Après l'accolade fermante de l'instruction if, ajoutez le mot clé else suivi d'une paire d'accolades. À l'intérieur des accolades de l'instruction else, vous pouvez ajouter un deuxième corps qui ne sera exécuté que si la condition de la branche if est fausse.

Ajoutez une branche else à votre programme :

1. Après l'accolade fermante de l'instruction if, ajoutez le mot clé else suivi d'une autre paire d'accolades :

fun main() {
    val trafficLightColor = "Red"

    if (trafficLightColor == "Red") {
        println("Stop")
    } else {

    }
}

2. À l'intérieur des accolades du mot clé else, ajoutez une fonction println(), puis transmettez-lui un argument "Go" :

fun main() {
    val trafficLightColor = "Red"

    if (trafficLightColor == "Red") {
        println("Stop")
    } else {
        println("Go")
    }
}

3. Exécutez ce programme, puis affichez la sortie :

Stop

Le programme se comporte de la même manière qu'avant l'ajout de la branche else, mais il n'affiche pas de message Go.

4. Réaffectez la variable trafficLightColor à une valeur Green, car vous souhaitez que les conducteurs passent au vert :

fun main() {
    val trafficLightColor = "Green"

    if (trafficLightColor == "Red") {
        println("Stop")
    } else {
        println("Go")
    }
}

5. Exécutez ce programme, puis affichez la sortie :

Go

Comme vous pouvez le voir, le programme imprime à présent un message Go au lieu de Stop.

Vous avez réattribué la variable trafficLightColor à une valeur "Green", de sorte que l'expression trafficLightColor == "Red" évaluée dans la branche if renvoie une valeur false, car la valeur "Green" est différente de "Red".

Par conséquent, le programme ignore toutes les instructions de la branche if et exécute toutes celles de la branche else. Cela signifie que la fonction println("Go") est exécutée, mais pas la fonction println("Stop").

Ajouter une branche else if

En général, un feu tricolore comprend également un feu orange qui invite les conducteurs à ralentir. Vous pouvez étendre le processus décisionnel du programme pour en tenir compte.

Vous avez appris à écrire des instructions conditionnelles qui répondent aux besoins d'un seul point de décision avec des instructions if/else contenant une seule branche if et une seule branche else. Comment gérer un embranchement plus complexe avec plusieurs points de décision ? En présence de plusieurs points de décision, vous devez créer des instructions conditionnelles avec plusieurs couches de conditions. Vous pouvez le faire en ajoutant des branches else if à des instructions if/else.

Après l'accolade fermante de la branche if, vous devez ajouter le mot clé else if. Entre les parenthèses du mot clé else if, vous devez ajouter une expression booléenne comme condition pour la branche else if, suivie d'un corps entre accolades. Le corps n'est exécuté que si la condition 1 échoue, mais que la condition 2 est remplie.

La branche else if est toujours située après la branche if, mais avant la branche else. Vous pouvez utiliser plusieurs branches else if dans une instruction :

L'instruction if peut également contenir la branche if et des branches else if sans aucune branche else :

Ajoutez une branche else if à votre programme :

1. Après l'accolade fermante de l'instruction if, ajoutez une expression else if (trafficLightColor == "Yellow") suivie d'accolades :

fun main() {
    val trafficLightColor = "Green"

    if (trafficLightColor == "Red") {
        println("Stop")
    } else if (trafficLightColor == "Yellow") {

    } else {
        println("Go")
    }
}

2. À l'intérieur des accolades de la branche else if, ajoutez une instruction println(), puis transmettez-lui un argument de chaîne "Slow" :

fun main() {
    val trafficLightColor = "Green"

    if (trafficLightColor == "Red") {
        println("Stop")
    } else if (trafficLightColor == "Yellow") {
        println("Slow")
    } else {
        println("Go")
    }
}

3. Réaffectez la variable trafficLightColor à une valeur de chaîne "Yellow" :

fun main() {
    val trafficLightColor = "Yellow"

    if (trafficLightColor == "Red") {
        println("Stop")
    } else if (trafficLightColor == "Yellow") {
        println("Slow")
    } else {
        println("Go")
    }
}

4. Exécutez ce programme, puis affichez la sortie :

Slow

Le programme imprime à présent le message Slow au lieu de Stop ou Go.

Voici la raison pour laquelle le programme affiche uniquement un message Slow, et non les autres lignes :

• Une valeur "Yellow" est affectée à la variable trafficLightColor.
• La valeur "Yellow" étant différente de "Red", l'expression booléenne de la branche if (représentée par 1 dans l'image) renvoie une valeur false. Le programme ignore toutes les instructions de la branche if et n'imprime pas de message Stop.
• Étant donné que la branche if génère une valeur false, le programme procède à l'évaluation de l'expression booléenne à l'intérieur de la branche else if.
• La valeur "Yellow" étant égale à "Yellow", l'expression booléenne de la branche else if (représentée par 2 dans l'image) renvoie une valeur true. Le programme exécute toutes les instructions à l'intérieur de la branche else if et imprime un message Slow.
• Étant donné que la valeur booléenne expression de la branche else if renvoie une valeur true, le programme ignore les autres branches. Par conséquent, toutes les instructions de la branche else ne sont pas exécutées et le programme n'imprime pas de message Go.

À vous de jouer

Avez-vous remarqué que le programme actuel contenait un bug ?

Dans le module 1, vous avez découvert un type de bug appelé erreur de compilation, où Kotlin ne peut pas compiler le code en raison d'une erreur syntaxique dans votre code, rendant impossible l'exécution du programme. Vous êtes confronté ici à un autre type de bug appelé erreur logique dans lequel le programme peut s'exécuter, mais ne produit pas le résultat attendu.

On part du principe que vous souhaitez que les conducteurs ne passent que lorsque le feu est vert. Que se passe-t-il si le feu de signalisation est endommagé et ne fonctionne pas ? Voulez-vous que le conducteur passe au feu ou reçoive un avertissement indiquant que quelque chose ne va pas ?

Malheureusement, dans le programme actuel, si la couleur du feu n'est ni rouge ni orange (condition else), le conducteur est tout de même invité à avancer (go).

Corrigez ce problème :

1. Réaffectez une valeur "Black" à la variable trafficLightColor pour illustrer un feu de signalisation éteint :

fun main() {
    val trafficLightColor = "Black"

    if (trafficLightColor == "Red") {
        println("Stop")
    } else if (trafficLightColor == "Yellow") {
        println("Slow")
    } else {
        println("Go")
    }
}

2. Exécutez ce programme, puis affichez la sortie :

Go

Notez que le programme imprime un message Go, même si aucune valeur "Green" n'est affectée à la variable trafficLightColor. Pouvez-vous corriger ce programme afin qu'il reflète le comportement approprié ?

Vous devez modifier le programme pour qu'il imprime ce qui suit :

• Un message Go, uniquement si une valeur "Green" est affectée à la variable trafficLightColor
• Un message Invalid traffic-light color si une valeur "Red", "Yellow" ou "Green" n'est pas affectée à la variable trafficLightColor.

Corriger la branche else

La branche else est toujours située à la fin d'une instruction if/else, car il s'agit d'une branche CatchAll. Elle s'exécute automatiquement lorsque toutes les autres conditions des branches précédentes ne sont pas remplies. Par conséquent, la branche else ne convient pas si vous souhaitez qu'une action ne s'exécute que lorsqu'elle remplit une condition spécifique. Dans le cas du feu de signalisation, vous pouvez utiliser la branche else if pour spécifier la condition pour le feu vert.

Utilisez la branche else if pour évaluer la condition de feu vert :

1. Après la branche else if actuelle, ajoutez une autre branche else if (trafficLightColor == "Green") :

fun main() {
    val trafficLightColor = "Black"

    if (trafficLightColor == "Red") {
        println("Stop")
    } else if (trafficLightColor == "Yellow") {
        println("Slow")
    } else if (trafficLightColor == "Green") {
        println("Go")
    }
}

2. Exécutez ce programme, puis affichez la sortie.

La sortie est vide, car aucune branche else ne s'exécute lorsque les conditions précédentes ne sont pas remplies.

3. Après la dernière branche else if, ajoutez une branche else contenant une instruction println("Invalid traffic-light color") :

fun main() {
    val trafficLightColor = "Black"

    if (trafficLightColor == "Red") {
        println("Stop")
    } else if (trafficLightColor == "Yellow") {
        println("Slow")
    } else if (trafficLightColor == "Green") {
        println("Go")
    } else {
        println("Invalid traffic-light color")
    }

}

4. Exécutez ce programme, puis affichez la sortie :

Invalid traffic-light color

5. Affectez à la variable trafficLightColor une valeur autre que "Red", "Yellow" ou "Green", puis réexécutez le programme.

Quel est le résultat de ce programme ?

En programmation, il est recommandé d'avoir une branche else if explicite comme validation d'entrée pour la couleur verte et une branche else pour "intercepter" d'autres entrées non valides. De cette façon, les conducteurs ne sont invités à avancer (go) que lorsque le feu est vert. Dans les autres cas, un message explicite signale que le feu tricolore ne fonctionne pas comme prévu.

3. Utiliser une instruction "when" pour plusieurs branches

Votre programme trafficLightColor semble plus complexe avec plusieurs conditions, que l'on désigne également sous le nom d'embranchements. Vous vous demandez peut-être s'il est possible de simplifier un programme avec un nombre de branches encore plus important.

En langage Kotlin, lorsque vous traitez plusieurs branches, vous pouvez utiliser l'instruction when au lieu de if/else, car elle facilite la lisibilité du code pour les lecteurs humains, qui sont généralement des développeurs. Il est très important de tenir compte de la lisibilité lorsque vous écrivez votre code. En effet, il est susceptible d'être examiné et modifié par d'autres développeurs au cours de sa durée de vie. Une bonne lisibilité permettra aux développeurs de comprendre votre code et empêchera toute introduction accidentelle de bugs.

Il est préférable d'utiliser des instructions when lorsqu'il y a plusieurs branches à prendre en compte.

Une instruction when accepte une seule valeur via le paramètre. La valeur est ensuite évaluée par rapport à chacune des conditions, de manière séquentielle. Le corps de la première condition qui est remplie est ensuite exécuté. Chaque condition et chaque corps sont séparés par une flèche (->). Comme pour les instructions if/else, chaque paire formée d'une condition et d'un corps est appelée branche dans les instructions when. Comme pour l'instruction if/else, vous pouvez ajouter une branche else comme condition finale dans une instruction when. Elle fait office de branche CatchAll.

Réécrire une instruction if/else avec une instruction when

Le programme de feu de signalisation comprend déjà plusieurs branches :

• Couleur du feu Rouge
• Couleur du feu Orange
• Couleur du feu Vert
• Autre couleur du feu

Convertissez le programme pour utiliser une instruction when :

1. Dans la fonction main(), supprimez l'instruction if/else :

fun main() {
    val trafficLightColor = "Black"

}

2. Ajoutez une instruction when, puis transmettez la variable trafficLightColor en tant qu'argument :

fun main() {
    val trafficLightColor = "Black"

    when (trafficLightColor) {
    }
}

3. Dans le corps de l'instruction when, ajoutez la condition "Red", suivie d'une flèche et d'un corps println("Stop") :

fun main() {
    val trafficLightColor = "Black"

    when (trafficLightColor) {
        "Red" -> println("Stop")
    }
}

4. Sur la ligne suivante, ajoutez la condition "Yellow", suivie d'une flèche et d'un corps println("Slow") :

fun main() {
    val trafficLightColor = "Black"

    when (trafficLightColor) {
        "Red" -> println("Stop")
        "Yellow" -> println("Slow")
    }
}

5. Sur la ligne suivante, ajoutez la condition "Green", suivie d'une flèche, puis d'un corps println("Go") :

fun main() {
    val trafficLightColor = "Black"

    when (trafficLightColor) {
        "Red" -> println("Stop")
        "Yellow" -> println("Slow")
        "Green" -> println("Go")
    }
}

6. Sur la ligne suivante, ajoutez le mot clé else, suivi d'une flèche, puis d'un corps println("Invalid traffic-light color") :

fun main() {
    val trafficLightColor = "Black"

    when (trafficLightColor) {
        "Red" -> println("Stop")
        "Yellow" -> println("Slow")
        "Green" -> println("Go")
        else -> println("Invalid traffic-light color")
    }
}

7. Réaffectez une valeur "Yellow" à la variable trafficLightColor :

fun main() {
    val trafficLightColor = "Yellow"

    when (trafficLightColor) {
        "Red" -> println("Stop")
        "Yellow" -> println("Slow")
        "Green" -> println("Go")
        else -> println("Invalid traffic-light color")
    }
}

Selon vous, quelle sera la sortie de ce programme lorsque vous l'aurez exécuté ?

8. Exécutez le programme, puis affichez la sortie :

Slow

La sortie est un message Slow pour les raisons suivantes :

• Une valeur "Yellow" est affectée à la variable trafficLightColor.
• Le programme évalue chaque condition une par une, de manière séquentielle.
• La valeur "Yellow" n'étant pas égale à "Red", le programme ignore le premier corps.
• La valeur "Yellow" étant égale à "Yellow", le programme exécute le deuxième corps et imprime un message Slow.
• Un corps a été exécuté. Le programme ignore donc les troisième et quatrième branches, et quitte l'instruction when.

Écrire des conditions plus complexes dans une instruction when

Jusqu'à présent, vous avez appris à écrire des conditions when pour une seule condition "égal à" ; c'est le cas, par exemple, quand une valeur "Yellow" est affectée à la variable trafficLightColor. Vous allez maintenant apprendre à utiliser la virgule (,), le mot clé in et le mot clé is pour former des conditions when plus complexes.

Créez un programme pour déterminer si un nombre entre 1 et 10 est un nombre premier :

1. Ouvrez Kotlin Playground dans une fenêtre distincte.

Vous reviendrez au programme de feu de signalisation plus tard.

2. Définissez une variable x, puis affectez-lui une valeur 3 :

fun main() {
    val x = 3
}

3. Ajoutez une instruction when qui inclut plusieurs branches pour les conditions 2, 3, 5 et 7, puis faites-les suivre du corps println("x is prime number between 1 and 10.") :

fun main() {
    val x = 3

    when (x) {
        2 -> println("x is a prime number between 1 and 10.")
        3 -> println("x is a prime number between 1 and 10.")
        5 -> println("x is a prime number between 1 and 10.")
        7 -> println("x is a prime number between 1 and 10.")
    }
}

4. Ajoutez une branche else avec un corps println("x is not prime number between 1 and 10.") :

fun main() {
    val x = 3

    when (x) {
        2 -> println("x is a prime number between 1 and 10.")
        3 -> println("x is a prime number between 1 and 10.")
        5 -> println("x is a prime number between 1 and 10.")
        7 -> println("x is a prime number between 1 and 10.")
        else -> println("x isn't a prime number between 1 and 10.")
    }
}

5. Exécutez le programme, puis vérifiez que la sortie est conforme à vos attentes :

x is a prime number between 1 and 10.

Utiliser une virgule (,) pour plusieurs conditions

Le programme des nombres premiers contient de nombreuses répétitions d'instructions println(). Lorsque vous écrivez une instruction when, vous pouvez utiliser une virgule (,) pour indiquer plusieurs conditions correspondant au même corps.

Dans le schéma ci-dessus, si la première ou la deuxième condition est remplie, le corps correspondant est exécuté.

Réécrivez le programme des nombres premiers avec le concept suivant :

1. Dans la branche de la condition 2, ajoutez 3, 5 et 7, en les séparant par des virgules (,) :

fun main() {
    val x = 3

    when (x) {
        2, 3, 5, 7 -> println("x is a prime number between 1 and 10.")
        3 -> println("x is a prime number between 1 and 10.")
        5 -> println("x is a prime number between 1 and 10.")
        7 -> println("x is a prime number between 1 and 10.")
        else -> println("x isn't a prime number between 1 and 10.")
    }
}

2. Supprimez les différentes branches des conditions 3, 5 et 7 :

fun main() {
    val x = 3

    when (x) {
        2, 3, 5, 7 -> println("x is a prime number between 1 and 10.")
        else -> println("x isn't a prime number between 1 and 10.")
    }
}

3. Exécutez le programme, puis vérifiez que la sortie est conforme à vos attentes :

x is a prime number between 1 and 10.

Utiliser le mot clé in pour une plage de conditions

Outre le symbole de la virgule (,) pour indiquer plusieurs conditions, vous pouvez utiliser le mot clé in et une plage de valeurs dans les branches when.

Pour utiliser une plage de valeurs, ajoutez un nombre qui indique le début de la plage, suivi de deux points sans espace, puis fermez la plage à l'aide d'un autre nombre pour en indiquer la fin.

Lorsque la valeur du paramètre est égale à une valeur comprise entre le début et la fin de la plage, le premier corps est exécuté.

Dans votre programme des nombres premiers, pouvez-vous imprimer un message si le nombre est compris entre 1 et 10, mais n'est pas un nombre premier ?

Ajoutez une autre branche avec le mot clé in :

1. Après la première branche de l'instruction when, ajoutez-en une deuxième avec le mot clé in, suivi d'une plage 1..10 et d'un corps println("x is a number between 1 and 10, but not a prime number.") :

fun main() {
    val x = 3

    when (x) {
        2, 3, 5, 7 -> println("x is a prime number between 1 and 10.")
        in 1..10 -> println("x is a number between 1 and 10, but not a prime number.")
        else -> println("x isn't a prime number between 1 and 10.")
    }
}

2. Remplacez la variable x par une valeur 4 :

fun main() {
    val x = 4

    when (x) {
        2, 3, 5, 7 -> println("x is a prime number between 1 and 10.")
        in 1..10 -> println("x is a number between 1 and 10, but not a prime number.")
        else -> println("x isn't a prime number between 1 and 10.")
    }
}

3. Exécutez le programme, puis vérifiez la sortie :

x is a number between 1 and 10, but not a prime number.

Le programme imprime le message de la deuxième branche, mais pas celui de la première ni de la troisième.

Voici comment ce programme fonctionne :

• Une valeur 4 est affectée à la variable x.
• Le programme procède à l'évaluation des conditions de la première branche. La valeur 4 étant différente de 2, 3, 5 ou 7, le programme ignore l'exécution du corps de la première branche et passe à la deuxième.
• Étant donné que la valeur 4 est comprise entre 1 et 10, le corps du message x is a number between 1 and 10, but not a prime number. est imprimé.
• Un corps est exécuté. Le programme quitte donc l'instruction when et ignore la branche else.

Utiliser le mot clé is pour vérifier le type de données

Vous pouvez utiliser le mot clé is comme condition pour vérifier le type de données d'une valeur évaluée.

Dans le schéma ci-dessus, si la valeur de l'argument est du type de données indiqué, le premier corps est exécuté.

Dans votre programme des nombres premiers, pouvez-vous imprimer un message si l'entrée est un nombre entier qui n'est pas compris entre 1 et 10 ?

Ajoutez une autre branche avec le mot clé is :

1. Modifiez x pour qu'il soit de type Any. Cela indique que x peut être une valeur d'un type autre que Int.

fun main() {
    val x: Any = 4

    when (x) {
        2, 3, 5, 7 -> println("x is a prime number between 1 and 10.")
        in 1..10 -> println("x is a number between 1 and 10, but not a prime number.")
        else -> println("x isn't a prime number between 1 and 10.")
    }
}

2. Après la deuxième branche de l'instruction when, ajoutez le mot clé is et un type de données Int avec un corps println("x is an integer number, but not between 1 and 10.") :

fun main() {
    val x: Any = 4

    when (x) {
        2, 3, 5, 7 -> println("x is a prime number between 1 and 10.")
        in 1..10 -> println("x is a number between 1 and 10, but not a prime number.")
        is Int -> println("x is an integer number, but not between 1 and 10.")
        else -> println("x isn't a prime number between 1 and 10.")
    }
}

3. Dans la branche else, remplacez le corps par println("x isn't an integer number.") :

fun main() {
    val x: Any = 4

    when (x) {
        2, 3, 5, 7 -> println("x is a prime number between 1 and 10.")
        in 1..10 -> println("x is a number between 1 and 10, but not a prime number.")
        is Int -> println("x is an integer number, but not between 1 and 10.")
        else -> println("x isn't an integer number.")
    }
}

4. Remplacez la variable x par une valeur 20 :

fun main() {
    val x: Any = 20

    when (x) {
        2, 3, 5, 7 -> println("x is a prime number between 1 and 10.")
        in 1..10 -> println("x is a number between 1 and 10, but not a prime number.")
        is Int -> println("x is an integer number, but not between 1 and 10.")
        else -> println("x isn't an integer number.")
    }
}

5. Exécutez le programme, puis vérifiez la sortie :

x is an integer number, but not between 1 and 10.

Le programme imprime le message de la troisième branche, mais pas ceux de la première, de la deuxième ni de la quatrième.

Voici comment le programme fonctionne :

• Une valeur 20 est affectée à la variable x.
• Le programme procède à l'évaluation des conditions de la première branche. La valeur 20 étant différente de 2, 3, 5 ou 7, le programme ignore l'exécution du corps de la première branche et passe à la deuxième.
• La valeur 20 n'étant pas comprise dans la plage 1 à 10, le programme ignore l'exécution du corps de la deuxième branche et passe à la troisième.
• La valeur 20 étant de type Int, le corps x is an integer number, but not between 1 and 10 est imprimé.
• Un corps est exécuté. Le programme quitte donc l'instruction when et ignore la branche else.

À vous de jouer

Vous allez maintenant mettre en pratique ce que vous avez appris dans votre programme de feu de signalisation.

Supposons que dans certains pays, les feux de signalisation utilisent la couleur jaune en lieu et place de la couleur orange. Pouvez-vous modifier le programme pour qu'il couvre cette condition supplémentaire, tout en conservant les conditions d'origine ?

Ajouter une condition supplémentaire avec le même corps

Ajoutez une condition supplémentaire au programme de feu de signalisation :

1. Si elle est toujours ouverte, revenez à l'instance de Kotlin Playground avec votre programme de feu de signalisation.
2. Si vous l'avez fermée, ouvrez une nouvelle instance de Kotlin Playground et saisissez le code suivant :

fun main() {
    val trafficLightColor = "Yellow"

    when (trafficLightColor) {
        "Red" -> println("Stop")
        "Yellow" -> println("Slow")
        "Green" -> println("Go")
        else -> println("Invalid traffic-light color")
    }
}

3. Dans la deuxième branche de l'instruction when, ajoutez une virgule après la condition "Yellow", puis une condition "Amber" :

fun main() {
    val trafficLightColor = "Yellow"

    when (trafficLightColor) {
        "Red" -> println("Stop")
        "Yellow", "Amber" -> println("Slow")
        "Green" -> println("Go")
        else -> println("Invalid traffic-light color")
    }
}

4. Remplacez la variable trafficLightColor par une valeur "Amber" :

fun main() {
    val trafficLightColor = "Amber"

    when (trafficLightColor) {
        "Red" -> println("Stop")
        "Yellow", "Amber" -> println("Slow")
        "Green" -> println("Go")
        else -> println("Invalid traffic-light color")
    }
}

5. Exécutez ce programme, puis vérifiez la sortie :

Slow

4. Utiliser if/else et when en tant qu'expressions

Vous avez appris à utiliser if/else et when en tant qu'instructions. Lorsque vous utilisez des instructions conditionnelles comme instructions, vous autorisez chaque branche à exécuter différentes actions dans le corps en fonction des conditions.

Vous pouvez également utiliser des instructions conditionnelles comme expressions pour renvoyer des valeurs différentes pour chaque branche de la condition. Lorsque le corps de chaque branche est similaire, vous pouvez utiliser des expressions conditionnelles pour améliorer la lisibilité du code par rapport aux instructions conditionnelles.

La syntaxe des instructions conditionnelles utilisées comme expressions est semblable à celle des instructions. Cependant, la dernière ligne des corps de chaque branche doit renvoyer une valeur ou une expression, et les instructions conditionnelles sont affectées à une variable.

Si les corps ne contiennent qu'une expression ou une valeur de retour, vous pouvez supprimer les accolades afin de rendre le code plus concis.

Dans la section suivante, vous allez examiner les expressions if/else via le programme de feu de signalisation.

Convertir une instruction if en expression

Cette instruction if/else contient de nombreuses répétitions de l'instruction println() :

fun main() {
    val trafficLightColor = "Black"

    if (trafficLightColor == "Red") {
        println("Stop")
    } else if (trafficLightColor == "Yellow") {
        println("Slow")
    } else if (trafficLightColor == "Green") {
        println("Go")
    } else {
        println("Invalid traffic-light color")
    }

}

Convertissez cette instruction if/else en expression if/else et supprimez cette répétition :

1. Dans Kotlin Playground, accédez au programme de feu de signalisation précédent.
2. Définissez une variable message, puis affectez-lui une instruction if/else :

fun main() {
    val trafficLightColor = "Black"

    val message = if (trafficLightColor == "Red") {
        println("Stop")
    } else if (trafficLightColor == "Yellow") {
        println("Slow")
    } else if (trafficLightColor == "Green") {
        println("Go")
    } else {
        println("Invalid traffic-light color")
    }

}

3. Supprimez toutes les instructions println() et leurs accolades, mais conservez les valeurs qu'elles contiennent :

fun main() {
    val trafficLightColor = "Black"

    val message =
      if (trafficLightColor == "Red") "Stop"
      else if (trafficLightColor == "Yellow") "Slow"
      else if (trafficLightColor == "Green") "Go"
      else "Invalid traffic-light color"
}

4. Ajoutez une instruction println() à la fin du programme, puis transmettez-lui la variable message en tant qu'argument :

fun main() {
    val trafficLightColor = "Black"

    val message =
      if (trafficLightColor == "Red") "Stop"
      else if (trafficLightColor == "Yellow") "Slow"
      else if (trafficLightColor == "Green") "Go"
      else "Invalid traffic-light color"

    println(message)
}

5. Exécutez ce programme, puis affichez la sortie :

Invalid traffic-light color

À vous de jouer

Convertissez le programme de feu de signalisation pour qu'il utilise une expression when au lieu d'une instruction when :

1. Dans Kotlin Playground, saisissez le code suivant :

fun main() {
    val trafficLightColor = "Amber"

    when (trafficLightColor) {
        "Red" -> println("Stop")
        "Yellow", "Amber" -> println("Slow")
        "Green" -> println("Go")
        else -> println("Invalid traffic-light color")
    }
}

Pouvez-vous convertir l'instruction when en expression afin de ne pas répéter les instructions println() ?

2. Créez une variable message et affectez-la à l'expression when :

fun main() {
    val trafficLightColor = "Amber"

    val message = when(trafficLightColor) {
        "Red" -> "Stop"
        "Yellow", "Amber" -> "Proceed with caution."
        "Green" -> "Go"
        else -> "Invalid traffic-light color"
    }
}

3. Ajoutez une instruction println() en tant que dernière ligne du programme, puis transmettez-lui la variable message en tant qu'argument :

fun main() {
    val trafficLightColor = "Amber"

    val message = when(trafficLightColor) {
        "Red" -> "Stop"
        "Yellow", "Amber" -> "Proceed with caution."
        "Green" -> "Go"
        else -> "Invalid traffic-light color"
    }
    println(message)
}

5. Conclusion

Félicitations ! Vous savez maintenant ce que sont les instructions conditionnelles et comment les écrire en langage Kotlin.

Résumé

• En langage Kotlin, un embranchement peut être réalisé avec les instructions conditionnelles if/else ou when.
• Le corps d'une branche if dans une instruction conditionnelle if/else n'est exécuté que lorsque l'expression booléenne contenue dans la condition de branche if renvoie une valeur true.
• Les branches else if suivantes d'une instruction conditionnelle if/else ne sont exécutées que lorsque les branches if ou else if précédentes renvoient des valeurs false.
• La dernière branche else d'une instruction conditionnelle if/else n'est exécutée que lorsque toutes les branches if ou else if précédentes renvoient des valeurs false.
• Il est recommandé d'utiliser l'instruction conditionnelle when au lieu de if/else lorsqu'il y a plus de deux branches.
• Vous pouvez écrire des conditions plus complexes dans des instructions conditionnelles when avec la virgule (,), des plages in et le mot clé is.
• Les instructions conditionnelles if/else et when peuvent fonctionner comme des instructions ou des expressions.

En savoir plus

• Conditions et boucles