Déclarer et appeler des fonctions simples

Introduction : le rôle central des fonctions

Au coeur de tout programme non trivial se trouvent les fonctions (parfois appelées méthodes, procédures ou sous-routines dans d'autres langages). Une fonction est un bloc de code nommé et autonome, conçu pour effectuer une tâche spécifique. L'utilisation de fonctions est fondamentale en programmation pour plusieurs raisons :

• Réutilisabilité : Au lieu de répéter le même bloc de code à plusieurs endroits, vous l'encapsulez dans une fonction et l'appelez simplement par son nom chaque fois que vous en avez besoin.
• Organisation et Modularité : Les fonctions permettent de découper un problème complexe en sous-problèmes plus petits et gérables. Chaque fonction résout une partie du problème, rendant le code global plus structuré et plus facile à comprendre.
• Lisibilité : Un nom de fonction bien choisi décrit clairement ce que fait le bloc de code, améliorant ainsi la lisibilité générale du programme.
• Maintenance : Si une logique doit être modifiée, vous ne devez la mettre à jour qu'à un seul endroit : à l'intérieur de la fonction concernée.
• Testabilité : Les fonctions individuelles peuvent être testées de manière isolée, ce qui facilite la vérification de la correction du programme.

En Kotlin, comme nous l'avons vu avec `main` et `println`, les fonctions sont des citoyens de première classe. Apprendre à définir et à utiliser vos propres fonctions est une compétence essentielle pour tout développeur Kotlin.

Syntaxe de déclaration d'une fonction

La déclaration d'une fonction en Kotlin suit une structure claire, introduite par le mot-clé `fun` :

fun nomDeLaFonction(parametre1: Type1, parametre2: Type2, ...): TypeDeRetour {
    // Corps de la fonction : instructions à exécuter
    // ...
    return valeurDeRetour // Si la fonction renvoie quelque chose
}

Décortiquons cette syntaxe :

• `fun` : Le mot-clé obligatoire qui signale le début de la déclaration d'une fonction.
• `nomDeLaFonction` : Le nom que vous donnez à votre fonction. Il doit suivre les conventions de nommage de Kotlin (généralement en `camelCase`, commençant par une minuscule). Le nom doit être descriptif de la tâche effectuée par la fonction (par exemple, `calculatePrice`, `printUserDetails`, `isValidInput`).
• `( ... )` : Les parenthèses contiennent la liste des paramètres (ou arguments) que la fonction accepte en entrée.
  • Chaque paramètre est défini par son nom suivi de deux-points (`:`) et de son type (par exemple, `name: String`, `count: Int`).
  • Les paramètres sont séparés par des virgules.
  • Si une fonction ne prend aucun paramètre, les parenthèses restent vides `()`.
• `: TypeDeRetour` : Après les parenthèses, deux-points suivis du type de la valeur que la fonction retourne (ou renvoie) après avoir terminé son exécution. Par exemple, `: Int` si elle renvoie un entier, `: String` si elle renvoie une chaîne, `: Boolean` si elle renvoie un booléen.
• `: Unit` (ou absence de type de retour) : Si une fonction n'a pas besoin de retourner une valeur significative (elle effectue juste une action, comme afficher quelque chose), son type de retour est `Unit`. `Unit` est un type spécial en Kotlin qui n'a qu'une seule valeur. Dans ce cas, vous pouvez soit écrire `: Unit` explicitement, soit omettre complètement le type de retour et les deux-points. Le compilateur comprendra qu'il s'agit d'une fonction `Unit`.
• `{ ... }` : Les accolades délimitent le corps de la fonction. C'est à l'intérieur de ce bloc que vous écrivez les instructions (le code) qui seront exécutées lorsque la fonction sera appelée.
• `return` : Le mot-clé `return` est utilisé à l'intérieur du corps pour spécifier la valeur que la fonction doit renvoyer. L'exécution de la fonction s'arrête immédiatement après une instruction `return`. Si le type de retour est `Unit`, le `return` est implicite à la fin du bloc et peut être omis (ou utilisé sans valeur : `return`).

Exemples de déclarations de fonctions

Voyons quelques exemples concrets :

// Déclaration (type de retour Unit omis)
fun printWelcomeMessage() {
    println("************************")
    println("* Bienvenue sur CertiQuizz ! *")
    println("************************")
}

// Déclaration équivalente avec Unit explicite
fun printGoodbyeMessage(): Unit {
    println("Merci de votre visite !")
}

fun greetUser(name: String) { // Prend un paramètre 'name' de type String
    println("Bonjour, $name !")
}

fun displayScore(playerName: String, score: Int) { // Prend deux paramètres
    println("Joueur: $playerName - Score: $score")
}

fun add(a: Int, b: Int): Int { // Prend deux Int, retourne un Int
    val sum = a + b
    return sum // Retourne le résultat du calcul
}

fun isEven(number: Int): Boolean { // Prend un Int, retourne un Boolean
    return number % 2 == 0 // Retourne le résultat de la comparaison
}

fun createGreeting(name: String): String { // Prend une String, retourne une String
    return "Hello, $name! Welcome!"
}

Appeler une fonction

Déclarer une fonction ne suffit pas, il faut ensuite l'appeler (ou l'invoquer) pour que le code à l'intérieur de son corps soit exécuté. Pour appeler une fonction, vous utilisez simplement son nom suivi de parenthèses `()`.

