Kotlin Bootcamp for Programmers 3 : Functions (Formation Kotlin pour les programmeurs 3 : Fonctions)

Cet atelier de programmation fait partie du cours Kotlin Bootcamp for Programmers (Formation Kotlin pour les programmeurs). Vous tirerez le meilleur parti de ce cours si vous suivez les ateliers de programmation dans l'ordre. En fonction de vos connaissances, vous pouvez parcourir certaines sections. Ce cours s'adresse aux programmeurs qui connaissent un langage orienté objet et souhaitent apprendre l'Kotlin.

Présentation

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

Plutôt que de créer un exemple d'application, les leçons de ce cours sont conçues pour développer vos connaissances, mais elles ne doivent pas être indépendantes les unes des autres pour vous permettre de parcourir les sections que vous connaissez déjà. Pour les assembler, de nombreux exemples utilisent un thème d'aquarium. Et si vous voulez voir l'histoire complète de l'aquarium, consultez le cours Udacity Kotlin Bootcamp for Programmers.

Ce que vous devez déjà savoir

• Les bases d'un langage de programmation moderne, orienté de façon statique et orientée objet
• Programmer avec des classes, des méthodes et une gestion des exceptions dans au moins une langue
• Utiliser la boucle REPL (Read-Eval-Print Loop) dans IntelliJ IDEA
• Principes de base du langage 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 et des arguments main() dans IntelliJ IDEA
• Utiliser les valeurs par défaut et les fonctions compactes
• Appliquer des filtres pour les listes
• Créer des lambdas de base et des fonctions plus avancées

Objectifs de l'atelier

• Utilisez le protocole REPL pour tester du code.
• Créez des programmes Kotlin de base avec IntelliJ IDEA.

Dans cette tâche, vous allez créer un programme Kotlin, découvrir la fonction main() et apprendre à 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 dans un atelier de programmation précédent:

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

printHello()

⇒ Hello World

Vous définissez des fonctions à l'aide du mot clé fun, suivi de leur nom. Comme pour les autres langages de programmation, les parenthèses () sont utilisées pour les arguments de fonction, le cas échéant. Des accolades {} encadrent le code de la fonction. Aucun type de retour n'est associé à cette fonction, car elle ne renvoie aucun résultat.

Étape 1: Créer un fichier Kotlin

