Conditions avec `if`/`else` (et son usage comme expression)

Introduction : prendre des décisions dans le code

L'une des capacités les plus fondamentales d'un programme informatique est de pouvoir prendre des décisions : exécuter certaines actions uniquement si une condition spécifique est remplie, ou choisir entre différents chemins d'exécution en fonction de l'état actuel. La structure de contrôle la plus élémentaire et la plus universelle pour réaliser cela est l'instruction `if`, souvent accompagnée de son acolyte `else`.

En Kotlin, `if` permet d'évaluer une condition (une expression qui résulte en une valeur `Boolean` : `true` ou `false`). Si la condition est `true`, un bloc de code associé est exécuté. Si elle est `false`, ce bloc est ignoré. L'ajout de `else` permet de spécifier un autre bloc de code à exécuter lorsque la condition initiale est `false`.

Une particularité intéressante et très utilisée en Kotlin est que `if`/`else` n'est pas seulement une instruction (qui effectue une action), mais peut aussi être utilisée comme une expression (qui produit une valeur). Cela permet d'écrire du code conditionnel de manière plus concise et fonctionnelle.

La structure `if` simple

La forme la plus basique est l'instruction `if` seule. Elle exécute un bloc de code si et seulement si la condition entre parenthèses est évaluée à `true`.

Syntaxe :

if (condition) {
    // Bloc de code à exécuter si la condition est true
}

La `condition` doit être une expression qui retourne une valeur `Boolean`.

fun main() {
    val temperature = 25
    val isSunny = true

    if (temperature > 20) {
        println("Il fait chaud !") // Sera affiché car 25 > 20 est true
    }

    if (isSunny) {
        println("Le soleil brille.") // Sera affiché car isSunny est true
    }

    if (temperature < 0) {
        println("Il gèle !") // Ne sera pas affiché car 25 < 0 est false
    }

    println("Fin du programme météo.")
}

Si le bloc de code à exécuter ne contient qu'une seule instruction, les accolades `{}` sont techniquement optionnelles, mais il est fortement recommandé de toujours les utiliser pour la clarté et pour éviter des erreurs si vous ajoutez des instructions plus tard.

Ajouter une alternative : `if`/`else`

Souvent, vous voulez exécuter un certain code si la condition est vraie, et un *autre* code si elle est fausse. C'est là qu'intervient le mot-clé `else`.

Syntaxe :

if (condition) {
    // Bloc A : exécuté si condition est true
} else {
    // Bloc B : exécuté si condition est false
}

Le programme exécutera soit le Bloc A, soit le Bloc B, mais jamais les deux.

fun main() {
    val userAge = 17
    val accessGranted: Boolean

    if (userAge >= 18) {
        println("Accès autorisé.")
        accessGranted = true
    } else {
        println("Accès refusé (trop jeune).")
        accessGranted = false
    }

    println("Vérification terminée. Accès accordé: $accessGranted")
}

Dans cet exemple, comme `userAge` (17) n'est pas supérieur ou égal à 18, la condition est `false`, et c'est le bloc `else` qui est exécuté.

Chaîner les conditions : `if`/`else if`/`else`

Vous pouvez avoir besoin de tester plusieurs conditions mutuellement exclusives. Au lieu d'imbriquer des `if`/`else`, vous pouvez utiliser la structure `else if` pour enchaîner les tests.

Syntaxe :

if (condition1) {
    // Bloc 1 : exécuté si condition1 est true
} else if (condition2) {
    // Bloc 2 : exécuté si condition1 est false ET condition2 est true
} else if (condition3) {
    // Bloc 3 : exécuté si condition1 et condition2 sont false ET condition3 est true
} else {
    // Bloc final (optionnel) : exécuté si toutes les conditions précédentes sont false
}

Dès qu'une condition (`if` ou `else if`) est trouvée `true`, son bloc est exécuté et le reste de la chaîne est ignoré.

fun main() {
    val score = 75
    val grade: Char

    if (score >= 90) {
        grade = 'A'
    } else if (score >= 80) {
        grade = 'B'
    } else if (score >= 70) {
        grade = 'C' // Cette condition est true (75 >= 70)
    } else if (score >= 60) {
        grade = 'D'
    } else {
        grade = 'F'
    }

    println("Votre note est: $grade") // Affiche: Votre note est: C
}

