Conditions, boucles et fonctions

Ce que tu vas apprendre

• Choisir entre plusieurs cas avec if et when.
• Répéter une action avec for et les intervalles.
• Écrire tes propres fonctions, avec des valeurs par défaut.

if : une expression

val minutes = 25
val rapide = if (minutes <= 30) "rapide" else "longue"
println("Recette $rapide")

En Kotlin, if peut produire une valeur : c'est une expression. Le résultat est rangé dans rapide.

Quand if sert de cette façon, la branche else est obligatoire. Chaque branche peut être un bloc entre accolades, et la dernière ligne du bloc donne la valeur.

when : plusieurs cas

val type = "dessert"
when (type) {
    "entree" -> println("À servir froid")
    "plat" -> println("À servir chaud")
    "dessert", "gouter" -> println("Pour la fin du repas")
    else -> println("Type inconnu")
}

when compare une valeur à chaque branche, dans l'ordre, et exécute la première qui correspond. Il remplace une longue suite de if.

On sépare plusieurs valeurs par une virgule. else couvre tous les autres cas.

Intervalles et when sans valeur

val minutes = 40
val duree = when {
    minutes < 15 -> "express"
    minutes in 15..45 -> "normale"
    else -> "longue"
}

Un intervalle s'écrit 15..45 et inclut les deux bornes. in teste l'appartenance.

Sans valeur entre parenthèses, chaque branche est une condition booléenne. Quand when donne une valeur, il doit couvrir tous les cas, d'où le else.

for : répéter

val courses = listOf("farine", "oeufs", "lait")
for (article in courses) {
    println("- $article")
}

for parcourt une liste, un tableau ou un intervalle. Ici, article prend chaque valeur à tour de rôle.

Pour compter, utilise un intervalle :

for (i in 1..3) print(i)       // 123
for (i in 1..<3) print(i)      // 12
for (i in 6 downTo 0 step 2) print(i)  // 6420

1..<3 exclut la borne de fin. downTo compte à rebours et step règle le pas.

Pour avoir la position de chaque élément :

for ((index, article) in courses.withIndex()) {
    println("$index : $article")
}

Écrire une fonction

fun total(prix: Double, quantite: Int): Double {
    return prix * quantite
}

fun main() {
    println(total(2.5, 4))   // 10.0
}

Une fonction regroupe des instructions sous un nom. Elle se déclare avec fun.

Chaque paramètre a un type, écrit après son nom. Le type retourné suit la parenthèse fermante, après :.

Une fonction qui ne renvoie rien renvoie en réalité Unit. On peut alors omettre le type et return.

fun afficherTitre(titre: String) {
    println("== $titre ==")
}

Une fonction sur une ligne

Quand le corps tient en une expression, remplace les accolades par =.

fun total(prix: Double, quantite: Int) = prix * quantite

Le type de retour est alors déduit. Avec des accolades, il faut l'écrire, sauf pour Unit.

Valeurs par défaut et arguments nommés

fun afficher(recette: String, prefixe: String = "Info") {
    println("[$prefixe] $recette")
}

fun main() {
    afficher("Quiche")                         // [Info] Quiche
    afficher(prefixe = "Nouveau", recette = "Flan")
}

Un paramètre avec une valeur par défaut peut être omis à l'appel. Un argument nommé s'écrit nom = valeur et peut venir dans n'importe quel ordre.

Sortir plus tôt avec return

fun verifier(nom: String): String {
    if (nom.isEmpty()) {
        return "Le nom est vide"
    }
    return "Recette : $nom"
}

return quitte immédiatement la fonction. Cela évite d'imbriquer les conditions les unes dans les autres.

À retenir

• if est une expression : il peut donner une valeur, avec un else obligatoire dans ce cas.
• when choisit parmi plusieurs cas, accepte des virgules, des intervalles avec in, et une forme sans valeur.
• for parcourt une liste ou un intervalle : 1..3, 1..<3, downTo, step.
• Une fonction se déclare avec fun, des paramètres typés et un type de retour après :.
• Une fonction d'une seule expression s'écrit avec =.
• Les valeurs par défaut et les arguments nommés évitent d'écrire plusieurs versions d'une même fonction.