Formation Kotlin pour les programmeurs 3 : Fonctions

Cet atelier de programmation fait partie du cours Kotlin Bootcamp for Programmers. Vous tirerez pleinement parti de ce cours en suivant les ateliers de programmation dans l'ordre. En fonction de vos connaissances, vous pourrez peut-être survoler certaines sections. Ce cours s'adresse aux programmeurs qui connaissent un langage orienté objet et qui souhaitent apprendre Kotlin.

Introduction

Dans cet atelier de programmation, vous allez créer un programme Kotlin et en apprendre plus sur les fonctions dans ce langage, y compris les valeurs par défaut des paramètres, les filtres, les lambdas et les fonctions compactes.

Plutôt que de créer une seule application exemple, les leçons de ce cours sont conçues pour développer vos connaissances, mais sont semi-indépendantes les unes des autres afin que vous puissiez parcourir les sections que vous connaissez. Pour les relier, de nombreux exemples utilisent un thème d'aquarium. Si vous souhaitez en savoir plus sur l'histoire de l'aquarium, consultez le cours Udacity Kotlin Bootcamp for Programmers.

Ce que vous devez déjà savoir

• Principes de base d'un langage de programmation moderne, orienté objet et à typage statique
• Programmer avec des classes, des méthodes et la gestion des exceptions dans au moins une langue
• Utiliser le REPL (Read-Eval-Print Loop) de Kotlin dans IntelliJ IDEA
• Les bases de Kotlin, y compris les types, les opérateurs et les boucles

Cet atelier de programmation s'adresse aux programmeurs qui connaissent un langage orienté objet et souhaitent en savoir plus sur Kotlin.

Points abordés

• Créer un programme avec une fonction main() et des arguments dans IntelliJ IDEA
• Utiliser les valeurs par défaut et les fonctions compactes
• Appliquer des filtres aux listes
• Créer des lambdas et des fonctions d'ordre supérieur de base

Objectifs de l'atelier

• Utilisez le REPL pour tester du code.
• Utilisez IntelliJ IDEA pour créer des programmes Kotlin de base.

Dans cette tâche, vous allez créer un programme Kotlin et découvrir la fonction main(), ainsi que la façon de transmettre des arguments à un programme à partir de la ligne de commande.

Vous vous souvenez peut-être de la fonction printHello() que vous avez saisie dans le REPL lors d'un précédent atelier de programmation :

fun printHello() {
    println ("Hello World")
}

printHello()

⇒ Hello World

Vous définissez des fonctions à l'aide du mot clé fun, suivi du nom de la fonction. Comme pour les autres langages de programmation, les parenthèses () sont utilisées pour les arguments de fonction, le cas échéant. Les accolades {} encadrent le code de la fonction. Cette fonction ne renvoie rien, il n'y a donc pas de type de retour.

Étape 1 : Créez un fichier Kotlin