Même si `75 >= 60` est aussi vrai, cette condition n'est jamais testée car la condition précédente (`score >= 70`) était déjà vraie.

`if` utilisé comme une Expression

C'est ici que Kotlin apporte une touche élégante. Au lieu d'utiliser `if`/`else` comme une instruction pour *modifier* une variable (comme `accessGranted` ou `grade` dans les exemples précédents), vous pouvez l'utiliser directement comme une expression qui *produit* une valeur. Le résultat de l'expression `if` est la valeur de la dernière expression dans le bloc qui a été exécuté.

Syntaxe :

val resultat = if (condition) {
    // ... éventuellement d'autres instructions ...
    valeurSiTrue // Dernière expression du bloc if
} else {
    // ... éventuellement d'autres instructions ...
    valeurSiFalse // Dernière expression du bloc else
}

Reprenons nos exemples précédents en utilisant `if` comme expression :

fun main() {
    // Exemple de l'âge
    val userAge = 17
    val accessMessage = if (userAge >= 18) {
        "Accès autorisé."
    } else {
        "Accès refusé (trop jeune)."
    }
    println(accessMessage) // Affiche: Accès refusé (trop jeune).

    // Exemple de la note (grade)
    val score = 75
    val grade = if (score >= 90) {
        'A'
    } else if (score >= 80) {
        'B'
    } else if (score >= 70) {
        'C'
    } else if (score >= 60) {
        'D'
    } else {
        'F'
    }
    println("Votre note est: $grade") // Affiche: Votre note est: C

    // Peut être utilisé directement dans d'autres expressions
    val number = -5
    println("Le nombre $number est ${if (number >= 0) "positif ou nul" else "négatif"}.")
    // Affiche: Le nombre -5 est négatif.
}

Notez comme le code devient plus concis et déclaratif. Au lieu de dire "si telle condition, *alors fais ça* pour modifier la variable", on dit "la variable *est égale à* ce que l'expression if/else retourne". C'est souvent considéré comme un style plus idiomatique et plus sûr en Kotlin, car cela encourage l'utilisation de `val` (variables immuables).

Conditions courantes et opérateurs logiques

Les conditions utilisées dans les `if` sont typiquement construites à l'aide de :

• Opérateurs de comparaison : `==` (égal à), `!=` (différent de), `>` (supérieur à), `<` (inférieur à), `>=` (supérieur ou égal à), `<=` (inférieur ou égal à).
• Variables booléennes : Directement `if (isLoggedIn)` ou `if (!hasErrors)`.
• Appels de fonction retournant `Boolean` : `if (isValid(userInput))`.
• Opérateurs logiques :
  • `&&` (ET logique) : `true` seulement si les deux opérandes sont `true`.
  • `||` (OU logique) : `true` si au moins un des opérandes est `true`.
  • `!` (NON logique) : Inverse la valeur booléenne (`!true` est `false`, `!false` est `true`).

fun main() {
    val age = 25
    val hasLicense = true

    if (age >= 18 && hasLicense) { // Doit avoir 18 ans ET avoir le permis
        println("Peut conduire.")
    } else {
        println("Ne peut pas conduire.")
    }

    val isAdmin = false
    val isEditor = true

    if (isAdmin || isEditor) { // Doit être admin OU éditeur
        println("A des droits de modification.")
    } else {
        println("N'a que des droits de lecture.")
    }
}

Récapitulatif : `if`/`else` pour la logique conditionnelle

La structure `if`/`else` est le pilier de la logique conditionnelle en Kotlin.

• Utilisez `if (condition) { ... }` pour exécuter du code si la condition est vraie.
• Ajoutez `else { ... }` pour un bloc alternatif si la condition est fausse.
• Enchaînez avec `else if (condition) { ... }` pour tester plusieurs conditions.
• Kotlin permet d'utiliser `if`/`else` comme une expression qui retourne une valeur, rendant le code plus concis et favorisant l'immutabilité. Dans ce cas, la branche `else` est obligatoire.

Maîtriser `if`/`else` sous ses deux formes (instruction et expression) est fondamental pour écrire des programmes Kotlin capables de s'adapter et de réagir aux différentes situations.