S'il la fonction attend des paramètres, vous devez fournir les valeurs correspondantes (appelées arguments) à l'intérieur des parenthèses, dans le même ordre que la déclaration des paramètres.

Si la fonction retourne une valeur, vous pouvez stocker cette valeur dans une variable (en utilisant `val` ou `var`) ou l'utiliser directement dans une autre expression (par exemple, à l'intérieur d'un `println`).

fun main() {
    // Appel de fonctions sans paramètres
    printWelcomeMessage()

    // Appel de fonctions avec arguments
    greetUser("Alice") // L'argument "Alice" est passé au paramètre 'name'
    displayScore("Bob", 150) // "Bob" -> playerName, 150 -> score

    // Appel de fonction retournant une valeur et stockage du résultat
    val result = add(5, 3)
    println("5 + 3 = $result") // Affiche: 5 + 3 = 8

    val numberToCheck = 10
    val checkEven = isEven(numberToCheck)
    println("Le nombre $numberToCheck est pair: $checkEven") // Affiche: Le nombre 10 est pair: true

    // Utilisation directe de la valeur de retour
    println(createGreeting("Charlie")) // Affiche: Hello, Charlie! Welcome!

    // Appel d'une autre fonction sans paramètres
    printGoodbyeMessage()
}

// --- Définitions des fonctions utilisées ci-dessus ---
fun printWelcomeMessage() {
    println("************************")
    println("* Bienvenue sur CertiQuizz ! *")
    println("************************")
}

fun greetUser(name: String) {
    println("Bonjour, $name !")
}

fun displayScore(playerName: String, score: Int) {
    println("Joueur: $playerName - Score: $score")
}

fun add(a: Int, b: Int): Int {
    return a + b
}

fun isEven(number: Int): Boolean {
    return number % 2 == 0
}

fun createGreeting(name: String): String {
    return "Hello, $name! Welcome!"
}

fun printGoodbyeMessage() {
    println("Merci de votre visite !")
}

Fonctions "Single-Expression"

Kotlin offre une syntaxe plus concise pour les fonctions dont le corps ne consiste qu'en une unique expression. Dans ce cas, vous pouvez omettre les accolades `{}` et le mot-clé `return`, et utiliser directement le signe `=` après la déclaration des paramètres pour indiquer l'expression dont la valeur sera retournée.

De plus, pour ces fonctions "single-expression", le type de retour peut souvent être inféré par le compilateur, vous n'avez donc pas toujours besoin de le déclarer explicitement.

// Fonction add classique
fun addVerbose(a: Int, b: Int): Int {
    return a + b
}

// Fonction add en syntaxe single-expression
fun addConcise(a: Int, b: Int): Int = a + b

// Fonction add single-expression avec inférence du type de retour (Int)
fun addInferred(a: Int, b: Int) = a + b

// Fonction isEven en single-expression (retour Boolean inféré)
fun isEvenConcise(number: Int) = number % 2 == 0

// Fonction createGreeting en single-expression (retour String inféré)
fun createGreetingConcise(name: String) = "Hello, $name! Welcome!"

fun main() {
    println(addConcise(10, 5)) // Affiche 15
    println(addInferred(20, 7)) // Affiche 27
    println(isEvenConcise(4))   // Affiche true
    println(createGreetingConcise("David")) // Affiche Hello, David! Welcome!
}

Cette syntaxe est très courante en Kotlin pour les fonctions simples et contribue à la concision du code. Utilisez-la dès que le corps de votre fonction se résume à une seule expression à retourner.

Récapitulatif : les fonctions comme blocs de construction

Les fonctions sont les blocs de construction fondamentaux de vos programmes Kotlin.

• On les déclare avec le mot-clé `fun`, suivi d'un nom, de paramètres entre parenthèses `()` (nom: Type), et éventuellement d'un type de retour `: Type`.
• Si une fonction ne retourne rien, son type est `Unit` (qui peut être omis).
• Le code de la fonction se trouve dans le corps délimité par des accolades `{}`.
• On utilise `return` pour renvoyer une valeur.
• On appelle une fonction en utilisant son nom suivi de parenthèses `()`, en passant les arguments requis.
• Les fonctions dont le corps est une seule expression peuvent utiliser la syntaxe concise avec `=`.

Maîtriser la déclaration et l'appel de fonctions simples est la première étape vers l'écriture de code Kotlin structuré, réutilisable et facile à maintenir.