1. Ouvrez IntelliJ IDEA.
2. Le volet Projet situé à gauche dans IntelliJ IDEA affiche la liste des fichiers et dossiers de votre projet. Recherchez le dossier src, puis effectuez un clic droit dessus. (Vous devriez déjà avoir le projet Hello Kotlin de l'atelier de programmation précédent.)
3. Sélectionnez New > Kotlin File/Class (Nouveau > Fichier/Classe Kotlin).
4. Laissez Type sur Fichier et nommez le fichier Hello.
5. Cliquez sur OK.

Un fichier nommé Hello.kt se trouve désormais dans le dossier src.

Étape 2 : Ajoutez du code et exécutez votre programme

1. Comme pour les autres langages, la fonction Kotlin main() spécifie le point d'entrée pour l'exécution. Tous les arguments de ligne de commande sont transmis sous forme de tableau de chaînes.
   
   Saisissez ou collez le code suivant dans le fichier Hello.kt  :

fun main(args: Array<String>) {
    println("Hello, world!")
}

Conseil : À partir de Kotlin 1.3, si votre fonction main() n'utilise aucun paramètre, vous n'avez pas besoin de définir args.

Comme votre fonction printHello() précédente, celle-ci ne comporte aucune instruction return. Chaque fonction en Kotlin renvoie quelque chose, même si rien n'est spécifié explicitement. Ainsi, une fonction comme main() renvoie un type kotlin.Unit, qui est la façon dont Kotlin indique qu'il n'y a pas de valeur.

Remarque : Lorsqu'une fonction renvoie kotlin.Unit, vous n'avez pas besoin de le spécifier explicitement. Cela diffère de certaines autres langues, où vous devez indiquer explicitement que vous ne renvoyez rien.

3. Pour exécuter votre programme, cliquez sur le triangle vert à gauche de la fonction main(). Sélectionnez Run 'HelloKt' (Exécuter "HelloKt") dans le menu.
4. IntelliJ IDEA compile le programme et l'exécute. Les résultats s'affichent dans un volet de journaux en bas de l'écran, comme illustré ci-dessous.

Programmeurs Java : si vous utilisez une version d'IntelliJ IDEA déjà installée au lieu d'installer une nouvelle copie, vous risquez de rencontrer des problèmes d'accès au compilateur Kotlin. Assurez-vous que votre projet fait référence à la bonne version du JDK. Consultez cette discussion sur Stack Overflow et la documentation sur la modification du SDK du projet pour IntelliJ IDEA.

Étape 3 : Transmettre des arguments à main()

Étant donné que vous exécutez votre programme à partir d'IntelliJ IDEA et non à partir de la ligne de commande, vous devez spécifier les arguments du programme un peu différemment.

1. Sélectionnez Exécuter > Modifier les configurations. La fenêtre Run/Debug Configurations (Configurations d'exécution/de débogage) s'ouvre.
2. Saisissez Kotlin! dans le champ Arguments du programme.
3. Cliquez sur OK.

Étape 4 : Modifiez le code pour utiliser un modèle de chaîne

Un modèle de chaîne insère une variable ou une expression dans une chaîne, et $ spécifie qu'une partie de la chaîne sera une variable ou une expression. Les accolades {} encadrent l'expression, le cas échéant.

1. Dans Hello.kt, modifiez le message d'accueil pour utiliser le premier argument transmis au programme, args[0], au lieu de "world".

fun main(args: Array<String>) {
    println("Hello, ${args[0]}")
}

2. Exécutez le programme. La sortie inclut l'argument que vous avez spécifié.

⇒ Hello, Kotlin!

Dans cette tâche, vous allez découvrir pourquoi presque tout a une valeur en Kotlin et pourquoi c'est utile.

D'autres langages comportent des instructions, qui sont des lignes de code sans valeur. En Kotlin, presque tout est une expression et a une valeur, même si cette valeur est kotlin.Unit.

1. Dans Hello.kt, écrivez du code dans main() pour attribuer un println() à une variable appelée isUnit et l'imprimer. (println() ne renvoie pas de valeur, il renvoie donc kotlin.Unit.)

// Will assign kotlin.Unit
val isUnit = println("This is an expression")
println(isUnit)

2. Exécutez votre programme. Le premier println() affiche la chaîne "This is an expression". Le deuxième println() affiche la valeur de la première instruction println(), c'est-à-dire kotlin.Unit.

⇒ This is an expression
kotlin.Unit

3. Déclarez un val appelé temperature et initialisez-le sur 10.
4. Déclarez un autre val appelé isHot et attribuez la valeur renvoyée d'une instruction if/else à isHot, comme indiqué dans le code suivant. Comme il s'agit d'une expression, vous pouvez utiliser immédiatement la valeur de l'expression if.

val temperature = 10
val isHot = if (temperature > 50) true else false
println(isHot)

⇒ false

4. Utilisez la valeur d'une expression dans un modèle de chaîne. Ajoutez du code pour vérifier la température et déterminer si un poisson est à la bonne température ou s'il fait trop chaud, puis exécutez votre programme.

val temperature = 10
val message = "The water temperature is ${ if (temperature > 50) "too warm" else "OK" }."
println(message)

⇒ The water temperature is OK.

Remarque : Les boucles font exception à la règle "tout a une valeur". Il n'existe aucune valeur pertinente pour les boucles for ou while. Elles n'ont donc pas de valeur. Si vous essayez d'attribuer la valeur d'une boucle à un élément, le compilateur génère une erreur.

Dans cette tâche, vous en apprendrez plus sur les fonctions en Kotlin et sur l'expression conditionnelle when, qui est très utile.

Étape 1 : Créez des fonctions

Dans cette étape, vous allez mettre en pratique certaines des choses que vous avez apprises et créer des fonctions avec différents types. Vous pouvez remplacer le contenu de Hello.kt par ce nouveau code.

1. Écrivez une fonction appelée feedTheFish() qui appelle randomDay() pour obtenir un jour aléatoire de la semaine. Utilisez un modèle de chaîne pour imprimer un food que le poisson mangera ce jour-là. Pour l'instant, les poissons mangent la même chose tous les jours.

fun feedTheFish() {
    val day = randomDay()
    val food = "pellets"
    println ("Today is $day and the fish eat $food")
}

fun main(args: Array<String>) {
    feedTheFish()
}

2. Écrivez la fonction randomDay() pour choisir un jour aléatoire dans un tableau et le renvoyer.

La fonction nextInt() prend une limite entière, qui limite le nombre de Random() à 0 à 6 pour correspondre au tableau week.

fun randomDay() : String {
    val week = arrayOf ("Monday", "Tuesday", "Wednesday", "Thursday",
            "Friday", "Saturday", "Sunday")
    return week[Random().nextInt(week.size)]
}

3. Les fonctions Random() et nextInt() sont définies dans java.util.*. En haut du fichier, ajoutez l'importation nécessaire :

import java.util.*    // required import

Remarque : Avant d'ajouter l'importation, Random() génère une erreur de référence non résolue dans IntelliJ IDEA. Pour ajouter l'importation automatiquement, cliquez sur Random(), puis appuyez sur Alt+Enter (Option+Enter sur Mac). Sélectionnez Import > java.util.Random.

4. Exécutez votre programme et vérifiez le résultat.

⇒ Today is Tuesday and the fish eat pellets

Étape 2 : Utilisez une expression "when"

Pour aller plus loin, modifiez le code afin de choisir différents aliments pour différents jours à l'aide d'une expression when. L'instruction when est semblable à switch dans d'autres langages de programmation, mais when s'arrête automatiquement à la fin de chaque branche. Il s'assure également que votre code couvre toutes les branches si vous vérifiez une énumération.

1. Dans Hello.kt, ajoutez une fonction appelée fishFood() qui prend un jour comme String et renvoie la nourriture du poisson pour la journée comme String. Utilisez when() pour que le poisson reçoive une nourriture spécifique chaque jour. Exécutez votre programme plusieurs fois pour voir différents résultats.

fun fishFood (day : String) : String {
    var food = ""
    when (day) {
        "Monday" -> food = "flakes"
        "Tuesday" -> food = "pellets"
        "Wednesday" -> food = "redworms"
        "Thursday" -> food = "granules"
        "Friday" -> food = "mosquitoes"
        "Saturday" -> food = "lettuce"
        "Sunday" -> food = "plankton"
    }
    return food
}

fun feedTheFish() {
    val day = randomDay()
    val food = fishFood(day)

    println ("Today is $day and the fish eat $food")
}

⇒ Today is Thursday and the fish eat granules

2. Ajoutez une branche par défaut à l'expression when à l'aide de else. Pour les tests, afin de vous assurer que la valeur par défaut est parfois prise en compte dans votre programme, supprimez les branches Tuesday et Saturday.
   
   Le fait d'avoir une branche par défaut garantit que food reçoit une valeur avant d'être renvoyé. Il n'est donc plus nécessaire de l'initialiser. Étant donné que le code attribue désormais une chaîne à food une seule fois, vous pouvez déclarer food avec val au lieu de var.

fun fishFood (day : String) : String {
    val food : String
    when (day) {
        "Monday" -> food = "flakes"
        "Wednesday" -> food = "redworms"
        "Thursday" -> food = "granules"
        "Friday" -> food = "mosquitoes"
        "Sunday" -> food = "plankton"
        else -> food = "nothing"
    }
    return food
}

3. Comme chaque expression a une valeur, vous pouvez rendre ce code un peu plus concis. Renvoyez directement la valeur de l'expression when et éliminez la variable food. La valeur de l'expression when est la valeur de la dernière expression de la branche qui a satisfait la condition.

fun fishFood (day : String) : String {
    return when (day) {
        "Monday" -> "flakes"
        "Wednesday" -> "redworms"
        "Thursday" -> "granules"
        "Friday" -> "mosquitoes"
        "Sunday" -> "plankton"
        else -> "nothing"
    }
}

La version finale de votre programme ressemble au code ci-dessous.

import java.util.*    // required import

fun randomDay() : String {
    val week = arrayOf ("Monday", "Tuesday", "Wednesday", "Thursday",
        "Friday", "Saturday", "Sunday")
    return week[Random().nextInt(week.size)]
}

fun fishFood (day : String) : String {
    return when (day) {
        "Monday" -> "flakes"
        "Wednesday" -> "redworms"
        "Thursday" -> "granules"
        "Friday" -> "mosquitoes"
        "Sunday" -> "plankton"
        else -> "nothing"
    }
}

fun feedTheFish() {
    val day = randomDay()
    val food = fishFood(day)
    println ("Today is $day and the fish eat $food")
}

fun main(args: Array<String>) {
    feedTheFish()
}

Dans cette tâche, vous allez découvrir les valeurs par défaut des fonctions et des méthodes. Vous découvrirez également les fonctions compactes, qui peuvent rendre votre code plus concis et lisible, et réduire le nombre de chemins de code à tester. Les fonctions compactes sont également appelées fonctions à expression unique.

Étape 1 : Créer une valeur par défaut pour un paramètre

En Kotlin, vous pouvez transmettre des arguments par nom de paramètre. Vous pouvez également spécifier des valeurs par défaut pour les paramètres : si un argument n'est pas fourni par l'appelant, la valeur par défaut est utilisée. Plus tard, lorsque vous écrirez des méthodes (fonctions membres), vous pourrez éviter d'écrire de nombreuses versions surchargées de la même méthode.

1. Dans Hello.kt, écrivez une fonction swim() avec un paramètre String nommé speed qui affiche la vitesse du poisson. La valeur par défaut du paramètre speed est "fast".

fun swim(speed: String = "fast") {
   println("swimming $speed")
}

2. À partir de la fonction main(), appelez la fonction swim() de trois manières différentes. Appelez d'abord la fonction en utilisant la valeur par défaut. Appelez ensuite la fonction et transmettez le paramètre speed sans nom, puis appelez la fonction en nommant le paramètre speed.

swim()   // uses default speed
swim("slow")   // positional argument
swim(speed="turtle-like")   // named parameter

⇒ swimming fast
swimming slow
swimming turtle-like

Remarque : Les arguments n'ont pas besoin d'utiliser les noms de paramètres. Vous pouvez simplement les transmettre dans l'ordre défini. Toutefois, cela peut devenir un peu déroutant avec les valeurs par défaut. Il est donc recommandé de placer les paramètres sans valeur par défaut en premier et ceux avec valeur par défaut en dernier.

Étape 2 : Ajoutez les paramètres requis

Si aucune valeur par défaut n'est spécifiée pour un paramètre, l'argument correspondant doit toujours être transmis.

1. Dans Hello.kt, écrivez une fonction shouldChangeWater() qui prend trois paramètres : day, temperature et un niveau dirty. La fonction renvoie true si l'eau doit être changée (le dimanche, si la température est trop élevée ou si l'eau est trop sale). Le jour de la semaine est obligatoire, mais la température par défaut est de 22 et le niveau de saleté par défaut est de 20.
   
   Utilisez une expression when sans argument, qui en Kotlin agit comme une série de vérifications if/else if.

fun shouldChangeWater (day: String, temperature: Int = 22, dirty: Int = 20): Boolean {
    return when {
        temperature > 30 -> true
        dirty > 30 -> true
        day == "Sunday" ->  true
        else -> false
    }
}

2. Appelez shouldChangeWater() à partir de feedTheFish() et indiquez le jour. Le paramètre day n'a pas de valeur par défaut. Vous devez donc spécifier un argument. Les deux autres paramètres de shouldChangeWater() ont des valeurs par défaut. Vous n'avez donc pas besoin de leur transmettre d'arguments.
   

fun feedTheFish() {
    val day = randomDay()
    val food = fishFood(day)
    println ("Today is $day and the fish eat $food")
    println("Change water: ${shouldChangeWater(day)}")
}

=> Today is Thursday and the fish eat granules
Change water: false

Étape 3 : Créer des fonctions compactes

L'expression when que vous avez écrite à l'étape précédente regroupe beaucoup de logique dans une petite quantité de code. Si vous souhaitez le décompresser un peu ou si les conditions à vérifier sont plus complexes, vous pouvez utiliser des variables locales bien nommées. Mais la méthode Kotlin consiste à utiliser des fonctions compactes.

Les fonctions compactes, ou fonctions à expression unique, sont un modèle courant en Kotlin. Lorsqu'une fonction renvoie les résultats d'une seule expression, vous pouvez spécifier le corps de la fonction après un symbole =, omettre les accolades {} et omettre return.

1. Dans Hello.kt, ajoutez des fonctions compactes pour tester les conditions.

fun isTooHot(temperature: Int) = temperature > 30

fun isDirty(dirty: Int) = dirty > 30

fun isSunday(day: String) = day == "Sunday"

2. Modifiez shouldChangeWater() pour appeler les nouvelles fonctions.

fun shouldChangeWater (day: String, temperature: Int = 22, dirty: Int = 20): Boolean {
    return when {
        isTooHot(temperature) -> true
        isDirty(dirty) -> true
        isSunday(day) -> true
        else  -> false
    }
}

3. Exécutez votre programme. Le résultat de println() avec shouldChangeWater() doit être le même qu'avant le passage aux fonctions compactes.

Valeurs par défaut

La valeur par défaut d'un paramètre ne doit pas nécessairement être une valeur. Il peut s'agir d'une autre fonction, comme indiqué dans l'exemple partiel suivant :

fun shouldChangeWater (day: String, temperature: Int = 22, dirty: Int = getDirtySensorReading()): Boolean {
    ...

Remarque : Une fonction utilisée comme valeur par défaut est évaluée au moment de l'exécution. N'y placez donc pas d'opération coûteuse, comme une lecture de fichier ou une allocation de mémoire importante. L'opération est exécutée chaque fois que votre fonction est appelée, ce qui peut ralentir votre programme.

Dans cette tâche, vous allez découvrir les filtres en Kotlin. Les filtres sont un moyen pratique d'obtenir une partie d'une liste en fonction d'une condition.

Étape 1 : Créez un filtre

1. Dans Hello.kt, définissez une liste de décorations d'aquarium au niveau supérieur avec listOf(). Vous pouvez remplacer le contenu de Hello.kt.

val decorations = listOf ("rock", "pagoda", "plastic plant", "alligator", "flowerpot")

2. Créez une fonction main() avec une ligne pour n'imprimer que les décorations qui commencent par la lettre "p". Le code de la condition de filtre se trouve entre accolades {}, et it fait référence à chaque élément lorsque le filtre effectue une boucle. Si l'expression renvoie true, l'élément est inclus.

fun main() {
    println( decorations.filter {it[0] == 'p'})
}

3. Exécutez votre programme. La sortie suivante s'affiche dans la fenêtre Run (Exécuter) :

⇒ [pagoda, plastic plant]

Étape 2 : Comparer les filtres eager et lazy

Si vous connaissez les filtres dans d'autres langages, vous vous demandez peut-être si les filtres en Kotlin sont eager ou lazy. La liste de résultats est-elle créée immédiatement ou lorsqu'elle est consultée ? En Kotlin, cela se produit de la manière dont vous en avez besoin. Par défaut, filter est "eager" (avide) et une liste est créée chaque fois que vous utilisez le filtre.

Pour rendre le filtre paresseux, vous pouvez utiliser un Sequence, qui est une collection qui ne peut examiner qu'un seul élément à la fois, en commençant par le début et en allant jusqu'à la fin. Par chance, il s'agit exactement de l'API dont un filtre différé a besoin.

1. Dans Hello.kt, modifiez votre code pour attribuer la liste filtrée à une variable appelée eager, puis imprimez-la.

fun main() {
    val decorations = listOf ("rock", "pagoda", "plastic plant", "alligator", "flowerpot")

    // eager, creates a new list
    val eager = decorations.filter { it [0] == 'p' }
    println("eager: " + eager)

2. Sous ce code, évaluez le filtre à l'aide d'un Sequence avec asSequence(). Attribuez la séquence à une variable appelée filtered, puis imprimez-la.

   // lazy, will wait until asked to evaluate
    val filtered = decorations.asSequence().filter { it[0] == 'p' }
    println("filtered: " + filtered)

Lorsque vous renvoyez les résultats du filtre sous la forme d'un Sequence, la variable filtered ne contient pas de nouvelle liste, mais un Sequence des éléments de la liste et des informations sur le filtre à appliquer à ces éléments. Chaque fois que vous accédez à des éléments de Sequence, le filtre est appliqué et le résultat vous est renvoyé.

3. Forcez l'évaluation de la séquence en la convertissant en List avec toList(). Imprimez le résultat.

    // force evaluation of the lazy list
    val newList = filtered.toList()
    println("new list: " + newList)

4. Exécutez votre programme et observez le résultat.

⇒ eager: [pagoda, plastic plant]
filtered: kotlin.sequences.FilteringSequence@386cc1c4
new list: [pagoda, plastic plant]

Pour visualiser ce qui se passe avec Sequence et l'évaluation différée, utilisez la fonction map(). La fonction map() effectue une transformation simple sur chaque élément de la séquence.

5. Avec la même liste decorations que ci-dessus, effectuez une transformation avec map() qui ne fait rien et renvoie simplement l'élément qui a été transmis. Ajoutez un println() pour afficher chaque fois qu'un élément est consulté, et attribuez la séquence à une variable appelée lazyMap.

    val lazyMap = decorations.asSequence().map {
        println("access: $it")
        it
    }

6. Imprimez lazyMap, imprimez le premier élément de lazyMap à l'aide de first() et imprimez lazyMap converti en List.

    println("lazy: $lazyMap")
    println("-----")
    println("first: ${lazyMap.first()}")
    println("-----")
    println("all: ${lazyMap.toList()}")

7. Exécutez votre programme et observez le résultat. L'impression de lazyMap n'imprime qu'une référence à Sequence. Le println() interne n'est pas appelé. L'impression du premier élément n'accède qu'au premier élément. La conversion de Sequence en List permet d'accéder à tous les éléments.

⇒ lazy: kotlin.sequences.TransformingSequence@5ba23b66
-----
access: rock
first: rock
-----
access: rock
access: pagoda
access: plastic plant
access: alligator
access: flowerpot
all: [rock, pagoda, plastic plant, alligator, flowerpot]

8. Créez un Sequence à l'aide du filtre d'origine avant d'appliquer map. Imprimez ce résultat.

    val lazyMap2 = decorations.asSequence().filter {it[0] == 'p'}.map {
        println("access: $it")
        it
    }
    println("-----")
    println("filtered: ${ lazyMap2.toList() }")

9. Exécutez votre programme et observez les résultats supplémentaires. Comme pour l'obtention du premier élément, le println() interne n'est appelé que pour les éléments auxquels on accède.

⇒
-----
access: pagoda
access: plastic plant
filtered: [pagoda, plastic plant]

Dans cette tâche, vous allez découvrir les lambdas et les fonctions d'ordre supérieur en Kotlin.

Lambdas

En plus des fonctions nommées traditionnelles, Kotlin est compatible avec les lambdas. Un lambda est une expression qui crée une fonction. mais au lieu de déclarer une fonction nommée, vous déclarez une fonction sans nom. L'un des avantages de cette approche est que l'expression lambda peut désormais être transmise en tant que données. Dans d'autres langages, les lambdas sont appelés fonctions anonymes, littéraux de fonction ou des noms similaires.

Fonctions d'ordre supérieur

Vous pouvez créer une fonction d'ordre supérieur en transmettant un lambda à une autre fonction. Dans la tâche précédente, vous avez créé une fonction d'ordre supérieur appelée filter. Vous avez transmis l'expression lambda suivante à filter comme condition à vérifier :
{it[0] == 'p'}

De même, map est une fonction d'ordre supérieur, et le lambda que vous lui avez transmis était la transformation à appliquer.

Étape 1 : En savoir plus sur les lambdas

1. Comme les fonctions nommées, les lambdas peuvent avoir des paramètres. Pour les lambdas, les paramètres (et leurs types, si nécessaire) se trouvent à gauche de ce qu'on appelle une flèche de fonction ->. Le code à exécuter se trouve à droite de la flèche de la fonction. Une fois le lambda attribué à une variable, vous pouvez l'appeler comme une fonction.
   
   À l'aide du REPL (Outils > Kotlin > Kotlin REPL), essayez ce code :

var dirtyLevel = 20
val waterFilter = { dirty : Int -> dirty / 2}
println(waterFilter(dirtyLevel))

⇒ 10

Dans cet exemple, le lambda prend un Int nommé dirty et renvoie dirty / 2. (car la filtration élimine les impuretés).

2. La syntaxe Kotlin pour les types de fonction est étroitement liée à sa syntaxe pour les lambdas. Utilisez cette syntaxe pour déclarer clairement une variable contenant une fonction :

val waterFilter: (Int) -> Int = { dirty -> dirty / 2 }

Voici ce que dit le code :

• Créez une variable appelée waterFilter.
• waterFilter peut être n'importe quelle fonction qui accepte un Int et renvoie un Int.
• Attribuez un lambda à waterFilter.
• Le lambda renvoie la valeur de l'argument dirty divisée par 2.

Notez que vous n'avez plus besoin de spécifier le type de l'argument lambda. Le type est calculé par inférence de type.

Étape 2 : Créez une fonction d'ordre supérieur

Jusqu'à présent, les exemples de lambdas ressemblent surtout à des fonctions. La véritable puissance des lambdas réside dans leur utilisation pour créer des fonctions d'ordre supérieur, où l'argument d'une fonction est une autre fonction.

1. Écrivez une fonction d'ordre supérieur. Voici un exemple de base, une fonction qui prend deux arguments. Le premier argument est un entier. Le deuxième argument est une fonction qui accepte un entier et en renvoie un autre. Essayez-le dans le REPL.

fun updateDirty(dirty: Int, operation: (Int) -> Int): Int {
   return operation(dirty)
}

Le corps du code appelle la fonction qui a été transmise en tant que deuxième argument et lui transmet le premier argument.

2. Pour appeler cette fonction, transmettez-lui un entier et une fonction.

val waterFilter: (Int) -> Int = { dirty -> dirty / 2 }
println(updateDirty(30, waterFilter))

⇒ 15

La fonction que vous transmettez ne doit pas nécessairement être un lambda. Il peut s'agir d'une fonction nommée standard. Pour spécifier l'argument en tant que fonction régulière, utilisez l'opérateur ::. Kotlin sait ainsi que vous transmettez la référence de la fonction en tant qu'argument et que vous n'essayez pas d'appeler la fonction.

3. Essayez de transmettre une fonction nommée standard à updateDirty().

fun increaseDirty( start: Int ) = start + 1

println(updateDirty(15, ::increaseDirty))

⇒ 16

Remarque : Kotlin préfère que tout paramètre qui accepte une fonction soit le dernier paramètre. Lorsque vous travaillez avec des fonctions d'ordre supérieur, Kotlin dispose d'une syntaxe spéciale, appelée syntaxe d'appel du dernier paramètre, qui vous permet de rendre le code encore plus concis. Dans ce cas, vous pouvez transmettre un lambda pour le paramètre de fonction, mais vous n'avez pas besoin de le placer entre parenthèses.

var dirtyLevel = 19;
dirtyLevel = updateDirty(dirtyLevel) { dirtyLevel -> dirtyLevel + 23}
println(dirtyLevel)

⇒ 42

• Pour créer un fichier source Kotlin dans IntelliJ IDEA, commencez par un projet Kotlin.
• Pour compiler et exécuter un programme dans IntelliJ IDEA, cliquez sur le triangle vert à côté de la fonction main(). Le résultat s'affiche dans une fenêtre de journal ci-dessous.
• Dans IntelliJ IDEA, spécifiez les arguments de ligne de commande à transmettre à la fonction main() dans Run > Edit Configurations (Exécuter > Modifier les configurations).
• Presque tout a une valeur en Kotlin. Vous pouvez utiliser ce fait pour rendre votre code plus concis en utilisant la valeur d'un if ou d'un when comme expression ou valeur de retour.
• Les arguments par défaut évitent d'avoir plusieurs versions d'une fonction ou d'une méthode. Exemples :
  fun swim(speed: String = "fast") { ... }
• Les fonctions compactes, ou fonctions à expression unique, peuvent rendre votre code plus lisible. Exemples :
  fun isTooHot(temperature: Int) = temperature > 30
• Vous avez appris les bases des filtres, qui utilisent des expressions lambda. Exemples :
  val beginsWithP = decorations.filter { it [0] == 'p' }
• Une expression lambda est une expression qui crée une fonction sans nom. Les expressions lambda sont définies entre accolades {}.
• Dans une fonction d'ordre supérieur, vous transmettez une fonction telle qu'une expression lambda à une autre fonction en tant que données. Par exemple :
  dirtyLevel = updateDirty(dirtyLevel) { dirtyLevel -> dirtyLevel + 23}

Cette leçon est riche en contenu, surtout si vous débutez avec les expressions lambda. Une leçon ultérieure reviendra sur les lambdas et les fonctions d'ordre supérieur.

Remarque  : Vous avez peut-être remarqué qu'en Kotlin, comme dans d'autres langages, il existe plusieurs façons de faire les choses. Rendre le code plus compact peut parfois améliorer la lisibilité et même les performances, mais pas toujours. À mesure que vous en apprendrez davantage sur Kotlin, vous trouverez peut-être des moyens plus simples et plus concis de faire les choses.

Documentation Kotlin

Si vous souhaitez en savoir plus sur un sujet abordé dans ce cours ou si vous êtes bloqué, https://kotlinlang.org est le meilleur point de départ.

• Conventions de codage Kotlin
• Idiomes Kotlin

• Modèles de chaîne
• Expression when
• Fonctions à expression unique
• Fonctions d'ordre supérieur et lambdas
• Filtres
• Séquences
• Syntaxe du dernier appel de paramètre

Tutoriels Kotlin

Le site Web https://try.kotlinlang.org inclut des tutoriels complets appelés Kotlin Koans, un interpréteur Web et un ensemble complet de documentation de référence avec des exemples.

Cours Udacity

Pour consulter le cours Udacity sur ce sujet, reportez-vous à la formation Kotlin pour les programmeurs.

IntelliJ IDEA

La documentation d'IntelliJ IDEA est disponible sur le site Web de JetBrains.

Cette section répertorie les devoirs possibles pour les élèves qui suivent cet atelier de programmation dans le cadre d'un cours animé par un enseignant. Il revient à l'enseignant d'effectuer les opérations suivantes :

• Attribuer des devoirs si nécessaire
• Indiquer aux élèves comment rendre leurs devoirs
• Noter les devoirs

Les enseignants peuvent utiliser ces suggestions autant qu'ils le souhaitent, et ne doivent pas hésiter à attribuer d'autres devoirs aux élèves s'ils le jugent nécessaire.

Si vous suivez cet atelier de programmation par vous-même, n'hésitez pas à utiliser ces devoirs pour tester vos connaissances.

Répondre aux questions suivantes

Question 1

La fonction contains(element: String) renvoie true si la chaîne element est contenue dans la chaîne sur laquelle elle est appelée. Quel sera le résultat du code suivant ?

val decorations = listOf ("rock", "pagoda", "plastic plant", "alligator", "flowerpot")

println(decorations.filter {it.contains('p')})

▢ [pagoda, plastic, plant]

▢ [pagoda, plastic plant]

▢ [pagoda, plastic plant, flowerpot]

▢ [rock, alligator]

Question 2

Dans la définition de fonction suivante, lequel des paramètres est obligatoire ?
fun shouldChangeWater (day: String, temperature: Int = 22, dirty: Int = 20, numDecorations: Int = 0): Boolean {...}

▢ numDecorations

▢ dirty

▢ day

▢ temperature

Question 3

Vous pouvez transmettre une fonction nommée standard (et non le résultat de son appel) à une autre fonction. Comment transmettez-vous increaseDirty( start: Int ) = start + 1 à updateDirty(dirty: Int, operation: (Int) -> Int) ?

▢ updateDirty(15, &increaseDirty())

▢ updateDirty(15, increaseDirty())

▢ updateDirty(15, ("increaseDirty()"))

▢ updateDirty(15, ::increaseDirty)

Passez à la leçon suivante : 4. Classes et objets

Pour obtenir un aperçu du cours, y compris des liens vers d'autres ateliers de programmation, consultez Formation Kotlin pour les programmeurs : bienvenue dans le cours.