1. Ouvrez IntelliJ IDEA.
2. Le volet Project (Projet) situé à gauche dans IntelliJ IDEA affiche la liste des fichiers et dossiers de votre projet. Recherchez le dossier src, puis cliquez dessus avec le bouton droit sous Hello Kotlin. (Vous devez 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. Conservez l'option File (Type) et File (Nom), puis nommez le fichier Hello.
5. Cliquez sur OK.

Le dossier src contient désormais un fichier nommé Hello.kt.

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

1. Comme d'autres langages, la fonction main() Kotlin spécifie le point d'entrée à l'exécution. Tous les arguments de ligne de commande sont transmis sous la forme d'un 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.

Tout comme votre précédente fonction printHello(), cette fonction ne comporte aucune instruction return. Chaque fonction de Kotlin renvoie un élément, même si rien n'est explicitement spécifié. Ainsi, une fonction comme cette main()renvoie un type kotlin.Unit, ce qui correspond à la méthode Kotlin's moyen de dire qu'il n'y a aucune valeur.

Remarque:Lorsqu'une fonction renvoie kotlin.Unit, vous n'avez pas besoin de l'indiquer explicitement. Cette règle est différente des autres langues, où vous devez explicitement indiquer que vous ne retournez rien.

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

Programmeurs Java:si vous utilisez une version précédemment installée d'IntelliJ IDEA au lieu d'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 le changement de SDK de projet pour IntelliJ IDEA.

Étape 3: Transmettez les arguments à main()

Comme vous exécutez votre programme à partir d'IntelliJ IDEA et non à partir de la ligne de commande, vous devez spécifier des arguments pour le programme un peu différemment.

1. Sélectionnez Run > Modifier les configurations. La fenêtre Run/Debug Configurations (Configurations d'exécution/de débogage) s'ouvre.
2. Saisissez Kotlin! dans le champ Program arguments (Arguments de 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, tandis que $ spécifie qu'une partie de la chaîne est une variable ou une expression. Des accolades dans {} encadrent l'expression, le cas échéant.

1. Dans Hello.kt, remplacez le message de bienvenue par 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, et le résultat inclut l'argument que vous avez spécifié.

⇒ Hello, Kotlin!

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

D'autres langues comportent des instructions. Il s'agit de lignes de code qui n'ont pas de valeur. En langage Kotlin, pratiquement tout est une expression et possède une valeur, même si cette valeur est de type kotlin.Unit.

1. Dans Hello.kt, écrivez le code de main() pour attribuer une println() à une variable appelée isUnit, puis imprimez-la. (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 élément println() imprime la chaîne "This is an expression". La seconde println() affiche la valeur de la première instruction println(), c'est-à-dire kotlin.Unit.

⇒ This is an expression
kotlin.Unit

3. Déclarez une val appelée temperature et initialisez-la dans 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 immédiatement utiliser la valeur de l'expression if.

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

⇒ false

4. Utiliser la valeur d'une expression dans un modèle de chaîne. Ajoutez du code pour vérifier la température afin de déterminer si un poisson est sûr ou 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 sont des exceptions à "tous les éléments ont une valeur". Il n'existe pas de valeur sensible pour for boucles ou while boucles. Elles n'ont donc pas de valeurs. Si vous essayez d'attribuer une valeur de boucle à un élément, le compilateur génère une erreur.

Dans cette tâche, vous allez en apprendre davantage sur les fonctions en langage Kotlin et sur l'expression conditionnelle when très utile.

Étape 1: Créer des fonctions

Au cours de cette étape, vous allez rassembler une sélection de ce que vous avez appris et créé avec des types de fonctions différents. Vous pouvez remplacer le contenu du fichier Hello.kt par ce nouveau code.

1. Écrivez une fonction appelée feedTheFish() qui appelle randomDay() pour obtenir un jour de la semaine aléatoire. Utilisez un modèle de chaîne pour imprimer un food correspondant au poisson à consommer ce jour-là. Pour l'instant, les poissons se servent des mêmes aliments 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 d'un tableau et l'afficher.

La fonction nextInt() utilise 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 requise:

import java.util.*    // required import

Conseil:Avant d'ajouter l'importation, Random() renvoie une erreur de référence non résolue dans IntelliJ IDEA. Pour ajouter automatiquement l'importation, cliquez sur Random(), puis 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 pour 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 casse automatiquement à la fin de chaque branche. Si vous consultez une énumération, elle vérifie également que votre code couvre toutes les branches.

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

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. À des fins de test, pour vous assurer que la branche par défaut est parfois utilisée dans votre programme, supprimez les branches Tuesday et Saturday.
   
   Une branche par défaut garantit que food obtient une valeur avant de le renvoyer et n'a donc pas besoin d'être initialisé. Comme 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. Toutes les expressions ayant une valeur, vous pouvez rendre ce code un peu plus concis. Renvoyez directement la valeur de l'expression when, puis supprimez la variable food. La valeur de l'expression when correspond à la valeur de la dernière expression de la branche qui remplit 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 aussi les fonctions compactes, qui permettent de rendre votre code plus concis et lisible, et de réduire le nombre de chemins de code à tester. Les fonctions compactes sont également appelées fonctions à expression unique.

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

En langage Kotlin, vous pouvez transmettre des arguments par nom de paramètre. Vous pouvez également définir les valeurs par défaut des paramètres: si un argument n'est pas fourni par l'appelant, la valeur par défaut est utilisée. Par la suite, lorsque vous écrivez des méthodes (fonctions des membres), vous éviterez d'écrire de nombreuses surcharges de la même méthode.

1. Dans Hello.kt, écrivez une fonction swim() dont le paramètre String est nommé speed et 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. Depuis la fonction main(), appelez la fonction swim() de trois manières. Commencez par appeler la fonction à l'aide de 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 des paramètres. Vous pouvez simplement les transmettre dans l'ordre défini. Cependant, avec des valeurs par défaut, cela peut être un peu déroutant. Il est donc préférable de placer d'abord les paramètres par défaut, puis ceux avec des valeurs par défaut.

Étape 2: Ajoutez les paramètres requis

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

1. Dans Hello.kt, écrivez une fonction shouldChangeWater() qui comporte trois paramètres : day, temperature et un niveau dirty. La fonction renvoie true si le niveau d'eau doit être modifié, ce qui se produit si le dimanche est trop long, 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 fait office de série de vérifications if/else if en langage Kotlin.

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() depuis 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() ayant des valeurs par défaut, vous n'avez 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éez des fonctions compactes

L'expression when que vous avez rédigée à l'étape précédente contient beaucoup de logique dans une petite quantité de code. Si vous souhaitez décompresser quelque chose ou si les conditions à vérifier étaient plus complexes, vous pourriez utiliser des variables locales correctement nommées. Mais Kotlin peut le faire avec des fonctions compactes.

Les fonctions compactes, ou fonctions à expression unique, sont un modèle courant dans 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 semblable à ce qu'il était avant de passer à des fonctions compactes.

Valeurs par défaut

La valeur par défaut d'un paramètre ne doit pas être une valeur. Il peut s'agir d'une autre fonction, comme illustré 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. Par conséquent, n'appliquez pas d'opération coûteuse telle qu'une lecture de fichier ou une allocation de mémoire importante dans la fonction. L'opération est exécutée chaque fois que la fonction est appelée, ce qui peut ralentir votre programme.

Dans cette tâche, vous allez en apprendre davantage sur les filtres en langage Kotlin. Les filtres sont un moyen pratique de faire partie d'une liste en fonction d'une certaine condition.

Étape 1: Création d'un filtre

1. Dans Hello.kt, définissez une liste des décorations d'aquarium au premier niveau avec listOf(). Vous pouvez remplacer le contenu du fichier Hello.kt.

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

2. Créez une fonction main() avec une ligne pour imprimer uniquement les décorations commençant par la lettre 'p'. Le code de la condition de filtre est entouré d'accolades {}, et it fait référence à chaque élément lorsque le filtre est lu en 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: Comparez les filtres chargés et différés

Si vous connaissez les filtres dans d'autres langues, vous vous demandez peut-être si vous utilisez des filtres Kotlin ou différés. Est-ce que la liste des résultats est créée immédiatement ou lorsqu'on y accède ? En langage Kotlin, cela se produit comme vous le souhaitez. Par défaut, filter souhaite accéder à une liste, et une liste est créée chaque fois que vous utilisez ce filtre.

Pour rendre le filtre différé, vous pouvez utiliser un Sequence, une collection qui ne peut examiner qu'un élément à la fois, du début à la fin et de la fin. Heureusement, 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 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 en tant que Sequence, la variable filtered ne contient pas de nouvelle liste. Elle contient Sequence des éléments de la liste, ainsi que les connaissances du 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 l'outil 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() sans aucun effet, puis renvoie simplement l'élément qui a été transmis. Ajoutez un println() pour chaque affichage, 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 avec first() et imprimez le 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. Le fait d'imprimer lazyMap renvoie simplement une référence à la Sequence. Le println() interne n'est pas appelé. L'impression du premier élément permet d'accéder uniquement au premier d'entre eux. Convertir la 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 le résultat supplémentaire. Comme pour l'obtention du premier élément, la propriété println() interne n'est appelée que pour les éléments auxquels vous accédez.

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

Dans cette tâche, vous allez découvrir les fonctions lambda et plus avancées en langage Kotlin.

Lambda

En plus des fonctions traditionnelles nommées, Kotlin accepte les lambdas. Un lambda est une expression qui crée une fonction. Toutefois, au lieu de déclarer une fonction nommée, vous la déclarez sans nom. Cette fonctionnalité est en partie utile lorsque l'expression lambda peut maintenant être transmise en tant que données. Dans d'autres langues, les lambdas sont appelés fonctions anonymes, littéraux de fonction ou noms similaires.

Fonctions d'ordre supérieur

Vous pouvez créer une fonction de niveau supérieur en transmettant un lambda à une autre. Dans la tâche précédente, vous avez créé une fonction de niveau 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 de niveau supérieur, et le lambda que vous lui avez transmis est la transformation à appliquer.

Étape 1: Connaître 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 que l'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 (Tools > Kotlin > Kotlin REPL), exécutez le code suivant:

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. (Le filtre permet d'éliminer les saletés.)

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

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

Voici le contenu du code:

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

Notez qu'il n'est plus nécessaire de spécifier le type d'argument lambda. Le type est calculé par inférence de type.

Étape 2: Créez un ordre plus élevé

Jusqu'à présent, les exemples pour les lambdas ressemblent principalement à des fonctions. Le pouvoir réel des lambdas les utilise pour créer des fonctions par ordre plus élevé, où l'argument d'une fonction est une autre fonction.

1. Écrivez une fonction de niveau supérieur. Voici un exemple de base comportant deux arguments. Le premier argument est un entier. Le deuxième argument est une fonction qui prend un entier et renvoie un entier. Essayez-le dans le REPL.

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

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

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

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

⇒ 15

La fonction que vous transmettez n'a pas besoin d'être un lambda. Il peut s'agir d'une fonction nommée standard. Pour spécifier l'argument en tant que fonction standard, utilisez l'opérateur ::. De cette façon, Kotlin sait que vous transmettez la référence de fonction en tant qu'argument, et 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 compatible avec une fonction est le dernier paramètre. Lors de l'utilisation de fonctions plus avancées, Kotlin utilise une syntaxe spéciale appelée syntaxe du dernier appel de 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 apparaît 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 > Modifier les configurations.
• Presque tout présente en Kotlin a une valeur. Vous pouvez utiliser ce fait pour rendre votre code plus concis. Pour cela, utilisez la valeur d'un if ou d'un when comme expression ou valeur de retour.
• Avec les arguments par défaut, il n'est plus nécessaire de créer plusieurs versions d'une fonction ou d'une méthode. Exemples :
  fun swim(speed: String = "fast") { ... }
• Les fonctions compactes ou les expressions uniques peuvent rendre votre code plus lisible. Exemples :
  fun isTooHot(temperature: Int) = temperature > 30
• Vous avez appris quelques notions de base sur les 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 les accolades {}.
• Dans une fonction de niveau supérieur, vous transmettez en tant que données une fonction telle qu'une expression lambda. Exemple:
  dirtyLevel = updateDirty(dirtyLevel) { dirtyLevel -> dirtyLevel + 23}

Cette leçon contient beaucoup de choses, en particulier si vous découvrez les lambdas. La leçon suivante aborde les lambdas et les fonctions plus avancées.

Remarque: Vous avez peut-être remarqué qu'il existe plusieurs façons de procéder dans Kotlin, comme dans d'autres langues. Un code plus compact contribue parfois à la lisibilité et même aux performances, et parfois non. À mesure que vous en saurez plus sur Kotlin, vous trouverez peut-être des moyens plus simples et plus concis d'effectuer certaines actions.

Documentation Kotlin

Si vous souhaitez en savoir plus sur un sujet de ce cours ou si vous rencontrez des difficultés, https://kotlinlang.org constitue le meilleur point de départ.

• Conventions de codage Kotlin
• Idiomes Kotlin

• Modèles de chaîne
• Expression when
• Fonctions d'expression unique
• Fonctions et ordres lambdas plus élevés
• Filtres
• Séquences
• Syntaxe des appels du dernier paramètre

Tutoriels Kotlin

Le site Web https://try.kotlinlang.org propose des tutoriels enrichis appelés Kotlin Koans, un interpréteur Web ainsi qu'une documentation de référence complète avec des exemples.

Cours Udacity

Pour afficher le cours Udacity sur ce sujet, consultez Kotlin Bootcamp for Programmers (Formation Kotlin pour les programmeurs).

IntelliJ IDEA

Consultez la documentation sur IntelliJ IDEA sur le site Web de JetBrains.

Cette section répertorie les devoirs possibles pour les élèves qui effectuent cet atelier de programmation dans le cadre d'un cours animé par un enseignant. C'est à l'enseignant de procéder comme suit:

• Si nécessaire, rendez-les.
• Communiquez aux élèves comment rendre leurs devoirs.
• Notez les devoirs.

Les enseignants peuvent utiliser ces suggestions autant qu'ils le souhaitent, et ils n'ont pas besoin d'attribuer les devoirs de leur choix.

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

Répondez à ces questions.

Question 1

La fonction contains(element: String) renvoie true si la chaîne element est contenue dans la chaîne dans laquelle elle est appelée. Quelle sera la sortie 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 la fonction suivante, lequel des paramètres est requis ?
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 l'appel) à une autre fonction. Comment transmettre 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. Cours et objets

Pour une présentation du cours, y compris des liens vers d'autres ateliers de programmation, consultez le "Kotlin Bootcamp for Programmers: Welcome to the course."